{"version":3,"sources":["webpack://TylerComponentsWeb.[name]/webpack/universalModuleDefinition","webpack://TylerComponentsWeb.[name]/webpack/bootstrap","webpack://TylerComponentsWeb.[name]/./dist/esm5/a11y/a11y.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/constants/date-constants.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/utils.js","webpack://TylerComponentsWeb.[name]/./node_modules/shadow-utils/esm5/core/shadow-utils.js","webpack://TylerComponentsWeb.[name]/./node_modules/shadow-utils/esm5/core/dom-helper.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/dom-utils.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/custom-elements/component-utils.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/custom-elements/decorators/custom-element.js","webpack://TylerComponentsWeb.[name]/./node_modules/tslib/tslib.es6.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/custom-elements/decorators/foundation-property.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/events/event-aware.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/scroll/scroll-types.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/message-list/message-list-entry.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/message-list/message-list.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/scroll/scroll-axis-observer.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/services/service-adapter.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/clipboard.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/event-utils.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/http-utils.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/object-utils.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/item-manager.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/platform.js","webpack://TylerComponentsWeb.[name]/./dist/esm5/utils/string-utils.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","hideElementVisually","element","style","border","clip","height","margin","overflow","padding","position","width","outline","setProperty","DATE_CONSTANTS","days","daysLong","months","monthsLong","isDefined","obj","isString","isBoolean","isNumber","isDate","Date","isValidDate","isNaN","getTime","isFunction","isArray","Array","isObject","coerceBoolean","coerceNumber","debounce","func","wait","immediate","context","args","result","timeout","timestamp","later","last","now","setTimeout","apply","this","arguments","callNow","throttle","options","leading","remaining","clearTimeout","trailing","nameof","fn","fnString","toString","match","exec","Error","deepQuerySelectorAll","rootElement","selectors","checkRootElement","nodes","replace","split","el","nodeType","Node","ELEMENT_NODE","matchesFn","Element","matches","msMatchesSelector","webkitMatchesSelector","some","selector","indexOf","push","tagName","assignedNodes","forEach","slottedNode","concat","node","shadowRoot","firstElementChild","nextElementSibling","SCROLLBAR_WIDTH","REGULAR_EXPRESSIONS","placement","auto","primary","secondary","topBottom","_ownerDocument","ownerDocument","document","getElement","allowNull","querySelector","isElement","isPositionStatic","getComputedStyle","parseStyle","length","parsedValue","parseFloat","isFinite","parsePlacement","test","placements","elementIndex","parentElement","from","children","elementParents","untilElement","parentElements","body","parentNode","host","offsetParent","offsetParentElem","documentElement","scrollbarWidth","elem","createElement","top","left","appendChild","offsetWidth","clientWidth","removeElement","isScrollable","elemStyle","overflowY","overflowX","scrollParent","includeSelf","docElem","excludeStatic","scrollParentElem","scrollParentStyle","isScrollbarVisible","x","scrollWidth","y","scrollHeight","clientHeight","offset","elemBCR","getBoundingClientRect","win","defaultView","offsetValues","bottom","right","parentBCR","pageYOffset","pageXOffset","Math","round","viewportOffset","parentElementOffset","parentStyle","borderTopWidth","borderLeftWidth","offsetHeight","isElementInViewport","scrollParentOffset","positionElement","targetElement","hostElement","elemPlacement","hostElem","targetElemOffset","hostElemOffset","elemSize","abs","marginLeft","marginRight","marginTop","marginBottom","xOverflow","yOverflow","centerXOverflow","centerYOverflow","adjustedRect","scrollTop","scrollLeft","elemPosition","class","notChildEventListener","callback","delay","evtHandler","event","handle","stopPropagation","cancelable","preventDefault","activeElement","type","target","contains","requestAnimationFrame","addEventListener","removeEventListener","removeAllChildren","lastChild","removeChild","replaceElement","newChild","oldChild","replaceChild","addClass","classList","add","removeClass","remove","getAnimationEvent","animations","playKeyframeAnimation","className","animationEvent","animationCompletedListener","safeCssWidth","slice","Number","calcSizeUnattached","container","visibility","cloneNode","size","ensureChildren","Promise","resolve","observer","MutationObserver","changes","disconnect","observe","childList","ensureChild","initialElements","reduce","prev","curr","addedNodes","foundElements","subtree","walkUpUntil","matcher","parent","calculateFontWidth","info","ctx","getContext","fontSize","fontFamily","font","measureText","generateTextShadow","iterations","color","shadows","join","defineCustomElement","component","tryDefine","defineCustomElements","components","ctor","customElements","upgradeProperty","instance","requireParent","parentTagName","toLowerCase","parseTemplateString","template","createTemplateContent","DOMParser","parseFromString","attachLightTemplate","componentInstance","content","attachShadowTemplate","elementName","styles","delegatesFocus","templateElement","prepareShadowTemplate","attachShadow","setShadowTemplate","replaceShadowTemplate","styleElement","textContent","ShadyCSS","nativeShadow","prepareTemplate","polyfillShadowStyles","child","createDocumentFragment","firstChild","provideDocumentStyles","fromDocument","documentStyleSheets","shadowStyleSheet","sheet","sheetName","sheetFilter","selectorFilter","matchingStyleSheet","styleSheetList","prop","href","RegExp","styleSheets","startIndex","cssRules","rule","cssText","selectorText","insertRule","getShadowElement","getLightElement","emitEvent","data","bubble","evt","CustomEvent","detail","bubbles","createEvent","initCustomEvent","dispatchEvent","toggleElementPlaceholder","isVisible","placeholder","exists","createComment","getClosestShadowRoot","current","closestElement","startElement","__closestFrom","assignedSlot","closest","getRootNode","CUSTOM_ELEMENT_NAME_PROPERTY","CUSTOM_ELEMENT_DEPENDENCIES_PROPERTY","CustomElement","config","originalConnectedCallback","connectedCallback","isConnected","_isInitialized","initializedCallback","dependencies","extendStatics","b","setPrototypeOf","__proto__","__assign","assign","FoundationPropertyOptions","set","runIfVerified","propertyName","action","_foundation","localName","FoundationProperty","allOptions","descriptor","defaultGet","defaultSet","foundationPropertyName","configurable","wireDescriptorSet","attributes","desc","getOwnPropertyDescriptor","Reflect","wireDescriptorGet","get_1","that","attrs","setter","set_1","setFoundation","getFoundation","wireAction","ScrollDirection","ScrollEvents","EventAware","_listenerMap","Map","_emit","listeners","cb","hasListeners","has","addListener","listener","removeListener","includes","splice","delete","MessageListEntry","message","identifier","originalMessage","MessageList","useAutoEllipsis","_useAutoEllipsis","reset","_updateMessage","_messages","index","_getMessageIndex","update","hasMessage","_this","item","hasEllipsis","substr","ServiceRequestMethod","_super","ScrollAxisObserver","_element","_config","_axis","_scrollThreshold","_lastScrollPosition","_lastScrollTop","_lastScrollLeft","_isListening","_initialize","__","constructor","destroy","stop","start","_scrollListener","throttleTime","_onScroll","paused","axis","scrollThreshold","_isScrollAxis","isVertical","isHorizontal","scrollPosition","direction","Down","Right","Up","Left","Scroll","Scrolled","scrollStart","scrollEnd","scrollSize","ScrolledStart","ScrolledEnd","elementSize","setScrollPosition","copyToClipboard","text","textarea","yPosition","setAttribute","select","setSelectionRange","copySuccessful","execCommand","getEventPath","path","composedPath","createQueryString","params","encodeURIComponent","getPropertyValue","inPath","ary","findWhere","predicate","find","matchesPredicate","findIndexWhere","findIndex","createPredicate","_i","key_1","keys","every","listenOwnProperty","propObj","getPrototypeOf","originalValueDescriptor","ItemManager","_key","_items","getItems","count","setKey","_getItem","clear","hasV8BreakIterator","Intl","v8BreakIterator","Platform","isBrowser","navigator","userAgent","chrome","CSS","EDGE","TRIDENT","BLINK","MSStream","SAFARI","WEBKIT","dashify","padLeft","char","padRight"],"mappings":"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","file":"tyler-components-web-core.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"core\"] = factory();\n\telse\n\t\troot[\"TylerComponentsWeb\"] = root[\"TylerComponentsWeb\"] || {}, root[\"TylerComponentsWeb\"][\"core\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/Users/kieran/Development/GitHub/tyler-technologies/tyler-components-web-core/dist/dist\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n","/**\n * Hides an element from the user visually, while keeping it in the DOM.\n * @param element The element to hide from view.\n */\nexport function hideElementVisually(element) {\n    element.style.border = '0';\n    element.style.clip = 'rect(0 0 0 0)';\n    element.style.height = '1px';\n    element.style.margin = '-1px';\n    element.style.overflow = 'hidden';\n    element.style.padding = '0';\n    element.style.position = 'absolute';\n    element.style.width = '1px';\n    element.style.outline = '0';\n    element.style.setProperty('-webkit-appearance', 'none');\n    element.style.setProperty('-moz-appearance', 'none');\n}\n","var days = [\n    'Su',\n    'Mo',\n    'Tu',\n    'We',\n    'Th',\n    'Fr',\n    'Sa'\n];\nvar daysLong = [\n    'Sunday',\n    'Monday',\n    'Tuesday',\n    'Wedensday',\n    'Thursday',\n    'Friday',\n    'Saturday'\n];\nvar months = [\n    'Jan',\n    'Feb',\n    'Mar',\n    'Apr',\n    'May',\n    'Jun',\n    'Jul',\n    'Aug',\n    'Sep',\n    'Oct',\n    'Nov',\n    'Dec'\n];\nvar monthsLong = [\n    'January',\n    'February',\n    'March',\n    'April',\n    'May',\n    'June',\n    'July',\n    'August',\n    'September',\n    'October',\n    'November',\n    'December'\n];\nexport var DATE_CONSTANTS = {\n    days: days,\n    daysLong: daysLong,\n    months: months,\n    monthsLong: monthsLong\n};\n","// https://stackoverflow.com/questions/899574/which-is-best-to-use-typeof-or-instanceof\n/**\n * Checks if an object is undefined or null.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isDefined(obj) {\n    return typeof obj !== 'undefined' && obj !== null;\n}\n/**\n * Checks if an object is a string.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isString(obj) {\n    return typeof obj === 'string';\n}\n/**\n * Checks if an object is a boolean.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isBoolean(obj) {\n    return typeof obj === 'boolean';\n}\n/**\n * Checks if an object is a number.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isNumber(obj) {\n    return typeof obj === 'number';\n}\n/**\n * Checks if an object is a date.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isDate(obj) {\n    return obj instanceof Date;\n}\n/**\n * Checks if an object is a date and is a valid date.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isValidDate(obj) {\n    if (!isDate(obj)) {\n        return false;\n    }\n    return !isNaN(obj.getTime());\n}\n/**\n * Checks if an object is a function.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isFunction(obj) {\n    return typeof obj === 'function';\n}\n/**\n * Checks if an object is an array.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isArray(obj) {\n    return obj instanceof Array;\n}\n/**\n * Checks if an object is an object.\n * @param {object} obj The object to test.\n * @returns {boolean}\n */\nexport function isObject(obj) {\n    return obj instanceof Object;\n}\n/**\n * Coerces a string to a boolean.\n * @param {string} value The value to convert.\n * @returns {boolean}\n */\nexport function coerceBoolean(value) {\n    return value != null && '' + value !== 'false';\n}\n/**\n * Coerces a string to a number.\n * @param {string} value The value to convert.\n * @returns {number}\n */\nexport function coerceNumber(value) {\n    return +value;\n}\n/**\n * Debounce method.\n * @param {function} func The function to call.\n * @param {number} wait The amount of time (milliseconds) to wait.\n * @param {boolean} [immediate=false] Should the callback be executed once immeadiately.\n */\nexport function debounce(func, wait, immediate) {\n    if (immediate === void 0) { immediate = false; }\n    var context;\n    var args;\n    var result;\n    var timeout;\n    var timestamp = 0;\n    var later = function () {\n        var last = Date.now() - timestamp;\n        if (last < wait && last >= 0) {\n            timeout = setTimeout(later, wait - last);\n        }\n        else {\n            timeout = null;\n            if (!immediate) {\n                result = func.apply(context, args);\n                if (!timeout) {\n                    context = args = null;\n                }\n            }\n        }\n    };\n    return function () {\n        context = this;\n        args = arguments;\n        timestamp = Date.now();\n        var callNow = immediate && !timeout;\n        if (!timeout) {\n            timeout = setTimeout(later, wait);\n        }\n        if (callNow) {\n            result = func.apply(context, args);\n            context = args = null;\n        }\n        return result;\n    };\n}\n/**\n * Throttle method.\n * @param {function} func The function to call.\n * @param {number} wait The amount of time (milliseconds) to wait.\n * @param {object=} options An options object with the following properties\n *   <ul>\n *     <li>**leading**: Should the callback be executed once immeadiately.</li>\n *     <li>**trailing**: Should the callback be executed once after the throttle completes.</li>\n *   </ul>\n */\nexport function throttle(func, wait, options) {\n    var context;\n    var args;\n    var result;\n    var timeout;\n    var timestamp = 0;\n    options = options || {};\n    var later = function () {\n        timestamp = options.leading === false ? 0 : Date.now();\n        timeout = null;\n        result = func.apply(context, args);\n        if (!timeout) {\n            context = args = null;\n        }\n    };\n    return function () {\n        var now = Date.now();\n        if (!timestamp && options.leading === false) {\n            timestamp = now;\n        }\n        var remaining = wait - (now - timestamp);\n        context = this;\n        args = arguments;\n        if (remaining <= 0 || remaining > wait) {\n            if (timeout) {\n                clearTimeout(timeout);\n                timeout = null;\n            }\n            timestamp = now;\n            result = func.apply(context, args);\n            if (!timeout) {\n                context = args = null;\n            }\n        }\n        else if (!timeout && options.trailing !== false) {\n            timeout = setTimeout(later, remaining);\n        }\n        return result;\n    };\n}\n/**\n * A minification-safe nameof function for retrieving the name of a property or method at runtime.\n * Note: this function only works with properties/methods on an object. To get the name of a variable,\n *       you will need to wrap it within an object.\n * @param {Function} fn A function the returns a property or method that will be stringified.\n */\nexport function nameof(fn) {\n    var fnString = fn.toString();\n    // fnString should look something like: function () { return _this.canActivate; }\n    // When minified fnString will look something like: function(){return a.canActivate}\n    var nameofRegExp = /[^.]\\.([^;}\\s]+)(?:[;}\\s])/; // Get everything after first dot and before the end of the statement\n    var match = nameofRegExp.exec(fnString);\n    if (!match) {\n        throw new Error(\"Could not parse nameof string: \" + fnString);\n    }\n    return match[1];\n}\n","import { matchesSelectors } from './dom-helper';\n/**\n * Walks the DOM tree starting at a root element and checks if any of its children\n * match the provided selectors. Similar to the native `querySelectorAll` except\n * that it will traverse the shadow DOM as well as slotted nodes.\n * @param {Element} rootElement The element to start querying from.\n * @param {string[]} selectors An array of CSS selectors.\n * @param {boolean} [checkRootElement] True if the provided root element is to be matched against the selectors.\n */\nexport function deepQuerySelectorAll(rootElement, selectors, checkRootElement) {\n    if (checkRootElement === void 0) { checkRootElement = false; }\n    var nodes = [];\n    if (!rootElement) {\n        return nodes;\n    }\n    if (typeof selectors === 'string') {\n        selectors = selectors.replace(/\\s+/, '').split(',');\n    }\n    if (checkRootElement && matchesSelectors(rootElement, selectors) && nodes.indexOf(rootElement) === -1) {\n        nodes.push(rootElement);\n    }\n    if (rootElement.tagName === 'SLOT') {\n        var slotNodes = rootElement.assignedNodes();\n        slotNodes.forEach(function (slottedNode) { return nodes = nodes.concat(deepQuerySelectorAll(slottedNode, selectors, true)); });\n    }\n    else {\n        var node = rootElement.shadowRoot ? rootElement.shadowRoot.firstElementChild : rootElement.firstElementChild;\n        while (node) {\n            nodes = nodes.concat(deepQuerySelectorAll(node, selectors, true));\n            node = node.nextElementSibling;\n        }\n    }\n    return nodes;\n}\n/**\n * Gets the currently focused element within the document by also traversing shadow roots.\n * @returns {Element}\n */\nexport function getActiveElement() {\n    var activeElement = document.activeElement;\n    if (!activeElement || activeElement === document.body) {\n        return activeElement;\n    }\n    return getActiveShadowElement(activeElement);\n}\n/**\n * Gets the active element within the provided elements shadow root. If the element\n * does not have a shadow root, the provided element is returned.\n * @param {Element} element The active element.\n */\nexport function getActiveShadowElement(element) {\n    if (element.shadowRoot && element.shadowRoot.activeElement) {\n        element = getActiveShadowElement(element.shadowRoot.activeElement);\n    }\n    return element;\n}\n\n//# sourceMappingURL=shadow-utils.js.map\n","/**\n * Checks if an element matches any of the provided selectors.\n * @param {Element} el The element to match.\n * @param {string[]} selectors The selectors to check the element against.\n */\nexport function matchesSelectors(el, selectors) {\n    if (el.nodeType !== Node.ELEMENT_NODE) {\n        return false;\n    }\n    if (typeof selectors === 'string') {\n        selectors = selectors.replace(/\\s+/, '').split(',');\n    }\n    var matchesFn = Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;\n    return selectors.some(function (selector) { return matchesFn.call(el, selector); });\n}\n\n//# sourceMappingURL=dom-helper.js.map\n","import { deepQuerySelectorAll } from 'shadow-utils';\nimport { isArray } from './utils';\n/**\n * Holds regular expressions\n */\n/* tslint:disable-next-line:require-private-underscore */\nvar REGULAR_EXPRESSIONS = {\n    placement: {\n        auto: /\\s?auto?\\s?/i,\n        primary: /^(top|bottom|left|right)$/,\n        secondary: /^(top|bottom|left|right|center)$/,\n        topBottom: /^(top|bottom)$/\n    },\n    overflow: /(auto|scroll)/\n};\n/**\n * Holds the browser scrollbar width.\n */\n/* tslint:disable-next-line:require-private-underscore */\nvar SCROLLBAR_WIDTH;\n/**\n * Gets the ownerDocument for an element, if null, than returns the document element.\n * @param {Element} element The element to get the ownerDocument for\n * @returns {Document}\n */\nfunction _ownerDocument(element) {\n    return element.ownerDocument || document;\n}\n/**\n * Retrieves an element based on the provided root and selector.\n * @param {Element} root The root element to search within.\n * @param {string} selector The selector for the child element.\n * @param {boolean} [allowNull=false] Should the method allow the element to be not found? Default is false.\n * @returns {HTMLElement}\n */\nexport function getElement(root, selector, allowNull) {\n    if (allowNull === void 0) { allowNull = false; }\n    var element = root.querySelector(selector);\n    if (!element && !allowNull) {\n        throw new Error(\"Element not found with selector: \" + selector);\n    }\n    return element;\n}\n/**\n * Checks if an element is a valid element.\n * @param {Element} element The node to test\n * @returns {boolean}\n */\nexport function isElement(element) {\n    return element && element.nodeType === 1;\n}\n/**\n * Checks if an element is statically positioned.\n * @param {Element} element The node to test.\n * @returns {boolean}\n */\nexport function isPositionStatic(element) {\n    return (window.getComputedStyle(element).position || 'static') === 'static';\n}\n/**\n * Parses a style string to a numeric value (removes 'px').\n * @param {string} value The style string to parse.\n * @returns {number}\n */\nexport function parseStyle(value) {\n    if (!value || !value.length) {\n        return 0;\n    }\n    var parsedValue = parseFloat(value);\n    return isFinite(parsedValue) ? parsedValue : 0;\n}\n/**\n * Parses a string into a placemnt object.\n * @param {string} placement The placement string.\n * @returns {IElementPlacement}\n */\nexport function parsePlacement(placement) {\n    var auto = REGULAR_EXPRESSIONS.placement.auto.test(placement);\n    if (auto) {\n        placement = placement.replace(REGULAR_EXPRESSIONS.placement.auto, '');\n    }\n    var placements = placement.split('-');\n    placements[0] = placements[0] || 'bottom';\n    if (!REGULAR_EXPRESSIONS.placement.primary.test(placements[0])) {\n        placements[0] = 'bottom';\n    }\n    placements[1] = placements[1] || 'center';\n    if (!REGULAR_EXPRESSIONS.placement.secondary.test(placements[1])) {\n        placements[1] = 'center';\n    }\n    return {\n        primary: placements[0],\n        secondary: placements[1],\n        auto: auto\n    };\n}\n/**\n * Gets the index of an element in the parent element children.\n * @param {Element} element The element to get the index on.\n * @returns {number}\n */\nexport function elementIndex(element) {\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - elementIndex: invalid element argument');\n    }\n    if (!element.parentElement) {\n        return -1;\n    }\n    return Array.from(element.parentElement.children).indexOf(element);\n}\n/**\n * Gets an array of parent elements up to the body element.\n * @param {Element} element The element to get the parents of.\n * @param {Element=} untilElement Optional element where traversal should stop.\n * @returns {Array}\n */\nexport function elementParents(element, untilElement) {\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - elementParents: invalid element argument');\n    }\n    var parentElements = [];\n    while (element.parentElement) {\n        parentElements.push(element.parentElement);\n        if (element.parentElement === untilElement || element.parentElement === _ownerDocument(element).body) {\n            break;\n        }\n        // pierce shadow DOM\n        if (element.parentElement && element.parentElement.parentNode && element.parentElement.parentNode.nodeType === 11) {\n            element = element.parentElement.parentNode.host;\n        }\n        else {\n            element = element.parentElement;\n        }\n    }\n    return parentElements;\n}\n/**\n * Gets the non-statically positioned parent of an element.\n * @param element The element to get the offset parent of.\n * @returns {Element}\n */\nexport function offsetParent(element) {\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - offsetParent: invalid element argument');\n    }\n    var offsetParentElem = element.offsetParent;\n    while (offsetParentElem && isPositionStatic(offsetParentElem)) {\n        offsetParentElem = offsetParentElem.offsetParent;\n    }\n    return offsetParentElem || _ownerDocument(element).documentElement;\n}\n/**\n * Gets the browser scrollbar width.\n * @returns {number}\n */\nexport function scrollbarWidth() {\n    if (SCROLLBAR_WIDTH === undefined) {\n        var elem = document.createElement('div');\n        elem.style.position = 'absolute';\n        elem.style.top = '-100px';\n        elem.style.left = '-100px';\n        elem.style.width = '50px';\n        elem.style.height = '50px';\n        elem.style.overflow = 'scroll';\n        document.body.appendChild(elem);\n        var width = elem.offsetWidth - elem.clientWidth;\n        removeElement(elem);\n        SCROLLBAR_WIDTH = isFinite(width) ? width : 0;\n    }\n    return SCROLLBAR_WIDTH;\n}\n/**\n * Checks if an element is scrollable.\n * @param {Element} element The element to test for scrollability\n * @returns {boolean}\n */\nexport function isScrollable(element) {\n    var elemStyle = window.getComputedStyle(element);\n    return REGULAR_EXPRESSIONS.overflow.test('' + elemStyle.overflow + elemStyle.overflowY + elemStyle.overflowX);\n}\n/**\n * Gets the scroll parent of an element.\n * @param {Element} element The element to get the scroll parent of.\n * @param {boolean} [includeSelf=false] Should the element be checked for scrollability.\n * @returns {Element}\n */\nexport function scrollParent(element, includeSelf) {\n    if (includeSelf === void 0) { includeSelf = false; }\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - scrollParent: invalid element argument');\n    }\n    var docElem = _ownerDocument(element).documentElement;\n    var elemStyle = window.getComputedStyle(element);\n    if (includeSelf && REGULAR_EXPRESSIONS.overflow.test('' + elemStyle.overflow + elemStyle.overflowY + elemStyle.overflowX)) {\n        return element;\n    }\n    var excludeStatic = elemStyle.position === 'absolute';\n    var scrollParentElem = element.parentElement || docElem;\n    if (scrollParentElem === docElem || elemStyle.position === 'fixed') {\n        return scrollParentElem;\n    }\n    while (scrollParentElem && scrollParentElem !== docElem) {\n        var scrollParentStyle = window.getComputedStyle(scrollParentElem);\n        if (excludeStatic && scrollParentStyle.position !== 'static') {\n            excludeStatic = false;\n        }\n        if (!excludeStatic && REGULAR_EXPRESSIONS.overflow.test('' + scrollParentStyle.overflow + scrollParentStyle.overflowY + scrollParentStyle.overflowX)) {\n            break;\n        }\n        scrollParentElem = scrollParentElem.scrollParent;\n    }\n    return scrollParentElem || docElem;\n}\n/**\n * Checks if the elements scroll parent scrollbars are visible.\n * @param {Element} element The element to check the scroll parent of.\n * @returns {IScrollbarVisibility}\n */\nexport function isScrollbarVisible(element) {\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - isDocumentScrolled: invalid element argument');\n    }\n    var scrollParentElem = scrollParent(element);\n    return {\n        x: scrollParentElem.scrollWidth > scrollParentElem.clientWidth,\n        y: scrollParentElem.scrollHeight > scrollParentElem.clientHeight\n    };\n}\n/**\n * Gets the offset from the element to the parent element edges.\n * If no parentElement is supplied, the documentElement will be used.\n * @param {Element} element The element to compute the offset for.\n * @param {Element=} parentElement Optional parent element to measure from.\n * @returns {DOMRect}\n */\nexport function offset(element, parentElement) {\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - offset: invalid element argument');\n    }\n    var elemBCR = element.getBoundingClientRect();\n    var win = _ownerDocument(element).defaultView;\n    var docElem = parentElement || win.document.documentElement;\n    var offsetValues = { width: elemBCR.width, height: elemBCR.width, top: 0, left: 0, bottom: 0, right: 0 };\n    if (!parentElement || docElem === win.document.documentElement || docElem === win.document.body) {\n        offsetValues.top = win.pageYOffset + elemBCR.top;\n        offsetValues.bottom = docElem.clientHeight - win.pageYOffset - elemBCR.bottom;\n        offsetValues.left = win.pageXOffset + elemBCR.left;\n        offsetValues.right = docElem.clientWidth - win.pageXOffset - elemBCR.right;\n    }\n    else {\n        if (!isElement(parentElement)) {\n            throw new Error('DOMUtils - offset: invalid parentElement argument');\n        }\n        var parentBCR = parentElement.getBoundingClientRect();\n        offsetValues.top = elemBCR.top - parentBCR.top;\n        offsetValues.bottom = parentBCR.bottom - elemBCR.bottom;\n        offsetValues.left = elemBCR.left - parentBCR.left;\n        offsetValues.right = parentBCR.right - elemBCR.right;\n    }\n    return {\n        width: Math.round(elemBCR.width),\n        height: Math.round(elemBCR.height),\n        top: Math.round(offsetValues.top),\n        bottom: Math.round(offsetValues.bottom),\n        left: Math.round(offsetValues.left),\n        right: Math.round(offsetValues.right)\n    };\n}\n/**\n * Gets the offset from the element to the parent element viewable edges.\n * If no parentElement is supplied, the documentElement will be used.\n * @param {Element} element The element to measure\n * @param {Element=} parentElement The parent element to measure to.\n * @returns {DOMRect}\n */\nexport function viewportOffset(element, parentElement) {\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - offset: invalid element argument');\n    }\n    var win = _ownerDocument(element).defaultView;\n    parentElement = parentElement || win.document.documentElement;\n    var parentElementOffset = offset(element, parentElement);\n    var offsetValues = {\n        top: parentElementOffset.top,\n        bottom: 0,\n        left: parentElementOffset.left,\n        right: 0\n    };\n    if (parentElement === win.document.documentElement) {\n        offsetValues.top -= win.pageYOffset;\n        offsetValues.left -= win.pageXOffset;\n    }\n    else {\n        var parentStyle = window.getComputedStyle(parentElement);\n        offsetValues.top -= parseStyle('' + parentStyle.borderTopWidth);\n        offsetValues.left -= parseStyle('' + parentStyle.borderLeftWidth);\n    }\n    offsetValues.bottom = parentElement.clientHeight - offsetValues.top - element.offsetHeight;\n    offsetValues.right = parentElement.clientWidth - offsetValues.left - element.offsetWidth;\n    return {\n        width: parentElementOffset.width,\n        height: parentElementOffset.height,\n        top: Math.round(offsetValues.top),\n        bottom: Math.round(offsetValues.bottom),\n        left: Math.round(offsetValues.left),\n        right: Math.round(offsetValues.right)\n    };\n}\n/**\n * Checks if any part of an element is visible in the viewport.\n * @param {Element} element The element to check.\n * @returns {boolean}\n */\nexport function isElementInViewport(element) {\n    if (!isElement(element)) {\n        throw new Error('DOMUtils - isElementInViewport: invalid element argument');\n    }\n    var document = _ownerDocument(element);\n    var scrollParentElem = scrollParent(element);\n    var elemBCR = element.getBoundingClientRect();\n    if (scrollParentElem !== document.documentElement && scrollParentElem !== document.body) {\n        var scrollParentOffset = offset(element, scrollParentElem);\n        if (scrollParentOffset.top + elemBCR.height < 0 ||\n            scrollParentOffset.left + elemBCR.width < 0 ||\n            scrollParentOffset.bottom + elemBCR.height - this.scrollbarWidth < 0 ||\n            scrollParentOffset.right + elemBCR.width - this.scrollbarWidth < 0) {\n            return false;\n        }\n    }\n    if (elemBCR.top + elemBCR.height < 0 ||\n        elemBCR.left + elemBCR.width < 0 ||\n        elemBCR.bottom + elemBCR.height > document.documentElement.clientHeight ||\n        elemBCR.right + elemBCR.width > document.documentElement.clientWidth) {\n        return false;\n    }\n    return true;\n}\n/**\n * Calculates an elements position relative to another element.  The position\n * returned is relative to the body element.\n * Passing 'auto' as part of the placement parameter\n * will enable smart placement - where the element fits. i.e:\n * 'auto left-top' will check to see if there is enough space to the left\n * of the hostElem to fit the targetElem, if not place right (same for secondary\n * top placement).\n * @param {Element} element The element being positioned.\n * @param {Element} targetElement The element to position to.\n * @param {string} placement The desired placement of the positioned element.\n * @param {Element=} appendToElement The element that the positioned element will be calculated from.\n * Available placements are:\n *   <ul>\n *     <li>top</li>\n *     <li>top-right</li>\n *     <li>top-left</li>\n *     <li>bottom</li>\n *     <li>bottom-left</li>\n *     <li>bottom-right</li>\n *     <li>left</li>\n *     <li>left-top</li>\n *     <li>left-bottom</li>\n *     <li>right</li>\n *     <li>right-top</li>\n *     <li>right-bottom</li>\n *   </ul>\n * @returns {IElementPosition} The position of the element\n */\nexport function positionElement(element, targetElement, placement, hostElement) {\n    if (!isElement(element)) {\n        throw new Error('TylDOM - positionElement: invalid element argument');\n    }\n    if (!isElement(targetElement)) {\n        throw new Error('TylDOM - positionElement: invalid target element argument');\n    }\n    var elemPlacement = parsePlacement(placement);\n    var hostElem = hostElement || _ownerDocument(element).body;\n    var targetElemOffset = offset(targetElement, hostElem);\n    if (elemPlacement.auto) {\n        var hostElemOffset = offset(targetElement, _ownerDocument(element).body);\n        var elemStyle = window.getComputedStyle(element);\n        var elemSize = {\n            width: element.offsetWidth + Math.round(Math.abs(parseStyle('' + elemStyle.marginLeft) + parseStyle('' + elemStyle.marginRight))),\n            height: element.offsetHeight + Math.round(Math.abs(parseStyle('' + elemStyle.marginTop) + parseStyle('' + elemStyle.marginBottom)))\n        };\n        // check if the popup element will fit in the primary placement and if the opposite placement\n        // has more room than the primary placement.  If true use opposite placement.\n        switch (elemPlacement.primary) {\n            case 'top':\n                if (elemSize.height > hostElemOffset.top && hostElemOffset.bottom > hostElemOffset.top) {\n                    elemPlacement.primary = 'bottom';\n                }\n                break;\n            case 'bottom':\n                if (elemSize.height > hostElemOffset.bottom && hostElemOffset.top > hostElemOffset.bottom) {\n                    elemPlacement.primary = 'top';\n                }\n                break;\n            case 'left':\n                if (elemSize.width > hostElemOffset.left && hostElemOffset.right > hostElemOffset.left) {\n                    elemPlacement.primary = 'right';\n                }\n                break;\n            case 'right':\n                if (elemSize.width > hostElemOffset.right && hostElemOffset.left > hostElemOffset.right) {\n                    elemPlacement.primary = 'left';\n                }\n                break;\n        }\n        // for the secondary placement the popup element will align with an edge of the targetElement\n        // so we need to subtract the popup element size from the hostElemOffset when checking\n        // if the popup element will fit.\n        var xOverflow = elemSize.width - hostElemOffset.width;\n        var yOverflow = elemSize.height - hostElemOffset.height;\n        switch (elemPlacement.secondary) {\n            case 'top':\n                if (yOverflow > hostElemOffset.bottom && yOverflow <= hostElemOffset.top) {\n                    elemPlacement.secondary = 'bottom';\n                }\n                break;\n            case 'bottom':\n                if (yOverflow > hostElemOffset.top && yOverflow <= hostElemOffset.bottom) {\n                    elemPlacement.secondary = 'top';\n                }\n                break;\n            case 'left':\n                if (xOverflow > hostElemOffset.right && xOverflow <= hostElemOffset.left) {\n                    elemPlacement.secondary = 'right';\n                }\n                break;\n            case 'right':\n                if (xOverflow > hostElemOffset.left && xOverflow <= hostElemOffset.right) {\n                    elemPlacement.secondary = 'left';\n                }\n                break;\n        }\n        if (elemPlacement.secondary === 'center') {\n            if (REGULAR_EXPRESSIONS.placement.topBottom.test(elemPlacement.primary)) {\n                var centerXOverflow = hostElemOffset.width / 2 - element.offsetWidth / 2;\n                if (hostElemOffset.left + centerXOverflow < 0 && xOverflow <= hostElemOffset.right) {\n                    elemPlacement.secondary = 'left';\n                }\n                else if (hostElemOffset.right + xOverflow < 0 && xOverflow <= hostElemOffset.left) {\n                    elemPlacement.secondary = 'right';\n                }\n            }\n            else {\n                var centerYOverflow = hostElemOffset.height / 2 - elemSize.height / 2;\n                if (hostElemOffset.top + centerYOverflow < 0 && yOverflow <= hostElemOffset.bottom) {\n                    elemPlacement.secondary = 'top';\n                }\n                else if (hostElemOffset.bottom + yOverflow < 0 && yOverflow <= hostElemOffset.top) {\n                    elemPlacement.secondary = 'bottom';\n                }\n            }\n        }\n    }\n    var adjustedRect = {\n        top: targetElemOffset.top + hostElem.scrollTop,\n        left: targetElemOffset.left + hostElem.scrollLeft,\n        bottom: hostElem.clientHeight - targetElemOffset.top - targetElemOffset.height,\n        right: hostElem.clientWidth - targetElemOffset.left - targetElemOffset.width\n    };\n    var elemPosition = { top: 0, bottom: 0, left: 0, right: 0, placement: {}, class: '' };\n    switch (elemPlacement.primary) {\n        case 'top':\n            elemPosition.top = adjustedRect.top - element.offsetHeight;\n            elemPosition.bottom = adjustedRect.bottom + targetElemOffset.height;\n            break;\n        case 'bottom':\n            elemPosition.top = adjustedRect.top + targetElemOffset.height;\n            elemPosition.bottom = adjustedRect.bottom - element.offsetHeight;\n            break;\n        case 'left':\n            elemPosition.left = adjustedRect.left - element.offsetWidth;\n            elemPosition.right = adjustedRect.right + targetElemOffset.width;\n            break;\n        case 'right':\n            elemPosition.left = adjustedRect.left + targetElemOffset.width;\n            elemPosition.right = adjustedRect.right - element.offsetWidth;\n            break;\n        default:\n            break;\n    }\n    switch (elemPlacement.secondary) {\n        case 'top':\n            elemPosition.top = adjustedRect.top;\n            elemPosition.bottom = adjustedRect.bottom + targetElemOffset.height - element.offsetHeight;\n            break;\n        case 'bottom':\n            elemPosition.top = adjustedRect.top + targetElemOffset.height - element.offsetHeight;\n            elemPosition.bottom = adjustedRect.bottom;\n            break;\n        case 'left':\n            elemPosition.left = adjustedRect.left;\n            elemPosition.right = adjustedRect.right + targetElemOffset.width - element.offsetWidth;\n            break;\n        case 'right':\n            elemPosition.left = adjustedRect.left + targetElemOffset.width - element.offsetWidth;\n            elemPosition.right = adjustedRect.right;\n            break;\n        case 'center':\n            if (REGULAR_EXPRESSIONS.placement.topBottom.test(elemPlacement.primary)) {\n                elemPosition.left = adjustedRect.left + targetElemOffset.width / 2 - element.offsetWidth / 2;\n                elemPosition.right = adjustedRect.right + targetElemOffset.width / 2 - element.offsetWidth / 2;\n            }\n            else {\n                elemPosition.top = adjustedRect.top + targetElemOffset.height / 2 - element.offsetHeight / 2;\n                elemPosition.bottom = adjustedRect.bottom + targetElemOffset.height / 2 - element.offsetHeight / 2;\n            }\n            break;\n        default:\n            break;\n    }\n    elemPosition.placement = elemPlacement;\n    elemPosition.top = Math.round(elemPosition.top);\n    elemPosition.bottom = Math.round(elemPosition.bottom);\n    elemPosition.left = Math.round(elemPosition.left);\n    elemPosition.right = Math.round(elemPosition.right);\n    elemPosition.class = elemPlacement.secondary === 'center' ? elemPlacement.primary : elemPlacement.primary + '-' + elemPlacement.secondary;\n    return elemPosition;\n}\n/**\n * Adds an event listener to the document that will call the provided callback function\n * when an element and it's children no longer have focus.  The blur and touchstart events are used\n * to evaluate the active element to determine if the callback should be called.\n *\n * @param {Element} element The element to add the event listener to.\n * @param {Function} callback The function to call when the element and children don't have focus.\n * @param {boolean} [delay=false] Should a RAF cycle occur before the callback is called.\n * @returns {Function} The function to call to remove the document events.\n */\nexport function notChildEventListener(element, callback, delay) {\n    var evtHandler = function (event) {\n        var handle = function () {\n            event.stopPropagation();\n            if (event.cancelable) {\n                event.preventDefault();\n            }\n            var activeElement = (event.type === 'touchstart' ? event.target : _ownerDocument(element).activeElement);\n            if (!element.contains(activeElement)) {\n                callback(activeElement);\n            }\n        };\n        if (delay) {\n            window.requestAnimationFrame(function () { return handle(); });\n        }\n        else {\n            handle();\n        }\n    };\n    var docElem = _ownerDocument(element);\n    docElem.addEventListener('blur', evtHandler, true);\n    docElem.addEventListener('touchstart', evtHandler, true);\n    return function () {\n        docElem.removeEventListener('blur', evtHandler, true);\n        docElem.removeEventListener('touchstart', evtHandler, true);\n    };\n}\n/**\n * Removes all children from a DOM node.\n * @param node The DOM node to remove children from.\n */\nexport function removeAllChildren(node) {\n    while (node.lastChild) {\n        node.removeChild(node.lastChild);\n    }\n}\n/**\n * Replaces one child node of the specified node with another.\n * @param newChild The new node to replace `oldChild`.\n * @param oldChild The existing node to be replaced.\n * @returns {Node} The replaced node. Same node as `oldChild`.\n */\nexport function replaceElement(newChild, oldChild) {\n    return oldChild.parentNode.replaceChild(newChild, oldChild);\n}\n/**\n * Adds a class or array of classes to an element.\n *\n * @param {string | string[]} name The class(es) to add to the element\n * @param {Element} element The element to add class(es) to.\n */\nexport function addClass(name, element) {\n    if (isArray(name)) {\n        name.forEach(function (n) { return element.classList.add(n); });\n    }\n    else {\n        element.classList.add(name);\n    }\n}\n/**\n * Removes a class or array of classes to an element.\n *\n * @param {string | string[]} name The class(es) to remove from the element\n * @param {Element} element The element to remove class(es) from.\n */\nexport function removeClass(name, element) {\n    if (isArray(name)) {\n        name.forEach(function (n) { return element.classList.remove(n); });\n    }\n    else {\n        element.classList.remove(name);\n    }\n}\n/** Determines which type of animation event is supported. */\nexport function getAnimationEvent() {\n    var el = document.createElement('fakeelement');\n    // tslint:disable:object-literal-key-quotes\n    var animations = {\n        'animation': 'animationend',\n        'OAnimation': 'oAnimationEnd',\n        'MozAnimation': 'animationend',\n        'WebkitAnimation': 'webkitAnimationEnd'\n    };\n    for (var t in animations) {\n        if (el.style[t] !== undefined) {\n            return animations[t];\n        }\n    }\n}\n/**\n * A helper method to trigger a keyframe animation via adding a class, and removing the class when the animation completes.\n * @param {HTMLElement} element The element to play the animation on.\n * @param {string} className The class to add that triggers the animation.\n */\nexport function playKeyframeAnimation(element, className) {\n    element.classList.add(className);\n    var animationEvent = getAnimationEvent();\n    var animationCompletedListener = function () {\n        element.classList.remove(className);\n        element.removeEventListener(animationEvent, animationCompletedListener);\n    };\n    element.addEventListener(animationEvent, animationCompletedListener);\n}\n/**\n * Removes an element from the DOM using the available remove method for that platform.\n * @param {HTMLElement} element The element to remove.\n */\nexport function removeElement(element) {\n    if (element['removeNode']) {\n        element['removeNode'](true);\n    }\n    else if (element['remove']) {\n        element.remove();\n    }\n    else {\n        element.parentNode.removeChild(element);\n    }\n}\n/**\n * Returns a width string that is safe for css based on the provided input.\n * @param {string | number} width\n * @returns {string | undefined} A width safe for using in CSS.\n */\nexport function safeCssWidth(width) {\n    if (typeof width === 'string') {\n        if (width[width.length - 1] === '%') {\n            return width;\n        }\n        else if (width.slice(-2) === 'px') {\n            return width;\n        }\n        else if (Number(width) >= 0) {\n            return width + \"px\";\n        }\n    }\n    else if (typeof width === 'number') {\n        if (width >= 0) {\n            return width + \"px\";\n        }\n    }\n    return undefined;\n}\n/**\n * Calculates the size of an element that is not attached to the DOM.\n * @param {HTMLElement} element The element to calc the size of.\n * @returns {width, height} The size of the element.\n */\nexport function calcSizeUnattached(element) {\n    var container = document.createElement('div');\n    container.style.position = 'absolute';\n    container.style.top = '-99999px';\n    container.style.left = '-99999px';\n    container.style.visibility = 'hidden';\n    container.appendChild(element.cloneNode(true));\n    document.body.appendChild(container);\n    var size = {\n        width: container.scrollWidth,\n        height: container.scrollHeight\n    };\n    removeElement(container);\n    container = undefined;\n    return size;\n}\n/**\n * Resolves a promise when the provided element has children.\n * @param {Element} element An element that does or will contain children.\n */\nexport function ensureChildren(element) {\n    if (element.children.length) {\n        return Promise.resolve();\n    }\n    return new Promise(function (resolve) {\n        var observer = new MutationObserver(function (changes) {\n            if (element.children.length) {\n                observer.disconnect();\n                resolve();\n            }\n        });\n        observer.observe(element, { childList: true });\n    });\n}\n/**\n * Resolves a promise when the provided element has a child that matches a given selector.\n * @param {Element} element An element that does or will contain children.\n * @param {string} selector A CSS selector to use for finding an element.\n */\nexport function ensureChild(element, selector) {\n    var initialElements = deepQuerySelectorAll(element, selector);\n    if (initialElements.length) {\n        return Promise.resolve(initialElements[0]);\n    }\n    return new Promise(function (resolve) {\n        var observer = new MutationObserver(function (changes) {\n            var hasAddedNodes = changes.reduce(function (prev, curr) { return prev + curr.addedNodes.length; }, 0) > 0;\n            if (hasAddedNodes) {\n                var foundElements = deepQuerySelectorAll(element, selector);\n                if (foundElements.length) {\n                    observer.disconnect();\n                    resolve(foundElements[0]);\n                }\n            }\n        });\n        observer.observe(element, { childList: true, subtree: true });\n    });\n}\n/**\n * Walks up the tree starting a specific node and stops when the provided matcher function returns true.\n * @param {Node} node The node to start searching from.\n * @returns {Node | null} The closest matching ancestor node, or null if not found.\n */\nexport function walkUpUntil(node, matcher) {\n    var parent = (node && node.parentNode);\n    while (parent) {\n        if (matcher(parent)) {\n            return parent;\n        }\n        parent = parent.parentNode;\n    }\n    return null;\n}\n/**\n * Calculates the width of a string given the provided font information.\n */\nexport function calculateFontWidth(value, info) {\n    var canvas = document.createElement('canvas');\n    var ctx = canvas.getContext('2d');\n    var fontSize = info ? info.fontSize : 16;\n    var fontFamily = info ? info.fontFamily : 'Roboto';\n    ctx.font = fontSize + \"px \" + fontFamily;\n    return ctx.measureText(value).width;\n}\n/**\n * Generates a CSS text-shadow style value based on the number of iterations and color provided.\n * @param {number} iterations The number of iterations for how long the shadow should be.\n * @param {string} color The color of the text shadow. Can be any CSS-safe color format. Ex. hex, rgb, rgba, hsl... etc.\n */\nexport function generateTextShadow(iterations, color) {\n    var shadows = [];\n    for (var i = 1; i <= iterations; i++) {\n        shadows.push(i + \"px \" + i + \"px \" + color);\n    }\n    return shadows.join(', ');\n}\n","import { replaceElement, isArray, removeAllChildren, walkUpUntil } from '../utils';\n/**\n * Recursively defines a component as a custom elements and all of its dependencies.\n * @param component The component to import.\n */\nexport function defineCustomElement(component) {\n    tryDefine(component['_customElementName'], component);\n    if (isArray(component['_customElementDependencies'])) {\n        defineCustomElements(component['_customElementDependencies']);\n    }\n}\n/**\n * Defines the specified custom element components.\n * @param {any[]} components The components to register.\n */\nexport function defineCustomElements(components) {\n    components.forEach(defineCustomElement);\n}\n/**\n * Attempts to define the provided custom element name/constructor if not already defined.\n * @param name The name of the custom element to define.\n * @param ctor The custom element constructor.\n */\n// tslint:disable-next-line:ban-types\nexport function tryDefine(name, ctor, options) {\n    if (window.customElements.get(name)) {\n        return;\n    }\n    window.customElements.define(name, ctor, options);\n}\n/**\n * Useful when capturing the value of a unupgraded component during the `connectedCallback` upon upgrade.\n *\n * More information here:\n * https://developers.google.com/web/fundamentals/architecture/building-components/best-practices#lazy-properties\n *\n * @param property\n */\nexport function upgradeProperty(instance, property) {\n    if (instance.hasOwnProperty(property)) {\n        var value = instance[property];\n        delete instance[property];\n        instance[property] = value;\n    }\n}\n/**\n * Traverses up the DOM tree starting from the provided component element to find the specified parent.\n * @param {HTMLElement} component The starting HTMLElement.\n * @param {string} parentTagName The parent tag name we are searching for.\n */\nexport function requireParent(component, parentTagName) {\n    var el = component;\n    while (el.parentNode) {\n        el = el.parentNode;\n        if (!el.tagName) {\n            break;\n        }\n        if (!el.tagName || el.tagName.toLowerCase() === parentTagName.toLowerCase()) {\n            return el;\n        }\n    }\n    return null;\n}\n/**\n * Creates a template element from a string.\n * @param template The template HTML string.\n */\nexport function parseTemplateString(template) {\n    var templateDocument = new DOMParser().parseFromString(template, 'text/html');\n    return createTemplateContent(templateDocument.querySelector('template'));\n}\n/**\n * Attaches a template to the given web component instance light DOM.\n * @param {T} componentInstance A component instance.\n * @param {string} template The template HTML string.\n */\nexport function attachLightTemplate(componentInstance, template) {\n    componentInstance.appendChild(parseTemplateString(template).content.cloneNode(true));\n}\n/**\n * Attaches a shadow root to the given web component instance.\n * @param {T} componentInstance A component instance.\n * @param {string} elementName The name of the element the shadow root is to be attached to.\n * @param {string} template The shadow root template HTML string.\n * @param {string | string[]} styles The shadow root styles string to be encapsulated by this shadow root.\n * @param {boolean} [delegatesFocus=false] Should the component delagate focus.\n */\nexport function attachShadowTemplate(componentInstance, elementName, template, styles, delegatesFocus) {\n    if (delegatesFocus === void 0) { delegatesFocus = false; }\n    var templateElement = prepareShadowTemplate(elementName, template, styles);\n    componentInstance.attachShadow({ mode: 'open', delegatesFocus: delegatesFocus });\n    setShadowTemplate(componentInstance, templateElement);\n}\n/**\n * Replaces the template of an existing shadow root with the provided template.\n * @param {T} componentInstance A component instance.\n * @param {string} elementName The name of the element the shadow root is to be attached to.\n * @param {string} template The shadow root template HTML string.\n * @param {string | string[]} styles The shadow root styles string to be encapsulated by this shadow root.\n */\nexport function replaceShadowTemplate(componentInstance, elementName, template, styles) {\n    if (!componentInstance.shadowRoot) {\n        throw new Error('This element does not contain a shadow root. Did you mean to call `attachShadowTemplate`?');\n    }\n    var templateElement = prepareShadowTemplate(elementName, template, styles);\n    if (componentInstance.shadowRoot.children.length) {\n        removeAllChildren(componentInstance.shadowRoot);\n    }\n    setShadowTemplate(componentInstance, templateElement);\n}\n/**\n * Creates and prepares an HTML template element for rendering within a shadow root.\n * @param {string} elementName The name of the element the shadow root is to be attached to.\n * @param {string} template The shadow root template HTML string.\n * @param {string | string[]} styles The shadow root styles string to be encapsulated by this shadow root.\n */\nexport function prepareShadowTemplate(elementName, template, styles) {\n    var templateElement = parseTemplateString(template);\n    if (styles) {\n        styles = styles instanceof Array ? styles : [styles];\n        var styleElement = document.createElement('style');\n        styleElement.type = 'text/css';\n        styleElement.textContent = styles.join(' ');\n        templateElement.content.appendChild(styleElement);\n    }\n    if (window.ShadyCSS && !window.ShadyCSS.nativeShadow) {\n        window.ShadyCSS.prepareTemplate(templateElement, elementName);\n    }\n    return templateElement;\n}\n/**\n * Appends a template to the provided components shadow root.\n * @param {T} componentInstance A component instance.\n * @param {HTMLTemplateElement} templateElement A template element to be cloned.\n */\nexport function setShadowTemplate(componentInstance, templateElement) {\n    componentInstance.shadowRoot.appendChild(templateElement.content.cloneNode(true));\n}\n/**\n * Polyfills the shadow DOM styles if necessary.\n * @param componentInstance A custom element instance.\n */\nexport function polyfillShadowStyles(componentInstance) {\n    if (window.ShadyCSS && !window.ShadyCSS.nativeShadow) {\n        window.ShadyCSS.styleElement(componentInstance);\n    }\n}\n/**\n * Polyfills the `content` property on a `<template>` element that is created dynamically.\n * @param {HTMLTemplateElement} template The template element.\n */\nexport function createTemplateContent(template) {\n    if (template.content) {\n        return template;\n    }\n    template.content = template.ownerDocument.createDocumentFragment();\n    var child;\n    while (child = template.firstChild) { // tslint:disable-line\n        template.content.appendChild(child);\n    }\n    return template;\n}\n/**\n * Copies style rules from the provided document stylesheets collection to the provided shadow root stylesheet.\n * @param {Document} fromDocument The document to find the style sheets in.\n * @param {ShadowRoot} shadowRoot The shadow root that contains the stylesheet to copy the rules to.\n * @param {IStyleSheetDescriptor[]} styleSheetDescriptors A collection of style sheet predicates.\n * @param {CSSStyleSheet} shadowStyleSheet The shadow root stylesheet to copy the style rules to.\n */\nexport function provideDocumentStyles(fromDocument, shadowRoot, documentStyleSheets, shadowStyleSheet) {\n    if (!shadowStyleSheet) {\n        return;\n    }\n    var documentSheets = [];\n    documentStyleSheets.forEach(function (sheet) {\n        var sheetName = typeof sheet === 'string' ? sheet : sheet.name;\n        var sheetFilter = sheet.selectorFilter;\n        var matchingStyleSheet = _findMatchingStyleSheet(fromDocument.styleSheets, sheetName);\n        if (!matchingStyleSheet) {\n            throw new Error(\"Could not find stylesheet: \" + sheetName);\n        }\n        var startIndex = shadowStyleSheet.cssRules.length;\n        for (var rule in matchingStyleSheet.cssRules) {\n            if (matchingStyleSheet.cssRules.hasOwnProperty(rule) && matchingStyleSheet.cssRules[rule].cssText && (!sheetFilter || new RegExp(sheetFilter).test(matchingStyleSheet.cssRules[rule].selectorText))) {\n                shadowStyleSheet.insertRule(matchingStyleSheet.cssRules[rule].cssText, startIndex++);\n            }\n        }\n    });\n}\n/**\n * Finds a stylesheet by name in the provided stylesheet list.\n * @param styleSheetList The stylesheet list to search.\n * @param sheetName The stylesheet name to find.\n * @returns {CSSStyleSheet | undefined}\n */\nfunction _findMatchingStyleSheet(styleSheetList, sheetName) {\n    for (var prop in styleSheetList) {\n        if (styleSheetList.hasOwnProperty(prop) && styleSheetList[prop].href) {\n            if (new RegExp(sheetName).test(styleSheetList[prop].href)) {\n                return styleSheetList[prop];\n            }\n        }\n    }\n    return undefined;\n}\n/**\n * Gets an HTML element using a query selector from the provided components` shadow root.\n * @param {HTMLElement} componentInstance The component instance that contains a shadow root.\n * @param {string} selector The selector to be passed to `querySelector`.\n */\nexport function getShadowElement(componentInstance, selector) {\n    return componentInstance.shadowRoot.querySelector(selector);\n}\n/**\n * Gets an HTML element using a query selector from the provided components` light DOM.\n * @param {HTMLElement} componentInstance The component instance.\n * @param {string} selector The selector to be passed to `querySelector`.\n */\nexport function getLightElement(componentInstance, selector) {\n    return componentInstance.querySelector(selector);\n}\n/**\n * Creates and dispatches a cross-browser `CustomEvent` with the provided type and data.\n * @param {string} type\n * @param {any} data\n * @param {boolean=} bubble\n */\nexport function emitEvent(component, type, data, bubble, cancelable) {\n    if (bubble === void 0) { bubble = true; }\n    if (cancelable === void 0) { cancelable = false; }\n    var evt;\n    if (typeof CustomEvent === 'function') {\n        evt = new CustomEvent(type, {\n            detail: data,\n            bubbles: bubble,\n            cancelable: cancelable\n        });\n    }\n    else {\n        evt = document.createEvent('CustomEvent');\n        evt.initCustomEvent(type, bubble, cancelable, data);\n    }\n    return component.dispatchEvent(evt);\n}\n/**\n * Replaces the provided element with a placeholder comment and vice versa.\n * Useful for hiding and showing elements while retaining their location in the DOM.\n * @param {boolean} isVisible Whether the element is visible or not.\n * @param {string} elementName The element tag name.\n * @param {string} selector The selector used to find the element\n * @param {Node} element The element\n * @param {Comment} placeholder The existing placeholder\n */\nexport function toggleElementPlaceholder(component, isVisible, elementName, selector, element, placeholder) {\n    var exists = !!getShadowElement(component, selector);\n    if (!placeholder) {\n        placeholder = document.createComment(\"(\" + elementName + \") \" + selector);\n    }\n    if (isVisible && !exists) {\n        replaceElement(element, placeholder);\n    }\n    else if (!isVisible && exists) {\n        replaceElement(placeholder, element);\n    }\n    return placeholder;\n}\n/**\n * Walks up the tree starting a specific node and stops when it finds a shadow root.\n * @param {Node} node The node to start searching from.\n * @returns {ShadowRoot | null} The closest shadow root ancestor, or null if not inside a shadow root.\n */\nexport function getClosestShadowRoot(node) {\n    return walkUpUntil(node, function (current) { return current.toString() === '[object ShadowRoot]'; });\n}\n/**\n * Finds the closest element up the tree from a starting element across shadow boundaries.\n * @param selector The CSS selector for the element to find.\n * @param startElement The element to start finding from.\n */\nexport function closestElement(selector, startElement) {\n    function __closestFrom(el) {\n        if (!el || el === document || el === window) {\n            return null;\n        }\n        if (el.assignedSlot) {\n            el = el.assignedSlot;\n        }\n        var found = el.closest(selector);\n        return found || __closestFrom(el.getRootNode().host);\n    }\n    return __closestFrom(startElement);\n}\n// export interface IFocusTrap {\n//   activate: () => IFocusTrap;\n//   deactivate: (options?: IFocusTrapDeactivateOptions) => IFocusTrap;\n//   pause: () => IFocusTrap;\n//   unpause: () => IFocusTrap;\n// }\n// export interface IFocusTrapDeactivateOptions {\n//   returnFocus?: boolean;\n//   onDeactivate?: () => void;\n// }\n// export interface IFocusTrapOptions {\n//   onActivate?: () => void;\n//   onDeactivate?: () => void;\n//   initialFocus?: Element | string | (() => void);\n//   fallbackFocus?: Element | string | (() => void);\n//   escapeDeactivates?: boolean;\n//   clickOutsideDeactivates?: boolean;\n//   returnFocusOnDeactivate?: boolean;\n// }\n","import { isFunction } from '../../utils';\nimport { polyfillShadowStyles } from '../component-utils';\nexport var CUSTOM_ELEMENT_NAME_PROPERTY = '_customElementName';\nexport var CUSTOM_ELEMENT_DEPENDENCIES_PROPERTY = '_customElementDependencies';\n/**\n * This decorator is intended to be used on classes that extend `HTMLElement` to\n * extend/modify the behavior of a custom element.\n * @param {ICustomElementConfig} [config={}] The custom element configuration.\n */\nexport function CustomElement(config) {\n    return function (ctor) {\n        patchConnectedCallback(ctor);\n        if (config.name) {\n            ctor[CUSTOM_ELEMENT_NAME_PROPERTY] = config.name;\n        }\n        if (config.dependencies && config.dependencies.length) {\n            ctor[CUSTOM_ELEMENT_DEPENDENCIES_PROPERTY] = config.dependencies;\n        }\n    };\n}\nfunction patchConnectedCallback(ctor) {\n    var originalConnectedCallback = ctor.prototype.connectedCallback;\n    ctor.prototype.connectedCallback = function () {\n        if (!this.isConnected) {\n            return;\n        }\n        polyfillShadowStyles(this);\n        if (!this._isInitialized) {\n            this._isInitialized = true;\n            if (isFunction(this.initializedCallback)) {\n                this.initializedCallback.apply(this);\n            }\n        }\n        if (isFunction(originalConnectedCallback)) {\n            originalConnectedCallback.apply(this);\n        }\n    };\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import * as tslib_1 from \"tslib\";\nvar FoundationPropertyOptions = /** @class */ (function () {\n    function FoundationPropertyOptions(options) {\n        this.get = true;\n        this.set = true;\n        if (options) {\n            Object.assign(this, options);\n        }\n    }\n    return FoundationPropertyOptions;\n}());\nvar foundationPropertyNotFoundMessage = function (className, propertyName) { return className + \"'s foundation does not contain the property \\\"\" + propertyName + \"\\\"\"; };\nvar foundationNotFoundMessage = function (className) { return className + \" does not have a foundation\"; };\nfunction runIfVerified(target, propertyName, action) {\n    if (target._foundation) {\n        if (propertyName in target._foundation) {\n            return action();\n        }\n        else {\n            throw new Error(foundationPropertyNotFoundMessage(target.localName, propertyName));\n        }\n    }\n    else {\n        throw new Error(foundationNotFoundMessage(target.localName));\n    }\n}\nexport function FoundationProperty(options) {\n    var allOptions = new FoundationPropertyOptions(options);\n    return function (target, name, descriptor) {\n        var defaultGet;\n        var defaultSet;\n        var propertyName = name;\n        var foundationPropertyName = ((options && options.name) || name).toString();\n        if (descriptor) {\n            defaultGet = descriptor.get;\n            defaultSet = descriptor.set;\n            descriptor.configurable = true;\n            descriptor.enumerable = true;\n            if (allOptions.set) {\n                descriptor.set = function (value) {\n                    return wireDescriptorSet(this, foundationPropertyName, function (attributes) {\n                        var desc = Object.getOwnPropertyDescriptor(target, foundationPropertyName);\n                        desc.set = attributes.set;\n                        Reflect.defineProperty(target, propertyName, desc);\n                        attributes.set(value);\n                    }, defaultSet);\n                };\n            }\n            if (allOptions.get) {\n                descriptor.get = function () {\n                    return wireDescriptorGet(this, foundationPropertyName, function (attributes) {\n                        var desc = Object.getOwnPropertyDescriptor(target, foundationPropertyName);\n                        desc.get = attributes.get;\n                        Reflect.defineProperty(target, propertyName, desc);\n                        return attributes.get();\n                    }, defaultGet);\n                };\n            }\n        }\n        else {\n            if (allOptions.set || allOptions.get) {\n                var attributes = { configurable: true, enumerable: true };\n                var get_1 = {\n                    get: function () {\n                        var that = this;\n                        return wireDescriptorGet(that, foundationPropertyName, function (attrs) {\n                            var setter;\n                            // We have to wire the setter here as well\n                            if (allOptions.set) {\n                                setter = tslib_1.__assign({}, set_1);\n                            }\n                            Reflect.defineProperty(that, foundationPropertyName, tslib_1.__assign({ configurable: true, enumerable: true }, attrs, setter));\n                            return attrs.get();\n                        });\n                    }\n                };\n                var set_1 = {\n                    set: function (value) {\n                        var that = this;\n                        return wireDescriptorSet(that, foundationPropertyName, function (attrs) {\n                            var getter;\n                            // We have to wire the getter here as well\n                            if (allOptions.get) {\n                                getter = tslib_1.__assign({}, get_1);\n                            }\n                            Reflect.defineProperty(that, foundationPropertyName, tslib_1.__assign({ configurable: true, enumerable: true }, attrs, getter));\n                            attrs.set(value);\n                        });\n                    }\n                };\n                if (allOptions.get) {\n                    Object.assign(attributes, tslib_1.__assign({}, get_1));\n                }\n                if (allOptions.set) {\n                    Object.assign(attributes, tslib_1.__assign({}, set_1));\n                }\n                Reflect.defineProperty(target, propertyName, attributes);\n            }\n        }\n    };\n}\nfunction setFoundation(target, value, propertyName) {\n    target._foundation[propertyName] = value;\n}\nfunction getFoundation(target, propertyName) {\n    return target._foundation[propertyName];\n}\nfunction wireDescriptorSet(target, propertyName, wireAction, defaultSet) {\n    var attributes;\n    if (defaultSet) {\n        attributes = {\n            set: function (value) {\n                defaultSet.call(target, value);\n                setFoundation(target, value, propertyName);\n            }\n        };\n    }\n    else {\n        attributes = {\n            set: function (value) {\n                setFoundation(target, value, propertyName);\n            }\n        };\n    }\n    return runIfVerified(target, propertyName, function () { return wireAction(attributes); });\n}\nfunction wireDescriptorGet(target, propertyName, wireAction, defaultGet) {\n    var attributes;\n    if (defaultGet) {\n        attributes = {\n            get: function () {\n                defaultGet.call(target);\n                return getFoundation(target, propertyName);\n            }\n        };\n    }\n    else {\n        attributes = {\n            get: function () {\n                return getFoundation(target, propertyName);\n            }\n        };\n    }\n    return runIfVerified(target, propertyName, function () { return wireAction(attributes); });\n}\n","var EventAware = /** @class */ (function () {\n    function EventAware() {\n        this._listenerMap = new Map();\n    }\n    EventAware.prototype._emit = function (type, data) {\n        var listeners = this._listenerMap.get(type);\n        if (listeners && listeners.length) {\n            listeners.forEach(function (cb) { return cb({ type: type, data: data }); });\n        }\n    };\n    EventAware.prototype.hasListeners = function (type) {\n        return type ? this._listenerMap.has(type) : this._listenerMap.size > 0;\n    };\n    EventAware.prototype.addListener = function (type, listener) {\n        if (!this._listenerMap.has(type)) {\n            this._listenerMap.set(type, [listener]);\n        }\n        else {\n            var listeners = this._listenerMap.get(type);\n            if (listeners) {\n                listeners.push(listener);\n            }\n        }\n    };\n    EventAware.prototype.removeListener = function (type, listener) {\n        var listeners = this._listenerMap.get(type);\n        if (listeners && listeners.length && listeners.includes(listener)) {\n            listeners.splice(listeners.indexOf(listener), 1);\n            if (!listeners.length) {\n                this._listenerMap.delete(type);\n            }\n        }\n    };\n    return EventAware;\n}());\nexport { EventAware };\n","export var ScrollDirection;\n(function (ScrollDirection) {\n    ScrollDirection[\"Up\"] = \"up\";\n    ScrollDirection[\"Down\"] = \"down\";\n    ScrollDirection[\"Left\"] = \"left\";\n    ScrollDirection[\"Right\"] = \"right\";\n})(ScrollDirection || (ScrollDirection = {}));\nexport var ScrollEvents;\n(function (ScrollEvents) {\n    ScrollEvents[\"Scroll\"] = \"scroll\";\n    ScrollEvents[\"Scrolled\"] = \"scrolled\";\n    ScrollEvents[\"ScrolledStart\"] = \"scrolled-start\";\n    ScrollEvents[\"ScrolledEnd\"] = \"scrolled-end\";\n})(ScrollEvents || (ScrollEvents = {}));\n","/**\n * Represents a single message list entry containing a string message and its identifier.\n */\nvar MessageListEntry = /** @class */ (function () {\n    function MessageListEntry(message, identifier) {\n        this.message = message;\n        this.identifier = identifier;\n        this.originalMessage = message;\n    }\n    return MessageListEntry;\n}());\nexport { MessageListEntry };\n","import { MessageListEntry } from './message-list-entry';\n/**\n * Represents a message list of any type. This class can be used to attach a string message to\n * a generic identifier.\n */\nvar MessageList = /** @class */ (function () {\n    function MessageList(useAutoEllipsis) {\n        if (useAutoEllipsis === void 0) { useAutoEllipsis = true; }\n        this._useAutoEllipsis = true;\n        this._useAutoEllipsis = useAutoEllipsis;\n        this.reset();\n    }\n    Object.defineProperty(MessageList.prototype, \"useAutoEllipsis\", {\n        /**\n         * True if ellipsis management occurs automatically. Default is true.\n         */\n        get: function () {\n            return this._useAutoEllipsis;\n        },\n        set: function (value) {\n            this._useAutoEllipsis = value;\n            this._updateMessage();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Adds a message to the entry map.\n     * @param {string} message The message string.\n     * @param {T} identifier The message identifier.\n     * @returns {MessageList<T>} A reference to `this` for chaining.\n     */\n    MessageList.prototype.add = function (message, identifier) {\n        this._messages.push(new MessageListEntry(message, identifier));\n        this._updateMessage();\n        return this;\n    };\n    /**\n     * Removes a message using the provided identifier.\n     * @param {T} identifier The message identifier.\n     * @returns {MessageList<T>} A reference to `this` for chaining.\n     */\n    MessageList.prototype.remove = function (identifier) {\n        var index = this._getMessageIndex(identifier);\n        if (index >= 0) {\n            this._messages.splice(index, 1);\n            this._updateMessage();\n        }\n        return this;\n    };\n    /**\n     * Updates an existing message value.\n     * @param {string} message The message string.\n     * @param {T} identifier The existing message identifier.\n     * @returns {MessageList<T>} A reference to `this` for chaining.\n     */\n    MessageList.prototype.update = function (message, identifier) {\n        var index = this._getMessageIndex(identifier);\n        if (index >= 0) {\n            this._messages[index].message = message;\n            this._updateMessage();\n        }\n        return this;\n    };\n    Object.defineProperty(MessageList.prototype, \"messageCount\", {\n        /**\n         * Gets the number of messages in the list.\n         * @returns {number}\n         */\n        get: function () {\n            return this._messages.length;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Resets the message list to it's original state and removes all messages.\n     */\n    MessageList.prototype.reset = function () {\n        this._messages = [];\n        this.message = '';\n    };\n    /**\n     * Determines if a message with the provided identifier exists.\n     * @param {T} identifier The message identifier.\n     */\n    MessageList.prototype.hasMessage = function (identifier) {\n        return this._getMessageIndex(identifier) >= 0;\n    };\n    MessageList.prototype._updateMessage = function () {\n        var _this = this;\n        this.message = '';\n        this._messages.forEach(function (item, index) {\n            if (_this.useAutoEllipsis) {\n                var hasEllipsis = item.message.substr(item.message.length - 3) === '...';\n                if (index === _this._messages.length - 1) {\n                    if (!hasEllipsis) {\n                        item.message += '...';\n                    }\n                }\n                else if (hasEllipsis) {\n                    item.message = item.message.substr(0, item.message.length - 3);\n                }\n            }\n            else {\n                item.message = item.originalMessage;\n            }\n            _this.message += item.message + (index < _this._messages.length - 1 ? ', ' : '');\n        });\n        return this;\n    };\n    MessageList.prototype._getMessageIndex = function (identifier) {\n        var index = -1;\n        for (var i = 0; i < this._messages.length; i++) {\n            if (this._messages[i].identifier === identifier) {\n                index = i;\n                break;\n            }\n        }\n        return index;\n    };\n    return MessageList;\n}());\nexport { MessageList };\n","import * as tslib_1 from \"tslib\";\nimport { EventAware } from '../events/event-aware';\nimport { ScrollEvents, ScrollDirection } from './scroll-types';\nimport { isDefined, throttle, isNumber } from '../utils';\nvar DEFAULT_SCROLL_THROTTLE = 100;\n/**\n * Provides facilties for observing and reacting to scroll events and information on a given element.\n */\nvar ScrollAxisObserver = /** @class */ (function (_super) {\n    tslib_1.__extends(ScrollAxisObserver, _super);\n    function ScrollAxisObserver(_element, _config) {\n        if (_config === void 0) { _config = {}; }\n        var _this = _super.call(this) || this;\n        _this._element = _element;\n        _this._config = _config;\n        _this._axis = 'vertical';\n        _this._scrollThreshold = 0;\n        _this._lastScrollPosition = 0;\n        _this._lastScrollTop = 0;\n        _this._lastScrollLeft = 0;\n        _this._isListening = false;\n        _this._initialize();\n        return _this;\n    }\n    ScrollAxisObserver.prototype.destroy = function () {\n        this.stop();\n    };\n    ScrollAxisObserver.prototype.start = function () {\n        if (!this._isListening) {\n            this._element.addEventListener('scroll', this._scrollListener);\n            this._isListening = true;\n        }\n    };\n    ScrollAxisObserver.prototype.stop = function () {\n        this._element.removeEventListener('scroll', this._scrollListener);\n        this._isListening = false;\n    };\n    ScrollAxisObserver.prototype._initialize = function () {\n        var _this = this;\n        if (this._config.throttle) {\n            var wait = this._config.throttleTime || DEFAULT_SCROLL_THROTTLE;\n            this._scrollListener = throttle(function () { return _this._onScroll(); }, wait);\n        }\n        else {\n            this._scrollListener = function () { return _this._onScroll(); };\n        }\n        if (!isDefined(this._config.paused) || !this._config.paused) {\n            this.start();\n        }\n        if (isDefined(this._config.axis)) {\n            this._axis = this._config.axis;\n        }\n        if (isDefined(this._config.scrollThreshold) && isNumber(this._config.scrollThreshold)) {\n            this._scrollThreshold = this._config.scrollThreshold;\n        }\n    };\n    ScrollAxisObserver.prototype._isScrollAxis = function () {\n        var isVertical = this._lastScrollTop !== this._element.scrollTop;\n        var isHorizontal = this._lastScrollLeft !== this._element.scrollLeft;\n        return (this._axis === 'vertical' && isVertical) || (this._axis === 'horizontal' && isHorizontal);\n    };\n    ScrollAxisObserver.prototype._onScroll = function () {\n        if (!this._isScrollAxis()) {\n            return;\n        }\n        var position = this.scrollPosition;\n        var direction = this._lastScrollPosition - position < 0 ? (this._axis === 'vertical' ? ScrollDirection.Down : ScrollDirection.Right) : (this._axis === 'vertical' ? ScrollDirection.Up : ScrollDirection.Left);\n        this._emit(ScrollEvents.Scroll, { direction: direction, position: position });\n        if (this._lastScrollPosition <= this._scrollThreshold && position > this._scrollThreshold) {\n            this._emit(ScrollEvents.Scrolled, true);\n        }\n        else if (this._lastScrollPosition >= this._scrollThreshold && (this._scrollThreshold > 0 ? position < this._scrollThreshold : position === 0)) {\n            this._emit(ScrollEvents.Scrolled, false);\n        }\n        var scrollStart = Math.round(position - this._scrollThreshold);\n        var scrollEnd = Math.round(this.scrollSize - position);\n        if (this._lastScrollPosition >= this._scrollThreshold && scrollStart <= 0) {\n            this._emit(ScrollEvents.ScrolledStart);\n        }\n        else if (this._lastScrollPosition <= (this.scrollSize - this._scrollThreshold) && scrollEnd <= this._scrollThreshold) {\n            this._emit(ScrollEvents.ScrolledEnd);\n        }\n        this._lastScrollPosition = position || 0;\n        this._lastScrollTop = this._element.scrollTop || 0;\n        this._lastScrollLeft = this._element.scrollLeft || 0;\n    };\n    Object.defineProperty(ScrollAxisObserver.prototype, \"scrollPosition\", {\n        get: function () {\n            return this._axis === 'vertical' ? this._element.scrollTop : this._element.scrollLeft;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ScrollAxisObserver.prototype, \"isScrolled\", {\n        get: function () {\n            return this.scrollPosition > this._scrollThreshold;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ScrollAxisObserver.prototype, \"isScrolledStart\", {\n        get: function () {\n            return this.scrollPosition === 0;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ScrollAxisObserver.prototype, \"isScrolledEnd\", {\n        get: function () {\n            return this.scrollPosition === this._element.scrollWidth;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ScrollAxisObserver.prototype, \"isScrollable\", {\n        get: function () {\n            if (this._axis === 'vertical') {\n                return this._element.scrollHeight > this._element.clientHeight;\n            }\n            return this._element.scrollWidth > this._element.clientWidth;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ScrollAxisObserver.prototype, \"scrollSize\", {\n        get: function () {\n            return (this._axis === 'vertical' ? this._element.scrollHeight : this._element.scrollWidth) - this.elementSize;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ScrollAxisObserver.prototype, \"elementSize\", {\n        get: function () {\n            return this._axis === 'vertical' ? this._element.clientHeight : this._element.clientWidth;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ScrollAxisObserver.prototype.setScrollPosition = function (position) {\n        if (this._axis === 'vertical') {\n            this._element.scrollTop = position;\n        }\n        else {\n            this._element.scrollLeft = position;\n        }\n    };\n    return ScrollAxisObserver;\n}(EventAware));\nexport { ScrollAxisObserver };\n","export var ServiceRequestMethod;\n(function (ServiceRequestMethod) {\n    ServiceRequestMethod[\"GET\"] = \"GET\";\n    ServiceRequestMethod[\"POST\"] = \"POST\";\n    ServiceRequestMethod[\"PUT\"] = \"PUT\";\n    ServiceRequestMethod[\"DELETE\"] = \"DELETE\";\n    ServiceRequestMethod[\"PATCH\"] = \"PATCH\";\n    ServiceRequestMethod[\"HEAD\"] = \"HEAD\";\n    ServiceRequestMethod[\"CONNECT\"] = \"CONNECT\";\n    ServiceRequestMethod[\"OPTIONS\"] = \"OPTIONS\";\n    ServiceRequestMethod[\"TRACE\"] = \"TRACE\";\n})(ServiceRequestMethod || (ServiceRequestMethod = {}));\n","/** Copy the text value to the clipboard. */\nexport function copyToClipboard(text) {\n    var textarea = _createTextareaAndSelect(text);\n    var copySuccessful = document.execCommand('copy');\n    if (textarea) {\n        document.body.removeChild(textarea);\n        textarea = null;\n    }\n    return copySuccessful;\n}\n/**\n * Creates a hidden textarea element, sets its value from `text` property,\n * and makes a selection on it.\n */\nfunction _createTextareaAndSelect(text) {\n    var textarea = document.createElement('textarea');\n    textarea.style.fontSize = '12pt';\n    textarea.style.border = '0';\n    textarea.style.clip = 'rect(0 0 0 0)';\n    textarea.style.height = '1px';\n    textarea.style.margin = '-1px';\n    textarea.style.overflow = 'hidden';\n    textarea.style.padding = '0';\n    textarea.style.position = 'absolute';\n    textarea.style.width = '1px';\n    textarea.style.outline = '0';\n    textarea.style.setProperty('-webkit-appearance', 'none');\n    textarea.style.setProperty('-moz-appearance', 'none');\n    var yPosition = window.pageYOffset || document.documentElement.scrollTop;\n    textarea.style.top = yPosition + 'px';\n    textarea.setAttribute('readonly', '');\n    textarea.value = text;\n    document.body.appendChild(textarea);\n    textarea.select();\n    textarea.setSelectionRange(0, textarea.value.length);\n    return textarea;\n}\n","/**\n * Gets the node path from where the event originated from.\n * @param evt The event.\n */\nexport function getEventPath(evt) {\n    return evt.path || (evt.composedPath && evt.composedPath()) || composedPath(evt.target);\n}\n/**\n * Equivalent to path/composedPath.\n * Note: Slots and shadow roots are detected, but aren't needed as they are virtually invisible anyway...\n */\nexport function composedPath(el) {\n    var path = [];\n    while (el) {\n        if (el.shadowRoot) {\n            if (el.shadowRoot.activeElement) {\n                path.push(el.shadowRoot.activeElement);\n            }\n            path.push(el.shadowRoot);\n        }\n        path.push(el);\n        if (el.tagName === 'HTML') {\n            path.push(document);\n            path.push(window);\n            break;\n        }\n        el = el.parentElement;\n    }\n    return path;\n}\n","/**\n * Converts a JavaScript object to a URI encoded query string.\n * @param {any} obj The parameters for the query string.\n */\nexport function createQueryString(obj) {\n    if (!obj || obj.length === 0) {\n        return null;\n    }\n    var params = [];\n    for (var property in obj) {\n        if (!obj.hasOwnProperty(property)) {\n            continue;\n        }\n        if (obj[property] instanceof Array) {\n            for (var index in obj[property]) {\n                if (obj[property].hasOwnProperty(index)) {\n                    params.push(encodeURIComponent(property) + '=' + (obj[property][index] !== null && typeof obj[property][index] !== 'undefined' ? encodeURIComponent(obj[property][index]) : ''));\n                }\n            }\n        }\n        else {\n            params.push(encodeURIComponent(property) + '=' + (obj[property] !== null && typeof obj[property] !== 'undefined' ? encodeURIComponent(obj[property]) : ''));\n        }\n    }\n    return '?' + params.join('&');\n}\n","/**\n * This method will find a value in a JavaScript object using a string path.\n * Example:\n *   var obj = { one: 1, two: { twoOne: 21, twoTwo: 22, twoThree: [{ threeOne: 31 }] } };\n *   getPropertyValue(obj, 'two.twoOne'); // 21\n *   getPropertyValue(obj, 'one'); // 1\n *   getPropertyValue(obj, 'two.twoThree[0].threeOne'); // 31\n *\n * Inspired by \"Alnitak\"'s answer on stack overflow:\n * http://stackoverflow.com/questions/6491463/accessing-nested-javascript-objects-with-string-key\n */\nexport function getPropertyValue(obj, inPath) {\n    var path = inPath.replace(/\\[(\\w+)\\]/g, '.$1'); // Convert indexes to properties\n    path = path.replace(/^\\./, ''); // Strip a leading dot\n    var ary = path.split('.');\n    // tslint:disable-next-line:prefer-for-of\n    for (var i = 0; i < ary.length; ++i) {\n        var property = ary[i];\n        if (obj && typeof obj === 'object' && property in obj) {\n            obj = obj[property];\n        }\n        else {\n            obj = '';\n            break;\n        }\n    }\n    return obj;\n}\n/**\n * A wrapper around Array.prototype.find to allow for passing in a predicate.\n * @param {any[]} ary The array to search.\n * @param {any} predicate The predicate.\n */\nexport function findWhere(ary, predicate) {\n    return ary.find(function (item) { return matchesPredicate(item, predicate); });\n}\n/**\n * A wrapper around Array.prototype.findIndex to allow for passing in a predicate.\n * @param {any[]} ary The array to search.\n * @param {any} predicate The predicate.\n */\nexport function findIndexWhere(ary, predicate) {\n    return ary.findIndex(function (item) { return matchesPredicate(item, predicate); });\n}\n/**\n * This function will create a predicate in the form of \"{ [property name]: [value] }\" where the square brackets are\n * replaced with the actual property name and value for the data.\n */\nexport function createPredicate(key, data) {\n    if (!key || !key.length) {\n        throw new Error('Invalid key');\n    }\n    var predicate = {};\n    for (var _i = 0, key_1 = key; _i < key_1.length; _i++) {\n        var propertyName = key_1[_i];\n        if (Object.prototype.hasOwnProperty.call(data, propertyName)) {\n            predicate[propertyName] = data[propertyName];\n        }\n        else {\n            throw new Error(\"Invalid key. The property \\\"\" + propertyName + \"\\\" does not exist in the data.\");\n        }\n    }\n    return predicate;\n}\n/**\n * Determines if an object matches a predicate.\n */\nexport function matchesPredicate(obj, predicate) {\n    return Object.keys(predicate).every(function (key) { return obj[key] === predicate[key]; });\n}\n/**\n * Decorates an object by overriding its property descriptor to add a listener invocation in its dynamically created setter.\n * Note: This does retain existing functionality, and will only work with configurable properties.\n * @param context The `this` context to use for the listener.\n * @param obj The object to decorate.\n * @param prop The property to override.\n * @param listener The listener function that will be executed when the property values changes.\n * @returns A function that can be invoked to return the property to its original property descriptor.\n */\nexport function listenOwnProperty(context, obj, prop, listener) {\n    var propObj = obj;\n    if (!obj.hasOwnProperty(prop)) {\n        propObj = Object.getPrototypeOf(obj);\n    }\n    var originalValueDescriptor = Object.getOwnPropertyDescriptor(propObj, prop);\n    if (!originalValueDescriptor) {\n        throw new Error(\"Property \" + prop + \" does not exist.\");\n    }\n    Object.defineProperty(obj, prop, {\n        configurable: true,\n        get: function () {\n            return originalValueDescriptor.get ? originalValueDescriptor.get.apply(this, arguments) : undefined;\n        },\n        set: function () {\n            if (originalValueDescriptor.set) {\n                originalValueDescriptor.set.apply(this, arguments);\n            }\n            listener.apply(context, arguments);\n        }\n    });\n    return function () { return Object.defineProperty(obj, prop, originalValueDescriptor); };\n}\n","import { findWhere, createPredicate } from './object-utils';\nvar ItemManager = /** @class */ (function () {\n    function ItemManager(_key) {\n        this._key = _key;\n        this._items = [];\n    }\n    /**\n     * Returns all items.\n     */\n    ItemManager.prototype.getItems = function () {\n        return this._items.slice();\n    };\n    /**\n     * Returns the number of items.\n     */\n    ItemManager.prototype.count = function () {\n        return this._items.length;\n    };\n    /**\n     * Sets the item key.\n     * @param key The item key(s).\n     */\n    ItemManager.prototype.setKey = function (key) {\n        this._key = key;\n    };\n    /**\n     * Addes the provided items.\n     * @param data The item data.\n     */\n    ItemManager.prototype.add = function (data) {\n        var _this = this;\n        if (!(data instanceof Array)) {\n            data = [data];\n        }\n        data.forEach(function (item) {\n            if (!_this.exists(item)) {\n                _this._items.push(item);\n            }\n        });\n        return this;\n    };\n    /**\n     * Removes an item from the selections.\n     * @param data The data to be deselected.\n     */\n    ItemManager.prototype.remove = function (data) {\n        if (!(data instanceof Array)) {\n            data = [data];\n        }\n        for (var i = data.length - 1; i >= 0; i--) {\n            if (this.exists(data[i])) {\n                this._items.splice(this._items.indexOf(this._getItem(data[i])), 1);\n            }\n        }\n        return this;\n    };\n    /**\n     * Removes all selected items.\n     */\n    ItemManager.prototype.clear = function () {\n        this._items = [];\n        return this;\n    };\n    /**\n     * Determines if the provided item exists in the selections or not.\n     * @param data The data value.\n     */\n    ItemManager.prototype.exists = function (data) {\n        return this._getItem(data) !== null;\n    };\n    /**\n     * Gets the item from the items collection, or null if not found.\n     * @param data The data value.\n     */\n    ItemManager.prototype._getItem = function (data) {\n        if (this._key) {\n            return findWhere(this._items, createPredicate(this._key, data)) || null;\n        }\n        else {\n            return this._items.find(function (item) { return item === data; }) || null;\n        }\n    };\n    return ItemManager;\n}());\nexport { ItemManager };\n","/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Whether the current platform supports the V8 Break Iterator. The V8 check\n// is necessary to detect all Blink based browsers.\nvar hasV8BreakIterator = (typeof (Intl) !== 'undefined' && Intl.v8BreakIterator);\n/**\n * Class used to detect the current platform by comparing the userAgent strings and\n * checking browser-specific global properties.\n * @docs-private\n */\nvar Platform = /** @class */ (function () {\n    function Platform() {\n    }\n    Object.defineProperty(Platform, \"isBrowser\", {\n        get: function () {\n            return typeof document === 'object' && !!document;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"isMobile\", {\n        get: function () {\n            return Platform.isBrowser && /Mobi/.test(navigator.userAgent);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"EDGE\", {\n        /** Layout Engines */\n        get: function () {\n            return Platform.isBrowser && /(edge)/i.test(navigator.userAgent);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"TRIDENT\", {\n        get: function () {\n            return Platform.isBrowser && /(msie|trident)/i.test(navigator.userAgent);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"BLINK\", {\n        // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.\n        get: function () {\n            return Platform.isBrowser && (!!(window.chrome || hasV8BreakIterator) && !!CSS && !Platform.EDGE && !Platform.TRIDENT);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"WEBKIT\", {\n        // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to\n        // ensure that Webkit runs standalone and is not used as another engine's base.\n        get: function () {\n            return Platform.isBrowser && /AppleWebKit/i.test(navigator.userAgent) && !Platform.BLINK && !Platform.EDGE && !Platform.TRIDENT;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"IOS\", {\n        /** Browsers and Platform Types */\n        get: function () {\n            return Platform.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"FIREFOX\", {\n        // It's difficult to detect the plain Gecko engine, because most of the browsers identify\n        // them self as Gecko-like browsers and modify the userAgent's according to that.\n        // Since we only cover one explicit Firefox case, we can simply check for Firefox\n        // instead of having an unstable check for Gecko.\n        get: function () {\n            return Platform.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(Platform, \"ANDROID\", {\n        // Trident on mobile adds the android platform to the userAgent to trick detections.\n        get: function () {\n            return Platform.isBrowser && /android/i.test(navigator.userAgent) && !Platform.TRIDENT;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake\n    // this and just place the Safari keyword in the userAgent. To be more safe about Safari every\n    // Safari browser should also use Webkit as its layout engine.\n    Platform.prototype.SAFARI = function () {\n        return Platform.isBrowser && /safari/i.test(navigator.userAgent) && Platform.WEBKIT;\n    };\n    return Platform;\n}());\nexport { Platform };\n","import { isDefined, isString } from './utils';\n/**\n * Converts a string value to dash-case.\n * Ex. someTestValue => some-test-value\n * @param {string} value The string to convert\n */\nexport function dashify(value) {\n    if (!isDefined(value) || !isString(value)) {\n        return value;\n    }\n    return value.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();\n}\n/**\n * Left pads a string to the specified length with the specified character.\n * @param {string} value The string to pad.\n * @param {number} length The minimum total length.\n * @param {string} char The character to pad with, space will be used if not specified.\n */\nexport function padLeft(value, length, char) {\n    if (!length || !isDefined(value) || !isString(value)) {\n        return value;\n    }\n    return new Array(length - value.length + 1).join(char || ' ') + value;\n}\n/**\n * Right pads a string to the specified length with the specified character.\n * @param {string} value The string to pad.\n * @param {number} length The minimum total length.\n * @param {string} char The character to pad with, space will be used if not specified.\n */\nexport function padRight(value, length, char) {\n    if (!length || !isDefined(value) || !isString(value)) {\n        return value;\n    }\n    return value + new Array(length - value.length + 1).join(char || ' ');\n}\n"],"sourceRoot":""}