{"version":3,"sources":["webpack:///./node_modules/preact/dist/preact.esm.js","webpack:///./node_modules/memoize-one/dist/memoize-one.esm.js","webpack:///./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:///./node_modules/namespace-emitter/index.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/mime-match/index.js"],"names":["VNode","options","stack","EMPTY_CHILDREN","h","nodeName","attributes","lastSimple","child","simple","i","children","arguments","length","push","pop","undefined","String","p","key","vnode","extend","obj","props","defer","Promise","resolve","then","bind","setTimeout","cloneElement","slice","call","IS_NON_DIMENSIONAL","items","enqueueRender","component","_dirty","debounceRendering","rerender","list","renderComponent","isSameNodeType","node","hydrating","splitText","_componentConstructor","isNamedNode","normalizedNodeName","toLowerCase","getNodeProps","defaultProps","createNode","isSvg","document","createElementNS","createElement","removeNode","parentNode","removeChild","setAccessor","name","old","value","style","cssText","test","innerHTML","__html","useCapture","replace","substring","addEventListener","eventProxy","removeEventListener","_listeners","setProperty","removeAttribute","ns","removeAttributeNS","setAttributeNS","setAttribute","className","e","this","type","event","mounts","diffLevel","isSvgMode","flushMounts","c","afterMount","componentDidMount","diff","dom","context","mountAll","parent","componentRoot","ownerSVGElement","ret","idiff","appendChild","out","prevSvgMode","_component","nodeValue","createTextNode","replaceChild","recollectNodeTree","vnodeName","buildComponentFromVNode","firstChild","fc","vchildren","a","nextSibling","innerDiffNode","dangerouslySetInnerHTML","diffAttributes","isHydrating","j","f","vchild","originalChildren","childNodes","keyed","keyedLen","min","len","childrenLen","vlen","_child","__key","trim","insertBefore","unmountOnly","unmountComponent","ref","removeChildren","lastChild","next","previousSibling","attrs","components","collectComponent","constructor","createComponent","Ctor","inst","prototype","render","Component","doRender","nextBase","splice","state","setComponentProps","opts","_disable","__ref","base","componentWillMount","componentWillReceiveProps","prevContext","prevProps","syncComponentUpdates","isChild","rendered","cbase","previousProps","previousState","prevState","previousContext","isUpdate","initialBase","initialChildComponent","skip","shouldComponentUpdate","componentWillUpdate","getChildContext","toUnmount","childComponent","childProps","_parentComponent","baseParent","componentRef","t","unshift","componentDidUpdate","afterUpdate","_renderCallbacks","originalComponent","oldDom","isDirectOwner","isOwner","beforeUnmount","componentWillUnmount","inner","merge","setState","callback","s","forceUpdate","preact","areInputsEqual","newInputs","lastInputs","memoizeOne","resultFn","isEqual","lastThis","lastResult","lastArgs","calledOnce","memoized","newArgs","_i","apply","MapShim","Map","getIndex","arr","result","some","entry","index","class_1","__entries__","Object","defineProperty","get","enumerable","configurable","set","delete","entries","has","clear","forEach","ctx","_a","isBrowser","window","global$1","global","Math","self","Function","requestAnimationFrame$1","requestAnimationFrame","Date","now","trailingTimeout","throttle","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","REFRESH_DELAY","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","addObserver","observer","indexOf","connect_","removeObserver","observers","disconnect_","changesDetected","updateObservers_","activeObservers","filter","gatherActive","hasActive","broadcastActive","observe","childList","characterData","subtree","disconnect","_b","propertyName","isReflowProperty","getInstance","instance_","defineConfigurable","target","keys","writable","getWindowOf","ownerGlobal","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","parseFloat","getBordersSize","styles","positions","reduce","size","position","getPaddings","paddings","positions_1","getSVGContentRect","bbox","getBBox","width","height","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","horizPad","left","right","vertPad","top","bottom","boxSizing","round","isDocumentElement","vertScrollbar","horizScrollbar","abs","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","documentElement","getContentRect","createReadOnlyRect","x","y","Constr","DOMRectReadOnly","rect","create","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","isActive","broadcastRect","ResizeObserverEntry","rectInit","contentRect","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","TypeError","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","_this","observation","map","WeakMap","ResizeObserver","method","module","exports","emitter","_fns","getListeners","idx","args","l","concat","emitAll","fns","emit","arg1","arg2","arg3","arg4","arg5","arg6","toEmit","on","fn","once","one","off","keep","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","runClearTimeout","marker","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","Item","array","noop","nextTick","Array","title","browser","env","argv","version","versions","addListener","removeListener","removeAllListeners","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","wildcard","reMimePartSplit","pattern","split"],"mappings":"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","file":"js/chunk-vendors~9c5b28f6.7460c82a.js","sourcesContent":["/** Virtual DOM Node */\nfunction VNode() {}\n\n/** Global options\n *\t@public\n *\t@namespace options {Object}\n */\nvar options = {\n\n\t/** If `true`, `prop` changes trigger synchronous component updates.\n  *\t@name syncComponentUpdates\n  *\t@type Boolean\n  *\t@default true\n  */\n\t//syncComponentUpdates: true,\n\n\t/** Processes all created VNodes.\n  *\t@param {VNode} vnode\tA newly-created VNode to normalize/process\n  */\n\t//vnode(vnode) { }\n\n\t/** Hook invoked after a component is mounted. */\n\t// afterMount(component) { }\n\n\t/** Hook invoked after the DOM is updated with a component's latest render. */\n\t// afterUpdate(component) { }\n\n\t/** Hook invoked immediately before a component is unmounted. */\n\t// beforeUnmount(component) { }\n};\n\nvar stack = [];\n\nvar EMPTY_CHILDREN = [];\n\n/**\n * JSX/hyperscript reviver.\n * @see http://jasonformat.com/wtf-is-jsx\n * Benchmarks: https://esbench.com/bench/57ee8f8e330ab09900a1a1a0\n *\n * Note: this is exported as both `h()` and `createElement()` for compatibility reasons.\n *\n * Creates a VNode (virtual DOM element). A tree of VNodes can be used as a lightweight representation\n * of the structure of a DOM tree. This structure can be realized by recursively comparing it against\n * the current _actual_ DOM structure, and applying only the differences.\n *\n * `h()`/`createElement()` accepts an element name, a list of attributes/props,\n * and optionally children to append to the element.\n *\n * @example The following DOM tree\n *\n * `<div id=\"foo\" name=\"bar\">Hello!</div>`\n *\n * can be constructed using this function as:\n *\n * `h('div', { id: 'foo', name : 'bar' }, 'Hello!');`\n *\n * @param {string} nodeName\tAn element name. Ex: `div`, `a`, `span`, etc.\n * @param {Object} attributes\tAny attributes/props to set on the created element.\n * @param rest\t\t\tAdditional arguments are taken to be children to append. Can be infinitely nested Arrays.\n *\n * @public\n */\nfunction h(nodeName, attributes) {\n\tvar children = EMPTY_CHILDREN,\n\t    lastSimple,\n\t    child,\n\t    simple,\n\t    i;\n\tfor (i = arguments.length; i-- > 2;) {\n\t\tstack.push(arguments[i]);\n\t}\n\tif (attributes && attributes.children != null) {\n\t\tif (!stack.length) stack.push(attributes.children);\n\t\tdelete attributes.children;\n\t}\n\twhile (stack.length) {\n\t\tif ((child = stack.pop()) && child.pop !== undefined) {\n\t\t\tfor (i = child.length; i--;) {\n\t\t\t\tstack.push(child[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tif (typeof child === 'boolean') child = null;\n\n\t\t\tif (simple = typeof nodeName !== 'function') {\n\t\t\t\tif (child == null) child = '';else if (typeof child === 'number') child = String(child);else if (typeof child !== 'string') simple = false;\n\t\t\t}\n\n\t\t\tif (simple && lastSimple) {\n\t\t\t\tchildren[children.length - 1] += child;\n\t\t\t} else if (children === EMPTY_CHILDREN) {\n\t\t\t\tchildren = [child];\n\t\t\t} else {\n\t\t\t\tchildren.push(child);\n\t\t\t}\n\n\t\t\tlastSimple = simple;\n\t\t}\n\t}\n\n\tvar p = new VNode();\n\tp.nodeName = nodeName;\n\tp.children = children;\n\tp.attributes = attributes == null ? undefined : attributes;\n\tp.key = attributes == null ? undefined : attributes.key;\n\n\t// if a \"vnode hook\" is defined, pass every created VNode to it\n\tif (options.vnode !== undefined) options.vnode(p);\n\n\treturn p;\n}\n\n/**\n *  Copy all properties from `props` onto `obj`.\n *  @param {Object} obj\t\tObject onto which properties should be copied.\n *  @param {Object} props\tObject from which to copy properties.\n *  @returns obj\n *  @private\n */\nfunction extend(obj, props) {\n  for (var i in props) {\n    obj[i] = props[i];\n  }return obj;\n}\n\n/**\n * Call a function asynchronously, as soon as possible. Makes\n * use of HTML Promise to schedule the callback if available,\n * otherwise falling back to `setTimeout` (mainly for IE<11).\n *\n * @param {Function} callback\n */\nvar defer = typeof Promise == 'function' ? Promise.resolve().then.bind(Promise.resolve()) : setTimeout;\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its children.\n * @param {VNode} vnode\t\tThe virtual DOM element to clone\n * @param {Object} props\tAttributes/props to add when cloning\n * @param {VNode} rest\t\tAny additional arguments will be used as replacement children.\n */\nfunction cloneElement(vnode, props) {\n  return h(vnode.nodeName, extend(extend({}, vnode.attributes), props), arguments.length > 2 ? [].slice.call(arguments, 2) : vnode.children);\n}\n\n// DOM properties that should NOT have \"px\" added when numeric\nvar IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;\n\n/** Managed queue of dirty components to be re-rendered */\n\nvar items = [];\n\nfunction enqueueRender(component) {\n\tif (!component._dirty && (component._dirty = true) && items.push(component) == 1) {\n\t\t(options.debounceRendering || defer)(rerender);\n\t}\n}\n\nfunction rerender() {\n\tvar p,\n\t    list = items;\n\titems = [];\n\twhile (p = list.pop()) {\n\t\tif (p._dirty) renderComponent(p);\n\t}\n}\n\n/**\n * Check if two nodes are equivalent.\n *\n * @param {Node} node\t\t\tDOM Node to compare\n * @param {VNode} vnode\t\t\tVirtual DOM node to compare\n * @param {boolean} [hydrating=false]\tIf true, ignores component constructors when comparing.\n * @private\n */\nfunction isSameNodeType(node, vnode, hydrating) {\n  if (typeof vnode === 'string' || typeof vnode === 'number') {\n    return node.splitText !== undefined;\n  }\n  if (typeof vnode.nodeName === 'string') {\n    return !node._componentConstructor && isNamedNode(node, vnode.nodeName);\n  }\n  return hydrating || node._componentConstructor === vnode.nodeName;\n}\n\n/**\n * Check if an Element has a given nodeName, case-insensitively.\n *\n * @param {Element} node\tA DOM Element to inspect the name of.\n * @param {String} nodeName\tUnnormalized name to compare against.\n */\nfunction isNamedNode(node, nodeName) {\n  return node.normalizedNodeName === nodeName || node.nodeName.toLowerCase() === nodeName.toLowerCase();\n}\n\n/**\n * Reconstruct Component-style `props` from a VNode.\n * Ensures default/fallback values from `defaultProps`:\n * Own-properties of `defaultProps` not present in `vnode.attributes` are added.\n *\n * @param {VNode} vnode\n * @returns {Object} props\n */\nfunction getNodeProps(vnode) {\n  var props = extend({}, vnode.attributes);\n  props.children = vnode.children;\n\n  var defaultProps = vnode.nodeName.defaultProps;\n  if (defaultProps !== undefined) {\n    for (var i in defaultProps) {\n      if (props[i] === undefined) {\n        props[i] = defaultProps[i];\n      }\n    }\n  }\n\n  return props;\n}\n\n/** Create an element with the given nodeName.\n *\t@param {String} nodeName\n *\t@param {Boolean} [isSvg=false]\tIf `true`, creates an element within the SVG namespace.\n *\t@returns {Element} node\n */\nfunction createNode(nodeName, isSvg) {\n\tvar node = isSvg ? document.createElementNS('http://www.w3.org/2000/svg', nodeName) : document.createElement(nodeName);\n\tnode.normalizedNodeName = nodeName;\n\treturn node;\n}\n\n/** Remove a child node from its parent if attached.\n *\t@param {Element} node\t\tThe node to remove\n */\nfunction removeNode(node) {\n\tvar parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\n/** Set a named attribute on the given Node, with special behavior for some names and event handlers.\n *\tIf `value` is `null`, the attribute/handler will be removed.\n *\t@param {Element} node\tAn element to mutate\n *\t@param {string} name\tThe name/key to set, such as an event or attribute name\n *\t@param {any} old\tThe last value that was set for this name/node pair\n *\t@param {any} value\tAn attribute value, such as a function to be used as an event handler\n *\t@param {Boolean} isSvg\tAre we currently diffing inside an svg?\n *\t@private\n */\nfunction setAccessor(node, name, old, value, isSvg) {\n\tif (name === 'className') name = 'class';\n\n\tif (name === 'key') {\n\t\t// ignore\n\t} else if (name === 'ref') {\n\t\tif (old) old(null);\n\t\tif (value) value(node);\n\t} else if (name === 'class' && !isSvg) {\n\t\tnode.className = value || '';\n\t} else if (name === 'style') {\n\t\tif (!value || typeof value === 'string' || typeof old === 'string') {\n\t\t\tnode.style.cssText = value || '';\n\t\t}\n\t\tif (value && typeof value === 'object') {\n\t\t\tif (typeof old !== 'string') {\n\t\t\t\tfor (var i in old) {\n\t\t\t\t\tif (!(i in value)) node.style[i] = '';\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (var i in value) {\n\t\t\t\tnode.style[i] = typeof value[i] === 'number' && IS_NON_DIMENSIONAL.test(i) === false ? value[i] + 'px' : value[i];\n\t\t\t}\n\t\t}\n\t} else if (name === 'dangerouslySetInnerHTML') {\n\t\tif (value) node.innerHTML = value.__html || '';\n\t} else if (name[0] == 'o' && name[1] == 'n') {\n\t\tvar useCapture = name !== (name = name.replace(/Capture$/, ''));\n\t\tname = name.toLowerCase().substring(2);\n\t\tif (value) {\n\t\t\tif (!old) node.addEventListener(name, eventProxy, useCapture);\n\t\t} else {\n\t\t\tnode.removeEventListener(name, eventProxy, useCapture);\n\t\t}\n\t\t(node._listeners || (node._listeners = {}))[name] = value;\n\t} else if (name !== 'list' && name !== 'type' && !isSvg && name in node) {\n\t\tsetProperty(node, name, value == null ? '' : value);\n\t\tif (value == null || value === false) node.removeAttribute(name);\n\t} else {\n\t\tvar ns = isSvg && name !== (name = name.replace(/^xlink:?/, ''));\n\t\tif (value == null || value === false) {\n\t\t\tif (ns) node.removeAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase());else node.removeAttribute(name);\n\t\t} else if (typeof value !== 'function') {\n\t\t\tif (ns) node.setAttributeNS('http://www.w3.org/1999/xlink', name.toLowerCase(), value);else node.setAttribute(name, value);\n\t\t}\n\t}\n}\n\n/** Attempt to set a DOM property to the given value.\n *\tIE & FF throw for certain property-value combinations.\n */\nfunction setProperty(node, name, value) {\n\ttry {\n\t\tnode[name] = value;\n\t} catch (e) {}\n}\n\n/** Proxy an event to hooked event handlers\n *\t@private\n */\nfunction eventProxy(e) {\n\treturn this._listeners[e.type](options.event && options.event(e) || e);\n}\n\n/** Queue of components that have been mounted and are awaiting componentDidMount */\nvar mounts = [];\n\n/** Diff recursion count, used to track the end of the diff cycle. */\nvar diffLevel = 0;\n\n/** Global flag indicating if the diff is currently within an SVG */\nvar isSvgMode = false;\n\n/** Global flag indicating if the diff is performing hydration */\nvar hydrating = false;\n\n/** Invoke queued componentDidMount lifecycle methods */\nfunction flushMounts() {\n\tvar c;\n\twhile (c = mounts.pop()) {\n\t\tif (options.afterMount) options.afterMount(c);\n\t\tif (c.componentDidMount) c.componentDidMount();\n\t}\n}\n\n/** Apply differences in a given vnode (and it's deep children) to a real DOM Node.\n *\t@param {Element} [dom=null]\t\tA DOM node to mutate into the shape of the `vnode`\n *\t@param {VNode} vnode\t\t\tA VNode (with descendants forming a tree) representing the desired DOM structure\n *\t@returns {Element} dom\t\t\tThe created/mutated element\n *\t@private\n */\nfunction diff(dom, vnode, context, mountAll, parent, componentRoot) {\n\t// diffLevel having been 0 here indicates initial entry into the diff (not a subdiff)\n\tif (!diffLevel++) {\n\t\t// when first starting the diff, check if we're diffing an SVG or within an SVG\n\t\tisSvgMode = parent != null && parent.ownerSVGElement !== undefined;\n\n\t\t// hydration is indicated by the existing element to be diffed not having a prop cache\n\t\thydrating = dom != null && !('__preactattr_' in dom);\n\t}\n\n\tvar ret = idiff(dom, vnode, context, mountAll, componentRoot);\n\n\t// append the element if its a new parent\n\tif (parent && ret.parentNode !== parent) parent.appendChild(ret);\n\n\t// diffLevel being reduced to 0 means we're exiting the diff\n\tif (! --diffLevel) {\n\t\thydrating = false;\n\t\t// invoke queued componentDidMount lifecycle methods\n\t\tif (!componentRoot) flushMounts();\n\t}\n\n\treturn ret;\n}\n\n/** Internals of `diff()`, separated to allow bypassing diffLevel / mount flushing. */\nfunction idiff(dom, vnode, context, mountAll, componentRoot) {\n\tvar out = dom,\n\t    prevSvgMode = isSvgMode;\n\n\t// empty values (null, undefined, booleans) render as empty Text nodes\n\tif (vnode == null || typeof vnode === 'boolean') vnode = '';\n\n\t// Fast case: Strings & Numbers create/update Text nodes.\n\tif (typeof vnode === 'string' || typeof vnode === 'number') {\n\n\t\t// update if it's already a Text node:\n\t\tif (dom && dom.splitText !== undefined && dom.parentNode && (!dom._component || componentRoot)) {\n\t\t\t/* istanbul ignore if */ /* Browser quirk that can't be covered: https://github.com/developit/preact/commit/fd4f21f5c45dfd75151bd27b4c217d8003aa5eb9 */\n\t\t\tif (dom.nodeValue != vnode) {\n\t\t\t\tdom.nodeValue = vnode;\n\t\t\t}\n\t\t} else {\n\t\t\t// it wasn't a Text node: replace it with one and recycle the old Element\n\t\t\tout = document.createTextNode(vnode);\n\t\t\tif (dom) {\n\t\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\t\t\t\trecollectNodeTree(dom, true);\n\t\t\t}\n\t\t}\n\n\t\tout['__preactattr_'] = true;\n\n\t\treturn out;\n\t}\n\n\t// If the VNode represents a Component, perform a component diff:\n\tvar vnodeName = vnode.nodeName;\n\tif (typeof vnodeName === 'function') {\n\t\treturn buildComponentFromVNode(dom, vnode, context, mountAll);\n\t}\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tisSvgMode = vnodeName === 'svg' ? true : vnodeName === 'foreignObject' ? false : isSvgMode;\n\n\t// If there's no existing element or it's the wrong type, create a new one:\n\tvnodeName = String(vnodeName);\n\tif (!dom || !isNamedNode(dom, vnodeName)) {\n\t\tout = createNode(vnodeName, isSvgMode);\n\n\t\tif (dom) {\n\t\t\t// move children into the replacement node\n\t\t\twhile (dom.firstChild) {\n\t\t\t\tout.appendChild(dom.firstChild);\n\t\t\t} // if the previous Element was mounted into the DOM, replace it inline\n\t\t\tif (dom.parentNode) dom.parentNode.replaceChild(out, dom);\n\n\t\t\t// recycle the old element (skips non-Element node types)\n\t\t\trecollectNodeTree(dom, true);\n\t\t}\n\t}\n\n\tvar fc = out.firstChild,\n\t    props = out['__preactattr_'],\n\t    vchildren = vnode.children;\n\n\tif (props == null) {\n\t\tprops = out['__preactattr_'] = {};\n\t\tfor (var a = out.attributes, i = a.length; i--;) {\n\t\t\tprops[a[i].name] = a[i].value;\n\t\t}\n\t}\n\n\t// Optimization: fast-path for elements containing a single TextNode:\n\tif (!hydrating && vchildren && vchildren.length === 1 && typeof vchildren[0] === 'string' && fc != null && fc.splitText !== undefined && fc.nextSibling == null) {\n\t\tif (fc.nodeValue != vchildren[0]) {\n\t\t\tfc.nodeValue = vchildren[0];\n\t\t}\n\t}\n\t// otherwise, if there are existing or new children, diff them:\n\telse if (vchildren && vchildren.length || fc != null) {\n\t\t\tinnerDiffNode(out, vchildren, context, mountAll, hydrating || props.dangerouslySetInnerHTML != null);\n\t\t}\n\n\t// Apply attributes/props from VNode to the DOM Element:\n\tdiffAttributes(out, vnode.attributes, props);\n\n\t// restore previous SVG mode: (in case we're exiting an SVG namespace)\n\tisSvgMode = prevSvgMode;\n\n\treturn out;\n}\n\n/** Apply child and attribute changes between a VNode and a DOM Node to the DOM.\n *\t@param {Element} dom\t\t\tElement whose children should be compared & mutated\n *\t@param {Array} vchildren\t\tArray of VNodes to compare to `dom.childNodes`\n *\t@param {Object} context\t\t\tImplicitly descendant context object (from most recent `getChildContext()`)\n *\t@param {Boolean} mountAll\n *\t@param {Boolean} isHydrating\tIf `true`, consumes externally created elements similar to hydration\n */\nfunction innerDiffNode(dom, vchildren, context, mountAll, isHydrating) {\n\tvar originalChildren = dom.childNodes,\n\t    children = [],\n\t    keyed = {},\n\t    keyedLen = 0,\n\t    min = 0,\n\t    len = originalChildren.length,\n\t    childrenLen = 0,\n\t    vlen = vchildren ? vchildren.length : 0,\n\t    j,\n\t    c,\n\t    f,\n\t    vchild,\n\t    child;\n\n\t// Build up a map of keyed children and an Array of unkeyed children:\n\tif (len !== 0) {\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tvar _child = originalChildren[i],\n\t\t\t    props = _child['__preactattr_'],\n\t\t\t    key = vlen && props ? _child._component ? _child._component.__key : props.key : null;\n\t\t\tif (key != null) {\n\t\t\t\tkeyedLen++;\n\t\t\t\tkeyed[key] = _child;\n\t\t\t} else if (props || (_child.splitText !== undefined ? isHydrating ? _child.nodeValue.trim() : true : isHydrating)) {\n\t\t\t\tchildren[childrenLen++] = _child;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (vlen !== 0) {\n\t\tfor (var i = 0; i < vlen; i++) {\n\t\t\tvchild = vchildren[i];\n\t\t\tchild = null;\n\n\t\t\t// attempt to find a node based on key matching\n\t\t\tvar key = vchild.key;\n\t\t\tif (key != null) {\n\t\t\t\tif (keyedLen && keyed[key] !== undefined) {\n\t\t\t\t\tchild = keyed[key];\n\t\t\t\t\tkeyed[key] = undefined;\n\t\t\t\t\tkeyedLen--;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// attempt to pluck a node of the same type from the existing children\n\t\t\telse if (!child && min < childrenLen) {\n\t\t\t\t\tfor (j = min; j < childrenLen; j++) {\n\t\t\t\t\t\tif (children[j] !== undefined && isSameNodeType(c = children[j], vchild, isHydrating)) {\n\t\t\t\t\t\t\tchild = c;\n\t\t\t\t\t\t\tchildren[j] = undefined;\n\t\t\t\t\t\t\tif (j === childrenLen - 1) childrenLen--;\n\t\t\t\t\t\t\tif (j === min) min++;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// morph the matched/found/created DOM child to match vchild (deep)\n\t\t\tchild = idiff(child, vchild, context, mountAll);\n\n\t\t\tf = originalChildren[i];\n\t\t\tif (child && child !== dom && child !== f) {\n\t\t\t\tif (f == null) {\n\t\t\t\t\tdom.appendChild(child);\n\t\t\t\t} else if (child === f.nextSibling) {\n\t\t\t\t\tremoveNode(f);\n\t\t\t\t} else {\n\t\t\t\t\tdom.insertBefore(child, f);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// remove unused keyed children:\n\tif (keyedLen) {\n\t\tfor (var i in keyed) {\n\t\t\tif (keyed[i] !== undefined) recollectNodeTree(keyed[i], false);\n\t\t}\n\t}\n\n\t// remove orphaned unkeyed children:\n\twhile (min <= childrenLen) {\n\t\tif ((child = children[childrenLen--]) !== undefined) recollectNodeTree(child, false);\n\t}\n}\n\n/** Recursively recycle (or just unmount) a node and its descendants.\n *\t@param {Node} node\t\t\t\t\t\tDOM node to start unmount/removal from\n *\t@param {Boolean} [unmountOnly=false]\tIf `true`, only triggers unmount lifecycle, skips removal\n */\nfunction recollectNodeTree(node, unmountOnly) {\n\tvar component = node._component;\n\tif (component) {\n\t\t// if node is owned by a Component, unmount that component (ends up recursing back here)\n\t\tunmountComponent(component);\n\t} else {\n\t\t// If the node's VNode had a ref function, invoke it with null here.\n\t\t// (this is part of the React spec, and smart for unsetting references)\n\t\tif (node['__preactattr_'] != null && node['__preactattr_'].ref) node['__preactattr_'].ref(null);\n\n\t\tif (unmountOnly === false || node['__preactattr_'] == null) {\n\t\t\tremoveNode(node);\n\t\t}\n\n\t\tremoveChildren(node);\n\t}\n}\n\n/** Recollect/unmount all children.\n *\t- we use .lastChild here because it causes less reflow than .firstChild\n *\t- it's also cheaper than accessing the .childNodes Live NodeList\n */\nfunction removeChildren(node) {\n\tnode = node.lastChild;\n\twhile (node) {\n\t\tvar next = node.previousSibling;\n\t\trecollectNodeTree(node, true);\n\t\tnode = next;\n\t}\n}\n\n/** Apply differences in attributes from a VNode to the given DOM Element.\n *\t@param {Element} dom\t\tElement with attributes to diff `attrs` against\n *\t@param {Object} attrs\t\tThe desired end-state key-value attribute pairs\n *\t@param {Object} old\t\t\tCurrent/previous attributes (from previous VNode or element's prop cache)\n */\nfunction diffAttributes(dom, attrs, old) {\n\tvar name;\n\n\t// remove attributes no longer present on the vnode by setting them to undefined\n\tfor (name in old) {\n\t\tif (!(attrs && attrs[name] != null) && old[name] != null) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = undefined, isSvgMode);\n\t\t}\n\t}\n\n\t// add new & update changed attributes\n\tfor (name in attrs) {\n\t\tif (name !== 'children' && name !== 'innerHTML' && (!(name in old) || attrs[name] !== (name === 'value' || name === 'checked' ? dom[name] : old[name]))) {\n\t\t\tsetAccessor(dom, name, old[name], old[name] = attrs[name], isSvgMode);\n\t\t}\n\t}\n}\n\n/** Retains a pool of Components for re-use, keyed on component name.\n *\tNote: since component names are not unique or even necessarily available, these are primarily a form of sharding.\n *\t@private\n */\nvar components = {};\n\n/** Reclaim a component for later re-use by the recycler. */\nfunction collectComponent(component) {\n\tvar name = component.constructor.name;\n\t(components[name] || (components[name] = [])).push(component);\n}\n\n/** Create a component. Normalizes differences between PFC's and classful Components. */\nfunction createComponent(Ctor, props, context) {\n\tvar list = components[Ctor.name],\n\t    inst;\n\n\tif (Ctor.prototype && Ctor.prototype.render) {\n\t\tinst = new Ctor(props, context);\n\t\tComponent.call(inst, props, context);\n\t} else {\n\t\tinst = new Component(props, context);\n\t\tinst.constructor = Ctor;\n\t\tinst.render = doRender;\n\t}\n\n\tif (list) {\n\t\tfor (var i = list.length; i--;) {\n\t\t\tif (list[i].constructor === Ctor) {\n\t\t\t\tinst.nextBase = list[i].nextBase;\n\t\t\t\tlist.splice(i, 1);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treturn inst;\n}\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n\n/** Set a component's `props` (generally derived from JSX attributes).\n *\t@param {Object} props\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.renderSync=false]\tIf `true` and {@link options.syncComponentUpdates} is `true`, triggers synchronous rendering.\n *\t@param {boolean} [opts.render=true]\t\t\tIf `false`, no render will be triggered.\n */\nfunction setComponentProps(component, props, opts, context, mountAll) {\n\tif (component._disable) return;\n\tcomponent._disable = true;\n\n\tif (component.__ref = props.ref) delete props.ref;\n\tif (component.__key = props.key) delete props.key;\n\n\tif (!component.base || mountAll) {\n\t\tif (component.componentWillMount) component.componentWillMount();\n\t} else if (component.componentWillReceiveProps) {\n\t\tcomponent.componentWillReceiveProps(props, context);\n\t}\n\n\tif (context && context !== component.context) {\n\t\tif (!component.prevContext) component.prevContext = component.context;\n\t\tcomponent.context = context;\n\t}\n\n\tif (!component.prevProps) component.prevProps = component.props;\n\tcomponent.props = props;\n\n\tcomponent._disable = false;\n\n\tif (opts !== 0) {\n\t\tif (opts === 1 || options.syncComponentUpdates !== false || !component.base) {\n\t\t\trenderComponent(component, 1, mountAll);\n\t\t} else {\n\t\t\tenqueueRender(component);\n\t\t}\n\t}\n\n\tif (component.__ref) component.__ref(component);\n}\n\n/** Render a Component, triggering necessary lifecycle events and taking High-Order Components into account.\n *\t@param {Component} component\n *\t@param {Object} [opts]\n *\t@param {boolean} [opts.build=false]\t\tIf `true`, component will build and store a DOM node if not already associated with one.\n *\t@private\n */\nfunction renderComponent(component, opts, mountAll, isChild) {\n\tif (component._disable) return;\n\n\tvar props = component.props,\n\t    state = component.state,\n\t    context = component.context,\n\t    previousProps = component.prevProps || props,\n\t    previousState = component.prevState || state,\n\t    previousContext = component.prevContext || context,\n\t    isUpdate = component.base,\n\t    nextBase = component.nextBase,\n\t    initialBase = isUpdate || nextBase,\n\t    initialChildComponent = component._component,\n\t    skip = false,\n\t    rendered,\n\t    inst,\n\t    cbase;\n\n\t// if updating\n\tif (isUpdate) {\n\t\tcomponent.props = previousProps;\n\t\tcomponent.state = previousState;\n\t\tcomponent.context = previousContext;\n\t\tif (opts !== 2 && component.shouldComponentUpdate && component.shouldComponentUpdate(props, state, context) === false) {\n\t\t\tskip = true;\n\t\t} else if (component.componentWillUpdate) {\n\t\t\tcomponent.componentWillUpdate(props, state, context);\n\t\t}\n\t\tcomponent.props = props;\n\t\tcomponent.state = state;\n\t\tcomponent.context = context;\n\t}\n\n\tcomponent.prevProps = component.prevState = component.prevContext = component.nextBase = null;\n\tcomponent._dirty = false;\n\n\tif (!skip) {\n\t\trendered = component.render(props, state, context);\n\n\t\t// context to pass to the child, can be updated via (grand-)parent component\n\t\tif (component.getChildContext) {\n\t\t\tcontext = extend(extend({}, context), component.getChildContext());\n\t\t}\n\n\t\tvar childComponent = rendered && rendered.nodeName,\n\t\t    toUnmount,\n\t\t    base;\n\n\t\tif (typeof childComponent === 'function') {\n\t\t\t// set up high order component link\n\n\t\t\tvar childProps = getNodeProps(rendered);\n\t\t\tinst = initialChildComponent;\n\n\t\t\tif (inst && inst.constructor === childComponent && childProps.key == inst.__key) {\n\t\t\t\tsetComponentProps(inst, childProps, 1, context, false);\n\t\t\t} else {\n\t\t\t\ttoUnmount = inst;\n\n\t\t\t\tcomponent._component = inst = createComponent(childComponent, childProps, context);\n\t\t\t\tinst.nextBase = inst.nextBase || nextBase;\n\t\t\t\tinst._parentComponent = component;\n\t\t\t\tsetComponentProps(inst, childProps, 0, context, false);\n\t\t\t\trenderComponent(inst, 1, mountAll, true);\n\t\t\t}\n\n\t\t\tbase = inst.base;\n\t\t} else {\n\t\t\tcbase = initialBase;\n\n\t\t\t// destroy high order component link\n\t\t\ttoUnmount = initialChildComponent;\n\t\t\tif (toUnmount) {\n\t\t\t\tcbase = component._component = null;\n\t\t\t}\n\n\t\t\tif (initialBase || opts === 1) {\n\t\t\t\tif (cbase) cbase._component = null;\n\t\t\t\tbase = diff(cbase, rendered, context, mountAll || !isUpdate, initialBase && initialBase.parentNode, true);\n\t\t\t}\n\t\t}\n\n\t\tif (initialBase && base !== initialBase && inst !== initialChildComponent) {\n\t\t\tvar baseParent = initialBase.parentNode;\n\t\t\tif (baseParent && base !== baseParent) {\n\t\t\t\tbaseParent.replaceChild(base, initialBase);\n\n\t\t\t\tif (!toUnmount) {\n\t\t\t\t\tinitialBase._component = null;\n\t\t\t\t\trecollectNodeTree(initialBase, false);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (toUnmount) {\n\t\t\tunmountComponent(toUnmount);\n\t\t}\n\n\t\tcomponent.base = base;\n\t\tif (base && !isChild) {\n\t\t\tvar componentRef = component,\n\t\t\t    t = component;\n\t\t\twhile (t = t._parentComponent) {\n\t\t\t\t(componentRef = t).base = base;\n\t\t\t}\n\t\t\tbase._component = componentRef;\n\t\t\tbase._componentConstructor = componentRef.constructor;\n\t\t}\n\t}\n\n\tif (!isUpdate || mountAll) {\n\t\tmounts.unshift(component);\n\t} else if (!skip) {\n\t\t// Ensure that pending componentDidMount() hooks of child components\n\t\t// are called before the componentDidUpdate() hook in the parent.\n\t\t// Note: disabled as it causes duplicate hooks, see https://github.com/developit/preact/issues/750\n\t\t// flushMounts();\n\n\t\tif (component.componentDidUpdate) {\n\t\t\tcomponent.componentDidUpdate(previousProps, previousState, previousContext);\n\t\t}\n\t\tif (options.afterUpdate) options.afterUpdate(component);\n\t}\n\n\tif (component._renderCallbacks != null) {\n\t\twhile (component._renderCallbacks.length) {\n\t\t\tcomponent._renderCallbacks.pop().call(component);\n\t\t}\n\t}\n\n\tif (!diffLevel && !isChild) flushMounts();\n}\n\n/** Apply the Component referenced by a VNode to the DOM.\n *\t@param {Element} dom\tThe DOM node to mutate\n *\t@param {VNode} vnode\tA Component-referencing VNode\n *\t@returns {Element} dom\tThe created/mutated element\n *\t@private\n */\nfunction buildComponentFromVNode(dom, vnode, context, mountAll) {\n\tvar c = dom && dom._component,\n\t    originalComponent = c,\n\t    oldDom = dom,\n\t    isDirectOwner = c && dom._componentConstructor === vnode.nodeName,\n\t    isOwner = isDirectOwner,\n\t    props = getNodeProps(vnode);\n\twhile (c && !isOwner && (c = c._parentComponent)) {\n\t\tisOwner = c.constructor === vnode.nodeName;\n\t}\n\n\tif (c && isOwner && (!mountAll || c._component)) {\n\t\tsetComponentProps(c, props, 3, context, mountAll);\n\t\tdom = c.base;\n\t} else {\n\t\tif (originalComponent && !isDirectOwner) {\n\t\t\tunmountComponent(originalComponent);\n\t\t\tdom = oldDom = null;\n\t\t}\n\n\t\tc = createComponent(vnode.nodeName, props, context);\n\t\tif (dom && !c.nextBase) {\n\t\t\tc.nextBase = dom;\n\t\t\t// passing dom/oldDom as nextBase will recycle it if unused, so bypass recycling on L229:\n\t\t\toldDom = null;\n\t\t}\n\t\tsetComponentProps(c, props, 1, context, mountAll);\n\t\tdom = c.base;\n\n\t\tif (oldDom && dom !== oldDom) {\n\t\t\toldDom._component = null;\n\t\t\trecollectNodeTree(oldDom, false);\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n/** Remove a component from the DOM and recycle it.\n *\t@param {Component} component\tThe Component instance to unmount\n *\t@private\n */\nfunction unmountComponent(component) {\n\tif (options.beforeUnmount) options.beforeUnmount(component);\n\n\tvar base = component.base;\n\n\tcomponent._disable = true;\n\n\tif (component.componentWillUnmount) component.componentWillUnmount();\n\n\tcomponent.base = null;\n\n\t// recursively tear down & recollect high-order component children:\n\tvar inner = component._component;\n\tif (inner) {\n\t\tunmountComponent(inner);\n\t} else if (base) {\n\t\tif (base['__preactattr_'] && base['__preactattr_'].ref) base['__preactattr_'].ref(null);\n\n\t\tcomponent.nextBase = base;\n\n\t\tremoveNode(base);\n\t\tcollectComponent(component);\n\n\t\tremoveChildren(base);\n\t}\n\n\tif (component.__ref) component.__ref(null);\n}\n\n/** Base Component class.\n *\tProvides `setState()` and `forceUpdate()`, which trigger rendering.\n *\t@public\n *\n *\t@example\n *\tclass MyFoo extends Component {\n *\t\trender(props, state) {\n *\t\t\treturn <div />;\n *\t\t}\n *\t}\n */\nfunction Component(props, context) {\n\tthis._dirty = true;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.context = context;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.props = props;\n\n\t/** @public\n  *\t@type {object}\n  */\n\tthis.state = this.state || {};\n}\n\nextend(Component.prototype, {\n\n\t/** Returns a `boolean` indicating if the component should re-render when receiving the given `props` and `state`.\n  *\t@param {object} nextProps\n  *\t@param {object} nextState\n  *\t@param {object} nextContext\n  *\t@returns {Boolean} should the component re-render\n  *\t@name shouldComponentUpdate\n  *\t@function\n  */\n\n\t/** Update component state by copying properties from `state` to `this.state`.\n  *\t@param {object} state\t\tA hash of state properties to update with new values\n  *\t@param {function} callback\tA function to be called once component state is updated\n  */\n\tsetState: function setState(state, callback) {\n\t\tvar s = this.state;\n\t\tif (!this.prevState) this.prevState = extend({}, s);\n\t\textend(s, typeof state === 'function' ? state(s, this.props) : state);\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\tenqueueRender(this);\n\t},\n\n\n\t/** Immediately perform a synchronous re-render of the component.\n  *\t@param {function} callback\t\tA function to be called after component is re-rendered.\n  *\t@private\n  */\n\tforceUpdate: function forceUpdate(callback) {\n\t\tif (callback) (this._renderCallbacks = this._renderCallbacks || []).push(callback);\n\t\trenderComponent(this, 2);\n\t},\n\n\n\t/** Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n  *\tVirtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n  *\t@param {object} props\t\tProps (eg: JSX attributes) received from parent element/component\n  *\t@param {object} state\t\tThe component's current state\n  *\t@param {object} context\t\tContext object (if a parent component has provided context)\n  *\t@returns VNode\n  */\n\trender: function render() {}\n});\n\n/** Render JSX into a `parent` Element.\n *\t@param {VNode} vnode\t\tA (JSX) VNode to render\n *\t@param {Element} parent\t\tDOM element to render into\n *\t@param {Element} [merge]\tAttempt to re-use an existing DOM tree rooted at `merge`\n *\t@public\n *\n *\t@example\n *\t// render a div into <body>:\n *\trender(<div id=\"hello\">hello!</div>, document.body);\n *\n *\t@example\n *\t// render a \"Thing\" component into #foo:\n *\tconst Thing = ({ name }) => <span>{ name }</span>;\n *\trender(<Thing name=\"one\" />, document.querySelector('#foo'));\n */\nfunction render(vnode, parent, merge) {\n  return diff(merge, vnode, {}, false, parent, false);\n}\n\nvar preact = {\n\th: h,\n\tcreateElement: h,\n\tcloneElement: cloneElement,\n\tComponent: Component,\n\trender: render,\n\trerender: rerender,\n\toptions: options\n};\n\nexport default preact;\nexport { h, h as createElement, cloneElement, Component, render, rerender, options };\n//# sourceMappingURL=preact.esm.js.map\n","function areInputsEqual(newInputs, lastInputs) {\n    if (newInputs.length !== lastInputs.length) {\n        return false;\n    }\n    for (var i = 0; i < newInputs.length; i++) {\n        if (newInputs[i] !== lastInputs[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n    if (isEqual === void 0) { isEqual = areInputsEqual; }\n    var lastThis;\n    var lastArgs = [];\n    var lastResult;\n    var calledOnce = false;\n    function memoized() {\n        var newArgs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            newArgs[_i] = arguments[_i];\n        }\n        if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {\n            return lastResult;\n        }\n        lastResult = resultFn.apply(this, newArgs);\n        calledOnce = true;\n        lastThis = this;\n        lastArgs = newArgs;\n        return lastResult;\n    }\n    return memoized;\n}\n\nexport default memoizeOne;\n","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\n","/**\n* Create an event emitter with namespaces\n* @name createNamespaceEmitter\n* @example\n* var emitter = require('./index')()\n*\n* emitter.on('*', function () {\n*   console.log('all events emitted', this.event)\n* })\n*\n* emitter.on('example', function () {\n*   console.log('example event emitted')\n* })\n*/\nmodule.exports = function createNamespaceEmitter () {\n  var emitter = {}\n  var _fns = emitter._fns = {}\n\n  /**\n  * Emit an event. Optionally namespace the event. Handlers are fired in the order in which they were added with exact matches taking precedence. Separate the namespace and event with a `:`\n  * @name emit\n  * @param {String} event – the name of the event, with optional namespace\n  * @param {...*} data – up to 6 arguments that are passed to the event listener\n  * @example\n  * emitter.emit('example')\n  * emitter.emit('demo:test')\n  * emitter.emit('data', { example: true}, 'a string', 1)\n  */\n  emitter.emit = function emit (event, arg1, arg2, arg3, arg4, arg5, arg6) {\n    var toEmit = getListeners(event)\n\n    if (toEmit.length) {\n      emitAll(event, toEmit, [arg1, arg2, arg3, arg4, arg5, arg6])\n    }\n  }\n\n  /**\n  * Create en event listener.\n  * @name on\n  * @param {String} event\n  * @param {Function} fn\n  * @example\n  * emitter.on('example', function () {})\n  * emitter.on('demo', function () {})\n  */\n  emitter.on = function on (event, fn) {\n    if (!_fns[event]) {\n      _fns[event] = []\n    }\n\n    _fns[event].push(fn)\n  }\n\n  /**\n  * Create en event listener that fires once.\n  * @name once\n  * @param {String} event\n  * @param {Function} fn\n  * @example\n  * emitter.once('example', function () {})\n  * emitter.once('demo', function () {})\n  */\n  emitter.once = function once (event, fn) {\n    function one () {\n      fn.apply(this, arguments)\n      emitter.off(event, one)\n    }\n    this.on(event, one)\n  }\n\n  /**\n  * Stop listening to an event. Stop all listeners on an event by only passing the event name. Stop a single listener by passing that event handler as a callback.\n  * You must be explicit about what will be unsubscribed: `emitter.off('demo')` will unsubscribe an `emitter.on('demo')` listener,\n  * `emitter.off('demo:example')` will unsubscribe an `emitter.on('demo:example')` listener\n  * @name off\n  * @param {String} event\n  * @param {Function} [fn] – the specific handler\n  * @example\n  * emitter.off('example')\n  * emitter.off('demo', function () {})\n  */\n  emitter.off = function off (event, fn) {\n    var keep = []\n\n    if (event && fn) {\n      var fns = this._fns[event]\n      var i = 0\n      var l = fns ? fns.length : 0\n\n      for (i; i < l; i++) {\n        if (fns[i] !== fn) {\n          keep.push(fns[i])\n        }\n      }\n    }\n\n    keep.length ? this._fns[event] = keep : delete this._fns[event]\n  }\n\n  function getListeners (e) {\n    var out = _fns[e] ? _fns[e] : []\n    var idx = e.indexOf(':')\n    var args = (idx === -1) ? [e] : [e.substring(0, idx), e.substring(idx + 1)]\n\n    var keys = Object.keys(_fns)\n    var i = 0\n    var l = keys.length\n\n    for (i; i < l; i++) {\n      var key = keys[i]\n      if (key === '*') {\n        out = out.concat(_fns[key])\n      }\n\n      if (args.length === 2 && args[0] === key) {\n        out = out.concat(_fns[key])\n        break\n      }\n    }\n\n    return out\n  }\n\n  function emitAll (e, fns, args) {\n    var i = 0\n    var l = fns.length\n\n    for (i; i < l; i++) {\n      if (!fns[i]) break\n      fns[i].event = e\n      fns[i].apply(fns[i], args)\n    }\n  }\n\n  return emitter\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","var wildcard = require('wildcard');\nvar reMimePartSplit = /[\\/\\+\\.]/;\n\n/**\n  # mime-match\n\n  A simple function to checker whether a target mime type matches a mime-type\n  pattern (e.g. image/jpeg matches image/jpeg OR image/*).\n\n  ## Example Usage\n\n  <<< example.js\n\n**/\nmodule.exports = function(target, pattern) {\n  function test(pattern) {\n    var result = wildcard(pattern, target, reMimePartSplit);\n\n    // ensure that we have a valid mime type (should have two parts)\n    return result && result.length >= 2;\n  }\n\n  return pattern ? test(pattern.split(';')[0]) : test;\n};\n"],"sourceRoot":""}