{"version":3,"sources":["Searchbox.min__ff92a1d47dbcec2611e1.js","./src/magicbox/Grammars/Basic.ts","./src/ui/Querybox/Querybox.ts","./src/magicbox/Grammar.ts","./src/ui/Omnibox/Omnibox.ts","./src/ui/SearchButton/SearchButton.ts","./src/magicbox/Expression/ExpressionEndOfInput.ts","./src/magicbox/Expression/ExpressionConstant.ts","./src/magicbox/Grammars/Field.ts","./src/magicbox/SuggestionsManager.ts","./src/magicbox/MagicBox.ts","./src/magicbox/MagicBoxUtils.ts","./src/ui/Searchbox/Searchbox.ts","./src/magicbox/Expression/ExpressionRef.ts","./src/magicbox/Result/RefResult.ts","./src/magicbox/Expression/ExpressionOptions.ts","./src/magicbox/Result/OptionResult.ts","./src/magicbox/Expression/ExpressionRegExp.ts","./src/magicbox/Expression/ExpressionFunction.ts","./src/magicbox/Expression/ExpressionList.ts","./src/magicbox/Grammars/NestedQuery.ts","./src/magicbox/Grammars/Date.ts","./src/magicbox/Grammars/QueryExtension.ts","./src/magicbox/Grammars/SubExpression.ts","./src/magicbox/InputManager.ts","./src/magicbox/QueryProcessor.ts","./src/magicbox/Grammars/Complete.ts","./src/magicbox/Grammars/Expressions.ts","./src/events/ResultPreviewsManagerEvents.ts","./src/ui/Querybox/QueryboxOptionsProcessing.ts","./src/magicbox/Result/Result.ts","./src/magicbox/doMagicBoxExport.ts","./src/magicbox/Grammars/Grammars.ts","./src/magicbox/ResultPreviewsManager.ts","./src/magicbox/MagicBoxClear.ts","./src/ui/Omnibox/FieldAddon.ts","./src/ui/Omnibox/OldOmniboxAddon.ts","./src/ui/Omnibox/QueryExtensionAddon.ts","./src/ui/Omnibox/QuerySuggestAddon.ts","./src/utils/SearchBoxResize.ts"],"names":["webpackJsonpCoveo__temporary","132","module","exports","__webpack_require__","Object","defineProperty","value","notWordStart","notInWord","Basic","basicExpressions","grammars","DoubleQuoted","NotDoubleQuote","SingleQuoted","NotSingleQuote","Number","Word","input","end","expression","regex","RegExp","replace","groups","match","index","result","Result","isSuccess","length","EndOfInputResult","138","__extends","this","extendStatics","setPrototypeOf","__proto__","Array","d","b","p","hasOwnProperty","__","constructor","prototype","create","element","options","bindings","Querybox","ID","HTMLInputElement","logger","error","ComponentOptions","initComponentOptions","QueryboxOptionsProcessing","postProcess","$$","toggleClass","enableQuerySyntax","magicBox","createMagicBox","Grammar","Query","Term","Spaces","inline","find","setAttribute","placeholder","l","bind","onRootElement","QueryEvents","buildingQuery","args","handleBuildingQuery","StandaloneSearchInterfaceEvents","beforeRedirect","updateQueryState","onQueryState","MODEL_EVENTS","CHANGE_ONE","QUERY_STATE_ATTRIBUTES","Q","handleQueryStateChanged","enableSearchAsYouType","addClass","onchange","searchAsYouType","onsubmit","submit","onblur","onclear","triggerQueryOnClear","usageAnalytics","logSearchEvent","analyticsActionCauseList","searchboxClear","triggerNewQuery","_this","clearSuggestion","searchboxSubmit","setText","text","clear","getText","getResult","getDisplayedResult","getCursor","resultAtCursor","Assert","exists","queryBuilder","lastQuery","QueryboxQueryParameters","addParameters","clearTimeout","searchAsYouTypeTimeout","queryController","executeQuery","logInActionsHistory","queryStateModel","set","QueryStateModel","attributesEnum","q","window","setTimeout","logSearchAsYouType","searchboxAsYouType","searchAsYouTypeDelay","doExport","exportGlobally","buildBooleanOption","defaultValue","section","buildNumberOption","min","enableWildcards","enableQuestionMarks","depend","enableLowercaseOperators","enablePartialMatch","partialMatchKeywords","partialMatchThreshold","buildStringOption","Component","Initialization","registerAutoCreateComponent","176","start","expressions","ExpressionRef","addExpressions","_","each","basicExpression","id","addExpression","Error","buildExpression","getExpression","parse","grammar","isString","buildStringExpression","isArray","ExpressionOptions","map","v","i","isRegExp","ExpressionRegExp","isFunction","ExpressionFunction","matchs","stringMatch","spliter","ref","occurrence","ExpressionConstant","ExpressionList","str","re","cloneRegExp","source","group","exec","push","193","__assign","assign","t","s","n","arguments","call","Omnibox","lastSuggestions","movedOnce","skipAutoSuggest","originalValueForQuerySyntax","omniboxAnalytics","searchInterface","getOmniboxAnalytics","suggestionAddon","enableQuerySuggestAddon","QuerySuggestAddon","VoidQuerySuggestAddon","OldOmniboxAddon","newQuery","handleNewQuery","handleBeforeRedirect","querySuccess","handleQuerySuccess","isAutoSuggestion","duringQuery","handleDuringQuery","onComponentOptions","COMPONENT_OPTIONS_ATTRIBUTES","SEARCH_BOX","updateGrammar","OmniboxEvents","querySuggestGetFocus","handleQuerySuggestGetFocus","logSearchBoxSubmitEvent","blur","getInput","querySelector","createGrammar","Expressions","Complete","enableFieldAddon","FieldAddon","fieldAlias","listOfFields","concat","keys","enableQueryExtensionAddon","QueryExtensionAddon","Any","selectableSuggestionClass","selectedSuggestionClass","suggestionTimeout","omniboxTimeout","setupMagicBox","onmove","modifyEventTo","getOmniboxAnalyticsEventCause","onfocus","onSuggestions","suggestions","Utils","isEmptyString","partialQueries","undefined","onselect","suggestion","indexOf","compact","handleAutoSuggestionWithKeyboard","handleAutoSuggestionsWithMouse","cancelAllPendingEvents","buildCustomDataForPartialQueries","getQuery","sendAllPendingEvents","ontabpress","handleTabPress","getSuggestions","handleSuggestions","modifyCustomDataOnPending","modifyQueryContentOnPending","clearSearchAsYouType","pendingEvt","getPendingSearchEvent","PendingSearchAsYouTypeSearchEvent","k","modifyCustomData","queryContent","modifyQueryContent","updateOmniboxAnalytics","ranking","findWhere","suggestionRanking","querySuggestCharacterThreshold","suggestionsEventArgs","omnibox","triggerOmniboxSuggestions","isNullOrEmptyString","trigger","populateOmniboxSuggestions","isDescendant","root","data","clone","clean","preprocessResultForQueryArgs","notQuotedValues","findAll","fieldNames","alias","toLowerCase","triggerOmniboxPreprocessResultForQuery","query","toString","omniboxPreprocessResultForQuery","clearFiltersOnNewQuery","clearFiltersIfNewQuery","origin","firstQuery","validOrigins","type","getLastQuery","BreadcrumbEvents","clearBreadcrumb","handleTabPressForSuggestions","handleTabPressForOldOmniboxAddon","logCustomEvent","domSuggestions","filter","dom","selected","findAllElementsWithClass","selectable","elements","className","reduce","total","analyticsEvent","shouldExecuteQuery","cancel","wordCompletion","getWordCompletion","currentOmniboxSuggestion","getFirstSuggestion","textSuggestion","promise","then","pendingEvent","beforeResolve","evt","modifyEventCause","forceExecuteQuery","suggestionShouldTriggerQuery","allowQueriesWithoutKeywords","isNonEmptyString","executableConfidence","StandaloneSearchInterface","omniboxFromLink","postProcessing","enableSimpleFieldAddon","buildFieldsOption","buildLocalizedStringOption","numberOfSuggestions","195","SearchButton","AccessibleButton","withElement","withOwner","withLabel","withSelectAction","handleClick","build","trim","svgMagnifierContainer","SVGIcons","icons","search","el","SVGDom","addClassToSVGInContainer","svgLoadingAnimationContainer","loading","appendChild","click","debug","updateQueryStateModelWithSearchboxQuery","searchbox","218","ExpressionEndOfInput","219","success","220","Field","FieldQuery","FieldQueryOperation","FieldQueryValue","FieldQueryNumeric","FieldSimpleQuery","FieldName","FieldOperator","FieldOperatorNumeric","FieldValue","FieldValueNumeric","FieldValueString","FieldValueList","FieldValueStringList","FieldValueSeparator","FieldValueNotQuoted","NumberRange","include","Date","221","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","e","rejected","done","apply","__generator","body","verb","op","f","TypeError","y","label","ops","pop","trys","g","sent","throw","return","Symbol","iterator","Direction","magicBoxContainer","inputManager","suggestionListboxID","QueryUtils","createGuid","suggestionListboxClassName","resolveRoot","defaults","suggestionClass","selectedClass","timeout","on","handleMouseOver","handleMouseOut","suggestionsProcessor","QueryProcessor","resultPreviewsManager","ResultPreviewsManager","suggestionsListbox","buildSuggestionsContainer","append","addAccessibilityProperties","appendEmptySuggestionOption","get","currentSuggestions","enumerable","configurable","findClass","hasPreviews","hasClass","target","parents","processMouseSelection","contains","targetParents","relatedTarget","isValid","relatedTargetParents","removeSelectedStatus","querySuggestLoseFocus","moveDown","_a","move","Down","moveUp","Up","moveLeft","Left","moveRight","Right","selectAndReturnKeyboardFocusedElement","keyboardFocusedElement","clearKeyboardFocusedElement","receiveSuggestions","results","status","_b","processQueries","ProcessingStatus","Overriden","updateSuggestions","clearSuggestions","empty","activeDescendant","hasSuggestions","expanded","displaySearchResultPreviewsForSuggestion","sort","a","forEach","modifyDomFromExistingSuggestion","createDomFromSuggestion","querySuggestRendered","htmlElementIsSuggestion","returnMoved","processKeyboardSelection","addSelectedStatus","updateSelectedSuggestion","focusedSuggestion","processKeyboardPreviewSelection","preview","role","ariaLabel","selectSuggestion","html","innerHTML","separator","suggestionLabel","onSelect","querySuggestSelection","found","classList","direction","firstPreview","focusedPreviewElement","moveWithinPreview","previewElements","moveWithinSuggestion","currentlySelected","selectables","currentIndex","selectQuerySuggest","removeAttribute","newFocusedPreview","getElementInDirection","previewsOwner","HTMLElement","getElementsByClassName","elem","item","updateAreaSelectedIfDefined","removeClass","getAttribute","addAccessibilityPropertiesForMagicBox","addAccessibilityPropertiesForInput","omniboxSelectables","SuggestionsManager","222","MagicBoxInstance","callback","requestAnimationFrame","isUndefined","displayedResult","inputContainer","document","createElement","InputManager","firstSuggestionWithText","addSuggestions","existingValue","getValue","setResult","suggestionsContainer","suggestionsManager","magicBoxClear","MagicBoxClear","setupHandler","toggleTabindexAndAriaHidden","setCursor","resultAt","onkeydown","key","shouldMoveInSuggestions","KEYBOARD","ENTER","ESCAPE","onchangecursor","onkeyup","UP_ARROW","DOWN_ARROW","LEFT_ARROW","RIGHT_ARROW","selectedSuggestion","focusOnSuggestion","addSelectEventHandlers","setWordCompletion","firstSuggestionText","hasFocus","focus","doMagicBoxExport","223","escapeRegExp","highlightText","highligth","ignoreCase","matchClass","doNotMatchClass","escaped","stringRegex","notmatch","escapeText","classname","escape","MagicBoxUtils","282","Searchbox","initSearchBox","initSearchButton","applyMagicBoxIcon","applyCustomHeight","div","enableOmnibox","addSearchButton","anchor","searchButton","magicBoxIcon","mainClear","height","SearchBoxResize","resize","parent","extend","492","parseOnce","parseMany","refResult","RefResult","all","getBestExpect","expect","subResult","subResults","subInput","substr","getLength","requiredOccurance","isNumber","last","endOfInput","493","lastResult","failAttempt","getExpect","path","first","initial","rest","494","parts","OptionResult","495","496","497","func","498","JSON","stringify","499","NestedQuery","NestedField","500","DateYear","DateMonth","DateDay","DateRange","DateRelative","DateRelativeTerm","DateRelativeNegative","DateRelativeNegativeRef","501","QueryExtension","QueryExtensionName","QueryExtensionArguments","QueryExtensionArgumentList","QueryExtensionArgument","QueryExtensionArgumentName","QueryExtensionArgumentValue","502","SubExpression","503","underlay","highlightContainer","ghostTextContainer","insertBefore","addAccessibilitiesProperties","isExpanded","updateInput","updateHighlight","toHtmlElement","updateWordCompletion","createTextNode","updateScroll","createTextRange","range","select","selectionStart","setSelectionRange","defer","clientWidth","scrollWidth","style","visibility","scrollLeft","scrollTop","updateScrollDefer","keydown","keyup","oncut","onInputChange","onpaste","keyCode","which","TAB","tabPress","stopPropagation","preventDefault","handleLeftRightArrow","computeCssClassNameForType","504","racePromises","promises","queries","asyncQueries","overrideIfProcessing","processedResults","accumulateResultsChronologically","buildProcessResults","Finished","waitForOverride","waitForTimeout","TimedOut","override","flatten","orderedResults","output","items","507","508","loadSubGrammar","subGrammar","expressionDef","BasicExpression","Start","ExpressionsList","Expression","OptionalSpaces","Empty","subGrammars","509","buildingResultPreviewsQuery","updateResultPreviewsManagerOptions","populateSearchResultPreviews","ResultPreviewsManagerEvents","510","owner","componentOptionsModel","ComponentOptionsModel","searchBox","processQueryOnClearVersusEmptyQuery","processQueryOnClearVersusSearchAsYouType","warn","52","until","findParent","subResultFind","expects","groupBy","bestResults","chain","sortBy","pluck","getHumanReadableExpect","getHumanReadable","join","before","after","nextIndex","subresult","561","MagicBox","Grammars","Instance","GrammarsImportedLocally","562","ExpressionsGrammar","563","previewHeaderText","previewHeaderFieldText","previewClass","previewsProcessor","lastDisplayedSuggestion","suggestionsPreviewContainer","focusedElement","previewSelectables","firstVerticalOffset","offsetTop","firstIndexOnNextRow","findIndex","previewSelectable","externalOptions","currentDelay","isQueryForSuggestionOngoing","arePreviewsForSuggestionCurrentlyDisplayed","getExternalOptions","lastDelay","resolveAfter","isNullOrUndefined","displayAfterDuration","lastQueriedSuggestion","getSearchResultPreviewsQuery","displaySuggestionPreviews","focusedIndex","getIncrementInDirection","numberOfResultsPerRow","setHasPreviews","shouldHavePreviews","initPreviewForSuggestions","revertPreviewForSuggestions","buildPreviewContainer","previewContainerId","remove","resultPreviewsContainer","optionsEventArgs","populateEventArgs","previewsQueries","appendSearchResultPreview","position","elementDom","appendSearchResultPreviews","previews","toggle","564","clearIcon","insertAfter","hasText","tabindex","565","573","574","cache","getSuggestion","hash","getHash","hashString","hashToString","hashValueToSuggestion","values","current","fieldValues","field","simpleFieldNames","catch","fieldName","currentField","fieldValue","fieldQuery","word","INDEX","getFields","fields","getEndpoint","listFields","fieldDescriptions","fieldDescription","includeInQuery","groupByField","name","withAt","fieldNameLC","matchFields","fieldNameBeginsWithAt","listFieldValues","pattern","patternType","sortCriteria","maximumNumberOfValues","575","eventArgs","buildPopulateOmniboxEventArgs","populateOmnibox","rowsToSuggestions","rows","getCurrentQueryExpression","cursorPos","substring","getRegexToSearch","strValue","escapeRegexCharacter","getQueryExpressionBreakDown","ret","queryWords","split","searchValue","newValue","clearCurrentExpression","insertAt","at","toInsert","oldValue","slice","replaceCurrentExpression","currentQueryExpression","completeQueryExpression","allQueryExpressions","cursorPosition","closeOmnibox","row","deferred","zIndex","576","names","attributeNames","used","queryExtension","queryExtensionArgumentResults","getExtensions","extensions","extensionName","matchExtensions","extension","difference","argumentNames","argumentName","577","suggestiontHtml","highlighted","part","notMatched","matched","corrected","outerHTML","isPartialMatch","StringUtils","firstFail","every","getQuerySuggest","payload","completions","locale","searchHub","pipeline","enableWordCompletion","context","count","tab","referrer","actionsHistory","timezone","visitorId","isGuestUser","getBindings","buildingQuerySuggest","querySuggestSuccess","completion","partial","T","String","getQueryContext","historyStore","buildHistoryStore","historyFromStore","getHistory","AnalyticsInformation","clientId","670","671","size","getSearchbox","elementToResize","getElementsToResize","magicboxInput","searchboxStyle","inputChangeStyle","magicboxInputStyle","applyStyle","HtmlElement","cssText"],"mappings":"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","file":"Searchbox.min__ff92a1d47dbcec2611e1.js","sourcesContent":["webpackJsonpCoveo__temporary([9,10,11,79],{\n\n/***/ 132:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Result_1 = __webpack_require__(52);\nvar Result_2 = __webpack_require__(52);\nexports.notWordStart = ' ()[],$@\\'\"';\nexports.notInWord = ' ()[],:';\nexports.Basic = {\n    basicExpressions: ['Word', 'DoubleQuoted'],\n    grammars: {\n        DoubleQuoted: '\"[NotDoubleQuote]\"',\n        NotDoubleQuote: /[^\"]*/,\n        SingleQuoted: \"'[NotSingleQuote]'\",\n        NotSingleQuote: /[^']*/,\n        Number: /-?(0|[1-9]\\d*)(\\.\\d+)?/,\n        Word: function (input, end, expression) {\n            var regex = new RegExp('[^' + exports.notWordStart.replace(/(.)/g, '\\\\$1') + '][^' + exports.notInWord.replace(/(.)/g, '\\\\$1') + ']*');\n            var groups = input.match(regex);\n            if (groups != null && groups.index != 0) {\n                groups = null;\n            }\n            var result = new Result_1.Result(groups != null ? groups[0] : null, expression, input);\n            if (result.isSuccess() && end && input.length > result.value.length) {\n                return new Result_2.EndOfInputResult(result);\n            }\n            return result;\n        }\n    }\n};\n\n\n/***/ }),\n\n/***/ 138:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__webpack_require__(565);\nvar QueryEvents_1 = __webpack_require__(11);\nvar StandaloneSearchInterfaceEvents_1 = __webpack_require__(99);\nvar GlobalExports_1 = __webpack_require__(3);\nvar Grammar_1 = __webpack_require__(176);\nvar MagicBox_1 = __webpack_require__(222);\nvar Assert_1 = __webpack_require__(5);\nvar Model_1 = __webpack_require__(18);\nvar QueryStateModel_1 = __webpack_require__(13);\nvar Strings_1 = __webpack_require__(6);\nvar Dom_1 = __webpack_require__(1);\nvar AnalyticsActionListMeta_1 = __webpack_require__(10);\nvar Component_1 = __webpack_require__(7);\nvar ComponentOptions_1 = __webpack_require__(8);\nvar Initialization_1 = __webpack_require__(2);\nvar QueryboxOptionsProcessing_1 = __webpack_require__(510);\nvar QueryboxQueryParameters_1 = __webpack_require__(139);\n/**\n * The `Querybox` component renders an input which the end user can interact with to enter and submit queries.\n *\n * When the end user submits a search request, the `Querybox` component triggers a query and logs the corresponding\n * usage analytics data.\n *\n * For technical reasons, it is necessary to instantiate this component on a `div` element rather than on an `input`\n * element.\n *\n * See also the [`Searchbox`]{@link Searchbox} component, which can automatically instantiate a `Querybox` along with an\n * optional [`SearchButton`]{@link SearchButton} component.\n */\nvar Querybox = /** @class */ (function (_super) {\n    __extends(Querybox, _super);\n    /**\n     * Creates a new `Querybox component`. Creates a new `Coveo.Magicbox` instance and wraps the Magicbox methods\n     * (`onblur`, `onsubmit` etc.). Binds event on `buildingQuery` and before redirection (for standalone box).\n     * @param element The HTMLElement on which to instantiate the component. This cannot be an HTMLInputElement for\n     * technical reasons.\n     * @param options The options for the `Querybox` component.\n     * @param bindings The bindings that the component requires to function normally. If not set, these will be\n     * automatically resolved (with a slower execution time).\n     */\n    function Querybox(element, options, bindings) {\n        var _this = _super.call(this, element, Querybox.ID, bindings) || this;\n        _this.element = element;\n        _this.options = options;\n        _this.bindings = bindings;\n        if (element instanceof HTMLInputElement) {\n            _this.logger.error('Querybox cannot be used on an HTMLInputElement');\n        }\n        _this.options = ComponentOptions_1.ComponentOptions.initComponentOptions(element, Querybox, options);\n        new QueryboxOptionsProcessing_1.QueryboxOptionsProcessing(_this).postProcess();\n        Dom_1.$$(_this.element).toggleClass('coveo-query-syntax-disabled', _this.options.enableQuerySyntax == false);\n        _this.magicBox = MagicBox_1.createMagicBox(element, new Grammar_1.Grammar('Query', {\n            Query: '[Term*][Spaces?]',\n            Term: '[Spaces?][Word]',\n            Spaces: / +/,\n            Word: /[^ ]+/\n        }), {\n            inline: true\n        });\n        var input = Dom_1.$$(_this.magicBox.element).find('input');\n        if (input) {\n            Dom_1.$$(input).setAttribute('aria-label', _this.options.placeholder || Strings_1.l('Search'));\n        }\n        _this.bind.onRootElement(QueryEvents_1.QueryEvents.buildingQuery, function (args) { return _this.handleBuildingQuery(args); });\n        _this.bind.onRootElement(StandaloneSearchInterfaceEvents_1.StandaloneSearchInterfaceEvents.beforeRedirect, function () { return _this.updateQueryState(); });\n        _this.bind.onQueryState(Model_1.MODEL_EVENTS.CHANGE_ONE, QueryStateModel_1.QUERY_STATE_ATTRIBUTES.Q, function (args) {\n            return _this.handleQueryStateChanged(args);\n        });\n        if (_this.options.enableSearchAsYouType) {\n            Dom_1.$$(_this.element).addClass('coveo-search-as-you-type');\n            _this.magicBox.onchange = function () {\n                _this.searchAsYouType();\n            };\n        }\n        _this.magicBox.onsubmit = function () {\n            _this.submit();\n        };\n        _this.magicBox.onblur = function () {\n            _this.updateQueryState();\n        };\n        _this.magicBox.onclear = function () {\n            _this.updateQueryState();\n            if (_this.options.triggerQueryOnClear) {\n                _this.usageAnalytics.logSearchEvent(AnalyticsActionListMeta_1.analyticsActionCauseList.searchboxClear, {});\n                _this.triggerNewQuery(false);\n            }\n        };\n        return _this;\n    }\n    /**\n     * Adds the current content of the input to the query and triggers a query if the current content of the input has\n     * changed since last submit.\n     *\n     * Also logs the `serachboxSubmit` event in the usage analytics.\n     */\n    Querybox.prototype.submit = function () {\n        this.magicBox.clearSuggestion();\n        this.updateQueryState();\n        this.usageAnalytics.logSearchEvent(AnalyticsActionListMeta_1.analyticsActionCauseList.searchboxSubmit, {});\n        this.triggerNewQuery(false);\n    };\n    /**\n     * Sets the content of the input.\n     *\n     * @param text The string to set in the input.\n     */\n    Querybox.prototype.setText = function (text) {\n        this.magicBox.setText(text);\n        this.updateQueryState();\n    };\n    /**\n     * Clears the content of the input.\n     *\n     * See also the [`triggerQueryOnClear`]{@link Querybox.options.triggerQueryOnClear} option.\n     */\n    Querybox.prototype.clear = function () {\n        this.magicBox.clear();\n    };\n    /**\n     * Gets the content of the input.\n     *\n     * @returns {string} The content of the input.\n     */\n    Querybox.prototype.getText = function () {\n        return this.magicBox.getText();\n    };\n    /**\n     * Gets the result from the input.\n     *\n     * @returns {Result} The result.\n     */\n    Querybox.prototype.getResult = function () {\n        return this.magicBox.getResult();\n    };\n    /**\n     * Gets the displayed result from the input.\n     *\n     * @returns {Result} The displayed result.\n     */\n    Querybox.prototype.getDisplayedResult = function () {\n        return this.magicBox.getDisplayedResult();\n    };\n    /**\n     * Gets the current cursor position in the input.\n     *\n     * @returns {number} The cursor position (index starts at 0).\n     */\n    Querybox.prototype.getCursor = function () {\n        return this.magicBox.getCursor();\n    };\n    /**\n     * Gets the result at cursor position.\n     *\n     * @param match {string | { (result): boolean }} The match condition.\n     *\n     * @returns {Result[]} The result.\n     */\n    Querybox.prototype.resultAtCursor = function (match) {\n        return this.magicBox.resultAtCursor(match);\n    };\n    Querybox.prototype.handleBuildingQuery = function (args) {\n        Assert_1.Assert.exists(args);\n        Assert_1.Assert.exists(args.queryBuilder);\n        this.updateQueryState();\n        this.lastQuery = this.magicBox.getText();\n        new QueryboxQueryParameters_1.QueryboxQueryParameters(this.options).addParameters(args.queryBuilder, this.lastQuery);\n    };\n    Querybox.prototype.triggerNewQuery = function (searchAsYouType) {\n        clearTimeout(this.searchAsYouTypeTimeout);\n        var text = this.magicBox.getText();\n        if (this.lastQuery != text && text != null) {\n            this.lastQuery = text;\n            this.queryController.executeQuery({\n                searchAsYouType: searchAsYouType,\n                logInActionsHistory: true\n            });\n        }\n    };\n    Querybox.prototype.updateQueryState = function () {\n        this.queryStateModel.set(QueryStateModel_1.QueryStateModel.attributesEnum.q, this.magicBox.getText());\n    };\n    Querybox.prototype.handleQueryStateChanged = function (args) {\n        Assert_1.Assert.exists(args);\n        var q = args.value;\n        if (q != this.magicBox.getText()) {\n            this.magicBox.setText(q);\n        }\n    };\n    Querybox.prototype.searchAsYouType = function () {\n        var _this = this;\n        clearTimeout(this.searchAsYouTypeTimeout);\n        this.searchAsYouTypeTimeout = window.setTimeout(function () {\n            _this.usageAnalytics.logSearchAsYouType(AnalyticsActionListMeta_1.analyticsActionCauseList.searchboxAsYouType, {});\n            _this.triggerNewQuery(true);\n        }, this.options.searchAsYouTypeDelay);\n    };\n    Querybox.ID = 'Querybox';\n    Querybox.doExport = function () {\n        GlobalExports_1.exportGlobally({\n            Querybox: Querybox,\n            QueryboxQueryParameters: QueryboxQueryParameters_1.QueryboxQueryParameters\n        });\n    };\n    /**\n     * The options for the Querybox.\n     * @componentOptions\n     */\n    Querybox.options = {\n        /**\n         * Whether to enable the search-as-you-type feature.\n         *\n         * **Note:** Enabling this feature can consume lots of queries per month (QPM), especially if the [`searchAsYouTypeDelay`]{@link Querybox.options.searchAsYouTypeDelay} option is set to a low value.\n         *\n         * Default value is `false`.\n         */\n        enableSearchAsYouType: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n        /**\n         * If the [`enableSearchAsYouType`]{@link Querybox.options.enableSearchAsYouType} option is `true`, specifies how\n         * long to wait (in milliseconds) between each key press before triggering a new query.\n         *\n         * Default value is `50`. Minimum value is `0`\n         */\n        searchAsYouTypeDelay: ComponentOptions_1.ComponentOptions.buildNumberOption({ defaultValue: 50, min: 0, section: 'Advanced Options' }),\n        /**\n         * Specifies whether to interpret special query syntax (e.g., `@objecttype=message`) when the end user types\n         * a query in the `Querybox` (see\n         * [Coveo Query Syntax Reference](https://docs.coveo.com/en/1552/searching-with-coveo/coveo-cloud-query-syntax)). Setting this\n         * option to `true` also causes the `Querybox` to highlight any query syntax.\n         *\n         * Regardless of the value of this option, the Coveo Cloud REST Search API always interprets expressions surrounded\n         * by double quotes (`\"`) as exact phrase match requests.\n         *\n         * See also [`enableLowercaseOperators`]{@link Querybox.options.enableLowercaseOperators}.\n         *\n         * **Notes:**\n         * > * End user preferences can override the value you specify for this option.\n         * >\n         * > If the end user selects a value other than **Automatic** for the **Enable query syntax** setting (see\n         * > the [`enableQuerySyntax`]{@link ResultsPreferences.options.enableQuerySyntax} option of the\n         * > [`ResultsPreferences`]{@link ResultsPreferences} component), the end user preference takes precedence over this\n         * > option.\n         * >\n         * > * On-premises versions of the Coveo Search API require this option to be set to `true` in order to interpret\n         * > expressions surrounded by double quotes (`\"`) as exact phrase match requests.\n         *\n         * Default value is `false`.\n         */\n        enableQuerySyntax: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n        /**\n         * Specifies whether to expand basic expression keywords containing wildcards characters (`*`) to the possible\n         * matching keywords in order to broaden the query (see\n         * [Using Wildcards in Queries](https://docs.coveo.com/en/1580/)).\n         *\n         * See also [`enableQuestionMarks`]{@link Querybox.options.enableQuestionMarks}.\n         *\n         *  **Note:**\n         * > If you are using an on-premises version of the Coveo Search API, you need to set the\n         * > [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option to `true` to be able to set\n         * > `enableWildcards` to `true`.\n         *\n         * Default value is `false`.\n         */\n        enableWildcards: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n        /**\n         * If [`enableWildcards`]{@link Querybox.options.enableWildcards} is `true`, specifies whether to expand basic\n         * expression keywords containing question mark characters (`?`) to the possible matching keywords in order to\n         * broaden the query (see\n         * [Using Wildcards in Queries](https://docs.coveo.com/en/1580/)).\n         *\n         * **Note:**\n         * > If you are using an on-premises version of the Coveo Search API, you also need to set the\n         * > [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option to `true` in order to be able to set\n         * > `enableQuestionMarks` to `true`.\n         *\n         * Default value is `false`.\n         */\n        enableQuestionMarks: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false, depend: 'enableWildcards' }),\n        /**\n         * If the [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option is `true`, specifies whether to\n         * interpret the `AND`, `NOT`, `OR`, and `NEAR` keywords in the `Querybox` as query operators in the query, even if\n         * the end user types those keywords in lowercase.\n         *\n         * This option applies to all query operators (see\n         * [Coveo Query Syntax Reference](https://docs.coveo.com/en/1552/searching-with-coveo/coveo-cloud-query-syntax)).\n         *\n         * **Example:**\n         * > If this option and the `enableQuerySyntax` option are both `true`, the Coveo Platform interprets the `near`\n         * > keyword in a query such as `service center near me` as the `NEAR` query operator (not as a query term).\n         *\n         * > Otherwise, if the `enableQuerySyntax` option is `true` and this option is `false`, the end user has to type the\n         * > `NEAR` keyword in uppercase for the Coveo Platform to interpret it as a query operator.\n         *\n         * Default value is `false`.\n         */\n        enableLowercaseOperators: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false, depend: 'enableQuerySyntax' }),\n        /**\n         * Whether to convert a basic expression containing at least a certain number of keywords (see the\n         * [`partialMatchKeywords`]{@link Querybox.options.partialMatchKeywords} option) to *partial match expression*, so\n         * that items containing at least a certain number of those keywords (see the\n         * [`partialMatchThreshold`]{@link Querybox.options.partialMatchThreshold} option) will match the expression.\n         *\n         * **Notes:**\n         * - Only the basic expression of the query (see [`q`]{@link q}) can be converted to a partial match expression.\n         * - When the [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option is set to `true`, this feature has no effect if the basic expression contains advanced query syntax (field expressions, operators, etc.).\n         *\n         * @notSupportedIn salesforcefree\n         */\n        enablePartialMatch: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false }),\n        /**\n         * The minimum number of keywords that need to be present in the basic expression to convert it to a partial match expression.\n         *\n         * See also the [`partialMatchThreshold`]{@link Querybox.options.partialMatchThreshold} option.\n         *\n         * **Notes:**\n         *\n         * - Repeated keywords count as a single keyword.\n         * - Thesaurus expansions count towards the `partialMatchKeywords` count.\n         * - Stemming expansions **do not** count towards the `partialMatchKeywords` count.\n         *\n         * @notSupportedIn salesforcefree\n         */\n        partialMatchKeywords: ComponentOptions_1.ComponentOptions.buildNumberOption({ defaultValue: 5, min: 1, depend: 'enablePartialMatch' }),\n        /**\n         * An absolute or relative value indicating the minimum number of partial match expression keywords an item must contain to match the expression.\n         *\n         * See also the [`partialMatchKeywords`]{@link Querybox.options.partialMatchKeywords} option.\n         *\n         * **Notes:**\n         * - A keyword and its stemming expansions count as a single keyword when evaluating whether an item meets the `partialMatchThreshold`.\n         * - When a relative `partialMatchThreshold` does not yield a whole integer, the fractional part is truncated (e.g., `3.6` becomes `3`).\n         *\n         * @notSupportedIn salesforcefree\n         */\n        partialMatchThreshold: ComponentOptions_1.ComponentOptions.buildStringOption({ defaultValue: '50%', depend: 'enablePartialMatch' }),\n        /**\n         * Whether to trigger a query when clearing the `Querybox`.\n         *\n         * Default value is `false`.\n         */\n        triggerQueryOnClear: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false })\n    };\n    return Querybox;\n}(Component_1.Component));\nexports.Querybox = Querybox;\nInitialization_1.Initialization.registerAutoCreateComponent(Querybox);\n\n\n/***/ }),\n\n/***/ 176:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ExpressionRef_1 = __webpack_require__(492);\nvar ExpressionOptions_1 = __webpack_require__(494);\nvar ExpressionRegExp_1 = __webpack_require__(496);\nvar _ = __webpack_require__(0);\nvar ExpressionFunction_1 = __webpack_require__(497);\nvar ExpressionConstant_1 = __webpack_require__(219);\nvar ExpressionList_1 = __webpack_require__(498);\nvar Grammar = /** @class */ (function () {\n    function Grammar(start, expressions) {\n        if (expressions === void 0) { expressions = {}; }\n        this.expressions = {};\n        this.start = new ExpressionRef_1.ExpressionRef(start, null, 'start', this);\n        this.addExpressions(expressions);\n    }\n    Grammar.prototype.addExpressions = function (expressions) {\n        var _this = this;\n        _.each(expressions, function (basicExpression, id) {\n            _this.addExpression(id, basicExpression);\n        });\n    };\n    Grammar.prototype.addExpression = function (id, basicExpression) {\n        if (id in this.expressions) {\n            throw new Error('Grammar already contain the id:' + id);\n        }\n        this.expressions[id] = Grammar.buildExpression(basicExpression, id, this);\n    };\n    Grammar.prototype.getExpression = function (id) {\n        return this.expressions[id];\n    };\n    Grammar.prototype.parse = function (value) {\n        return this.start.parse(value, true);\n    };\n    Grammar.buildExpression = function (value, id, grammar) {\n        var type = typeof value;\n        if (type == 'undefined') {\n            throw new Error('Invalid Expression: ' + value);\n        }\n        if (_.isString(value)) {\n            return this.buildStringExpression(value, id, grammar);\n        }\n        if (_.isArray(value)) {\n            return new ExpressionOptions_1.ExpressionOptions(_.map(value, function (v, i) { return new ExpressionRef_1.ExpressionRef(v, null, id + '_' + i, grammar); }), id);\n        }\n        if (_.isRegExp(value)) {\n            return new ExpressionRegExp_1.ExpressionRegExp(value, id, grammar);\n        }\n        if (_.isFunction(value)) {\n            return new ExpressionFunction_1.ExpressionFunction(value, id, grammar);\n        }\n        throw new Error('Invalid Expression: ' + value);\n    };\n    Grammar.buildStringExpression = function (value, id, grammar) {\n        var matchs = Grammar.stringMatch(value, Grammar.spliter);\n        var expressions = _.map(matchs, function (match, i) {\n            if (match[1]) {\n                // Ref\n                var ref = match[1];\n                var occurrence = match[3] ? Number(match[3]) : match[2] || null;\n                return new ExpressionRef_1.ExpressionRef(ref, occurrence, id + '_' + i, grammar);\n            }\n            else {\n                // Constant\n                return new ExpressionConstant_1.ExpressionConstant(match[4], id + '_' + i);\n            }\n        });\n        if (expressions.length == 1) {\n            var expression = expressions[0];\n            expression.id = id;\n            return expression;\n        }\n        else {\n            return new ExpressionList_1.ExpressionList(expressions, id);\n        }\n    };\n    Grammar.stringMatch = function (str, re) {\n        var groups = [];\n        var cloneRegExp = new RegExp(re.source, 'g');\n        var group = cloneRegExp.exec(str);\n        while (group !== null) {\n            groups.push(group);\n            group = cloneRegExp.exec(str);\n        }\n        return groups;\n    };\n    Grammar.spliter = /\\[(\\w+)(\\*|\\+|\\?|\\{([1-9][0-9]*)\\})?\\]|(.[^\\[]*)/;\n    return Grammar;\n}());\nexports.Grammar = Grammar;\n\n\n/***/ }),\n\n/***/ 193:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n///<reference path=\"FieldAddon.ts\" />\n///<reference path=\"QueryExtensionAddon.ts\" />\n///<reference path=\"QuerySuggestAddon.ts\" />\n///<reference path=\"OldOmniboxAddon.ts\" />\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n        s = arguments[i];\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n            t[p] = s[p];\n    }\n    return t;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__webpack_require__(573);\nvar _ = __webpack_require__(0);\nvar underscore_1 = __webpack_require__(0);\nvar BreadcrumbEvents_1 = __webpack_require__(35);\nvar OmniboxEvents_1 = __webpack_require__(34);\nvar QueryEvents_1 = __webpack_require__(11);\nvar StandaloneSearchInterfaceEvents_1 = __webpack_require__(99);\nvar GlobalExports_1 = __webpack_require__(3);\nvar Grammar_1 = __webpack_require__(176);\nvar Complete_1 = __webpack_require__(507);\nvar Expressions_1 = __webpack_require__(508);\nvar MagicBox_1 = __webpack_require__(222);\nvar Assert_1 = __webpack_require__(5);\nvar ComponentOptionsModel_1 = __webpack_require__(28);\nvar Model_1 = __webpack_require__(18);\nvar QueryStateModel_1 = __webpack_require__(13);\nvar Strings_1 = __webpack_require__(6);\nvar Dom_1 = __webpack_require__(1);\nvar Utils_1 = __webpack_require__(4);\nvar AnalyticsActionListMeta_1 = __webpack_require__(10);\nvar PendingSearchAsYouTypeSearchEvent_1 = __webpack_require__(127);\nvar SharedAnalyticsCalls_1 = __webpack_require__(125);\nvar Component_1 = __webpack_require__(7);\nvar ComponentOptions_1 = __webpack_require__(8);\nvar Initialization_1 = __webpack_require__(2);\nvar Querybox_1 = __webpack_require__(138);\nvar QueryboxOptionsProcessing_1 = __webpack_require__(510);\nvar QueryboxQueryParameters_1 = __webpack_require__(139);\nvar SearchInterface_1 = __webpack_require__(19);\nvar FieldAddon_1 = __webpack_require__(574);\nvar OldOmniboxAddon_1 = __webpack_require__(575);\nvar QueryExtensionAddon_1 = __webpack_require__(576);\nvar QuerySuggestAddon_1 = __webpack_require__(577);\nvar MINIMUM_EXECUTABLE_CONFIDENCE = 0.8;\n/**\n * The `Omnibox` component extends the [`Querybox`]{@link Querybox}, and thus provides the same basic options and\n * behaviors. Furthermore, the `Omnibox` adds a type-ahead capability to the search input.\n *\n * You can configure the type-ahead feature by enabling or disabling certain addons, which the Coveo JavaScript Search\n * Framework provides out-of-the-box (see the [`enableFieldAddon`]{@link Omnibox.options.enableFieldAddon},\n * [`enableQueryExtension`]{@link Omnibox.options.enableQueryExtensionAddon}, and\n * [`enableQuerySuggestAddon`]{@link Omnibox.options.enableQuerySuggestAddon} options).\n *\n * Custom components and external code can also extend or customize the type-ahead feature and the query completion\n * suggestions it provides by attaching their own handlers to the\n * [`populateOmniboxSuggestions`]{@link OmniboxEvents.populateOmniboxSuggestions} event.\n *\n * See also the [`Searchbox`]{@link Searchbox} component, which can automatically instantiate an `Omnibox` along with an\n * optional {@link SearchButton}.\n */\nvar Omnibox = /** @class */ (function (_super) {\n    __extends(Omnibox, _super);\n    /**\n     * Creates a new Omnibox component. Also enables necessary addons and binds events on various query events.\n     * @param element The HTMLElement on which to instantiate the component.\n     * @param options The options for the Omnibox component.\n     * @param bindings The bindings that the component requires to function normally. If not set, these will be\n     * automatically resolved (with a slower execution time).\n     */\n    function Omnibox(element, options, bindings) {\n        var _this = _super.call(this, element, Omnibox.ID, bindings) || this;\n        _this.element = element;\n        _this.options = options;\n        _this.lastSuggestions = [];\n        _this.movedOnce = false;\n        _this.skipAutoSuggest = false;\n        _this.options = ComponentOptions_1.ComponentOptions.initComponentOptions(element, Omnibox, options);\n        var originalValueForQuerySyntax = _this.options.enableQuerySyntax;\n        new QueryboxOptionsProcessing_1.QueryboxOptionsProcessing(_this).postProcess();\n        _this.omniboxAnalytics = _this.searchInterface.getOmniboxAnalytics();\n        Dom_1.$$(_this.element).toggleClass('coveo-query-syntax-disabled', _this.options.enableQuerySyntax == false);\n        _this.suggestionAddon = _this.options.enableQuerySuggestAddon ? new QuerySuggestAddon_1.QuerySuggestAddon(_this) : new QuerySuggestAddon_1.VoidQuerySuggestAddon();\n        new OldOmniboxAddon_1.OldOmniboxAddon(_this);\n        _this.createMagicBox();\n        _this.bind.onRootElement(QueryEvents_1.QueryEvents.newQuery, function (args) { return _this.handleNewQuery(args); });\n        _this.bind.onRootElement(QueryEvents_1.QueryEvents.buildingQuery, function (args) { return _this.handleBuildingQuery(args); });\n        _this.bind.onRootElement(StandaloneSearchInterfaceEvents_1.StandaloneSearchInterfaceEvents.beforeRedirect, function () { return _this.handleBeforeRedirect(); });\n        _this.bind.onRootElement(QueryEvents_1.QueryEvents.querySuccess, function () { return _this.handleQuerySuccess(); });\n        _this.bind.onQueryState(Model_1.MODEL_EVENTS.CHANGE_ONE, QueryStateModel_1.QUERY_STATE_ATTRIBUTES.Q, function (args) {\n            return _this.handleQueryStateChanged(args);\n        });\n        if (_this.isAutoSuggestion()) {\n            _this.bind.onRootElement(QueryEvents_1.QueryEvents.duringQuery, function (args) { return _this.handleDuringQuery(args); });\n        }\n        _this.bind.onComponentOptions(Model_1.MODEL_EVENTS.CHANGE_ONE, ComponentOptionsModel_1.COMPONENT_OPTIONS_ATTRIBUTES.SEARCH_BOX, function (args) {\n            if (args.value.enableQuerySyntax != null) {\n                _this.options.enableQuerySyntax = args.value.enableQuerySyntax;\n            }\n            else {\n                _this.options.enableQuerySyntax = originalValueForQuerySyntax;\n            }\n            _this.updateGrammar();\n        });\n        _this.bind.onRootElement(OmniboxEvents_1.OmniboxEvents.querySuggestGetFocus, function (args) { return _this.handleQuerySuggestGetFocus(args); });\n        return _this;\n    }\n    /**\n     * Adds the current content of the input to the query and triggers a query if the current content of the input has\n     * changed since last submit.\n     *\n     * Also logs a `searchboxSubmit` event in the usage analytics.\n     */\n    Omnibox.prototype.submit = function () {\n        var _this = this;\n        this.magicBox.clearSuggestion();\n        this.updateQueryState();\n        this.triggerNewQuery(false, function () {\n            SharedAnalyticsCalls_1.logSearchBoxSubmitEvent(_this.usageAnalytics);\n        });\n        this.magicBox.blur();\n    };\n    /**\n     * Gets the current content of the input.\n     * @returns {string} The current content of the input.\n     */\n    Omnibox.prototype.getText = function () {\n        return this.magicBox.getText();\n    };\n    /**\n     * Sets the content of the input\n     * @param text The string to set in the input.\n     */\n    Omnibox.prototype.setText = function (text) {\n        this.magicBox.setText(text);\n        this.updateQueryState();\n    };\n    /**\n     * Clears the content of the input.\n     */\n    Omnibox.prototype.clear = function () {\n        this.magicBox.clear();\n    };\n    /**\n     * Gets the `HTMLInputElement` of the Omnibox.\n     */\n    Omnibox.prototype.getInput = function () {\n        return this.magicBox.element.querySelector('input');\n    };\n    Omnibox.prototype.getResult = function () {\n        return this.magicBox.getResult();\n    };\n    Omnibox.prototype.getDisplayedResult = function () {\n        return this.magicBox.getDisplayedResult();\n    };\n    Omnibox.prototype.getCursor = function () {\n        return this.magicBox.getCursor();\n    };\n    Omnibox.prototype.resultAtCursor = function (match) {\n        return this.magicBox.resultAtCursor(match);\n    };\n    Omnibox.prototype.createGrammar = function () {\n        var grammar = null;\n        if (this.options.enableQuerySyntax) {\n            grammar = Expressions_1.Expressions(Complete_1.Complete);\n            if (this.options.enableFieldAddon) {\n                new FieldAddon_1.FieldAddon(this);\n            }\n            if (this.options.fieldAlias != null) {\n                this.options.listOfFields = this.options.listOfFields || [];\n                this.options.listOfFields = this.options.listOfFields.concat(_.keys(this.options.fieldAlias));\n            }\n            if (this.options.enableQueryExtensionAddon) {\n                new QueryExtensionAddon_1.QueryExtensionAddon(this);\n            }\n        }\n        else {\n            grammar = { start: 'Any', expressions: { Any: /.*/ } };\n        }\n        if (this.options.grammar != null) {\n            grammar = this.options.grammar(grammar);\n        }\n        return grammar;\n    };\n    Omnibox.prototype.updateGrammar = function () {\n        var grammar = this.createGrammar();\n        this.magicBox.grammar = new Grammar_1.Grammar(grammar.start, grammar.expressions);\n        this.magicBox.setText(this.magicBox.getText());\n    };\n    Omnibox.prototype.createMagicBox = function () {\n        var grammar = this.createGrammar();\n        this.magicBox = MagicBox_1.createMagicBox(this.element, new Grammar_1.Grammar(grammar.start, grammar.expressions), {\n            inline: this.options.inline,\n            selectableSuggestionClass: 'coveo-omnibox-selectable',\n            selectedSuggestionClass: 'coveo-omnibox-selected',\n            suggestionTimeout: this.options.omniboxTimeout\n        });\n        var input = Dom_1.$$(this.magicBox.element).find('input');\n        if (input) {\n            Dom_1.$$(input).setAttribute('aria-label', Strings_1.l('Search'));\n        }\n        this.setupMagicBox();\n    };\n    Omnibox.prototype.setupMagicBox = function () {\n        var _this = this;\n        this.magicBox.onmove = function () {\n            // We assume that once the user has moved its selection, it becomes an explicit omnibox analytics event\n            if (_this.isAutoSuggestion()) {\n                _this.modifyEventTo = _this.getOmniboxAnalyticsEventCause();\n            }\n            _this.movedOnce = true;\n        };\n        this.magicBox.onfocus = function () {\n            if (_this.isAutoSuggestion()) {\n                // This flag is used to block the automatic query when the UI is loaded with a query (#q=foo)\n                // and then the input is focused. We want to block that query, even if it match the suggestion\n                // Only when there is an actual change in the input (user typing something) is when we want the automatic query to kick in\n                _this.skipAutoSuggest = true;\n            }\n        };\n        this.magicBox.onSuggestions = function (suggestions) {\n            // If text is empty, this can mean that user selected text from the search box\n            // and hit \"delete\" : Reset the partial queries in this case\n            if (Utils_1.Utils.isEmptyString(_this.getText())) {\n                _this.omniboxAnalytics.partialQueries = [];\n            }\n            _this.movedOnce = false;\n            _this.lastSuggestions = suggestions;\n            if (_this.isAutoSuggestion() && !_this.skipAutoSuggest) {\n                _this.searchAsYouType();\n            }\n        };\n        if (this.options.enableSearchAsYouType) {\n            Dom_1.$$(this.element).addClass('coveo-magicbox-search-as-you-type');\n        }\n        this.magicBox.onchange = function () {\n            _this.skipAutoSuggest = false;\n            var text = _this.getText();\n            if (text != undefined && text != '') {\n                if (_this.isAutoSuggestion()) {\n                    if (_this.movedOnce) {\n                        _this.searchAsYouType(true);\n                    }\n                }\n                else if (_this.options.enableSearchAsYouType) {\n                    _this.searchAsYouType(true);\n                }\n            }\n            else {\n                _this.clear();\n            }\n        };\n        if (this.options.placeholder) {\n            this.magicBox.element.querySelector('input').placeholder = this.options.placeholder;\n        }\n        this.magicBox.onsubmit = function () { return _this.submit(); };\n        this.magicBox.onselect = function (suggestion) {\n            var index = _.indexOf(_this.lastSuggestions, suggestion);\n            var suggestions = _.compact(_.map(_this.lastSuggestions, function (suggestion) { return suggestion.text; }));\n            _this.magicBox.clearSuggestion();\n            _this.updateQueryState();\n            // A bit tricky here : When it's machine learning auto suggestions\n            // the mouse selection and keyboard selection acts differently :\n            // keyboard selection will automatically do the query (which will log a search as you type event -> further modified by this.modifyEventTo if needed)\n            // mouse selection will not \"auto\" send the query.\n            // the movedOnce variable detect the keyboard movement, and is used to differentiate mouse vs keyboard\n            if (!_this.isAutoSuggestion()) {\n                _this.usageAnalytics.cancelAllPendingEvents();\n                _this.triggerNewQuery(false, function () {\n                    _this.usageAnalytics.logSearchEvent(_this.getOmniboxAnalyticsEventCause(), _this.buildCustomDataForPartialQueries(index, suggestions));\n                });\n            }\n            else if (_this.isAutoSuggestion() && _this.movedOnce) {\n                _this.handleAutoSuggestionWithKeyboard(index, suggestions);\n            }\n            else if (_this.isAutoSuggestion() && !_this.movedOnce) {\n                _this.handleAutoSuggestionsWithMouse(index, suggestions);\n            }\n            // Consider a selection like a reset of the partial queries (it's the end of a suggestion pattern)\n            if (_this.isAutoSuggestion()) {\n                _this.omniboxAnalytics.partialQueries = [];\n            }\n        };\n        this.magicBox.onblur = function () {\n            if (_this.isAutoSuggestion()) {\n                _this.setText(_this.getQuery(true));\n                _this.usageAnalytics.sendAllPendingEvents();\n            }\n        };\n        this.magicBox.onclear = function () {\n            _this.updateQueryState();\n            if (_this.options.triggerQueryOnClear || _this.options.enableSearchAsYouType) {\n                _this.triggerNewQuery(false, function () {\n                    _this.usageAnalytics.logSearchEvent(AnalyticsActionListMeta_1.analyticsActionCauseList.searchboxClear, {});\n                });\n            }\n        };\n        this.magicBox.ontabpress = function () {\n            _this.handleTabPress();\n        };\n        this.magicBox.getSuggestions = function () { return _this.handleSuggestions(); };\n    };\n    Omnibox.prototype.handleAutoSuggestionWithKeyboard = function (index, suggestions) {\n        var _this = this;\n        if (this.searchAsYouTypeTimeout) {\n            // Here, there is currently a search as you typed queued up :\n            // Think : user typed very quickly, then very quickly selected a suggestion (without waiting for the search as you type)\n            // Cancel the search as you type query, then immediately do the query with the selection (+analytics event with the selection)\n            this.usageAnalytics.cancelAllPendingEvents();\n            clearTimeout(this.searchAsYouTypeTimeout);\n            this.searchAsYouTypeTimeout = undefined;\n            this.triggerNewQuery(false, function () {\n                _this.usageAnalytics.logSearchEvent(_this.getOmniboxAnalyticsEventCause(), _this.buildCustomDataForPartialQueries(index, suggestions));\n            });\n        }\n        else {\n            // Here, the search as you type query has returned, but the analytics event has not ye been sent.\n            // Think : user typed slowly, the query returned, and then the user selected a suggestion.\n            // Since the analytics event has not yet been sent (search as you type event have a 5 sec delay)\n            // modify the pending event, then send the newly modified analytics event immediately.\n            this.modifyEventTo = this.getOmniboxAnalyticsEventCause();\n            this.modifyCustomDataOnPending(index, suggestions);\n            this.modifyQueryContentOnPending();\n            this.usageAnalytics.sendAllPendingEvents();\n        }\n    };\n    Omnibox.prototype.handleAutoSuggestionsWithMouse = function (index, suggestions) {\n        var _this = this;\n        if (this.searchAsYouTypeTimeout || index != 0) {\n            // Here : the user either very quickly chose the first suggestion, and the search as you type is still queued up.\n            // OR\n            // the user chose something different then the first suggestion.\n            // Remove the search as you type if it's there, and do the query with the suggestion directly.\n            this.clearSearchAsYouType();\n            this.usageAnalytics.cancelAllPendingEvents();\n            this.triggerNewQuery(false, function () {\n                _this.usageAnalytics.logSearchEvent(_this.getOmniboxAnalyticsEventCause(), _this.buildCustomDataForPartialQueries(index, suggestions));\n            });\n        }\n        else {\n            // Here : the user either very slowly chose a suggestion, and there is no search as you typed queued up\n            // AND\n            // the user chose the first suggestion.\n            // this means the query is already returned, but the analytics event is still queued up.\n            // modify the analytics event, and send it.\n            this.modifyEventTo = this.getOmniboxAnalyticsEventCause();\n            this.modifyCustomDataOnPending(index, suggestions);\n            this.modifyQueryContentOnPending();\n            this.usageAnalytics.sendAllPendingEvents();\n            // This should happen if :\n            // users did a (short) query first, which does not match the first suggestion. (eg: typed \"t\", then search)\n            // then, refocus the search box. The same suggestion(s) will re-appear.\n            // By selecting the first one with the mouse, we need to retrigger a query because this means the search as you type could not\n            // kick in and do the query automatically.\n            if (this.lastQuery != this.getText()) {\n                this.triggerNewQuery(false, function () {\n                    _this.usageAnalytics.logSearchEvent(_this.getOmniboxAnalyticsEventCause(), _this.buildCustomDataForPartialQueries(index, suggestions));\n                });\n            }\n        }\n    };\n    Omnibox.prototype.modifyCustomDataOnPending = function (index, suggestions) {\n        var pendingEvt = this.usageAnalytics.getPendingSearchEvent();\n        if (pendingEvt instanceof PendingSearchAsYouTypeSearchEvent_1.PendingSearchAsYouTypeSearchEvent) {\n            var newCustomData_1 = this.buildCustomDataForPartialQueries(index, suggestions);\n            _.each(_.keys(newCustomData_1), function (k) {\n                pendingEvt.modifyCustomData(k, newCustomData_1[k]);\n            });\n        }\n    };\n    Omnibox.prototype.modifyQueryContentOnPending = function () {\n        var pendingEvt = this.usageAnalytics.getPendingSearchEvent();\n        if (pendingEvt instanceof PendingSearchAsYouTypeSearchEvent_1.PendingSearchAsYouTypeSearchEvent) {\n            var queryContent = this.getQuery(this.options.enableSearchAsYouType);\n            pendingEvt.modifyQueryContent(queryContent);\n        }\n    };\n    Omnibox.prototype.buildCustomDataForPartialQueries = function (index, suggestions) {\n        this.updateOmniboxAnalytics(suggestions, index);\n        return this.omniboxAnalytics.buildCustomDataForPartialQueries();\n    };\n    Omnibox.prototype.handleQuerySuggestGetFocus = function (_a) {\n        var suggestion = _a.suggestion;\n        var suggestions = _.compact(_.map(this.lastSuggestions, function (suggestion) { return suggestion.text; }));\n        var ranking = this.lastSuggestions.indexOf(underscore_1.findWhere(this.lastSuggestions, { text: suggestion }));\n        this.updateOmniboxAnalytics(suggestions, ranking);\n    };\n    Omnibox.prototype.updateOmniboxAnalytics = function (suggestions, suggestionRanking) {\n        this.omniboxAnalytics.suggestions = suggestions;\n        this.omniboxAnalytics.suggestionRanking = suggestionRanking;\n    };\n    Omnibox.prototype.handleSuggestions = function () {\n        var text = this.getText();\n        if (this.options.querySuggestCharacterThreshold <= text.length) {\n            var suggestionsEventArgs = {\n                suggestions: [],\n                omnibox: this\n            };\n            this.triggerOmniboxSuggestions(suggestionsEventArgs);\n            if (!Utils_1.Utils.isNullOrEmptyString(text)) {\n                this.omniboxAnalytics.partialQueries.push(text);\n            }\n            return _.compact(suggestionsEventArgs.suggestions);\n        }\n        else {\n            return [];\n        }\n    };\n    Omnibox.prototype.triggerOmniboxSuggestions = function (args) {\n        this.bind.trigger(this.element, OmniboxEvents_1.OmniboxEvents.populateOmniboxSuggestions, args);\n        if (!Dom_1.$$(this.element).isDescendant(this.root)) {\n            this.bind.trigger(this.root, OmniboxEvents_1.OmniboxEvents.populateOmniboxSuggestions, args);\n        }\n    };\n    Omnibox.prototype.handleBeforeRedirect = function () {\n        this.updateQueryState();\n    };\n    Omnibox.prototype.handleBuildingQuery = function (data) {\n        var _this = this;\n        Assert_1.Assert.exists(data);\n        Assert_1.Assert.exists(data.queryBuilder);\n        this.updateQueryState();\n        this.lastQuery = this.getQuery(data.searchAsYouType);\n        var result = this.lastQuery == this.magicBox.getDisplayedResult().input\n            ? this.magicBox.getDisplayedResult().clone()\n            : this.magicBox.grammar.parse(this.lastQuery).clean();\n        var preprocessResultForQueryArgs = {\n            result: result\n        };\n        if (this.options.enableQuerySyntax) {\n            var notQuotedValues = preprocessResultForQueryArgs.result.findAll('FieldValueNotQuoted');\n            _.each(notQuotedValues, function (value) { return (value.value = '\"' + value.value.replace(/\"|\\u00A0/g, ' ') + '\"'); });\n            if (this.options.fieldAlias) {\n                var fieldNames = preprocessResultForQueryArgs.result.findAll(function (result) { return result.expression.id == 'FieldName' && result.isSuccess(); });\n                _.each(fieldNames, function (result) {\n                    var alias = _.find(_.keys(_this.options.fieldAlias), function (alias) { return alias.toLowerCase() == result.value.toLowerCase(); });\n                    if (alias != null) {\n                        result.value = _this.options.fieldAlias[alias];\n                    }\n                });\n            }\n        }\n        this.triggerOmniboxPreprocessResultForQuery(preprocessResultForQueryArgs);\n        var query = preprocessResultForQueryArgs.result.toString();\n        new QueryboxQueryParameters_1.QueryboxQueryParameters(this.options).addParameters(data.queryBuilder, query);\n    };\n    Omnibox.prototype.triggerOmniboxPreprocessResultForQuery = function (args) {\n        this.bind.trigger(this.element, OmniboxEvents_1.OmniboxEvents.omniboxPreprocessResultForQuery, args);\n        if (!Dom_1.$$(this.element).isDescendant(this.root)) {\n            this.bind.trigger(this.root, OmniboxEvents_1.OmniboxEvents.omniboxPreprocessResultForQuery, args);\n        }\n    };\n    Omnibox.prototype.handleNewQuery = function (data) {\n        Assert_1.Assert.exists(data);\n        this.options.clearFiltersOnNewQuery && this.clearFiltersIfNewQuery(data);\n    };\n    Omnibox.prototype.clearFiltersIfNewQuery = function (_a) {\n        var origin = _a.origin, searchAsYouType = _a.searchAsYouType;\n        if (this.queryController.firstQuery) {\n            return;\n        }\n        // Prevent queries triggered by unrelated components to clear the the filters\n        // e.g., a facet selection\n        var validOrigins = [Omnibox.ID, 'SearchButton'];\n        if (!origin || validOrigins.indexOf(origin.type) === -1) {\n            return;\n        }\n        var lastQuery = this.queryController.getLastQuery().q || '';\n        var newQuery = this.getQuery(searchAsYouType);\n        if (lastQuery !== newQuery) {\n            this.bind.trigger(this.root, BreadcrumbEvents_1.BreadcrumbEvents.clearBreadcrumb);\n        }\n    };\n    Omnibox.prototype.handleTabPress = function () {\n        if (this.options.enableQuerySuggestAddon) {\n            this.handleTabPressForSuggestions();\n        }\n        this.handleTabPressForOldOmniboxAddon();\n    };\n    Omnibox.prototype.handleTabPressForSuggestions = function () {\n        if (!this.options.enableSearchAsYouType) {\n            var suggestions = _.compact(_.map(this.lastSuggestions, function (suggestion) { return suggestion.text; }));\n            this.usageAnalytics.logCustomEvent(this.getOmniboxAnalyticsEventCause(), this.buildCustomDataForPartialQueries(0, suggestions), this.element);\n        }\n        else {\n            this.setText(this.getQuery(true));\n        }\n    };\n    Omnibox.prototype.handleTabPressForOldOmniboxAddon = function () {\n        var domSuggestions = this.lastSuggestions.filter(function (suggestions) { return suggestions.dom; }).map(function (suggestions) { return Dom_1.$$(suggestions.dom); });\n        var selected = this.findAllElementsWithClass(domSuggestions, '.coveo-omnibox-selected');\n        if (selected.length > 0) {\n            Dom_1.$$(selected[0]).trigger('tabSelect');\n        }\n        else if (!this.options.enableQuerySuggestAddon) {\n            var selectable = this.findAllElementsWithClass(domSuggestions, '.coveo-omnibox-selectable');\n            if (selectable.length > 0) {\n                Dom_1.$$(selectable[0]).trigger('tabSelect');\n            }\n        }\n    };\n    Omnibox.prototype.findAllElementsWithClass = function (elements, className) {\n        return elements\n            .map(function (element) { return element.find(className); })\n            .filter(function (s) { return s; })\n            .reduce(function (total, s) { return total.concat(s); }, []);\n    };\n    Omnibox.prototype.triggerNewQuery = function (searchAsYouType, analyticsEvent) {\n        clearTimeout(this.searchAsYouTypeTimeout);\n        var shouldExecuteQuery = this.shouldExecuteQuery(searchAsYouType);\n        this.lastQuery = this.getQuery(searchAsYouType);\n        shouldExecuteQuery && analyticsEvent();\n        this.queryController.executeQuery({\n            searchAsYouType: searchAsYouType,\n            logInActionsHistory: true,\n            cancel: !shouldExecuteQuery,\n            origin: this\n        });\n    };\n    Omnibox.prototype.getQuery = function (searchAsYouType) {\n        if (this.lastQuery == this.magicBox.getText()) {\n            return this.lastQuery;\n        }\n        if (!searchAsYouType) {\n            return this.magicBox.getText();\n        }\n        var wordCompletion = this.magicBox.getWordCompletion();\n        if (wordCompletion != null) {\n            return wordCompletion;\n        }\n        var currentOmniboxSuggestion = this.magicBox.getWordCompletion() || this.getFirstSuggestion();\n        if (currentOmniboxSuggestion) {\n            return currentOmniboxSuggestion;\n        }\n        if (this.isAutoSuggestion()) {\n            return this.lastQuery || this.magicBox.getText();\n        }\n        return this.magicBox.getText();\n    };\n    Omnibox.prototype.getFirstSuggestion = function () {\n        if (this.lastSuggestions == null) {\n            return '';\n        }\n        if (this.lastSuggestions.length <= 0) {\n            return '';\n        }\n        var textSuggestion = _.find(this.lastSuggestions, function (suggestion) { return suggestion.text != null; });\n        if (textSuggestion == null) {\n            return '';\n        }\n        return textSuggestion.text;\n    };\n    Omnibox.prototype.updateQueryState = function () {\n        this.queryStateModel.set(QueryStateModel_1.QueryStateModel.attributesEnum.q, this.magicBox.getText());\n    };\n    Omnibox.prototype.handleQueryStateChanged = function (args) {\n        Assert_1.Assert.exists(args);\n        var q = args.value;\n        if (q != this.magicBox.getText()) {\n            this.magicBox.setText(q);\n        }\n    };\n    Omnibox.prototype.handleQuerySuccess = function () {\n        if (!this.isAutoSuggestion()) {\n            this.omniboxAnalytics.partialQueries = [];\n        }\n    };\n    Omnibox.prototype.handleDuringQuery = function (args) {\n        var _this = this;\n        // When the query results returns ... (args.promise)\n        args.promise.then(function () {\n            // Get a handle on a pending search as you type (those events are delayed, not sent instantly)\n            var pendingEvent = _this.usageAnalytics.getPendingSearchEvent();\n            if (pendingEvent instanceof PendingSearchAsYouTypeSearchEvent_1.PendingSearchAsYouTypeSearchEvent) {\n                pendingEvent.beforeResolve.then(function (evt) {\n                    // Check if we need to modify the event type beforeResolving it\n                    args.promise.then(function () {\n                        if (_this.modifyEventTo) {\n                            evt.modifyEventCause(_this.modifyEventTo);\n                            _this.modifyEventTo = null;\n                        }\n                    });\n                });\n            }\n        });\n    };\n    Omnibox.prototype.searchAsYouType = function (forceExecuteQuery) {\n        var _this = this;\n        if (forceExecuteQuery === void 0) { forceExecuteQuery = false; }\n        this.clearSearchAsYouType();\n        if (this.shouldExecuteQuery(true)) {\n            this.searchAsYouTypeTimeout = window.setTimeout(function () {\n                if (_this.suggestionShouldTriggerQuery() || forceExecuteQuery) {\n                    var suggestions_1 = _.map(_this.lastSuggestions, function (suggestion) { return suggestion.text; });\n                    var index_1 = _.indexOf(suggestions_1, _this.magicBox.getWordCompletion());\n                    _this.triggerNewQuery(true, function () {\n                        _this.usageAnalytics.logSearchAsYouType(AnalyticsActionListMeta_1.analyticsActionCauseList.searchboxAsYouType, _this.buildCustomDataForPartialQueries(index_1, suggestions_1));\n                    });\n                    _this.clearSearchAsYouType();\n                }\n            }, this.options.searchAsYouTypeDelay);\n        }\n    };\n    Omnibox.prototype.isAutoSuggestion = function () {\n        return this.options.enableSearchAsYouType && this.options.enableQuerySuggestAddon;\n    };\n    Omnibox.prototype.shouldExecuteQuery = function (searchAsYouType) {\n        var text = this.getQuery(searchAsYouType);\n        if (this.searchInterface.options.allowQueriesWithoutKeywords === false) {\n            return this.lastQuery != text && Utils_1.Utils.isNonEmptyString(text);\n        }\n        return this.lastQuery != text && text != null;\n    };\n    Omnibox.prototype.suggestionShouldTriggerQuery = function (suggestions) {\n        if (suggestions === void 0) { suggestions = this.lastSuggestions; }\n        if (this.shouldExecuteQuery(true)) {\n            if (suggestions && suggestions[0]) {\n                var suggestion = suggestions[0];\n                // If we have access to a confidence level, return true if we are equal or above the minimum confidence level.\n                if (suggestion && suggestion.executableConfidence != undefined) {\n                    return suggestion.executableConfidence >= MINIMUM_EXECUTABLE_CONFIDENCE;\n                }\n                // If we don't have access to a confidence level, return true only if it \"starts with\" the content of the search box\n                if (suggestion.text && suggestion.text.indexOf(this.magicBox.getText()) == 0) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    };\n    Omnibox.prototype.clearSearchAsYouType = function () {\n        clearTimeout(this.searchAsYouTypeTimeout);\n        this.searchAsYouTypeTimeout = undefined;\n    };\n    Omnibox.prototype.getOmniboxAnalyticsEventCause = function () {\n        if (this.searchInterface instanceof SearchInterface_1.StandaloneSearchInterface) {\n            return AnalyticsActionListMeta_1.analyticsActionCauseList.omniboxFromLink;\n        }\n        return AnalyticsActionListMeta_1.analyticsActionCauseList.omniboxAnalytics;\n    };\n    Omnibox.ID = 'Omnibox';\n    Omnibox.doExport = function () {\n        GlobalExports_1.exportGlobally({\n            Omnibox: Omnibox,\n            QueryboxQueryParameters: QueryboxQueryParameters_1.QueryboxQueryParameters\n        });\n    };\n    /**\n     * The options for the omnibox\n     * @componentOptions\n     */\n    Omnibox.options = {\n        /**\n         * Specifies whether query completion suggestions appearing in the `Omnibox` should push the result list and facets\n         * down, rather than rendering themselves over them (and partially hiding them).\n         *\n         * Set this option as well as {@link Omnibox.options.enableSearchAsYouType} and\n         * {@link Omnibox.options.enableQuerySuggestAddon} to `true` for a cool effect!\n         *\n         * Default value is `false`.\n         */\n        inline: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false }),\n        /**\n         * Whether to automatically trigger a new query whenever the end user types additional text in the search box input.\n         *\n         * See also the [`searchAsYouTypeDelay`]{@link Omnibox.options.searchAsYouTypeDelay} option.\n         *\n         * **Note:**\n         * > If you set this option and the [`enableQuerySuggestAddon`]{@link Omnibox.options.enableQuerySuggestAddon}\n         * > option to `true`, the query suggestion feature returns the auto-completion of the currently typed keyword as\n         * > its first suggestion.\n         *\n         * Default value is `false`.\n         */\n        enableSearchAsYouType: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n        /**\n         * If {@link Omnibox.options.enableSearchAsYouType} is `true`, specifies the delay (in milliseconds) before\n         * triggering a new query when the end user types in the `Omnibox`.\n         *\n         * Default value is `2000`. Minimum value is `0`.\n         */\n        searchAsYouTypeDelay: ComponentOptions_1.ComponentOptions.buildNumberOption({\n            defaultValue: 2000,\n            min: 0,\n            depend: 'enableSearchAsYouType',\n            section: 'Advanced Options'\n        }),\n        /**\n         * The `field` addon makes the `Omnibox` highlight and complete field syntax. Setting this option to `true` automatically sets\n         * the [enableQuerySyntax]{@link Querybox.options.enableQuerySyntax} option to `true` as a side effect.\n         *\n         * **Example:**\n         * > Suppose you want to search for PDF files. You start typing `@f` in the search box. The `Omnibox` provides\n         * > you with several matching fields. You select the `@filetype` field. Then, you start typing `=p` in the input.\n         * > This time, the `Omnibox` provides you with several matching values for the `@filetype` field. You select the\n         * > `pdf` suggestion, and submit your search request. Since the `enableQuerySyntax` option is set to `true`, the\n         * > Coveo Search API interprets the basic expression as query syntax and returns the items whose `@filetype` field\n         * > matches the `pdf` value.\n         *\n         * Default value is `false`.\n         */\n        enableFieldAddon: ComponentOptions_1.ComponentOptions.buildBooleanOption({\n            defaultValue: false,\n            depend: 'enableQuerySyntax',\n            postProcessing: function (value, options) {\n                if (value) {\n                    options.enableQuerySyntax = true;\n                }\n                return value;\n            },\n            section: 'Advanced Options'\n        }),\n        enableSimpleFieldAddon: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false, depend: 'enableFieldAddon' }),\n        listOfFields: ComponentOptions_1.ComponentOptions.buildFieldsOption({ depend: 'enableFieldAddon' }),\n        /**\n         * Whether to display Coveo Machine Learning (Coveo ML) query suggestions in the `Omnibox`.\n         *\n         * A Coveo ML query suggestions (QS) model must be properly configured in your Coveo Cloud organization, otherwise this\n         * option has no effect (see\n         * [Create a QS Model](https://docs.coveo.com/en/1832/#create-a-qs-model)).\n         *\n         * **Note:**\n         * > When you set this option and the [`enableSearchAsYouType`]{@link Omnibox.options.enableSearchAsYouType} option\n         * > to `true`, the query suggestion feature returns the auto-completion of the currently typed keyword as its first\n         * > query suggestion.\n         *\n         * @availablesince [December 2015 Release (v1.0.273)](https://docs.coveo.com/en/289/#december-2015-release-v10273)\n         */\n        enableQuerySuggestAddon: ComponentOptions_1.ComponentOptions.buildBooleanOption({\n            defaultValue: true,\n            alias: ['enableTopQueryAddon', 'enableRevealQuerySuggestAddon']\n        }),\n        /**\n         * If {@link Querybox.options.enableQuerySyntax} is `true`, specifies whether to enable the `query extension` addon.\n         *\n         * The `query extension` addon allows the Omnibox to complete the syntax for query extensions.\n         *\n         * Default value is `false`.\n         */\n        enableQueryExtensionAddon: ComponentOptions_1.ComponentOptions.buildBooleanOption({\n            defaultValue: false,\n            depend: 'enableQuerySyntax',\n            postProcessing: function (value, options) {\n                if (value) {\n                    options.enableQuerySyntax = true;\n                }\n                return value;\n            },\n            section: 'Advanced Options'\n        }),\n        /**\n         * Specifies a placeholder for the input.\n         *\n         * @availablesince [July 2016 Release (v1.667.24)](https://docs.coveo.com/en/309/#july-2016-release-v166724)\n         */\n        placeholder: ComponentOptions_1.ComponentOptions.buildLocalizedStringOption(),\n        /**\n         * Specifies a timeout (in milliseconds) before rejecting suggestions in the Omnibox.\n         *\n         * Default value is `2000`. Minimum value is `0`.\n         */\n        omniboxTimeout: ComponentOptions_1.ComponentOptions.buildNumberOption({ defaultValue: 2000, min: 0 }),\n        /**\n         * Specifies whether the Coveo Platform should try to interpret special query syntax such as field references in the\n         * query that the user enters in the Querybox (see\n         * [Coveo Query Syntax Reference](https://docs.coveo.com/en/1552/searching-with-coveo/coveo-cloud-query-syntax)).\n         *\n         * Setting this option to `true` also causes the query syntax in the Querybox to highlight.\n         *\n         * Default value is `false`.\n         */\n        enableQuerySyntax: ComponentOptions_1.ComponentOptions.buildBooleanOption({\n            defaultValue: false,\n            section: 'Advanced Options'\n        }),\n        /**\n         * Specifies the number of suggestions that should appear in standard ML-powered query suggestions.\n         *\n         * This option only affects the number of suggestions that appear with the {@link Omnibox.options.enableQuerySuggestAddon} option.\n         *\n         * This options does not affect the {@link AnalyticsSuggestions} or the {@link FieldSuggestions} component, which expose their own dedicated options for this parameter.\n         *\n         * Default value is `5`.\n         *\n         * Minimum value is `1`.\n         */\n        numberOfSuggestions: ComponentOptions_1.ComponentOptions.buildNumberOption({\n            defaultValue: 5,\n            min: 1\n        }),\n        /**\n         * The minimum number of characters required in the in the text input before displaying available query suggestions when focus is on the component.\n         *\n         * Note: Only effective when [enableQuerySuggestAddon]{@link Omnibox.options.enableQuerySuggestAddon} is true.\n         *\n         * depend: 'enableQuerySuggestAddon'\n         *\n         * Default (and minimum): 0, meaning that trending query suggestions are displayed when focus is on the component, even if its text input is empty.\n         *\n         * @availablesince [July 2019 Release (v2.6459)](https://docs.coveo.com/en/2938/)\n         */\n        querySuggestCharacterThreshold: ComponentOptions_1.ComponentOptions.buildNumberOption({\n            defaultValue: 0,\n            min: 0\n        }),\n        /**\n         * Whether to clear all active query filters when the end user submits a new query from the search box.\n         *\n         * Note: This does not include the filter expression enforced by the currently selected tab, if any.\n         *\n         * @availablesince [September 2019 Release (v2.7023)](https://docs.coveo.com/en/2990/)\n         */\n        clearFiltersOnNewQuery: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: false })\n    };\n    return Omnibox;\n}(Component_1.Component));\nexports.Omnibox = Omnibox;\nOmnibox.options = __assign({}, Omnibox.options, Querybox_1.Querybox.options);\nInitialization_1.Initialization.registerAutoCreateComponent(Omnibox);\n\n\n/***/ }),\n\n/***/ 195:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar GlobalExports_1 = __webpack_require__(3);\nvar Strings_1 = __webpack_require__(6);\nvar AccessibleButton_1 = __webpack_require__(15);\nvar Dom_1 = __webpack_require__(1);\nvar SVGDom_1 = __webpack_require__(16);\nvar SVGIcons_1 = __webpack_require__(12);\nvar Utils_1 = __webpack_require__(4);\nvar AnalyticsActionListMeta_1 = __webpack_require__(10);\nvar Component_1 = __webpack_require__(7);\nvar Initialization_1 = __webpack_require__(2);\nvar QueryStateModel_1 = __webpack_require__(13);\n/**\n * The SearchButton component renders a search icon that the end user can click to trigger a new query.\n *\n * See also the {@link Searchbox} component, which can automatically instantiate a SearchButton component along with a\n * {@link Querybox} component or an {@link Omnibox} component.\n */\nvar SearchButton = /** @class */ (function (_super) {\n    __extends(SearchButton, _super);\n    /**\n     * Creates a new SearchButton. Binds a `click` event on the element. Adds a search icon on the element.\n     * @param element The HTMLElement on which to instantiate the component.\n     * @param options The options for the SearchButton component.\n     * @param bindings The bindings that the component requires to function normally. If not set, these will be\n     * automatically resolved (with a slower execution time).\n     */\n    function SearchButton(element, options, bindings) {\n        var _this = _super.call(this, element, SearchButton.ID, bindings) || this;\n        _this.element = element;\n        _this.options = options;\n        new AccessibleButton_1.AccessibleButton()\n            .withElement(element)\n            .withOwner(_this.bind)\n            .withLabel(Strings_1.l('Search'))\n            .withSelectAction(function () { return _this.handleClick(); })\n            .build();\n        // Provide a magnifier icon if element contains nothing\n        if (Utils_1.Utils.trim(Dom_1.$$(_this.element).text()) == '') {\n            var svgMagnifierContainer = Dom_1.$$('span', { className: 'coveo-search-button' }, SVGIcons_1.SVGIcons.icons.search).el;\n            SVGDom_1.SVGDom.addClassToSVGInContainer(svgMagnifierContainer, 'coveo-search-button-svg');\n            var svgLoadingAnimationContainer = Dom_1.$$('span', { className: 'coveo-search-button-loading' }, SVGIcons_1.SVGIcons.icons.loading).el;\n            SVGDom_1.SVGDom.addClassToSVGInContainer(svgLoadingAnimationContainer, 'coveo-search-button-loading-svg');\n            element.appendChild(svgMagnifierContainer);\n            element.appendChild(svgLoadingAnimationContainer);\n        }\n        return _this;\n    }\n    /**\n     * Triggers the `click` event handler, which logs a `searchboxSubmit` event in the usage analytics and executes a\n     * query.\n     */\n    SearchButton.prototype.click = function () {\n        this.handleClick();\n    };\n    SearchButton.prototype.handleClick = function () {\n        this.logger.debug('Performing query following button click');\n        this.updateQueryStateModelWithSearchboxQuery();\n        this.usageAnalytics.logSearchEvent(AnalyticsActionListMeta_1.analyticsActionCauseList.searchboxSubmit, {});\n        this.queryController.executeQuery({ origin: this, logInActionsHistory: true });\n    };\n    SearchButton.prototype.updateQueryStateModelWithSearchboxQuery = function () {\n        var searchbox = this.options && this.options.searchbox;\n        searchbox && this.queryStateModel.set(QueryStateModel_1.QueryStateModel.attributesEnum.q, searchbox.getText());\n    };\n    SearchButton.ID = 'SearchButton';\n    SearchButton.doExport = function () {\n        GlobalExports_1.exportGlobally({\n            SearchButton: SearchButton\n        });\n    };\n    SearchButton.options = {};\n    return SearchButton;\n}(Component_1.Component));\nexports.SearchButton = SearchButton;\nInitialization_1.Initialization.registerAutoCreateComponent(SearchButton);\n\n\n/***/ }),\n\n/***/ 218:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExpressionEndOfInput = {\n    id: 'end of input',\n    parse: null\n};\n\n\n/***/ }),\n\n/***/ 219:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Result_1 = __webpack_require__(52);\nvar Result_2 = __webpack_require__(52);\nvar ExpressionConstant = /** @class */ (function () {\n    function ExpressionConstant(value, id) {\n        this.value = value;\n        this.id = id;\n    }\n    ExpressionConstant.prototype.parse = function (input, end) {\n        // the value must be at the start of the input\n        var success = input.indexOf(this.value) == 0;\n        var result = new Result_1.Result(success ? this.value : null, this, input);\n        // if is successful and we require the end but the length of parsed is\n        // lower than the input length, return a EndOfInputExpected Result\n        if (success && end && input.length > this.value.length) {\n            return new Result_2.EndOfInputResult(result);\n        }\n        return result;\n    };\n    ExpressionConstant.prototype.toString = function () {\n        return this.value;\n    };\n    return ExpressionConstant;\n}());\nexports.ExpressionConstant = ExpressionConstant;\n\n\n/***/ }),\n\n/***/ 220:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Basic_1 = __webpack_require__(132);\nvar Date_1 = __webpack_require__(500);\nexports.Field = {\n    basicExpressions: ['FieldSimpleQuery', 'FieldQuery', 'Field'],\n    grammars: {\n        FieldQuery: '[Field][OptionalSpaces][FieldQueryOperation]',\n        FieldQueryOperation: ['FieldQueryValue', 'FieldQueryNumeric'],\n        FieldQueryValue: '[FieldOperator][OptionalSpaces][FieldValue]',\n        FieldQueryNumeric: '[FieldOperatorNumeric][OptionalSpaces][FieldValueNumeric]',\n        FieldSimpleQuery: '[FieldName]:[OptionalSpaces][FieldValue]',\n        Field: '@[FieldName]',\n        FieldName: /[a-zA-Z][a-zA-Z0-9\\.\\_]*/,\n        FieldOperator: /==|=|<>/,\n        FieldOperatorNumeric: /<=|>=|<|>/,\n        FieldValue: ['DateRange', 'NumberRange', 'DateRelative', 'Date', 'Number', 'FieldValueList', 'FieldValueString'],\n        FieldValueNumeric: ['DateRelative', 'Date', 'Number'],\n        FieldValueString: ['DoubleQuoted', 'FieldValueNotQuoted'],\n        FieldValueList: '([FieldValueString][FieldValueStringList*])',\n        FieldValueStringList: '[FieldValueSeparator][FieldValueString]',\n        FieldValueSeparator: / *, */,\n        FieldValueNotQuoted: /[^ \\(\\)\\[\\],]+/,\n        NumberRange: '[Number][Spaces?]..[Spaces?][Number]'\n    },\n    include: [Date_1.Date, Basic_1.Basic]\n};\n\n\n/***/ }),\n\n/***/ 221:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [0, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar underscore_1 = __webpack_require__(0);\nvar OmniboxEvents_1 = __webpack_require__(34);\nvar Component_1 = __webpack_require__(7);\nvar Dom_1 = __webpack_require__(1);\nvar ResultPreviewsManager_1 = __webpack_require__(563);\nvar QueryProcessor_1 = __webpack_require__(504);\nvar QueryUtils_1 = __webpack_require__(21);\nvar Direction;\n(function (Direction) {\n    Direction[\"Up\"] = \"Up\";\n    Direction[\"Down\"] = \"Down\";\n    Direction[\"Left\"] = \"Left\";\n    Direction[\"Right\"] = \"Right\";\n})(Direction = exports.Direction || (exports.Direction = {}));\nvar SuggestionsManager = /** @class */ (function () {\n    function SuggestionsManager(element, magicBoxContainer, inputManager, options) {\n        var _this = this;\n        this.element = element;\n        this.magicBoxContainer = magicBoxContainer;\n        this.inputManager = inputManager;\n        this.suggestionListboxID = \"coveo-magicbox-suggestions-\" + QueryUtils_1.QueryUtils.createGuid();\n        this.suggestionListboxClassName = \"coveo-magicbox-suggestions\";\n        this.root = Component_1.Component.resolveRoot(element);\n        this.options = underscore_1.defaults(options, {\n            suggestionClass: 'magic-box-suggestion',\n            selectedClass: 'magic-box-selected'\n        });\n        // Put in a sane default, so as to not reject every suggestions if not set on initialization\n        if (this.options.timeout == undefined) {\n            this.options.timeout = 500;\n        }\n        Dom_1.$$(this.element).on('mouseover', function (e) {\n            _this.handleMouseOver(e);\n        });\n        Dom_1.$$(this.element).on('mouseout', function (e) {\n            _this.handleMouseOut(e);\n        });\n        this.suggestionsProcessor = new QueryProcessor_1.QueryProcessor({ timeout: this.options.timeout });\n        this.resultPreviewsManager = new ResultPreviewsManager_1.ResultPreviewsManager(element, {\n            selectedClass: this.options.selectedClass,\n            timeout: this.options.timeout\n        });\n        this.suggestionsListbox = this.buildSuggestionsContainer();\n        Dom_1.$$(this.element).append(this.suggestionsListbox.el);\n        this.addAccessibilityProperties();\n        this.appendEmptySuggestionOption();\n    }\n    Object.defineProperty(SuggestionsManager.prototype, \"hasSuggestions\", {\n        get: function () {\n            return this.currentSuggestions && this.currentSuggestions.length > 0;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(SuggestionsManager.prototype, \"hasFocus\", {\n        get: function () {\n            return Dom_1.$$(this.element).findClass(this.options.selectedClass).length > 0;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(SuggestionsManager.prototype, \"hasPreviews\", {\n        get: function () {\n            return this.resultPreviewsManager.hasPreviews;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(SuggestionsManager.prototype, \"focusedSuggestion\", {\n        get: function () {\n            var _this = this;\n            return underscore_1.find(this.currentSuggestions, function (suggestion) {\n                return Dom_1.$$(suggestion.dom).hasClass(_this.options.selectedClass) || Dom_1.$$(suggestion.dom).findClass(_this.options.selectedClass).length > 0;\n            });\n        },\n        enumerable: true,\n        configurable: true\n    });\n    SuggestionsManager.prototype.handleMouseOver = function (e) {\n        var target = Dom_1.$$(e.target);\n        var parents = target.parents(this.options.suggestionClass);\n        if (target.hasClass(this.options.suggestionClass)) {\n            this.processMouseSelection(target.el);\n        }\n        else if (parents.length > 0 && this.element.contains(parents[0])) {\n            this.processMouseSelection(parents[0]);\n        }\n    };\n    SuggestionsManager.prototype.handleMouseOut = function (e) {\n        var target = Dom_1.$$(e.target);\n        var targetParents = target.parents(this.options.suggestionClass);\n        //e.relatedTarget is not available if moving off the browser window or is an empty object `{}` when moving out of namespace in LockerService.\n        if (e.relatedTarget && Dom_1.$$(e.relatedTarget).isValid()) {\n            var relatedTargetParents = Dom_1.$$(e.relatedTarget).parents(this.options.suggestionClass);\n            if (target.hasClass(this.options.selectedClass) && !Dom_1.$$(e.relatedTarget).hasClass(this.options.suggestionClass)) {\n                this.removeSelectedStatus(target.el);\n            }\n            else if (relatedTargetParents.length == 0 && targetParents.length > 0) {\n                this.removeSelectedStatus(targetParents[0]);\n            }\n        }\n        else {\n            if (target.hasClass(this.options.selectedClass)) {\n                this.removeSelectedStatus(target.el);\n            }\n            else if (targetParents.length > 0) {\n                this.removeSelectedStatus(targetParents[0]);\n            }\n        }\n        Dom_1.$$(this.root).trigger(OmniboxEvents_1.OmniboxEvents.querySuggestLoseFocus);\n    };\n    SuggestionsManager.prototype.moveDown = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, this.move(Direction.Down)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.moveUp = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, this.move(Direction.Up)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.moveLeft = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, this.move(Direction.Left)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.moveRight = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, this.move(Direction.Right)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.selectAndReturnKeyboardFocusedElement = function () {\n        var selected = this.keyboardFocusedElement;\n        if (selected) {\n            Dom_1.$$(selected).trigger('keyboardSelect');\n            // By definition, once an element has been \"selected\" with the keyboard,\n            // it is not longer \"active\" since the event has been processed.\n            this.keyboardFocusedElement = null;\n            this.inputManager.blur();\n        }\n        return selected;\n    };\n    SuggestionsManager.prototype.clearKeyboardFocusedElement = function () {\n        this.keyboardFocusedElement = null;\n    };\n    SuggestionsManager.prototype.receiveSuggestions = function (suggestions) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _a, results, status;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0: return [4 /*yield*/, this.suggestionsProcessor.processQueries(suggestions)];\n                    case 1:\n                        _a = _b.sent(), results = _a.results, status = _a.status;\n                        if (status === QueryProcessor_1.ProcessingStatus.Overriden) {\n                            return [2 /*return*/, []];\n                        }\n                        this.updateSuggestions(results);\n                        return [2 /*return*/, results];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.clearSuggestions = function () {\n        this.updateSuggestions([]);\n    };\n    SuggestionsManager.prototype.updateSuggestions = function (suggestions) {\n        var _this = this;\n        this.suggestionsListbox.empty();\n        this.inputManager.activeDescendant = null;\n        this.currentSuggestions = suggestions;\n        Dom_1.$$(this.element).toggleClass('magic-box-hasSuggestion', this.hasSuggestions);\n        this.inputManager.expanded = this.hasSuggestions;\n        this.resultPreviewsManager.displaySearchResultPreviewsForSuggestion(null);\n        if (!this.hasSuggestions) {\n            this.appendEmptySuggestionOption();\n            Dom_1.$$(this.root).trigger(OmniboxEvents_1.OmniboxEvents.querySuggestLoseFocus);\n            return;\n        }\n        suggestions\n            .sort(function (a, b) { return (b.index || 0) - (a.index || 0); })\n            .forEach(function (suggestion) {\n            var dom = suggestion.dom ? _this.modifyDomFromExistingSuggestion(suggestion.dom) : _this.createDomFromSuggestion(suggestion);\n            dom.setAttribute('id', \"magic-box-suggestion-\" + underscore_1.indexOf(suggestions, suggestion));\n            dom.setAttribute('role', 'option');\n            dom.setAttribute('aria-selected', 'false');\n            dom.setAttribute('aria-label', dom.text());\n            dom['suggestion'] = suggestion;\n            _this.suggestionsListbox.append(dom.el);\n        });\n        var numberOfSuggestions = this.suggestionsListbox.findAll(\".\" + this.options.suggestionClass).length;\n        Dom_1.$$(this.root).trigger(OmniboxEvents_1.OmniboxEvents.querySuggestRendered, { numberOfSuggestions: numberOfSuggestions });\n    };\n    Object.defineProperty(SuggestionsManager.prototype, \"selectedSuggestion\", {\n        get: function () {\n            if (this.htmlElementIsSuggestion(this.keyboardFocusedElement)) {\n                return this.returnMoved(this.keyboardFocusedElement);\n            }\n            return null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    SuggestionsManager.prototype.processKeyboardSelection = function (suggestion) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        this.addSelectedStatus(suggestion);\n                        this.keyboardFocusedElement = suggestion;\n                        return [4 /*yield*/, this.updateSelectedSuggestion(this.focusedSuggestion)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.processKeyboardPreviewSelection = function (preview) {\n        this.addSelectedStatus(preview);\n        this.keyboardFocusedElement = preview;\n    };\n    SuggestionsManager.prototype.processMouseSelection = function (suggestion) {\n        this.addSelectedStatus(suggestion);\n        this.updateSelectedSuggestion(this.focusedSuggestion);\n        this.keyboardFocusedElement = null;\n    };\n    SuggestionsManager.prototype.buildSuggestionsContainer = function () {\n        return Dom_1.$$('div', {\n            className: this.suggestionListboxClassName,\n            id: this.suggestionListboxID,\n            role: 'listbox',\n            ariaLabel: 'Search Suggestions'\n        });\n    };\n    SuggestionsManager.prototype.createDomFromSuggestion = function (suggestion) {\n        var _this = this;\n        var dom = Dom_1.$$('div', {\n            className: \"magic-box-suggestion \" + this.options.suggestionClass\n        });\n        suggestion.dom = dom.el;\n        dom.on('click', function () {\n            _this.selectSuggestion(suggestion);\n        });\n        dom.on('keyboardSelect', function () {\n            _this.selectSuggestion(suggestion);\n        });\n        if (suggestion.html) {\n            dom.el.innerHTML = suggestion.html;\n            return dom;\n        }\n        if (suggestion.text) {\n            dom.text(suggestion.text);\n            return dom;\n        }\n        if (suggestion.separator) {\n            dom.addClass('magic-box-suggestion-seperator');\n            var suggestionLabel = Dom_1.$$('div', {\n                className: 'magic-box-suggestion-seperator-label'\n            }, suggestion.separator);\n            dom.append(suggestionLabel.el);\n            return dom;\n        }\n        return dom;\n    };\n    SuggestionsManager.prototype.selectSuggestion = function (suggestion) {\n        suggestion.onSelect();\n        Dom_1.$$(this.root).trigger(OmniboxEvents_1.OmniboxEvents.querySuggestSelection, { suggestion: suggestion.text });\n    };\n    SuggestionsManager.prototype.appendEmptySuggestionOption = function () {\n        // Accessibility tools reports that a listbox element must always have at least one child with an option\n        // Even if there is no suggestions to show.\n        this.suggestionsListbox.append(Dom_1.$$('div', { role: 'option' }).el);\n    };\n    SuggestionsManager.prototype.modifyDomFromExistingSuggestion = function (dom) {\n        // this need to be done if the selection is in cache and the dom is set in the suggestion\n        this.removeSelectedStatus(dom);\n        var found = dom.classList.contains(this.options.suggestionClass) ? dom : Dom_1.$$(dom).find('.' + this.options.suggestionClass);\n        this.removeSelectedStatus(found);\n        return Dom_1.$$(dom);\n    };\n    SuggestionsManager.prototype.move = function (direction) {\n        return __awaiter(this, void 0, void 0, function () {\n            var firstPreview;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!this.resultPreviewsManager.focusedPreviewElement) return [3 /*break*/, 2];\n                        return [4 /*yield*/, this.moveWithinPreview(direction)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                    case 2:\n                        if (direction === Direction.Right || direction === Direction.Left) {\n                            firstPreview = this.resultPreviewsManager.previewElements[0];\n                            if (firstPreview) {\n                                this.processKeyboardPreviewSelection(firstPreview);\n                                return [2 /*return*/];\n                            }\n                        }\n                        return [4 /*yield*/, this.moveWithinSuggestion(direction)];\n                    case 3:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.moveWithinSuggestion = function (direction) {\n        return __awaiter(this, void 0, void 0, function () {\n            var currentlySelected, selectables, currentIndex, index;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        currentlySelected = Dom_1.$$(this.element).find(\".\" + this.options.selectedClass);\n                        selectables = Dom_1.$$(this.element).findAll(\".\" + this.options.suggestionClass);\n                        currentIndex = underscore_1.indexOf(selectables, currentlySelected);\n                        index = direction === Direction.Up ? currentIndex - 1 : currentIndex + 1;\n                        index = (index + selectables.length) % selectables.length;\n                        return [4 /*yield*/, this.selectQuerySuggest(selectables[index])];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.selectQuerySuggest = function (suggestion) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!suggestion) return [3 /*break*/, 2];\n                        return [4 /*yield*/, this.processKeyboardSelection(suggestion)];\n                    case 1:\n                        _a.sent();\n                        return [3 /*break*/, 3];\n                    case 2:\n                        this.keyboardFocusedElement = null;\n                        this.inputManager.input.removeAttribute('aria-activedescendant');\n                        _a.label = 3;\n                    case 3: return [2 /*return*/, suggestion];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.moveWithinPreview = function (direction) {\n        return __awaiter(this, void 0, void 0, function () {\n            var newFocusedPreview;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        newFocusedPreview = this.resultPreviewsManager.getElementInDirection(direction);\n                        if (!!newFocusedPreview) return [3 /*break*/, 2];\n                        return [4 /*yield*/, this.selectQuerySuggest(this.resultPreviewsManager.previewsOwner.dom)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                    case 2:\n                        this.processKeyboardPreviewSelection(newFocusedPreview);\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.returnMoved = function (selected) {\n        if (selected) {\n            if (selected['suggestion']) {\n                return selected['suggestion'];\n            }\n            if (selected['no-text-suggestion']) {\n                return null;\n            }\n            if (selected instanceof HTMLElement) {\n                return {\n                    text: Dom_1.$$(selected).text()\n                };\n            }\n        }\n        return null;\n    };\n    SuggestionsManager.prototype.addSelectedStatus = function (element) {\n        var selected = this.element.getElementsByClassName(this.options.selectedClass);\n        for (var i = 0; i < selected.length; i++) {\n            var elem = selected.item(i);\n            this.removeSelectedStatus(elem);\n        }\n        Dom_1.$$(element).addClass(this.options.selectedClass);\n        this.updateAreaSelectedIfDefined(element, 'true');\n    };\n    SuggestionsManager.prototype.updateSelectedSuggestion = function (suggestion) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        Dom_1.$$(this.root).trigger(OmniboxEvents_1.OmniboxEvents.querySuggestGetFocus, {\n                            suggestion: suggestion.text\n                        });\n                        return [4 /*yield*/, this.resultPreviewsManager.displaySearchResultPreviewsForSuggestion(suggestion)];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    SuggestionsManager.prototype.removeSelectedStatus = function (suggestion) {\n        Dom_1.$$(suggestion).removeClass(this.options.selectedClass);\n        this.updateAreaSelectedIfDefined(suggestion, 'false');\n    };\n    SuggestionsManager.prototype.updateAreaSelectedIfDefined = function (element, value) {\n        if (Dom_1.$$(element).getAttribute('aria-selected')) {\n            this.inputManager.activeDescendant = element;\n            Dom_1.$$(element).setAttribute('aria-selected', value);\n        }\n    };\n    SuggestionsManager.prototype.addAccessibilityProperties = function () {\n        this.addAccessibilityPropertiesForMagicBox();\n        this.addAccessibilityPropertiesForInput();\n    };\n    SuggestionsManager.prototype.addAccessibilityPropertiesForMagicBox = function () {\n        var magicBox = Dom_1.$$(this.magicBoxContainer);\n        magicBox.setAttribute('role', 'search');\n        magicBox.setAttribute('aria-haspopup', 'listbox');\n    };\n    SuggestionsManager.prototype.addAccessibilityPropertiesForInput = function () {\n        var input = Dom_1.$$(this.inputManager.input);\n        this.inputManager.activeDescendant = null;\n        this.inputManager.expanded = false;\n        input.setAttribute('aria-owns', this.suggestionListboxID);\n        input.setAttribute('aria-controls', this.suggestionListboxID);\n    };\n    SuggestionsManager.prototype.htmlElementIsSuggestion = function (selected) {\n        var omniboxSelectables = Dom_1.$$(this.element).findAll(\".\" + this.options.suggestionClass);\n        return underscore_1.indexOf(omniboxSelectables, selected) > -1;\n    };\n    return SuggestionsManager;\n}());\nexports.SuggestionsManager = SuggestionsManager;\n\n\n/***/ }),\n\n/***/ 222:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [0, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar underscore_1 = __webpack_require__(0);\nvar Core_1 = __webpack_require__(20);\nvar Dom_1 = __webpack_require__(1);\nvar doMagicBoxExport_1 = __webpack_require__(561);\nvar InputManager_1 = __webpack_require__(503);\nvar MagicBoxClear_1 = __webpack_require__(564);\nvar SuggestionsManager_1 = __webpack_require__(221);\nvar MagicBoxInstance = /** @class */ (function () {\n    function MagicBoxInstance(element, grammar, options) {\n        if (options === void 0) { options = {}; }\n        var _this = this;\n        this.element = element;\n        this.grammar = grammar;\n        this.options = options;\n        this.lastSuggestions = [];\n        if (underscore_1.isUndefined(this.options.inline)) {\n            this.options.inline = false;\n        }\n        Dom_1.$$(element).addClass('magic-box');\n        if (this.options.inline) {\n            Dom_1.$$(element).addClass('magic-box-inline');\n        }\n        this.result = this.grammar.parse('');\n        this.displayedResult = this.result.clean();\n        var inputContainer = Dom_1.$$(element).find('.magic-box-input');\n        if (!inputContainer) {\n            inputContainer = document.createElement('div');\n            inputContainer.className = 'magic-box-input';\n            element.appendChild(inputContainer);\n        }\n        this.inputManager = new InputManager_1.InputManager(inputContainer, function (text, wordCompletion) {\n            if (!wordCompletion) {\n                _this.setText(text);\n                _this.addSuggestions();\n                _this.onchange && _this.onchange();\n            }\n            else {\n                _this.setText(text);\n                _this.onselect && _this.onselect(_this.firstSuggestionWithText);\n            }\n        }, this);\n        this.inputManager.ontabpress = function () {\n            _this.ontabpress && _this.ontabpress();\n        };\n        var existingValue = this.inputManager.getValue();\n        if (existingValue) {\n            this.displayedResult.input = existingValue;\n        }\n        this.inputManager.setResult(this.displayedResult);\n        var suggestionsContainer = document.createElement('div');\n        suggestionsContainer.className = 'magic-box-suggestions';\n        this.element.appendChild(suggestionsContainer);\n        this.suggestionsManager = new SuggestionsManager_1.SuggestionsManager(suggestionsContainer, this.element, this.inputManager, {\n            suggestionClass: this.options.selectableSuggestionClass,\n            selectedClass: this.options.selectedSuggestionClass,\n            timeout: this.options.suggestionTimeout\n        });\n        this.magicBoxClear = new MagicBoxClear_1.MagicBoxClear(this);\n        this.setupHandler();\n    }\n    Object.defineProperty(MagicBoxInstance.prototype, \"firstSuggestionWithText\", {\n        get: function () {\n            return underscore_1.find(this.lastSuggestions, function (suggestion) { return suggestion.text; });\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MagicBoxInstance.prototype, \"firstSuggestionText\", {\n        get: function () {\n            var firstSuggestionWithText = this.firstSuggestionWithText;\n            return firstSuggestionWithText ? firstSuggestionWithText.text : '';\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MagicBoxInstance.prototype.getResult = function () {\n        return this.result;\n    };\n    MagicBoxInstance.prototype.getDisplayedResult = function () {\n        return this.displayedResult;\n    };\n    MagicBoxInstance.prototype.setText = function (text) {\n        Dom_1.$$(this.element).toggleClass('magic-box-notEmpty', text.length > 0);\n        this.magicBoxClear.toggleTabindexAndAriaHidden(text.length > 0);\n        this.result = this.grammar.parse(text);\n        this.displayedResult = this.result.clean();\n        this.inputManager.setResult(this.displayedResult);\n    };\n    MagicBoxInstance.prototype.setCursor = function (index) {\n        this.inputManager.setCursor(index);\n    };\n    MagicBoxInstance.prototype.getCursor = function () {\n        return this.inputManager.getCursor();\n    };\n    MagicBoxInstance.prototype.resultAtCursor = function (match) {\n        return this.displayedResult.resultAt(this.getCursor(), match);\n    };\n    MagicBoxInstance.prototype.setupHandler = function () {\n        var _this = this;\n        this.inputManager.onblur = function () {\n            Dom_1.$$(_this.element).removeClass('magic-box-hasFocus');\n            _this.onblur && _this.onblur();\n            if (!_this.options.inline) {\n                _this.clearSuggestion();\n            }\n        };\n        this.inputManager.onfocus = function () {\n            Dom_1.$$(_this.element).addClass('magic-box-hasFocus');\n            _this.addSuggestions();\n            _this.onfocus && _this.onfocus();\n        };\n        this.inputManager.onkeydown = function (key) {\n            if (_this.shouldMoveInSuggestions(key)) {\n                return false;\n            }\n            if (key === Core_1.KEYBOARD.ENTER) {\n                var suggestion = _this.suggestionsManager.selectAndReturnKeyboardFocusedElement();\n                if (suggestion == null) {\n                    _this.onsubmit && _this.onsubmit();\n                }\n                return false;\n            }\n            else if (key === Core_1.KEYBOARD.ESCAPE) {\n                _this.clearSuggestion();\n                _this.blur();\n            }\n            else {\n                _this.suggestionsManager.clearKeyboardFocusedElement();\n            }\n            return true;\n        };\n        this.inputManager.onchangecursor = function () {\n            _this.addSuggestions();\n        };\n        this.inputManager.onkeyup = function (key) {\n            _this.onmove && _this.onmove();\n            if (!_this.shouldMoveInSuggestions(key)) {\n                return true;\n            }\n            switch (key) {\n                case Core_1.KEYBOARD.UP_ARROW:\n                    _this.suggestionsManager.moveUp();\n                    break;\n                case Core_1.KEYBOARD.DOWN_ARROW:\n                    _this.suggestionsManager.moveDown();\n                    break;\n                case Core_1.KEYBOARD.LEFT_ARROW:\n                    _this.suggestionsManager.moveLeft();\n                    break;\n                case Core_1.KEYBOARD.RIGHT_ARROW:\n                    _this.suggestionsManager.moveRight();\n                    break;\n            }\n            if (_this.suggestionsManager.selectedSuggestion) {\n                _this.focusOnSuggestion(_this.suggestionsManager.selectedSuggestion);\n            }\n            _this.onchange && _this.onchange();\n            return false;\n        };\n    };\n    MagicBoxInstance.prototype.addSuggestions = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var suggestions;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4 /*yield*/, this.suggestionsManager.receiveSuggestions(this.getSuggestions != null ? this.getSuggestions() : [])];\n                    case 1:\n                        suggestions = _a.sent();\n                        this.addSelectEventHandlers(suggestions);\n                        this.inputManager.setWordCompletion(this.firstSuggestionText);\n                        this.onSuggestions(suggestions);\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    MagicBoxInstance.prototype.shouldMoveInSuggestions = function (key) {\n        switch (key) {\n            case Core_1.KEYBOARD.UP_ARROW:\n            case Core_1.KEYBOARD.DOWN_ARROW:\n                return true;\n            case Core_1.KEYBOARD.LEFT_ARROW:\n            case Core_1.KEYBOARD.RIGHT_ARROW:\n                if (this.suggestionsManager.hasFocus && this.suggestionsManager.hasPreviews) {\n                    return true;\n                }\n        }\n        return false;\n    };\n    MagicBoxInstance.prototype.addSelectEventHandlers = function (suggestions) {\n        var _this = this;\n        underscore_1.each(suggestions, function (suggestion) {\n            if (suggestion.onSelect == null && suggestion.text != null) {\n                suggestion.onSelect = function () {\n                    _this.setText(suggestion.text);\n                    _this.onselect && _this.onselect(suggestion);\n                };\n            }\n        });\n    };\n    MagicBoxInstance.prototype.focus = function () {\n        Dom_1.$$(this.element).addClass('magic-box-hasFocus');\n        this.inputManager.focus();\n    };\n    MagicBoxInstance.prototype.blur = function () {\n        this.inputManager.blur();\n    };\n    MagicBoxInstance.prototype.clearSuggestion = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                this.inputManager.setWordCompletion(null);\n                this.suggestionsManager.clearSuggestions();\n                this.onSuggestions([]);\n                return [2 /*return*/];\n            });\n        });\n    };\n    MagicBoxInstance.prototype.focusOnSuggestion = function (suggestion) {\n        if (suggestion == null || suggestion.text == null) {\n            this.inputManager.setResult(this.displayedResult, this.firstSuggestionText);\n        }\n        else {\n            this.inputManager.setResult(this.grammar.parse(suggestion.text).clean(), suggestion.text);\n        }\n    };\n    MagicBoxInstance.prototype.getText = function () {\n        return this.inputManager.getValue();\n    };\n    MagicBoxInstance.prototype.getWordCompletion = function () {\n        return this.inputManager.getWordCompletion();\n    };\n    MagicBoxInstance.prototype.clear = function () {\n        this.setText('');\n        this.clearSuggestion();\n        this.focus();\n        this.onclear && this.onclear();\n    };\n    MagicBoxInstance.prototype.hasSuggestions = function () {\n        return this.suggestionsManager.hasSuggestions;\n    };\n    return MagicBoxInstance;\n}());\nexports.MagicBoxInstance = MagicBoxInstance;\nfunction createMagicBox(element, grammar, options) {\n    return new MagicBoxInstance(element, grammar, options);\n}\nexports.createMagicBox = createMagicBox;\nfunction requestAnimationFrame(callback) {\n    if ('requestAnimationFrame' in window) {\n        return window.requestAnimationFrame(callback);\n    }\n    return setTimeout(callback);\n}\nexports.requestAnimationFrame = requestAnimationFrame;\ndoMagicBoxExport_1.doMagicBoxExport();\n\n\n/***/ }),\n\n/***/ 223:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar _ = __webpack_require__(0);\nvar MagicBoxUtils = /** @class */ (function () {\n    function MagicBoxUtils() {\n    }\n    MagicBoxUtils.escapeRegExp = function (str) {\n        return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, '\\\\$&');\n    };\n    MagicBoxUtils.highlightText = function (text, highligth, ignoreCase, matchClass, doNotMatchClass) {\n        var _this = this;\n        if (ignoreCase === void 0) { ignoreCase = false; }\n        if (matchClass === void 0) { matchClass = 'magic-box-hightlight'; }\n        if (doNotMatchClass === void 0) { doNotMatchClass = ''; }\n        if (highligth.length == 0) {\n            return text;\n        }\n        var escaped = this.escapeRegExp(highligth);\n        var stringRegex = '(' + escaped + ')|(.*?(?=' + escaped + ')|.+)';\n        var regex = new RegExp(stringRegex, ignoreCase ? 'gi' : 'g');\n        return text.replace(regex, function (text, match, notmatch) { return _this.escapeText(match != null ? matchClass : doNotMatchClass, text); });\n    };\n    MagicBoxUtils.escapeText = function (classname, text) {\n        return \"<span class=\\\"\" + classname + \"\\\">\" + _.escape(text) + \"</span>\";\n    };\n    return MagicBoxUtils;\n}());\nexports.MagicBoxUtils = MagicBoxUtils;\n\n\n/***/ }),\n\n/***/ 282:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n        s = arguments[i];\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n            t[p] = s[p];\n    }\n    return t;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__webpack_require__(670);\nvar GlobalExports_1 = __webpack_require__(3);\nvar Dom_1 = __webpack_require__(1);\nvar SVGDom_1 = __webpack_require__(16);\nvar SVGIcons_1 = __webpack_require__(12);\nvar SearchBoxResize_1 = __webpack_require__(671);\nvar Component_1 = __webpack_require__(7);\nvar ComponentOptions_1 = __webpack_require__(8);\nvar Initialization_1 = __webpack_require__(2);\nvar Omnibox_1 = __webpack_require__(193);\nvar Querybox_1 = __webpack_require__(138);\nvar SearchButton_1 = __webpack_require__(195);\nvar underscore_1 = __webpack_require__(0);\n/**\n * The `Searchbox` component allows you to conveniently instantiate two components which end users frequently use to\n * enter and submit queries.\n *\n * This component attaches itself to a `div` element and takes care of instantiating either a\n * [`Querybox`]{@link Querybox} or an [`Omnibox`]{@link Omnibox} component (see the\n * [`enableOmnibox`]{@link Searchbox.options.enableOmnibox} option). Optionally, the `Searchbox` can also instantiate a\n * [`SearchButton`]{@link SearchButton} component, and append it inside the same `div` (see the\n * [`addSearchButton`]{@link Searchbox.options.addSearchButton} option).\n */\nvar Searchbox = /** @class */ (function (_super) {\n    __extends(Searchbox, _super);\n    /**\n     * Creates a new `Searchbox` component. Creates a new `Coveo.Magicbox` instance and wraps magic box methods (`onblur`,\n     * `onsubmit`, etc.). Binds event on `buildingQuery` and on redirection (for standalone box).\n     * @param element The HTMLElement on which to instantiate the component. This cannot be an HTMLInputElement for\n     * technical reasons.\n     * @param options The options for the `Searchbox component`. These will merge with the options from the component set\n     * directly on the `HTMLElement`.\n     * @param bindings The bindings that the component requires to function normally. If not set, these will be\n     * automatically resolved (with a slower execution time).\n     */\n    function Searchbox(element, options, bindings) {\n        var _this = _super.call(this, element, Searchbox.ID, bindings) || this;\n        _this.element = element;\n        _this.options = options;\n        _this.bindings = bindings;\n        _this.options = ComponentOptions_1.ComponentOptions.initComponentOptions(element, Searchbox, options);\n        if (_this.options.inline) {\n            Dom_1.$$(element).addClass('coveo-inline');\n        }\n        _this.initSearchBox();\n        _this.initSearchButton();\n        _this.applyMagicBoxIcon();\n        _this.applyCustomHeight();\n        return _this;\n    }\n    Searchbox.prototype.initSearchBox = function () {\n        var div = document.createElement('div');\n        this.element.appendChild(div);\n        if (this.options.enableOmnibox) {\n            this.searchbox = new Omnibox_1.Omnibox(div, this.options, this.bindings);\n        }\n        else {\n            this.searchbox = new Querybox_1.Querybox(div, this.options, this.bindings);\n        }\n    };\n    Searchbox.prototype.initSearchButton = function () {\n        if (!this.options.addSearchButton) {\n            return;\n        }\n        var anchor = Dom_1.$$('a');\n        this.element.appendChild(anchor.el);\n        this.searchButton = new SearchButton_1.SearchButton(anchor.el, { searchbox: this.searchbox }, this.bindings);\n    };\n    Searchbox.prototype.applyMagicBoxIcon = function () {\n        var magicBoxIcon = Dom_1.$$(this.element).find('.magic-box-icon');\n        magicBoxIcon.innerHTML = SVGIcons_1.SVGIcons.icons.mainClear;\n        SVGDom_1.SVGDom.addClassToSVGInContainer(magicBoxIcon, 'magic-box-clear-svg');\n    };\n    Searchbox.prototype.applyCustomHeight = function () {\n        if (!this.options.height) {\n            return;\n        }\n        Dom_1.$$(this.element).addClass('coveo-custom-height');\n        SearchBoxResize_1.SearchBoxResize.resize(this.element, this.options.height);\n    };\n    Searchbox.ID = 'Searchbox';\n    Searchbox.parent = Omnibox_1.Omnibox;\n    Searchbox.doExport = function () {\n        GlobalExports_1.exportGlobally({\n            Searchbox: Searchbox,\n            SearchButton: SearchButton_1.SearchButton,\n            Omnibox: Omnibox_1.Omnibox,\n            Querybox: Querybox_1.Querybox\n        });\n    };\n    /**\n     * Possible options for the {@link Searchbox}\n     * @componentOptions\n     */\n    Searchbox.options = {\n        /**\n         * Specifies whether to instantiate a [`SearchButton`]{@link SearchButton} component.\n         *\n         * Default value is `true`.\n         */\n        addSearchButton: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: true }),\n        /**\n         * A custom height for the search box (in pixels).\n         *\n         * Note: Avoid setting this option if you want to modify the search box styling through custom CSS.\n         *\n         * Minimum value is `25`\n         *\n         * Default behavior: The most specific CSS rules targeting HTML elements generated by the Searchbox component are used\n         * (e.g., if you are only using the default CoveoFullSearch.css stylesheet with no further styling customizations,\n         * the search box height will be set to 50 pixels by default).\n         *\n         * @availablesince [July 2019 Release (v2.6459)](https://docs.coveo.com/en/2938/)\n         */\n        height: ComponentOptions_1.ComponentOptions.buildNumberOption({ min: 25 }),\n        /**\n         * Specifies whether to instantiate an [`Omnibox`]{@link Omnibox} component.\n         *\n         * When this option is `false`, the `Searchbox` instantiates a [`Querybox`]{@link Querybox} component instead.\n         *\n         * **Note:**\n         * > You can use configuration options specific to the component you choose to instantiate with the `Searchbox`.\n         *\n         * **Examples:**\n         *\n         * In this first case, the `Searchbox` instantiates a `Querybox` component. You can configure this `Querybox`\n         * instance using any of the `Querybox` component options, such as\n         * [`triggerQueryOnClear`]{@link Querybox.options.triggerQueryOnClear}.\n         * ```html\n         * <div class='CoveoSearchbox' data-trigger-query-on-clear='true'></div>\n         * ```\n         *\n         * In this second case, the `Searchbox` instantiates an `Omnibox` component. You can configure this `Omnibox`\n         * instance using any of the `Omnibox` component options, such as\n         * [`placeholder`]{@link Omnibox.options.placeholder}.\n         * Moreover, since the `Omnibox` component inherits all of the `Querybox` component options, the\n         * `data-trigger-query-on-clear` option from the previous example would also work on this `Omnibox` instance.\n         * ```html\n         * <div class='CoveoSearchbox' data-enable-omnibox='true' data-placeholder='Please enter a query'></div>\n         * ```\n         *\n         * Default value is `true`.\n         */\n        enableOmnibox: ComponentOptions_1.ComponentOptions.buildBooleanOption({ defaultValue: true })\n    };\n    return Searchbox;\n}(Component_1.Component));\nexports.Searchbox = Searchbox;\nSearchbox.options = __assign({}, Searchbox.options, Omnibox_1.Omnibox.options, Querybox_1.Querybox.options);\n// Only parse omnibox option if omnibox is enabled\nunderscore_1.each(Searchbox.options, function (value, key) {\n    if (key in Omnibox_1.Omnibox.options && !(key in Querybox_1.Querybox.options)) {\n        Searchbox.options[key] = underscore_1.extend({ depend: 'enableOmnibox' }, value);\n    }\n});\nInitialization_1.Initialization.registerAutoCreateComponent(Searchbox);\n\n\n/***/ }),\n\n/***/ 492:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Result_1 = __webpack_require__(52);\nvar RefResult_1 = __webpack_require__(493);\nvar ExpressionEndOfInput_1 = __webpack_require__(218);\nvar _ = __webpack_require__(0);\nvar ExpressionRef = /** @class */ (function () {\n    function ExpressionRef(ref, occurrence, id, grammar) {\n        this.ref = ref;\n        this.occurrence = occurrence;\n        this.id = id;\n        this.grammar = grammar;\n    }\n    ExpressionRef.prototype.parse = function (input, end) {\n        var ref = this.grammar.getExpression(this.ref);\n        if (ref == null) {\n            throw new Error('Expression not found:' + this.ref);\n        }\n        if (this.occurrence == '?' || this.occurrence == null) {\n            return this.parseOnce(input, end, ref);\n        }\n        else {\n            return this.parseMany(input, end, ref);\n        }\n    };\n    ExpressionRef.prototype.parseOnce = function (input, end, ref) {\n        var refResult = ref.parse(input, end);\n        var success = refResult.isSuccess();\n        if (!success && this.occurrence == '?') {\n            if (end) {\n                // if end was found\n                if (input.length == 0) {\n                    return new RefResult_1.RefResult([], this, input, refResult);\n                }\n                // if end was not found and all error expression are EndOfInput, reparse with end = false.\n                if (_.all(refResult.getBestExpect(), function (expect) { return expect.expression == ExpressionEndOfInput_1.ExpressionEndOfInput; })) {\n                    return new RefResult_1.RefResult([new Result_1.Result(null, ExpressionEndOfInput_1.ExpressionEndOfInput, input)], this, input, refResult);\n                }\n                return refResult;\n            }\n            // the ref is not required and it do not need to end the input\n            return new RefResult_1.RefResult([], this, input, null);\n        }\n        return new RefResult_1.RefResult([refResult], this, input, success ? null : refResult);\n    };\n    ExpressionRef.prototype.parseMany = function (input, end, ref) {\n        var subResults = [];\n        var subResult;\n        var subInput = input;\n        var success;\n        // try to parse until it do not match, do not manage the end yet\n        do {\n            subResult = ref.parse(subInput, false);\n            success = subResult.isSuccess();\n            if (success) {\n                subResults.push(subResult);\n                subInput = subInput.substr(subResult.getLength());\n            }\n        } while (success && subResult.input != subInput);\n        // minimal occurance of a ref\n        var requiredOccurance = _.isNumber(this.occurrence) ? this.occurrence : this.occurrence == '+' ? 1 : 0;\n        // if the minimal occurance is not reached add the fail result to the list\n        if (subResults.length < requiredOccurance) {\n            subResults.push(subResult);\n        }\n        else if (end) {\n            // if there is at least one match, check if the last match is at the end\n            if (subResults.length > 0) {\n                var last = _.last(subResults);\n                subResult = ref.parse(last.input, true);\n                if (subResult.isSuccess()) {\n                    // if successful, replace the last subResult by the one with end\n                    subResults[subResults.length - 1] = subResult;\n                }\n                else {\n                    // if not successful, we keep the last successful result and we add a endOfInputExpected Result after it\n                    subResults.push(new Result_1.Result(null, ExpressionEndOfInput_1.ExpressionEndOfInput, last.input.substr(last.getLength())));\n                    // we parse back the last with the length of the successful Result (at the same place we put the endOfInputExpected) and put it in failAttempt\n                    subResult = ref.parse(last.input.substr(last.getLength()), true);\n                }\n            }\n            else if (input.length != 0) {\n                // if there is no result at all and we are not at the end, return a endOfInputExpected Result\n                var endOfInput = new Result_1.Result(null, ExpressionEndOfInput_1.ExpressionEndOfInput, input);\n                return new RefResult_1.RefResult([endOfInput], this, input, subResult);\n            }\n        }\n        return new RefResult_1.RefResult(subResults, this, input, subResult);\n    };\n    ExpressionRef.prototype.toString = function () {\n        return this.id;\n    };\n    return ExpressionRef;\n}());\nexports.ExpressionRef = ExpressionRef;\n\n\n/***/ }),\n\n/***/ 493:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Result_1 = __webpack_require__(52);\nvar _ = __webpack_require__(0);\nvar RefResult = /** @class */ (function (_super) {\n    __extends(RefResult, _super);\n    function RefResult(results, expression, input, lastResult) {\n        var _this = _super.call(this, results, expression, input) || this;\n        _this.expression = expression;\n        _this.input = input;\n        if (_.last(results) != lastResult) {\n            _this.failAttempt = lastResult;\n            if (_this.failAttempt != null) {\n                _this.failAttempt.parent = _this;\n            }\n        }\n        return _this;\n    }\n    /**\n     * Return all fail result.\n     */\n    RefResult.prototype.getExpect = function () {\n        var expect = _super.prototype.getExpect.call(this);\n        // add the failAttempt to the expect\n        if (this.failAttempt != null) {\n            return expect.concat(this.failAttempt.getExpect());\n        }\n        return expect;\n    };\n    /**\n     * Clean the result to have the most relevant result. If the result is successful just return a clone of it.\n     */\n    RefResult.prototype.clean = function (path) {\n        // if there is no failAttempt, we will use the default clean\n        if (this.failAttempt != null && (path != null || !this.isSuccess())) {\n            path = path || _.last(this.getBestExpect()).path(this);\n            var next = _.first(path);\n            // if the next is in the subResults, not the failAttempt, do the default clean;\n            if (next != null && next == this.failAttempt) {\n                var last = _.last(this.subResults);\n                // if the last is not successful, remove it because we want the failAttempt path\n                var subResults = _.map(last != null && last.isSuccess() ? this.subResults : _.initial(this.subResults), function (subResult) {\n                    return subResult.clean();\n                });\n                subResults.push(next.clean(_.rest(path)));\n                return new Result_1.Result(subResults, this.expression, this.input);\n            }\n        }\n        return _super.prototype.clean.call(this, path);\n    };\n    return RefResult;\n}(Result_1.Result));\nexports.RefResult = RefResult;\n\n\n/***/ }),\n\n/***/ 494:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar OptionResult_1 = __webpack_require__(495);\nvar ExpressionOptions = /** @class */ (function () {\n    function ExpressionOptions(parts, id) {\n        this.parts = parts;\n        this.id = id;\n    }\n    ExpressionOptions.prototype.parse = function (input, end) {\n        var failAttempt = [];\n        for (var i = 0; i < this.parts.length; i++) {\n            var subResult = this.parts[i].parse(input, end);\n            if (subResult.isSuccess()) {\n                return new OptionResult_1.OptionResult(subResult, this, input, failAttempt);\n            }\n            failAttempt.push(subResult);\n        }\n        return new OptionResult_1.OptionResult(null, this, input, failAttempt);\n    };\n    ExpressionOptions.prototype.toString = function () {\n        return this.id;\n    };\n    return ExpressionOptions;\n}());\nexports.ExpressionOptions = ExpressionOptions;\n\n\n/***/ }),\n\n/***/ 495:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Result_1 = __webpack_require__(52);\nvar _ = __webpack_require__(0);\nvar OptionResult = /** @class */ (function (_super) {\n    __extends(OptionResult, _super);\n    function OptionResult(result, expression, input, failAttempt) {\n        var _this = _super.call(this, result != null ? [result] : null, expression, input) || this;\n        _this.result = result;\n        _this.expression = expression;\n        _this.input = input;\n        _this.failAttempt = failAttempt;\n        _.forEach(_this.failAttempt, function (subResult) {\n            subResult.parent = _this;\n        });\n        return _this;\n    }\n    /**\n     * Return all fail result.\n     */\n    OptionResult.prototype.getExpect = function () {\n        var _this = this;\n        var expect = [];\n        if (this.result != null) {\n            expect = this.result.getExpect();\n        }\n        expect = _.reduce(this.failAttempt, function (expect, result) { return expect.concat(result.getExpect()); }, expect);\n        if (expect.length > 0 && _.all(expect, function (result) { return result.input == _this.input; })) {\n            return [this];\n        }\n        return expect;\n    };\n    /**\n     * Clean the result to have the most relevant result. If the result is successful just return a clone of it.\n     */\n    OptionResult.prototype.clean = function (path) {\n        if (path != null || !this.isSuccess()) {\n            // Result will be a ref. We skip it for cleaner tree.\n            path = _.rest(path || _.last(this.getBestExpect()).path(this));\n            // next can be Result or one of the failAttempt. In both case we have only one child\n            var next = _.first(path);\n            if (next == null) {\n                return new Result_1.Result(null, this.expression, this.input);\n            }\n            return new Result_1.Result([next.clean(_.rest(path))], this.expression, this.input);\n        }\n        // Result will be a ref. We skip it for cleaner tree.\n        return new Result_1.Result(_.map(this.result.subResults, function (subResult) { return subResult.clean(); }), this.expression, this.input);\n    };\n    return OptionResult;\n}(Result_1.Result));\nexports.OptionResult = OptionResult;\n\n\n/***/ }),\n\n/***/ 496:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Result_1 = __webpack_require__(52);\nvar Result_2 = __webpack_require__(52);\nvar ExpressionRegExp = /** @class */ (function () {\n    function ExpressionRegExp(value, id, grammar) {\n        this.value = value;\n        this.id = id;\n    }\n    ExpressionRegExp.prototype.parse = function (input, end) {\n        var groups = input.match(this.value);\n        // if the RegExp do not match at the start, ignore it\n        if (groups != null && groups.index != 0) {\n            groups = null;\n        }\n        var result = new Result_1.Result(groups != null ? groups[0] : null, this, input);\n        // if is successful and we require the end but the length of parsed is\n        // lower than the input length, return a EndOfInputExpected Result\n        if (result.isSuccess() && end && input.length > result.value.length) {\n            return new Result_2.EndOfInputResult(result);\n        }\n        return result;\n    };\n    ExpressionRegExp.prototype.toString = function () {\n        return this.id;\n    };\n    return ExpressionRegExp;\n}());\nexports.ExpressionRegExp = ExpressionRegExp;\n\n\n/***/ }),\n\n/***/ 497:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ExpressionFunction = /** @class */ (function () {\n    function ExpressionFunction(func, id, grammar) {\n        this.func = func;\n        this.id = id;\n        this.grammar = grammar;\n    }\n    ExpressionFunction.prototype.parse = function (input, end) {\n        return this.func(input, end, this);\n    };\n    ExpressionFunction.prototype.toString = function () {\n        return this.id;\n    };\n    return ExpressionFunction;\n}());\nexports.ExpressionFunction = ExpressionFunction;\n\n\n/***/ }),\n\n/***/ 498:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Result_1 = __webpack_require__(52);\nvar ExpressionList = /** @class */ (function () {\n    function ExpressionList(parts, id) {\n        this.parts = parts;\n        this.id = id;\n        if (parts.length == 0) {\n            throw new Error(JSON.stringify(id) + ' should have at least 1 parts');\n        }\n    }\n    ExpressionList.prototype.parse = function (input, end) {\n        var subResults = [];\n        var subResult;\n        var subInput = input;\n        for (var i = 0; i < this.parts.length; i++) {\n            var part = this.parts[i];\n            subResult = part.parse(subInput, end && i == this.parts.length - 1);\n            subResults.push(subResult);\n            // if the subResult do not succeed, stop the parsing\n            if (!subResult.isSuccess()) {\n                break;\n            }\n            else {\n                subInput = subInput.substr(subResult.getLength());\n            }\n        }\n        return new Result_1.Result(subResults, this, input);\n    };\n    ExpressionList.prototype.toString = function () {\n        return this.id;\n    };\n    return ExpressionList;\n}());\nexports.ExpressionList = ExpressionList;\n\n\n/***/ }),\n\n/***/ 499:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Field_1 = __webpack_require__(220);\nexports.NestedQuery = {\n    basicExpressions: ['NestedQuery'],\n    grammars: {\n        NestedQuery: '[[NestedField][OptionalSpaces][Expressions]]',\n        NestedField: '[[Field]]',\n        FieldValue: ['NestedQuery']\n    },\n    include: [Field_1.Field]\n};\n\n\n/***/ }),\n\n/***/ 500:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Basic_1 = __webpack_require__(132);\nexports.Date = {\n    grammars: {\n        Date: '[DateYear]/[DateMonth]/[DateDay]',\n        DateYear: /([0-9]{4})/,\n        DateMonth: /(1[0-2]|0?[1-9])/,\n        DateDay: /([1-2][0-9]|3[0-1]|0?[1-9])/,\n        DateRange: '[Date][Spaces?]..[Spaces?][Date]',\n        DateRelative: ['DateRelativeNegative', 'DateRelativeTerm'],\n        DateRelativeTerm: /now|today|yesterday/,\n        DateRelativeNegative: '[DateRelativeTerm][DateRelativeNegativeRef]',\n        DateRelativeNegativeRef: /([\\-\\+][0-9]+(s|m|h|d|mo|y))/\n    },\n    include: [Basic_1.Basic]\n};\n\n\n/***/ }),\n\n/***/ 501:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Basic_1 = __webpack_require__(132);\nexports.QueryExtension = {\n    basicExpressions: ['QueryExtension'],\n    grammars: {\n        QueryExtension: '$[QueryExtensionName]([QueryExtensionArguments])',\n        QueryExtensionName: /\\w+/,\n        QueryExtensionArguments: '[QueryExtensionArgumentList*][QueryExtensionArgument]',\n        QueryExtensionArgumentList: '[QueryExtensionArgument][Spaces?],[Spaces?]',\n        QueryExtensionArgument: '[QueryExtensionArgumentName]:[Spaces?][QueryExtensionArgumentValue]',\n        QueryExtensionArgumentName: /\\w+/,\n        QueryExtensionArgumentValue: ['SingleQuoted', 'Expressions']\n    },\n    include: [Basic_1.Basic]\n};\n\n\n/***/ }),\n\n/***/ 502:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SubExpression = {\n    basicExpressions: ['SubExpression'],\n    grammars: {\n        SubExpression: '([Expressions])'\n    }\n};\n\n\n/***/ }),\n\n/***/ 503:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar _ = __webpack_require__(0);\nvar Core_1 = __webpack_require__(20);\nvar Strings_1 = __webpack_require__(6);\nvar Dom_1 = __webpack_require__(1);\nvar KeyboardUtils_1 = __webpack_require__(25);\nvar InputManager = /** @class */ (function () {\n    function InputManager(element, onchange, magicBox) {\n        this.onchange = onchange;\n        this.magicBox = magicBox;\n        this.hasFocus = false;\n        this.root = Core_1.Component.resolveRoot(element);\n        this.underlay = document.createElement('div');\n        this.underlay.className = 'magic-box-underlay';\n        this.highlightContainer = document.createElement('span');\n        this.highlightContainer.className = 'magic-box-highlight-container';\n        this.underlay.appendChild(this.highlightContainer);\n        this.ghostTextContainer = document.createElement('span');\n        this.ghostTextContainer.className = 'magic-box-ghost-text';\n        this.underlay.appendChild(this.ghostTextContainer);\n        this.input = Dom_1.$$(element).find('input');\n        if (!this.input) {\n            this.input = document.createElement('input');\n            element.appendChild(this.underlay);\n            element.appendChild(this.input);\n        }\n        else {\n            element.insertBefore(this.underlay, this.input);\n        }\n        this.setupHandler();\n        this.addAccessibilitiesProperties();\n    }\n    Object.defineProperty(InputManager.prototype, \"expanded\", {\n        set: function (isExpanded) {\n            this.input.setAttribute('aria-expanded', isExpanded.toString());\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(InputManager.prototype, \"activeDescendant\", {\n        set: function (element) {\n            if (element) {\n                this.input.setAttribute('aria-activedescendant', element.id);\n            }\n            else {\n                this.input.removeAttribute('aria-activedescendant');\n            }\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Update the input with the result value\n     */\n    InputManager.prototype.updateInput = function () {\n        if (this.input.value != this.result.input) {\n            this.input.value = this.result.input;\n            if (this.hasFocus) {\n                this.setCursor(this.getValue().length);\n            }\n        }\n    };\n    /**\n     * Update the highlight with the result value\n     */\n    InputManager.prototype.updateHighlight = function () {\n        Dom_1.$$(this.highlightContainer).empty();\n        this.highlightContainer.appendChild(this.result.toHtmlElement());\n    };\n    /**\n     * Update the ghostText with the wordCompletion\n     */\n    InputManager.prototype.updateWordCompletion = function () {\n        Dom_1.$$(this.ghostTextContainer).empty();\n        this.ghostTextContainer.innerHTML = '';\n        if (this.wordCompletion != null) {\n            this.ghostTextContainer.appendChild(document.createTextNode(this.wordCompletion.substr(this.result.input.length)));\n        }\n    };\n    /**\n     * Set the result and update visual if needed\n     */\n    InputManager.prototype.setResult = function (result, wordCompletion) {\n        this.result = result;\n        this.updateInput();\n        this.updateHighlight();\n        // reuse last wordCompletion for a better visual\n        if (_.isUndefined(wordCompletion) && this.wordCompletion != null && this.wordCompletion.indexOf(this.result.input) == 0) {\n            this.updateWordCompletion();\n        }\n        else {\n            this.setWordCompletion(wordCompletion);\n        }\n        this.updateScroll();\n    };\n    /**\n     * Set the word completion. will be ignore if the word completion do not start with the result input\n     */\n    InputManager.prototype.setWordCompletion = function (wordCompletion) {\n        if (wordCompletion != null && wordCompletion.toLowerCase().indexOf(this.result.input.toLowerCase()) != 0) {\n            wordCompletion = null;\n        }\n        this.wordCompletion = wordCompletion;\n        this.updateWordCompletion();\n        this.updateScroll();\n    };\n    /**\n     * Set cursor position\n     */\n    InputManager.prototype.setCursor = function (index) {\n        this.input.focus();\n        if (this.input.createTextRange) {\n            var range = this.input.createTextRange();\n            range.move('character', index);\n            range.select();\n        }\n        else if (this.input.selectionStart != null) {\n            this.input.focus();\n            this.input.setSelectionRange(index, index);\n        }\n    };\n    InputManager.prototype.getCursor = function () {\n        return this.input.selectionStart;\n    };\n    InputManager.prototype.updateScroll = function (defer) {\n        var _this = this;\n        if (defer === void 0) { defer = true; }\n        var callback = function () {\n            // this is the cheapest call we can do before update scroll\n            if (_this.underlay.clientWidth < _this.underlay.scrollWidth) {\n                _this.underlay.style.visibility = 'hidden';\n                _this.underlay.scrollLeft = _this.input.scrollLeft;\n                _this.underlay.scrollTop = _this.input.scrollTop;\n                _this.underlay.style.visibility = 'visible';\n            }\n            _this.updateScrollDefer = null;\n            // one day we will have to remove this\n            if (_this.hasFocus) {\n                _this.updateScroll();\n            }\n        };\n        // sometime we want it to be updated as soon as posible to have no flickering\n        if (!defer) {\n            callback();\n        }\n        else if (this.updateScrollDefer == null) {\n            this.updateScrollDefer = requestAnimationFrame(callback);\n        }\n    };\n    InputManager.prototype.setupHandler = function () {\n        var _this = this;\n        this.input.onblur = function () {\n            _this.hasFocus = false;\n            setTimeout(function () {\n                if (!_this.hasFocus) {\n                    _this.onblur && _this.onblur();\n                }\n            }, 300);\n            _this.updateScroll();\n        };\n        this.input.onfocus = function () {\n            if (!_this.hasFocus) {\n                _this.hasFocus = true;\n                _this.updateScroll();\n                _this.onfocus && _this.onfocus();\n            }\n        };\n        this.input.onkeydown = function (e) {\n            _this.keydown(e);\n        };\n        this.input.onkeyup = function (e) {\n            _this.keyup(e);\n        };\n        this.input.oncut = function () {\n            setTimeout(function () {\n                _this.onInputChange();\n            });\n        };\n        this.input.onpaste = function () {\n            setTimeout(function () {\n                _this.onInputChange();\n            });\n        };\n    };\n    InputManager.prototype.addAccessibilitiesProperties = function () {\n        this.input.setAttribute('autocomplete', 'off');\n        this.input.setAttribute('type', 'text');\n        this.input.setAttribute('role', 'combobox');\n        this.input.setAttribute('form', 'coveo-dummy-form');\n        this.input.setAttribute('aria-autocomplete', 'list');\n        this.input.setAttribute('title', Strings_1.l('InsertAQuery') + \". \" + Strings_1.l('PressEnterToSend'));\n    };\n    InputManager.prototype.focus = function () {\n        var _this = this;\n        // neet a timeout for IE8-9\n        setTimeout(function () {\n            _this.input.focus();\n            _this.setCursor(_this.getValue().length);\n        });\n    };\n    InputManager.prototype.blur = function () {\n        if (this.hasFocus) {\n            this.input.blur();\n        }\n    };\n    InputManager.prototype.keydown = function (e) {\n        var _this = this;\n        switch (e.keyCode || e.which) {\n            case KeyboardUtils_1.KEYBOARD.TAB:\n                // Take care of not \"preventing\" the default event behaviour : For accessibility reasons, it is much simpler\n                // to simply let the browser do it's standard action (which is to focus out of the input).\n                // Instead, handle \"tabPress\" immediately instead of \"keyup\".\n                // The focus will be on the next element in the page when the key is released, so keyup on the input will never be triggered.\n                this.tabPress();\n                this.magicBox.clearSuggestion();\n                break;\n            default:\n                e.stopPropagation();\n                if (this.onkeydown == null || this.onkeydown(e.keyCode || e.which)) {\n                    requestAnimationFrame(function () {\n                        _this.onInputChange();\n                    });\n                }\n                else {\n                    e.preventDefault();\n                }\n                break;\n        }\n    };\n    InputManager.prototype.keyup = function (e) {\n        switch (e.keyCode || e.which) {\n            case KeyboardUtils_1.KEYBOARD.LEFT_ARROW:\n            case KeyboardUtils_1.KEYBOARD.RIGHT_ARROW:\n                this.handleLeftRightArrow(e);\n                break;\n            default:\n                if (this.onkeydown == null || this.onkeyup(e.keyCode || e.which)) {\n                    this.onInputChange();\n                }\n                else {\n                    e.preventDefault();\n                }\n                break;\n        }\n    };\n    InputManager.prototype.handleLeftRightArrow = function (e) {\n        var querySuggestPreview = Dom_1.$$(this.root).find(\".\" + Core_1.Component.computeCssClassNameForType('QuerySuggestPreview'));\n        if (!querySuggestPreview) {\n            this.onchangecursor();\n        }\n        var inputChanged = this.onkeydown == null || this.onkeyup(e.keyCode || e.which);\n        inputChanged ? this.onInputChange() : e.preventDefault();\n    };\n    InputManager.prototype.tabPress = function () {\n        this.ontabpress && this.ontabpress();\n        this.onblur && this.onblur();\n    };\n    InputManager.prototype.onInputChange = function () {\n        if (this.result.input != this.input.value) {\n            this.onchange(this.input.value, false);\n        }\n    };\n    InputManager.prototype.getValue = function () {\n        return this.input.value;\n    };\n    InputManager.prototype.getWordCompletion = function () {\n        return this.wordCompletion;\n    };\n    return InputManager;\n}());\nexports.InputManager = InputManager;\n\n\n/***/ }),\n\n/***/ 504:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n        s = arguments[i];\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n            t[p] = s[p];\n    }\n    return t;\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [0, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar underscore_1 = __webpack_require__(0);\nvar ProcessingStatus;\n(function (ProcessingStatus) {\n    ProcessingStatus[ProcessingStatus[\"Finished\"] = 0] = \"Finished\";\n    ProcessingStatus[ProcessingStatus[\"TimedOut\"] = 1] = \"TimedOut\";\n    ProcessingStatus[ProcessingStatus[\"Overriden\"] = 2] = \"Overriden\";\n})(ProcessingStatus = exports.ProcessingStatus || (exports.ProcessingStatus = {}));\n/**\n * IE11 equivalent of Promise.race\n * Adapted from Promise.race(iterable) polyfill on https://www.promisejs.org/api/\n */\nfunction racePromises(promises) {\n    return new Promise(function (resolve, reject) { return promises.forEach(function (value) { return Promise.resolve(value).then(resolve, reject); }); });\n}\nvar QueryProcessor = /** @class */ (function () {\n    function QueryProcessor(options) {\n        if (options === void 0) { options = {}; }\n        this.options = __assign({ timeout: 500 }, options);\n    }\n    /**\n     * Overrides the previous queries and accumulates the result of promise arrays with a timeout.\n     */\n    QueryProcessor.prototype.processQueries = function (queries) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _this = this;\n            var asyncQueries;\n            return __generator(this, function (_a) {\n                this.overrideIfProcessing();\n                this.processedResults = new Array(queries.length);\n                asyncQueries = queries.map(function (query) { return (query instanceof Promise ? query : Promise.resolve(query)); });\n                return [2 /*return*/, racePromises([\n                        this.accumulateResultsChronologically(asyncQueries).then(function () { return _this.buildProcessResults(ProcessingStatus.Finished); }),\n                        this.waitForOverride().then(function () { return _this.buildProcessResults(ProcessingStatus.Overriden); }),\n                        this.waitForTimeout().then(function () { return _this.buildProcessResults(ProcessingStatus.TimedOut); })\n                    ])];\n            });\n        });\n    };\n    QueryProcessor.prototype.overrideIfProcessing = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                if (this.override) {\n                    this.override();\n                }\n                return [2 /*return*/];\n            });\n        });\n    };\n    Object.defineProperty(QueryProcessor.prototype, \"orderedResults\", {\n        get: function () {\n            return underscore_1.flatten(this.processedResults.filter(function (result) { return !!result; }), true);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    QueryProcessor.prototype.buildProcessResults = function (status) {\n        return {\n            status: status,\n            results: status !== ProcessingStatus.Overriden ? this.orderedResults : []\n        };\n    };\n    QueryProcessor.prototype.accumulateResultsChronologically = function (queries) {\n        return __awaiter(this, void 0, void 0, function () {\n            var output;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        output = this.processedResults;\n                        return [4 /*yield*/, Promise.all(queries.map(function (query, i) { return query.then(function (items) { return (output[i] = items); }); }))];\n                    case 1:\n                        _a.sent();\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    QueryProcessor.prototype.waitForOverride = function () {\n        var _this = this;\n        return new Promise(function (resolve) {\n            _this.override = function () {\n                _this.override = null;\n                resolve();\n            };\n        });\n    };\n    QueryProcessor.prototype.waitForTimeout = function () {\n        var _this = this;\n        return new Promise(function (resolve) { return setTimeout(function () { return resolve(); }, _this.options.timeout); });\n    };\n    return QueryProcessor;\n}());\nexports.QueryProcessor = QueryProcessor;\n\n\n/***/ }),\n\n/***/ 507:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar NestedQuery_1 = __webpack_require__(499);\nvar QueryExtension_1 = __webpack_require__(501);\nvar Basic_1 = __webpack_require__(132);\nvar Field_1 = __webpack_require__(220);\nvar SubExpression_1 = __webpack_require__(502);\nexports.Complete = {\n    include: [NestedQuery_1.NestedQuery, QueryExtension_1.QueryExtension, SubExpression_1.SubExpression, Field_1.Field, Basic_1.Basic]\n};\n\n\n/***/ }),\n\n/***/ 508:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Grammar_1 = __webpack_require__(176);\nvar _ = __webpack_require__(0);\nfunction loadSubGrammar(expressions, basicExpressions, grammars, subGrammar) {\n    _.each(subGrammar.expressions, function (expression) {\n        if (!_.contains(expressions, expression)) {\n            expressions.push(expression);\n        }\n    });\n    _.each(subGrammar.basicExpressions, function (expression) {\n        if (!_.contains(basicExpressions, expression)) {\n            basicExpressions.push(expression);\n        }\n    });\n    _.each(subGrammar.grammars, function (expressionDef, id) {\n        if (!(id in grammars)) {\n            grammars[id] = expressionDef;\n        }\n        else {\n            if (_.isArray(grammars[id]) && _.isArray(expressionDef)) {\n                _.each(expressionDef, function (value) {\n                    grammars[id].push(value);\n                });\n            }\n            else {\n                _.each(expressionDef, function (value) {\n                    grammars[id].push(value);\n                });\n                throw new Error('Can not merge ' + id + '(' + JSON.stringify(expressionDef) + ' => ' + JSON.stringify(grammars[id]) + ')');\n            }\n        }\n    });\n}\nfunction Expressions() {\n    var subGrammars = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        subGrammars[_i] = arguments[_i];\n    }\n    var expressions = [];\n    var BasicExpression = [];\n    var grammars = {\n        Start: ['Expressions', 'Empty'],\n        Expressions: '[OptionalSpaces][Expression][ExpressionsList*][OptionalSpaces]',\n        ExpressionsList: '[Spaces][Expression]',\n        Expression: expressions,\n        BasicExpression: BasicExpression,\n        OptionalSpaces: / */,\n        Spaces: / +/,\n        Empty: /(?!.)/\n    };\n    for (var i = 0; i < subGrammars.length; i++) {\n        loadSubGrammar(expressions, BasicExpression, grammars, subGrammars[i]);\n        _.each(subGrammars[i].include, function (subGrammar) {\n            if (!_.contains(subGrammars, subGrammar)) {\n                subGrammars.push(subGrammar);\n            }\n        });\n    }\n    expressions.push('BasicExpression');\n    return {\n        start: 'Start',\n        expressions: grammars\n    };\n}\nexports.Expressions = Expressions;\nfunction ExpressionsGrammar() {\n    var subGrammars = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        subGrammars[_i] = arguments[_i];\n    }\n    var grammar = Expressions.apply(this, subGrammars);\n    return new Grammar_1.Grammar(grammar.start, grammar.expressions);\n}\nexports.ExpressionsGrammar = ExpressionsGrammar;\n\n\n/***/ }),\n\n/***/ 509:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Those are the string definitions of events for ResultPreviewsManager.\n *\n * Those events should be bound to the element returned by `resolveRoot`.\n */\nvar ResultPreviewsManagerEvents = /** @class */ (function () {\n    function ResultPreviewsManagerEvents() {\n    }\n    /**\n     * Executed when building a query to fetch result previews.\n     * This always receives {@link IBuildingResultPreviewsQueryEventArgs} as arguments.\n     */\n    ResultPreviewsManagerEvents.buildingResultPreviewsQuery = 'buildingResultPreviewsQuery';\n    /**\n     * Executed when a {@link Suggestion} is focused before {@link PopulateSearchResultPreviews} is called to fetch more options.\n     * This always receives {@link IUpdateResultPreviewsManagerOptionsEventArgs} as arguments.\n     */\n    ResultPreviewsManagerEvents.updateResultPreviewsManagerOptions = 'updateResultPreviewsManagerOptions';\n    /**\n     * Executed when a {@link Suggestion} is focused and waiting for search result previews.\n     * This always receives {@link IPopulateSearchResultPreviewsEventArgs} as arguments.\n     */\n    ResultPreviewsManagerEvents.populateSearchResultPreviews = 'populateSearchResultPreviews';\n    return ResultPreviewsManagerEvents;\n}());\nexports.ResultPreviewsManagerEvents = ResultPreviewsManagerEvents;\n\n\n/***/ }),\n\n/***/ 510:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __assign = (this && this.__assign) || Object.assign || function(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n        s = arguments[i];\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n            t[p] = s[p];\n    }\n    return t;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ComponentOptionsModel_1 = __webpack_require__(28);\nvar QueryboxOptionsProcessing = /** @class */ (function () {\n    function QueryboxOptionsProcessing(owner) {\n        this.owner = owner;\n    }\n    Object.defineProperty(QueryboxOptionsProcessing.prototype, \"options\", {\n        get: function () {\n            return this.owner.options;\n        },\n        set: function (options) {\n            this.owner.options = options;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    QueryboxOptionsProcessing.prototype.postProcess = function () {\n        this.options = __assign({}, this.options, this.owner.componentOptionsModel.get(ComponentOptionsModel_1.ComponentOptionsModel.attributesEnum.searchBox));\n        this.processQueryOnClearVersusEmptyQuery();\n        this.processQueryOnClearVersusSearchAsYouType();\n    };\n    QueryboxOptionsProcessing.prototype.processQueryOnClearVersusEmptyQuery = function () {\n        if (this.options.triggerQueryOnClear && this.owner.searchInterface.options.allowQueriesWithoutKeywords === false) {\n            this.owner.logger.warn('Forcing option triggerQueryOnClear to false, as it is not supported when the search interface is configured to not allow queries without keywords (data-allow-queries-without-keywords=\"false\")', this.owner);\n            this.options.triggerQueryOnClear = false;\n        }\n    };\n    QueryboxOptionsProcessing.prototype.processQueryOnClearVersusSearchAsYouType = function () {\n        if (this.owner.searchInterface.options.allowQueriesWithoutKeywords === true &&\n            this.options.triggerQueryOnClear === false &&\n            this.options.enableSearchAsYouType === true) {\n            this.owner.logger.warn('Forcing option triggerQueryOnClear to true, since search-as-you-type is enabled', this.owner);\n            this.options.triggerQueryOnClear = true;\n        }\n    };\n    return QueryboxOptionsProcessing;\n}());\nexports.QueryboxOptionsProcessing = QueryboxOptionsProcessing;\n\n\n/***/ }),\n\n/***/ 52:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ExpressionEndOfInput_1 = __webpack_require__(218);\nvar ExpressionConstant_1 = __webpack_require__(219);\nvar _ = __webpack_require__(0);\nvar Result = /** @class */ (function () {\n    function Result(value, expression, input) {\n        var _this = this;\n        this.expression = expression;\n        this.input = input;\n        if (_.isString(value)) {\n            this.value = value;\n        }\n        else if (_.isArray(value)) {\n            this.subResults = value;\n            _.forEach(this.subResults, function (subResult) {\n                subResult.parent = _this;\n            });\n        }\n    }\n    Result.prototype.isSuccess = function () {\n        // if null is the value, this mean the expression could not parse this input\n        return this.value != null || (this.subResults != null && _.all(this.subResults, function (subResult) { return subResult.isSuccess(); }));\n    };\n    /**\n     * Return path to this result ([parent.parent, parent, this])\n     */\n    Result.prototype.path = function (until) {\n        var path = this.parent != null && this.parent != until ? this.parent.path(until) : [];\n        path.push(this);\n        return path;\n    };\n    /**\n     * Return the closest parent that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n     */\n    Result.prototype.findParent = function (match) {\n        var parent = this;\n        var iterator = _.isString(match) ? function (result) { return match == result.expression.id; } : match;\n        while (parent != null && !iterator(parent)) {\n            parent = parent.parent;\n        }\n        return parent;\n    };\n    /**\n     * Return the first child that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n     */\n    Result.prototype.find = function (match) {\n        var iterator = _.isString(match) ? function (result) { return match == result.expression.id; } : match;\n        if (iterator(this)) {\n            return this;\n        }\n        if (this.subResults) {\n            for (var i = 0; i < this.subResults.length; i++) {\n                var subResultFind = this.subResults[i].find(iterator);\n                if (subResultFind) {\n                    return subResultFind;\n                }\n            }\n        }\n        return null;\n    };\n    /**\n     * Return all children that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n     */\n    Result.prototype.findAll = function (match) {\n        var results = [];\n        var iterator = _.isString(match) ? function (result) { return match == result.expression.id; } : match;\n        if (iterator(this)) {\n            results.push(this);\n        }\n        if (this.subResults) {\n            results = _.reduce(this.subResults, function (results, subResult) { return results.concat(subResult.findAll(iterator)); }, results);\n        }\n        return results;\n    };\n    /**\n     * Return the first child that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n     */\n    Result.prototype.resultAt = function (index, match) {\n        if (index < 0 || index > this.getLength()) {\n            return [];\n        }\n        if (match != null) {\n            if (_.isString(match)) {\n                if (match == this.expression.id) {\n                    return [this];\n                }\n            }\n            else {\n                if (match(this)) {\n                    return [this];\n                }\n            }\n        }\n        else {\n            var value = this.value == null && this.subResults == null ? this.input : this.value;\n            if (value != null) {\n                return [this];\n            }\n        }\n        if (this.subResults != null) {\n            var results = [];\n            for (var i = 0; i < this.subResults.length; i++) {\n                var subResult = this.subResults[i];\n                results = results.concat(subResult.resultAt(index, match));\n                index -= subResult.getLength();\n                if (index < 0) {\n                    break;\n                }\n            }\n            return results;\n        }\n        return [];\n    };\n    /**\n     * Return all fail result.\n     */\n    Result.prototype.getExpect = function () {\n        if (this.value == null && this.subResults == null) {\n            return [this];\n        }\n        if (this.subResults != null) {\n            return _.reduce(this.subResults, function (expect, result) { return expect.concat(result.getExpect()); }, []);\n        }\n        return [];\n    };\n    /**\n     * Return the best fail result (The farthest result who got parsed). We also remove duplicate and always return the simplest result of a kind\n     */\n    Result.prototype.getBestExpect = function () {\n        var expects = this.getExpect();\n        var groups = _.groupBy(expects, function (expect) { return expect.input; });\n        var key = _.last(_.keys(groups).sort(function (a, b) {\n            return b.length - a.length;\n        }));\n        var bestResults = groups[key];\n        var groups = _.groupBy(bestResults, function (expect) { return expect.expression.id; });\n        return _.map(groups, function (bestResults) {\n            return _.chain(bestResults)\n                .map(function (result) {\n                return {\n                    path: result.path().length,\n                    result: result\n                };\n            })\n                .sortBy('path')\n                .pluck('result')\n                .first()\n                .value();\n        });\n    };\n    Result.prototype.getHumanReadableExpect = function () {\n        var expect = this.getBestExpect();\n        var input = expect.length > 0 ? _.last(expect).input : '';\n        return ('Expected ' +\n            _.map(expect, function (result) { return result.getHumanReadable(); }).join(' or ') +\n            ' but ' +\n            (input.length > 0 ? JSON.stringify(input[0]) : 'end of input') +\n            ' found.');\n    };\n    /**\n     * Return a string that represent what is before this result\n     */\n    Result.prototype.before = function () {\n        if (this.parent == null) {\n            return '';\n        }\n        var index = _.indexOf(this.parent.subResults, this);\n        return (this.parent.before() +\n            _.chain(this.parent.subResults)\n                .first(index)\n                .map(function (subResult) { return subResult.toString(); })\n                .join('')\n                .value());\n    };\n    /**\n     * Return a string that represent what is after this result\n     */\n    Result.prototype.after = function () {\n        if (this.parent == null) {\n            return '';\n        }\n        var index = _.indexOf(this.parent.subResults, this);\n        return (_.chain(this.parent.subResults)\n            .last(this.parent.subResults.length - index - 1)\n            .map(function (subResult) { return subResult.toString(); })\n            .join('')\n            .value() + this.parent.after());\n    };\n    /**\n     * Return the length of the result\n     */\n    Result.prototype.getLength = function () {\n        if (this.value != null) {\n            return this.value.length;\n        }\n        if (this.subResults != null) {\n            return _.reduce(this.subResults, function (length, subResult) { return length + subResult.getLength(); }, 0);\n        }\n        return this.input.length;\n    };\n    Result.prototype.toHtmlElement = function () {\n        var element = document.createElement('span');\n        var id = this.expression != null ? this.expression.id : null;\n        if (id != null) {\n            element.setAttribute('data-id', id);\n        }\n        element.setAttribute('data-success', this.isSuccess().toString());\n        if (this.value != null) {\n            element.appendChild(document.createTextNode(this.value));\n            element.setAttribute('data-value', this.value);\n        }\n        else if (this.subResults != null) {\n            _.each(this.subResults, function (subResult) {\n                element.appendChild(subResult.toHtmlElement());\n            });\n        }\n        else {\n            element.appendChild(document.createTextNode(this.input));\n            element.setAttribute('data-input', this.input);\n            element.className = 'magic-box-error' + (this.input.length > 0 ? '' : ' magic-box-error-empty');\n        }\n        element['result'] = this;\n        return element;\n    };\n    /**\n     * Clean the result to have the most relevant result. If the result is successful just return a clone of it.\n     */\n    Result.prototype.clean = function (path) {\n        if (path != null || !this.isSuccess()) {\n            path = path || _.last(this.getBestExpect()).path(this);\n            var next = _.first(path);\n            if (next != null) {\n                var nextIndex = _.indexOf(this.subResults, next);\n                var subResults = nextIndex == -1 ? [] : _.map(_.first(this.subResults, nextIndex), function (subResult) { return subResult.clean(); });\n                subResults.push(next.clean(_.rest(path)));\n                return new Result(subResults, this.expression, this.input);\n            }\n            else {\n                return new Result(null, this.expression, this.input);\n            }\n        }\n        if (this.value != null) {\n            return new Result(this.value, this.expression, this.input);\n        }\n        if (this.subResults != null) {\n            return new Result(_.map(this.subResults, function (subResult) { return subResult.clean(); }), this.expression, this.input);\n        }\n    };\n    Result.prototype.clone = function () {\n        if (this.value != null) {\n            return new Result(this.value, this.expression, this.input);\n        }\n        if (this.subResults != null) {\n            return new Result(_.map(this.subResults, function (subResult) { return subResult.clone(); }), this.expression, this.input);\n        }\n        return new Result(null, this.expression, this.input);\n    };\n    Result.prototype.toString = function () {\n        if (this.value != null) {\n            return this.value;\n        }\n        if (this.subResults != null) {\n            return _.map(this.subResults, function (subresult) { return subresult.toString(); }).join('');\n        }\n        return this.input;\n    };\n    Result.prototype.getHumanReadable = function () {\n        if (this.expression instanceof ExpressionConstant_1.ExpressionConstant) {\n            return JSON.stringify(this.expression.value);\n        }\n        return this.expression.id;\n    };\n    return Result;\n}());\nexports.Result = Result;\nvar EndOfInputResult = /** @class */ (function (_super) {\n    __extends(EndOfInputResult, _super);\n    function EndOfInputResult(result) {\n        var _this = _super.call(this, [result], ExpressionEndOfInput_1.ExpressionEndOfInput, result.input) || this;\n        var endOfInput = new Result(null, ExpressionEndOfInput_1.ExpressionEndOfInput, result.input.substr(result.getLength()));\n        endOfInput.parent = _this;\n        _this.subResults.push(endOfInput);\n        return _this;\n    }\n    return EndOfInputResult;\n}(Result));\nexports.EndOfInputResult = EndOfInputResult;\n\n\n/***/ }),\n\n/***/ 561:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar GlobalExports_1 = __webpack_require__(3);\nvar ExpressionConstant_1 = __webpack_require__(219);\nvar ExpressionEndOfInput_1 = __webpack_require__(218);\nvar ExpressionFunction_1 = __webpack_require__(497);\nvar ExpressionList_1 = __webpack_require__(498);\nvar ExpressionOptions_1 = __webpack_require__(494);\nvar ExpressionRef_1 = __webpack_require__(492);\nvar ExpressionRegExp_1 = __webpack_require__(496);\nvar Grammar_1 = __webpack_require__(176);\nvar Grammars_1 = __webpack_require__(562);\nvar InputManager_1 = __webpack_require__(503);\nvar MagicBox_1 = __webpack_require__(222);\nvar MagicBoxUtils_1 = __webpack_require__(223);\nvar OptionResult_1 = __webpack_require__(495);\nvar RefResult_1 = __webpack_require__(493);\nvar Result_1 = __webpack_require__(52);\nvar SuggestionsManager_1 = __webpack_require__(221);\nexports.GrammarsImportedLocally = Grammars_1.Grammars;\nfunction doMagicBoxExport() {\n    GlobalExports_1.exportGlobally({\n        MagicBox: {\n            EndOfInputResult: Result_1.EndOfInputResult,\n            ExpressionConstant: ExpressionConstant_1.ExpressionConstant,\n            ExpressionEndOfInput: ExpressionEndOfInput_1.ExpressionEndOfInput,\n            ExpressionFunction: ExpressionFunction_1.ExpressionFunction,\n            ExpressionList: ExpressionList_1.ExpressionList,\n            ExpressionOptions: ExpressionOptions_1.ExpressionOptions,\n            ExpressionRef: ExpressionRef_1.ExpressionRef,\n            ExpressionRegExp: ExpressionRegExp_1.ExpressionRegExp,\n            Grammar: Grammar_1.Grammar,\n            Grammars: Grammars_1.Grammars,\n            InputManager: InputManager_1.InputManager,\n            Instance: MagicBox_1.MagicBoxInstance,\n            OptionResult: OptionResult_1.OptionResult,\n            RefResult: RefResult_1.RefResult,\n            Result: Result_1.Result,\n            SuggestionsManager: SuggestionsManager_1.SuggestionsManager,\n            Utils: MagicBoxUtils_1.MagicBoxUtils,\n            create: MagicBox_1.createMagicBox,\n            requestAnimationFrame: MagicBox_1.requestAnimationFrame\n        }\n    });\n}\nexports.doMagicBoxExport = doMagicBoxExport;\n\n\n/***/ }),\n\n/***/ 562:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Basic_1 = __webpack_require__(132);\nvar Complete_1 = __webpack_require__(507);\nvar Date_1 = __webpack_require__(500);\nvar Expressions_1 = __webpack_require__(508);\nvar Field_1 = __webpack_require__(220);\nvar NestedQuery_1 = __webpack_require__(499);\nvar QueryExtension_1 = __webpack_require__(501);\nvar SubExpression_1 = __webpack_require__(502);\nexports.Grammars = {\n    Basic: Basic_1.Basic,\n    notInWord: Basic_1.notInWord,\n    notWordStart: Basic_1.notWordStart,\n    Complete: Complete_1.Complete,\n    Date: Date_1.Date,\n    Expressions: Expressions_1.Expressions,\n    ExpressionsGrammar: Expressions_1.ExpressionsGrammar,\n    Field: Field_1.Field,\n    NestedQuery: NestedQuery_1.NestedQuery,\n    QueryExtension: QueryExtension_1.QueryExtension,\n    SubExpression: SubExpression_1.SubExpression\n};\n\n\n/***/ }),\n\n/***/ 563:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [0, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Dom_1 = __webpack_require__(1);\nvar Strings_1 = __webpack_require__(6);\nvar underscore_1 = __webpack_require__(0);\nvar Component_1 = __webpack_require__(7);\nvar SuggestionsManager_1 = __webpack_require__(221);\nvar ResultPreviewsManagerEvents_1 = __webpack_require__(509);\nvar QueryProcessor_1 = __webpack_require__(504);\nvar Utils_1 = __webpack_require__(4);\nvar ResultPreviewsManager = /** @class */ (function () {\n    function ResultPreviewsManager(element, options) {\n        if (options === void 0) { options = {}; }\n        this.element = element;\n        this.options = underscore_1.defaults(options, {\n            previewHeaderText: Strings_1.l('QuerySuggestPreview'),\n            previewHeaderFieldText: Strings_1.l('QuerySuggestPreviewWithField'),\n            previewClass: 'coveo-preview-selectable',\n            selectedClass: 'magic-box-selected'\n        });\n        this.root = Component_1.Component.resolveRoot(element);\n        this.previewsProcessor = new QueryProcessor_1.QueryProcessor({ timeout: this.options.timeout });\n    }\n    Object.defineProperty(ResultPreviewsManager.prototype, \"previewsOwner\", {\n        get: function () {\n            return this.lastDisplayedSuggestion;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ResultPreviewsManager.prototype, \"hasPreviews\", {\n        get: function () {\n            return !!this.suggestionsPreviewContainer;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ResultPreviewsManager.prototype, \"focusedPreviewElement\", {\n        get: function () {\n            if (!this.hasPreviews) {\n                return null;\n            }\n            var focusedElement = this.suggestionsPreviewContainer.findClass(this.options.selectedClass)[0];\n            if (!focusedElement || !focusedElement.classList.contains(this.options.previewClass)) {\n                return null;\n            }\n            return focusedElement;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ResultPreviewsManager.prototype, \"previewElements\", {\n        get: function () {\n            if (!this.hasPreviews) {\n                return [];\n            }\n            return this.suggestionsPreviewContainer.findClass(this.options.previewClass);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ResultPreviewsManager.prototype, \"suggestionsListbox\", {\n        get: function () {\n            return Dom_1.$$(Dom_1.$$(this.element).findClass('coveo-magicbox-suggestions')[0]);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ResultPreviewsManager.prototype, \"numberOfResultsPerRow\", {\n        get: function () {\n            var previewSelectables = this.suggestionsPreviewContainer.findClass(this.options.previewClass);\n            if (previewSelectables.length === 0) {\n                return 0;\n            }\n            var firstVerticalOffset = previewSelectables[0].offsetTop;\n            var firstIndexOnNextRow = underscore_1.findIndex(previewSelectables, function (previewSelectable) { return previewSelectable.offsetTop !== firstVerticalOffset; });\n            return firstIndexOnNextRow !== -1 ? firstIndexOnNextRow : previewSelectables.length;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ResultPreviewsManager.prototype, \"previewContainerId\", {\n        get: function () {\n            return \"coveo-previews-for-\" + this.lastDisplayedSuggestion.dom.id;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ResultPreviewsManager.prototype.displaySearchResultPreviewsForSuggestion = function (suggestion) {\n        return __awaiter(this, void 0, void 0, function () {\n            var externalOptions, currentDelay, isQueryForSuggestionOngoing, arePreviewsForSuggestionCurrentlyDisplayed, _a, status, results;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        externalOptions = this.getExternalOptions();\n                        currentDelay = (this.lastDelay = Utils_1.Utils.resolveAfter(Utils_1.Utils.isNullOrUndefined(externalOptions.displayAfterDuration) ? 200 : externalOptions.displayAfterDuration));\n                        return [4 /*yield*/, currentDelay];\n                    case 1:\n                        _b.sent();\n                        if (currentDelay !== this.lastDelay) {\n                            return [2 /*return*/];\n                        }\n                        isQueryForSuggestionOngoing = suggestion && this.lastQueriedSuggestion === suggestion;\n                        if (isQueryForSuggestionOngoing) {\n                            return [2 /*return*/];\n                        }\n                        arePreviewsForSuggestionCurrentlyDisplayed = this.lastDisplayedSuggestion === suggestion;\n                        if (arePreviewsForSuggestionCurrentlyDisplayed) {\n                            this.previewsProcessor.overrideIfProcessing();\n                            this.lastQueriedSuggestion = null;\n                            return [2 /*return*/];\n                        }\n                        this.lastQueriedSuggestion = suggestion;\n                        if (!suggestion) {\n                            this.displaySuggestionPreviews(null, []);\n                            return [2 /*return*/];\n                        }\n                        return [4 /*yield*/, this.getSearchResultPreviewsQuery(suggestion)];\n                    case 2:\n                        _a = _b.sent(), status = _a.status, results = _a.results;\n                        if (status === QueryProcessor_1.ProcessingStatus.Overriden) {\n                            return [2 /*return*/];\n                        }\n                        this.lastQueriedSuggestion = null;\n                        this.displaySuggestionPreviews(suggestion, results);\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    ResultPreviewsManager.prototype.getElementInDirection = function (direction) {\n        var previewElements = this.previewElements;\n        var focusedIndex = previewElements.indexOf(this.focusedPreviewElement);\n        if (focusedIndex === -1) {\n            return null;\n        }\n        if (focusedIndex === 0 && direction === SuggestionsManager_1.Direction.Left) {\n            return null;\n        }\n        return previewElements[(focusedIndex + this.getIncrementInDirection(direction)) % previewElements.length];\n    };\n    ResultPreviewsManager.prototype.getIncrementInDirection = function (direction) {\n        switch (direction) {\n            case SuggestionsManager_1.Direction.Left:\n                return -1;\n            case SuggestionsManager_1.Direction.Right:\n                return 1;\n            case SuggestionsManager_1.Direction.Up:\n                return -this.numberOfResultsPerRow;\n            case SuggestionsManager_1.Direction.Down:\n                return this.numberOfResultsPerRow;\n        }\n    };\n    ResultPreviewsManager.prototype.setHasPreviews = function (shouldHavePreviews) {\n        if (this.hasPreviews === !!shouldHavePreviews) {\n            return;\n        }\n        if (shouldHavePreviews) {\n            this.initPreviewForSuggestions();\n        }\n        else {\n            this.revertPreviewForSuggestions();\n        }\n    };\n    ResultPreviewsManager.prototype.initPreviewForSuggestions = function () {\n        this.suggestionsPreviewContainer = Dom_1.$$('div', {\n            className: 'coveo-suggestion-container'\n        }, this.suggestionsListbox.el, this.buildPreviewContainer());\n        this.element.appendChild(this.suggestionsPreviewContainer.el);\n        this.suggestionsListbox.setAttribute('aria-controls', this.previewContainerId);\n    };\n    ResultPreviewsManager.prototype.revertPreviewForSuggestions = function () {\n        this.element.appendChild(this.suggestionsListbox.el);\n        this.suggestionsPreviewContainer.remove();\n        this.suggestionsPreviewContainer = null;\n    };\n    ResultPreviewsManager.prototype.buildPreviewContainer = function () {\n        return Dom_1.$$('div', {\n            className: 'coveo-preview-container',\n            id: this.previewContainerId\n        }, (this.resultPreviewsContainer = Dom_1.$$('div', {\n            className: 'coveo-preview-results',\n            role: 'listbox',\n            'aria-orientation': 'horizontal'\n        }))).el;\n    };\n    ResultPreviewsManager.prototype.getExternalOptions = function () {\n        var optionsEventArgs = {};\n        Dom_1.$$(this.root).trigger(ResultPreviewsManagerEvents_1.ResultPreviewsManagerEvents.updateResultPreviewsManagerOptions, optionsEventArgs);\n        return optionsEventArgs;\n    };\n    ResultPreviewsManager.prototype.getSearchResultPreviewsQuery = function (suggestion) {\n        var populateEventArgs = {\n            suggestion: suggestion,\n            previewsQueries: []\n        };\n        Dom_1.$$(this.root).trigger(ResultPreviewsManagerEvents_1.ResultPreviewsManagerEvents.populateSearchResultPreviews, populateEventArgs);\n        return this.previewsProcessor.processQueries(populateEventArgs.previewsQueries);\n    };\n    ResultPreviewsManager.prototype.appendSearchResultPreview = function (preview, position) {\n        this.resultPreviewsContainer.append(preview.element);\n        preview.element.id = \"coveo-result-preview-\" + position;\n        var elementDom = Dom_1.$$(preview.element);\n        elementDom.setAttribute('aria-selected', 'false');\n        elementDom.setAttribute('role', 'option');\n        elementDom.on('click', function () { return preview.onSelect(); });\n        elementDom.on('keyboardSelect', function () { return preview.onSelect(); });\n    };\n    ResultPreviewsManager.prototype.appendSearchResultPreviews = function (previews) {\n        var _this = this;\n        this.resultPreviewsContainer.empty();\n        previews.forEach(function (preview, i) { return _this.appendSearchResultPreview(preview, i); });\n    };\n    ResultPreviewsManager.prototype.displaySuggestionPreviews = function (suggestion, previews) {\n        this.lastDisplayedSuggestion = suggestion;\n        this.setHasPreviews(previews && previews.length > 0);\n        this.element.classList.toggle('magic-box-hasPreviews', this.hasPreviews);\n        if (!this.hasPreviews) {\n            return;\n        }\n        this.appendSearchResultPreviews(previews);\n    };\n    return ResultPreviewsManager;\n}());\nexports.ResultPreviewsManager = ResultPreviewsManager;\n\n\n/***/ }),\n\n/***/ 564:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Dom_1 = __webpack_require__(1);\nvar Strings_1 = __webpack_require__(6);\nvar AccessibleButton_1 = __webpack_require__(15);\nvar MagicBoxClear = /** @class */ (function () {\n    function MagicBoxClear(magicBox) {\n        this.element = Dom_1.$$('div', {\n            className: 'magic-box-clear'\n        });\n        var clearIcon = Dom_1.$$('div', {\n            className: 'magic-box-icon'\n        });\n        this.element.append(clearIcon.el);\n        this.element.insertAfter(Dom_1.$$(magicBox.element).find('input'));\n        new AccessibleButton_1.AccessibleButton()\n            .withElement(this.element)\n            .withLabel(Strings_1.l('Clear'))\n            .withSelectAction(function () { return magicBox.clear(); })\n            .build();\n        this.toggleTabindexAndAriaHidden(false);\n    }\n    MagicBoxClear.prototype.toggleTabindexAndAriaHidden = function (hasText) {\n        var tabindex = hasText ? '0' : '-1';\n        this.element.setAttribute('tabindex', tabindex);\n        this.element.setAttribute('aria-hidden', \"\" + !hasText);\n    };\n    return MagicBoxClear;\n}());\nexports.MagicBoxClear = MagicBoxClear;\n\n\n/***/ }),\n\n/***/ 565:\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\n\n/***/ }),\n\n/***/ 573:\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\n\n/***/ }),\n\n/***/ 574:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar OmniboxEvents_1 = __webpack_require__(34);\nvar _ = __webpack_require__(0);\nvar MagicBoxUtils_1 = __webpack_require__(223);\nvar FieldAddon = /** @class */ (function () {\n    function FieldAddon(omnibox) {\n        var _this = this;\n        this.omnibox = omnibox;\n        this.cache = {};\n        this.omnibox.bind.on(this.omnibox.element, OmniboxEvents_1.OmniboxEvents.populateOmniboxSuggestions, function (args) {\n            args.suggestions.push(_this.getSuggestion());\n        });\n    }\n    FieldAddon.prototype.getSuggestion = function () {\n        var _this = this;\n        var hash = this.getHash();\n        if (hash == null) {\n            return null;\n        }\n        var hashString = this.hashToString(hash);\n        if (this.cache[hashString] != null) {\n            return this.hashValueToSuggestion(hash, this.cache[hashString]);\n        }\n        var values;\n        if (hash.type == 'FieldName') {\n            values = this.fieldNames(hash.current);\n        }\n        if (hash.type == 'FieldValue') {\n            values = this.fieldValues(hash.field, hash.current);\n        }\n        if (hash.type == 'SimpleFieldName') {\n            values = this.simpleFieldNames(hash.current);\n        }\n        this.cache[hashString] = values;\n        values.catch(function () {\n            delete _this.cache[hashString];\n        });\n        return this.hashValueToSuggestion(hash, values);\n    };\n    FieldAddon.prototype.getHash = function () {\n        var fieldName = _.last(this.omnibox.resultAtCursor('FieldName'));\n        if (fieldName != null) {\n            fieldName = fieldName.findParent('Field') || fieldName;\n            var currentField = fieldName.toString();\n            var before = fieldName.before();\n            var after = fieldName.after();\n            return { type: 'FieldName', current: currentField, before: before, after: after };\n        }\n        var fieldValue = _.last(this.omnibox.resultAtCursor('FieldValue'));\n        if (fieldValue) {\n            var fieldQuery = fieldValue.findParent('FieldQuery') || (this.omnibox.options.enableSimpleFieldAddon && fieldValue.findParent('FieldSimpleQuery'));\n            if (fieldQuery) {\n                var field = fieldQuery.find('FieldName').toString();\n                if (this.omnibox.options.fieldAlias) {\n                    if (field in this.omnibox.options.fieldAlias) {\n                        field = this.omnibox.options.fieldAlias[field];\n                    }\n                }\n                var value = fieldValue.toString();\n                var before = fieldValue.before();\n                var after = fieldValue.after();\n                return { type: 'FieldValue', field: field, current: value, before: before, after: after };\n            }\n        }\n        if (this.omnibox.options.enableSimpleFieldAddon) {\n            var word = _.last(this.omnibox.resultAtCursor('Word'));\n            if (word != null) {\n                var current = word.toString();\n                var before = word.before();\n                var after = word.after();\n                return { type: 'SimpleFieldName', current: current, before: before, after: after };\n            }\n        }\n    };\n    FieldAddon.prototype.hashToString = function (hash) {\n        if (hash == null) {\n            return null;\n        }\n        return hash.type + hash.current + (hash.field || '');\n    };\n    FieldAddon.prototype.hashValueToSuggestion = function (hash, promise) {\n        return promise.then(function (values) {\n            var suggestions = _.map(values, function (value, i) {\n                var suggestion = {\n                    text: hash.before +\n                        (hash.current.toLowerCase().indexOf(value.toLowerCase()) == 0 ? hash.current + value.substr(hash.current.length) : value) +\n                        hash.after,\n                    html: MagicBoxUtils_1.MagicBoxUtils.highlightText(value, hash.current, true),\n                    index: FieldAddon.INDEX - i / values.length\n                };\n                return suggestion;\n            });\n            return suggestions;\n        });\n    };\n    FieldAddon.prototype.getFields = function () {\n        var _this = this;\n        if (this.fields == null) {\n            this.fields = new Promise(function (resolve, reject) {\n                if (_this.omnibox.options.listOfFields != null) {\n                    resolve(_this.omnibox.options.listOfFields);\n                }\n                else {\n                    var promise = _this.omnibox.queryController.getEndpoint().listFields();\n                    promise\n                        .then(function (fieldDescriptions) {\n                        var fieldNames = _.chain(fieldDescriptions)\n                            .filter(function (fieldDescription) { return fieldDescription.includeInQuery && fieldDescription.groupByField; })\n                            .map(function (fieldDescription) { return fieldDescription.name.substr(1); })\n                            .value();\n                        resolve(fieldNames);\n                    })\n                        .catch(function () {\n                        reject();\n                    });\n                }\n            });\n        }\n        return this.fields;\n    };\n    FieldAddon.prototype.fieldNames = function (current) {\n        var withAt = current.length > 0 && current[0] == '@';\n        var fieldName = withAt ? current.substr(1) : current;\n        var fieldNameLC = fieldName.toLowerCase();\n        return this.getFields().then(function (fields) {\n            var matchFields = _.chain(fields)\n                .map(function (fieldName) {\n                var fieldNameBeginsWithAt = fieldName.length > 0 && fieldName[0] == '@';\n                return {\n                    index: fieldName.toLowerCase().indexOf(fieldNameLC),\n                    field: fieldNameBeginsWithAt ? fieldName : '@' + fieldName\n                };\n            })\n                .filter(function (field) {\n                return field.index != -1 && field.field.length > current.length;\n            })\n                .sortBy('index')\n                .map(function (field) { return field.field; })\n                .value();\n            matchFields = _.first(matchFields, 5);\n            return matchFields;\n        });\n    };\n    FieldAddon.prototype.fieldValues = function (field, current) {\n        return this.omnibox.queryController\n            .getEndpoint()\n            .listFieldValues({\n            pattern: '.*' + current + '.*',\n            patternType: 'RegularExpression',\n            sortCriteria: 'occurrences',\n            field: '@' + field,\n            maximumNumberOfValues: 5\n        })\n            .then(function (values) {\n            return _.chain(values)\n                .map(function (value) {\n                return {\n                    index: value.value.toLowerCase().indexOf(current),\n                    value: value.value\n                };\n            })\n                .filter(function (value) {\n                return value.value.length > current.length;\n            })\n                .sortBy('index')\n                .map(function (value) {\n                return value.value.replace(/ /g, '\\u00A0');\n            })\n                .value();\n        });\n    };\n    FieldAddon.prototype.simpleFieldNames = function (current) {\n        var fieldName = current;\n        var fieldNameLC = fieldName.toLowerCase();\n        return this.getFields().then(function (fields) {\n            var matchFields = _.chain(fields)\n                .map(function (field) {\n                return {\n                    index: field.toLowerCase().indexOf(fieldNameLC),\n                    field: field + ':'\n                };\n            })\n                .filter(function (field) {\n                return field.index != -1 && field.field.length > current.length;\n            })\n                .sortBy('index')\n                .map(function (field) { return field.field; })\n                .value();\n            matchFields = _.first(matchFields, 5);\n            return matchFields;\n        });\n    };\n    FieldAddon.INDEX = 64;\n    return FieldAddon;\n}());\nexports.FieldAddon = FieldAddon;\n\n\n/***/ }),\n\n/***/ 575:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar OmniboxEvents_1 = __webpack_require__(34);\nvar Dom_1 = __webpack_require__(1);\nvar Utils_1 = __webpack_require__(4);\nvar _ = __webpack_require__(0);\nvar OldOmniboxAddon = /** @class */ (function () {\n    function OldOmniboxAddon(omnibox) {\n        var _this = this;\n        this.omnibox = omnibox;\n        this.omnibox.bind.on(this.omnibox.element, OmniboxEvents_1.OmniboxEvents.populateOmniboxSuggestions, function (args) {\n            _.each(_this.getSuggestion(), function (suggestion) {\n                args.suggestions.push(suggestion);\n            });\n        });\n    }\n    OldOmniboxAddon.prototype.getSuggestion = function () {\n        var text = this.omnibox.magicBox.getText();\n        if (text.length == 0) {\n            return null;\n        }\n        var eventArgs = this.buildPopulateOmniboxEventArgs();\n        Dom_1.$$(this.omnibox.root).trigger(OmniboxEvents_1.OmniboxEvents.populateOmnibox, eventArgs);\n        return this.rowsToSuggestions(eventArgs.rows);\n    };\n    OldOmniboxAddon.prototype.getCurrentQueryExpression = function () {\n        var cursorPos = this.omnibox.getCursor();\n        var value = this.omnibox.getText();\n        var length = value.length;\n        var start = cursorPos;\n        var end = cursorPos;\n        if (value[start] == ' ') {\n            start--;\n        }\n        while (start > 0 && value[start] != ' ') {\n            start--;\n        }\n        while (end < length && value[end] != ' ') {\n            end++;\n        }\n        return value.substring(start, end);\n    };\n    OldOmniboxAddon.prototype.getRegexToSearch = function (strValue) {\n        if (strValue == null) {\n            strValue = this.omnibox.getText();\n        }\n        return new RegExp(Utils_1.Utils.escapeRegexCharacter(strValue), 'i');\n    };\n    OldOmniboxAddon.prototype.getQueryExpressionBreakDown = function () {\n        var _this = this;\n        var ret = [];\n        var queryWords = this.omnibox.getText().split(' ');\n        _.each(queryWords, function (word) {\n            ret.push({\n                word: word,\n                regex: _this.getRegexToSearch(word)\n            });\n        });\n        return ret;\n    };\n    OldOmniboxAddon.prototype.replace = function (searchValue, newValue) {\n        this.omnibox.setText(this.omnibox.getText().replace(searchValue, newValue));\n    };\n    OldOmniboxAddon.prototype.clearCurrentExpression = function () {\n        this.replace(this.getCurrentQueryExpression(), '');\n    };\n    OldOmniboxAddon.prototype.insertAt = function (at, toInsert) {\n        var oldValue = this.omnibox.getText();\n        var newValue = [oldValue.slice(0, at), toInsert, oldValue.slice(at)].join('');\n        this.omnibox.setText(newValue);\n    };\n    OldOmniboxAddon.prototype.replaceCurrentExpression = function (newValue) {\n        this.replace(this.getCurrentQueryExpression(), newValue);\n    };\n    OldOmniboxAddon.prototype.buildPopulateOmniboxEventArgs = function () {\n        var _this = this;\n        var currentQueryExpression = this.getCurrentQueryExpression();\n        var ret = {\n            rows: [],\n            completeQueryExpression: {\n                word: this.omnibox.getText(),\n                regex: this.getRegexToSearch()\n            },\n            currentQueryExpression: {\n                word: currentQueryExpression,\n                regex: this.getRegexToSearch(currentQueryExpression)\n            },\n            allQueryExpressions: this.getQueryExpressionBreakDown(),\n            cursorPosition: this.omnibox.getCursor(),\n            clear: function () {\n                _this.omnibox.clear();\n            },\n            clearCurrentExpression: function () {\n                _this.clearCurrentExpression();\n            },\n            replace: function (searchValue, newValue) {\n                _this.replace(searchValue, newValue);\n            },\n            replaceCurrentExpression: function (newValue) {\n                _this.replaceCurrentExpression(newValue);\n            },\n            insertAt: function (at, toInsert) {\n                _this.insertAt(at, toInsert);\n            },\n            closeOmnibox: function () {\n                _this.omnibox.magicBox.blur();\n            }\n        };\n        return ret;\n    };\n    OldOmniboxAddon.prototype.rowsToSuggestions = function (rows) {\n        return _.map(rows, function (row) {\n            if (!Utils_1.Utils.isNullOrUndefined(row.element)) {\n                return new Promise(function (resolve) {\n                    resolve([\n                        {\n                            dom: row.element,\n                            index: row.zIndex\n                        }\n                    ]);\n                });\n            }\n            else if (!Utils_1.Utils.isNullOrUndefined(row.deferred)) {\n                return new Promise(function (resolve) {\n                    row.deferred.then(function (row) {\n                        if (row.element != null) {\n                            resolve([\n                                {\n                                    dom: row.element,\n                                    index: row.zIndex\n                                }\n                            ]);\n                        }\n                        else {\n                            resolve(null);\n                        }\n                    });\n                });\n            }\n            return null;\n        });\n    };\n    return OldOmniboxAddon;\n}());\nexports.OldOmniboxAddon = OldOmniboxAddon;\n\n\n/***/ }),\n\n/***/ 576:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\n///<reference path='Omnibox.ts'/>\nvar OmniboxEvents_1 = __webpack_require__(34);\nvar _ = __webpack_require__(0);\nvar MagicBoxUtils_1 = __webpack_require__(223);\nvar QueryExtensionAddon = /** @class */ (function () {\n    function QueryExtensionAddon(omnibox) {\n        var _this = this;\n        this.omnibox = omnibox;\n        this.cache = {};\n        this.omnibox.bind.on(this.omnibox.element, OmniboxEvents_1.OmniboxEvents.populateOmniboxSuggestions, function (args) {\n            args.suggestions.push(_this.getSuggestion());\n        });\n    }\n    QueryExtensionAddon.prototype.getSuggestion = function () {\n        var _this = this;\n        var hash = this.getHash(this.omnibox.magicBox);\n        if (hash == null) {\n            return null;\n        }\n        var hashString = this.hashToString(hash);\n        if (this.cache[hashString] != null) {\n            return this.hashValueToSuggestion(hash, this.cache[hashString]);\n        }\n        var values = hash.type == 'QueryExtensionName' ? this.names(hash.current) : this.attributeNames(hash.name, hash.current, hash.used);\n        this.cache[hashString] = values;\n        values.catch(function () {\n            delete _this.cache[hashString];\n        });\n        return this.hashValueToSuggestion(hash, values);\n    };\n    QueryExtensionAddon.prototype.getHash = function (magicBox) {\n        var queryExtension = _.last(magicBox.resultAtCursor('QueryExtension'));\n        if (queryExtension != null) {\n            var queryExtensionArgumentResults = queryExtension.findAll('QueryExtensionArgument');\n            var current = _.last(magicBox.resultAtCursor('QueryExtensionName'));\n            if (current != null) {\n                return {\n                    type: 'QueryExtensionName',\n                    current: current.toString(),\n                    before: current.before(),\n                    after: current.after()\n                };\n            }\n            current = _.last(magicBox.resultAtCursor('QueryExtensionArgumentName'));\n            if (current != null) {\n                var used = _.chain(queryExtensionArgumentResults)\n                    .map(function (result) {\n                    var name = result.find('QueryExtensionArgumentName');\n                    return name && name.toString();\n                })\n                    .compact()\n                    .value();\n                var name = queryExtension.find('QueryExtensionName').toString();\n                return {\n                    type: 'QueryExtensionArgumentName',\n                    current: current.toString(),\n                    before: current.before(),\n                    after: current.after(),\n                    name: name,\n                    used: used\n                };\n            }\n        }\n        return null;\n    };\n    QueryExtensionAddon.prototype.hashToString = function (hash) {\n        if (hash == null) {\n            return null;\n        }\n        return [hash.type, hash.current, hash.name || '', hash.used ? hash.used.join() : ''].join();\n    };\n    QueryExtensionAddon.prototype.hashValueToSuggestion = function (hash, promise) {\n        return promise.then(function (values) {\n            var suggestions = _.map(values, function (value, i) {\n                return {\n                    html: MagicBoxUtils_1.MagicBoxUtils.highlightText(value, hash.current, true),\n                    text: hash.before + value + hash.after,\n                    index: QueryExtensionAddon.INDEX - i / values.length\n                };\n            });\n            return suggestions;\n        });\n    };\n    QueryExtensionAddon.prototype.getExtensions = function () {\n        if (this.extensions == null) {\n            this.extensions = this.omnibox.queryController.getEndpoint().extensions();\n        }\n        return this.extensions;\n    };\n    QueryExtensionAddon.prototype.names = function (current) {\n        var extensionName = current.toLowerCase();\n        return this.getExtensions().then(function (extensions) {\n            var matchExtensions = _.chain(extensions)\n                .map(function (extension) {\n                return {\n                    index: extension.name.toLowerCase().indexOf(extensionName),\n                    extension: extension.name\n                };\n            })\n                .filter(function (extension) {\n                return extension.index != -1 && extension.extension.length > extensionName.length;\n            })\n                .sortBy('index')\n                .pluck('extension')\n                .value();\n            matchExtensions = _.first(matchExtensions, 5);\n            return matchExtensions;\n        });\n    };\n    QueryExtensionAddon.prototype.attributeNames = function (name, current, used) {\n        return this.getExtensions().then(function (extensions) {\n            var extension = _.find(extensions, function (extension) { return extension.name == name; });\n            if (extension == null) {\n                return [];\n            }\n            else {\n                return _.filter(_.difference(extension.argumentNames, used), function (argumentName) { return argumentName.indexOf(current) == 0; });\n            }\n        });\n    };\n    QueryExtensionAddon.prototype.hash = function () {\n        return;\n    };\n    QueryExtensionAddon.INDEX = 62;\n    return QueryExtensionAddon;\n}());\nexports.QueryExtensionAddon = QueryExtensionAddon;\n\n\n/***/ }),\n\n/***/ 577:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [0, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Dom_1 = __webpack_require__(1);\nvar ComponentOptionsModel_1 = __webpack_require__(28);\nvar OmniboxEvents_1 = __webpack_require__(34);\nvar StringUtils_1 = __webpack_require__(22);\nvar underscore_1 = __webpack_require__(0);\nvar QueryStateModel_1 = __webpack_require__(13);\nvar Utils_1 = __webpack_require__(4);\nvar HistoryStore_1 = __webpack_require__(89);\nvar AnalyticsInformation_1 = __webpack_require__(50);\nvar QuerySuggestAddon = /** @class */ (function () {\n    function QuerySuggestAddon(omnibox) {\n        var _this = this;\n        this.omnibox = omnibox;\n        Dom_1.$$(this.omnibox.element).on(OmniboxEvents_1.OmniboxEvents.populateOmniboxSuggestions, function (e, args) {\n            args.suggestions.push(_this.getSuggestion());\n        });\n    }\n    QuerySuggestAddon.suggestiontHtml = function (suggestion) {\n        return suggestion.highlighted.replace(/\\[(.*?)\\]|\\{(.*?)\\}|\\((.*?)\\)/g, function (part, notMatched, matched, corrected) {\n            var className = '';\n            if (matched) {\n                className = 'coveo-omnibox-hightlight';\n            }\n            if (corrected) {\n                className = 'coveo-omnibox-hightlight2';\n            }\n            var ret;\n            if (className) {\n                ret = Dom_1.$$('span', {\n                    className: className\n                });\n            }\n            else {\n                ret = Dom_1.$$('span');\n            }\n            ret.text(notMatched || matched || corrected);\n            return ret.el.outerHTML;\n        });\n    };\n    QuerySuggestAddon.isPartialMatch = function (suggestion) {\n        // groups : 1=notMatched, 2=matched, 3=corrected\n        var parts = StringUtils_1.StringUtils.match(suggestion.highlighted, /\\[(.*?)\\]|\\{(.*?)\\}|\\((.*?)\\)/g);\n        var firstFail = underscore_1.find(parts, function (part) { return part[1] != null; });\n        // if no fail found, this is a partial or a full match\n        if (firstFail == null) {\n            return true;\n        }\n        // if all right parts are notMatched, the right parts is autocomplete\n        return underscore_1.every(underscore_1.last(parts, underscore_1.indexOf(parts, firstFail) - parts.length), function (part) { return part[1] != null; });\n    };\n    QuerySuggestAddon.prototype.getSuggestion = function () {\n        var text = this.omnibox.magicBox.getText();\n        if (text.length >= this.omnibox.options.querySuggestCharacterThreshold) {\n            return this.getQuerySuggest(text);\n        }\n        return Promise.resolve([]);\n    };\n    QuerySuggestAddon.prototype.getQuerySuggest = function (text) {\n        return __awaiter(this, void 0, void 0, function () {\n            var payload, results, _a, completions;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        payload = {\n                            q: text,\n                            locale: this.locale,\n                            searchHub: this.searchHub,\n                            pipeline: this.pipeline,\n                            enableWordCompletion: this.enableWordCompletion,\n                            context: this.context,\n                            count: this.count,\n                            tab: this.tab,\n                            referrer: document.referrer,\n                            actionsHistory: this.actionsHistory,\n                            timezone: this.timezone,\n                            visitorId: this.visitorId,\n                            isGuestUser: this.isGuestUser\n                        };\n                        Dom_1.$$(this.omnibox.getBindings().searchInterface.element).trigger(OmniboxEvents_1.OmniboxEvents.buildingQuerySuggest, {\n                            payload: payload\n                        });\n                        _b.label = 1;\n                    case 1:\n                        _b.trys.push([1, 3, , 4]);\n                        return [4 /*yield*/, this.omnibox.queryController.getEndpoint().getQuerySuggest(payload)];\n                    case 2:\n                        results = _b.sent();\n                        return [3 /*break*/, 4];\n                    case 3:\n                        _a = _b.sent();\n                        return [2 /*return*/, []];\n                    case 4:\n                        completions = results.completions;\n                        Dom_1.$$(this.omnibox.getBindings().searchInterface.element).trigger(OmniboxEvents_1.OmniboxEvents.querySuggestSuccess, {\n                            completions: completions\n                        });\n                        return [2 /*return*/, underscore_1.map(completions, function (completion, i) {\n                                return {\n                                    html: QuerySuggestAddon.suggestiontHtml(completion),\n                                    text: completion.expression,\n                                    index: QuerySuggestAddon.INDEX - i / completions.length,\n                                    partial: QuerySuggestAddon.isPartialMatch(completion),\n                                    executableConfidence: completion.executableConfidence\n                                };\n                            })];\n                }\n            });\n        });\n    };\n    Object.defineProperty(QuerySuggestAddon.prototype, \"tab\", {\n        get: function () {\n            var tab = this.omnibox.getBindings().queryStateModel.get(QueryStateModel_1.QUERY_STATE_ATTRIBUTES.T);\n            if (Utils_1.Utils.isNonEmptyString(tab)) {\n                return tab;\n            }\n            return undefined;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"locale\", {\n        get: function () {\n            return String['locale'];\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"searchHub\", {\n        get: function () {\n            return this.omnibox.getBindings().componentOptionsModel.get(ComponentOptionsModel_1.ComponentOptionsModel.attributesEnum.searchHub);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"pipeline\", {\n        get: function () {\n            return this.omnibox.getBindings().searchInterface.options.pipeline;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"enableWordCompletion\", {\n        get: function () {\n            return this.omnibox.options.enableSearchAsYouType;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"context\", {\n        get: function () {\n            return this.omnibox.getBindings().searchInterface.getQueryContext();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"count\", {\n        get: function () {\n            return this.omnibox.options.numberOfSuggestions;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"actionsHistory\", {\n        get: function () {\n            var historyStore = HistoryStore_1.buildHistoryStore();\n            var historyFromStore = historyStore.getHistory();\n            if (historyFromStore == null) {\n                return [];\n            }\n            return historyFromStore;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"timezone\", {\n        get: function () {\n            return this.omnibox.getBindings().searchInterface.options.timezone;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"visitorId\", {\n        get: function () {\n            return new AnalyticsInformation_1.AnalyticsInformation().clientId;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySuggestAddon.prototype, \"isGuestUser\", {\n        get: function () {\n            return this.omnibox.getBindings().queryController.getEndpoint().options.isGuestUser;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    QuerySuggestAddon.INDEX = 60;\n    return QuerySuggestAddon;\n}());\nexports.QuerySuggestAddon = QuerySuggestAddon;\nvar VoidQuerySuggestAddon = /** @class */ (function () {\n    function VoidQuerySuggestAddon() {\n    }\n    VoidQuerySuggestAddon.prototype.getSuggestion = function () {\n        return Promise.resolve([]);\n    };\n    return VoidQuerySuggestAddon;\n}());\nexports.VoidQuerySuggestAddon = VoidQuerySuggestAddon;\n\n\n/***/ }),\n\n/***/ 670:\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\n\n/***/ }),\n\n/***/ 671:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Dom_1 = __webpack_require__(1);\nvar SearchBoxResize = /** @class */ (function () {\n    function SearchBoxResize() {\n    }\n    SearchBoxResize.resize = function (element, size) {\n        var _this = this;\n        var searchbox = this.getSearchbox(element);\n        var elementToResize = this.getElementsToResize(element);\n        var magicboxInput = this.getInput(element);\n        var searchboxStyle = \"height: \" + size + \"px; line-height: \" + size + \"px;\";\n        var inputChangeStyle = \"height: \" + size + \"px\";\n        //This need to be a little bit smaller because when the height become smaller than 38px or to big, the bottom border of the Searchbox dissapear\n        var magicboxInputStyle = \"height: \" + (size - 2) + \"px;\";\n        this.applyStyle(searchbox, searchboxStyle);\n        this.applyStyle(magicboxInput, magicboxInputStyle);\n        elementToResize.forEach(function (HtmlElement) {\n            _this.applyStyle(HtmlElement, inputChangeStyle);\n        });\n    };\n    SearchBoxResize.applyStyle = function (element, style) {\n        element.style.cssText += style;\n    };\n    SearchBoxResize.getSearchbox = function (element) {\n        return Dom_1.$$(element).find('.CoveoOmnibox') || Dom_1.$$(element).find('.CoveoQuerybox');\n    };\n    SearchBoxResize.getElementsToResize = function (element) {\n        return [\n            Dom_1.$$(element).find('.CoveoSearchButton'),\n            Dom_1.$$(Dom_1.$$(element).find('.magic-box-input')).find('input'),\n            Dom_1.$$(element).find('.magic-box-icon'),\n            Dom_1.$$(element).find('.magic-box-clear'),\n            Dom_1.$$(element).find('.magic-box-underlay')\n        ];\n    };\n    SearchBoxResize.getInput = function (element) {\n        return Dom_1.$$(element).find('.magic-box-input');\n    };\n    return SearchBoxResize;\n}());\nexports.SearchBoxResize = SearchBoxResize;\n\n\n/***/ })\n\n});\n\n\n// WEBPACK FOOTER //\n// Searchbox.min__ff92a1d47dbcec2611e1.js","import { SubGrammar } from './Expressions';\nimport { Expression } from '../Expression/Expression';\nimport { Result } from '../Result/Result';\nimport { EndOfInputResult } from '../Result/Result';\n\nexport const notWordStart = ' ()[],$@\\'\"';\nexport const notInWord = ' ()[],:';\n\nexport const Basic: SubGrammar = {\n  basicExpressions: ['Word', 'DoubleQuoted'],\n  grammars: {\n    DoubleQuoted: '\"[NotDoubleQuote]\"',\n    NotDoubleQuote: /[^\"]*/,\n    SingleQuoted: \"'[NotSingleQuote]'\",\n    NotSingleQuote: /[^']*/,\n    Number: /-?(0|[1-9]\\d*)(\\.\\d+)?/,\n    Word: (input: string, end: boolean, expression: Expression) => {\n      const regex = new RegExp('[^' + notWordStart.replace(/(.)/g, '\\\\$1') + '][^' + notInWord.replace(/(.)/g, '\\\\$1') + ']*');\n      let groups = input.match(regex);\n      if (groups != null && groups.index != 0) {\n        groups = null;\n      }\n      const result = new Result(groups != null ? groups[0] : null, expression, input);\n      if (result.isSuccess() && end && input.length > result.value.length) {\n        return new EndOfInputResult(result);\n      }\n      return result;\n    }\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/Basic.ts","import 'styling/_Querybox';\nimport { IBuildingQueryEventArgs, QueryEvents } from '../../events/QueryEvents';\nimport { StandaloneSearchInterfaceEvents } from '../../events/StandaloneSearchInterfaceEvents';\nimport { exportGlobally } from '../../GlobalExports';\nimport { Grammar } from '../../magicbox/Grammar';\nimport { createMagicBox, MagicBoxInstance } from '../../magicbox/MagicBox';\nimport { Result } from '../../magicbox/Result/Result';\nimport { Assert } from '../../misc/Assert';\nimport { IAttributeChangedEventArg, MODEL_EVENTS } from '../../models/Model';\nimport { QueryStateModel, QUERY_STATE_ATTRIBUTES } from '../../models/QueryStateModel';\nimport { l } from '../../strings/Strings';\nimport { $$ } from '../../utils/Dom';\nimport { analyticsActionCauseList, IAnalyticsNoMeta } from '../Analytics/AnalyticsActionListMeta';\nimport { Component } from '../Base/Component';\nimport { IComponentBindings } from '../Base/ComponentBindings';\nimport { ComponentOptions } from '../Base/ComponentOptions';\nimport { Initialization } from '../Base/Initialization';\nimport { QueryboxOptionsProcessing } from './QueryboxOptionsProcessing';\nimport { QueryboxQueryParameters } from './QueryboxQueryParameters';\n\nexport interface IQueryboxOptions {\n  enableSearchAsYouType?: boolean;\n  searchAsYouTypeDelay?: number;\n  enableQuerySyntax?: boolean;\n  enableWildcards?: boolean;\n  enableQuestionMarks?: boolean;\n  enableLowercaseOperators?: boolean;\n  enablePartialMatch?: boolean;\n  partialMatchKeywords?: number;\n  partialMatchThreshold?: string;\n  placeholder?: string;\n  triggerQueryOnClear?: boolean;\n}\n\n/**\n * The `Querybox` component renders an input which the end user can interact with to enter and submit queries.\n *\n * When the end user submits a search request, the `Querybox` component triggers a query and logs the corresponding\n * usage analytics data.\n *\n * For technical reasons, it is necessary to instantiate this component on a `div` element rather than on an `input`\n * element.\n *\n * See also the [`Searchbox`]{@link Searchbox} component, which can automatically instantiate a `Querybox` along with an\n * optional [`SearchButton`]{@link SearchButton} component.\n */\nexport class Querybox extends Component {\n  static ID = 'Querybox';\n\n  static doExport = () => {\n    exportGlobally({\n      Querybox: Querybox,\n      QueryboxQueryParameters: QueryboxQueryParameters\n    });\n  };\n\n  /**\n   * The options for the Querybox.\n   * @componentOptions\n   */\n  public static options: IQueryboxOptions = {\n    /**\n     * Whether to enable the search-as-you-type feature.\n     *\n     * **Note:** Enabling this feature can consume lots of queries per month (QPM), especially if the [`searchAsYouTypeDelay`]{@link Querybox.options.searchAsYouTypeDelay} option is set to a low value.\n     *\n     * Default value is `false`.\n     */\n    enableSearchAsYouType: ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n\n    /**\n     * If the [`enableSearchAsYouType`]{@link Querybox.options.enableSearchAsYouType} option is `true`, specifies how\n     * long to wait (in milliseconds) between each key press before triggering a new query.\n     *\n     * Default value is `50`. Minimum value is `0`\n     */\n    searchAsYouTypeDelay: ComponentOptions.buildNumberOption({ defaultValue: 50, min: 0, section: 'Advanced Options' }),\n\n    /**\n     * Specifies whether to interpret special query syntax (e.g., `@objecttype=message`) when the end user types\n     * a query in the `Querybox` (see\n     * [Coveo Query Syntax Reference](https://docs.coveo.com/en/1552/searching-with-coveo/coveo-cloud-query-syntax)). Setting this\n     * option to `true` also causes the `Querybox` to highlight any query syntax.\n     *\n     * Regardless of the value of this option, the Coveo Cloud REST Search API always interprets expressions surrounded\n     * by double quotes (`\"`) as exact phrase match requests.\n     *\n     * See also [`enableLowercaseOperators`]{@link Querybox.options.enableLowercaseOperators}.\n     *\n     * **Notes:**\n     * > * End user preferences can override the value you specify for this option.\n     * >\n     * > If the end user selects a value other than **Automatic** for the **Enable query syntax** setting (see\n     * > the [`enableQuerySyntax`]{@link ResultsPreferences.options.enableQuerySyntax} option of the\n     * > [`ResultsPreferences`]{@link ResultsPreferences} component), the end user preference takes precedence over this\n     * > option.\n     * >\n     * > * On-premises versions of the Coveo Search API require this option to be set to `true` in order to interpret\n     * > expressions surrounded by double quotes (`\"`) as exact phrase match requests.\n     *\n     * Default value is `false`.\n     */\n    enableQuerySyntax: ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n\n    /**\n     * Specifies whether to expand basic expression keywords containing wildcards characters (`*`) to the possible\n     * matching keywords in order to broaden the query (see\n     * [Using Wildcards in Queries](https://docs.coveo.com/en/1580/)).\n     *\n     * See also [`enableQuestionMarks`]{@link Querybox.options.enableQuestionMarks}.\n     *\n     *  **Note:**\n     * > If you are using an on-premises version of the Coveo Search API, you need to set the\n     * > [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option to `true` to be able to set\n     * > `enableWildcards` to `true`.\n     *\n     * Default value is `false`.\n     */\n    enableWildcards: ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n\n    /**\n     * If [`enableWildcards`]{@link Querybox.options.enableWildcards} is `true`, specifies whether to expand basic\n     * expression keywords containing question mark characters (`?`) to the possible matching keywords in order to\n     * broaden the query (see\n     * [Using Wildcards in Queries](https://docs.coveo.com/en/1580/)).\n     *\n     * **Note:**\n     * > If you are using an on-premises version of the Coveo Search API, you also need to set the\n     * > [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option to `true` in order to be able to set\n     * > `enableQuestionMarks` to `true`.\n     *\n     * Default value is `false`.\n     */\n    enableQuestionMarks: ComponentOptions.buildBooleanOption({ defaultValue: false, depend: 'enableWildcards' }),\n\n    /**\n     * If the [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option is `true`, specifies whether to\n     * interpret the `AND`, `NOT`, `OR`, and `NEAR` keywords in the `Querybox` as query operators in the query, even if\n     * the end user types those keywords in lowercase.\n     *\n     * This option applies to all query operators (see\n     * [Coveo Query Syntax Reference](https://docs.coveo.com/en/1552/searching-with-coveo/coveo-cloud-query-syntax)).\n     *\n     * **Example:**\n     * > If this option and the `enableQuerySyntax` option are both `true`, the Coveo Platform interprets the `near`\n     * > keyword in a query such as `service center near me` as the `NEAR` query operator (not as a query term).\n     *\n     * > Otherwise, if the `enableQuerySyntax` option is `true` and this option is `false`, the end user has to type the\n     * > `NEAR` keyword in uppercase for the Coveo Platform to interpret it as a query operator.\n     *\n     * Default value is `false`.\n     */\n    enableLowercaseOperators: ComponentOptions.buildBooleanOption({ defaultValue: false, depend: 'enableQuerySyntax' }),\n\n    /**\n     * Whether to convert a basic expression containing at least a certain number of keywords (see the\n     * [`partialMatchKeywords`]{@link Querybox.options.partialMatchKeywords} option) to *partial match expression*, so\n     * that items containing at least a certain number of those keywords (see the\n     * [`partialMatchThreshold`]{@link Querybox.options.partialMatchThreshold} option) will match the expression.\n     *\n     * **Notes:**\n     * - Only the basic expression of the query (see [`q`]{@link q}) can be converted to a partial match expression.\n     * - When the [`enableQuerySyntax`]{@link Querybox.options.enableQuerySyntax} option is set to `true`, this feature has no effect if the basic expression contains advanced query syntax (field expressions, operators, etc.).\n     *\n     * @notSupportedIn salesforcefree\n     */\n    enablePartialMatch: ComponentOptions.buildBooleanOption({ defaultValue: false }),\n\n    /**\n     * The minimum number of keywords that need to be present in the basic expression to convert it to a partial match expression.\n     *\n     * See also the [`partialMatchThreshold`]{@link Querybox.options.partialMatchThreshold} option.\n     *\n     * **Notes:**\n     *\n     * - Repeated keywords count as a single keyword.\n     * - Thesaurus expansions count towards the `partialMatchKeywords` count.\n     * - Stemming expansions **do not** count towards the `partialMatchKeywords` count.\n     *\n     * @notSupportedIn salesforcefree\n     */\n    partialMatchKeywords: ComponentOptions.buildNumberOption({ defaultValue: 5, min: 1, depend: 'enablePartialMatch' }),\n\n    /**\n     * An absolute or relative value indicating the minimum number of partial match expression keywords an item must contain to match the expression.\n     *\n     * See also the [`partialMatchKeywords`]{@link Querybox.options.partialMatchKeywords} option.\n     *\n     * **Notes:**\n     * - A keyword and its stemming expansions count as a single keyword when evaluating whether an item meets the `partialMatchThreshold`.\n     * - When a relative `partialMatchThreshold` does not yield a whole integer, the fractional part is truncated (e.g., `3.6` becomes `3`).\n     *\n     * @notSupportedIn salesforcefree\n     */\n    partialMatchThreshold: ComponentOptions.buildStringOption({ defaultValue: '50%', depend: 'enablePartialMatch' }),\n\n    /**\n     * Whether to trigger a query when clearing the `Querybox`.\n     *\n     * Default value is `false`.\n     */\n    triggerQueryOnClear: ComponentOptions.buildBooleanOption({ defaultValue: false })\n  };\n  MagicBoxImpl;\n\n  public magicBox: MagicBoxInstance;\n  private lastQuery: string;\n  private searchAsYouTypeTimeout: number;\n\n  /**\n   * Creates a new `Querybox component`. Creates a new `Coveo.Magicbox` instance and wraps the Magicbox methods\n   * (`onblur`, `onsubmit` etc.). Binds event on `buildingQuery` and before redirection (for standalone box).\n   * @param element The HTMLElement on which to instantiate the component. This cannot be an HTMLInputElement for\n   * technical reasons.\n   * @param options The options for the `Querybox` component.\n   * @param bindings The bindings that the component requires to function normally. If not set, these will be\n   * automatically resolved (with a slower execution time).\n   */\n  constructor(public element: HTMLElement, public options?: IQueryboxOptions, public bindings?: IComponentBindings) {\n    super(element, Querybox.ID, bindings);\n\n    if (element instanceof HTMLInputElement) {\n      this.logger.error('Querybox cannot be used on an HTMLInputElement');\n    }\n\n    this.options = ComponentOptions.initComponentOptions(element, Querybox, options);\n    new QueryboxOptionsProcessing(this).postProcess();\n\n    $$(this.element).toggleClass('coveo-query-syntax-disabled', this.options.enableQuerySyntax == false);\n    this.magicBox = createMagicBox(\n      element,\n      new Grammar('Query', {\n        Query: '[Term*][Spaces?]',\n        Term: '[Spaces?][Word]',\n        Spaces: / +/,\n        Word: /[^ ]+/\n      }),\n      {\n        inline: true\n      }\n    );\n\n    const input = $$(this.magicBox.element).find('input');\n    if (input) {\n      $$(input).setAttribute('aria-label', this.options.placeholder || l('Search'));\n    }\n\n    this.bind.onRootElement(QueryEvents.buildingQuery, (args: IBuildingQueryEventArgs) => this.handleBuildingQuery(args));\n    this.bind.onRootElement(StandaloneSearchInterfaceEvents.beforeRedirect, () => this.updateQueryState());\n    this.bind.onQueryState(MODEL_EVENTS.CHANGE_ONE, QUERY_STATE_ATTRIBUTES.Q, (args: IAttributeChangedEventArg) =>\n      this.handleQueryStateChanged(args)\n    );\n\n    if (this.options.enableSearchAsYouType) {\n      $$(this.element).addClass('coveo-search-as-you-type');\n      this.magicBox.onchange = () => {\n        this.searchAsYouType();\n      };\n    }\n\n    this.magicBox.onsubmit = () => {\n      this.submit();\n    };\n\n    this.magicBox.onblur = () => {\n      this.updateQueryState();\n    };\n\n    this.magicBox.onclear = () => {\n      this.updateQueryState();\n      if (this.options.triggerQueryOnClear) {\n        this.usageAnalytics.logSearchEvent<IAnalyticsNoMeta>(analyticsActionCauseList.searchboxClear, {});\n        this.triggerNewQuery(false);\n      }\n    };\n  }\n\n  /**\n   * Adds the current content of the input to the query and triggers a query if the current content of the input has\n   * changed since last submit.\n   *\n   * Also logs the `serachboxSubmit` event in the usage analytics.\n   */\n  public submit(): void {\n    this.magicBox.clearSuggestion();\n    this.updateQueryState();\n    this.usageAnalytics.logSearchEvent<IAnalyticsNoMeta>(analyticsActionCauseList.searchboxSubmit, {});\n    this.triggerNewQuery(false);\n  }\n\n  /**\n   * Sets the content of the input.\n   *\n   * @param text The string to set in the input.\n   */\n  public setText(text: string): void {\n    this.magicBox.setText(text);\n    this.updateQueryState();\n  }\n\n  /**\n   * Clears the content of the input.\n   *\n   * See also the [`triggerQueryOnClear`]{@link Querybox.options.triggerQueryOnClear} option.\n   */\n  public clear(): void {\n    this.magicBox.clear();\n  }\n\n  /**\n   * Gets the content of the input.\n   *\n   * @returns {string} The content of the input.\n   */\n  public getText(): string {\n    return this.magicBox.getText();\n  }\n\n  /**\n   * Gets the result from the input.\n   *\n   * @returns {Result} The result.\n   */\n  public getResult() {\n    return this.magicBox.getResult();\n  }\n\n  /**\n   * Gets the displayed result from the input.\n   *\n   * @returns {Result} The displayed result.\n   */\n  public getDisplayedResult(): Result {\n    return this.magicBox.getDisplayedResult();\n  }\n\n  /**\n   * Gets the current cursor position in the input.\n   *\n   * @returns {number} The cursor position (index starts at 0).\n   */\n  public getCursor(): number {\n    return this.magicBox.getCursor();\n  }\n\n  /**\n   * Gets the result at cursor position.\n   *\n   * @param match {string | { (result): boolean }} The match condition.\n   *\n   * @returns {Result[]} The result.\n   */\n  public resultAtCursor(match?: string | { (result): boolean }) {\n    return this.magicBox.resultAtCursor(match);\n  }\n\n  private handleBuildingQuery(args: IBuildingQueryEventArgs): void {\n    Assert.exists(args);\n    Assert.exists(args.queryBuilder);\n\n    this.updateQueryState();\n    this.lastQuery = this.magicBox.getText();\n    new QueryboxQueryParameters(this.options).addParameters(args.queryBuilder, this.lastQuery);\n  }\n\n  private triggerNewQuery(searchAsYouType: boolean): void {\n    clearTimeout(this.searchAsYouTypeTimeout);\n    let text = this.magicBox.getText();\n    if (this.lastQuery != text && text != null) {\n      this.lastQuery = text;\n      this.queryController.executeQuery({\n        searchAsYouType: searchAsYouType,\n        logInActionsHistory: true\n      });\n    }\n  }\n\n  private updateQueryState(): void {\n    this.queryStateModel.set(QueryStateModel.attributesEnum.q, this.magicBox.getText());\n  }\n\n  private handleQueryStateChanged(args: IAttributeChangedEventArg): void {\n    Assert.exists(args);\n    let q = <string>args.value;\n    if (q != this.magicBox.getText()) {\n      this.magicBox.setText(q);\n    }\n  }\n\n  private searchAsYouType(): void {\n    clearTimeout(this.searchAsYouTypeTimeout);\n    this.searchAsYouTypeTimeout = window.setTimeout(() => {\n      this.usageAnalytics.logSearchAsYouType<IAnalyticsNoMeta>(analyticsActionCauseList.searchboxAsYouType, {});\n      this.triggerNewQuery(true);\n    }, this.options.searchAsYouTypeDelay);\n  }\n}\nInitialization.registerAutoCreateComponent(Querybox);\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Querybox/Querybox.ts","import { ExpressionRef } from './Expression/ExpressionRef';\nimport { Expression, ExpressionDef } from './Expression/Expression';\nimport { ExpressionOptions } from './Expression/ExpressionOptions';\nimport { ExpressionRegExp } from './Expression/ExpressionRegExp';\nimport _ = require('underscore');\nimport { ExpressionFunction, ExpressionFunctionArgument } from './Expression/ExpressionFunction';\nimport { ExpressionConstant } from './Expression/ExpressionConstant';\nimport { ExpressionList } from './Expression/ExpressionList';\nimport { Result } from './Result/Result';\n\nexport class Grammar {\n  public start: ExpressionRef;\n  public expressions: { [id: string]: Expression } = {};\n\n  constructor(start: string, expressions: { [id: string]: ExpressionDef } = {}) {\n    this.start = new ExpressionRef(start, null, 'start', this);\n    this.addExpressions(expressions);\n  }\n\n  public addExpressions(expressions: { [id: string]: ExpressionDef }) {\n    _.each(expressions, (basicExpression: ExpressionDef, id: string) => {\n      this.addExpression(id, basicExpression);\n    });\n  }\n\n  public addExpression(id: string, basicExpression: ExpressionDef) {\n    if (id in this.expressions) {\n      throw new Error('Grammar already contain the id:' + id);\n    }\n    this.expressions[id] = Grammar.buildExpression(basicExpression, id, this);\n  }\n\n  public getExpression(id: string) {\n    return this.expressions[id];\n  }\n\n  public parse(value: string): Result {\n    return this.start.parse(value, true);\n  }\n\n  public static buildExpression(value: ExpressionDef, id: string, grammar: Grammar): Expression {\n    const type = typeof value;\n    if (type == 'undefined') {\n      throw new Error('Invalid Expression: ' + value);\n    }\n    if (_.isString(value)) {\n      return this.buildStringExpression(<string>value, id, grammar);\n    }\n    if (_.isArray(value)) {\n      return new ExpressionOptions(_.map(<string[]>value, (v: string, i) => new ExpressionRef(v, null, id + '_' + i, grammar)), id);\n    }\n    if (_.isRegExp(value)) {\n      return new ExpressionRegExp(<RegExp>value, id, grammar);\n    }\n    if (_.isFunction(value)) {\n      return new ExpressionFunction(<ExpressionFunctionArgument>value, id, grammar);\n    }\n    throw new Error('Invalid Expression: ' + value);\n  }\n\n  public static buildStringExpression(value: string, id: string, grammar: Grammar): Expression {\n    const matchs = Grammar.stringMatch(value, Grammar.spliter);\n    const expressions = _.map(matchs, (match: string[], i: number): Expression => {\n      if (match[1]) {\n        // Ref\n        const ref = match[1];\n        const occurrence = match[3] ? Number(match[3]) : match[2] || null;\n        return new ExpressionRef(ref, occurrence, id + '_' + i, grammar);\n      } else {\n        // Constant\n        return new ExpressionConstant(match[4], id + '_' + i);\n      }\n    });\n    if (expressions.length == 1) {\n      const expression = expressions[0];\n      expression.id = id;\n      return expression;\n    } else {\n      return new ExpressionList(expressions, id);\n    }\n  }\n\n  public static stringMatch(str: string, re: RegExp) {\n    const groups: string[][] = [];\n    const cloneRegExp = new RegExp(re.source, 'g');\n    let group: RegExpExecArray = cloneRegExp.exec(str);\n\n    while (group !== null) {\n      groups.push(group);\n      group = cloneRegExp.exec(str);\n    }\n    return groups;\n  }\n\n  static spliter = /\\[(\\w+)(\\*|\\+|\\?|\\{([1-9][0-9]*)\\})?\\]|(.[^\\[]*)/;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammar.ts","///<reference path=\"FieldAddon.ts\" />\n///<reference path=\"QueryExtensionAddon.ts\" />\n///<reference path=\"QuerySuggestAddon.ts\" />\n///<reference path=\"OldOmniboxAddon.ts\" />\n\nimport 'styling/_Omnibox';\nimport * as _ from 'underscore';\nimport { findWhere } from 'underscore';\nimport { BreadcrumbEvents } from '../../events/BreadcrumbEvents';\nimport {\n  IOmniboxPreprocessResultForQueryEventArgs,\n  IPopulateOmniboxSuggestionsEventArgs,\n  IQuerySuggestSelection,\n  OmniboxEvents\n} from '../../events/OmniboxEvents';\nimport { IBuildingQueryEventArgs, IDuringQueryEventArgs, INewQueryEventArgs, QueryEvents } from '../../events/QueryEvents';\nimport { StandaloneSearchInterfaceEvents } from '../../events/StandaloneSearchInterfaceEvents';\nimport { exportGlobally } from '../../GlobalExports';\nimport { ExpressionDef } from '../../magicbox/Expression/Expression';\nimport { Grammar } from '../../magicbox/Grammar';\nimport { Complete } from '../../magicbox/Grammars/Complete';\nimport { Expressions } from '../../magicbox/Grammars/Expressions';\nimport { createMagicBox, MagicBoxInstance } from '../../magicbox/MagicBox';\nimport { Result } from '../../magicbox/Result/Result';\nimport { Suggestion } from '../../magicbox/SuggestionsManager';\nimport { Assert } from '../../misc/Assert';\nimport { COMPONENT_OPTIONS_ATTRIBUTES } from '../../models/ComponentOptionsModel';\nimport { IAttributeChangedEventArg, MODEL_EVENTS } from '../../models/Model';\nimport { QueryStateModel, QUERY_STATE_ATTRIBUTES } from '../../models/QueryStateModel';\nimport { l } from '../../strings/Strings';\nimport { $$, Dom } from '../../utils/Dom';\nimport { Utils } from '../../utils/Utils';\nimport {\n  analyticsActionCauseList,\n  IAnalyticsActionCause,\n  IAnalyticsNoMeta,\n  IAnalyticsOmniboxSuggestionMeta\n} from '../Analytics/AnalyticsActionListMeta';\nimport { PendingSearchAsYouTypeSearchEvent } from '../Analytics/PendingSearchAsYouTypeSearchEvent';\nimport { logSearchBoxSubmitEvent } from '../Analytics/SharedAnalyticsCalls';\nimport { Component } from '../Base/Component';\nimport { IComponentBindings } from '../Base/ComponentBindings';\nimport { ComponentOptions } from '../Base/ComponentOptions';\nimport { IFieldOption } from '../Base/IComponentOptions';\nimport { Initialization } from '../Base/Initialization';\nimport { IQueryboxOptions, Querybox } from '../Querybox/Querybox';\nimport { QueryboxOptionsProcessing } from '../Querybox/QueryboxOptionsProcessing';\nimport { QueryboxQueryParameters } from '../Querybox/QueryboxQueryParameters';\nimport { StandaloneSearchInterface } from '../SearchInterface/SearchInterface';\nimport { FieldAddon } from './FieldAddon';\nimport { OldOmniboxAddon } from './OldOmniboxAddon';\nimport { OmniboxAnalytics } from './OmniboxAnalytics';\nimport { QueryExtensionAddon } from './QueryExtensionAddon';\nimport { IQuerySuggestAddon, QuerySuggestAddon, VoidQuerySuggestAddon } from './QuerySuggestAddon';\n\nexport interface IOmniboxSuggestion extends Suggestion {\n  executableConfidence?: number;\n}\n\nexport interface IOmniboxOptions extends IQueryboxOptions {\n  inline?: boolean;\n  enableFieldAddon?: boolean;\n  enableSimpleFieldAddon?: boolean;\n  listOfFields?: IFieldOption[];\n  fieldAlias?: { [alias: string]: IFieldOption };\n  enableQuerySuggestAddon?: boolean;\n  enableQueryExtensionAddon?: boolean;\n  omniboxTimeout?: number;\n  placeholder?: string;\n  numberOfSuggestions?: number;\n  querySuggestCharacterThreshold?: number;\n  grammar?: (grammar: {\n    start: string;\n    expressions: { [id: string]: ExpressionDef };\n  }) => { start: string; expressions: { [id: string]: ExpressionDef } };\n  clearFiltersOnNewQuery?: boolean;\n}\n\nconst MINIMUM_EXECUTABLE_CONFIDENCE = 0.8;\n\n/**\n * The `Omnibox` component extends the [`Querybox`]{@link Querybox}, and thus provides the same basic options and\n * behaviors. Furthermore, the `Omnibox` adds a type-ahead capability to the search input.\n *\n * You can configure the type-ahead feature by enabling or disabling certain addons, which the Coveo JavaScript Search\n * Framework provides out-of-the-box (see the [`enableFieldAddon`]{@link Omnibox.options.enableFieldAddon},\n * [`enableQueryExtension`]{@link Omnibox.options.enableQueryExtensionAddon}, and\n * [`enableQuerySuggestAddon`]{@link Omnibox.options.enableQuerySuggestAddon} options).\n *\n * Custom components and external code can also extend or customize the type-ahead feature and the query completion\n * suggestions it provides by attaching their own handlers to the\n * [`populateOmniboxSuggestions`]{@link OmniboxEvents.populateOmniboxSuggestions} event.\n *\n * See also the [`Searchbox`]{@link Searchbox} component, which can automatically instantiate an `Omnibox` along with an\n * optional {@link SearchButton}.\n */\nexport class Omnibox extends Component {\n  public static ID = 'Omnibox';\n\n  static doExport = () => {\n    exportGlobally({\n      Omnibox: Omnibox,\n      QueryboxQueryParameters: QueryboxQueryParameters\n    });\n  };\n\n  /**\n   * The options for the omnibox\n   * @componentOptions\n   */\n  static options: IOmniboxOptions = {\n    /**\n     * Specifies whether query completion suggestions appearing in the `Omnibox` should push the result list and facets\n     * down, rather than rendering themselves over them (and partially hiding them).\n     *\n     * Set this option as well as {@link Omnibox.options.enableSearchAsYouType} and\n     * {@link Omnibox.options.enableQuerySuggestAddon} to `true` for a cool effect!\n     *\n     * Default value is `false`.\n     */\n    inline: ComponentOptions.buildBooleanOption({ defaultValue: false }),\n\n    /**\n     * Whether to automatically trigger a new query whenever the end user types additional text in the search box input.\n     *\n     * See also the [`searchAsYouTypeDelay`]{@link Omnibox.options.searchAsYouTypeDelay} option.\n     *\n     * **Note:**\n     * > If you set this option and the [`enableQuerySuggestAddon`]{@link Omnibox.options.enableQuerySuggestAddon}\n     * > option to `true`, the query suggestion feature returns the auto-completion of the currently typed keyword as\n     * > its first suggestion.\n     *\n     * Default value is `false`.\n     */\n    enableSearchAsYouType: ComponentOptions.buildBooleanOption({ defaultValue: false, section: 'Advanced Options' }),\n\n    /**\n     * If {@link Omnibox.options.enableSearchAsYouType} is `true`, specifies the delay (in milliseconds) before\n     * triggering a new query when the end user types in the `Omnibox`.\n     *\n     * Default value is `2000`. Minimum value is `0`.\n     */\n    searchAsYouTypeDelay: ComponentOptions.buildNumberOption({\n      defaultValue: 2000,\n      min: 0,\n      depend: 'enableSearchAsYouType',\n      section: 'Advanced Options'\n    }),\n\n    /**\n     * The `field` addon makes the `Omnibox` highlight and complete field syntax. Setting this option to `true` automatically sets\n     * the [enableQuerySyntax]{@link Querybox.options.enableQuerySyntax} option to `true` as a side effect.\n     *\n     * **Example:**\n     * > Suppose you want to search for PDF files. You start typing `@f` in the search box. The `Omnibox` provides\n     * > you with several matching fields. You select the `@filetype` field. Then, you start typing `=p` in the input.\n     * > This time, the `Omnibox` provides you with several matching values for the `@filetype` field. You select the\n     * > `pdf` suggestion, and submit your search request. Since the `enableQuerySyntax` option is set to `true`, the\n     * > Coveo Search API interprets the basic expression as query syntax and returns the items whose `@filetype` field\n     * > matches the `pdf` value.\n     *\n     * Default value is `false`.\n     */\n    enableFieldAddon: ComponentOptions.buildBooleanOption({\n      defaultValue: false,\n      depend: 'enableQuerySyntax',\n      postProcessing: (value, options: IOmniboxOptions) => {\n        if (value) {\n          options.enableQuerySyntax = true;\n        }\n        return value;\n      },\n      section: 'Advanced Options'\n    }),\n    enableSimpleFieldAddon: ComponentOptions.buildBooleanOption({ defaultValue: false, depend: 'enableFieldAddon' }),\n    listOfFields: ComponentOptions.buildFieldsOption({ depend: 'enableFieldAddon' }),\n\n    /**\n     * Whether to display Coveo Machine Learning (Coveo ML) query suggestions in the `Omnibox`.\n     *\n     * A Coveo ML query suggestions (QS) model must be properly configured in your Coveo Cloud organization, otherwise this\n     * option has no effect (see\n     * [Create a QS Model](https://docs.coveo.com/en/1832/#create-a-qs-model)).\n     *\n     * **Note:**\n     * > When you set this option and the [`enableSearchAsYouType`]{@link Omnibox.options.enableSearchAsYouType} option\n     * > to `true`, the query suggestion feature returns the auto-completion of the currently typed keyword as its first\n     * > query suggestion.\n     *\n     * @availablesince [December 2015 Release (v1.0.273)](https://docs.coveo.com/en/289/#december-2015-release-v10273)\n     */\n    enableQuerySuggestAddon: ComponentOptions.buildBooleanOption({\n      defaultValue: true,\n      alias: ['enableTopQueryAddon', 'enableRevealQuerySuggestAddon']\n    }),\n\n    /**\n     * If {@link Querybox.options.enableQuerySyntax} is `true`, specifies whether to enable the `query extension` addon.\n     *\n     * The `query extension` addon allows the Omnibox to complete the syntax for query extensions.\n     *\n     * Default value is `false`.\n     */\n    enableQueryExtensionAddon: ComponentOptions.buildBooleanOption({\n      defaultValue: false,\n      depend: 'enableQuerySyntax',\n      postProcessing: (value, options: IOmniboxOptions) => {\n        if (value) {\n          options.enableQuerySyntax = true;\n        }\n        return value;\n      },\n      section: 'Advanced Options'\n    }),\n\n    /**\n     * Specifies a placeholder for the input.\n     *\n     * @availablesince [July 2016 Release (v1.667.24)](https://docs.coveo.com/en/309/#july-2016-release-v166724)\n     */\n    placeholder: ComponentOptions.buildLocalizedStringOption(),\n\n    /**\n     * Specifies a timeout (in milliseconds) before rejecting suggestions in the Omnibox.\n     *\n     * Default value is `2000`. Minimum value is `0`.\n     */\n    omniboxTimeout: ComponentOptions.buildNumberOption({ defaultValue: 2000, min: 0 }),\n    /**\n     * Specifies whether the Coveo Platform should try to interpret special query syntax such as field references in the\n     * query that the user enters in the Querybox (see\n     * [Coveo Query Syntax Reference](https://docs.coveo.com/en/1552/searching-with-coveo/coveo-cloud-query-syntax)).\n     *\n     * Setting this option to `true` also causes the query syntax in the Querybox to highlight.\n     *\n     * Default value is `false`.\n     */\n    enableQuerySyntax: ComponentOptions.buildBooleanOption({\n      defaultValue: false,\n      section: 'Advanced Options'\n    }),\n    /**\n     * Specifies the number of suggestions that should appear in standard ML-powered query suggestions.\n     *\n     * This option only affects the number of suggestions that appear with the {@link Omnibox.options.enableQuerySuggestAddon} option.\n     *\n     * This options does not affect the {@link AnalyticsSuggestions} or the {@link FieldSuggestions} component, which expose their own dedicated options for this parameter.\n     *\n     * Default value is `5`.\n     *\n     * Minimum value is `1`.\n     */\n    numberOfSuggestions: ComponentOptions.buildNumberOption({\n      defaultValue: 5,\n      min: 1\n    }),\n    /**\n     * The minimum number of characters required in the in the text input before displaying available query suggestions when focus is on the component.\n     *\n     * Note: Only effective when [enableQuerySuggestAddon]{@link Omnibox.options.enableQuerySuggestAddon} is true.\n     *\n     * depend: 'enableQuerySuggestAddon'\n     *\n     * Default (and minimum): 0, meaning that trending query suggestions are displayed when focus is on the component, even if its text input is empty.\n     *\n     * @availablesince [July 2019 Release (v2.6459)](https://docs.coveo.com/en/2938/)\n     */\n    querySuggestCharacterThreshold: ComponentOptions.buildNumberOption({\n      defaultValue: 0,\n      min: 0\n    }),\n\n    /**\n     * Whether to clear all active query filters when the end user submits a new query from the search box.\n     *\n     * Note: This does not include the filter expression enforced by the currently selected tab, if any.\n     *\n     * @availablesince [September 2019 Release (v2.7023)](https://docs.coveo.com/en/2990/)\n     */\n    clearFiltersOnNewQuery: ComponentOptions.buildBooleanOption({ defaultValue: false })\n  };\n\n  public magicBox: MagicBoxInstance;\n  private lastSuggestions: IOmniboxSuggestion[] = [];\n  private lastQuery: string;\n  private modifyEventTo: IAnalyticsActionCause;\n  private movedOnce = false;\n  private searchAsYouTypeTimeout: number;\n  private skipAutoSuggest = false;\n  private omniboxAnalytics: OmniboxAnalytics;\n\n  public suggestionAddon: IQuerySuggestAddon;\n\n  /**\n   * Creates a new Omnibox component. Also enables necessary addons and binds events on various query events.\n   * @param element The HTMLElement on which to instantiate the component.\n   * @param options The options for the Omnibox component.\n   * @param bindings The bindings that the component requires to function normally. If not set, these will be\n   * automatically resolved (with a slower execution time).\n   */\n  constructor(public element: HTMLElement, public options?: IOmniboxOptions, bindings?: IComponentBindings) {\n    super(element, Omnibox.ID, bindings);\n\n    this.options = ComponentOptions.initComponentOptions(element, Omnibox, options);\n    const originalValueForQuerySyntax = this.options.enableQuerySyntax;\n    new QueryboxOptionsProcessing(this).postProcess();\n    this.omniboxAnalytics = this.searchInterface.getOmniboxAnalytics();\n    $$(this.element).toggleClass('coveo-query-syntax-disabled', this.options.enableQuerySyntax == false);\n\n    this.suggestionAddon = this.options.enableQuerySuggestAddon ? new QuerySuggestAddon(this) : new VoidQuerySuggestAddon();\n    new OldOmniboxAddon(this);\n    this.createMagicBox();\n\n    this.bind.onRootElement(QueryEvents.newQuery, (args: INewQueryEventArgs) => this.handleNewQuery(args));\n    this.bind.onRootElement(QueryEvents.buildingQuery, (args: IBuildingQueryEventArgs) => this.handleBuildingQuery(args));\n    this.bind.onRootElement(StandaloneSearchInterfaceEvents.beforeRedirect, () => this.handleBeforeRedirect());\n    this.bind.onRootElement(QueryEvents.querySuccess, () => this.handleQuerySuccess());\n    this.bind.onQueryState(MODEL_EVENTS.CHANGE_ONE, QUERY_STATE_ATTRIBUTES.Q, (args: IAttributeChangedEventArg) =>\n      this.handleQueryStateChanged(args)\n    );\n    if (this.isAutoSuggestion()) {\n      this.bind.onRootElement(QueryEvents.duringQuery, (args: IDuringQueryEventArgs) => this.handleDuringQuery(args));\n    }\n    this.bind.onComponentOptions(MODEL_EVENTS.CHANGE_ONE, COMPONENT_OPTIONS_ATTRIBUTES.SEARCH_BOX, (args: IAttributeChangedEventArg) => {\n      if (args.value.enableQuerySyntax != null) {\n        this.options.enableQuerySyntax = args.value.enableQuerySyntax;\n      } else {\n        this.options.enableQuerySyntax = originalValueForQuerySyntax;\n      }\n      this.updateGrammar();\n    });\n    this.bind.onRootElement(OmniboxEvents.querySuggestGetFocus, (args: IQuerySuggestSelection) => this.handleQuerySuggestGetFocus(args));\n  }\n\n  /**\n   * Adds the current content of the input to the query and triggers a query if the current content of the input has\n   * changed since last submit.\n   *\n   * Also logs a `searchboxSubmit` event in the usage analytics.\n   */\n  public submit() {\n    this.magicBox.clearSuggestion();\n    this.updateQueryState();\n    this.triggerNewQuery(false, () => {\n      logSearchBoxSubmitEvent(this.usageAnalytics);\n    });\n    this.magicBox.blur();\n  }\n\n  /**\n   * Gets the current content of the input.\n   * @returns {string} The current content of the input.\n   */\n  public getText() {\n    return this.magicBox.getText();\n  }\n\n  /**\n   * Sets the content of the input\n   * @param text The string to set in the input.\n   */\n  public setText(text: string) {\n    this.magicBox.setText(text);\n    this.updateQueryState();\n  }\n\n  /**\n   * Clears the content of the input.\n   */\n  public clear() {\n    this.magicBox.clear();\n  }\n\n  /**\n   * Gets the `HTMLInputElement` of the Omnibox.\n   */\n  public getInput() {\n    return <HTMLInputElement>this.magicBox.element.querySelector('input');\n  }\n\n  public getResult() {\n    return this.magicBox.getResult();\n  }\n\n  public getDisplayedResult() {\n    return this.magicBox.getDisplayedResult();\n  }\n\n  public getCursor() {\n    return this.magicBox.getCursor();\n  }\n\n  public resultAtCursor(match?: string | { (result: Result): boolean }) {\n    return this.magicBox.resultAtCursor(match);\n  }\n\n  private createGrammar() {\n    let grammar = null;\n\n    if (this.options.enableQuerySyntax) {\n      grammar = Expressions(Complete);\n      if (this.options.enableFieldAddon) {\n        new FieldAddon(this);\n      }\n      if (this.options.fieldAlias != null) {\n        this.options.listOfFields = this.options.listOfFields || [];\n        this.options.listOfFields = this.options.listOfFields.concat(_.keys(this.options.fieldAlias));\n      }\n      if (this.options.enableQueryExtensionAddon) {\n        new QueryExtensionAddon(this);\n      }\n    } else {\n      grammar = { start: 'Any', expressions: { Any: /.*/ } };\n    }\n\n    if (this.options.grammar != null) {\n      grammar = this.options.grammar(grammar);\n    }\n\n    return grammar;\n  }\n\n  private updateGrammar() {\n    const grammar = this.createGrammar();\n    this.magicBox.grammar = new Grammar(grammar.start, grammar.expressions);\n    this.magicBox.setText(this.magicBox.getText());\n  }\n\n  private createMagicBox() {\n    const grammar = this.createGrammar();\n    this.magicBox = createMagicBox(this.element, new Grammar(grammar.start, grammar.expressions), {\n      inline: this.options.inline,\n      selectableSuggestionClass: 'coveo-omnibox-selectable',\n      selectedSuggestionClass: 'coveo-omnibox-selected',\n      suggestionTimeout: this.options.omniboxTimeout\n    });\n\n    const input = $$(this.magicBox.element).find('input');\n\n    if (input) {\n      $$(input).setAttribute('aria-label', l('Search'));\n    }\n\n    this.setupMagicBox();\n  }\n\n  private setupMagicBox() {\n    this.magicBox.onmove = () => {\n      // We assume that once the user has moved its selection, it becomes an explicit omnibox analytics event\n      if (this.isAutoSuggestion()) {\n        this.modifyEventTo = this.getOmniboxAnalyticsEventCause();\n      }\n      this.movedOnce = true;\n    };\n\n    this.magicBox.onfocus = () => {\n      if (this.isAutoSuggestion()) {\n        // This flag is used to block the automatic query when the UI is loaded with a query (#q=foo)\n        // and then the input is focused. We want to block that query, even if it match the suggestion\n        // Only when there is an actual change in the input (user typing something) is when we want the automatic query to kick in\n        this.skipAutoSuggest = true;\n      }\n    };\n\n    this.magicBox.onSuggestions = (suggestions: IOmniboxSuggestion[]) => {\n      // If text is empty, this can mean that user selected text from the search box\n      // and hit \"delete\" : Reset the partial queries in this case\n      if (Utils.isEmptyString(this.getText())) {\n        this.omniboxAnalytics.partialQueries = [];\n      }\n      this.movedOnce = false;\n      this.lastSuggestions = suggestions;\n      if (this.isAutoSuggestion() && !this.skipAutoSuggest) {\n        this.searchAsYouType();\n      }\n    };\n\n    if (this.options.enableSearchAsYouType) {\n      $$(this.element).addClass('coveo-magicbox-search-as-you-type');\n    }\n\n    this.magicBox.onchange = () => {\n      this.skipAutoSuggest = false;\n      const text = this.getText();\n      if (text != undefined && text != '') {\n        if (this.isAutoSuggestion()) {\n          if (this.movedOnce) {\n            this.searchAsYouType(true);\n          }\n        } else if (this.options.enableSearchAsYouType) {\n          this.searchAsYouType(true);\n        }\n      } else {\n        this.clear();\n      }\n    };\n\n    if (this.options.placeholder) {\n      (<HTMLInputElement>this.magicBox.element.querySelector('input')).placeholder = this.options.placeholder;\n    }\n    this.magicBox.onsubmit = () => this.submit();\n\n    this.magicBox.onselect = (suggestion: IOmniboxSuggestion) => {\n      const index = _.indexOf(this.lastSuggestions, suggestion);\n      const suggestions = _.compact(_.map(this.lastSuggestions, suggestion => suggestion.text));\n      this.magicBox.clearSuggestion();\n      this.updateQueryState();\n      // A bit tricky here : When it's machine learning auto suggestions\n      // the mouse selection and keyboard selection acts differently :\n      // keyboard selection will automatically do the query (which will log a search as you type event -> further modified by this.modifyEventTo if needed)\n      // mouse selection will not \"auto\" send the query.\n      // the movedOnce variable detect the keyboard movement, and is used to differentiate mouse vs keyboard\n      if (!this.isAutoSuggestion()) {\n        this.usageAnalytics.cancelAllPendingEvents();\n        this.triggerNewQuery(false, () => {\n          this.usageAnalytics.logSearchEvent<IAnalyticsOmniboxSuggestionMeta>(\n            this.getOmniboxAnalyticsEventCause(),\n            this.buildCustomDataForPartialQueries(index, suggestions)\n          );\n        });\n      } else if (this.isAutoSuggestion() && this.movedOnce) {\n        this.handleAutoSuggestionWithKeyboard(index, suggestions);\n      } else if (this.isAutoSuggestion() && !this.movedOnce) {\n        this.handleAutoSuggestionsWithMouse(index, suggestions);\n      }\n\n      // Consider a selection like a reset of the partial queries (it's the end of a suggestion pattern)\n      if (this.isAutoSuggestion()) {\n        this.omniboxAnalytics.partialQueries = [];\n      }\n    };\n\n    this.magicBox.onblur = () => {\n      if (this.isAutoSuggestion()) {\n        this.setText(this.getQuery(true));\n        this.usageAnalytics.sendAllPendingEvents();\n      }\n    };\n\n    this.magicBox.onclear = () => {\n      this.updateQueryState();\n      if (this.options.triggerQueryOnClear || this.options.enableSearchAsYouType) {\n        this.triggerNewQuery(false, () => {\n          this.usageAnalytics.logSearchEvent<IAnalyticsNoMeta>(analyticsActionCauseList.searchboxClear, {});\n        });\n      }\n    };\n\n    this.magicBox.ontabpress = () => {\n      this.handleTabPress();\n    };\n\n    this.magicBox.getSuggestions = () => this.handleSuggestions();\n  }\n\n  private handleAutoSuggestionWithKeyboard(index: number, suggestions: string[]) {\n    if (this.searchAsYouTypeTimeout) {\n      // Here, there is currently a search as you typed queued up :\n      // Think : user typed very quickly, then very quickly selected a suggestion (without waiting for the search as you type)\n      // Cancel the search as you type query, then immediately do the query with the selection (+analytics event with the selection)\n      this.usageAnalytics.cancelAllPendingEvents();\n      clearTimeout(this.searchAsYouTypeTimeout);\n      this.searchAsYouTypeTimeout = undefined;\n      this.triggerNewQuery(false, () => {\n        this.usageAnalytics.logSearchEvent<IAnalyticsOmniboxSuggestionMeta>(\n          this.getOmniboxAnalyticsEventCause(),\n          this.buildCustomDataForPartialQueries(index, suggestions)\n        );\n      });\n    } else {\n      // Here, the search as you type query has returned, but the analytics event has not ye been sent.\n      // Think : user typed slowly, the query returned, and then the user selected a suggestion.\n      // Since the analytics event has not yet been sent (search as you type event have a 5 sec delay)\n      // modify the pending event, then send the newly modified analytics event immediately.\n      this.modifyEventTo = this.getOmniboxAnalyticsEventCause();\n      this.modifyCustomDataOnPending(index, suggestions);\n      this.modifyQueryContentOnPending();\n      this.usageAnalytics.sendAllPendingEvents();\n    }\n  }\n\n  private handleAutoSuggestionsWithMouse(index: number, suggestions: string[]) {\n    if (this.searchAsYouTypeTimeout || index != 0) {\n      // Here : the user either very quickly chose the first suggestion, and the search as you type is still queued up.\n      // OR\n      // the user chose something different then the first suggestion.\n      // Remove the search as you type if it's there, and do the query with the suggestion directly.\n      this.clearSearchAsYouType();\n      this.usageAnalytics.cancelAllPendingEvents();\n      this.triggerNewQuery(false, () => {\n        this.usageAnalytics.logSearchEvent<IAnalyticsOmniboxSuggestionMeta>(\n          this.getOmniboxAnalyticsEventCause(),\n          this.buildCustomDataForPartialQueries(index, suggestions)\n        );\n      });\n    } else {\n      // Here : the user either very slowly chose a suggestion, and there is no search as you typed queued up\n      // AND\n      // the user chose the first suggestion.\n      // this means the query is already returned, but the analytics event is still queued up.\n      // modify the analytics event, and send it.\n      this.modifyEventTo = this.getOmniboxAnalyticsEventCause();\n      this.modifyCustomDataOnPending(index, suggestions);\n      this.modifyQueryContentOnPending();\n      this.usageAnalytics.sendAllPendingEvents();\n\n      // This should happen if :\n      // users did a (short) query first, which does not match the first suggestion. (eg: typed \"t\", then search)\n      // then, refocus the search box. The same suggestion(s) will re-appear.\n      // By selecting the first one with the mouse, we need to retrigger a query because this means the search as you type could not\n      // kick in and do the query automatically.\n      if (this.lastQuery != this.getText()) {\n        this.triggerNewQuery(false, () => {\n          this.usageAnalytics.logSearchEvent<IAnalyticsOmniboxSuggestionMeta>(\n            this.getOmniboxAnalyticsEventCause(),\n            this.buildCustomDataForPartialQueries(index, suggestions)\n          );\n        });\n      }\n    }\n  }\n\n  private modifyCustomDataOnPending(index: number, suggestions: string[]) {\n    const pendingEvt = this.usageAnalytics.getPendingSearchEvent();\n    if (pendingEvt instanceof PendingSearchAsYouTypeSearchEvent) {\n      const newCustomData = this.buildCustomDataForPartialQueries(index, suggestions);\n      _.each(_.keys(newCustomData), (k: string) => {\n        (<PendingSearchAsYouTypeSearchEvent>pendingEvt).modifyCustomData(k, newCustomData[k]);\n      });\n    }\n  }\n\n  private modifyQueryContentOnPending() {\n    const pendingEvt = this.usageAnalytics.getPendingSearchEvent();\n    if (pendingEvt instanceof PendingSearchAsYouTypeSearchEvent) {\n      const queryContent = this.getQuery(this.options.enableSearchAsYouType);\n      pendingEvt.modifyQueryContent(queryContent);\n    }\n  }\n\n  private buildCustomDataForPartialQueries(index: number, suggestions: string[]): IAnalyticsOmniboxSuggestionMeta {\n    this.updateOmniboxAnalytics(suggestions, index);\n    return this.omniboxAnalytics.buildCustomDataForPartialQueries();\n  }\n\n  private handleQuerySuggestGetFocus({ suggestion }: IQuerySuggestSelection) {\n    const suggestions = _.compact(_.map(this.lastSuggestions, suggestion => suggestion.text));\n    const ranking = this.lastSuggestions.indexOf(findWhere(this.lastSuggestions, { text: suggestion }));\n    this.updateOmniboxAnalytics(suggestions, ranking);\n  }\n\n  private updateOmniboxAnalytics(suggestions: string[], suggestionRanking: number) {\n    this.omniboxAnalytics.suggestions = suggestions;\n    this.omniboxAnalytics.suggestionRanking = suggestionRanking;\n  }\n\n  private handleSuggestions() {\n    const text = this.getText();\n    if (this.options.querySuggestCharacterThreshold <= text.length) {\n      const suggestionsEventArgs: IPopulateOmniboxSuggestionsEventArgs = {\n        suggestions: [],\n        omnibox: this\n      };\n\n      this.triggerOmniboxSuggestions(suggestionsEventArgs);\n\n      if (!Utils.isNullOrEmptyString(text)) {\n        this.omniboxAnalytics.partialQueries.push(text);\n      }\n\n      return _.compact(suggestionsEventArgs.suggestions);\n    } else {\n      return [];\n    }\n  }\n\n  private triggerOmniboxSuggestions(args: IPopulateOmniboxSuggestionsEventArgs) {\n    this.bind.trigger(this.element, OmniboxEvents.populateOmniboxSuggestions, args);\n\n    if (!$$(this.element).isDescendant(this.root)) {\n      this.bind.trigger(this.root, OmniboxEvents.populateOmniboxSuggestions, args);\n    }\n  }\n\n  private handleBeforeRedirect() {\n    this.updateQueryState();\n  }\n\n  private handleBuildingQuery(data: IBuildingQueryEventArgs) {\n    Assert.exists(data);\n    Assert.exists(data.queryBuilder);\n    this.updateQueryState();\n    this.lastQuery = this.getQuery(data.searchAsYouType);\n\n    const result: Result =\n      this.lastQuery == this.magicBox.getDisplayedResult().input\n        ? this.magicBox.getDisplayedResult().clone()\n        : this.magicBox.grammar.parse(this.lastQuery).clean();\n    const preprocessResultForQueryArgs: IOmniboxPreprocessResultForQueryEventArgs = {\n      result: result\n    };\n\n    if (this.options.enableQuerySyntax) {\n      const notQuotedValues = preprocessResultForQueryArgs.result.findAll('FieldValueNotQuoted');\n      _.each(notQuotedValues, (value: Result) => (value.value = '\"' + value.value.replace(/\"|\\u00A0/g, ' ') + '\"'));\n      if (this.options.fieldAlias) {\n        const fieldNames = preprocessResultForQueryArgs.result.findAll(\n          (result: Result) => result.expression.id == 'FieldName' && result.isSuccess()\n        );\n        _.each(fieldNames, (result: Result) => {\n          const alias = _.find(_.keys(this.options.fieldAlias), (alias: string) => alias.toLowerCase() == result.value.toLowerCase());\n          if (alias != null) {\n            result.value = <string>this.options.fieldAlias[alias];\n          }\n        });\n      }\n    }\n\n    this.triggerOmniboxPreprocessResultForQuery(preprocessResultForQueryArgs);\n    const query = preprocessResultForQueryArgs.result.toString();\n    new QueryboxQueryParameters(this.options).addParameters(data.queryBuilder, query);\n  }\n\n  private triggerOmniboxPreprocessResultForQuery(args: IOmniboxPreprocessResultForQueryEventArgs) {\n    this.bind.trigger(this.element, OmniboxEvents.omniboxPreprocessResultForQuery, args);\n\n    if (!$$(this.element).isDescendant(this.root)) {\n      this.bind.trigger(this.root, OmniboxEvents.omniboxPreprocessResultForQuery, args);\n    }\n  }\n\n  private handleNewQuery(data: INewQueryEventArgs) {\n    Assert.exists(data);\n    this.options.clearFiltersOnNewQuery && this.clearFiltersIfNewQuery(data);\n  }\n\n  private clearFiltersIfNewQuery({ origin, searchAsYouType }: INewQueryEventArgs) {\n    if (this.queryController.firstQuery) {\n      return;\n    }\n\n    // Prevent queries triggered by unrelated components to clear the the filters\n    // e.g., a facet selection\n    const validOrigins = [Omnibox.ID, 'SearchButton'];\n    if (!origin || validOrigins.indexOf(origin.type) === -1) {\n      return;\n    }\n\n    const lastQuery = this.queryController.getLastQuery().q || '';\n    const newQuery = this.getQuery(searchAsYouType);\n    if (lastQuery !== newQuery) {\n      this.bind.trigger(this.root, BreadcrumbEvents.clearBreadcrumb);\n    }\n  }\n\n  private handleTabPress() {\n    if (this.options.enableQuerySuggestAddon) {\n      this.handleTabPressForSuggestions();\n    }\n    this.handleTabPressForOldOmniboxAddon();\n  }\n\n  private handleTabPressForSuggestions() {\n    if (!this.options.enableSearchAsYouType) {\n      const suggestions = _.compact(_.map(this.lastSuggestions, suggestion => suggestion.text));\n      this.usageAnalytics.logCustomEvent(\n        this.getOmniboxAnalyticsEventCause(),\n        this.buildCustomDataForPartialQueries(0, suggestions),\n        this.element\n      );\n    } else {\n      this.setText(this.getQuery(true));\n    }\n  }\n\n  private handleTabPressForOldOmniboxAddon() {\n    const domSuggestions = this.lastSuggestions.filter(suggestions => suggestions.dom).map(suggestions => $$(suggestions.dom));\n    const selected = this.findAllElementsWithClass(domSuggestions, '.coveo-omnibox-selected');\n    if (selected.length > 0) {\n      $$(selected[0]).trigger('tabSelect');\n    } else if (!this.options.enableQuerySuggestAddon) {\n      const selectable = this.findAllElementsWithClass(domSuggestions, '.coveo-omnibox-selectable');\n      if (selectable.length > 0) {\n        $$(selectable[0]).trigger('tabSelect');\n      }\n    }\n  }\n\n  private findAllElementsWithClass(elements: Dom[], className: string): Dom[] {\n    return elements\n      .map(element => element.find(className))\n      .filter(s => s)\n      .reduce((total, s) => total.concat(s), []);\n  }\n\n  private triggerNewQuery(searchAsYouType: boolean, analyticsEvent: () => void) {\n    clearTimeout(this.searchAsYouTypeTimeout);\n    const shouldExecuteQuery = this.shouldExecuteQuery(searchAsYouType);\n    this.lastQuery = this.getQuery(searchAsYouType);\n    shouldExecuteQuery && analyticsEvent();\n\n    this.queryController.executeQuery({\n      searchAsYouType: searchAsYouType,\n      logInActionsHistory: true,\n      cancel: !shouldExecuteQuery,\n      origin: this\n    });\n  }\n\n  private getQuery(searchAsYouType: boolean) {\n    if (this.lastQuery == this.magicBox.getText()) {\n      return this.lastQuery;\n    }\n\n    if (!searchAsYouType) {\n      return this.magicBox.getText();\n    }\n\n    const wordCompletion = this.magicBox.getWordCompletion();\n\n    if (wordCompletion != null) {\n      return wordCompletion;\n    }\n\n    const currentOmniboxSuggestion = this.magicBox.getWordCompletion() || this.getFirstSuggestion();\n    if (currentOmniboxSuggestion) {\n      return currentOmniboxSuggestion;\n    }\n\n    if (this.isAutoSuggestion()) {\n      return this.lastQuery || this.magicBox.getText();\n    }\n\n    return this.magicBox.getText();\n  }\n\n  private getFirstSuggestion() {\n    if (this.lastSuggestions == null) {\n      return '';\n    }\n\n    if (this.lastSuggestions.length <= 0) {\n      return '';\n    }\n\n    const textSuggestion = _.find(this.lastSuggestions, (suggestion: IOmniboxSuggestion) => suggestion.text != null);\n\n    if (textSuggestion == null) {\n      return '';\n    }\n\n    return textSuggestion.text;\n  }\n\n  public updateQueryState() {\n    this.queryStateModel.set(QueryStateModel.attributesEnum.q, this.magicBox.getText());\n  }\n\n  private handleQueryStateChanged(args: IAttributeChangedEventArg) {\n    Assert.exists(args);\n    const q = <string>args.value;\n    if (q != this.magicBox.getText()) {\n      this.magicBox.setText(q);\n    }\n  }\n\n  private handleQuerySuccess() {\n    if (!this.isAutoSuggestion()) {\n      this.omniboxAnalytics.partialQueries = [];\n    }\n  }\n\n  private handleDuringQuery(args: IDuringQueryEventArgs) {\n    // When the query results returns ... (args.promise)\n    args.promise.then(() => {\n      // Get a handle on a pending search as you type (those events are delayed, not sent instantly)\n      const pendingEvent = this.usageAnalytics.getPendingSearchEvent();\n      if (pendingEvent instanceof PendingSearchAsYouTypeSearchEvent) {\n        (<PendingSearchAsYouTypeSearchEvent>pendingEvent).beforeResolve.then(evt => {\n          // Check if we need to modify the event type beforeResolving it\n          args.promise.then(() => {\n            if (this.modifyEventTo) {\n              evt.modifyEventCause(this.modifyEventTo);\n              this.modifyEventTo = null;\n            }\n          });\n        });\n      }\n    });\n  }\n\n  private searchAsYouType(forceExecuteQuery = false) {\n    this.clearSearchAsYouType();\n    if (this.shouldExecuteQuery(true)) {\n      this.searchAsYouTypeTimeout = window.setTimeout(() => {\n        if (this.suggestionShouldTriggerQuery() || forceExecuteQuery) {\n          const suggestions = _.map(this.lastSuggestions, suggestion => suggestion.text);\n          const index = _.indexOf(suggestions, this.magicBox.getWordCompletion());\n          this.triggerNewQuery(true, () => {\n            this.usageAnalytics.logSearchAsYouType<IAnalyticsOmniboxSuggestionMeta>(\n              analyticsActionCauseList.searchboxAsYouType,\n              this.buildCustomDataForPartialQueries(index, suggestions)\n            );\n          });\n          this.clearSearchAsYouType();\n        }\n      }, this.options.searchAsYouTypeDelay);\n    }\n  }\n\n  private isAutoSuggestion() {\n    return this.options.enableSearchAsYouType && this.options.enableQuerySuggestAddon;\n  }\n\n  private shouldExecuteQuery(searchAsYouType: boolean) {\n    const text = this.getQuery(searchAsYouType);\n    if (this.searchInterface.options.allowQueriesWithoutKeywords === false) {\n      return this.lastQuery != text && Utils.isNonEmptyString(text);\n    }\n    return this.lastQuery != text && text != null;\n  }\n\n  private suggestionShouldTriggerQuery(suggestions = this.lastSuggestions) {\n    if (this.shouldExecuteQuery(true)) {\n      if (suggestions && suggestions[0]) {\n        const suggestion = suggestions[0];\n        // If we have access to a confidence level, return true if we are equal or above the minimum confidence level.\n        if (suggestion && suggestion.executableConfidence != undefined) {\n          return suggestion.executableConfidence >= MINIMUM_EXECUTABLE_CONFIDENCE;\n        }\n        // If we don't have access to a confidence level, return true only if it \"starts with\" the content of the search box\n        if (suggestion.text && suggestion.text.indexOf(this.magicBox.getText()) == 0) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  private clearSearchAsYouType() {\n    clearTimeout(this.searchAsYouTypeTimeout);\n    this.searchAsYouTypeTimeout = undefined;\n  }\n\n  private getOmniboxAnalyticsEventCause() {\n    if (this.searchInterface instanceof StandaloneSearchInterface) {\n      return analyticsActionCauseList.omniboxFromLink;\n    }\n    return analyticsActionCauseList.omniboxAnalytics;\n  }\n}\n\nOmnibox.options = { ...Omnibox.options, ...Querybox.options };\nInitialization.registerAutoCreateComponent(Omnibox);\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Omnibox/Omnibox.ts","import { exportGlobally } from '../../GlobalExports';\nimport { l } from '../../strings/Strings';\nimport { AccessibleButton } from '../../utils/AccessibleButton';\nimport { $$ } from '../../utils/Dom';\nimport { SVGDom } from '../../utils/SVGDom';\nimport { SVGIcons } from '../../utils/SVGIcons';\nimport { Utils } from '../../utils/Utils';\nimport { IAnalyticsNoMeta, analyticsActionCauseList } from '../Analytics/AnalyticsActionListMeta';\nimport { Component } from '../Base/Component';\nimport { IComponentBindings } from '../Base/ComponentBindings';\nimport { Initialization } from '../Base/Initialization';\nimport { QueryStateModel } from '../../models/QueryStateModel';\n\nexport interface ISearchButtonOptions {\n  searchbox?: ISearchButtonSearchbox;\n}\n\nexport interface ISearchButtonSearchbox {\n  getText: () => string;\n}\n\n/**\n * The SearchButton component renders a search icon that the end user can click to trigger a new query.\n *\n * See also the {@link Searchbox} component, which can automatically instantiate a SearchButton component along with a\n * {@link Querybox} component or an {@link Omnibox} component.\n */\nexport class SearchButton extends Component {\n  static ID = 'SearchButton';\n\n  static doExport = () => {\n    exportGlobally({\n      SearchButton: SearchButton\n    });\n  };\n\n  static options: ISearchButtonOptions = {};\n\n  /**\n   * Creates a new SearchButton. Binds a `click` event on the element. Adds a search icon on the element.\n   * @param element The HTMLElement on which to instantiate the component.\n   * @param options The options for the SearchButton component.\n   * @param bindings The bindings that the component requires to function normally. If not set, these will be\n   * automatically resolved (with a slower execution time).\n   */\n  constructor(public element: HTMLElement, public options?: ISearchButtonOptions, bindings?: IComponentBindings) {\n    super(element, SearchButton.ID, bindings);\n\n    new AccessibleButton()\n      .withElement(element)\n      .withOwner(this.bind)\n      .withLabel(l('Search'))\n      .withSelectAction(() => this.handleClick())\n      .build();\n\n    // Provide a magnifier icon if element contains nothing\n    if (Utils.trim($$(this.element).text()) == '') {\n      const svgMagnifierContainer = $$('span', { className: 'coveo-search-button' }, SVGIcons.icons.search).el;\n      SVGDom.addClassToSVGInContainer(svgMagnifierContainer, 'coveo-search-button-svg');\n      const svgLoadingAnimationContainer = $$('span', { className: 'coveo-search-button-loading' }, SVGIcons.icons.loading).el;\n      SVGDom.addClassToSVGInContainer(svgLoadingAnimationContainer, 'coveo-search-button-loading-svg');\n      element.appendChild(svgMagnifierContainer);\n      element.appendChild(svgLoadingAnimationContainer);\n    }\n  }\n\n  /**\n   * Triggers the `click` event handler, which logs a `searchboxSubmit` event in the usage analytics and executes a\n   * query.\n   */\n  public click() {\n    this.handleClick();\n  }\n\n  private handleClick() {\n    this.logger.debug('Performing query following button click');\n    this.updateQueryStateModelWithSearchboxQuery();\n    this.usageAnalytics.logSearchEvent<IAnalyticsNoMeta>(analyticsActionCauseList.searchboxSubmit, {});\n    this.queryController.executeQuery({ origin: this, logInActionsHistory: true });\n  }\n\n  private updateQueryStateModelWithSearchboxQuery() {\n    const searchbox = this.options && this.options.searchbox;\n    searchbox && this.queryStateModel.set(QueryStateModel.attributesEnum.q, searchbox.getText());\n  }\n}\n\nInitialization.registerAutoCreateComponent(SearchButton);\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/SearchButton/SearchButton.ts","import { Expression } from './Expression';\n\nexport const ExpressionEndOfInput: Expression = {\n  id: 'end of input',\n  parse: null\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Expression/ExpressionEndOfInput.ts","import { Expression } from './Expression';\nimport { Result } from '../Result/Result';\nimport { EndOfInputResult } from '../Result/Result';\n\nexport class ExpressionConstant implements Expression {\n  constructor(public value: string, public id: string) {}\n\n  public parse(input: string, end: boolean): Result {\n    // the value must be at the start of the input\n    var success = input.indexOf(this.value) == 0;\n    var result = new Result(success ? this.value : null, this, input);\n    // if is successful and we require the end but the length of parsed is\n    // lower than the input length, return a EndOfInputExpected Result\n    if (success && end && input.length > this.value.length) {\n      return new EndOfInputResult(result);\n    }\n    return result;\n  }\n\n  public toString() {\n    return this.value;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Expression/ExpressionConstant.ts","import { Basic } from './Basic';\nimport { SubGrammar } from './Expressions';\nimport { Date } from './Date';\nexport const Field: SubGrammar = {\n  basicExpressions: ['FieldSimpleQuery', 'FieldQuery', 'Field'],\n  grammars: {\n    FieldQuery: '[Field][OptionalSpaces][FieldQueryOperation]',\n    FieldQueryOperation: ['FieldQueryValue', 'FieldQueryNumeric'],\n    FieldQueryValue: '[FieldOperator][OptionalSpaces][FieldValue]',\n    FieldQueryNumeric: '[FieldOperatorNumeric][OptionalSpaces][FieldValueNumeric]',\n    FieldSimpleQuery: '[FieldName]:[OptionalSpaces][FieldValue]',\n    Field: '@[FieldName]',\n    FieldName: /[a-zA-Z][a-zA-Z0-9\\.\\_]*/,\n    FieldOperator: /==|=|<>/,\n    FieldOperatorNumeric: /<=|>=|<|>/,\n    FieldValue: ['DateRange', 'NumberRange', 'DateRelative', 'Date', 'Number', 'FieldValueList', 'FieldValueString'],\n    FieldValueNumeric: ['DateRelative', 'Date', 'Number'],\n    FieldValueString: ['DoubleQuoted', 'FieldValueNotQuoted'],\n    FieldValueList: '([FieldValueString][FieldValueStringList*])',\n    FieldValueStringList: '[FieldValueSeparator][FieldValueString]',\n    FieldValueSeparator: / *, */,\n    FieldValueNotQuoted: /[^ \\(\\)\\[\\],]+/,\n    NumberRange: '[Number][Spaces?]..[Spaces?][Number]'\n  },\n  include: [Date, Basic]\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/Field.ts","import { defaults, indexOf, find } from 'underscore';\nimport { IQuerySuggestSelection, OmniboxEvents } from '../events/OmniboxEvents';\nimport { Component } from '../ui/Base/Component';\nimport { $$, Dom } from '../utils/Dom';\nimport { InputManager } from './InputManager';\nimport { ResultPreviewsManager } from './ResultPreviewsManager';\nimport { QueryProcessor, ProcessingStatus } from './QueryProcessor';\nimport { QueryUtils } from '../utils/QueryUtils';\n\nexport interface Suggestion {\n  text?: string;\n  index?: number;\n  html?: string;\n  dom?: HTMLElement;\n  separator?: string;\n  advancedQuery?: string;\n  onSelect?: () => void;\n}\n\nexport interface SuggestionsManagerOptions {\n  suggestionClass?: string;\n  selectedClass?: string;\n  timeout?: number;\n  previewHeaderText?: string;\n}\n\nexport enum Direction {\n  Up = 'Up',\n  Down = 'Down',\n  Left = 'Left',\n  Right = 'Right'\n}\n\nexport class SuggestionsManager {\n  public suggestionsListbox: Dom;\n  private suggestionsProcessor: QueryProcessor<Suggestion>;\n  private currentSuggestions: Suggestion[];\n  private options: SuggestionsManagerOptions;\n  private keyboardFocusedElement: HTMLElement;\n  private resultPreviewsManager: ResultPreviewsManager;\n  private root: HTMLElement;\n  private suggestionListboxID = `coveo-magicbox-suggestions-${QueryUtils.createGuid()}`;\n  private suggestionListboxClassName = `coveo-magicbox-suggestions`;\n\n  public get hasSuggestions() {\n    return this.currentSuggestions && this.currentSuggestions.length > 0;\n  }\n\n  public get hasFocus() {\n    return $$(this.element).findClass(this.options.selectedClass).length > 0;\n  }\n\n  public get hasPreviews() {\n    return this.resultPreviewsManager.hasPreviews;\n  }\n\n  private get focusedSuggestion() {\n    return find(\n      this.currentSuggestions,\n      suggestion =>\n        $$(suggestion.dom).hasClass(this.options.selectedClass) || $$(suggestion.dom).findClass(this.options.selectedClass).length > 0\n    );\n  }\n\n  constructor(\n    private element: HTMLElement,\n    private magicBoxContainer: HTMLElement,\n    private inputManager: InputManager,\n    options?: SuggestionsManagerOptions\n  ) {\n    this.root = Component.resolveRoot(element);\n    this.options = defaults(options, <SuggestionsManagerOptions>{\n      suggestionClass: 'magic-box-suggestion',\n      selectedClass: 'magic-box-selected'\n    });\n    // Put in a sane default, so as to not reject every suggestions if not set on initialization\n    if (this.options.timeout == undefined) {\n      this.options.timeout = 500;\n    }\n\n    $$(this.element).on('mouseover', e => {\n      this.handleMouseOver(e);\n    });\n\n    $$(this.element).on('mouseout', e => {\n      this.handleMouseOut(e);\n    });\n\n    this.suggestionsProcessor = new QueryProcessor({ timeout: this.options.timeout });\n    this.resultPreviewsManager = new ResultPreviewsManager(element, {\n      selectedClass: this.options.selectedClass,\n      timeout: this.options.timeout\n    });\n    this.suggestionsListbox = this.buildSuggestionsContainer();\n    $$(this.element).append(this.suggestionsListbox.el);\n    this.addAccessibilityProperties();\n    this.appendEmptySuggestionOption();\n  }\n\n  public handleMouseOver(e) {\n    const target = $$(<HTMLElement>e.target);\n    const parents = target.parents(this.options.suggestionClass);\n    if (target.hasClass(this.options.suggestionClass)) {\n      this.processMouseSelection(target.el);\n    } else if (parents.length > 0 && this.element.contains(parents[0])) {\n      this.processMouseSelection(parents[0]);\n    }\n  }\n\n  public handleMouseOut(e) {\n    const target = $$(<HTMLElement>e.target);\n    const targetParents = target.parents(this.options.suggestionClass);\n\n    //e.relatedTarget is not available if moving off the browser window or is an empty object `{}` when moving out of namespace in LockerService.\n    if (e.relatedTarget && $$(e.relatedTarget).isValid()) {\n      const relatedTargetParents = $$(<HTMLElement>e.relatedTarget).parents(this.options.suggestionClass);\n      if (target.hasClass(this.options.selectedClass) && !$$(<HTMLElement>e.relatedTarget).hasClass(this.options.suggestionClass)) {\n        this.removeSelectedStatus(target.el);\n      } else if (relatedTargetParents.length == 0 && targetParents.length > 0) {\n        this.removeSelectedStatus(targetParents[0]);\n      }\n    } else {\n      if (target.hasClass(this.options.selectedClass)) {\n        this.removeSelectedStatus(target.el);\n      } else if (targetParents.length > 0) {\n        this.removeSelectedStatus(targetParents[0]);\n      }\n    }\n    $$(this.root).trigger(OmniboxEvents.querySuggestLoseFocus);\n  }\n\n  public async moveDown() {\n    await this.move(Direction.Down);\n  }\n\n  public async moveUp() {\n    await this.move(Direction.Up);\n  }\n\n  public async moveLeft() {\n    await this.move(Direction.Left);\n  }\n\n  public async moveRight() {\n    await this.move(Direction.Right);\n  }\n\n  public selectAndReturnKeyboardFocusedElement(): HTMLElement {\n    const selected = this.keyboardFocusedElement;\n    if (selected) {\n      $$(selected).trigger('keyboardSelect');\n      // By definition, once an element has been \"selected\" with the keyboard,\n      // it is not longer \"active\" since the event has been processed.\n      this.keyboardFocusedElement = null;\n      this.inputManager.blur();\n    }\n    return selected;\n  }\n\n  public clearKeyboardFocusedElement() {\n    this.keyboardFocusedElement = null;\n  }\n\n  public async receiveSuggestions(suggestions: (Promise<Suggestion[]> | Suggestion[])[]) {\n    const { results, status } = await this.suggestionsProcessor.processQueries(suggestions);\n    if (status === ProcessingStatus.Overriden) {\n      return [];\n    }\n    this.updateSuggestions(results);\n    return results;\n  }\n\n  public clearSuggestions() {\n    this.updateSuggestions([]);\n  }\n\n  public updateSuggestions(suggestions: Suggestion[]) {\n    this.suggestionsListbox.empty();\n    this.inputManager.activeDescendant = null;\n\n    this.currentSuggestions = suggestions;\n\n    $$(this.element).toggleClass('magic-box-hasSuggestion', this.hasSuggestions);\n    this.inputManager.expanded = this.hasSuggestions;\n\n    this.resultPreviewsManager.displaySearchResultPreviewsForSuggestion(null);\n\n    if (!this.hasSuggestions) {\n      this.appendEmptySuggestionOption();\n      $$(this.root).trigger(OmniboxEvents.querySuggestLoseFocus);\n      return;\n    }\n\n    suggestions\n      .sort((a, b) => (b.index || 0) - (a.index || 0))\n      .forEach(suggestion => {\n        const dom = suggestion.dom ? this.modifyDomFromExistingSuggestion(suggestion.dom) : this.createDomFromSuggestion(suggestion);\n\n        dom.setAttribute('id', `magic-box-suggestion-${indexOf(suggestions, suggestion)}`);\n        dom.setAttribute('role', 'option');\n        dom.setAttribute('aria-selected', 'false');\n        dom.setAttribute('aria-label', dom.text());\n\n        dom['suggestion'] = suggestion;\n        this.suggestionsListbox.append(dom.el);\n      });\n\n    const numberOfSuggestions = this.suggestionsListbox.findAll(`.${this.options.suggestionClass}`).length;\n    $$(this.root).trigger(OmniboxEvents.querySuggestRendered, { numberOfSuggestions });\n  }\n\n  public get selectedSuggestion(): Suggestion {\n    if (this.htmlElementIsSuggestion(this.keyboardFocusedElement)) {\n      return this.returnMoved(this.keyboardFocusedElement) as Suggestion;\n    }\n    return null;\n  }\n\n  private async processKeyboardSelection(suggestion: HTMLElement) {\n    this.addSelectedStatus(suggestion);\n    this.keyboardFocusedElement = suggestion;\n    await this.updateSelectedSuggestion(this.focusedSuggestion);\n  }\n\n  private processKeyboardPreviewSelection(preview: HTMLElement) {\n    this.addSelectedStatus(preview);\n    this.keyboardFocusedElement = preview;\n  }\n\n  private processMouseSelection(suggestion: HTMLElement) {\n    this.addSelectedStatus(suggestion);\n    this.updateSelectedSuggestion(this.focusedSuggestion);\n    this.keyboardFocusedElement = null;\n  }\n\n  private buildSuggestionsContainer() {\n    return $$('div', {\n      className: this.suggestionListboxClassName,\n      id: this.suggestionListboxID,\n      role: 'listbox',\n      ariaLabel: 'Search Suggestions'\n    });\n  }\n\n  private createDomFromSuggestion(suggestion: Suggestion) {\n    const dom = $$('div', {\n      className: `magic-box-suggestion ${this.options.suggestionClass}`\n    });\n\n    suggestion.dom = dom.el;\n\n    dom.on('click', () => {\n      this.selectSuggestion(suggestion);\n    });\n\n    dom.on('keyboardSelect', () => {\n      this.selectSuggestion(suggestion);\n    });\n\n    if (suggestion.html) {\n      dom.el.innerHTML = suggestion.html;\n      return dom;\n    }\n\n    if (suggestion.text) {\n      dom.text(suggestion.text);\n\n      return dom;\n    }\n\n    if (suggestion.separator) {\n      dom.addClass('magic-box-suggestion-seperator');\n      const suggestionLabel = $$(\n        'div',\n        {\n          className: 'magic-box-suggestion-seperator-label'\n        },\n        suggestion.separator\n      );\n      dom.append(suggestionLabel.el);\n      return dom;\n    }\n\n    return dom;\n  }\n\n  private selectSuggestion(suggestion: Suggestion) {\n    suggestion.onSelect();\n    $$(this.root).trigger(OmniboxEvents.querySuggestSelection, <IQuerySuggestSelection>{ suggestion: suggestion.text });\n  }\n\n  private appendEmptySuggestionOption() {\n    // Accessibility tools reports that a listbox element must always have at least one child with an option\n    // Even if there is no suggestions to show.\n    this.suggestionsListbox.append($$('div', { role: 'option' }).el);\n  }\n\n  private modifyDomFromExistingSuggestion(dom: HTMLElement) {\n    // this need to be done if the selection is in cache and the dom is set in the suggestion\n    this.removeSelectedStatus(dom);\n    const found = dom.classList.contains(this.options.suggestionClass) ? dom : $$(dom).find('.' + this.options.suggestionClass);\n    this.removeSelectedStatus(found);\n    return $$(dom);\n  }\n\n  private async move(direction: Direction) {\n    if (this.resultPreviewsManager.focusedPreviewElement) {\n      await this.moveWithinPreview(direction);\n      return;\n    }\n    if (direction === Direction.Right || direction === Direction.Left) {\n      const firstPreview = this.resultPreviewsManager.previewElements[0];\n      if (firstPreview) {\n        this.processKeyboardPreviewSelection(firstPreview);\n        return;\n      }\n    }\n    await this.moveWithinSuggestion(direction);\n  }\n\n  private async moveWithinSuggestion(direction: Direction) {\n    const currentlySelected = $$(this.element).find(`.${this.options.selectedClass}`);\n    const selectables = $$(this.element).findAll(`.${this.options.suggestionClass}`);\n    const currentIndex = indexOf(selectables, currentlySelected);\n\n    let index = direction === Direction.Up ? currentIndex - 1 : currentIndex + 1;\n    index = (index + selectables.length) % selectables.length;\n\n    await this.selectQuerySuggest(selectables[index]);\n  }\n\n  private async selectQuerySuggest(suggestion: HTMLElement) {\n    if (suggestion) {\n      await this.processKeyboardSelection(suggestion);\n    } else {\n      this.keyboardFocusedElement = null;\n      this.inputManager.input.removeAttribute('aria-activedescendant');\n    }\n\n    return suggestion;\n  }\n\n  private async moveWithinPreview(direction: Direction) {\n    const newFocusedPreview = this.resultPreviewsManager.getElementInDirection(direction);\n    if (!newFocusedPreview) {\n      await this.selectQuerySuggest(this.resultPreviewsManager.previewsOwner.dom);\n      return;\n    }\n    this.processKeyboardPreviewSelection(newFocusedPreview);\n  }\n\n  private returnMoved(selected) {\n    if (selected) {\n      if (selected['suggestion']) {\n        return selected['suggestion'];\n      }\n      if (selected['no-text-suggestion']) {\n        return null;\n      }\n      if (selected instanceof HTMLElement) {\n        return {\n          text: $$(selected).text()\n        };\n      }\n    }\n    return null;\n  }\n\n  private addSelectedStatus(element: HTMLElement): void {\n    const selected = this.element.getElementsByClassName(this.options.selectedClass);\n    for (let i = 0; i < selected.length; i++) {\n      const elem = <HTMLElement>selected.item(i);\n      this.removeSelectedStatus(elem);\n    }\n    $$(element).addClass(this.options.selectedClass);\n    this.updateAreaSelectedIfDefined(element, 'true');\n  }\n\n  private async updateSelectedSuggestion(suggestion: Suggestion) {\n    $$(this.root).trigger(OmniboxEvents.querySuggestGetFocus, <IQuerySuggestSelection>{\n      suggestion: suggestion.text\n    });\n    await this.resultPreviewsManager.displaySearchResultPreviewsForSuggestion(suggestion);\n  }\n\n  private removeSelectedStatus(suggestion: HTMLElement): void {\n    $$(suggestion).removeClass(this.options.selectedClass);\n    this.updateAreaSelectedIfDefined(suggestion, 'false');\n  }\n\n  private updateAreaSelectedIfDefined(element: HTMLElement, value: string): void {\n    if ($$(element).getAttribute('aria-selected')) {\n      this.inputManager.activeDescendant = element;\n      $$(element).setAttribute('aria-selected', value);\n    }\n  }\n\n  private addAccessibilityProperties() {\n    this.addAccessibilityPropertiesForMagicBox();\n    this.addAccessibilityPropertiesForInput();\n  }\n\n  private addAccessibilityPropertiesForMagicBox() {\n    const magicBox = $$(this.magicBoxContainer);\n\n    magicBox.setAttribute('role', 'search');\n    magicBox.setAttribute('aria-haspopup', 'listbox');\n  }\n\n  private addAccessibilityPropertiesForInput() {\n    const input = $$(this.inputManager.input);\n\n    this.inputManager.activeDescendant = null;\n    this.inputManager.expanded = false;\n    input.setAttribute('aria-owns', this.suggestionListboxID);\n    input.setAttribute('aria-controls', this.suggestionListboxID);\n  }\n\n  private htmlElementIsSuggestion(selected: HTMLElement) {\n    const omniboxSelectables = $$(this.element).findAll(`.${this.options.suggestionClass}`);\n    return indexOf(omniboxSelectables, selected) > -1;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/SuggestionsManager.ts","import { each, find, isUndefined } from 'underscore';\nimport { KEYBOARD } from '../Core';\nimport { $$ } from '../utils/Dom';\nimport { doMagicBoxExport } from './doMagicBoxExport';\nimport { Grammar } from './Grammar';\nimport { InputManager } from './InputManager';\nimport { MagicBoxClear } from './MagicBoxClear';\nimport { Result } from './Result/Result';\nimport { Suggestion, SuggestionsManager } from './SuggestionsManager';\n\nexport interface Options {\n  inline?: boolean;\n  selectableSuggestionClass?: string;\n  selectedSuggestionClass?: string;\n  suggestionTimeout?: number;\n}\n\nexport class MagicBoxInstance {\n  public onblur: () => void;\n  public onfocus: () => void;\n  public onchange: () => void;\n  public onSuggestions: (suggestions: Suggestion[]) => void;\n  public onsubmit: () => void;\n  public onselect: (suggestion: Suggestion) => void;\n  public onclear: () => void;\n  public onmove: () => void;\n  public ontabpress: () => void;\n\n  public getSuggestions: () => Array<Promise<Suggestion[]> | Suggestion[]>;\n\n  private inputManager: InputManager;\n  private suggestionsManager: SuggestionsManager;\n  private magicBoxClear: MagicBoxClear;\n\n  private lastSuggestions: Suggestion[] = [];\n\n  private result: Result;\n  private displayedResult: Result;\n\n  private get firstSuggestionWithText(): Suggestion {\n    return find(this.lastSuggestions, suggestion => suggestion.text);\n  }\n\n  private get firstSuggestionText() {\n    const firstSuggestionWithText = this.firstSuggestionWithText;\n    return firstSuggestionWithText ? firstSuggestionWithText.text : '';\n  }\n\n  constructor(public element: HTMLElement, public grammar: Grammar, public options: Options = {}) {\n    if (isUndefined(this.options.inline)) {\n      this.options.inline = false;\n    }\n    $$(element).addClass('magic-box');\n    if (this.options.inline) {\n      $$(element).addClass('magic-box-inline');\n    }\n\n    this.result = this.grammar.parse('');\n    this.displayedResult = this.result.clean();\n\n    let inputContainer = $$(element).find('.magic-box-input');\n    if (!inputContainer) {\n      inputContainer = document.createElement('div');\n      inputContainer.className = 'magic-box-input';\n      element.appendChild(inputContainer);\n    }\n\n    this.inputManager = new InputManager(\n      inputContainer,\n      (text, wordCompletion) => {\n        if (!wordCompletion) {\n          this.setText(text);\n          this.addSuggestions();\n          this.onchange && this.onchange();\n        } else {\n          this.setText(text);\n          this.onselect && this.onselect(this.firstSuggestionWithText);\n        }\n      },\n      this\n    );\n\n    this.inputManager.ontabpress = () => {\n      this.ontabpress && this.ontabpress();\n    };\n\n    const existingValue = this.inputManager.getValue();\n    if (existingValue) {\n      this.displayedResult.input = existingValue;\n    }\n\n    this.inputManager.setResult(this.displayedResult);\n\n    const suggestionsContainer = document.createElement('div');\n    suggestionsContainer.className = 'magic-box-suggestions';\n    this.element.appendChild(suggestionsContainer);\n\n    this.suggestionsManager = new SuggestionsManager(suggestionsContainer, this.element, this.inputManager, {\n      suggestionClass: this.options.selectableSuggestionClass,\n      selectedClass: this.options.selectedSuggestionClass,\n      timeout: this.options.suggestionTimeout\n    });\n\n    this.magicBoxClear = new MagicBoxClear(this);\n    this.setupHandler();\n  }\n\n  public getResult() {\n    return this.result;\n  }\n\n  public getDisplayedResult() {\n    return this.displayedResult;\n  }\n\n  public setText(text: string) {\n    $$(this.element).toggleClass('magic-box-notEmpty', text.length > 0);\n    this.magicBoxClear.toggleTabindexAndAriaHidden(text.length > 0);\n\n    this.result = this.grammar.parse(text);\n    this.displayedResult = this.result.clean();\n\n    this.inputManager.setResult(this.displayedResult);\n  }\n\n  public setCursor(index: number) {\n    this.inputManager.setCursor(index);\n  }\n\n  public getCursor() {\n    return this.inputManager.getCursor();\n  }\n\n  public resultAtCursor(match?: string | { (result: Result): boolean }): Result[] {\n    return this.displayedResult.resultAt(this.getCursor(), match);\n  }\n\n  private setupHandler() {\n    this.inputManager.onblur = () => {\n      $$(this.element).removeClass('magic-box-hasFocus');\n      this.onblur && this.onblur();\n      if (!this.options.inline) {\n        this.clearSuggestion();\n      }\n    };\n\n    this.inputManager.onfocus = () => {\n      $$(this.element).addClass('magic-box-hasFocus');\n      this.addSuggestions();\n      this.onfocus && this.onfocus();\n    };\n\n    this.inputManager.onkeydown = (key: number) => {\n      if (this.shouldMoveInSuggestions(key)) {\n        return false;\n      }\n      if (key === KEYBOARD.ENTER) {\n        const suggestion = this.suggestionsManager.selectAndReturnKeyboardFocusedElement();\n        if (suggestion == null) {\n          this.onsubmit && this.onsubmit();\n        }\n        return false;\n      } else if (key === KEYBOARD.ESCAPE) {\n        this.clearSuggestion();\n        this.blur();\n      } else {\n        this.suggestionsManager.clearKeyboardFocusedElement();\n      }\n      return true;\n    };\n\n    this.inputManager.onchangecursor = () => {\n      this.addSuggestions();\n    };\n\n    this.inputManager.onkeyup = (key: number) => {\n      this.onmove && this.onmove();\n      if (!this.shouldMoveInSuggestions(key)) {\n        return true;\n      }\n      switch (key) {\n        case KEYBOARD.UP_ARROW:\n          this.suggestionsManager.moveUp();\n          break;\n        case KEYBOARD.DOWN_ARROW:\n          this.suggestionsManager.moveDown();\n          break;\n        case KEYBOARD.LEFT_ARROW:\n          this.suggestionsManager.moveLeft();\n          break;\n        case KEYBOARD.RIGHT_ARROW:\n          this.suggestionsManager.moveRight();\n          break;\n      }\n      if (this.suggestionsManager.selectedSuggestion) {\n        this.focusOnSuggestion(this.suggestionsManager.selectedSuggestion);\n      }\n      this.onchange && this.onchange();\n      return false;\n    };\n  }\n\n  public async addSuggestions() {\n    const suggestions = await this.suggestionsManager.receiveSuggestions(this.getSuggestions != null ? this.getSuggestions() : []);\n    this.addSelectEventHandlers(suggestions);\n    this.inputManager.setWordCompletion(this.firstSuggestionText);\n    this.onSuggestions(suggestions);\n  }\n\n  private shouldMoveInSuggestions(key: KEYBOARD) {\n    switch (key) {\n      case KEYBOARD.UP_ARROW:\n      case KEYBOARD.DOWN_ARROW:\n        return true;\n      case KEYBOARD.LEFT_ARROW:\n      case KEYBOARD.RIGHT_ARROW:\n        if (this.suggestionsManager.hasFocus && this.suggestionsManager.hasPreviews) {\n          return true;\n        }\n    }\n    return false;\n  }\n\n  private addSelectEventHandlers(suggestions: Suggestion[]) {\n    each(suggestions, (suggestion: Suggestion) => {\n      if (suggestion.onSelect == null && suggestion.text != null) {\n        suggestion.onSelect = () => {\n          this.setText(suggestion.text);\n          this.onselect && this.onselect(suggestion);\n        };\n      }\n    });\n  }\n\n  public focus() {\n    $$(this.element).addClass('magic-box-hasFocus');\n    this.inputManager.focus();\n  }\n\n  public blur() {\n    this.inputManager.blur();\n  }\n\n  public async clearSuggestion() {\n    this.inputManager.setWordCompletion(null);\n    this.suggestionsManager.clearSuggestions();\n    this.onSuggestions([]);\n  }\n\n  private focusOnSuggestion(suggestion: Suggestion) {\n    if (suggestion == null || suggestion.text == null) {\n      this.inputManager.setResult(this.displayedResult, this.firstSuggestionText);\n    } else {\n      this.inputManager.setResult(this.grammar.parse(suggestion.text).clean(), suggestion.text);\n    }\n  }\n\n  public getText() {\n    return this.inputManager.getValue();\n  }\n\n  public getWordCompletion() {\n    return this.inputManager.getWordCompletion();\n  }\n\n  public clear() {\n    this.setText('');\n    this.clearSuggestion();\n    this.focus();\n    this.onclear && this.onclear();\n  }\n\n  public hasSuggestions() {\n    return this.suggestionsManager.hasSuggestions;\n  }\n}\n\nexport function createMagicBox(element: HTMLElement, grammar: Grammar, options?: Options) {\n  return new MagicBoxInstance(element, grammar, options);\n}\n\nexport function requestAnimationFrame(callback: () => void) {\n  if ('requestAnimationFrame' in window) {\n    return window.requestAnimationFrame(callback);\n  }\n  return setTimeout(callback);\n}\n\ndoMagicBoxExport();\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/MagicBox.ts","import _ = require('underscore');\n\nexport class MagicBoxUtils {\n  static escapeRegExp(str) {\n    return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, '\\\\$&');\n  }\n\n  static highlightText(\n    text: string,\n    highligth: string,\n    ignoreCase = false,\n    matchClass: string = 'magic-box-hightlight',\n    doNotMatchClass: string = ''\n  ) {\n    if (highligth.length == 0) {\n      return text;\n    }\n    const escaped = this.escapeRegExp(highligth);\n    const stringRegex = '(' + escaped + ')|(.*?(?=' + escaped + ')|.+)';\n    const regex = new RegExp(stringRegex, ignoreCase ? 'gi' : 'g');\n    return text.replace(regex, (text, match, notmatch) => this.escapeText(match != null ? matchClass : doNotMatchClass, text));\n  }\n\n  private static escapeText = (classname: string, text: string) => {\n    return `<span class=\"${classname}\">${_.escape(text)}</span>`;\n  };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/MagicBoxUtils.ts","import 'styling/_Searchbox';\nimport { exportGlobally } from '../../GlobalExports';\nimport { $$ } from '../../utils/Dom';\nimport { SVGDom } from '../../utils/SVGDom';\nimport { SVGIcons } from '../../utils/SVGIcons';\nimport { SearchBoxResize } from '../../utils/SearchBoxResize';\nimport { Component } from '../Base/Component';\nimport { IComponentBindings } from '../Base/ComponentBindings';\nimport { ComponentOptions } from '../Base/ComponentOptions';\nimport { Initialization } from '../Base/Initialization';\nimport { IOmniboxOptions, Omnibox } from '../Omnibox/Omnibox';\nimport { Querybox } from '../Querybox/Querybox';\nimport { SearchButton } from '../SearchButton/SearchButton';\nimport { each, extend } from 'underscore';\n\nexport interface ISearchboxOptions extends IOmniboxOptions {\n  addSearchButton?: boolean;\n  enableOmnibox?: boolean;\n  height?: number;\n}\n\n/**\n * The `Searchbox` component allows you to conveniently instantiate two components which end users frequently use to\n * enter and submit queries.\n *\n * This component attaches itself to a `div` element and takes care of instantiating either a\n * [`Querybox`]{@link Querybox} or an [`Omnibox`]{@link Omnibox} component (see the\n * [`enableOmnibox`]{@link Searchbox.options.enableOmnibox} option). Optionally, the `Searchbox` can also instantiate a\n * [`SearchButton`]{@link SearchButton} component, and append it inside the same `div` (see the\n * [`addSearchButton`]{@link Searchbox.options.addSearchButton} option).\n */\nexport class Searchbox extends Component {\n  static ID = 'Searchbox';\n  static parent = Omnibox;\n\n  static doExport = () => {\n    exportGlobally({\n      Searchbox: Searchbox,\n      SearchButton: SearchButton,\n      Omnibox: Omnibox,\n      Querybox: Querybox\n    });\n  };\n\n  /**\n   * Possible options for the {@link Searchbox}\n   * @componentOptions\n   */\n  static options: ISearchboxOptions = {\n    /**\n     * Specifies whether to instantiate a [`SearchButton`]{@link SearchButton} component.\n     *\n     * Default value is `true`.\n     */\n    addSearchButton: ComponentOptions.buildBooleanOption({ defaultValue: true }),\n    /**\n     * A custom height for the search box (in pixels).\n     *\n     * Note: Avoid setting this option if you want to modify the search box styling through custom CSS.\n     *\n     * Minimum value is `25`\n     *\n     * Default behavior: The most specific CSS rules targeting HTML elements generated by the Searchbox component are used\n     * (e.g., if you are only using the default CoveoFullSearch.css stylesheet with no further styling customizations,\n     * the search box height will be set to 50 pixels by default).\n     *\n     * @availablesince [July 2019 Release (v2.6459)](https://docs.coveo.com/en/2938/)\n     */\n    height: ComponentOptions.buildNumberOption({ min: 25 }),\n\n    /**\n     * Specifies whether to instantiate an [`Omnibox`]{@link Omnibox} component.\n     *\n     * When this option is `false`, the `Searchbox` instantiates a [`Querybox`]{@link Querybox} component instead.\n     *\n     * **Note:**\n     * > You can use configuration options specific to the component you choose to instantiate with the `Searchbox`.\n     *\n     * **Examples:**\n     *\n     * In this first case, the `Searchbox` instantiates a `Querybox` component. You can configure this `Querybox`\n     * instance using any of the `Querybox` component options, such as\n     * [`triggerQueryOnClear`]{@link Querybox.options.triggerQueryOnClear}.\n     * ```html\n     * <div class='CoveoSearchbox' data-trigger-query-on-clear='true'></div>\n     * ```\n     *\n     * In this second case, the `Searchbox` instantiates an `Omnibox` component. You can configure this `Omnibox`\n     * instance using any of the `Omnibox` component options, such as\n     * [`placeholder`]{@link Omnibox.options.placeholder}.\n     * Moreover, since the `Omnibox` component inherits all of the `Querybox` component options, the\n     * `data-trigger-query-on-clear` option from the previous example would also work on this `Omnibox` instance.\n     * ```html\n     * <div class='CoveoSearchbox' data-enable-omnibox='true' data-placeholder='Please enter a query'></div>\n     * ```\n     *\n     * Default value is `true`.\n     */\n    enableOmnibox: ComponentOptions.buildBooleanOption({ defaultValue: true })\n  };\n\n  /**\n   * The [`SearchButton`]{@link SearchButton} component instance.\n   */\n  public searchButton: SearchButton;\n\n  /**\n   * The component instance which allows end users to input queries.\n   *\n   * Can be either a [`Querybox`]{@link Querybox} or an [`Omnibox`]{@link Omnibox} component, depending on the value of\n   * [`enableOmnibox`]{@link Searchbox.options.enableOmnibox}.\n   */\n  public searchbox: Querybox | Omnibox;\n\n  /**\n   * Creates a new `Searchbox` component. Creates a new `Coveo.Magicbox` instance and wraps magic box methods (`onblur`,\n   * `onsubmit`, etc.). Binds event on `buildingQuery` and on redirection (for standalone box).\n   * @param element The HTMLElement on which to instantiate the component. This cannot be an HTMLInputElement for\n   * technical reasons.\n   * @param options The options for the `Searchbox component`. These will merge with the options from the component set\n   * directly on the `HTMLElement`.\n   * @param bindings The bindings that the component requires to function normally. If not set, these will be\n   * automatically resolved (with a slower execution time).\n   */\n  constructor(public element: HTMLElement, public options?: ISearchboxOptions, public bindings?: IComponentBindings) {\n    super(element, Searchbox.ID, bindings);\n\n    this.options = ComponentOptions.initComponentOptions(element, Searchbox, options);\n\n    if (this.options.inline) {\n      $$(element).addClass('coveo-inline');\n    }\n\n    this.initSearchBox();\n    this.initSearchButton();\n    this.applyMagicBoxIcon();\n    this.applyCustomHeight();\n  }\n\n  private initSearchBox() {\n    const div = document.createElement('div');\n    this.element.appendChild(div);\n\n    if (this.options.enableOmnibox) {\n      this.searchbox = new Omnibox(div, this.options, this.bindings);\n    } else {\n      this.searchbox = new Querybox(div, this.options, this.bindings);\n    }\n  }\n\n  private initSearchButton() {\n    if (!this.options.addSearchButton) {\n      return;\n    }\n\n    const anchor = $$('a');\n    this.element.appendChild(anchor.el);\n    this.searchButton = new SearchButton(anchor.el, { searchbox: this.searchbox }, this.bindings);\n  }\n\n  private applyMagicBoxIcon() {\n    const magicBoxIcon = $$(this.element).find('.magic-box-icon');\n    magicBoxIcon.innerHTML = SVGIcons.icons.mainClear;\n    SVGDom.addClassToSVGInContainer(magicBoxIcon, 'magic-box-clear-svg');\n  }\n\n  private applyCustomHeight() {\n    if (!this.options.height) {\n      return;\n    }\n\n    $$(this.element).addClass('coveo-custom-height');\n    SearchBoxResize.resize(this.element, this.options.height);\n  }\n}\n\nSearchbox.options = { ...Searchbox.options, ...Omnibox.options, ...Querybox.options };\n\n// Only parse omnibox option if omnibox is enabled\neach(<any>Searchbox.options, (value, key: string) => {\n  if (key in Omnibox.options && !(key in Querybox.options)) {\n    Searchbox.options[key] = extend({ depend: 'enableOmnibox' }, value);\n  }\n});\n\nInitialization.registerAutoCreateComponent(Searchbox);\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Searchbox/Searchbox.ts","import { Expression } from './Expression';\nimport { Result } from '../Result/Result';\nimport { Grammar } from '../Grammar';\nimport { RefResult } from '../Result/RefResult';\nimport { ExpressionEndOfInput } from './ExpressionEndOfInput';\nimport _ = require('underscore');\n\nexport class ExpressionRef implements Expression {\n  constructor(public ref: string, public occurrence: string | number, public id: string, public grammar: Grammar) {}\n\n  parse(input: string, end: boolean): Result {\n    var ref = this.grammar.getExpression(this.ref);\n    if (ref == null) {\n      throw new Error('Expression not found:' + this.ref);\n    }\n    if (this.occurrence == '?' || this.occurrence == null) {\n      return this.parseOnce(input, end, ref);\n    } else {\n      return this.parseMany(input, end, ref);\n    }\n  }\n\n  parseOnce(input: string, end: boolean, ref: Expression): Result {\n    var refResult = ref.parse(input, end);\n    var success = refResult.isSuccess();\n    if (!success && this.occurrence == '?') {\n      if (end) {\n        // if end was found\n        if (input.length == 0) {\n          return new RefResult([], this, input, refResult);\n        }\n        // if end was not found and all error expression are EndOfInput, reparse with end = false.\n        if (_.all(refResult.getBestExpect(), expect => expect.expression == ExpressionEndOfInput)) {\n          return new RefResult([new Result(null, ExpressionEndOfInput, input)], this, input, refResult);\n        }\n        return refResult;\n      }\n      // the ref is not required and it do not need to end the input\n      return new RefResult([], this, input, null);\n    }\n    return new RefResult([refResult], this, input, success ? null : refResult);\n  }\n\n  parseMany(input: string, end: boolean, ref: Expression) {\n    var subResults: Result[] = [];\n    var subResult: Result;\n    var subInput = input;\n    var success: boolean;\n\n    // try to parse until it do not match, do not manage the end yet\n    do {\n      subResult = ref.parse(subInput, false);\n      success = subResult.isSuccess();\n      if (success) {\n        subResults.push(subResult);\n        subInput = subInput.substr(subResult.getLength());\n      }\n    } while (success && subResult.input != subInput);\n\n    // minimal occurance of a ref\n    var requiredOccurance = _.isNumber(this.occurrence) ? <number>this.occurrence : this.occurrence == '+' ? 1 : 0;\n\n    // if the minimal occurance is not reached add the fail result to the list\n    if (subResults.length < requiredOccurance) {\n      subResults.push(subResult);\n    } else if (end) {\n      // if there is at least one match, check if the last match is at the end\n      if (subResults.length > 0) {\n        var last = _.last(subResults);\n        subResult = ref.parse(last.input, true);\n        if (subResult.isSuccess()) {\n          // if successful, replace the last subResult by the one with end\n          subResults[subResults.length - 1] = subResult;\n        } else {\n          // if not successful, we keep the last successful result and we add a endOfInputExpected Result after it\n          subResults.push(new Result(null, ExpressionEndOfInput, last.input.substr(last.getLength())));\n          // we parse back the last with the length of the successful Result (at the same place we put the endOfInputExpected) and put it in failAttempt\n          subResult = ref.parse(last.input.substr(last.getLength()), true);\n        }\n      } else if (input.length != 0) {\n        // if there is no result at all and we are not at the end, return a endOfInputExpected Result\n        var endOfInput = new Result(null, ExpressionEndOfInput, input);\n        return new RefResult([endOfInput], this, input, subResult);\n      }\n    }\n    return new RefResult(subResults, this, input, subResult);\n  }\n\n  public toString() {\n    return this.id;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Expression/ExpressionRef.ts","import { Result } from './Result';\nimport { Expression } from '../Expression/Expression';\nimport _ = require('underscore');\n\nexport class RefResult extends Result {\n  public failAttempt: Result;\n  constructor(results: Result[], public expression: Expression, public input: string, lastResult: Result) {\n    super(results, expression, input);\n    if (_.last(results) != lastResult) {\n      this.failAttempt = lastResult;\n      if (this.failAttempt != null) {\n        this.failAttempt.parent = this;\n      }\n    }\n  }\n\n  /**\n   * Return all fail result.\n   */\n  public getExpect(): Result[] {\n    var expect = super.getExpect();\n    // add the failAttempt to the expect\n    if (this.failAttempt != null) {\n      return expect.concat(this.failAttempt.getExpect());\n    }\n    return expect;\n  }\n\n  /**\n   * Clean the result to have the most relevant result. If the result is successful just return a clone of it.\n   */\n  public clean(path?: Result[]): Result {\n    // if there is no failAttempt, we will use the default clean\n    if (this.failAttempt != null && (path != null || !this.isSuccess())) {\n      path = path || _.last(this.getBestExpect()).path(this);\n      var next = _.first(path);\n      // if the next is in the subResults, not the failAttempt, do the default clean;\n      if (next != null && next == this.failAttempt) {\n        var last = _.last(this.subResults);\n        // if the last is not successful, remove it because we want the failAttempt path\n        var subResults: Result[] = _.map(last != null && last.isSuccess() ? this.subResults : _.initial(this.subResults), subResult =>\n          subResult.clean()\n        );\n        subResults.push(next.clean(_.rest(path)));\n        return new Result(subResults, this.expression, this.input);\n      }\n    }\n    return super.clean(path);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Result/RefResult.ts","import { Expression } from './Expression';\nimport { ExpressionRef } from './ExpressionRef';\nimport { Result } from '../Result/Result';\nimport { OptionResult } from '../Result/OptionResult';\n\nexport class ExpressionOptions implements Expression {\n  constructor(public parts: ExpressionRef[], public id: string) {}\n\n  parse(input: string, end: boolean): Result {\n    var failAttempt: Result[] = [];\n    for (var i = 0; i < this.parts.length; i++) {\n      var subResult = this.parts[i].parse(input, end);\n      if (subResult.isSuccess()) {\n        return new OptionResult(subResult, this, input, failAttempt);\n      }\n      failAttempt.push(subResult);\n    }\n    return new OptionResult(null, this, input, failAttempt);\n  }\n\n  public toString() {\n    return this.id;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Expression/ExpressionOptions.ts","import { Result } from './Result';\nimport _ = require('underscore');\nimport { Expression } from '../Expression/Expression';\n\nexport class OptionResult extends Result {\n  constructor(private result: Result, public expression: Expression, public input: string, public failAttempt: Result[]) {\n    super(result != null ? [result] : null, expression, input);\n    _.forEach(this.failAttempt, subResult => {\n      subResult.parent = this;\n    });\n  }\n\n  /**\n   * Return all fail result.\n   */\n  public getExpect(): Result[] {\n    var expect = [];\n    if (this.result != null) {\n      expect = this.result.getExpect();\n    }\n    expect = _.reduce(this.failAttempt, (expect: Result[], result: Result) => expect.concat(result.getExpect()), expect);\n    if (expect.length > 0 && _.all(expect, result => result.input == this.input)) {\n      return [this];\n    }\n    return expect;\n  }\n\n  /**\n   * Clean the result to have the most relevant result. If the result is successful just return a clone of it.\n   */\n  public clean(path?: Result[]): Result {\n    if (path != null || !this.isSuccess()) {\n      // Result will be a ref. We skip it for cleaner tree.\n      path = _.rest(path || _.last(this.getBestExpect()).path(this));\n      // next can be Result or one of the failAttempt. In both case we have only one child\n      var next = _.first(path);\n      if (next == null) {\n        return new Result(null, this.expression, this.input);\n      }\n      return new Result([next.clean(_.rest(path))], this.expression, this.input);\n    }\n    // Result will be a ref. We skip it for cleaner tree.\n    return new Result(_.map(this.result.subResults, subResult => subResult.clean()), this.expression, this.input);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Result/OptionResult.ts","import { Expression } from './Expression';\nimport { Grammar } from '../Grammar';\nimport { Result } from '../Result/Result';\nimport { EndOfInputResult } from '../Result/Result';\n\nexport class ExpressionRegExp implements Expression {\n  constructor(public value: RegExp, public id: string, grammar: Grammar) {}\n\n  parse(input: string, end: boolean): Result {\n    var groups = input.match(this.value);\n    // if the RegExp do not match at the start, ignore it\n    if (groups != null && groups.index != 0) {\n      groups = null;\n    }\n    var result = new Result(groups != null ? groups[0] : null, this, input);\n    // if is successful and we require the end but the length of parsed is\n    // lower than the input length, return a EndOfInputExpected Result\n    if (result.isSuccess() && end && input.length > result.value.length) {\n      return new EndOfInputResult(result);\n    }\n    return result;\n  }\n\n  public toString() {\n    return this.id;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Expression/ExpressionRegExp.ts","import { Expression } from './Expression';\nimport { Result } from '../Result/Result';\nimport { Grammar } from '../Grammar';\n\nexport interface ExpressionFunctionArgument {\n  (input: string, end: boolean, expression: Expression): Result;\n}\n\nexport class ExpressionFunction implements Expression {\n  constructor(public func: ExpressionFunctionArgument, public id: string, public grammar: Grammar) {}\n\n  public parse(input: string, end: boolean): Result {\n    return this.func(input, end, this);\n  }\n\n  public toString() {\n    return this.id;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Expression/ExpressionFunction.ts","import { Result } from '../Result/Result';\nimport { Expression } from './Expression';\n\nexport class ExpressionList implements Expression {\n  constructor(private parts: Expression[], public id: string) {\n    if (parts.length == 0) {\n      throw new Error(JSON.stringify(id) + ' should have at least 1 parts');\n    }\n  }\n\n  parse(input: string, end: boolean): Result {\n    var subResults: Result[] = [];\n    var subResult: Result;\n    var subInput = input;\n\n    for (var i = 0; i < this.parts.length; i++) {\n      var part = this.parts[i];\n      subResult = part.parse(subInput, end && i == this.parts.length - 1);\n      subResults.push(subResult);\n      // if the subResult do not succeed, stop the parsing\n      if (!subResult.isSuccess()) {\n        break;\n      } else {\n        subInput = subInput.substr(subResult.getLength());\n      }\n    }\n    return new Result(subResults, this, input);\n  }\n\n  public toString() {\n    return this.id;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Expression/ExpressionList.ts","import { SubGrammar } from './Expressions';\nimport { Field } from './Field';\n\nexport var NestedQuery: SubGrammar = {\n  basicExpressions: ['NestedQuery'],\n  grammars: {\n    NestedQuery: '[[NestedField][OptionalSpaces][Expressions]]',\n    NestedField: '[[Field]]',\n    FieldValue: ['NestedQuery']\n  },\n  include: [Field]\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/NestedQuery.ts","import { SubGrammar } from './Expressions';\nimport { Basic } from './Basic';\n\nexport const Date: SubGrammar = {\n  grammars: {\n    Date: '[DateYear]/[DateMonth]/[DateDay]',\n    DateYear: /([0-9]{4})/,\n    DateMonth: /(1[0-2]|0?[1-9])/,\n    DateDay: /([1-2][0-9]|3[0-1]|0?[1-9])/,\n    DateRange: '[Date][Spaces?]..[Spaces?][Date]',\n    DateRelative: ['DateRelativeNegative', 'DateRelativeTerm'],\n    DateRelativeTerm: /now|today|yesterday/,\n    DateRelativeNegative: '[DateRelativeTerm][DateRelativeNegativeRef]',\n    DateRelativeNegativeRef: /([\\-\\+][0-9]+(s|m|h|d|mo|y))/\n  },\n  include: [Basic]\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/Date.ts","import { Basic } from './Basic';\nimport { SubGrammar } from './Expressions';\nexport const QueryExtension: SubGrammar = {\n  basicExpressions: ['QueryExtension'],\n  grammars: {\n    QueryExtension: '$[QueryExtensionName]([QueryExtensionArguments])',\n    QueryExtensionName: /\\w+/,\n    QueryExtensionArguments: '[QueryExtensionArgumentList*][QueryExtensionArgument]',\n    QueryExtensionArgumentList: '[QueryExtensionArgument][Spaces?],[Spaces?]',\n    QueryExtensionArgument: '[QueryExtensionArgumentName]:[Spaces?][QueryExtensionArgumentValue]',\n    QueryExtensionArgumentName: /\\w+/,\n    QueryExtensionArgumentValue: ['SingleQuoted', 'Expressions']\n  },\n  include: [Basic]\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/QueryExtension.ts","import { SubGrammar } from './Expressions';\n\nexport const SubExpression: SubGrammar = {\n  basicExpressions: ['SubExpression'],\n  grammars: {\n    SubExpression: '([Expressions])'\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/SubExpression.ts","import * as _ from 'underscore';\nimport { Component } from '../Core';\nimport { l } from '../strings/Strings';\nimport { $$ } from '../utils/Dom';\nimport { KEYBOARD } from '../utils/KeyboardUtils';\nimport { MagicBoxInstance } from './MagicBox';\nimport { Result } from './Result/Result';\n\nexport class InputManager {\n  public input: HTMLInputElement;\n  private underlay: HTMLElement;\n  private highlightContainer: HTMLElement;\n  private ghostTextContainer: HTMLElement;\n  private root: HTMLElement;\n\n  private result: Result;\n  private wordCompletion: string;\n\n  private hasFocus: boolean = false;\n\n  /**\n   * Binding event\n   */\n  public onblur: () => void;\n  public onfocus: () => void;\n  public onkeyup: (key: number) => boolean;\n  public onkeydown: (key: number) => boolean;\n  public onchangecursor: () => void;\n  public ontabpress: () => void;\n\n  public set expanded(isExpanded: boolean) {\n    this.input.setAttribute('aria-expanded', isExpanded.toString());\n  }\n\n  public set activeDescendant(element: HTMLElement) {\n    if (element) {\n      this.input.setAttribute('aria-activedescendant', element.id);\n    } else {\n      this.input.removeAttribute('aria-activedescendant');\n    }\n  }\n\n  constructor(element: HTMLElement, private onchange: (text: string, wordCompletion: boolean) => void, private magicBox: MagicBoxInstance) {\n    this.root = Component.resolveRoot(element);\n    this.underlay = document.createElement('div');\n    this.underlay.className = 'magic-box-underlay';\n\n    this.highlightContainer = document.createElement('span');\n    this.highlightContainer.className = 'magic-box-highlight-container';\n    this.underlay.appendChild(this.highlightContainer);\n\n    this.ghostTextContainer = document.createElement('span');\n    this.ghostTextContainer.className = 'magic-box-ghost-text';\n    this.underlay.appendChild(this.ghostTextContainer);\n\n    this.input = $$(element).find('input') as HTMLInputElement;\n    if (!this.input) {\n      this.input = document.createElement('input');\n      element.appendChild(this.underlay);\n      element.appendChild(this.input);\n    } else {\n      element.insertBefore(this.underlay, this.input);\n    }\n\n    this.setupHandler();\n    this.addAccessibilitiesProperties();\n  }\n\n  /**\n   * Update the input with the result value\n   */\n  private updateInput() {\n    if (this.input.value != this.result.input) {\n      this.input.value = this.result.input;\n      if (this.hasFocus) {\n        this.setCursor(this.getValue().length);\n      }\n    }\n  }\n\n  /**\n   * Update the highlight with the result value\n   */\n  private updateHighlight() {\n    $$(this.highlightContainer).empty();\n    this.highlightContainer.appendChild(this.result.toHtmlElement());\n  }\n\n  /**\n   * Update the ghostText with the wordCompletion\n   */\n  private updateWordCompletion() {\n    $$(this.ghostTextContainer).empty();\n    this.ghostTextContainer.innerHTML = '';\n    if (this.wordCompletion != null) {\n      this.ghostTextContainer.appendChild(document.createTextNode(this.wordCompletion.substr(this.result.input.length)));\n    }\n  }\n\n  /**\n   * Set the result and update visual if needed\n   */\n  public setResult(result: Result, wordCompletion?: string) {\n    this.result = result;\n\n    this.updateInput();\n\n    this.updateHighlight();\n\n    // reuse last wordCompletion for a better visual\n    if (_.isUndefined(wordCompletion) && this.wordCompletion != null && this.wordCompletion.indexOf(this.result.input) == 0) {\n      this.updateWordCompletion();\n    } else {\n      this.setWordCompletion(wordCompletion);\n    }\n\n    this.updateScroll();\n  }\n\n  /**\n   * Set the word completion. will be ignore if the word completion do not start with the result input\n   */\n  public setWordCompletion(wordCompletion: string) {\n    if (wordCompletion != null && wordCompletion.toLowerCase().indexOf(this.result.input.toLowerCase()) != 0) {\n      wordCompletion = null;\n    }\n    this.wordCompletion = wordCompletion;\n    this.updateWordCompletion();\n    this.updateScroll();\n  }\n\n  /**\n   * Set cursor position\n   */\n  public setCursor(index: number) {\n    this.input.focus();\n    if ((<any>this.input).createTextRange) {\n      var range = (<any>this.input).createTextRange();\n      range.move('character', index);\n      range.select();\n    } else if (this.input.selectionStart != null) {\n      this.input.focus();\n      this.input.setSelectionRange(index, index);\n    }\n  }\n\n  public getCursor() {\n    return this.input.selectionStart;\n  }\n\n  /**\n   * Update the scroll of the underlay this allowed the highlight to match the text\n   */\n\n  private updateScrollDefer: number;\n  private updateScroll(defer = true) {\n    var callback = () => {\n      // this is the cheapest call we can do before update scroll\n      if (this.underlay.clientWidth < this.underlay.scrollWidth) {\n        this.underlay.style.visibility = 'hidden';\n        this.underlay.scrollLeft = this.input.scrollLeft;\n        this.underlay.scrollTop = this.input.scrollTop;\n        this.underlay.style.visibility = 'visible';\n      }\n      this.updateScrollDefer = null;\n      // one day we will have to remove this\n      if (this.hasFocus) {\n        this.updateScroll();\n      }\n    };\n    // sometime we want it to be updated as soon as posible to have no flickering\n    if (!defer) {\n      callback();\n    } else if (this.updateScrollDefer == null) {\n      this.updateScrollDefer = requestAnimationFrame(callback);\n    }\n  }\n\n  private setupHandler() {\n    this.input.onblur = () => {\n      this.hasFocus = false;\n      setTimeout(() => {\n        if (!this.hasFocus) {\n          this.onblur && this.onblur();\n        }\n      }, 300);\n      this.updateScroll();\n    };\n    this.input.onfocus = () => {\n      if (!this.hasFocus) {\n        this.hasFocus = true;\n        this.updateScroll();\n        this.onfocus && this.onfocus();\n      }\n    };\n    this.input.onkeydown = e => {\n      this.keydown(e);\n    };\n    this.input.onkeyup = e => {\n      this.keyup(e);\n    };\n    this.input.oncut = () => {\n      setTimeout(() => {\n        this.onInputChange();\n      });\n    };\n    this.input.onpaste = () => {\n      setTimeout(() => {\n        this.onInputChange();\n      });\n    };\n  }\n\n  private addAccessibilitiesProperties() {\n    this.input.setAttribute('autocomplete', 'off');\n    this.input.setAttribute('type', 'text');\n    this.input.setAttribute('role', 'combobox');\n    this.input.setAttribute('form', 'coveo-dummy-form');\n    this.input.setAttribute('aria-autocomplete', 'list');\n    this.input.setAttribute('title', `${l('InsertAQuery')}. ${l('PressEnterToSend')}`);\n  }\n\n  public focus() {\n    // neet a timeout for IE8-9\n    setTimeout(() => {\n      this.input.focus();\n      this.setCursor(this.getValue().length);\n    });\n  }\n\n  public blur() {\n    if (this.hasFocus) {\n      this.input.blur();\n    }\n  }\n\n  private keydown(e: KeyboardEvent) {\n    switch (e.keyCode || e.which) {\n      case KEYBOARD.TAB:\n        // Take care of not \"preventing\" the default event behaviour : For accessibility reasons, it is much simpler\n        // to simply let the browser do it's standard action (which is to focus out of the input).\n        // Instead, handle \"tabPress\" immediately instead of \"keyup\".\n        // The focus will be on the next element in the page when the key is released, so keyup on the input will never be triggered.\n        this.tabPress();\n        this.magicBox.clearSuggestion();\n        break;\n      default:\n        e.stopPropagation();\n        if (this.onkeydown == null || this.onkeydown(e.keyCode || e.which)) {\n          requestAnimationFrame(() => {\n            this.onInputChange();\n          });\n        } else {\n          e.preventDefault();\n        }\n        break;\n    }\n  }\n\n  private keyup(e: KeyboardEvent) {\n    switch (e.keyCode || e.which) {\n      case KEYBOARD.LEFT_ARROW:\n      case KEYBOARD.RIGHT_ARROW:\n        this.handleLeftRightArrow(e);\n        break;\n      default:\n        if (this.onkeydown == null || this.onkeyup(e.keyCode || e.which)) {\n          this.onInputChange();\n        } else {\n          e.preventDefault();\n        }\n        break;\n    }\n  }\n\n  private handleLeftRightArrow(e: KeyboardEvent) {\n    const querySuggestPreview = $$(this.root).find(`.${Component.computeCssClassNameForType('QuerySuggestPreview')}`);\n    if (!querySuggestPreview) {\n      this.onchangecursor();\n    }\n\n    const inputChanged = this.onkeydown == null || this.onkeyup(e.keyCode || e.which);\n    inputChanged ? this.onInputChange() : e.preventDefault();\n  }\n\n  private tabPress() {\n    this.ontabpress && this.ontabpress();\n    this.onblur && this.onblur();\n  }\n\n  private onInputChange() {\n    if (this.result.input != this.input.value) {\n      this.onchange(this.input.value, false);\n    }\n  }\n\n  public getValue() {\n    return this.input.value;\n  }\n\n  public getWordCompletion() {\n    return this.wordCompletion;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/InputManager.ts","import { flatten } from 'underscore';\n\nexport interface IQueryProcessorOptions {\n  timeout: number;\n}\n\nexport enum ProcessingStatus {\n  Finished,\n  TimedOut,\n  Overriden\n}\n\nexport interface IQueryProcessResult<T> {\n  status: ProcessingStatus;\n  results: T[];\n}\n\n/**\n * IE11 equivalent of Promise.race\n * Adapted from Promise.race(iterable) polyfill on https://www.promisejs.org/api/\n */\nfunction racePromises<T>(promises: Thenable<T>[]): Promise<T> {\n  return new Promise<T>((resolve, reject) => promises.forEach(value => Promise.resolve(value).then(resolve, reject)));\n}\n\nexport class QueryProcessor<T> {\n  private override: () => void;\n  private options: IQueryProcessorOptions;\n  private processedResults: T[][];\n\n  constructor(options: Partial<IQueryProcessorOptions> = {}) {\n    this.options = { timeout: 500, ...options };\n  }\n\n  /**\n   * Overrides the previous queries and accumulates the result of promise arrays with a timeout.\n   */\n  public async processQueries(queries: (T[] | Promise<T[]>)[]): Promise<IQueryProcessResult<T>> {\n    this.overrideIfProcessing();\n    this.processedResults = new Array(queries.length);\n    const asyncQueries = queries.map(query => (query instanceof Promise ? query : Promise.resolve(query)));\n\n    return racePromises([\n      this.accumulateResultsChronologically(asyncQueries).then(() => this.buildProcessResults(ProcessingStatus.Finished)),\n      this.waitForOverride().then(() => this.buildProcessResults(ProcessingStatus.Overriden)),\n      this.waitForTimeout().then(() => this.buildProcessResults(ProcessingStatus.TimedOut))\n    ]);\n  }\n\n  public async overrideIfProcessing() {\n    if (this.override) {\n      this.override();\n    }\n  }\n\n  private get orderedResults(): T[] {\n    return flatten(this.processedResults.filter(result => !!result), true);\n  }\n\n  private buildProcessResults(status: ProcessingStatus): IQueryProcessResult<T> {\n    return {\n      status,\n      results: status !== ProcessingStatus.Overriden ? this.orderedResults : []\n    };\n  }\n\n  private async accumulateResultsChronologically(queries: Promise<T[]>[]) {\n    const output = this.processedResults;\n    await Promise.all(queries.map((query, i) => query.then(items => (output[i] = items))));\n  }\n\n  private waitForOverride() {\n    return new Promise<void>(resolve => {\n      this.override = () => {\n        this.override = null;\n        resolve();\n      };\n    });\n  }\n\n  private waitForTimeout() {\n    return new Promise<void>(resolve => setTimeout(() => resolve(), this.options.timeout));\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/QueryProcessor.ts","import { SubGrammar } from './Expressions';\nimport { NestedQuery } from './NestedQuery';\nimport { QueryExtension } from './QueryExtension';\nimport { Basic } from './Basic';\nimport { Field } from './Field';\nimport { SubExpression } from './SubExpression';\n\nexport const Complete: SubGrammar = {\n  include: [NestedQuery, QueryExtension, SubExpression, Field, Basic]\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/Complete.ts","import { Grammar } from '../Grammar';\nimport { ExpressionDef } from '../Expression/Expression';\nimport * as _ from 'underscore';\n\nexport interface SubGrammar {\n  grammars?: { [id: string]: ExpressionDef };\n  expressions?: string[];\n  basicExpressions?: string[];\n  include?: SubGrammar[];\n}\n\nfunction loadSubGrammar(\n  expressions: string[],\n  basicExpressions: string[],\n  grammars: { [id: string]: ExpressionDef },\n  subGrammar: SubGrammar\n) {\n  _.each(subGrammar.expressions, expression => {\n    if (!_.contains(expressions, expression)) {\n      expressions.push(expression);\n    }\n  });\n  _.each(subGrammar.basicExpressions, expression => {\n    if (!_.contains(basicExpressions, expression)) {\n      basicExpressions.push(expression);\n    }\n  });\n  _.each(subGrammar.grammars, (expressionDef: ExpressionDef, id: string) => {\n    if (!(id in grammars)) {\n      grammars[id] = expressionDef;\n    } else {\n      if (_.isArray(grammars[id]) && _.isArray(expressionDef)) {\n        _.each(<string[]>expressionDef, (value: string) => {\n          (<string[]>grammars[id]).push(value);\n        });\n      } else {\n        _.each(<string[]>expressionDef, (value: string) => {\n          (<string[]>grammars[id]).push(value);\n        });\n        throw new Error('Can not merge ' + id + '(' + JSON.stringify(expressionDef) + ' => ' + JSON.stringify(grammars[id]) + ')');\n      }\n    }\n  });\n}\n\nexport function Expressions(...subGrammars: SubGrammar[]): { start: string; expressions: { [id: string]: ExpressionDef } } {\n  var expressions: string[] = [];\n  var BasicExpression: string[] = [];\n  var grammars: { [id: string]: ExpressionDef } = {\n    Start: ['Expressions', 'Empty'],\n    Expressions: '[OptionalSpaces][Expression][ExpressionsList*][OptionalSpaces]',\n    ExpressionsList: '[Spaces][Expression]',\n    Expression: expressions,\n    BasicExpression: BasicExpression,\n    OptionalSpaces: / */,\n    Spaces: / +/,\n    Empty: /(?!.)/\n  };\n  for (var i = 0; i < subGrammars.length; i++) {\n    loadSubGrammar(expressions, BasicExpression, grammars, subGrammars[i]);\n    _.each(subGrammars[i].include, subGrammar => {\n      if (!_.contains(subGrammars, subGrammar)) {\n        subGrammars.push(subGrammar);\n      }\n    });\n  }\n  expressions.push('BasicExpression');\n  return {\n    start: 'Start',\n    expressions: grammars\n  };\n}\n\nexport function ExpressionsGrammar(...subGrammars: SubGrammar[]) {\n  var grammar = Expressions.apply(this, subGrammars);\n  return new Grammar(grammar.start, grammar.expressions);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/Expressions.ts","import { ISearchResultPreview } from '../magicbox/ResultPreviewsManager';\nimport { Suggestion } from '../magicbox/SuggestionsManager';\nimport { IQuery } from '../rest/Query';\n\nexport interface IBuildingResultPreviewsQueryEventArgs {\n  /**\n   * The query to be sent to Search API.\n   */\n  query: IQuery;\n}\n\n/**\n * Executed when a {@link Suggestion} is focused before {@link PopulateSearchResultPreviews} is called to fetch more options.\n */\nexport interface IUpdateResultPreviewsManagerOptionsEventArgs {\n  /**\n   * How many milliseconds should a {@link Suggestion} be focused for before {@link PopulateSearchResultPreviews} is called.\n   *\n   * If this is not defined, it will default to 200ms.\n   */\n  displayAfterDuration?: number;\n}\n\n/**\n * Executed when a {@link Suggestion} is focused and waiting for search result previews.\n */\nexport interface IPopulateSearchResultPreviewsEventArgs {\n  /**\n   * The suggestion to look up search result previews for.\n   */\n  suggestion: Suggestion;\n  /**\n   * The result previews query. This must be set synchronously before the event resolves.\n   * Setting this to a non-empty array will display the given search result previews.\n   */\n  previewsQueries: (ISearchResultPreview[] | Promise<ISearchResultPreview[]>)[];\n}\n\n/**\n * Those are the string definitions of events for ResultPreviewsManager.\n *\n * Those events should be bound to the element returned by `resolveRoot`.\n */\nexport class ResultPreviewsManagerEvents {\n  /**\n   * Executed when building a query to fetch result previews.\n   * This always receives {@link IBuildingResultPreviewsQueryEventArgs} as arguments.\n   */\n  public static buildingResultPreviewsQuery = 'buildingResultPreviewsQuery';\n  /**\n   * Executed when a {@link Suggestion} is focused before {@link PopulateSearchResultPreviews} is called to fetch more options.\n   * This always receives {@link IUpdateResultPreviewsManagerOptionsEventArgs} as arguments.\n   */\n  public static updateResultPreviewsManagerOptions = 'updateResultPreviewsManagerOptions';\n  /**\n   * Executed when a {@link Suggestion} is focused and waiting for search result previews.\n   * This always receives {@link IPopulateSearchResultPreviewsEventArgs} as arguments.\n   */\n  public static populateSearchResultPreviews = 'populateSearchResultPreviews';\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/events/ResultPreviewsManagerEvents.ts","import { Omnibox, IOmniboxOptions } from '../Omnibox/Omnibox';\nimport { Querybox, IQueryboxOptions } from './Querybox';\nimport { ComponentOptionsModel } from '../../models/ComponentOptionsModel';\n\nexport class QueryboxOptionsProcessing {\n  constructor(public owner: Omnibox | Querybox) {}\n\n  private get options() {\n    return this.owner.options;\n  }\n\n  private set options(options: IOmniboxOptions | IQueryboxOptions) {\n    this.owner.options = options;\n  }\n\n  public postProcess() {\n    this.options = { ...this.options, ...this.owner.componentOptionsModel.get(ComponentOptionsModel.attributesEnum.searchBox) };\n    this.processQueryOnClearVersusEmptyQuery();\n    this.processQueryOnClearVersusSearchAsYouType();\n  }\n\n  private processQueryOnClearVersusEmptyQuery() {\n    if (this.options.triggerQueryOnClear && this.owner.searchInterface.options.allowQueriesWithoutKeywords === false) {\n      this.owner.logger.warn(\n        'Forcing option triggerQueryOnClear to false, as it is not supported when the search interface is configured to not allow queries without keywords (data-allow-queries-without-keywords=\"false\")',\n        this.owner\n      );\n      this.options.triggerQueryOnClear = false;\n    }\n  }\n\n  private processQueryOnClearVersusSearchAsYouType() {\n    if (\n      this.owner.searchInterface.options.allowQueriesWithoutKeywords === true &&\n      this.options.triggerQueryOnClear === false &&\n      this.options.enableSearchAsYouType === true\n    ) {\n      this.owner.logger.warn('Forcing option triggerQueryOnClear to true, since search-as-you-type is enabled', this.owner);\n      this.options.triggerQueryOnClear = true;\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Querybox/QueryboxOptionsProcessing.ts","import { Expression } from '../Expression/Expression';\nimport { ExpressionEndOfInput } from '../Expression/ExpressionEndOfInput';\nimport { ExpressionConstant } from '../Expression/ExpressionConstant';\nimport _ = require('underscore');\n\nexport class Result {\n  public value: string;\n  public subResults: Result[];\n  public parent: Result;\n\n  constructor(value: string | Result[], public expression: Expression, public input: string) {\n    if (_.isString(value)) {\n      this.value = <string>value;\n    } else if (_.isArray(value)) {\n      this.subResults = <Result[]>value;\n      _.forEach(this.subResults, (subResult: Result) => {\n        subResult.parent = this;\n      });\n    }\n  }\n\n  public isSuccess() {\n    // if null is the value, this mean the expression could not parse this input\n    return this.value != null || (this.subResults != null && _.all(this.subResults, subResult => subResult.isSuccess()));\n  }\n\n  /**\n   * Return path to this result ([parent.parent, parent, this])\n   */\n  public path(until?: Result): Result[] {\n    var path: Result[] = this.parent != null && this.parent != until ? this.parent.path(until) : [];\n    path.push(this);\n    return path;\n  }\n\n  /**\n   * Return the closest parent that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n   */\n  public findParent(match: string | { (result: Result): boolean }): Result {\n    var parent = <Result>this;\n    var iterator = _.isString(match) ? (result: Result) => match == result.expression.id : <{ (result: Result): boolean }>match;\n    while (parent != null && !iterator(parent)) {\n      parent = parent.parent;\n    }\n    return parent;\n  }\n\n  /**\n   * Return the first child that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n   */\n  public find(match: string | { (result: Result): boolean }): Result {\n    var iterator = _.isString(match) ? (result: Result) => match == result.expression.id : <{ (result: Result): boolean }>match;\n    if (iterator(this)) {\n      return this;\n    }\n    if (this.subResults) {\n      for (var i = 0; i < this.subResults.length; i++) {\n        var subResultFind = this.subResults[i].find(iterator);\n        if (subResultFind) {\n          return subResultFind;\n        }\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Return all children that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n   */\n  public findAll(match: string | { (result: Result): boolean }): Result[] {\n    var results: Result[] = [];\n    var iterator = _.isString(match) ? (result: Result) => match == result.expression.id : <{ (result: Result): boolean }>match;\n    if (iterator(this)) {\n      results.push(this);\n    }\n    if (this.subResults) {\n      results = _.reduce(this.subResults, (results, subResult: Result) => results.concat(subResult.findAll(iterator)), results);\n    }\n    return results;\n  }\n\n  /**\n   * Return the first child that match the condition (can be it-self). If match is a string, it will search for the result expresion id\n   */\n  public resultAt(index: number, match?: string | { (result: Result): boolean }): Result[] {\n    if (index < 0 || index > this.getLength()) {\n      return [];\n    }\n    if (match != null) {\n      if (_.isString(match)) {\n        if (match == this.expression.id) {\n          return [this];\n        }\n      } else {\n        if ((<{ (result: Result): boolean }>match)(this)) {\n          return [this];\n        }\n      }\n    } else {\n      var value = this.value == null && this.subResults == null ? this.input : this.value;\n      if (value != null) {\n        return [this];\n      }\n    }\n\n    if (this.subResults != null) {\n      var results = [];\n      for (var i = 0; i < this.subResults.length; i++) {\n        var subResult = this.subResults[i];\n        results = results.concat(subResult.resultAt(index, match));\n        index -= subResult.getLength();\n        if (index < 0) {\n          break;\n        }\n      }\n      return results;\n    }\n\n    return [];\n  }\n\n  /**\n   * Return all fail result.\n   */\n  public getExpect(): Result[] {\n    if (this.value == null && this.subResults == null) {\n      return [this];\n    }\n    if (this.subResults != null) {\n      return _.reduce(this.subResults, (expect: Result[], result: Result) => expect.concat(result.getExpect()), []);\n    }\n    return [];\n  }\n\n  /**\n   * Return the best fail result (The farthest result who got parsed). We also remove duplicate and always return the simplest result of a kind\n   */\n  public getBestExpect(): Result[] {\n    var expects = this.getExpect();\n    var groups = _.groupBy(expects, expect => expect.input);\n    var key = _.last(\n      _.keys(groups).sort((a, b) => {\n        return b.length - a.length;\n      })\n    );\n    var bestResults = groups[key];\n    var groups = _.groupBy(bestResults, expect => expect.expression.id);\n    return _.map(groups, (bestResults: Result[]): Result => {\n      return _.chain(bestResults)\n        .map(result => {\n          return {\n            path: result.path().length,\n            result: result\n          };\n        })\n        .sortBy('path')\n        .pluck('result')\n        .first()\n        .value();\n    });\n  }\n\n  public getHumanReadableExpect() {\n    var expect = this.getBestExpect();\n    var input = expect.length > 0 ? _.last(expect).input : '';\n    return (\n      'Expected ' +\n      _.map(expect, (result: Result) => result.getHumanReadable()).join(' or ') +\n      ' but ' +\n      (input.length > 0 ? JSON.stringify(input[0]) : 'end of input') +\n      ' found.'\n    );\n  }\n\n  /**\n   * Return a string that represent what is before this result\n   */\n  public before(): string {\n    if (this.parent == null) {\n      return '';\n    }\n    var index = _.indexOf(this.parent.subResults, this);\n    return (\n      this.parent.before() +\n      _.chain(this.parent.subResults)\n        .first(index)\n        .map(subResult => subResult.toString())\n        .join('')\n        .value()\n    );\n  }\n\n  /**\n   * Return a string that represent what is after this result\n   */\n  public after(): string {\n    if (this.parent == null) {\n      return '';\n    }\n    var index = _.indexOf(this.parent.subResults, this);\n    return (\n      _.chain(this.parent.subResults)\n        .last(this.parent.subResults.length - index - 1)\n        .map(subResult => subResult.toString())\n        .join('')\n        .value() + this.parent.after()\n    );\n  }\n\n  /**\n   * Return the length of the result\n   */\n  public getLength() {\n    if (this.value != null) {\n      return this.value.length;\n    }\n\n    if (this.subResults != null) {\n      return _.reduce(this.subResults, (length: number, subResult: Result) => length + subResult.getLength(), 0);\n    }\n\n    return this.input.length;\n  }\n\n  public toHtmlElement(): HTMLElement {\n    var element = document.createElement('span');\n    var id = this.expression != null ? this.expression.id : null;\n\n    if (id != null) {\n      element.setAttribute('data-id', id);\n    }\n\n    element.setAttribute('data-success', this.isSuccess().toString());\n\n    if (this.value != null) {\n      element.appendChild(document.createTextNode(this.value));\n      element.setAttribute('data-value', this.value);\n    } else if (this.subResults != null) {\n      _.each(this.subResults, (subResult: Result) => {\n        element.appendChild(subResult.toHtmlElement());\n      });\n    } else {\n      element.appendChild(document.createTextNode(this.input));\n      element.setAttribute('data-input', this.input);\n      element.className = 'magic-box-error' + (this.input.length > 0 ? '' : ' magic-box-error-empty');\n    }\n\n    element['result'] = this;\n\n    return element;\n  }\n\n  /**\n   * Clean the result to have the most relevant result. If the result is successful just return a clone of it.\n   */\n  public clean(path?: Result[]): Result {\n    if (path != null || !this.isSuccess()) {\n      path = path || _.last(this.getBestExpect()).path(this);\n      var next = _.first(path);\n      if (next != null) {\n        var nextIndex = _.indexOf(this.subResults, next);\n        var subResults: Result[] = nextIndex == -1 ? [] : _.map(_.first(this.subResults, nextIndex), subResult => subResult.clean());\n        subResults.push(next.clean(_.rest(path)));\n        return new Result(subResults, this.expression, this.input);\n      } else {\n        return new Result(null, this.expression, this.input);\n      }\n    }\n    if (this.value != null) {\n      return new Result(this.value, this.expression, this.input);\n    }\n    if (this.subResults != null) {\n      return new Result(_.map(this.subResults, subResult => subResult.clean()), this.expression, this.input);\n    }\n  }\n\n  public clone(): Result {\n    if (this.value != null) {\n      return new Result(this.value, this.expression, this.input);\n    }\n    if (this.subResults != null) {\n      return new Result(_.map(this.subResults, subResult => subResult.clone()), this.expression, this.input);\n    }\n    return new Result(null, this.expression, this.input);\n  }\n\n  public toString() {\n    if (this.value != null) {\n      return this.value;\n    }\n    if (this.subResults != null) {\n      return _.map(this.subResults, subresult => subresult.toString()).join('');\n    }\n    return this.input;\n  }\n\n  public getHumanReadable() {\n    if (this.expression instanceof ExpressionConstant) {\n      return JSON.stringify((<ExpressionConstant>this.expression).value);\n    }\n    return this.expression.id;\n  }\n}\n\nexport class EndOfInputResult extends Result {\n  constructor(result: Result) {\n    super([result], ExpressionEndOfInput, result.input);\n    var endOfInput = new Result(null, ExpressionEndOfInput, result.input.substr(result.getLength()));\n    endOfInput.parent = this;\n    this.subResults.push(endOfInput);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Result/Result.ts","import { exportGlobally } from '../GlobalExports';\nimport { Expression } from './Expression/Expression';\nimport { ExpressionConstant } from './Expression/ExpressionConstant';\nimport { ExpressionEndOfInput } from './Expression/ExpressionEndOfInput';\nimport { ExpressionFunction, ExpressionFunctionArgument } from './Expression/ExpressionFunction';\nimport { ExpressionList } from './Expression/ExpressionList';\nimport { ExpressionOptions } from './Expression/ExpressionOptions';\nimport { ExpressionRef } from './Expression/ExpressionRef';\nimport { ExpressionRegExp } from './Expression/ExpressionRegExp';\nimport { Grammar } from './Grammar';\nimport { SubGrammar } from './Grammars/Expressions';\nimport { Grammars } from './Grammars/Grammars';\nimport { InputManager } from './InputManager';\nimport { createMagicBox, MagicBoxInstance, requestAnimationFrame } from './MagicBox';\nimport { MagicBoxUtils as Utils } from './MagicBoxUtils';\nimport { OptionResult } from './Result/OptionResult';\nimport { RefResult } from './Result/RefResult';\nimport { EndOfInputResult, Result } from './Result/Result';\nimport { Suggestion, SuggestionsManager } from './SuggestionsManager';\nexport type ExpressionImportedLocally = Expression;\nexport type SuggestionImportedLocally = Suggestion;\nexport type SubGrammarLocally = SubGrammar;\nexport type ExpressionFunctionArgumentLocally = ExpressionFunctionArgument;\nexport const GrammarsImportedLocally = Grammars;\n\nexport function doMagicBoxExport() {\n  exportGlobally({\n    MagicBox: {\n      EndOfInputResult,\n      ExpressionConstant,\n      ExpressionEndOfInput,\n      ExpressionFunction,\n      ExpressionList,\n      ExpressionOptions,\n      ExpressionRef,\n      ExpressionRegExp,\n      Grammar,\n      Grammars,\n      InputManager,\n      Instance: MagicBoxInstance,\n      OptionResult,\n      RefResult,\n      Result,\n      SuggestionsManager,\n      Utils,\n      create: createMagicBox,\n      requestAnimationFrame\n    }\n  });\n}\n\nexport declare namespace MagicBox {\n  export const EndOfInputResult: EndOfInputResult;\n  export const ExpressionConstant: ExpressionConstant;\n  export const ExpressionFunction: ExpressionFunction;\n  export const ExpressionList: ExpressionList;\n  export const ExpressionOptions: ExpressionOptions;\n  export const ExpressionRef: ExpressionRef;\n  export const ExpressionRegExp: ExpressionRegExp;\n  export const Grammar: Grammar;\n  export const InputManager: InputManager;\n  export const Instance: MagicBoxInstance;\n  export const OptionResult: OptionResult;\n  export const RefResult: RefResult;\n  export const Result: Result;\n  export const SuggestionsManager: SuggestionsManager;\n  export const Utils: Utils;\n  export const ExpressionEndOfInput;\n  export type Instance = MagicBoxInstance;\n  export type Suggestion = SuggestionImportedLocally;\n\n  export namespace Grammars {\n    export const Basic: typeof GrammarsImportedLocally.Basic;\n    export const notInWord: typeof GrammarsImportedLocally.notInWord;\n    export const notWordStart: typeof GrammarsImportedLocally.notWordStart;\n    export const Complete: typeof GrammarsImportedLocally.Complete;\n    export const Date: typeof GrammarsImportedLocally.Date;\n    export const Expressions: typeof GrammarsImportedLocally.Expressions;\n    export const ExpressionsGrammar: typeof GrammarsImportedLocally.ExpressionsGrammar;\n    export const Field: typeof GrammarsImportedLocally.Field;\n    export const NestedQuery: typeof GrammarsImportedLocally.NestedQuery;\n    export const QueryExtension: typeof GrammarsImportedLocally.QueryExtension;\n    export const SubExpression: typeof GrammarsImportedLocally.SubExpression;\n  }\n\n  export const createMagicBox;\n  export const create;\n  export const requestAnimationFrame;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/doMagicBoxExport.ts","import { Basic, notInWord, notWordStart } from './Basic';\nimport { Complete } from './Complete';\nimport { Date } from './Date';\nimport { Expressions, ExpressionsGrammar, SubGrammar } from './Expressions';\nimport { ExpressionFunctionArgument } from '../Expression/ExpressionFunction';\nimport { Field } from './Field';\nimport { NestedQuery } from './NestedQuery';\nimport { QueryExtension } from './QueryExtension';\nimport { SubExpression } from './SubExpression';\nexport type SubGrammarImported = SubGrammar;\nexport type ExpressionFunctionArgumentImported = ExpressionFunctionArgument;\n\nexport const Grammars = {\n  Basic,\n  notInWord,\n  notWordStart,\n  Complete,\n  Date,\n  Expressions,\n  ExpressionsGrammar,\n  Field,\n  NestedQuery,\n  QueryExtension,\n  SubExpression\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/Grammars/Grammars.ts","import { $$, Dom } from '../utils/Dom';\nimport { l } from '../strings/Strings';\nimport { defaults, findIndex } from 'underscore';\nimport { Component } from '../ui/Base/Component';\nimport { Direction, Suggestion } from './SuggestionsManager';\nimport {\n  ResultPreviewsManagerEvents,\n  IPopulateSearchResultPreviewsEventArgs,\n  IUpdateResultPreviewsManagerOptionsEventArgs\n} from '../events/ResultPreviewsManagerEvents';\nimport { QueryProcessor, ProcessingStatus } from './QueryProcessor';\nimport { Utils } from '../utils/Utils';\n\nexport interface ISearchResultPreview {\n  element: HTMLElement;\n  onSelect: () => void;\n}\n\nexport interface IResultPreviewsManagerOptions {\n  previewClass: string;\n  selectedClass: string;\n  previewHeaderText: string;\n  previewHeaderFieldText: string;\n  timeout: number;\n}\n\nexport class ResultPreviewsManager {\n  private options: IResultPreviewsManagerOptions;\n  private suggestionsPreviewContainer: Dom;\n  private resultPreviewsContainer: Dom;\n  private lastQueriedSuggestion: Suggestion;\n  private lastDisplayedSuggestion: Suggestion;\n  private previewsProcessor: QueryProcessor<ISearchResultPreview>;\n  private lastDelay: Promise<void>;\n  private root: HTMLElement;\n\n  public get previewsOwner() {\n    return this.lastDisplayedSuggestion;\n  }\n\n  public get hasPreviews() {\n    return !!this.suggestionsPreviewContainer;\n  }\n\n  public get focusedPreviewElement() {\n    if (!this.hasPreviews) {\n      return null;\n    }\n    const focusedElement = this.suggestionsPreviewContainer.findClass(this.options.selectedClass)[0];\n    if (!focusedElement || !focusedElement.classList.contains(this.options.previewClass)) {\n      return null;\n    }\n    return focusedElement;\n  }\n\n  public get previewElements() {\n    if (!this.hasPreviews) {\n      return [];\n    }\n    return this.suggestionsPreviewContainer.findClass(this.options.previewClass);\n  }\n\n  private get suggestionsListbox() {\n    return $$($$(this.element).findClass('coveo-magicbox-suggestions')[0]);\n  }\n\n  private get numberOfResultsPerRow() {\n    const previewSelectables = this.suggestionsPreviewContainer.findClass(this.options.previewClass);\n    if (previewSelectables.length === 0) {\n      return 0;\n    }\n    const firstVerticalOffset = previewSelectables[0].offsetTop;\n    const firstIndexOnNextRow = findIndex(previewSelectables, previewSelectable => previewSelectable.offsetTop !== firstVerticalOffset);\n    return firstIndexOnNextRow !== -1 ? firstIndexOnNextRow : previewSelectables.length;\n  }\n\n  private get previewContainerId() {\n    return `coveo-previews-for-${this.lastDisplayedSuggestion.dom.id}`;\n  }\n\n  constructor(private element: HTMLElement, options: Partial<IResultPreviewsManagerOptions> = {}) {\n    this.options = defaults(options, <IResultPreviewsManagerOptions>{\n      previewHeaderText: l('QuerySuggestPreview'),\n      previewHeaderFieldText: l('QuerySuggestPreviewWithField'),\n      previewClass: 'coveo-preview-selectable',\n      selectedClass: 'magic-box-selected'\n    });\n    this.root = Component.resolveRoot(element);\n    this.previewsProcessor = new QueryProcessor({ timeout: this.options.timeout });\n  }\n\n  public async displaySearchResultPreviewsForSuggestion(suggestion: Suggestion) {\n    const externalOptions = this.getExternalOptions();\n    const currentDelay = (this.lastDelay = Utils.resolveAfter(\n      Utils.isNullOrUndefined(externalOptions.displayAfterDuration) ? 200 : externalOptions.displayAfterDuration\n    ));\n    await currentDelay;\n    if (currentDelay !== this.lastDelay) {\n      return;\n    }\n    const isQueryForSuggestionOngoing = suggestion && this.lastQueriedSuggestion === suggestion;\n    if (isQueryForSuggestionOngoing) {\n      return;\n    }\n    const arePreviewsForSuggestionCurrentlyDisplayed = this.lastDisplayedSuggestion === suggestion;\n    if (arePreviewsForSuggestionCurrentlyDisplayed) {\n      this.previewsProcessor.overrideIfProcessing();\n      this.lastQueriedSuggestion = null;\n      return;\n    }\n    this.lastQueriedSuggestion = suggestion;\n    if (!suggestion) {\n      this.displaySuggestionPreviews(null, []);\n      return;\n    }\n    const { status, results } = await this.getSearchResultPreviewsQuery(suggestion);\n    if (status === ProcessingStatus.Overriden) {\n      return;\n    }\n    this.lastQueriedSuggestion = null;\n    this.displaySuggestionPreviews(suggestion, results);\n  }\n\n  public getElementInDirection(direction: Direction) {\n    const previewElements = this.previewElements;\n    const focusedIndex = previewElements.indexOf(this.focusedPreviewElement);\n\n    if (focusedIndex === -1) {\n      return null;\n    }\n\n    if (focusedIndex === 0 && direction === Direction.Left) {\n      return null;\n    }\n\n    return previewElements[(focusedIndex + this.getIncrementInDirection(direction)) % previewElements.length];\n  }\n\n  private getIncrementInDirection(direction: Direction) {\n    switch (direction) {\n      case Direction.Left:\n        return -1;\n      case Direction.Right:\n        return 1;\n      case Direction.Up:\n        return -this.numberOfResultsPerRow;\n      case Direction.Down:\n        return this.numberOfResultsPerRow;\n    }\n  }\n\n  private setHasPreviews(shouldHavePreviews: boolean) {\n    if (this.hasPreviews === !!shouldHavePreviews) {\n      return;\n    }\n    if (shouldHavePreviews) {\n      this.initPreviewForSuggestions();\n    } else {\n      this.revertPreviewForSuggestions();\n    }\n  }\n\n  private initPreviewForSuggestions() {\n    this.suggestionsPreviewContainer = $$(\n      'div',\n      {\n        className: 'coveo-suggestion-container'\n      },\n      this.suggestionsListbox.el,\n      this.buildPreviewContainer()\n    );\n    this.element.appendChild(this.suggestionsPreviewContainer.el);\n    this.suggestionsListbox.setAttribute('aria-controls', this.previewContainerId);\n  }\n\n  private revertPreviewForSuggestions() {\n    this.element.appendChild(this.suggestionsListbox.el);\n    this.suggestionsPreviewContainer.remove();\n    this.suggestionsPreviewContainer = null;\n  }\n\n  private buildPreviewContainer() {\n    return $$(\n      'div',\n      {\n        className: 'coveo-preview-container',\n        id: this.previewContainerId\n      },\n      (this.resultPreviewsContainer = $$('div', {\n        className: 'coveo-preview-results',\n        role: 'listbox',\n        'aria-orientation': 'horizontal'\n      }))\n    ).el;\n  }\n\n  private getExternalOptions() {\n    const optionsEventArgs: IUpdateResultPreviewsManagerOptionsEventArgs = {};\n    $$(this.root).trigger(ResultPreviewsManagerEvents.updateResultPreviewsManagerOptions, optionsEventArgs);\n    return optionsEventArgs;\n  }\n\n  private getSearchResultPreviewsQuery(suggestion: Suggestion) {\n    const populateEventArgs: IPopulateSearchResultPreviewsEventArgs = {\n      suggestion,\n      previewsQueries: []\n    };\n    $$(this.root).trigger(ResultPreviewsManagerEvents.populateSearchResultPreviews, populateEventArgs);\n    return this.previewsProcessor.processQueries(populateEventArgs.previewsQueries);\n  }\n\n  private appendSearchResultPreview(preview: ISearchResultPreview, position: number) {\n    this.resultPreviewsContainer.append(preview.element);\n    preview.element.id = `coveo-result-preview-${position}`;\n    const elementDom = $$(preview.element);\n    elementDom.setAttribute('aria-selected', 'false');\n    elementDom.setAttribute('role', 'option');\n    elementDom.on('click', () => preview.onSelect());\n    elementDom.on('keyboardSelect', () => preview.onSelect());\n  }\n\n  private appendSearchResultPreviews(previews: ISearchResultPreview[]) {\n    this.resultPreviewsContainer.empty();\n    previews.forEach((preview, i) => this.appendSearchResultPreview(preview, i));\n  }\n\n  private displaySuggestionPreviews(suggestion: Suggestion, previews: ISearchResultPreview[]) {\n    this.lastDisplayedSuggestion = suggestion;\n    this.setHasPreviews(previews && previews.length > 0);\n    this.element.classList.toggle('magic-box-hasPreviews', this.hasPreviews);\n    if (!this.hasPreviews) {\n      return;\n    }\n    this.appendSearchResultPreviews(previews);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/ResultPreviewsManager.ts","import { $$, Dom } from '../utils/Dom';\nimport { MagicBoxInstance } from './MagicBox';\nimport { l } from '../strings/Strings';\nimport { AccessibleButton } from '../utils/AccessibleButton';\n\nexport class MagicBoxClear {\n  public element: Dom;\n\n  constructor(magicBox: MagicBoxInstance) {\n    this.element = $$('div', {\n      className: 'magic-box-clear'\n    });\n    const clearIcon = $$('div', {\n      className: 'magic-box-icon'\n    });\n    this.element.append(clearIcon.el);\n\n    this.element.insertAfter($$(magicBox.element).find('input'));\n\n    new AccessibleButton()\n      .withElement(this.element)\n      .withLabel(l('Clear'))\n      .withSelectAction(() => magicBox.clear())\n      .build();\n\n    this.toggleTabindexAndAriaHidden(false);\n  }\n\n  public toggleTabindexAndAriaHidden(hasText: boolean) {\n    const tabindex = hasText ? '0' : '-1';\n    this.element.setAttribute('tabindex', tabindex);\n    this.element.setAttribute('aria-hidden', `${!hasText}`);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/magicbox/MagicBoxClear.ts","///<reference path='Omnibox.ts'/>\nimport { Omnibox, IOmniboxSuggestion } from './Omnibox';\nimport { OmniboxEvents, IPopulateOmniboxSuggestionsEventArgs } from '../../events/OmniboxEvents';\nimport { IFieldDescription } from '../../rest/FieldDescription';\nimport { IEndpointError } from '../../rest/EndpointError';\nimport * as _ from 'underscore';\nimport { Result } from '../../magicbox/Result/Result';\nimport { MagicBoxUtils } from '../../magicbox/MagicBoxUtils';\n\ninterface IFieldAddonHash {\n  type: string;\n  before: string;\n  after: string;\n  current: string;\n  field?: string;\n}\n\nexport class FieldAddon {\n  static INDEX = 64;\n  cache: { [hash: string]: Promise<IOmniboxSuggestion[]> } = {};\n\n  constructor(public omnibox: Omnibox) {\n    this.omnibox.bind.on(this.omnibox.element, OmniboxEvents.populateOmniboxSuggestions, (args: IPopulateOmniboxSuggestionsEventArgs) => {\n      args.suggestions.push(this.getSuggestion());\n    });\n  }\n\n  public getSuggestion(): Promise<IOmniboxSuggestion[]> {\n    const hash = this.getHash();\n    if (hash == null) {\n      return null;\n    }\n    const hashString = this.hashToString(hash);\n    if (this.cache[hashString] != null) {\n      return this.hashValueToSuggestion(hash, this.cache[hashString]);\n    }\n    let values: Promise<IOmniboxSuggestion[]>;\n    if (hash.type == 'FieldName') {\n      values = this.fieldNames(hash.current);\n    }\n    if (hash.type == 'FieldValue') {\n      values = this.fieldValues(hash.field, hash.current);\n    }\n    if (hash.type == 'SimpleFieldName') {\n      values = this.simpleFieldNames(hash.current);\n    }\n    this.cache[hashString] = values;\n    values.catch(() => {\n      delete this.cache[hashString];\n    });\n    return this.hashValueToSuggestion(hash, values);\n  }\n\n  private getHash(): IFieldAddonHash {\n    let fieldName: Result = _.last(this.omnibox.resultAtCursor('FieldName'));\n    if (fieldName != null) {\n      fieldName = fieldName.findParent('Field') || fieldName;\n      const currentField = fieldName.toString();\n      const before = fieldName.before();\n      const after = fieldName.after();\n      return { type: 'FieldName', current: currentField, before: before, after: after };\n    }\n    const fieldValue: Result = _.last(this.omnibox.resultAtCursor('FieldValue'));\n    if (fieldValue) {\n      const fieldQuery =\n        fieldValue.findParent('FieldQuery') || (this.omnibox.options.enableSimpleFieldAddon && fieldValue.findParent('FieldSimpleQuery'));\n      if (fieldQuery) {\n        let field = fieldQuery.find('FieldName').toString();\n        if (this.omnibox.options.fieldAlias) {\n          if (field in this.omnibox.options.fieldAlias) {\n            field = this.omnibox.options.fieldAlias[field];\n          }\n        }\n        const value = fieldValue.toString();\n        const before = fieldValue.before();\n        const after = fieldValue.after();\n        return { type: 'FieldValue', field: field, current: value, before: before, after: after };\n      }\n    }\n    if (this.omnibox.options.enableSimpleFieldAddon) {\n      const word: Result = _.last(this.omnibox.resultAtCursor('Word'));\n      if (word != null) {\n        const current = word.toString();\n        const before = word.before();\n        const after = word.after();\n        return { type: 'SimpleFieldName', current, before, after };\n      }\n    }\n  }\n\n  private hashToString(hash: IFieldAddonHash) {\n    if (hash == null) {\n      return null;\n    }\n    return hash.type + hash.current + (hash.field || '');\n  }\n\n  private hashValueToSuggestion(hash: IFieldAddonHash, promise: Promise<IOmniboxSuggestion[]>): Promise<IOmniboxSuggestion[]> {\n    return promise.then(values => {\n      const suggestions = _.map<any, IOmniboxSuggestion>(values, (value: string, i): IOmniboxSuggestion => {\n        const suggestion: IOmniboxSuggestion = {\n          text:\n            hash.before +\n            (hash.current.toLowerCase().indexOf(value.toLowerCase()) == 0 ? hash.current + value.substr(hash.current.length) : value) +\n            hash.after,\n          html: MagicBoxUtils.highlightText(value, hash.current, true),\n          index: FieldAddon.INDEX - i / values.length\n        };\n        return suggestion;\n      });\n      return suggestions;\n    });\n  }\n\n  private fields: Promise<IOmniboxSuggestion[]>;\n\n  private getFields(): Promise<IOmniboxSuggestion[]> {\n    if (this.fields == null) {\n      this.fields = new Promise<any[]>((resolve, reject) => {\n        if (this.omnibox.options.listOfFields != null) {\n          resolve(<string[]>this.omnibox.options.listOfFields);\n        } else {\n          const promise: Promise<IFieldDescription[] | IEndpointError> = this.omnibox.queryController.getEndpoint().listFields();\n          promise\n            .then((fieldDescriptions: IFieldDescription[]) => {\n              const fieldNames = _.chain(fieldDescriptions)\n                .filter((fieldDescription: IFieldDescription) => fieldDescription.includeInQuery && fieldDescription.groupByField)\n                .map((fieldDescription: IFieldDescription) => fieldDescription.name.substr(1))\n                .value();\n\n              resolve(fieldNames);\n            })\n            .catch(() => {\n              reject();\n            });\n        }\n      });\n    }\n    return this.fields;\n  }\n\n  private fieldNames(current: string): Promise<IOmniboxSuggestion[]> {\n    const withAt = current.length > 0 && current[0] == '@';\n    const fieldName = withAt ? current.substr(1) : current;\n    const fieldNameLC = fieldName.toLowerCase();\n\n    return this.getFields().then((fields: string[] | IOmniboxSuggestion[]): any[] => {\n      let matchFields = _.chain(fields)\n        .map((fieldName: any) => {\n          const fieldNameBeginsWithAt = fieldName.length > 0 && fieldName[0] == '@';\n          return {\n            index: fieldName.toLowerCase().indexOf(fieldNameLC),\n            field: fieldNameBeginsWithAt ? fieldName : '@' + fieldName\n          };\n        })\n        .filter(field => {\n          return field.index != -1 && field.field.length > current.length;\n        })\n        .sortBy('index')\n        .map(field => field.field)\n        .value();\n      matchFields = _.first(matchFields, 5);\n      return matchFields;\n    });\n  }\n\n  private fieldValues(field: string, current: string): Promise<any[]> {\n    return this.omnibox.queryController\n      .getEndpoint()\n      .listFieldValues({\n        pattern: '.*' + current + '.*',\n        patternType: 'RegularExpression',\n        sortCriteria: 'occurrences',\n        field: '@' + field,\n        maximumNumberOfValues: 5\n      })\n      .then(values => {\n        return _.chain(values)\n          .map(value => {\n            return {\n              index: value.value.toLowerCase().indexOf(current),\n              value: value.value\n            };\n          })\n          .filter(value => {\n            return value.value.length > current.length;\n          })\n          .sortBy('index')\n          .map(value => {\n            return value.value.replace(/ /g, '\\u00A0');\n          })\n          .value();\n      });\n  }\n\n  private simpleFieldNames(current: string): Promise<IOmniboxSuggestion[]> {\n    const fieldName = current;\n    const fieldNameLC = fieldName.toLowerCase();\n\n    return this.getFields().then((fields: any[]): IOmniboxSuggestion[] => {\n      let matchFields: any = _.chain(fields)\n        .map((field: string) => {\n          return {\n            index: field.toLowerCase().indexOf(fieldNameLC),\n            field: field + ':'\n          };\n        })\n        .filter(field => {\n          return field.index != -1 && field.field.length > current.length;\n        })\n        .sortBy('index')\n        .map(field => field.field)\n        .value();\n      matchFields = _.first(matchFields, 5);\n      return matchFields;\n    });\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Omnibox/FieldAddon.ts","///<reference path=\"Omnibox.ts\"/>\nimport { Omnibox, IOmniboxSuggestion } from './Omnibox';\nimport { IOmniboxDataRow } from './OmniboxInterface';\nimport {\n  OmniboxEvents,\n  IPopulateOmniboxEventArgs,\n  IPopulateOmniboxEventRow,\n  IPopulateOmniboxSuggestionsEventArgs\n} from '../../events/OmniboxEvents';\nimport { $$ } from '../../utils/Dom';\nimport { Utils } from '../../utils/Utils';\nimport * as _ from 'underscore';\n\nexport class OldOmniboxAddon {\n  constructor(public omnibox: Omnibox) {\n    this.omnibox.bind.on(this.omnibox.element, OmniboxEvents.populateOmniboxSuggestions, (args: IPopulateOmniboxSuggestionsEventArgs) => {\n      _.each(this.getSuggestion(), suggestion => {\n        args.suggestions.push(suggestion);\n      });\n    });\n  }\n\n  public getSuggestion(): Promise<IOmniboxSuggestion[]>[] {\n    const text = this.omnibox.magicBox.getText();\n\n    if (text.length == 0) {\n      return null;\n    }\n\n    const eventArgs = this.buildPopulateOmniboxEventArgs();\n    $$(this.omnibox.root).trigger(OmniboxEvents.populateOmnibox, eventArgs);\n\n    return this.rowsToSuggestions(eventArgs.rows);\n  }\n\n  private getCurrentQueryExpression() {\n    const cursorPos = this.omnibox.getCursor();\n    const value = this.omnibox.getText();\n    const length = value.length;\n    let start = cursorPos;\n    let end = cursorPos;\n    if (value[start] == ' ') {\n      start--;\n    }\n    while (start > 0 && value[start] != ' ') {\n      start--;\n    }\n    while (end < length && value[end] != ' ') {\n      end++;\n    }\n    return value.substring(start, end);\n  }\n\n  private getRegexToSearch(strValue?: string) {\n    if (strValue == null) {\n      strValue = this.omnibox.getText();\n    }\n    return new RegExp(Utils.escapeRegexCharacter(strValue), 'i');\n  }\n\n  private getQueryExpressionBreakDown() {\n    const ret = [];\n    const queryWords = this.omnibox.getText().split(' ');\n    _.each(queryWords, word => {\n      ret.push({\n        word: word,\n        regex: this.getRegexToSearch(word)\n      });\n    });\n    return ret;\n  }\n\n  private replace(searchValue: string, newValue: string) {\n    this.omnibox.setText(this.omnibox.getText().replace(searchValue, newValue));\n  }\n\n  private clearCurrentExpression() {\n    this.replace(this.getCurrentQueryExpression(), '');\n  }\n\n  private insertAt(at: number, toInsert: string) {\n    const oldValue = this.omnibox.getText();\n    const newValue = [oldValue.slice(0, at), toInsert, oldValue.slice(at)].join('');\n    this.omnibox.setText(newValue);\n  }\n\n  private replaceCurrentExpression(newValue: string) {\n    this.replace(this.getCurrentQueryExpression(), newValue);\n  }\n\n  private buildPopulateOmniboxEventArgs() {\n    const currentQueryExpression = this.getCurrentQueryExpression();\n    const ret: IPopulateOmniboxEventArgs = {\n      rows: [],\n      completeQueryExpression: {\n        word: this.omnibox.getText(),\n        regex: this.getRegexToSearch()\n      },\n      currentQueryExpression: {\n        word: currentQueryExpression,\n        regex: this.getRegexToSearch(currentQueryExpression)\n      },\n      allQueryExpressions: this.getQueryExpressionBreakDown(),\n      cursorPosition: this.omnibox.getCursor(),\n      clear: () => {\n        this.omnibox.clear();\n      },\n      clearCurrentExpression: () => {\n        this.clearCurrentExpression();\n      },\n      replace: (searchValue: string, newValue: string) => {\n        this.replace(searchValue, newValue);\n      },\n      replaceCurrentExpression: (newValue: string) => {\n        this.replaceCurrentExpression(newValue);\n      },\n      insertAt: (at: number, toInsert: string) => {\n        this.insertAt(at, toInsert);\n      },\n      closeOmnibox: () => {\n        this.omnibox.magicBox.blur();\n      }\n    };\n    return ret;\n  }\n\n  private rowsToSuggestions(rows: IOmniboxDataRow[]): Promise<IOmniboxSuggestion[]>[] {\n    return _.map(rows, (row: IPopulateOmniboxEventRow) => {\n      if (!Utils.isNullOrUndefined(row.element)) {\n        return new Promise<IOmniboxSuggestion[]>(resolve => {\n          resolve([\n            {\n              dom: row.element,\n              index: row.zIndex\n            }\n          ]);\n        });\n      } else if (!Utils.isNullOrUndefined(row.deferred)) {\n        return new Promise<IOmniboxSuggestion[]>(resolve => {\n          row.deferred.then(row => {\n            if (row.element != null) {\n              resolve([\n                {\n                  dom: row.element,\n                  index: row.zIndex\n                }\n              ]);\n            } else {\n              resolve(null);\n            }\n          });\n        });\n      }\n      return null;\n    });\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Omnibox/OldOmniboxAddon.ts","///<reference path='Omnibox.ts'/>\nimport { OmniboxEvents, IPopulateOmniboxSuggestionsEventArgs } from '../../events/OmniboxEvents';\nimport { Omnibox, IOmniboxSuggestion } from './Omnibox';\nimport { IExtension } from '../../rest/Extension';\nimport * as _ from 'underscore';\nimport { MagicBoxInstance } from '../../magicbox/MagicBox';\nimport { MagicBoxUtils } from '../../magicbox/MagicBoxUtils';\nimport { Result } from '../../magicbox/Result/Result';\n\ninterface IQueryExtensionAddonHash {\n  type: string;\n  before: string;\n  after: string;\n  current: string;\n  name?: string;\n  used?: string[];\n}\n\nexport class QueryExtensionAddon {\n  static INDEX = 62;\n\n  cache: { [hash: string]: Promise<string[]> } = {};\n\n  constructor(public omnibox: Omnibox) {\n    this.omnibox.bind.on(this.omnibox.element, OmniboxEvents.populateOmniboxSuggestions, (args: IPopulateOmniboxSuggestionsEventArgs) => {\n      args.suggestions.push(this.getSuggestion());\n    });\n  }\n\n  public getSuggestion(): Promise<IOmniboxSuggestion[]> {\n    var hash = this.getHash(this.omnibox.magicBox);\n    if (hash == null) {\n      return null;\n    }\n    var hashString = this.hashToString(hash);\n    if (this.cache[hashString] != null) {\n      return this.hashValueToSuggestion(hash, this.cache[hashString]);\n    }\n    var values = hash.type == 'QueryExtensionName' ? this.names(hash.current) : this.attributeNames(hash.name, hash.current, hash.used);\n    this.cache[hashString] = values;\n    values.catch(() => {\n      delete this.cache[hashString];\n    });\n    return this.hashValueToSuggestion(hash, values);\n  }\n\n  private getHash(magicBox: MagicBoxInstance): IQueryExtensionAddonHash {\n    var queryExtension: Result = _.last(magicBox.resultAtCursor('QueryExtension'));\n    if (queryExtension != null) {\n      var queryExtensionArgumentResults = queryExtension.findAll('QueryExtensionArgument');\n      var current = _.last(magicBox.resultAtCursor('QueryExtensionName'));\n      if (current != null) {\n        return {\n          type: 'QueryExtensionName',\n          current: current.toString(),\n          before: current.before(),\n          after: current.after()\n        };\n      }\n\n      current = _.last(magicBox.resultAtCursor('QueryExtensionArgumentName'));\n      if (current != null) {\n        var used: string[] = _.chain(queryExtensionArgumentResults)\n          .map(result => {\n            var name = result.find('QueryExtensionArgumentName');\n            return name && name.toString();\n          })\n          .compact()\n          .value();\n\n        var name = queryExtension.find('QueryExtensionName').toString();\n\n        return {\n          type: 'QueryExtensionArgumentName',\n          current: current.toString(),\n          before: current.before(),\n          after: current.after(),\n          name: name,\n          used: used\n        };\n      }\n    }\n    return null;\n  }\n\n  private hashToString(hash: IQueryExtensionAddonHash) {\n    if (hash == null) {\n      return null;\n    }\n    return [hash.type, hash.current, hash.name || '', hash.used ? hash.used.join() : ''].join();\n  }\n\n  private hashValueToSuggestion(hash: IQueryExtensionAddonHash, promise: Promise<string[]>): Promise<IOmniboxSuggestion[]> {\n    return promise.then(values => {\n      var suggestions: IOmniboxSuggestion[] = _.map(values, (value, i) => {\n        return {\n          html: MagicBoxUtils.highlightText(value, hash.current, true),\n          text: hash.before + value + hash.after,\n          index: QueryExtensionAddon.INDEX - i / values.length\n        };\n      });\n      return suggestions;\n    });\n  }\n\n  private extensions: Promise<any>;\n\n  private getExtensions() {\n    if (this.extensions == null) {\n      this.extensions = this.omnibox.queryController.getEndpoint().extensions();\n    }\n    return this.extensions;\n  }\n\n  private names(current: string): Promise<string[]> {\n    var extensionName = current.toLowerCase();\n    return this.getExtensions().then((extensions: IExtension[]) => {\n      var matchExtensions = _.chain(extensions)\n        .map((extension: IExtension) => {\n          return {\n            index: extension.name.toLowerCase().indexOf(extensionName),\n            extension: extension.name\n          };\n        })\n        .filter(extension => {\n          return extension.index != -1 && extension.extension.length > extensionName.length;\n        })\n        .sortBy('index')\n        .pluck('extension')\n        .value();\n      matchExtensions = _.first(matchExtensions, 5);\n      return matchExtensions;\n    });\n  }\n\n  private attributeNames(name: string, current: string, used: string[]): Promise<string[]> {\n    return this.getExtensions().then((extensions: IExtension[]) => {\n      var extension = _.find(extensions, (extension: IExtension) => extension.name == name);\n      if (extension == null) {\n        return [];\n      } else {\n        return _.filter(_.difference(extension.argumentNames, used), (argumentName: string) => argumentName.indexOf(current) == 0);\n      }\n    });\n  }\n\n  public hash() {\n    return;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Omnibox/QueryExtensionAddon.ts","///<reference path=\"Omnibox.ts\"/>\nimport { Omnibox, IOmniboxSuggestion } from './Omnibox';\nimport { $$, Dom } from '../../utils/Dom';\nimport { IQuerySuggestCompletion, IQuerySuggestRequest, IQuerySuggestResponse } from '../../rest/QuerySuggest';\nimport { ComponentOptionsModel } from '../../models/ComponentOptionsModel';\nimport {\n  OmniboxEvents,\n  IPopulateOmniboxSuggestionsEventArgs,\n  IBuildingQuerySuggestArgs,\n  IQuerySuggestSuccessArgs\n} from '../../events/OmniboxEvents';\nimport { StringUtils } from '../../utils/StringUtils';\nimport { map, every, last, indexOf, find } from 'underscore';\nimport { QUERY_STATE_ATTRIBUTES } from '../../models/QueryStateModel';\nimport { Utils } from '../../utils/Utils';\nimport { buildHistoryStore } from '../../utils/HistoryStore';\nimport { AnalyticsInformation } from '../Analytics/AnalyticsInformation';\n\nexport interface IQuerySuggestAddon {\n  getSuggestion(): Promise<IOmniboxSuggestion[]>;\n}\n\nexport class QuerySuggestAddon implements IQuerySuggestAddon {\n  static INDEX = 60;\n\n  private static suggestiontHtml(suggestion: IQuerySuggestCompletion) {\n    return suggestion.highlighted.replace(/\\[(.*?)\\]|\\{(.*?)\\}|\\((.*?)\\)/g, (part, notMatched, matched, corrected) => {\n      var className = '';\n      if (matched) {\n        className = 'coveo-omnibox-hightlight';\n      }\n      if (corrected) {\n        className = 'coveo-omnibox-hightlight2';\n      }\n\n      let ret: Dom;\n      if (className) {\n        ret = $$('span', {\n          className: className\n        });\n      } else {\n        ret = $$('span');\n      }\n      ret.text(notMatched || matched || corrected);\n      return ret.el.outerHTML;\n    });\n  }\n\n  private static isPartialMatch(suggestion: IQuerySuggestCompletion) {\n    // groups : 1=notMatched, 2=matched, 3=corrected\n    var parts = StringUtils.match(suggestion.highlighted, /\\[(.*?)\\]|\\{(.*?)\\}|\\((.*?)\\)/g);\n    var firstFail = find(parts, (part: string[]) => part[1] != null);\n    // if no fail found, this is a partial or a full match\n    if (firstFail == null) {\n      return true;\n    }\n    // if all right parts are notMatched, the right parts is autocomplete\n    return every(last(parts, indexOf(parts, firstFail) - parts.length), (part: string[]) => part[1] != null);\n  }\n\n  constructor(public omnibox: Omnibox) {\n    $$(this.omnibox.element).on(OmniboxEvents.populateOmniboxSuggestions, (e: Event, args: IPopulateOmniboxSuggestionsEventArgs) => {\n      args.suggestions.push(this.getSuggestion());\n    });\n  }\n\n  public getSuggestion(): Promise<IOmniboxSuggestion[]> {\n    const text = this.omnibox.magicBox.getText();\n\n    if (text.length >= this.omnibox.options.querySuggestCharacterThreshold) {\n      return this.getQuerySuggest(text);\n    }\n    return Promise.resolve([]);\n  }\n\n  private async getQuerySuggest(text: string): Promise<IOmniboxSuggestion[]> {\n    const payload: IQuerySuggestRequest = {\n      q: text,\n      locale: this.locale,\n      searchHub: this.searchHub,\n      pipeline: this.pipeline,\n      enableWordCompletion: this.enableWordCompletion,\n      context: this.context,\n      count: this.count,\n      tab: this.tab,\n      referrer: document.referrer,\n      actionsHistory: this.actionsHistory,\n      timezone: this.timezone,\n      visitorId: this.visitorId,\n      isGuestUser: this.isGuestUser\n    };\n\n    $$(this.omnibox.getBindings().searchInterface.element).trigger(OmniboxEvents.buildingQuerySuggest, <IBuildingQuerySuggestArgs>{\n      payload\n    });\n\n    let results: IQuerySuggestResponse;\n    try {\n      results = await this.omnibox.queryController.getEndpoint().getQuerySuggest(payload);\n    } catch {\n      return [];\n    }\n    const completions = results.completions;\n\n    $$(this.omnibox.getBindings().searchInterface.element).trigger(OmniboxEvents.querySuggestSuccess, <IQuerySuggestSuccessArgs>{\n      completions\n    });\n\n    return map(completions, (completion, i) => {\n      return {\n        html: QuerySuggestAddon.suggestiontHtml(completion),\n        text: completion.expression,\n        index: QuerySuggestAddon.INDEX - i / completions.length,\n        partial: QuerySuggestAddon.isPartialMatch(completion),\n        executableConfidence: completion.executableConfidence\n      };\n    });\n  }\n\n  private get tab() {\n    const tab = this.omnibox.getBindings().queryStateModel.get(QUERY_STATE_ATTRIBUTES.T) as string;\n\n    if (Utils.isNonEmptyString(tab)) {\n      return tab;\n    }\n\n    return undefined;\n  }\n\n  private get locale() {\n    return String['locale'];\n  }\n\n  private get searchHub() {\n    return this.omnibox.getBindings().componentOptionsModel.get(ComponentOptionsModel.attributesEnum.searchHub);\n  }\n\n  private get pipeline() {\n    return this.omnibox.getBindings().searchInterface.options.pipeline;\n  }\n\n  private get enableWordCompletion() {\n    return this.omnibox.options.enableSearchAsYouType;\n  }\n\n  private get context() {\n    return this.omnibox.getBindings().searchInterface.getQueryContext();\n  }\n\n  private get count() {\n    return this.omnibox.options.numberOfSuggestions;\n  }\n\n  private get actionsHistory() {\n    const historyStore = buildHistoryStore();\n    const historyFromStore = historyStore.getHistory();\n    if (historyFromStore == null) {\n      return [];\n    }\n    return historyFromStore;\n  }\n\n  private get timezone() {\n    return this.omnibox.getBindings().searchInterface.options.timezone;\n  }\n\n  private get visitorId() {\n    return new AnalyticsInformation().clientId;\n  }\n\n  private get isGuestUser() {\n    return this.omnibox.getBindings().queryController.getEndpoint().options.isGuestUser;\n  }\n}\n\nexport class VoidQuerySuggestAddon implements IQuerySuggestAddon {\n  getSuggestion(): Promise<IOmniboxSuggestion[]> {\n    return Promise.resolve([]);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/ui/Omnibox/QuerySuggestAddon.ts","import { $$ } from './Dom';\n\nexport class SearchBoxResize {\n  public static resize(element: HTMLElement, size: number) {\n    const searchbox = this.getSearchbox(element);\n    const elementToResize: HTMLElement[] = this.getElementsToResize(element);\n    const magicboxInput: HTMLElement = this.getInput(element);\n\n    const searchboxStyle = `height: ${size}px; line-height: ${size}px;`;\n    const inputChangeStyle = `height: ${size}px`;\n\n    //This need to be a little bit smaller because when the height become smaller than 38px or to big, the bottom border of the Searchbox dissapear\n    const magicboxInputStyle = `height: ${size - 2}px;`;\n\n    this.applyStyle(searchbox, searchboxStyle);\n    this.applyStyle(magicboxInput, magicboxInputStyle);\n\n    elementToResize.forEach(HtmlElement => {\n      this.applyStyle(HtmlElement, inputChangeStyle);\n    });\n  }\n\n  private static applyStyle(element: HTMLElement, style: string) {\n    element.style.cssText += style;\n  }\n\n  private static getSearchbox(element: HTMLElement): HTMLElement {\n    return $$(element).find('.CoveoOmnibox') || $$(element).find('.CoveoQuerybox');\n  }\n\n  private static getElementsToResize(element: HTMLElement): HTMLElement[] {\n    return [\n      $$(element).find('.CoveoSearchButton'),\n      $$($$(element).find('.magic-box-input')).find('input'),\n      $$(element).find('.magic-box-icon'),\n      $$(element).find('.magic-box-clear'),\n      $$(element).find('.magic-box-underlay')\n    ];\n  }\n\n  private static getInput(element: HTMLElement): HTMLElement {\n    return $$(element).find('.magic-box-input');\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/utils/SearchBoxResize.ts"],"sourceRoot":""}