@spscommerce/positioning 5.18.2 → 5.18.3-ie

package/lib/index.cjs.js

@@ -1 +1,1857 @@
-"use strict";var j=Object.defineProperty,V=Object.defineProperties;var G=Object.getOwnPropertyDescriptors;var C=Object.getOwnPropertySymbols;var z=Object.prototype.hasOwnProperty,W=Object.prototype.propertyIsEnumerable;var S=(e,i,r)=>i in e?j(e,i,{enumerable:!0,configurable:!0,writable:!0,value:r}):e[i]=r,D=(e,i)=>{for(var r in i||(i={}))z.call(i,r)&&S(e,r,i[r]);if(C)for(var r of C(i))W.call(i,r)&&S(e,r,i[r]);return e},F=(e,i)=>V(e,G(i));Object.defineProperty(exports,"__esModule",{value:!0});exports[Symbol.toStringTag]="Module";var N=require("@spscommerce/utils");exports.Position=void 0;(function(e){e.TOP_LEFT="top left",e.TOP_MIDDLE="top middle",e.TOP_RIGHT="top right",e.RIGHT_TOP="right top",e.RIGHT_MIDDLE="right middle",e.RIGHT_BOTTOM="right bottom",e.BOTTOM_RIGHT="bottom right",e.BOTTOM_MIDDLE="bottom middle",e.BOTTOM_LEFT="bottom left",e.LEFT_BOTTOM="left bottom",e.LEFT_MIDDLE="left middle",e.LEFT_TOP="left top"})(exports.Position||(exports.Position={}));exports.PositionAnchor=void 0;(function(e){e.TOP_LEFT="top left",e.TOP_RIGHT="top right",e.BOTTOM_LEFT="bottom left",e.BOTTOM_RIGHT="bottom right"})(exports.PositionAnchor||(exports.PositionAnchor={}));const H={anchor:exports.PositionAnchor.TOP_LEFT,offsets:[],position:exports.Position.TOP_LEFT};(function(){if(typeof window!="object")return;if("IntersectionObserver"in window&&"IntersectionObserverEntry"in window&&"intersectionRatio"in window.IntersectionObserverEntry.prototype){"isIntersecting"in window.IntersectionObserverEntry.prototype||Object.defineProperty(window.IntersectionObserverEntry.prototype,"isIntersecting",{get:function(){return this.intersectionRatio>0}});return}function e(t){try{return t.defaultView&&t.defaultView.frameElement||null}catch{return null}}var i=function(t){for(var o=t,n=e(o);n;)o=n.ownerDocument,n=e(o);return o}(window.document),r=[],f=null,g=null;function b(t){this.time=t.time,this.target=t.target,this.rootBounds=m(t.rootBounds),this.boundingClientRect=m(t.boundingClientRect),this.intersectionRect=m(t.intersectionRect||w()),this.isIntersecting=!!t.intersectionRect;var o=this.boundingClientRect,n=o.width*o.height,c=this.intersectionRect,a=c.width*c.height;n?this.intersectionRatio=Number((a/n).toFixed(4)):this.intersectionRatio=this.isIntersecting?1:0}function l(t,o){var n=o||{};if(typeof t!="function")throw new Error("callback must be a function");if(n.root&&n.root.nodeType!=1&&n.root.nodeType!=9)throw new Error("root must be a Document or Element");this._checkForIntersections=d(this._checkForIntersections.bind(this),this.THROTTLE_TIMEOUT),this._callback=t,this._observationTargets=[],this._queuedEntries=[],this._rootMarginValues=this._parseRootMargin(n.rootMargin),this.thresholds=this._initThresholds(n.threshold),this.root=n.root||null,this.rootMargin=this._rootMarginValues.map(function(c){return c.value+c.unit}).join(" "),this._monitoringDocuments=[],this._monitoringUnsubscribes=[]}l.prototype.THROTTLE_TIMEOUT=100,l.prototype.POLL_INTERVAL=null,l.prototype.USE_MUTATION_OBSERVER=!0,l._setupCrossOriginUpdater=function(){return f||(f=function(t,o){!t||!o?g=w():g=x(t,o),r.forEach(function(n){n._checkForIntersections()})}),f},l._resetCrossOriginUpdater=function(){f=null,g=null},l.prototype.observe=function(t){var o=this._observationTargets.some(function(n){return n.element==t});if(!o){if(!(t&&t.nodeType==1))throw new Error("target must be an Element");this._registerInstance(),this._observationTargets.push({element:t,entry:null}),this._monitorIntersections(t.ownerDocument),this._checkForIntersections()}},l.prototype.unobserve=function(t){this._observationTargets=this._observationTargets.filter(function(o){return o.element!=t}),this._unmonitorIntersections(t.ownerDocument),this._observationTargets.length==0&&this._unregisterInstance()},l.prototype.disconnect=function(){this._observationTargets=[],this._unmonitorAllIntersections(),this._unregisterInstance()},l.prototype.takeRecords=function(){var t=this._queuedEntries.slice();return this._queuedEntries=[],t},l.prototype._initThresholds=function(t){var o=t||[0];return Array.isArray(o)||(o=[o]),o.sort().filter(function(n,c,a){if(typeof n!="number"||isNaN(n)||n<0||n>1)throw new Error("threshold must be a number between 0 and 1 inclusively");return n!==a[c-1]})},l.prototype._parseRootMargin=function(t){var o=t||"0px",n=o.split(/\s+/).map(function(c){var a=/^(-?\d*\.?\d+)(px|%)$/.exec(c);if(!a)throw new Error("rootMargin must be specified in pixels or percent");return{value:parseFloat(a[1]),unit:a[2]}});return n[1]=n[1]||n[0],n[2]=n[2]||n[0],n[3]=n[3]||n[1],n},l.prototype._monitorIntersections=function(t){var o=t.defaultView;if(!!o&&this._monitoringDocuments.indexOf(t)==-1){var n=this._checkForIntersections,c=null,a=null;this.POLL_INTERVAL?c=o.setInterval(n,this.POLL_INTERVAL):(u(o,"resize",n,!0),u(t,"scroll",n,!0),this.USE_MUTATION_OBSERVER&&"MutationObserver"in o&&(a=new o.MutationObserver(n),a.observe(t,{attributes:!0,childList:!0,characterData:!0,subtree:!0}))),this._monitoringDocuments.push(t),this._monitoringUnsubscribes.push(function(){var O=t.defaultView;O&&(c&&O.clearInterval(c),p(O,"resize",n,!0)),p(t,"scroll",n,!0),a&&a.disconnect()});var E=this.root&&(this.root.ownerDocument||this.root)||i;if(t!=E){var y=e(t);y&&this._monitorIntersections(y.ownerDocument)}}},l.prototype._unmonitorIntersections=function(t){var o=this._monitoringDocuments.indexOf(t);if(o!=-1){var n=this.root&&(this.root.ownerDocument||this.root)||i,c=this._observationTargets.some(function(y){var O=y.element.ownerDocument;if(O==t)return!0;for(;O&&O!=n;){var R=e(O);if(O=R&&R.ownerDocument,O==t)return!0}return!1});if(!c){var a=this._monitoringUnsubscribes[o];if(this._monitoringDocuments.splice(o,1),this._monitoringUnsubscribes.splice(o,1),a(),t!=n){var E=e(t);E&&this._unmonitorIntersections(E.ownerDocument)}}}},l.prototype._unmonitorAllIntersections=function(){var t=this._monitoringUnsubscribes.slice(0);this._monitoringDocuments.length=0,this._monitoringUnsubscribes.length=0;for(var o=0;o<t.length;o++)t[o]()},l.prototype._checkForIntersections=function(){if(!(!this.root&&f&&!g)){var t=this._rootIsInDom(),o=t?this._getRootRect():w();this._observationTargets.forEach(function(n){var c=n.element,a=T(c),E=this._rootContainsTarget(c),y=n.entry,O=t&&E&&this._computeTargetAndRootIntersection(c,a,o),R=null;this._rootContainsTarget(c)?(!f||this.root)&&(R=o):R=w();var L=n.entry=new b({time:_(),target:c,boundingClientRect:a,rootBounds:R,intersectionRect:O});y?t&&E?this._hasCrossedThreshold(y,L)&&this._queuedEntries.push(L):y&&y.isIntersecting&&this._queuedEntries.push(L):this._queuedEntries.push(L)},this),this._queuedEntries.length&&this._callback(this.takeRecords(),this)}},l.prototype._computeTargetAndRootIntersection=function(t,o,n){if(window.getComputedStyle(t).display!="none"){for(var c=o,a=I(t),E=!1;!E&&a;){var y=null,O=a.nodeType==1?window.getComputedStyle(a):{};if(O.display=="none")return null;if(a==this.root||a.nodeType==9)if(E=!0,a==this.root||a==i)f&&!this.root?!g||g.width==0&&g.height==0?(a=null,y=null,c=null):y=g:y=n;else{var R=I(a),L=R&&T(R),k=R&&this._computeTargetAndRootIntersection(R,L,n);L&&k?(a=R,y=x(L,k)):(a=null,c=null)}else{var B=a.ownerDocument;a!=B.body&&a!=B.documentElement&&O.overflow!="visible"&&(y=T(a))}if(y&&(c=v(y,c)),!c)break;a=a&&I(a)}return c}},l.prototype._getRootRect=function(){var t;if(this.root&&!P(this.root))t=T(this.root);else{var o=P(this.root)?this.root:i,n=o.documentElement,c=o.body;t={top:0,left:0,right:n.clientWidth||c.clientWidth,width:n.clientWidth||c.clientWidth,bottom:n.clientHeight||c.clientHeight,height:n.clientHeight||c.clientHeight}}return this._expandRectByRootMargin(t)},l.prototype._expandRectByRootMargin=function(t){var o=this._rootMarginValues.map(function(c,a){return c.unit=="px"?c.value:c.value*(a%2?t.width:t.height)/100}),n={top:t.top-o[0],right:t.right+o[1],bottom:t.bottom+o[2],left:t.left-o[3]};return n.width=n.right-n.left,n.height=n.bottom-n.top,n},l.prototype._hasCrossedThreshold=function(t,o){var n=t&&t.isIntersecting?t.intersectionRatio||0:-1,c=o.isIntersecting?o.intersectionRatio||0:-1;if(n!==c)for(var a=0;a<this.thresholds.length;a++){var E=this.thresholds[a];if(E==n||E==c||E<n!=E<c)return!0}},l.prototype._rootIsInDom=function(){return!this.root||h(i,this.root)},l.prototype._rootContainsTarget=function(t){var o=this.root&&(this.root.ownerDocument||this.root)||i;return h(o,t)&&(!this.root||o==t.ownerDocument)},l.prototype._registerInstance=function(){r.indexOf(this)<0&&r.push(this)},l.prototype._unregisterInstance=function(){var t=r.indexOf(this);t!=-1&&r.splice(t,1)};function _(){return window.performance&&performance.now&&performance.now()}function d(t,o){var n=null;return function(){n||(n=setTimeout(function(){t(),n=null},o))}}function u(t,o,n,c){typeof t.addEventListener=="function"?t.addEventListener(o,n,c||!1):typeof t.attachEvent=="function"&&t.attachEvent("on"+o,n)}function p(t,o,n,c){typeof t.removeEventListener=="function"?t.removeEventListener(o,n,c||!1):typeof t.detatchEvent=="function"&&t.detatchEvent("on"+o,n)}function v(t,o){var n=Math.max(t.top,o.top),c=Math.min(t.bottom,o.bottom),a=Math.max(t.left,o.left),E=Math.min(t.right,o.right),y=E-a,O=c-n;return y>=0&&O>=0&&{top:n,bottom:c,left:a,right:E,width:y,height:O}||null}function T(t){var o;try{o=t.getBoundingClientRect()}catch{}return o?(o.width&&o.height||(o={top:o.top,right:o.right,bottom:o.bottom,left:o.left,width:o.right-o.left,height:o.bottom-o.top}),o):w()}function w(){return{top:0,bottom:0,left:0,right:0,width:0,height:0}}function m(t){return!t||"x"in t?t:{top:t.top,y:t.top,bottom:t.bottom,left:t.left,x:t.left,right:t.right,width:t.width,height:t.height}}function x(t,o){var n=o.top-t.top,c=o.left-t.left;return{top:n,left:c,height:o.height,width:o.width,bottom:n+o.height,right:c+o.width}}function h(t,o){for(var n=o;n;){if(n==t)return!0;n=I(n)}return!1}function I(t){var o=t.parentNode;return t.nodeType==9&&t!=i?e(t):(o&&o.assignedSlot&&(o=o.assignedSlot.parentNode),o&&o.nodeType==11&&o.host?o.host:o)}function P(t){return t&&t.nodeType===9}window.IntersectionObserver=l,window.IntersectionObserverEntry=b})();var U={exports:{}};(function(e){var i=Object.prototype.hasOwnProperty,r="~";function f(){}Object.create&&(f.prototype=Object.create(null),new f().__proto__||(r=!1));function g(d,u,p){this.fn=d,this.context=u,this.once=p||!1}function b(d,u,p,v,T){if(typeof p!="function")throw new TypeError("The listener must be a function");var w=new g(p,v||d,T),m=r?r+u:u;return d._events[m]?d._events[m].fn?d._events[m]=[d._events[m],w]:d._events[m].push(w):(d._events[m]=w,d._eventsCount++),d}function l(d,u){--d._eventsCount==0?d._events=new f:delete d._events[u]}function _(){this._events=new f,this._eventsCount=0}_.prototype.eventNames=function(){var u=[],p,v;if(this._eventsCount===0)return u;for(v in p=this._events)i.call(p,v)&&u.push(r?v.slice(1):v);return Object.getOwnPropertySymbols?u.concat(Object.getOwnPropertySymbols(p)):u},_.prototype.listeners=function(u){var p=r?r+u:u,v=this._events[p];if(!v)return[];if(v.fn)return[v.fn];for(var T=0,w=v.length,m=new Array(w);T<w;T++)m[T]=v[T].fn;return m},_.prototype.listenerCount=function(u){var p=r?r+u:u,v=this._events[p];return v?v.fn?1:v.length:0},_.prototype.emit=function(u,p,v,T,w,m){var x=r?r+u:u;if(!this._events[x])return!1;var h=this._events[x],I=arguments.length,P,t;if(h.fn){switch(h.once&&this.removeListener(u,h.fn,void 0,!0),I){case 1:return h.fn.call(h.context),!0;case 2:return h.fn.call(h.context,p),!0;case 3:return h.fn.call(h.context,p,v),!0;case 4:return h.fn.call(h.context,p,v,T),!0;case 5:return h.fn.call(h.context,p,v,T,w),!0;case 6:return h.fn.call(h.context,p,v,T,w,m),!0}for(t=1,P=new Array(I-1);t<I;t++)P[t-1]=arguments[t];h.fn.apply(h.context,P)}else{var o=h.length,n;for(t=0;t<o;t++)switch(h[t].once&&this.removeListener(u,h[t].fn,void 0,!0),I){case 1:h[t].fn.call(h[t].context);break;case 2:h[t].fn.call(h[t].context,p);break;case 3:h[t].fn.call(h[t].context,p,v);break;case 4:h[t].fn.call(h[t].context,p,v,T);break;default:if(!P)for(n=1,P=new Array(I-1);n<I;n++)P[n-1]=arguments[n];h[t].fn.apply(h[t].context,P)}}return!0},_.prototype.on=function(u,p,v){return b(this,u,p,v,!1)},_.prototype.once=function(u,p,v){return b(this,u,p,v,!0)},_.prototype.removeListener=function(u,p,v,T){var w=r?r+u:u;if(!this._events[w])return this;if(!p)return l(this,w),this;var m=this._events[w];if(m.fn)m.fn===p&&(!T||m.once)&&(!v||m.context===v)&&l(this,w);else{for(var x=0,h=[],I=m.length;x<I;x++)(m[x].fn!==p||T&&!m[x].once||v&&m[x].context!==v)&&h.push(m[x]);h.length?this._events[w]=h.length===1?h[0]:h:l(this,w)}return this},_.prototype.removeAllListeners=function(u){var p;return u?(p=r?r+u:u,this._events[p]&&l(this,p)):(this._events=new f,this._eventsCount=0),this},_.prototype.off=_.prototype.removeListener,_.prototype.addListener=_.prototype.on,_.prefixed=r,_.EventEmitter=_,e.exports=_})(U);var $=Object.defineProperty,q=Object.getOwnPropertyDescriptor,Y=(e,i,r,f)=>{for(var g=f>1?void 0:f?q(i,r):i,b=e.length-1,l;b>=0;b--)(l=e[b])&&(g=(f?l(i,r,g):l(g))||g);return f&&g&&$(i,r,g),g};const A=60,s=class{static on(e,i){s.events.on(e,i)}static off(e,i){s.events.off(e,i)}static once(e,i){s.events.once(e,i)}static checkCollisions(e,i){const r=i||Array.from(s.elements.keys()),f=e.getBoundingClientRect(),g=[];for(const b of r)if(b!==e){const l=b.getBoundingClientRect();l.left<=f.right&&l.right>=f.left&&l.top<=f.bottom&&l.bottom>=f.top&&g.push(b)}g.length&&s.onElementIntersection(e,g)}static isPositioned(e){return s.elements.has(e)}static getPositioningOptions(e){return s.elements.has(e)?s.elements.get(e):null}static position(e,i={}){const r=D(D({},H),i);let f=e;for(;f!==document.body;)if(f=f.parentElement,f.classList.contains("sps-focused-task")){r.scrollParent=f,s.registeredScrollParents.has(f)||(s.registeredScrollParents.add(f),f.addEventListener("scroll",s.update));break}if(e.style.visibility="hidden",s.elements.size===0&&(window.addEventListener("resize",s.update),window.addEventListener("scroll",s.update)),!r.relativeTo)throw new Error("You must provide an element for the relativeTo option to position an element.");s.elements.set(e,r),N.onNextTick(()=>{s.fixElementPosition(e),s.viewportObserver.observe(e),e.style.visibility="",s.checkCollisions(e)})}static release(e){if(s.elements.has(e)){s.clearStyles(e);const i=s.elements.get(e);i.scrollParent&&(i.scrollParent.removeEventListener("scroll",s.update),s.registeredScrollParents.delete(i.scrollParent)),s.elements.delete(e),s.elements.size===0&&(window.removeEventListener("resize",s.update),window.removeEventListener("scroll",s.update)),s.viewportObserver.unobserve(e)}}static releaseAll(){for(const e of s.elements.keys())s.release(e)}static refresh(e){s.elements.has(e)&&(s.clearStyles(e),s.fixElementPosition(e),s.checkCollisions(e))}static refreshAll(){for(const e of s.elements.keys())s.refresh(e)}static reposition(e,i){if(s.elements.has(e)){const r=s.elements.get(e);s.elements.set(e,Object.assign(r,i)),s.refresh(e)}}static onViewportIntersection(e){for(const i of e){const r=Object.keys(IntersectionObserverEntry.prototype).reduce((f,g)=>F(D({},f),{[g]:i[g]}),{});r.rootBounds=r.rootBounds||s.getRootBounds(),s.events.emit("viewportIntersection",Object.freeze(r))}}static onElementIntersection(e,i){s.events.emit("elementIntersection",{target:e,intersectingWith:i})}static getRootBounds(){const e=Math.max(document.documentElement.clientWidth,window.innerWidth||0),i=Math.max(document.documentElement.clientHeight,window.innerHeight||0);return{x:0,y:A,left:0,top:A,right:e,bottom:i,height:i-A,width:e}}static clearStyles(e){Object.assign(e.style,{position:"",width:"",top:"",left:"",right:"",bottom:"",visibility:"",zIndex:""})}static fixElementPosition(e,i){if(!this.elements.has(e))return;const r=i||this.elements.get(e),f=this.getRootBounds(),g=e.getBoundingClientRect(),b=r.relativeTo.getBoundingClientRect(),{width:l}=r.useRelativeTargetWidth?b:g;Object.assign(e.style,{minWidth:`${l}px`,position:"fixed",zIndex:r.zIndex||""});let _,d;const u=r.position.split(" "),p=r.offsets[0]||0,v=r.offsets[1]||0;switch(_=0,d=0,u[0]){case"top":_=b.top-g.height-p;break;case"left":d=b.left-l-p;break;case"right":d=b.right+p;break;case"bottom":_=b.bottom+p;break;default:throw new Error(`${r.position} is not a valid position`)}switch(u[1]){case"left":d=b.left-v;break;case"top":_=b.top-v;break;case"middle":u[0]==="top"||u[0]==="bottom"?d=b.left+b.width/2-l/2+v:(u[0]==="left"||u[0]==="right")&&(_=b.top+b.height/2-g.height/2+v);break;case"bottom":_=b.bottom-g.height+v;break;case"right":d=b.right-l+v;break;default:throw new Error(`${r.position} is not a valid position`)}const T=_+g.height,w=d+g.width,m=`${Math.round(_)}px`,x=`${Math.round(f.bottom-T)}px`,h=`${Math.round(d)}px`,I=`${Math.round(f.right-w)}px`;switch(r.anchor){case exports.PositionAnchor.TOP_LEFT:Object.assign(e.style,{top:m,bottom:"auto",left:h,right:"auto"});break;case exports.PositionAnchor.TOP_RIGHT:Object.assign(e.style,{top:m,bottom:"auto",left:"auto",right:I});break;case exports.PositionAnchor.BOTTOM_LEFT:Object.assign(e.style,{top:"auto",bottom:x,left:h,right:"auto"});break;case exports.PositionAnchor.BOTTOM_RIGHT:Object.assign(e.style,{top:"auto",bottom:x,left:"auto",right:I});break}}static update(e){const i=s.elements.entries(),r=[];for(const[f,g]of i)(!e||e.target===document||e.target===g.scrollParent||e.target===window)&&(s.fixElementPosition(f,g),s.checkCollisions(f,r),r.push(f))}on(e,i){s.on(e,i)}off(e,i){s.off(e,i)}once(e,i){s.once(e,i)}isPositioned(e){return s.isPositioned(e)}getPositioningOptions(e){return s.getPositioningOptions(e)}position(e,i={}){s.position(e,i)}release(e){s.release(e)}releaseAll(){s.releaseAll()}refresh(e){s.refresh(e)}refreshAll(){s.refreshAll()}reposition(e,i){s.reposition(e,i)}};let M=s;M.elements=new Map;M.registeredScrollParents=new Set;M.events=new U.exports.EventEmitter;M.viewportObserver=new IntersectionObserver(s.onViewportIntersection,{rootMargin:`-${A}px 0px 0px`,threshold:1});Y([N.lockedToAnimationFrames],M,"update",1);exports.DEFAULT_POSITIONING_OPTIONS=H;exports.PositioningService=M;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@spscommerce/utils');
+
+/**
+ * These are the possibilities for the `position` option of
+ * `PositioningOptions` when using `relativeTo`.
+ */
+exports.Position = void 0;
+(function (Position) {
+    Position["TOP_LEFT"] = "top left";
+    Position["TOP_MIDDLE"] = "top middle";
+    Position["TOP_RIGHT"] = "top right";
+    Position["RIGHT_TOP"] = "right top";
+    Position["RIGHT_MIDDLE"] = "right middle";
+    Position["RIGHT_BOTTOM"] = "right bottom";
+    Position["BOTTOM_RIGHT"] = "bottom right";
+    Position["BOTTOM_MIDDLE"] = "bottom middle";
+    Position["BOTTOM_LEFT"] = "bottom left";
+    Position["LEFT_BOTTOM"] = "left bottom";
+    Position["LEFT_MIDDLE"] = "left middle";
+    Position["LEFT_TOP"] = "left top";
+})(exports.Position || (exports.Position = {}));
+
+/** Indicates which point on a positioned element it should be positioned by. */
+exports.PositionAnchor = void 0;
+(function (PositionAnchor) {
+    PositionAnchor["TOP_LEFT"] = "top left";
+    PositionAnchor["TOP_RIGHT"] = "top right";
+    PositionAnchor["BOTTOM_LEFT"] = "bottom left";
+    PositionAnchor["BOTTOM_RIGHT"] = "bottom right";
+})(exports.PositionAnchor || (exports.PositionAnchor = {}));
+
+var DEFAULT_POSITIONING_OPTIONS = {
+    anchor: exports.PositionAnchor.TOP_LEFT,
+    offsets: [],
+    position: exports.Position.TOP_LEFT,
+};
+
+/**
+ * Copyright 2016 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.
+ *
+ *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document
+ *
+ */
+(function() {
+
+// Exit early if we're not running in a browser.
+if (typeof window !== 'object') {
+  return;
+}
+
+// Exit early if all IntersectionObserver and IntersectionObserverEntry
+// features are natively supported.
+if ('IntersectionObserver' in window &&
+    'IntersectionObserverEntry' in window &&
+    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {
+
+  // Minimal polyfill for Edge 15's lack of `isIntersecting`
+  // See: https://github.com/w3c/IntersectionObserver/issues/211
+  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {
+    Object.defineProperty(window.IntersectionObserverEntry.prototype,
+      'isIntersecting', {
+      get: function () {
+        return this.intersectionRatio > 0;
+      }
+    });
+  }
+  return;
+}
+
+/**
+ * Returns the embedding frame element, if any.
+ * @param {!Document} doc
+ * @return {!Element}
+ */
+function getFrameElement(doc) {
+  try {
+    return doc.defaultView && doc.defaultView.frameElement || null;
+  } catch (e) {
+    // Ignore the error.
+    return null;
+  }
+}
+
+/**
+ * A local reference to the root document.
+ */
+var document = (function(startDoc) {
+  var doc = startDoc;
+  var frame = getFrameElement(doc);
+  while (frame) {
+    doc = frame.ownerDocument;
+    frame = getFrameElement(doc);
+  }
+  return doc;
+})(window.document);
+
+/**
+ * An IntersectionObserver registry. This registry exists to hold a strong
+ * reference to IntersectionObserver instances currently observing a target
+ * element. Without this registry, instances without another reference may be
+ * garbage collected.
+ */
+var registry = [];
+
+/**
+ * The signal updater for cross-origin intersection. When not null, it means
+ * that the polyfill is configured to work in a cross-origin mode.
+ * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}
+ */
+var crossOriginUpdater = null;
+
+/**
+ * The current cross-origin intersection. Only used in the cross-origin mode.
+ * @type {DOMRect|ClientRect}
+ */
+var crossOriginRect = null;
+
+
+/**
+ * Creates the global IntersectionObserverEntry constructor.
+ * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry
+ * @param {Object} entry A dictionary of instance properties.
+ * @constructor
+ */
+function IntersectionObserverEntry(entry) {
+  this.time = entry.time;
+  this.target = entry.target;
+  this.rootBounds = ensureDOMRect(entry.rootBounds);
+  this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);
+  this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());
+  this.isIntersecting = !!entry.intersectionRect;
+
+  // Calculates the intersection ratio.
+  var targetRect = this.boundingClientRect;
+  var targetArea = targetRect.width * targetRect.height;
+  var intersectionRect = this.intersectionRect;
+  var intersectionArea = intersectionRect.width * intersectionRect.height;
+
+  // Sets intersection ratio.
+  if (targetArea) {
+    // Round the intersection ratio to avoid floating point math issues:
+    // https://github.com/w3c/IntersectionObserver/issues/324
+    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));
+  } else {
+    // If area is zero and is intersecting, sets to 1, otherwise to 0
+    this.intersectionRatio = this.isIntersecting ? 1 : 0;
+  }
+}
+
+
+/**
+ * Creates the global IntersectionObserver constructor.
+ * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface
+ * @param {Function} callback The function to be invoked after intersection
+ *     changes have queued. The function is not invoked if the queue has
+ *     been emptied by calling the `takeRecords` method.
+ * @param {Object=} opt_options Optional configuration options.
+ * @constructor
+ */
+function IntersectionObserver(callback, opt_options) {
+
+  var options = opt_options || {};
+
+  if (typeof callback != 'function') {
+    throw new Error('callback must be a function');
+  }
+
+  if (
+    options.root &&
+    options.root.nodeType != 1 &&
+    options.root.nodeType != 9
+  ) {
+    throw new Error('root must be a Document or Element');
+  }
+
+  // Binds and throttles `this._checkForIntersections`.
+  this._checkForIntersections = throttle(
+      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);
+
+  // Private properties.
+  this._callback = callback;
+  this._observationTargets = [];
+  this._queuedEntries = [];
+  this._rootMarginValues = this._parseRootMargin(options.rootMargin);
+
+  // Public properties.
+  this.thresholds = this._initThresholds(options.threshold);
+  this.root = options.root || null;
+  this.rootMargin = this._rootMarginValues.map(function(margin) {
+    return margin.value + margin.unit;
+  }).join(' ');
+
+  /** @private @const {!Array<!Document>} */
+  this._monitoringDocuments = [];
+  /** @private @const {!Array<function()>} */
+  this._monitoringUnsubscribes = [];
+}
+
+
+/**
+ * The minimum interval within which the document will be checked for
+ * intersection changes.
+ */
+IntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;
+
+
+/**
+ * The frequency in which the polyfill polls for intersection changes.
+ * this can be updated on a per instance basis and must be set prior to
+ * calling `observe` on the first target.
+ */
+IntersectionObserver.prototype.POLL_INTERVAL = null;
+
+/**
+ * Use a mutation observer on the root element
+ * to detect intersection changes.
+ */
+IntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;
+
+
+/**
+ * Sets up the polyfill in the cross-origin mode. The result is the
+ * updater function that accepts two arguments: `boundingClientRect` and
+ * `intersectionRect` - just as these fields would be available to the
+ * parent via `IntersectionObserverEntry`. This function should be called
+ * each time the iframe receives intersection information from the parent
+ * window, e.g. via messaging.
+ * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}
+ */
+IntersectionObserver._setupCrossOriginUpdater = function() {
+  if (!crossOriginUpdater) {
+    /**
+     * @param {DOMRect|ClientRect} boundingClientRect
+     * @param {DOMRect|ClientRect} intersectionRect
+     */
+    crossOriginUpdater = function(boundingClientRect, intersectionRect) {
+      if (!boundingClientRect || !intersectionRect) {
+        crossOriginRect = getEmptyRect();
+      } else {
+        crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);
+      }
+      registry.forEach(function(observer) {
+        observer._checkForIntersections();
+      });
+    };
+  }
+  return crossOriginUpdater;
+};
+
+
+/**
+ * Resets the cross-origin mode.
+ */
+IntersectionObserver._resetCrossOriginUpdater = function() {
+  crossOriginUpdater = null;
+  crossOriginRect = null;
+};
+
+
+/**
+ * Starts observing a target element for intersection changes based on
+ * the thresholds values.
+ * @param {Element} target The DOM element to observe.
+ */
+IntersectionObserver.prototype.observe = function(target) {
+  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {
+    return item.element == target;
+  });
+
+  if (isTargetAlreadyObserved) {
+    return;
+  }
+
+  if (!(target && target.nodeType == 1)) {
+    throw new Error('target must be an Element');
+  }
+
+  this._registerInstance();
+  this._observationTargets.push({element: target, entry: null});
+  this._monitorIntersections(target.ownerDocument);
+  this._checkForIntersections();
+};
+
+
+/**
+ * Stops observing a target element for intersection changes.
+ * @param {Element} target The DOM element to observe.
+ */
+IntersectionObserver.prototype.unobserve = function(target) {
+  this._observationTargets =
+      this._observationTargets.filter(function(item) {
+        return item.element != target;
+      });
+  this._unmonitorIntersections(target.ownerDocument);
+  if (this._observationTargets.length == 0) {
+    this._unregisterInstance();
+  }
+};
+
+
+/**
+ * Stops observing all target elements for intersection changes.
+ */
+IntersectionObserver.prototype.disconnect = function() {
+  this._observationTargets = [];
+  this._unmonitorAllIntersections();
+  this._unregisterInstance();
+};
+
+
+/**
+ * Returns any queue entries that have not yet been reported to the
+ * callback and clears the queue. This can be used in conjunction with the
+ * callback to obtain the absolute most up-to-date intersection information.
+ * @return {Array} The currently queued entries.
+ */
+IntersectionObserver.prototype.takeRecords = function() {
+  var records = this._queuedEntries.slice();
+  this._queuedEntries = [];
+  return records;
+};
+
+
+/**
+ * Accepts the threshold value from the user configuration object and
+ * returns a sorted array of unique threshold values. If a value is not
+ * between 0 and 1 and error is thrown.
+ * @private
+ * @param {Array|number=} opt_threshold An optional threshold value or
+ *     a list of threshold values, defaulting to [0].
+ * @return {Array} A sorted list of unique and valid threshold values.
+ */
+IntersectionObserver.prototype._initThresholds = function(opt_threshold) {
+  var threshold = opt_threshold || [0];
+  if (!Array.isArray(threshold)) threshold = [threshold];
+
+  return threshold.sort().filter(function(t, i, a) {
+    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {
+      throw new Error('threshold must be a number between 0 and 1 inclusively');
+    }
+    return t !== a[i - 1];
+  });
+};
+
+
+/**
+ * Accepts the rootMargin value from the user configuration object
+ * and returns an array of the four margin values as an object containing
+ * the value and unit properties. If any of the values are not properly
+ * formatted or use a unit other than px or %, and error is thrown.
+ * @private
+ * @param {string=} opt_rootMargin An optional rootMargin value,
+ *     defaulting to '0px'.
+ * @return {Array<Object>} An array of margin objects with the keys
+ *     value and unit.
+ */
+IntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {
+  var marginString = opt_rootMargin || '0px';
+  var margins = marginString.split(/\s+/).map(function(margin) {
+    var parts = /^(-?\d*\.?\d+)(px|%)$/.exec(margin);
+    if (!parts) {
+      throw new Error('rootMargin must be specified in pixels or percent');
+    }
+    return {value: parseFloat(parts[1]), unit: parts[2]};
+  });
+
+  // Handles shorthand.
+  margins[1] = margins[1] || margins[0];
+  margins[2] = margins[2] || margins[0];
+  margins[3] = margins[3] || margins[1];
+
+  return margins;
+};
+
+
+/**
+ * Starts polling for intersection changes if the polling is not already
+ * happening, and if the page's visibility state is visible.
+ * @param {!Document} doc
+ * @private
+ */
+IntersectionObserver.prototype._monitorIntersections = function(doc) {
+  var win = doc.defaultView;
+  if (!win) {
+    // Already destroyed.
+    return;
+  }
+  if (this._monitoringDocuments.indexOf(doc) != -1) {
+    // Already monitoring.
+    return;
+  }
+
+  // Private state for monitoring.
+  var callback = this._checkForIntersections;
+  var monitoringInterval = null;
+  var domObserver = null;
+
+  // If a poll interval is set, use polling instead of listening to
+  // resize and scroll events or DOM mutations.
+  if (this.POLL_INTERVAL) {
+    monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);
+  } else {
+    addEvent(win, 'resize', callback, true);
+    addEvent(doc, 'scroll', callback, true);
+    if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {
+      domObserver = new win.MutationObserver(callback);
+      domObserver.observe(doc, {
+        attributes: true,
+        childList: true,
+        characterData: true,
+        subtree: true
+      });
+    }
+  }
+
+  this._monitoringDocuments.push(doc);
+  this._monitoringUnsubscribes.push(function() {
+    // Get the window object again. When a friendly iframe is destroyed, it
+    // will be null.
+    var win = doc.defaultView;
+
+    if (win) {
+      if (monitoringInterval) {
+        win.clearInterval(monitoringInterval);
+      }
+      removeEvent(win, 'resize', callback, true);
+    }
+
+    removeEvent(doc, 'scroll', callback, true);
+    if (domObserver) {
+      domObserver.disconnect();
+    }
+  });
+
+  // Also monitor the parent.
+  var rootDoc =
+    (this.root && (this.root.ownerDocument || this.root)) || document;
+  if (doc != rootDoc) {
+    var frame = getFrameElement(doc);
+    if (frame) {
+      this._monitorIntersections(frame.ownerDocument);
+    }
+  }
+};
+
+
+/**
+ * Stops polling for intersection changes.
+ * @param {!Document} doc
+ * @private
+ */
+IntersectionObserver.prototype._unmonitorIntersections = function(doc) {
+  var index = this._monitoringDocuments.indexOf(doc);
+  if (index == -1) {
+    return;
+  }
+
+  var rootDoc =
+    (this.root && (this.root.ownerDocument || this.root)) || document;
+
+  // Check if any dependent targets are still remaining.
+  var hasDependentTargets =
+      this._observationTargets.some(function(item) {
+        var itemDoc = item.element.ownerDocument;
+        // Target is in this context.
+        if (itemDoc == doc) {
+          return true;
+        }
+        // Target is nested in this context.
+        while (itemDoc && itemDoc != rootDoc) {
+          var frame = getFrameElement(itemDoc);
+          itemDoc = frame && frame.ownerDocument;
+          if (itemDoc == doc) {
+            return true;
+          }
+        }
+        return false;
+      });
+  if (hasDependentTargets) {
+    return;
+  }
+
+  // Unsubscribe.
+  var unsubscribe = this._monitoringUnsubscribes[index];
+  this._monitoringDocuments.splice(index, 1);
+  this._monitoringUnsubscribes.splice(index, 1);
+  unsubscribe();
+
+  // Also unmonitor the parent.
+  if (doc != rootDoc) {
+    var frame = getFrameElement(doc);
+    if (frame) {
+      this._unmonitorIntersections(frame.ownerDocument);
+    }
+  }
+};
+
+
+/**
+ * Stops polling for intersection changes.
+ * @param {!Document} doc
+ * @private
+ */
+IntersectionObserver.prototype._unmonitorAllIntersections = function() {
+  var unsubscribes = this._monitoringUnsubscribes.slice(0);
+  this._monitoringDocuments.length = 0;
+  this._monitoringUnsubscribes.length = 0;
+  for (var i = 0; i < unsubscribes.length; i++) {
+    unsubscribes[i]();
+  }
+};
+
+
+/**
+ * Scans each observation target for intersection changes and adds them
+ * to the internal entries queue. If new entries are found, it
+ * schedules the callback to be invoked.
+ * @private
+ */
+IntersectionObserver.prototype._checkForIntersections = function() {
+  if (!this.root && crossOriginUpdater && !crossOriginRect) {
+    // Cross origin monitoring, but no initial data available yet.
+    return;
+  }
+
+  var rootIsInDom = this._rootIsInDom();
+  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();
+
+  this._observationTargets.forEach(function(item) {
+    var target = item.element;
+    var targetRect = getBoundingClientRect(target);
+    var rootContainsTarget = this._rootContainsTarget(target);
+    var oldEntry = item.entry;
+    var intersectionRect = rootIsInDom && rootContainsTarget &&
+        this._computeTargetAndRootIntersection(target, targetRect, rootRect);
+
+    var rootBounds = null;
+    if (!this._rootContainsTarget(target)) {
+      rootBounds = getEmptyRect();
+    } else if (!crossOriginUpdater || this.root) {
+      rootBounds = rootRect;
+    }
+
+    var newEntry = item.entry = new IntersectionObserverEntry({
+      time: now(),
+      target: target,
+      boundingClientRect: targetRect,
+      rootBounds: rootBounds,
+      intersectionRect: intersectionRect
+    });
+
+    if (!oldEntry) {
+      this._queuedEntries.push(newEntry);
+    } else if (rootIsInDom && rootContainsTarget) {
+      // If the new entry intersection ratio has crossed any of the
+      // thresholds, add a new entry.
+      if (this._hasCrossedThreshold(oldEntry, newEntry)) {
+        this._queuedEntries.push(newEntry);
+      }
+    } else {
+      // If the root is not in the DOM or target is not contained within
+      // root but the previous entry for this target had an intersection,
+      // add a new record indicating removal.
+      if (oldEntry && oldEntry.isIntersecting) {
+        this._queuedEntries.push(newEntry);
+      }
+    }
+  }, this);
+
+  if (this._queuedEntries.length) {
+    this._callback(this.takeRecords(), this);
+  }
+};
+
+
+/**
+ * Accepts a target and root rect computes the intersection between then
+ * following the algorithm in the spec.
+ * TODO(philipwalton): at this time clip-path is not considered.
+ * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo
+ * @param {Element} target The target DOM element
+ * @param {Object} targetRect The bounding rect of the target.
+ * @param {Object} rootRect The bounding rect of the root after being
+ *     expanded by the rootMargin value.
+ * @return {?Object} The final intersection rect object or undefined if no
+ *     intersection is found.
+ * @private
+ */
+IntersectionObserver.prototype._computeTargetAndRootIntersection =
+    function(target, targetRect, rootRect) {
+  // If the element isn't displayed, an intersection can't happen.
+  if (window.getComputedStyle(target).display == 'none') return;
+
+  var intersectionRect = targetRect;
+  var parent = getParentNode(target);
+  var atRoot = false;
+
+  while (!atRoot && parent) {
+    var parentRect = null;
+    var parentComputedStyle = parent.nodeType == 1 ?
+        window.getComputedStyle(parent) : {};
+
+    // If the parent isn't displayed, an intersection can't happen.
+    if (parentComputedStyle.display == 'none') return null;
+
+    if (parent == this.root || parent.nodeType == /* DOCUMENT */ 9) {
+      atRoot = true;
+      if (parent == this.root || parent == document) {
+        if (crossOriginUpdater && !this.root) {
+          if (!crossOriginRect ||
+              crossOriginRect.width == 0 && crossOriginRect.height == 0) {
+            // A 0-size cross-origin intersection means no-intersection.
+            parent = null;
+            parentRect = null;
+            intersectionRect = null;
+          } else {
+            parentRect = crossOriginRect;
+          }
+        } else {
+          parentRect = rootRect;
+        }
+      } else {
+        // Check if there's a frame that can be navigated to.
+        var frame = getParentNode(parent);
+        var frameRect = frame && getBoundingClientRect(frame);
+        var frameIntersect =
+            frame &&
+            this._computeTargetAndRootIntersection(frame, frameRect, rootRect);
+        if (frameRect && frameIntersect) {
+          parent = frame;
+          parentRect = convertFromParentRect(frameRect, frameIntersect);
+        } else {
+          parent = null;
+          intersectionRect = null;
+        }
+      }
+    } else {
+      // If the element has a non-visible overflow, and it's not the <body>
+      // or <html> element, update the intersection rect.
+      // Note: <body> and <html> cannot be clipped to a rect that's not also
+      // the document rect, so no need to compute a new intersection.
+      var doc = parent.ownerDocument;
+      if (parent != doc.body &&
+          parent != doc.documentElement &&
+          parentComputedStyle.overflow != 'visible') {
+        parentRect = getBoundingClientRect(parent);
+      }
+    }
+
+    // If either of the above conditionals set a new parentRect,
+    // calculate new intersection data.
+    if (parentRect) {
+      intersectionRect = computeRectIntersection(parentRect, intersectionRect);
+    }
+    if (!intersectionRect) break;
+    parent = parent && getParentNode(parent);
+  }
+  return intersectionRect;
+};
+
+
+/**
+ * Returns the root rect after being expanded by the rootMargin value.
+ * @return {ClientRect} The expanded root rect.
+ * @private
+ */
+IntersectionObserver.prototype._getRootRect = function() {
+  var rootRect;
+  if (this.root && !isDoc(this.root)) {
+    rootRect = getBoundingClientRect(this.root);
+  } else {
+    // Use <html>/<body> instead of window since scroll bars affect size.
+    var doc = isDoc(this.root) ? this.root : document;
+    var html = doc.documentElement;
+    var body = doc.body;
+    rootRect = {
+      top: 0,
+      left: 0,
+      right: html.clientWidth || body.clientWidth,
+      width: html.clientWidth || body.clientWidth,
+      bottom: html.clientHeight || body.clientHeight,
+      height: html.clientHeight || body.clientHeight
+    };
+  }
+  return this._expandRectByRootMargin(rootRect);
+};
+
+
+/**
+ * Accepts a rect and expands it by the rootMargin value.
+ * @param {DOMRect|ClientRect} rect The rect object to expand.
+ * @return {ClientRect} The expanded rect.
+ * @private
+ */
+IntersectionObserver.prototype._expandRectByRootMargin = function(rect) {
+  var margins = this._rootMarginValues.map(function(margin, i) {
+    return margin.unit == 'px' ? margin.value :
+        margin.value * (i % 2 ? rect.width : rect.height) / 100;
+  });
+  var newRect = {
+    top: rect.top - margins[0],
+    right: rect.right + margins[1],
+    bottom: rect.bottom + margins[2],
+    left: rect.left - margins[3]
+  };
+  newRect.width = newRect.right - newRect.left;
+  newRect.height = newRect.bottom - newRect.top;
+
+  return newRect;
+};
+
+
+/**
+ * Accepts an old and new entry and returns true if at least one of the
+ * threshold values has been crossed.
+ * @param {?IntersectionObserverEntry} oldEntry The previous entry for a
+ *    particular target element or null if no previous entry exists.
+ * @param {IntersectionObserverEntry} newEntry The current entry for a
+ *    particular target element.
+ * @return {boolean} Returns true if a any threshold has been crossed.
+ * @private
+ */
+IntersectionObserver.prototype._hasCrossedThreshold =
+    function(oldEntry, newEntry) {
+
+  // To make comparing easier, an entry that has a ratio of 0
+  // but does not actually intersect is given a value of -1
+  var oldRatio = oldEntry && oldEntry.isIntersecting ?
+      oldEntry.intersectionRatio || 0 : -1;
+  var newRatio = newEntry.isIntersecting ?
+      newEntry.intersectionRatio || 0 : -1;
+
+  // Ignore unchanged ratios
+  if (oldRatio === newRatio) return;
+
+  for (var i = 0; i < this.thresholds.length; i++) {
+    var threshold = this.thresholds[i];
+
+    // Return true if an entry matches a threshold or if the new ratio
+    // and the old ratio are on the opposite sides of a threshold.
+    if (threshold == oldRatio || threshold == newRatio ||
+        threshold < oldRatio !== threshold < newRatio) {
+      return true;
+    }
+  }
+};
+
+
+/**
+ * Returns whether or not the root element is an element and is in the DOM.
+ * @return {boolean} True if the root element is an element and is in the DOM.
+ * @private
+ */
+IntersectionObserver.prototype._rootIsInDom = function() {
+  return !this.root || containsDeep(document, this.root);
+};
+
+
+/**
+ * Returns whether or not the target element is a child of root.
+ * @param {Element} target The target element to check.
+ * @return {boolean} True if the target element is a child of root.
+ * @private
+ */
+IntersectionObserver.prototype._rootContainsTarget = function(target) {
+  var rootDoc =
+    (this.root && (this.root.ownerDocument || this.root)) || document;
+  return (
+    containsDeep(rootDoc, target) &&
+    (!this.root || rootDoc == target.ownerDocument)
+  );
+};
+
+
+/**
+ * Adds the instance to the global IntersectionObserver registry if it isn't
+ * already present.
+ * @private
+ */
+IntersectionObserver.prototype._registerInstance = function() {
+  if (registry.indexOf(this) < 0) {
+    registry.push(this);
+  }
+};
+
+
+/**
+ * Removes the instance from the global IntersectionObserver registry.
+ * @private
+ */
+IntersectionObserver.prototype._unregisterInstance = function() {
+  var index = registry.indexOf(this);
+  if (index != -1) registry.splice(index, 1);
+};
+
+
+/**
+ * Returns the result of the performance.now() method or null in browsers
+ * that don't support the API.
+ * @return {number} The elapsed time since the page was requested.
+ */
+function now() {
+  return window.performance && performance.now && performance.now();
+}
+
+
+/**
+ * Throttles a function and delays its execution, so it's only called at most
+ * once within a given time period.
+ * @param {Function} fn The function to throttle.
+ * @param {number} timeout The amount of time that must pass before the
+ *     function can be called again.
+ * @return {Function} The throttled function.
+ */
+function throttle(fn, timeout) {
+  var timer = null;
+  return function () {
+    if (!timer) {
+      timer = setTimeout(function() {
+        fn();
+        timer = null;
+      }, timeout);
+    }
+  };
+}
+
+
+/**
+ * Adds an event handler to a DOM node ensuring cross-browser compatibility.
+ * @param {Node} node The DOM node to add the event handler to.
+ * @param {string} event The event name.
+ * @param {Function} fn The event handler to add.
+ * @param {boolean} opt_useCapture Optionally adds the even to the capture
+ *     phase. Note: this only works in modern browsers.
+ */
+function addEvent(node, event, fn, opt_useCapture) {
+  if (typeof node.addEventListener == 'function') {
+    node.addEventListener(event, fn, opt_useCapture || false);
+  }
+  else if (typeof node.attachEvent == 'function') {
+    node.attachEvent('on' + event, fn);
+  }
+}
+
+
+/**
+ * Removes a previously added event handler from a DOM node.
+ * @param {Node} node The DOM node to remove the event handler from.
+ * @param {string} event The event name.
+ * @param {Function} fn The event handler to remove.
+ * @param {boolean} opt_useCapture If the event handler was added with this
+ *     flag set to true, it should be set to true here in order to remove it.
+ */
+function removeEvent(node, event, fn, opt_useCapture) {
+  if (typeof node.removeEventListener == 'function') {
+    node.removeEventListener(event, fn, opt_useCapture || false);
+  }
+  else if (typeof node.detatchEvent == 'function') {
+    node.detatchEvent('on' + event, fn);
+  }
+}
+
+
+/**
+ * Returns the intersection between two rect objects.
+ * @param {Object} rect1 The first rect.
+ * @param {Object} rect2 The second rect.
+ * @return {?Object|?ClientRect} The intersection rect or undefined if no
+ *     intersection is found.
+ */
+function computeRectIntersection(rect1, rect2) {
+  var top = Math.max(rect1.top, rect2.top);
+  var bottom = Math.min(rect1.bottom, rect2.bottom);
+  var left = Math.max(rect1.left, rect2.left);
+  var right = Math.min(rect1.right, rect2.right);
+  var width = right - left;
+  var height = bottom - top;
+
+  return (width >= 0 && height >= 0) && {
+    top: top,
+    bottom: bottom,
+    left: left,
+    right: right,
+    width: width,
+    height: height
+  } || null;
+}
+
+
+/**
+ * Shims the native getBoundingClientRect for compatibility with older IE.
+ * @param {Element} el The element whose bounding rect to get.
+ * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.
+ */
+function getBoundingClientRect(el) {
+  var rect;
+
+  try {
+    rect = el.getBoundingClientRect();
+  } catch (err) {
+    // Ignore Windows 7 IE11 "Unspecified error"
+    // https://github.com/w3c/IntersectionObserver/pull/205
+  }
+
+  if (!rect) return getEmptyRect();
+
+  // Older IE
+  if (!(rect.width && rect.height)) {
+    rect = {
+      top: rect.top,
+      right: rect.right,
+      bottom: rect.bottom,
+      left: rect.left,
+      width: rect.right - rect.left,
+      height: rect.bottom - rect.top
+    };
+  }
+  return rect;
+}
+
+
+/**
+ * Returns an empty rect object. An empty rect is returned when an element
+ * is not in the DOM.
+ * @return {ClientRect} The empty rect.
+ */
+function getEmptyRect() {
+  return {
+    top: 0,
+    bottom: 0,
+    left: 0,
+    right: 0,
+    width: 0,
+    height: 0
+  };
+}
+
+
+/**
+ * Ensure that the result has all of the necessary fields of the DOMRect.
+ * Specifically this ensures that `x` and `y` fields are set.
+ *
+ * @param {?DOMRect|?ClientRect} rect
+ * @return {?DOMRect}
+ */
+function ensureDOMRect(rect) {
+  // A `DOMRect` object has `x` and `y` fields.
+  if (!rect || 'x' in rect) {
+    return rect;
+  }
+  // A IE's `ClientRect` type does not have `x` and `y`. The same is the case
+  // for internally calculated Rect objects. For the purposes of
+  // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`
+  // for these fields.
+  return {
+    top: rect.top,
+    y: rect.top,
+    bottom: rect.bottom,
+    left: rect.left,
+    x: rect.left,
+    right: rect.right,
+    width: rect.width,
+    height: rect.height
+  };
+}
+
+
+/**
+ * Inverts the intersection and bounding rect from the parent (frame) BCR to
+ * the local BCR space.
+ * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.
+ * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.
+ * @return {ClientRect} The local root bounding rect for the parent's children.
+ */
+function convertFromParentRect(parentBoundingRect, parentIntersectionRect) {
+  var top = parentIntersectionRect.top - parentBoundingRect.top;
+  var left = parentIntersectionRect.left - parentBoundingRect.left;
+  return {
+    top: top,
+    left: left,
+    height: parentIntersectionRect.height,
+    width: parentIntersectionRect.width,
+    bottom: top + parentIntersectionRect.height,
+    right: left + parentIntersectionRect.width
+  };
+}
+
+
+/**
+ * Checks to see if a parent element contains a child element (including inside
+ * shadow DOM).
+ * @param {Node} parent The parent element.
+ * @param {Node} child The child element.
+ * @return {boolean} True if the parent node contains the child node.
+ */
+function containsDeep(parent, child) {
+  var node = child;
+  while (node) {
+    if (node == parent) return true;
+
+    node = getParentNode(node);
+  }
+  return false;
+}
+
+
+/**
+ * Gets the parent node of an element or its host element if the parent node
+ * is a shadow root.
+ * @param {Node} node The node whose parent to get.
+ * @return {Node|null} The parent node or null if no parent exists.
+ */
+function getParentNode(node) {
+  var parent = node.parentNode;
+
+  if (node.nodeType == /* DOCUMENT */ 9 && node != document) {
+    // If this node is a document node, look for the embedding frame.
+    return getFrameElement(node);
+  }
+
+  // If the parent has element that is assigned through shadow root slot
+  if (parent && parent.assignedSlot) {
+    parent = parent.assignedSlot.parentNode;
+  }
+
+  if (parent && parent.nodeType == 11 && parent.host) {
+    // If the parent is a shadow root, return the host element.
+    return parent.host;
+  }
+
+  return parent;
+}
+
+/**
+ * Returns true if `node` is a Document.
+ * @param {!Node} node
+ * @returns {boolean}
+ */
+function isDoc(node) {
+  return node && node.nodeType === 9;
+}
+
+
+// Exposes the constructors globally.
+window.IntersectionObserver = IntersectionObserver;
+window.IntersectionObserverEntry = IntersectionObserverEntry;
+
+}());
+
+var eventemitter3 = {exports: {}};
+
+(function (module) {
+
+var has = Object.prototype.hasOwnProperty
+  , prefix = '~';
+
+/**
+ * Constructor to create a storage for our `EE` objects.
+ * An `Events` instance is a plain object whose properties are event names.
+ *
+ * @constructor
+ * @private
+ */
+function Events() {}
+
+//
+// We try to not inherit from `Object.prototype`. In some engines creating an
+// instance in this way is faster than calling `Object.create(null)` directly.
+// If `Object.create(null)` is not supported we prefix the event names with a
+// character to make sure that the built-in object properties are not
+// overridden or used as an attack vector.
+//
+if (Object.create) {
+  Events.prototype = Object.create(null);
+
+  //
+  // This hack is needed because the `__proto__` property is still inherited in
+  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+  //
+  if (!new Events().__proto__) prefix = false;
+}
+
+/**
+ * Representation of a single event listener.
+ *
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+ * @constructor
+ * @private
+ */
+function EE(fn, context, once) {
+  this.fn = fn;
+  this.context = context;
+  this.once = once || false;
+}
+
+/**
+ * Add a listener for a given event.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} once Specify if the listener is a one-time listener.
+ * @returns {EventEmitter}
+ * @private
+ */
+function addListener(emitter, event, fn, context, once) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('The listener must be a function');
+  }
+
+  var listener = new EE(fn, context || emitter, once)
+    , evt = prefix ? prefix + event : event;
+
+  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+  else emitter._events[evt] = [emitter._events[evt], listener];
+
+  return emitter;
+}
+
+/**
+ * Clear event by name.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} evt The Event name.
+ * @private
+ */
+function clearEvent(emitter, evt) {
+  if (--emitter._eventsCount === 0) emitter._events = new Events();
+  else delete emitter._events[evt];
+}
+
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ *
+ * @constructor
+ * @public
+ */
+function EventEmitter() {
+  this._events = new Events();
+  this._eventsCount = 0;
+}
+
+/**
+ * Return an array listing the events for which the emitter has registered
+ * listeners.
+ *
+ * @returns {Array}
+ * @public
+ */
+EventEmitter.prototype.eventNames = function eventNames() {
+  var names = []
+    , events
+    , name;
+
+  if (this._eventsCount === 0) return names;
+
+  for (name in (events = this._events)) {
+    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    return names.concat(Object.getOwnPropertySymbols(events));
+  }
+
+  return names;
+};
+
+/**
+ * Return the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Array} The registered listeners.
+ * @public
+ */
+EventEmitter.prototype.listeners = function listeners(event) {
+  var evt = prefix ? prefix + event : event
+    , handlers = this._events[evt];
+
+  if (!handlers) return [];
+  if (handlers.fn) return [handlers.fn];
+
+  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+    ee[i] = handlers[i].fn;
+  }
+
+  return ee;
+};
+
+/**
+ * Return the number of listeners listening to a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Number} The number of listeners.
+ * @public
+ */
+EventEmitter.prototype.listenerCount = function listenerCount(event) {
+  var evt = prefix ? prefix + event : event
+    , listeners = this._events[evt];
+
+  if (!listeners) return 0;
+  if (listeners.fn) return 1;
+  return listeners.length;
+};
+
+/**
+ * Calls each of the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Boolean} `true` if the event had listeners, else `false`.
+ * @public
+ */
+EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+  var evt = prefix ? prefix + event : event;
+
+  if (!this._events[evt]) return false;
+
+  var listeners = this._events[evt]
+    , len = arguments.length
+    , args
+    , i;
+
+  if (listeners.fn) {
+    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+    switch (len) {
+      case 1: return listeners.fn.call(listeners.context), true;
+      case 2: return listeners.fn.call(listeners.context, a1), true;
+      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+    }
+
+    for (i = 1, args = new Array(len -1); i < len; i++) {
+      args[i - 1] = arguments[i];
+    }
+
+    listeners.fn.apply(listeners.context, args);
+  } else {
+    var length = listeners.length
+      , j;
+
+    for (i = 0; i < length; i++) {
+      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+      switch (len) {
+        case 1: listeners[i].fn.call(listeners[i].context); break;
+        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+        default:
+          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+            args[j - 1] = arguments[j];
+          }
+
+          listeners[i].fn.apply(listeners[i].context, args);
+      }
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Add a listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.on = function on(event, fn, context) {
+  return addListener(this, event, fn, context, false);
+};
+
+/**
+ * Add a one-time listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.once = function once(event, fn, context) {
+  return addListener(this, event, fn, context, true);
+};
+
+/**
+ * Remove the listeners of a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn Only remove the listeners that match this function.
+ * @param {*} context Only remove the listeners that have this context.
+ * @param {Boolean} once Only remove one-time listeners.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+  var evt = prefix ? prefix + event : event;
+
+  if (!this._events[evt]) return this;
+  if (!fn) {
+    clearEvent(this, evt);
+    return this;
+  }
+
+  var listeners = this._events[evt];
+
+  if (listeners.fn) {
+    if (
+      listeners.fn === fn &&
+      (!once || listeners.once) &&
+      (!context || listeners.context === context)
+    ) {
+      clearEvent(this, evt);
+    }
+  } else {
+    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+      if (
+        listeners[i].fn !== fn ||
+        (once && !listeners[i].once) ||
+        (context && listeners[i].context !== context)
+      ) {
+        events.push(listeners[i]);
+      }
+    }
+
+    //
+    // Reset the array, or remove it completely if we have no more listeners.
+    //
+    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+    else clearEvent(this, evt);
+  }
+
+  return this;
+};
+
+/**
+ * Remove all listeners, or those of the specified event.
+ *
+ * @param {(String|Symbol)} [event] The event name.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+  var evt;
+
+  if (event) {
+    evt = prefix ? prefix + event : event;
+    if (this._events[evt]) clearEvent(this, evt);
+  } else {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+
+  return this;
+};
+
+//
+// Alias methods names because people roll like that.
+//
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+//
+// Expose the prefix.
+//
+EventEmitter.prefixed = prefix;
+
+//
+// Allow `EventEmitter` to be imported as module namespace.
+//
+EventEmitter.EventEmitter = EventEmitter;
+
+//
+// Expose the module.
+//
+{
+  module.exports = EventEmitter;
+}
+}(eventemitter3));
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (undefined && undefined.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __values = (undefined && undefined.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var NAVBAR_HEIGHT = 60;
+/**
+ * This class follows a singleton pattern where you can create an instance by calling
+ * `new PositioningService()` if you wish, but all instance methods pass through to
+ * static methods, so there's really only one set of elements being positioned that's
+ * shared between all instances and static usages of PositioningService.
+ */
+var PositioningService = /** @class */ (function () {
+    function PositioningService() {
+    }
+    PositioningService.on = function (eventName, handler) {
+        PositioningService.events.on(eventName, handler);
+    };
+    PositioningService.off = function (eventName, handler) {
+        PositioningService.events.off(eventName, handler);
+    };
+    PositioningService.once = function (eventName, handler) {
+        PositioningService.events.once(eventName, handler);
+    };
+    PositioningService.checkCollisions = function (element, otherElements) {
+        var e_1, _a;
+        var otherElementsList = otherElements || Array.from(PositioningService.elements.keys());
+        var bounds = element.getBoundingClientRect();
+        var collisions = [];
+        try {
+            for (var otherElementsList_1 = __values(otherElementsList), otherElementsList_1_1 = otherElementsList_1.next(); !otherElementsList_1_1.done; otherElementsList_1_1 = otherElementsList_1.next()) {
+                var otherElement = otherElementsList_1_1.value;
+                if (otherElement !== element) {
+                    var otherBounds = otherElement.getBoundingClientRect();
+                    if (otherBounds.left <= bounds.right
+                        && otherBounds.right >= bounds.left
+                        && otherBounds.top <= bounds.bottom
+                        && otherBounds.bottom >= bounds.top) {
+                        collisions.push(otherElement);
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (otherElementsList_1_1 && !otherElementsList_1_1.done && (_a = otherElementsList_1.return)) _a.call(otherElementsList_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (collisions.length) {
+            PositioningService.onElementIntersection(element, collisions);
+        }
+    };
+    /**
+     * Returns `true` if the element is currently being positioned by the service
+     * and `false` otherwise.
+     */
+    PositioningService.isPositioned = function (element) {
+        return PositioningService.elements.has(element);
+    };
+    /**
+     * Returns the options currently beinng used for positioning the element,
+     * if it is indeed being positioned by the service.
+     */
+    PositioningService.getPositioningOptions = function (element) {
+        if (PositioningService.elements.has(element)) {
+            return PositioningService.elements.get(element);
+        }
+        return null;
+    };
+    /** PositioningService will start controlling the position of the given element. */
+    PositioningService.position = function (element, options) {
+        if (options === void 0) { options = {}; }
+        var opts = __assign(__assign({}, DEFAULT_POSITIONING_OPTIONS), options);
+        var e = element;
+        while (e !== document.body) {
+            e = e.parentElement;
+            if (e.classList.contains("sps-focused-task")) {
+                opts.scrollParent = e;
+                if (!PositioningService.registeredScrollParents.has(e)) {
+                    PositioningService.registeredScrollParents.add(e);
+                    e.addEventListener("scroll", PositioningService.update);
+                }
+                break;
+            }
+        }
+        // eslint-disable-next-line no-param-reassign
+        element.style.visibility = "hidden";
+        if (PositioningService.elements.size === 0) {
+            window.addEventListener("resize", PositioningService.update);
+            window.addEventListener("scroll", PositioningService.update);
+        }
+        if (!opts.relativeTo) {
+            throw new Error("You must provide an element for the relativeTo option to position an element.");
+        }
+        PositioningService.elements.set(element, opts);
+        utils.onNextTick(function () {
+            PositioningService.fixElementPosition(element);
+            PositioningService.viewportObserver.observe(element);
+            // eslint-disable-next-line no-param-reassign
+            element.style.visibility = "";
+            PositioningService.checkCollisions(element);
+        });
+    };
+    /** PositioningService will stop controlling the position of the given element. */
+    PositioningService.release = function (element) {
+        if (PositioningService.elements.has(element)) {
+            PositioningService.clearStyles(element);
+            var options = PositioningService.elements.get(element);
+            if (options.scrollParent) {
+                options.scrollParent.removeEventListener("scroll", PositioningService.update);
+                PositioningService.registeredScrollParents.delete(options.scrollParent);
+            }
+            PositioningService.elements.delete(element);
+            if (PositioningService.elements.size === 0) {
+                window.removeEventListener("resize", PositioningService.update);
+                window.removeEventListener("scroll", PositioningService.update);
+            }
+            PositioningService.viewportObserver.unobserve(element);
+        }
+    };
+    PositioningService.releaseAll = function () {
+        var e_2, _a;
+        try {
+            for (var _b = __values(PositioningService.elements.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var element = _c.value;
+                PositioningService.release(element);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    /** PositioningService will refresh the positioning of the given element */
+    PositioningService.refresh = function (element) {
+        if (PositioningService.elements.has(element)) {
+            PositioningService.clearStyles(element);
+            PositioningService.fixElementPosition(element);
+            PositioningService.checkCollisions(element);
+        }
+    };
+    PositioningService.refreshAll = function () {
+        var e_3, _a;
+        try {
+            for (var _b = __values(PositioningService.elements.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var element = _c.value;
+                PositioningService.refresh(element);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    /** Update the positioning options of a currently positioned element */
+    PositioningService.reposition = function (element, newOptions) {
+        if (PositioningService.elements.has(element)) {
+            var options = PositioningService.elements.get(element);
+            PositioningService.elements.set(element, Object.assign(options, newOptions));
+            PositioningService.refresh(element);
+        }
+    };
+    PositioningService.onViewportIntersection = function (entries) {
+        var e_4, _a;
+        var _loop_1 = function (entry) {
+            /*
+             * This is how you make a copy of an IntersectionObserverEntry that
+             * you can modify; it's read-only and incompatible with simply using
+             * destructuring or Object.assign. Before sending it out we make the
+             * copy read-only by passing it to Object.freeze
+             */
+            var entryCopy = Object.keys(IntersectionObserverEntry.prototype).reduce(function (copy, key) {
+                var _a;
+                return (__assign(__assign({}, copy), (_a = {}, _a[key] = entry[key], _a)));
+            }, {});
+            entryCopy.rootBounds = entryCopy.rootBounds || PositioningService.getRootBounds();
+            PositioningService.events.emit("viewportIntersection", Object.freeze(entryCopy));
+        };
+        try {
+            for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+                var entry = entries_1_1.value;
+                _loop_1(entry);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    PositioningService.onElementIntersection = function (target, intersectingWith) {
+        PositioningService.events.emit("elementIntersection", { target: target, intersectingWith: intersectingWith });
+    };
+    PositioningService.getRootBounds = function () {
+        var rootWidth = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
+        var rootHeight = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
+        return {
+            x: 0,
+            y: NAVBAR_HEIGHT,
+            left: 0,
+            top: NAVBAR_HEIGHT,
+            right: rootWidth,
+            bottom: rootHeight,
+            height: rootHeight - NAVBAR_HEIGHT,
+            width: rootWidth,
+        };
+    };
+    PositioningService.clearStyles = function (element) {
+        Object.assign(element.style, {
+            position: "",
+            width: "",
+            top: "",
+            left: "",
+            right: "",
+            bottom: "",
+            visibility: "",
+            zIndex: "",
+        });
+    };
+    PositioningService.fixElementPosition = function (element, options) {
+        if (!this.elements.has(element)) {
+            return;
+        }
+        var opts = options || this.elements.get(element);
+        var rootBounds = this.getRootBounds();
+        var positionedElementBounds = element.getBoundingClientRect();
+        var relativeTargetBounds = opts.relativeTo.getBoundingClientRect();
+        var width = (opts.useRelativeTargetWidth
+            ? relativeTargetBounds
+            : positionedElementBounds).width;
+        Object.assign(element.style, {
+            minWidth: width + "px",
+            position: "fixed",
+            zIndex: opts.zIndex || "",
+        });
+        var top;
+        var left;
+        var positionRelativeToTarget = opts.position.split(" ");
+        var offsetA = opts.offsets[0] || 0;
+        var offsetB = opts.offsets[1] || 0;
+        top = 0;
+        left = 0;
+        switch (positionRelativeToTarget[0]) {
+            case "top":
+                top = relativeTargetBounds.top - positionedElementBounds.height - offsetA;
+                break;
+            case "left":
+                left = relativeTargetBounds.left - width - offsetA;
+                break;
+            case "right":
+                left = relativeTargetBounds.right + offsetA;
+                break;
+            case "bottom":
+                top = relativeTargetBounds.bottom + offsetA;
+                break;
+            default:
+                throw new Error(opts.position + " is not a valid position");
+        }
+        switch (positionRelativeToTarget[1]) {
+            case "left":
+                left = relativeTargetBounds.left - offsetB;
+                break;
+            case "top":
+                top = relativeTargetBounds.top - offsetB;
+                break;
+            case "middle":
+                if (positionRelativeToTarget[0] === "top"
+                    || positionRelativeToTarget[0] === "bottom") {
+                    left = relativeTargetBounds.left
+                        + (relativeTargetBounds.width / 2)
+                        - (width / 2)
+                        + offsetB;
+                }
+                else if (positionRelativeToTarget[0] === "left"
+                    || positionRelativeToTarget[0] === "right") {
+                    top = relativeTargetBounds.top
+                        + (relativeTargetBounds.height / 2)
+                        - (positionedElementBounds.height / 2)
+                        + offsetB;
+                }
+                break;
+            case "bottom":
+                top = relativeTargetBounds.bottom - positionedElementBounds.height + offsetB;
+                break;
+            case "right":
+                left = relativeTargetBounds.right - width + offsetB;
+                break;
+            default:
+                throw new Error(opts.position + " is not a valid position");
+        }
+        var bottom = top + positionedElementBounds.height;
+        var right = left + positionedElementBounds.width;
+        var topPx = Math.round(top) + "px";
+        var bottomPx = Math.round(rootBounds.bottom - bottom) + "px";
+        var leftPx = Math.round(left) + "px";
+        var rightPx = Math.round(rootBounds.right - right) + "px";
+        switch (opts.anchor) {
+            case exports.PositionAnchor.TOP_LEFT:
+                Object.assign(element.style, {
+                    top: topPx,
+                    bottom: "auto",
+                    left: leftPx,
+                    right: "auto",
+                });
+                break;
+            case exports.PositionAnchor.TOP_RIGHT:
+                Object.assign(element.style, {
+                    top: topPx,
+                    bottom: "auto",
+                    left: "auto",
+                    right: rightPx,
+                });
+                break;
+            case exports.PositionAnchor.BOTTOM_LEFT:
+                Object.assign(element.style, {
+                    top: "auto",
+                    bottom: bottomPx,
+                    left: leftPx,
+                    right: "auto",
+                });
+                break;
+            case exports.PositionAnchor.BOTTOM_RIGHT:
+                Object.assign(element.style, {
+                    top: "auto",
+                    bottom: bottomPx,
+                    left: "auto",
+                    right: rightPx,
+                });
+                break;
+            // no default
+        }
+    };
+    PositioningService.update = function (event) {
+        var e_5, _a;
+        var elements = PositioningService.elements.entries();
+        var updatedElements = [];
+        try {
+            for (var elements_1 = __values(elements), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
+                var _b = __read(elements_1_1.value, 2), element = _b[0], options = _b[1];
+                if (!event
+                    || event.target === document
+                    || event.target === options.scrollParent
+                    || event.target === window) {
+                    PositioningService.fixElementPosition(element, options);
+                    PositioningService.checkCollisions(element, updatedElements);
+                    updatedElements.push(element);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    /* eslint class-methods-use-this: "off" */
+    PositioningService.prototype.on = function (eventName, handler) {
+        PositioningService.on(eventName, handler);
+    };
+    PositioningService.prototype.off = function (eventName, handler) {
+        PositioningService.off(eventName, handler);
+    };
+    PositioningService.prototype.once = function (eventName, handler) {
+        PositioningService.once(eventName, handler);
+    };
+    PositioningService.prototype.isPositioned = function (element) {
+        return PositioningService.isPositioned(element);
+    };
+    PositioningService.prototype.getPositioningOptions = function (element) {
+        return PositioningService.getPositioningOptions(element);
+    };
+    PositioningService.prototype.position = function (element, options) {
+        if (options === void 0) { options = {}; }
+        PositioningService.position(element, options);
+    };
+    PositioningService.prototype.release = function (element) {
+        PositioningService.release(element);
+    };
+    PositioningService.prototype.releaseAll = function () {
+        PositioningService.releaseAll();
+    };
+    PositioningService.prototype.refresh = function (element) {
+        PositioningService.refresh(element);
+    };
+    PositioningService.prototype.refreshAll = function () {
+        PositioningService.refreshAll();
+    };
+    PositioningService.prototype.reposition = function (element, newOptions) {
+        PositioningService.reposition(element, newOptions);
+    };
+    PositioningService.elements = new Map();
+    PositioningService.registeredScrollParents = new Set();
+    PositioningService.events = new eventemitter3.exports.EventEmitter();
+    PositioningService.viewportObserver = new IntersectionObserver(PositioningService.onViewportIntersection, {
+        rootMargin: "-" + NAVBAR_HEIGHT + "px 0px 0px",
+        threshold: 1,
+    });
+    __decorate([
+        utils.lockedToAnimationFrames,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Event]),
+        __metadata("design:returntype", void 0)
+    ], PositioningService, "update", null);
+    return PositioningService;
+}());
+
+exports.DEFAULT_POSITIONING_OPTIONS = DEFAULT_POSITIONING_OPTIONS;
+exports.PositioningService = PositioningService;