@spscommerce/positioning 5.18.1 → 5.18.3-ie2

package/lib/index.es.js

@@ -1,1063 +1,1852 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { onNextTick, lockedToAnimationFrames } from "@spscommerce/utils";
+import { lockedToAnimationFrames, onNextTick } from '@spscommerce/utils';
+
+/**
+ * These are the possibilities for the `position` option of
+ * `PositioningOptions` when using `relativeTo`.
+ */
 var Position;
-(function(Position2) {
-  Position2["TOP_LEFT"] = "top left";
-  Position2["TOP_MIDDLE"] = "top middle";
-  Position2["TOP_RIGHT"] = "top right";
-  Position2["RIGHT_TOP"] = "right top";
-  Position2["RIGHT_MIDDLE"] = "right middle";
-  Position2["RIGHT_BOTTOM"] = "right bottom";
-  Position2["BOTTOM_RIGHT"] = "bottom right";
-  Position2["BOTTOM_MIDDLE"] = "bottom middle";
-  Position2["BOTTOM_LEFT"] = "bottom left";
-  Position2["LEFT_BOTTOM"] = "left bottom";
-  Position2["LEFT_MIDDLE"] = "left middle";
-  Position2["LEFT_TOP"] = "left top";
+(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";
 })(Position || (Position = {}));
+
+/** Indicates which point on a positioned element it should be positioned by. */
 var PositionAnchor;
-(function(PositionAnchor2) {
-  PositionAnchor2["TOP_LEFT"] = "top left";
-  PositionAnchor2["TOP_RIGHT"] = "top right";
-  PositionAnchor2["BOTTOM_LEFT"] = "bottom left";
-  PositionAnchor2["BOTTOM_RIGHT"] = "bottom right";
+(function (PositionAnchor) {
+    PositionAnchor["TOP_LEFT"] = "top left";
+    PositionAnchor["TOP_RIGHT"] = "top right";
+    PositionAnchor["BOTTOM_LEFT"] = "bottom left";
+    PositionAnchor["BOTTOM_RIGHT"] = "bottom right";
 })(PositionAnchor || (PositionAnchor = {}));
-const DEFAULT_POSITIONING_OPTIONS = {
-  anchor: PositionAnchor.TOP_LEFT,
-  offsets: [],
-  position: Position.TOP_LEFT
+
+var DEFAULT_POSITIONING_OPTIONS = {
+    anchor: PositionAnchor.TOP_LEFT,
+    offsets: [],
+    position: 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() {
-  if (typeof window !== "object") {
-    return;
+
+// 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;
+      }
+    });
   }
-  if ("IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype) {
-    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;
   }
-  function getFrameElement(doc) {
-    try {
-      return doc.defaultView && doc.defaultView.frameElement || null;
-    } catch (e) {
-      return null;
-    }
+
+  if (!(target && target.nodeType == 1)) {
+    throw new Error('target must be an Element');
   }
-  var document2 = function(startDoc) {
-    var doc = startDoc;
-    var frame = getFrameElement(doc);
-    while (frame) {
-      doc = frame.ownerDocument;
-      frame = getFrameElement(doc);
-    }
-    return doc;
-  }(window.document);
-  var registry = [];
-  var crossOriginUpdater = null;
-  var crossOriginRect = null;
-  function IntersectionObserverEntry2(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;
-    var targetRect = this.boundingClientRect;
-    var targetArea = targetRect.width * targetRect.height;
-    var intersectionRect = this.intersectionRect;
-    var intersectionArea = intersectionRect.width * intersectionRect.height;
-    if (targetArea) {
-      this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));
-    } else {
-      this.intersectionRatio = this.isIntersecting ? 1 : 0;
-    }
+
+  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();
   }
-  function IntersectionObserver2(callback, opt_options) {
-    var options = opt_options || {};
-    if (typeof callback != "function") {
-      throw new Error("callback must be a function");
+};
+
+
+/**
+ * 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');
     }
-    if (options.root && options.root.nodeType != 1 && options.root.nodeType != 9) {
-      throw new Error("root must be a Document or Element");
+    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');
     }
-    this._checkForIntersections = throttle(this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);
-    this._callback = callback;
-    this._observationTargets = [];
-    this._queuedEntries = [];
-    this._rootMarginValues = this._parseRootMargin(options.rootMargin);
-    this.thresholds = this._initThresholds(options.threshold);
-    this.root = options.root || null;
-    this.rootMargin = this._rootMarginValues.map(function(margin) {
-      return margin.value + margin.unit;
-    }).join(" ");
-    this._monitoringDocuments = [];
-    this._monitoringUnsubscribes = [];
+    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;
   }
-  IntersectionObserver2.prototype.THROTTLE_TIMEOUT = 100;
-  IntersectionObserver2.prototype.POLL_INTERVAL = null;
-  IntersectionObserver2.prototype.USE_MUTATION_OBSERVER = true;
-  IntersectionObserver2._setupCrossOriginUpdater = function() {
-    if (!crossOriginUpdater) {
-      crossOriginUpdater = function(boundingClientRect, intersectionRect) {
-        if (!boundingClientRect || !intersectionRect) {
-          crossOriginRect = getEmptyRect();
-        } else {
-          crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);
-        }
-        registry.forEach(function(observer) {
-          observer._checkForIntersections();
-        });
-      };
-    }
-    return crossOriginUpdater;
-  };
-  IntersectionObserver2._resetCrossOriginUpdater = function() {
-    crossOriginUpdater = null;
-    crossOriginRect = null;
-  };
-  IntersectionObserver2.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();
-  };
-  IntersectionObserver2.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();
+  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
+      });
     }
-  };
-  IntersectionObserver2.prototype.disconnect = function() {
-    this._observationTargets = [];
-    this._unmonitorAllIntersections();
-    this._unregisterInstance();
-  };
-  IntersectionObserver2.prototype.takeRecords = function() {
-    var records = this._queuedEntries.slice();
-    this._queuedEntries = [];
-    return records;
-  };
-  IntersectionObserver2.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];
-    });
-  };
-  IntersectionObserver2.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] };
-    });
-    margins[1] = margins[1] || margins[0];
-    margins[2] = margins[2] || margins[0];
-    margins[3] = margins[3] || margins[1];
-    return margins;
-  };
-  IntersectionObserver2.prototype._monitorIntersections = function(doc) {
+  }
+
+  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) {
-      return;
-    }
-    if (this._monitoringDocuments.indexOf(doc) != -1) {
-      return;
-    }
-    var callback = this._checkForIntersections;
-    var monitoringInterval = null;
-    var domObserver = null;
-    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
-        });
+
+    if (win) {
+      if (monitoringInterval) {
+        win.clearInterval(monitoringInterval);
       }
+      removeEvent(win, 'resize', callback, true);
     }
-    this._monitoringDocuments.push(doc);
-    this._monitoringUnsubscribes.push(function() {
-      var win2 = doc.defaultView;
-      if (win2) {
-        if (monitoringInterval) {
-          win2.clearInterval(monitoringInterval);
-        }
-        removeEvent(win2, "resize", callback, true);
-      }
-      removeEvent(doc, "scroll", callback, true);
-      if (domObserver) {
-        domObserver.disconnect();
-      }
-    });
-    var rootDoc = this.root && (this.root.ownerDocument || this.root) || document2;
-    if (doc != rootDoc) {
-      var frame = getFrameElement(doc);
-      if (frame) {
-        this._monitorIntersections(frame.ownerDocument);
-      }
+
+    removeEvent(doc, 'scroll', callback, true);
+    if (domObserver) {
+      domObserver.disconnect();
     }
-  };
-  IntersectionObserver2.prototype._unmonitorIntersections = function(doc) {
-    var index = this._monitoringDocuments.indexOf(doc);
-    if (index == -1) {
-      return;
+  });
+
+  // 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);
     }
-    var rootDoc = this.root && (this.root.ownerDocument || this.root) || document2;
-    var hasDependentTargets = this._observationTargets.some(function(item) {
-      var itemDoc = item.element.ownerDocument;
-      if (itemDoc == doc) {
-        return true;
-      }
-      while (itemDoc && itemDoc != rootDoc) {
-        var frame2 = getFrameElement(itemDoc);
-        itemDoc = frame2 && frame2.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;
         }
-      }
-      return false;
-    });
-    if (hasDependentTargets) {
-      return;
-    }
-    var unsubscribe = this._monitoringUnsubscribes[index];
-    this._monitoringDocuments.splice(index, 1);
-    this._monitoringUnsubscribes.splice(index, 1);
-    unsubscribe();
-    if (doc != rootDoc) {
-      var frame = getFrameElement(doc);
-      if (frame) {
-        this._unmonitorIntersections(frame.ownerDocument);
-      }
-    }
-  };
-  IntersectionObserver2.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]();
+        // 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);
     }
-  };
-  IntersectionObserver2.prototype._checkForIntersections = function() {
-    if (!this.root && crossOriginUpdater && !crossOriginRect) {
-      return;
+  }
+};
+
+
+/**
+ * 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 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);
       }
-      var newEntry = item.entry = new IntersectionObserverEntry2({
-        time: now(),
-        target,
-        boundingClientRect: targetRect,
-        rootBounds,
-        intersectionRect
-      });
-      if (!oldEntry) {
+    } 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);
-      } else if (rootIsInDom && rootContainsTarget) {
-        if (this._hasCrossedThreshold(oldEntry, newEntry)) {
-          this._queuedEntries.push(newEntry);
-        }
-      } else {
-        if (oldEntry && oldEntry.isIntersecting) {
-          this._queuedEntries.push(newEntry);
-        }
       }
-    }, this);
-    if (this._queuedEntries.length) {
-      this._callback(this.takeRecords(), this);
     }
-  };
-  IntersectionObserver2.prototype._computeTargetAndRootIntersection = function(target, targetRect, rootRect) {
-    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 (parentComputedStyle.display == "none")
-        return null;
-      if (parent == this.root || parent.nodeType == 9) {
-        atRoot = true;
-        if (parent == this.root || parent == document2) {
-          if (crossOriginUpdater && !this.root) {
-            if (!crossOriginRect || crossOriginRect.width == 0 && crossOriginRect.height == 0) {
-              parent = null;
-              parentRect = null;
-              intersectionRect = null;
-            } else {
-              parentRect = crossOriginRect;
-            }
-          } else {
-            parentRect = rootRect;
-          }
-        } else {
-          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 {
+  }, 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 {
-        var doc = parent.ownerDocument;
-        if (parent != doc.body && parent != doc.documentElement && parentComputedStyle.overflow != "visible") {
-          parentRect = getBoundingClientRect(parent);
+        // 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;
         }
       }
-      if (parentRect) {
-        intersectionRect = computeRectIntersection(parentRect, intersectionRect);
-      }
-      if (!intersectionRect)
-        break;
-      parent = parent && getParentNode(parent);
-    }
-    return intersectionRect;
-  };
-  IntersectionObserver2.prototype._getRootRect = function() {
-    var rootRect;
-    if (this.root && !isDoc(this.root)) {
-      rootRect = getBoundingClientRect(this.root);
     } else {
-      var doc = isDoc(this.root) ? this.root : document2;
-      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);
-  };
-  IntersectionObserver2.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;
-  };
-  IntersectionObserver2.prototype._hasCrossedThreshold = function(oldEntry, newEntry) {
-    var oldRatio = oldEntry && oldEntry.isIntersecting ? oldEntry.intersectionRatio || 0 : -1;
-    var newRatio = newEntry.isIntersecting ? newEntry.intersectionRatio || 0 : -1;
-    if (oldRatio === newRatio)
-      return;
-    for (var i = 0; i < this.thresholds.length; i++) {
-      var threshold = this.thresholds[i];
-      if (threshold == oldRatio || threshold == newRatio || threshold < oldRatio !== threshold < newRatio) {
-        return true;
+      // 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);
       }
     }
-  };
-  IntersectionObserver2.prototype._rootIsInDom = function() {
-    return !this.root || containsDeep(document2, this.root);
-  };
-  IntersectionObserver2.prototype._rootContainsTarget = function(target) {
-    var rootDoc = this.root && (this.root.ownerDocument || this.root) || document2;
-    return containsDeep(rootDoc, target) && (!this.root || rootDoc == target.ownerDocument);
-  };
-  IntersectionObserver2.prototype._registerInstance = function() {
-    if (registry.indexOf(this) < 0) {
-      registry.push(this);
+
+    // If either of the above conditionals set a new parentRect,
+    // calculate new intersection data.
+    if (parentRect) {
+      intersectionRect = computeRectIntersection(parentRect, intersectionRect);
     }
-  };
-  IntersectionObserver2.prototype._unregisterInstance = function() {
-    var index = registry.indexOf(this);
-    if (index != -1)
-      registry.splice(index, 1);
-  };
-  function now() {
-    return window.performance && performance.now && performance.now();
+    if (!intersectionRect) break;
+    parent = parent && getParentNode(parent);
   }
-  function throttle(fn, timeout) {
-    var timer = null;
-    return function() {
-      if (!timer) {
-        timer = setTimeout(function() {
-          fn();
-          timer = null;
-        }, timeout);
-      }
+  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
     };
   }
-  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);
+  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;
     }
   }
-  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 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);
   }
-  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,
-      bottom,
-      left,
-      right,
-      width,
-      height
-    } || null;
+  else if (typeof node.attachEvent == 'function') {
+    node.attachEvent('on' + event, fn);
   }
-  function getBoundingClientRect(el) {
-    var rect;
-    try {
-      rect = el.getBoundingClientRect();
-    } catch (err) {
-    }
-    if (!rect)
-      return getEmptyRect();
-    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;
+}
+
+
+/**
+ * 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);
   }
-  function getEmptyRect() {
-    return {
-      top: 0,
-      bottom: 0,
-      left: 0,
-      right: 0,
-      width: 0,
-      height: 0
-    };
+  else if (typeof node.detatchEvent == 'function') {
+    node.detatchEvent('on' + event, fn);
   }
-  function ensureDOMRect(rect) {
-    if (!rect || "x" in rect) {
-      return rect;
-    }
-    return {
+}
+
+
+/**
+ * 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,
-      y: rect.top,
+      right: rect.right,
       bottom: rect.bottom,
       left: rect.left,
-      x: rect.left,
-      right: rect.right,
-      width: rect.width,
-      height: rect.height
-    };
-  }
-  function convertFromParentRect(parentBoundingRect, parentIntersectionRect) {
-    var top = parentIntersectionRect.top - parentBoundingRect.top;
-    var left = parentIntersectionRect.left - parentBoundingRect.left;
-    return {
-      top,
-      left,
-      height: parentIntersectionRect.height,
-      width: parentIntersectionRect.width,
-      bottom: top + parentIntersectionRect.height,
-      right: left + parentIntersectionRect.width
+      width: rect.right - rect.left,
+      height: rect.bottom - rect.top
     };
   }
-  function containsDeep(parent, child) {
-    var node = child;
-    while (node) {
-      if (node == parent)
-        return true;
-      node = getParentNode(node);
-    }
-    return false;
+  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;
   }
-  function getParentNode(node) {
-    var parent = node.parentNode;
-    if (node.nodeType == 9 && node != document2) {
-      return getFrameElement(node);
-    }
-    if (parent && parent.assignedSlot) {
-      parent = parent.assignedSlot.parentNode;
-    }
-    if (parent && parent.nodeType == 11 && parent.host) {
-      return parent.host;
-    }
-    return parent;
+  // 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);
   }
-  function isDoc(node) {
-    return node && node.nodeType === 9;
+  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);
   }
-  window.IntersectionObserver = IntersectionObserver2;
-  window.IntersectionObserverEntry = IntersectionObserverEntry2;
-})();
-var eventemitter3 = { exports: {} };
-(function(module) {
-  var has = Object.prototype.hasOwnProperty, prefix = "~";
-  function Events() {
+
+  // If the parent has element that is assigned through shadow root slot
+  if (parent && parent.assignedSlot) {
+    parent = parent.assignedSlot.parentNode;
   }
-  if (Object.create) {
-    Events.prototype = Object.create(null);
-    if (!new Events().__proto__)
-      prefix = false;
+
+  if (parent && parent.nodeType == 11 && parent.host) {
+    // If the parent is a shadow root, return the host element.
+    return parent.host;
   }
-  function EE(fn, context, once) {
-    this.fn = fn;
-    this.context = context;
-    this.once = once || false;
+
+  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');
   }
-  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;
+
+  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);
   }
-  function clearEvent(emitter, evt) {
-    if (--emitter._eventsCount === 0)
-      emitter._events = new Events();
-    else
-      delete emitter._events[evt];
+
+  if (Object.getOwnPropertySymbols) {
+    return names.concat(Object.getOwnPropertySymbols(events));
   }
-  function EventEmitter() {
-    this._events = new Events();
-    this._eventsCount = 0;
+
+  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;
   }
-  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 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;
     }
-    return names;
-  };
-  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;
+
+    for (i = 1, args = new Array(len -1); i < len; i++) {
+      args[i - 1] = arguments[i];
     }
-    return ee;
-  };
-  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;
-  };
-  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, void 0, true);
+
+    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:
-          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, void 0, 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);
-        }
+        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;
-  };
-  EventEmitter.prototype.on = function on(event, fn, context) {
-    return addListener(this, event, fn, context, false);
-  };
-  EventEmitter.prototype.once = function once(event, fn, context) {
-    return addListener(this, event, fn, context, true);
-  };
-  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-    var evt = prefix ? prefix + event : event;
-    if (!this._events[evt])
-      return this;
-    if (!fn) {
+  }
+
+  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);
-      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]);
       }
-    } 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]);
-        }
-      }
-      if (events.length)
-        this._events[evt] = events.length === 1 ? events[0] : events;
-      else
-        clearEvent(this, evt);
-    }
-    return this;
-  };
-  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;
-  };
-  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-  EventEmitter.prefixed = prefix;
-  EventEmitter.EventEmitter = EventEmitter;
-  {
-    module.exports = EventEmitter;
+
+    //
+    // 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);
   }
-})(eventemitter3);
-var __defProp2 = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp2(target, key, result);
-  return result;
+
+  return this;
 };
-const NAVBAR_HEIGHT = 60;
-const _PositioningService = class {
-  static on(eventName, handler) {
-    _PositioningService.events.on(eventName, handler);
-  }
-  static off(eventName, handler) {
-    _PositioningService.events.off(eventName, handler);
-  }
-  static once(eventName, handler) {
-    _PositioningService.events.once(eventName, handler);
+
+/**
+ * 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;
   }
-  static checkCollisions(element, otherElements) {
-    const otherElementsList = otherElements || Array.from(_PositioningService.elements.keys());
-    const bounds = element.getBoundingClientRect();
-    const collisions = [];
-    for (const otherElement of otherElementsList) {
-      if (otherElement !== element) {
-        const otherBounds = otherElement.getBoundingClientRect();
-        if (otherBounds.left <= bounds.right && otherBounds.right >= bounds.left && otherBounds.top <= bounds.bottom && otherBounds.bottom >= bounds.top) {
-          collisions.push(otherElement);
+
+  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];
         }
-      }
-    }
-    if (collisions.length) {
-      _PositioningService.onElementIntersection(element, collisions);
-    }
-  }
-  static isPositioned(element) {
-    return _PositioningService.elements.has(element);
-  }
-  static getPositioningOptions(element) {
-    if (_PositioningService.elements.has(element)) {
-      return _PositioningService.elements.get(element);
-    }
-    return null;
-  }
-  static position(element, options = {}) {
-    const opts = __spreadValues(__spreadValues({}, DEFAULT_POSITIONING_OPTIONS), options);
-    let 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);
+        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 };
         }
-        break;
-      }
-    }
-    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);
-    onNextTick(() => {
-      _PositioningService.fixElementPosition(element);
-      _PositioningService.viewportObserver.observe(element);
-      element.style.visibility = "";
-      _PositioningService.checkCollisions(element);
-    });
-  }
-  static release(element) {
-    if (_PositioningService.elements.has(element)) {
-      _PositioningService.clearStyles(element);
-      const 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);
-    }
-  }
-  static releaseAll() {
-    for (const element of _PositioningService.elements.keys()) {
-      _PositioningService.release(element);
-    }
-  }
-  static refresh(element) {
-    if (_PositioningService.elements.has(element)) {
-      _PositioningService.clearStyles(element);
-      _PositioningService.fixElementPosition(element);
-      _PositioningService.checkCollisions(element);
-    }
-  }
-  static refreshAll() {
-    for (const element of _PositioningService.elements.keys()) {
-      _PositioningService.refresh(element);
+    };
+    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);
     }
-  }
-  static reposition(element, newOptions) {
-    if (_PositioningService.elements.has(element)) {
-      const options = _PositioningService.elements.get(element);
-      _PositioningService.elements.set(element, Object.assign(options, newOptions));
-      _PositioningService.refresh(element);
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
     }
-  }
-  static onViewportIntersection(entries) {
-    for (const entry of entries) {
-      const entryCopy = Object.keys(IntersectionObserverEntry.prototype).reduce((copy, key) => __spreadProps(__spreadValues({}, copy), {
-        [key]: entry[key]
-      }), {});
-      entryCopy.rootBounds = entryCopy.rootBounds || _PositioningService.getRootBounds();
-      _PositioningService.events.emit("viewportIntersection", Object.freeze(entryCopy));
+    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() {
     }
-  }
-  static onElementIntersection(target, intersectingWith) {
-    _PositioningService.events.emit("elementIntersection", { target, intersectingWith });
-  }
-  static getRootBounds() {
-    const rootWidth = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
-    const 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.on = function (eventName, handler) {
+        PositioningService.events.on(eventName, handler);
     };
-  }
-  static clearStyles(element) {
-    Object.assign(element.style, {
-      position: "",
-      width: "",
-      top: "",
-      left: "",
-      right: "",
-      bottom: "",
-      visibility: "",
-      zIndex: ""
-    });
-  }
-  static fixElementPosition(element, options) {
-    if (!this.elements.has(element)) {
-      return;
-    }
-    const opts = options || this.elements.get(element);
-    const rootBounds = this.getRootBounds();
-    const positionedElementBounds = element.getBoundingClientRect();
-    const relativeTargetBounds = opts.relativeTo.getBoundingClientRect();
-    const { width } = opts.useRelativeTargetWidth ? relativeTargetBounds : positionedElementBounds;
-    Object.assign(element.style, {
-      minWidth: `${width}px`,
-      position: "fixed",
-      zIndex: opts.zIndex || ""
-    });
-    let top;
-    let left;
-    const positionRelativeToTarget = opts.position.split(" ");
-    const offsetA = opts.offsets[0] || 0;
-    const 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;
+    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);
+                    }
+                }
+            }
         }
-        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`);
-    }
-    const bottom = top + positionedElementBounds.height;
-    const right = left + positionedElementBounds.width;
-    const topPx = `${Math.round(top)}px`;
-    const bottomPx = `${Math.round(rootBounds.bottom - bottom)}px`;
-    const leftPx = `${Math.round(left)}px`;
-    const rightPx = `${Math.round(rootBounds.right - right)}px`;
-    switch (opts.anchor) {
-      case PositionAnchor.TOP_LEFT:
-        Object.assign(element.style, {
-          top: topPx,
-          bottom: "auto",
-          left: leftPx,
-          right: "auto"
-        });
-        break;
-      case PositionAnchor.TOP_RIGHT:
-        Object.assign(element.style, {
-          top: topPx,
-          bottom: "auto",
-          left: "auto",
-          right: rightPx
+        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);
+        onNextTick(function () {
+            PositioningService.fixElementPosition(element);
+            PositioningService.viewportObserver.observe(element);
+            // eslint-disable-next-line no-param-reassign
+            element.style.visibility = "";
+            PositioningService.checkCollisions(element);
         });
-        break;
-      case PositionAnchor.BOTTOM_LEFT:
+    };
+    /** 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, {
-          top: "auto",
-          bottom: bottomPx,
-          left: leftPx,
-          right: "auto"
+            position: "",
+            width: "",
+            top: "",
+            left: "",
+            right: "",
+            bottom: "",
+            visibility: "",
+            zIndex: "",
         });
-        break;
-      case PositionAnchor.BOTTOM_RIGHT:
+    };
+    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, {
-          top: "auto",
-          bottom: bottomPx,
-          left: "auto",
-          right: rightPx
+            minWidth: width + "px",
+            position: "fixed",
+            zIndex: opts.zIndex || "",
         });
-        break;
-    }
-  }
-  static update(event) {
-    const elements = _PositioningService.elements.entries();
-    const updatedElements = [];
-    for (const [element, options] of elements) {
-      if (!event || event.target === document || event.target === options.scrollParent || event.target === window) {
-        _PositioningService.fixElementPosition(element, options);
-        _PositioningService.checkCollisions(element, updatedElements);
-        updatedElements.push(element);
-      }
-    }
-  }
-  on(eventName, handler) {
-    _PositioningService.on(eventName, handler);
-  }
-  off(eventName, handler) {
-    _PositioningService.off(eventName, handler);
-  }
-  once(eventName, handler) {
-    _PositioningService.once(eventName, handler);
-  }
-  isPositioned(element) {
-    return _PositioningService.isPositioned(element);
-  }
-  getPositioningOptions(element) {
-    return _PositioningService.getPositioningOptions(element);
-  }
-  position(element, options = {}) {
-    _PositioningService.position(element, options);
-  }
-  release(element) {
-    _PositioningService.release(element);
-  }
-  releaseAll() {
-    _PositioningService.releaseAll();
-  }
-  refresh(element) {
-    _PositioningService.refresh(element);
-  }
-  refreshAll() {
-    _PositioningService.refreshAll();
-  }
-  reposition(element, newOptions) {
-    _PositioningService.reposition(element, newOptions);
-  }
-};
-let PositioningService = _PositioningService;
-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
-});
-__decorateClass([
-  lockedToAnimationFrames
-], PositioningService, "update", 1);
+        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 PositionAnchor.TOP_LEFT:
+                Object.assign(element.style, {
+                    top: topPx,
+                    bottom: "auto",
+                    left: leftPx,
+                    right: "auto",
+                });
+                break;
+            case PositionAnchor.TOP_RIGHT:
+                Object.assign(element.style, {
+                    top: topPx,
+                    bottom: "auto",
+                    left: "auto",
+                    right: rightPx,
+                });
+                break;
+            case PositionAnchor.BOTTOM_LEFT:
+                Object.assign(element.style, {
+                    top: "auto",
+                    bottom: bottomPx,
+                    left: leftPx,
+                    right: "auto",
+                });
+                break;
+            case 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([
+        lockedToAnimationFrames,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Event]),
+        __metadata("design:returntype", void 0)
+    ], PositioningService, "update", null);
+    return PositioningService;
+}());
+
 export { DEFAULT_POSITIONING_OPTIONS, Position, PositionAnchor, PositioningService };