@nanoporetech-digital/components 3.7.1 → 3.8.1

package/dist/components/index3.js

@@ -1,1075 +1,641 @@
 /*!
  * Web Components for Nanopore digital Web Apps
  */
-(function () {
-
-    var UNSUPPORTED_ENVIRONMENT = typeof window === "undefined";
-
-    /**
-     * Is true if the browser natively supports the 'scroll-behavior' CSS-property.
-     * @type {boolean}
-     */
-    var SUPPORTS_SCROLL_BEHAVIOR = UNSUPPORTED_ENVIRONMENT ? false : "scrollBehavior" in document.documentElement.style;
-
-    
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation. All rights reserved.
-    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-    this file except in compliance with the License. You may obtain a copy of the
-    License at http://www.apache.org/licenses/LICENSE-2.0
-
-    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-    MERCHANTABLITY OR NON-INFRINGEMENT.
-
-    See the Apache Version 2.0 License for specific language governing permissions
-    and limitations under the License.
-    ***************************************************************************** */
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m) return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-        }
-        catch (error) { e = { error: error }; }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"])) m.call(i);
-            }
-            finally { if (e) throw e.error; }
-        }
-        return ar;
-    }
-
-    function getScrollingElement() {
-        if (document.scrollingElement != null) {
-            return document.scrollingElement;
-        }
-        else {
-            return document.documentElement;
-        }
-    }
-
-    var STYLE_ATTRIBUTE_PROPERTY_NAME = "scroll-behavior";
-    var STYLE_ATTRIBUTE_PROPERTY_REGEXP = new RegExp(STYLE_ATTRIBUTE_PROPERTY_NAME + ":\\s*([^;]*)");
-    /**
-     * Given an Element, this function appends the given ScrollBehavior CSS property value to the elements' 'style' attribute.
-     * If it doesnt already have one, it will add it.
-     * @param {Element} element
-     * @param {ScrollBehavior} behavior
-     */
-    function appendScrollBehaviorToStyleAttribute(element, behavior) {
-        var addition = STYLE_ATTRIBUTE_PROPERTY_NAME + ":" + behavior;
-        var attributeValue = element.getAttribute("style");
-        if (attributeValue == null || attributeValue === "") {
-            element.setAttribute("style", addition);
-            return;
-        }
-        // The style attribute may already include a 'scroll-behavior:<something>' in which case that should be replaced
-        var existingValueForProperty = parseScrollBehaviorFromStyleAttribute(element);
-        if (existingValueForProperty != null) {
-            var replacementProperty = STYLE_ATTRIBUTE_PROPERTY_NAME + ":" + existingValueForProperty;
-            // Replace the variant that ends with a semi-colon which it may
-            attributeValue = attributeValue.replace(replacementProperty + ";", "");
-            // Replace the variant that *doesn't* end with a semi-colon
-            attributeValue = attributeValue.replace(replacementProperty, "");
-        }
-        // Now, append the behavior to the string.
-        element.setAttribute("style", attributeValue.endsWith(";") ? "" + attributeValue + addition : ";" + attributeValue + addition);
-    }
-    /**
-     * Given an Element, this function attempts to parse its 'style' attribute (if it has one)' to extract
-     * a value for the 'scroll-behavior' CSS property (if it is given within that style attribute)
-     * @param {Element} element
-     * @returns {ScrollBehavior?}
-     */
-    function parseScrollBehaviorFromStyleAttribute(element) {
-        var styleAttributeValue = element.getAttribute("style");
-        if (styleAttributeValue != null && styleAttributeValue.includes(STYLE_ATTRIBUTE_PROPERTY_NAME)) {
-            var match = styleAttributeValue.match(STYLE_ATTRIBUTE_PROPERTY_REGEXP);
-            if (match != null) {
-                var _a = __read(match, 2), behavior = _a[1];
-                if (behavior != null && behavior !== "") {
-                    return behavior;
-                }
-            }
-        }
-        return undefined;
-    }
-
-    var styleDeclarationPropertyName = "scrollBehavior";
-    /**
-     * Determines the scroll behavior to use, depending on the given ScrollOptions and the position of the Element
-     * within the DOM
-     * @param {Element|HTMLElement|Window} inputTarget
-     * @param {ScrollOptions} [options]
-     * @returns {ScrollBehavior}
-     */
-    function getScrollBehavior(inputTarget, options) {
-        // If the given 'behavior' is 'smooth', apply smooth scrolling no matter what
-        if (options != null && options.behavior === "smooth")
-            return "smooth";
-        var target = "style" in inputTarget ? inputTarget : getScrollingElement();
-        var value;
-        if ("style" in target) {
-            // Check if scroll-behavior is set as a property on the CSSStyleDeclaration
-            var scrollBehaviorPropertyValue = target.style[styleDeclarationPropertyName];
-            // Return it if it is given and has a proper value
-            if (scrollBehaviorPropertyValue != null && scrollBehaviorPropertyValue !== "") {
-                value = scrollBehaviorPropertyValue;
-            }
-        }
-        if (value == null) {
-            var attributeValue = target.getAttribute("scroll-behavior");
-            if (attributeValue != null && attributeValue !== "") {
-                value = attributeValue;
-            }
-        }
-        if (value == null) {
-            // Otherwise, check if it is set as an inline style
-            value = parseScrollBehaviorFromStyleAttribute(target);
-        }
-        if (value == null) {
-            // Take the computed style for the element and see if it contains a specific 'scroll-behavior' value
-            var computedStyle = getComputedStyle(target);
-            var computedStyleValue = computedStyle.getPropertyValue("scrollBehavior");
-            if (computedStyleValue != null && computedStyleValue !== "") {
-                value = computedStyleValue;
-            }
-        }
-        // In all other cases, use the value from the CSSOM
-        return value;
-    }
-
-    
-
-    
-
-    var HALF = 0.5;
-    /**
-     * The easing function to use when applying the smooth scrolling
-     * @param {number} k
-     * @returns {number}
-     */
-    function ease(k) {
-        return HALF * (1 - Math.cos(Math.PI * k));
-    }
-
-    var NOOP = {
-        reset: function () { }
-    };
-    var map = typeof WeakMap === "undefined" ? undefined : new WeakMap();
-    function disableScrollSnap(scroller) {
-        // If scroll-behavior is natively supported, or if there is no native WeakMap support, there's no need for this fix
-        if (SUPPORTS_SCROLL_BEHAVIOR || map == null) {
-            return NOOP;
-        }
-        var scrollingElement = getScrollingElement();
-        var cachedScrollSnapValue;
-        var cachedScrollBehaviorStyleAttributeValue;
-        var secondaryScroller;
-        var secondaryScrollerCachedScrollSnapValue;
-        var secondaryScrollerCachedScrollBehaviorStyleAttributeValue;
-        var existingResult = map.get(scroller);
-        if (existingResult != null) {
-            cachedScrollSnapValue = existingResult.cachedScrollSnapValue;
-            cachedScrollBehaviorStyleAttributeValue = existingResult.cachedScrollBehaviorStyleAttributeValue;
-            secondaryScroller = existingResult.secondaryScroller;
-            secondaryScrollerCachedScrollSnapValue = existingResult.secondaryScrollerCachedScrollSnapValue;
-            secondaryScrollerCachedScrollBehaviorStyleAttributeValue = existingResult.secondaryScrollerCachedScrollBehaviorStyleAttributeValue;
-            existingResult.release();
-        }
-        else {
-            cachedScrollSnapValue = scroller.style.scrollSnapType === "" ? null : scroller.style.scrollSnapType;
-            cachedScrollBehaviorStyleAttributeValue = parseScrollBehaviorFromStyleAttribute(scroller);
-            secondaryScroller = scroller === scrollingElement && scrollingElement !== document.body ? document.body : undefined;
-            secondaryScrollerCachedScrollSnapValue =
-                secondaryScroller == null ? undefined : secondaryScroller.style.scrollSnapType === "" ? null : secondaryScroller.style.scrollSnapType;
-            secondaryScrollerCachedScrollBehaviorStyleAttributeValue =
-                secondaryScroller == null ? undefined : parseScrollBehaviorFromStyleAttribute(secondaryScroller);
-            var cachedComputedScrollSnapValue = getComputedStyle(scroller).getPropertyValue("scroll-snap-type");
-            var secondaryScrollerCachedComputedScrollSnapValue = secondaryScroller == null ? undefined : getComputedStyle(secondaryScroller).getPropertyValue("scroll-snap-type");
-            // If it just so happens that there actually isn't any scroll snapping going on, there's no point in performing any additional work here.
-            if (cachedComputedScrollSnapValue === "none" && secondaryScrollerCachedComputedScrollSnapValue === "none") {
-                return NOOP;
-            }
-        }
-        scroller.style.scrollSnapType = "none";
-        if (secondaryScroller !== undefined) {
-            secondaryScroller.style.scrollSnapType = "none";
-        }
-        if (cachedScrollBehaviorStyleAttributeValue !== undefined) {
-            appendScrollBehaviorToStyleAttribute(scroller, cachedScrollBehaviorStyleAttributeValue);
-        }
-        if (secondaryScroller !== undefined && secondaryScrollerCachedScrollBehaviorStyleAttributeValue !== undefined) {
-            appendScrollBehaviorToStyleAttribute(secondaryScroller, secondaryScrollerCachedScrollBehaviorStyleAttributeValue);
-        }
-        var hasReleased = false;
-        var eventTarget = scroller === scrollingElement ? window : scroller;
-        function release() {
-            eventTarget.removeEventListener("scroll", resetHandler);
-            if (map != null) {
-                map["delete"](scroller);
-            }
-            hasReleased = true;
-        }
-        function resetHandler() {
-            scroller.style.scrollSnapType = cachedScrollSnapValue;
-            if (secondaryScroller != null && secondaryScrollerCachedScrollSnapValue !== undefined) {
-                secondaryScroller.style.scrollSnapType = secondaryScrollerCachedScrollSnapValue;
-            }
-            if (cachedScrollBehaviorStyleAttributeValue !== undefined) {
-                appendScrollBehaviorToStyleAttribute(scroller, cachedScrollBehaviorStyleAttributeValue);
-            }
-            if (secondaryScroller !== undefined && secondaryScrollerCachedScrollBehaviorStyleAttributeValue !== undefined) {
-                appendScrollBehaviorToStyleAttribute(secondaryScroller, secondaryScrollerCachedScrollBehaviorStyleAttributeValue);
-            }
-            release();
-        }
-        function reset() {
-            setTimeout(function () {
-                if (hasReleased)
-                    return;
-                eventTarget.addEventListener("scroll", resetHandler);
-            });
-        }
-        map.set(scroller, {
-            release: release,
-            cachedScrollSnapValue: cachedScrollSnapValue,
-            cachedScrollBehaviorStyleAttributeValue: cachedScrollBehaviorStyleAttributeValue,
-            secondaryScroller: secondaryScroller,
-            secondaryScrollerCachedScrollSnapValue: secondaryScrollerCachedScrollSnapValue,
-            secondaryScrollerCachedScrollBehaviorStyleAttributeValue: secondaryScrollerCachedScrollBehaviorStyleAttributeValue
-        });
-        return {
-            reset: reset
-        };
-    }
-
-    /**
-     * The duration of a smooth scroll
-     * @type {number}
-     */
-    var SCROLL_TIME = 15000;
-    /**
-     * Performs a smooth repositioning of the scroll
-     * @param {ISmoothScrollOptions} options
-     */
-    function smoothScroll(options) {
-        var startTime = options.startTime, startX = options.startX, startY = options.startY, endX = options.endX, endY = options.endY, method = options.method, scroller = options.scroller;
-        var timeLapsed = 0;
-        var distanceX = endX - startX;
-        var distanceY = endY - startY;
-        var speed = Math.max(Math.abs((distanceX / 1000) * SCROLL_TIME), Math.abs((distanceY / 1000) * SCROLL_TIME));
-        // Temporarily disables any scroll snapping that may be active since it fights for control over the scroller with this polyfill
-        var scrollSnapFix = disableScrollSnap(scroller);
-        requestAnimationFrame(function animate(timestamp) {
-            timeLapsed += timestamp - startTime;
-            var percentage = Math.max(0, Math.min(1, speed === 0 ? 0 : timeLapsed / speed));
-            var positionX = Math.floor(startX + distanceX * ease(percentage));
-            var positionY = Math.floor(startY + distanceY * ease(percentage));
-            method(positionX, positionY);
-            if (positionX !== endX || positionY !== endY) {
-                requestAnimationFrame(animate);
-            }
-            else {
-                if (scrollSnapFix != null) {
-                    scrollSnapFix.reset();
-                    scrollSnapFix = undefined;
-                }
-            }
-        });
-    }
-
-    /**
-     * Returns a High Resolution timestamp if possible, otherwise fallbacks to Date.now()
-     * @returns {number}
-     */
-    function now() {
-        if ("performance" in window)
-            return performance.now();
-        return Date.now();
-    }
-
-    
-
-    var ELEMENT_ORIGINAL_SCROLL = UNSUPPORTED_ENVIRONMENT ? undefined : Element.prototype.scroll;
-
-    var WINDOW_ORIGINAL_SCROLL = UNSUPPORTED_ENVIRONMENT ? undefined : window.scroll;
-
-    var ELEMENT_ORIGINAL_SCROLL_BY = UNSUPPORTED_ENVIRONMENT ? undefined : Element.prototype.scrollBy;
-
-    var WINDOW_ORIGINAL_SCROLL_BY = UNSUPPORTED_ENVIRONMENT ? undefined : window.scrollBy;
-
-    var ELEMENT_ORIGINAL_SCROLL_TO = UNSUPPORTED_ENVIRONMENT ? undefined : Element.prototype.scrollTo;
-
-    var WINDOW_ORIGINAL_SCROLL_TO = UNSUPPORTED_ENVIRONMENT ? undefined : window.scrollTo;
-
-    /**
-     * A fallback if Element.prototype.scroll is not defined
-     * @param {number} x
-     * @param {number} y
-     */
-    function elementPrototypeScrollFallback(x, y) {
-        this.__adjustingScrollPosition = true;
-        this.scrollLeft = x;
-        this.scrollTop = y;
-        delete this.__adjustingScrollPosition;
-    }
-    /**
-     * A fallback if Element.prototype.scrollTo is not defined
-     * @param {number} x
-     * @param {number} y
-     */
-    function elementPrototypeScrollToFallback(x, y) {
-        return elementPrototypeScrollFallback.call(this, x, y);
-    }
-    /**
-     * A fallback if Element.prototype.scrollBy is not defined
-     * @param {number} x
-     * @param {number} y
-     */
-    function elementPrototypeScrollByFallback(x, y) {
-        this.__adjustingScrollPosition = true;
-        this.scrollLeft += x;
-        this.scrollTop += y;
-        delete this.__adjustingScrollPosition;
-    }
-    /**
-     * Gets the original non-patched prototype method for the given kind
-     * @param {ScrollMethodName} kind
-     * @param {Element|Window} element
-     * @return {Function}
-     */
-    function getOriginalScrollMethodForKind(kind, element) {
-        switch (kind) {
-            case "scroll":
-                if (element instanceof Element) {
-                    if (ELEMENT_ORIGINAL_SCROLL != null) {
-                        return ELEMENT_ORIGINAL_SCROLL;
-                    }
-                    else {
-                        return elementPrototypeScrollFallback;
-                    }
-                }
-                else {
-                    return WINDOW_ORIGINAL_SCROLL;
-                }
-            case "scrollBy":
-                if (element instanceof Element) {
-                    if (ELEMENT_ORIGINAL_SCROLL_BY != null) {
-                        return ELEMENT_ORIGINAL_SCROLL_BY;
-                    }
-                    else {
-                        return elementPrototypeScrollByFallback;
-                    }
-                }
-                else {
-                    return WINDOW_ORIGINAL_SCROLL_BY;
-                }
-            case "scrollTo":
-                if (element instanceof Element) {
-                    if (ELEMENT_ORIGINAL_SCROLL_TO != null) {
-                        return ELEMENT_ORIGINAL_SCROLL_TO;
-                    }
-                    else {
-                        return elementPrototypeScrollToFallback;
-                    }
-                }
-                else {
-                    return WINDOW_ORIGINAL_SCROLL_TO;
-                }
-        }
-    }
-
-    /**
-     * Gets the Smooth Scroll Options to use for the step function
-     * @param {Element|Window} element
-     * @param {number} x
-     * @param {number} y
-     * @param {ScrollMethodName} kind
-     * @returns {ISmoothScrollOptions}
-     */
-    function getSmoothScrollOptions(element, x, y, kind) {
-        var startTime = now();
-        if (!(element instanceof Element)) {
-            // Use window as the scroll container
-            var scrollX_1 = window.scrollX, pageXOffset_1 = window.pageXOffset, scrollY_1 = window.scrollY, pageYOffset_1 = window.pageYOffset;
-            var startX = scrollX_1 == null || scrollX_1 === 0 ? pageXOffset_1 : scrollX_1;
-            var startY = scrollY_1 == null || scrollY_1 === 0 ? pageYOffset_1 : scrollY_1;
-            return {
-                startTime: startTime,
-                startX: startX,
-                startY: startY,
-                endX: Math.floor(kind === "scrollBy" ? startX + x : x),
-                endY: Math.floor(kind === "scrollBy" ? startY + y : y),
-                method: getOriginalScrollMethodForKind("scrollTo", window).bind(window),
-                scroller: getScrollingElement()
-            };
-        }
-        else {
-            var scrollLeft = element.scrollLeft, scrollTop = element.scrollTop;
-            var startX = scrollLeft;
-            var startY = scrollTop;
-            return {
-                startTime: startTime,
-                startX: startX,
-                startY: startY,
-                endX: Math.floor(kind === "scrollBy" ? startX + x : x),
-                endY: Math.floor(kind === "scrollBy" ? startY + y : y),
-                method: getOriginalScrollMethodForKind("scrollTo", element).bind(element),
-                scroller: element
-            };
-        }
-    }
-
-    /**
-     * Ensures that the given value is numeric
-     * @param {number} value
-     * @return {number}
-     */
-    function ensureNumeric(value) {
-        if (value == null)
-            return 0;
-        else if (typeof value === "number") {
-            return value;
-        }
-        else if (typeof value === "string") {
-            return parseFloat(value);
-        }
-        else {
-            return 0;
-        }
-    }
-
-    /**
-     * Returns true if the given value is some ScrollToOptions
-     * @param {number | ScrollToOptions} value
-     * @return {value is ScrollToOptions}
-     */
-    function isScrollToOptions(value) {
-        return value != null && typeof value === "object";
-    }
-
-    /**
-     * Handles a scroll method
-     * @param {Element|Window} element
-     * @param {ScrollMethodName} kind
-     * @param {number | ScrollToOptions} optionsOrX
-     * @param {number} y
-     */
-    function handleScrollMethod(element, kind, optionsOrX, y) {
-        onScrollWithOptions(getScrollToOptionsWithValidation(optionsOrX, y), element, kind);
-    }
-    /**
-     * Invoked when a 'ScrollToOptions' dict is provided to 'scroll()' as the first argument
-     * @param {ScrollToOptions} options
-     * @param {Element|Window} element
-     * @param {ScrollMethodName} kind
-     */
-    function onScrollWithOptions(options, element, kind) {
-        var behavior = getScrollBehavior(element, options);
-        // If the behavior is 'auto' apply instantaneous scrolling
-        if (behavior == null || behavior === "auto") {
-            getOriginalScrollMethodForKind(kind, element).call(element, options.left, options.top);
-        }
-        else {
-            smoothScroll(getSmoothScrollOptions(element, options.left, options.top, kind));
-        }
-    }
-    /**
-     * Normalizes the given scroll coordinates
-     * @param {number?} x
-     * @param {number?} y
-     * @return {Required<Pick<ScrollToOptions, "top" | "left">>}
-     */
-    function normalizeScrollCoordinates(x, y) {
-        return {
-            left: ensureNumeric(x),
-            top: ensureNumeric(y)
-        };
-    }
-    /**
-     * Gets ScrollToOptions based on the given arguments. Will throw if validation fails
-     * @param {number | ScrollToOptions} optionsOrX
-     * @param {number} y
-     * @return {Required<ScrollToOptions>}
-     */
-    function getScrollToOptionsWithValidation(optionsOrX, y) {
-        // If only one argument is given, and it isn't an options object, throw a TypeError
-        if (y === undefined && !isScrollToOptions(optionsOrX)) {
-            throw new TypeError("Failed to execute 'scroll' on 'Element': parameter 1 ('options') is not an object.");
-        }
-        // Scroll based on the primitive values given as arguments
-        if (!isScrollToOptions(optionsOrX)) {
-            return __assign(__assign({}, normalizeScrollCoordinates(optionsOrX, y)), { behavior: "auto" });
-        }
-        // Scroll based on the received options object
-        else {
-            return __assign(__assign({}, normalizeScrollCoordinates(optionsOrX.left, optionsOrX.top)), { behavior: optionsOrX.behavior == null ? "auto" : optionsOrX.behavior });
-        }
-    }
-
-    /**
-     * Patches the 'scroll' method on the Element prototype
-     */
-    function patchElementScroll() {
-        Element.prototype.scroll = function (optionsOrX, y) {
-            handleScrollMethod(this, "scroll", optionsOrX, y);
-        };
-    }
-
-    /**
-     * Patches the 'scrollBy' method on the Element prototype
-     */
-    function patchElementScrollBy() {
-        Element.prototype.scrollBy = function (optionsOrX, y) {
-            handleScrollMethod(this, "scrollBy", optionsOrX, y);
-        };
-    }
-
-    /**
-     * Patches the 'scrollTo' method on the Element prototype
-     */
-    function patchElementScrollTo() {
-        Element.prototype.scrollTo = function (optionsOrX, y) {
-            handleScrollMethod(this, "scrollTo", optionsOrX, y);
-        };
-    }
-
-    /**
-     * Patches the 'scroll' method on the Window prototype
-     */
-    function patchWindowScroll() {
-        window.scroll = function (optionsOrX, y) {
-            handleScrollMethod(this, "scroll", optionsOrX, y);
-        };
-    }
-
-    /**
-     * Patches the 'scrollBy' method on the Window prototype
-     */
-    function patchWindowScrollBy() {
-        window.scrollBy = function (optionsOrX, y) {
-            handleScrollMethod(this, "scrollBy", optionsOrX, y);
-        };
-    }
-
-    /**
-     * Patches the 'scrollTo' method on the Window prototype
-     */
-    function patchWindowScrollTo() {
-        window.scrollTo = function (optionsOrX, y) {
-            handleScrollMethod(this, "scrollTo", optionsOrX, y);
-        };
-    }
-
-    // tslint:disable:no-any
-    /**
-     * Gets the parent of an element, taking into account DocumentFragments, ShadowRoots, as well as the root context (window)
-     * @param {EventTarget} currentElement
-     * @returns {EventTarget | null}
-     */
-    function getParent(currentElement) {
-        if ("nodeType" in currentElement && currentElement.nodeType === 1) {
-            return currentElement.parentNode;
-        }
-        if ("ShadowRoot" in window && currentElement instanceof window.ShadowRoot) {
-            return currentElement.host;
-        }
-        else if (currentElement === document) {
-            return window;
-        }
-        else if (currentElement instanceof Node)
-            return currentElement.parentNode;
-        return null;
-    }
-
-    /**
-     * Returns true if the given overflow property represents a scrollable overflow value
-     * @param {string | null} overflow
-     * @return {boolean}
-     */
-    function canOverflow(overflow) {
-        return overflow !== "visible" && overflow !== "clip";
-    }
-    /**
-     * Returns true if the given element is scrollable
-     * @param {Element} element
-     * @return {boolean}
-     */
-    function isScrollable(element) {
-        if (element.clientHeight < element.scrollHeight || element.clientWidth < element.scrollWidth) {
-            var style = getComputedStyle(element, null);
-            return canOverflow(style.overflowY) || canOverflow(style.overflowX);
-        }
+class GestureController {
+  constructor() {
+    this.gestureId = 0;
+    this.requestedStart = new Map();
+    this.disabledGestures = new Map();
+    this.disabledScroll = new Set();
+  }
+  /**
+   * Creates a gesture delegate based on the GestureConfig passed
+   * @param config
+   * @returns a new gesture delegate
+   */
+  createGesture(config) {
+    return new GestureDelegate(this, this.newID(), config.name, config.priority || 0, !!config.disableScroll);
+  }
+  /**
+   * Creates a blocker that will block any other gesture events from firing. Set in the ion-gesture component.
+   * @param opts
+   * @returns a new blocker delegate
+   */
+  createBlocker(opts = {}) {
+    return new BlockerDelegate(this, this.newID(), opts.disable, !!opts.disableScroll);
+  }
+  start(gestureName, id, priority) {
+    if (!this.canStart(gestureName)) {
+      this.requestedStart.delete(id);
+      return false;
+    }
+    this.requestedStart.set(id, priority);
+    return true;
+  }
+  capture(gestureName, id, priority) {
+    if (!this.start(gestureName, id, priority)) {
+      return false;
+    }
+    const requestedStart = this.requestedStart;
+    let maxPriority = -10000;
+    requestedStart.forEach((value) => {
+      maxPriority = Math.max(maxPriority, value);
+    });
+    if (maxPriority === priority) {
+      this.capturedId = id;
+      requestedStart.clear();
+      const event = new CustomEvent('ionGestureCaptured', {
+        detail: { gestureName },
+      });
+      document.dispatchEvent(event);
+      return true;
+    }
+    requestedStart.delete(id);
+    return false;
+  }
+  release(id) {
+    this.requestedStart.delete(id);
+    if (this.capturedId === id) {
+      this.capturedId = undefined;
+    }
+  }
+  disableGesture(gestureName, id) {
+    let set = this.disabledGestures.get(gestureName);
+    if (set === undefined) {
+      set = new Set();
+      this.disabledGestures.set(gestureName, set);
+    }
+    set.add(id);
+  }
+  enableGesture(gestureName, id) {
+    const set = this.disabledGestures.get(gestureName);
+    if (set !== undefined) {
+      set.delete(id);
+    }
+  }
+  disableScroll(id) {
+    this.disabledScroll.add(id);
+    if (this.disabledScroll.size === 1) {
+      document.body.classList.add(BACKDROP_NO_SCROLL);
+    }
+  }
+  enableScroll(id) {
+    this.disabledScroll.delete(id);
+    if (this.disabledScroll.size === 0) {
+      document.body.classList.remove(BACKDROP_NO_SCROLL);
+    }
+  }
+  canStart(gestureName) {
+    if (this.capturedId !== undefined) {
+      // a gesture already captured
+      return false;
+    }
+    if (this.isDisabled(gestureName)) {
+      return false;
+    }
+    return true;
+  }
+  isCaptured() {
+    return this.capturedId !== undefined;
+  }
+  isScrollDisabled() {
+    return this.disabledScroll.size > 0;
+  }
+  isDisabled(gestureName) {
+    const disabled = this.disabledGestures.get(gestureName);
+    if (disabled && disabled.size > 0) {
+      return true;
+    }
+    return false;
+  }
+  newID() {
+    this.gestureId++;
+    return this.gestureId;
+  }
+}
+class GestureDelegate {
+  constructor(ctrl, id, name, priority, disableScroll) {
+    this.id = id;
+    this.name = name;
+    this.disableScroll = disableScroll;
+    this.priority = priority * 1000000 + id;
+    this.ctrl = ctrl;
+  }
+  canStart() {
+    if (!this.ctrl) {
+      return false;
+    }
+    return this.ctrl.canStart(this.name);
+  }
+  start() {
+    if (!this.ctrl) {
+      return false;
+    }
+    return this.ctrl.start(this.name, this.id, this.priority);
+  }
+  capture() {
+    if (!this.ctrl) {
+      return false;
+    }
+    const captured = this.ctrl.capture(this.name, this.id, this.priority);
+    if (captured && this.disableScroll) {
+      this.ctrl.disableScroll(this.id);
+    }
+    return captured;
+  }
+  release() {
+    if (this.ctrl) {
+      this.ctrl.release(this.id);
+      if (this.disableScroll) {
+        this.ctrl.enableScroll(this.id);
+      }
+    }
+  }
+  destroy() {
+    this.release();
+    this.ctrl = undefined;
+  }
+}
+class BlockerDelegate {
+  constructor(ctrl, id, disable, disableScroll) {
+    this.id = id;
+    this.disable = disable;
+    this.disableScroll = disableScroll;
+    this.ctrl = ctrl;
+  }
+  block() {
+    if (!this.ctrl) {
+      return;
+    }
+    if (this.disable) {
+      for (const gesture of this.disable) {
+        this.ctrl.disableGesture(gesture, this.id);
+      }
+    }
+    if (this.disableScroll) {
+      this.ctrl.disableScroll(this.id);
+    }
+  }
+  unblock() {
+    if (!this.ctrl) {
+      return;
+    }
+    if (this.disable) {
+      for (const gesture of this.disable) {
+        this.ctrl.enableGesture(gesture, this.id);
+      }
+    }
+    if (this.disableScroll) {
+      this.ctrl.enableScroll(this.id);
+    }
+  }
+  destroy() {
+    this.unblock();
+    this.ctrl = undefined;
+  }
+}
+const BACKDROP_NO_SCROLL = 'backdrop-no-scroll';
+const GESTURE_CONTROLLER = new GestureController();
+
+const addEventListener = (el, eventName, callback, opts) => {
+  // use event listener options when supported
+  // otherwise it's just a boolean for the "capture" arg
+  const listenerOpts = supportsPassive(el)
+    ? {
+      capture: !!opts.capture,
+      passive: !!opts.passive,
+    }
+    : !!opts.capture;
+  let add;
+  let remove;
+  if (el['__zone_symbol__addEventListener']) {
+    add = '__zone_symbol__addEventListener';
+    remove = '__zone_symbol__removeEventListener';
+  }
+  else {
+    add = 'addEventListener';
+    remove = 'removeEventListener';
+  }
+  el[add](eventName, callback, listenerOpts);
+  return () => {
+    el[remove](eventName, callback, listenerOpts);
+  };
+};
+const supportsPassive = (node) => {
+  if (_sPassive === undefined) {
+    try {
+      const opts = Object.defineProperty({}, 'passive', {
+        get: () => {
+          _sPassive = true;
+        },
+      });
+      node.addEventListener('optsTest', () => {
+        return;
+      }, opts);
+    }
+    catch (e) {
+      _sPassive = false;
+    }
+  }
+  return !!_sPassive;
+};
+let _sPassive;
+
+const MOUSE_WAIT = 2000;
+const createPointerEvents = (el, pointerDown, pointerMove, pointerUp, options) => {
+  let rmTouchStart;
+  let rmTouchMove;
+  let rmTouchEnd;
+  let rmTouchCancel;
+  let rmMouseStart;
+  let rmMouseMove;
+  let rmMouseUp;
+  let lastTouchEvent = 0;
+  const handleTouchStart = (ev) => {
+    lastTouchEvent = Date.now() + MOUSE_WAIT;
+    if (!pointerDown(ev)) {
+      return;
+    }
+    if (!rmTouchMove && pointerMove) {
+      rmTouchMove = addEventListener(el, 'touchmove', pointerMove, options);
+    }
+    if (!rmTouchEnd) {
+      rmTouchEnd = addEventListener(el, 'touchend', handleTouchEnd, options);
+    }
+    if (!rmTouchCancel) {
+      rmTouchCancel = addEventListener(el, 'touchcancel', handleTouchEnd, options);
+    }
+  };
+  const handleMouseDown = (ev) => {
+    if (lastTouchEvent > Date.now()) {
+      return;
+    }
+    if (!pointerDown(ev)) {
+      return;
+    }
+    if (!rmMouseMove && pointerMove) {
+      rmMouseMove = addEventListener(getDocument(el), 'mousemove', pointerMove, options);
+    }
+    if (!rmMouseUp) {
+      rmMouseUp = addEventListener(getDocument(el), 'mouseup', handleMouseUp, options);
+    }
+  };
+  const handleTouchEnd = (ev) => {
+    stopTouch();
+    if (pointerUp) {
+      pointerUp(ev);
+    }
+  };
+  const handleMouseUp = (ev) => {
+    stopMouse();
+    if (pointerUp) {
+      pointerUp(ev);
+    }
+  };
+  const stopTouch = () => {
+    if (rmTouchMove) {
+      rmTouchMove();
+    }
+    if (rmTouchEnd) {
+      rmTouchEnd();
+    }
+    if (rmTouchCancel) {
+      rmTouchCancel();
+    }
+    rmTouchMove = rmTouchEnd = rmTouchCancel = undefined;
+  };
+  const stopMouse = () => {
+    if (rmMouseMove) {
+      rmMouseMove();
+    }
+    if (rmMouseUp) {
+      rmMouseUp();
+    }
+    rmMouseMove = rmMouseUp = undefined;
+  };
+  const stop = () => {
+    stopTouch();
+    stopMouse();
+  };
+  const enable = (isEnabled = true) => {
+    if (!isEnabled) {
+      if (rmTouchStart) {
+        rmTouchStart();
+      }
+      if (rmMouseStart) {
+        rmMouseStart();
+      }
+      rmTouchStart = rmMouseStart = undefined;
+      stop();
+    }
+    else {
+      if (!rmTouchStart) {
+        rmTouchStart = addEventListener(el, 'touchstart', handleTouchStart, options);
+      }
+      if (!rmMouseStart) {
+        rmMouseStart = addEventListener(el, 'mousedown', handleMouseDown, options);
+      }
+    }
+  };
+  const destroy = () => {
+    enable(false);
+    pointerUp = pointerMove = pointerDown = undefined;
+  };
+  return {
+    enable,
+    stop,
+    destroy,
+  };
+};
+const getDocument = (node) => {
+  return node instanceof Document ? node : node.ownerDocument;
+};
+
+const createPanRecognizer = (direction, thresh, maxAngle) => {
+  const radians = maxAngle * (Math.PI / 180);
+  const isDirX = direction === 'x';
+  const maxCosine = Math.cos(radians);
+  const threshold = thresh * thresh;
+  let startX = 0;
+  let startY = 0;
+  let dirty = false;
+  let isPan = 0;
+  return {
+    start(x, y) {
+      startX = x;
+      startY = y;
+      isPan = 0;
+      dirty = true;
+    },
+    detect(x, y) {
+      if (!dirty) {
         return false;
-    }
-    /**
-     * Finds the nearest ancestor of an element that can scroll
-     * @param {Element} target
-     * @returns {Element|Window?}
-     */
-    function findNearestAncestorsWithScrollBehavior(target) {
-        var currentElement = target;
-        var scrollingElement = getScrollingElement();
-        while (currentElement != null) {
-            var behavior = getScrollBehavior(currentElement);
-            if (behavior != null && (currentElement === scrollingElement || isScrollable(currentElement))) {
-                return [currentElement, behavior];
-            }
-            var parent_1 = getParent(currentElement);
-            currentElement = parent_1;
-        }
-        // No such element could be found. Start over, but this time find the nearest ancestor that can simply scroll
-        currentElement = target;
-        while (currentElement != null) {
-            if (currentElement === scrollingElement || isScrollable(currentElement)) {
-                return [currentElement, "auto"];
-            }
-            var parent_2 = getParent(currentElement);
-            currentElement = parent_2;
-        }
-        // Default to the scrolling element
-        return [scrollingElement, "auto"];
-    }
-
-    // tslint:disable:no-any
-    /**
-     * Finds the nearest root from an element
-     * @param {Element} target
-     * @returns {Document|ShadowRoot}
-     */
-    function findNearestRoot(target) {
-        var currentElement = target;
-        while (currentElement != null) {
-            if ("ShadowRoot" in window && currentElement instanceof window.ShadowRoot) {
-                // Assume this is a ShadowRoot
-                return currentElement;
-            }
-            var parent_1 = getParent(currentElement);
-            if (parent_1 === currentElement) {
-                return document;
-            }
-            currentElement = parent_1;
-        }
-        return document;
-    }
-
-    /**
-     * Gets the origin of the given Location or HTMLAnchorElement if available in the runtime, and otherwise shims it. (it's a one-liner)
-     * @returns {string}
-     */
-    function getLocationOrigin(locationLike) {
-        if (locationLike === void 0) { locationLike = location; }
-        if ("origin" in locationLike && locationLike.origin != null) {
-            return locationLike.origin;
-        }
-        var port = locationLike.port != null && locationLike.port.length > 0 ? ":" + locationLike.port : "";
-        if (locationLike.protocol === "http:" && port === ":80") {
-            port = "";
-        }
-        else if (locationLike.protocol === "https:" && port === ":443") {
-            port = "";
-        }
-        return locationLike.protocol + "//" + locationLike.hostname + port;
-    }
-
-    /**
-     * A Regular expression that matches id's of the form "#[digit]"
-     * @type {RegExp}
-     */
-    var ID_WITH_LEADING_DIGIT_REGEXP = /^#\d/;
-    /**
-     * Catches anchor navigation to IDs within the same root and ensures that they can be smooth-scrolled
-     * if the scroll behavior is smooth in the first rooter within that context
-     */
-    function catchNavigation() {
-        // Listen for 'click' events globally
-        window.addEventListener("click", function (e) {
-            // Only work with trusted events on HTMLAnchorElements
-            if (!e.isTrusted || !(e.target instanceof HTMLAnchorElement))
-                return;
-            var _a = e.target, pathname = _a.pathname, search = _a.search, hash = _a.hash;
-            var pointsToCurrentPage = getLocationOrigin(e.target) === getLocationOrigin(location) && pathname === location.pathname && search === location.search;
-            // Only work with HTMLAnchorElements that navigates to a specific ID on the current page
-            if (!pointsToCurrentPage || hash == null || hash.length < 1) {
-                return;
-            }
-            // Find the nearest root, whether it be a ShadowRoot or the document itself
-            var root = findNearestRoot(e.target);
-            // Attempt to match the selector from that root. querySelector' doesn't support IDs that start with a digit, so work around that limitation
-            var elementMatch = hash.match(ID_WITH_LEADING_DIGIT_REGEXP) != null ? root.getElementById(hash.slice(1)) : root.querySelector(hash);
-            // If no selector could be found, don't proceed
-            if (elementMatch == null)
-                return;
-            // Find the nearest ancestor that can be scrolled
-            var _b = __read(findNearestAncestorsWithScrollBehavior(elementMatch), 2), behavior = _b[1];
-            // If the behavior isn't smooth, don't proceed
-            if (behavior !== "smooth")
-                return;
-            // Otherwise, first prevent the default action.
-            e.preventDefault();
-            // Now, scroll to the element with that ID
-            elementMatch.scrollIntoView({
-                behavior: behavior
-            });
-        });
-    }
-
-    var ELEMENT_ORIGINAL_SCROLL_INTO_VIEW = UNSUPPORTED_ENVIRONMENT ? undefined : Element.prototype.scrollIntoView;
-
-    /**
-     * The majority of this file is based on https://github.com/stipsan/compute-scroll-into-view (MIT license),
-     * but has been rewritten to accept a scroller as an argument.
-     */
-    /**
-     * Find out which edge to align against when logical scroll position is "nearest"
-     * Interesting fact: "nearest" works similarly to "if-needed", if the element is fully visible it will not scroll it
-     *
-     * Legends:
-     * ┌────────┐ ┏ ━ ━ ━ ┓
-     * │ target │   frame
-     * └────────┘ ┗ ━ ━ ━ ┛
-     */
-    function alignNearest(scrollingEdgeStart, scrollingEdgeEnd, scrollingSize, scrollingBorderStart, scrollingBorderEnd, elementEdgeStart, elementEdgeEnd, elementSize) {
-        /**
-         * If element edge A and element edge B are both outside scrolling box edge A and scrolling box edge B
-         *
-         *          ┌──┐
-         *        ┏━│━━│━┓
-         *          │  │
-         *        ┃ │  │ ┃        do nothing
-         *          │  │
-         *        ┗━│━━│━┛
-         *          └──┘
-         *
-         *  If element edge C and element edge D are both outside scrolling box edge C and scrolling box edge D
-         *
-         *    ┏ ━ ━ ━ ━ ┓
-         *   ┌───────────┐
-         *   │┃         ┃│        do nothing
-         *   └───────────┘
-         *    ┗ ━ ━ ━ ━ ┛
-         */
-        if ((elementEdgeStart < scrollingEdgeStart && elementEdgeEnd > scrollingEdgeEnd) ||
-            (elementEdgeStart > scrollingEdgeStart && elementEdgeEnd < scrollingEdgeEnd)) {
-            return 0;
-        }
-        /**
-         * If element edge A is outside scrolling box edge A and element height is less than scrolling box height
-         *
-         *          ┌──┐
-         *        ┏━│━━│━┓         ┏━┌━━┐━┓
-         *          └──┘             │  │
-         *  from  ┃      ┃     to  ┃ └──┘ ┃
-         *
-         *        ┗━ ━━ ━┛         ┗━ ━━ ━┛
-         *
-         * If element edge B is outside scrolling box edge B and element height is greater than scrolling box height
-         *
-         *        ┏━ ━━ ━┓         ┏━┌━━┐━┓
-         *                           │  │
-         *  from  ┃ ┌──┐ ┃     to  ┃ │  │ ┃
-         *          │  │             │  │
-         *        ┗━│━━│━┛         ┗━│━━│━┛
-         *          │  │             └──┘
-         *          │  │
-         *          └──┘
-         *
-         * If element edge C is outside scrolling box edge C and element width is less than scrolling box width
-         *
-         *       from                 to
-         *    ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓
-         *  ┌───┐                 ┌───┐
-         *  │ ┃ │       ┃         ┃   │     ┃
-         *  └───┘                 └───┘
-         *    ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛
-         *
-         * If element edge D is outside scrolling box edge D and element width is greater than scrolling box width
-         *
-         *       from                 to
-         *    ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓
-         *        ┌───────────┐   ┌───────────┐
-         *    ┃   │     ┃     │   ┃         ┃ │
-         *        └───────────┘   └───────────┘
-         *    ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛
-         */
-        if ((elementEdgeStart <= scrollingEdgeStart && elementSize <= scrollingSize) ||
-            (elementEdgeEnd >= scrollingEdgeEnd && elementSize >= scrollingSize)) {
-            return elementEdgeStart - scrollingEdgeStart - scrollingBorderStart;
-        }
-        /**
-         * If element edge B is outside scrolling box edge B and element height is less than scrolling box height
-         *
-         *        ┏━ ━━ ━┓         ┏━ ━━ ━┓
-         *
-         *  from  ┃      ┃     to  ┃ ┌──┐ ┃
-         *          ┌──┐             │  │
-         *        ┗━│━━│━┛         ┗━└━━┘━┛
-         *          └──┘
-         *
-         * If element edge A is outside scrolling box edge A and element height is greater than scrolling box height
-         *
-         *          ┌──┐
-         *          │  │
-         *          │  │             ┌──┐
-         *        ┏━│━━│━┓         ┏━│━━│━┓
-         *          │  │             │  │
-         *  from  ┃ └──┘ ┃     to  ┃ │  │ ┃
-         *                           │  │
-         *        ┗━ ━━ ━┛         ┗━└━━┘━┛
-         *
-         * If element edge C is outside scrolling box edge C and element width is greater than scrolling box width
-         *
-         *           from                 to
-         *        ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓
-         *  ┌───────────┐           ┌───────────┐
-         *  │     ┃     │   ┃       │ ┃         ┃
-         *  └───────────┘           └───────────┘
-         *        ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛
-         *
-         * If element edge D is outside scrolling box edge D and element width is less than scrolling box width
-         *
-         *           from                 to
-         *        ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓
-         *                ┌───┐             ┌───┐
-         *        ┃       │ ┃ │       ┃     │   ┃
-         *                └───┘             └───┘
-         *        ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛
-         *
-         */
-        if ((elementEdgeEnd > scrollingEdgeEnd && elementSize < scrollingSize) || (elementEdgeStart < scrollingEdgeStart && elementSize > scrollingSize)) {
-            return elementEdgeEnd - scrollingEdgeEnd + scrollingBorderEnd;
-        }
-        return 0;
-    }
-    function computeScrollIntoView(target, scroller, options) {
-        var block = options.block, inline = options.inline;
-        // Used to handle the top most element that can be scrolled
-        var scrollingElement = getScrollingElement();
-        // Support pinch-zooming properly, making sure elements scroll into the visual viewport
-        // Browsers that don't support visualViewport will report the layout viewport dimensions on document.documentElement.clientWidth/Height
-        // and viewport dimensions on window.innerWidth/Height
-        // https://www.quirksmode.org/mobile/viewports2.html
-        // https://bokand.github.io/viewport/index.html
-        var viewportWidth = window.visualViewport != null ? visualViewport.width : innerWidth;
-        var viewportHeight = window.visualViewport != null ? visualViewport.height : innerHeight;
-        var viewportX = window.scrollX != null ? window.scrollX : window.pageXOffset;
-        var viewportY = window.scrollY != null ? window.scrollY : window.pageYOffset;
-        var _a = target.getBoundingClientRect(), targetHeight = _a.height, targetWidth = _a.width, targetTop = _a.top, targetRight = _a.right, targetBottom = _a.bottom, targetLeft = _a.left;
-        // These values mutate as we loop through and generate scroll coordinates
-        var targetBlock = block === "start" || block === "nearest" ? targetTop : block === "end" ? targetBottom : targetTop + targetHeight / 2; // block === 'center
-        var targetInline = inline === "center" ? targetLeft + targetWidth / 2 : inline === "end" ? targetRight : targetLeft; // inline === 'start || inline === 'nearest
-        var _b = scroller.getBoundingClientRect(), height = _b.height, width = _b.width, top = _b.top, right = _b.right, bottom = _b.bottom, left = _b.left;
-        var frameStyle = getComputedStyle(scroller);
-        var borderLeft = parseInt(frameStyle.borderLeftWidth, 10);
-        var borderTop = parseInt(frameStyle.borderTopWidth, 10);
-        var borderRight = parseInt(frameStyle.borderRightWidth, 10);
-        var borderBottom = parseInt(frameStyle.borderBottomWidth, 10);
-        var blockScroll = 0;
-        var inlineScroll = 0;
-        // The property existance checks for offset[Width|Height] is because only HTMLElement objects have them, but any Element might pass by here
-        // @TODO find out if the "as HTMLElement" overrides can be dropped
-        var scrollbarWidth = "offsetWidth" in scroller ? scroller.offsetWidth - scroller.clientWidth - borderLeft - borderRight : 0;
-        var scrollbarHeight = "offsetHeight" in scroller ? scroller.offsetHeight - scroller.clientHeight - borderTop - borderBottom : 0;
-        if (scrollingElement === scroller) {
-            // Handle viewport logic (document.documentElement or document.body)
-            if (block === "start") {
-                blockScroll = targetBlock;
-            }
-            else if (block === "end") {
-                blockScroll = targetBlock - viewportHeight;
-            }
-            else if (block === "nearest") {
-                blockScroll = alignNearest(viewportY, viewportY + viewportHeight, viewportHeight, borderTop, borderBottom, viewportY + targetBlock, viewportY + targetBlock + targetHeight, targetHeight);
-            }
-            else {
-                // block === 'center' is the default
-                blockScroll = targetBlock - viewportHeight / 2;
-            }
-            if (inline === "start") {
-                inlineScroll = targetInline;
-            }
-            else if (inline === "center") {
-                inlineScroll = targetInline - viewportWidth / 2;
-            }
-            else if (inline === "end") {
-                inlineScroll = targetInline - viewportWidth;
-            }
-            else {
-                // inline === 'nearest' is the default
-                inlineScroll = alignNearest(viewportX, viewportX + viewportWidth, viewportWidth, borderLeft, borderRight, viewportX + targetInline, viewportX + targetInline + targetWidth, targetWidth);
-            }
-            // Apply scroll position offsets and ensure they are within bounds
-            // @TODO add more test cases to cover this 100%
-            blockScroll = Math.max(0, blockScroll + viewportY);
-            inlineScroll = Math.max(0, inlineScroll + viewportX);
-        }
-        else {
-            // Handle each scrolling frame that might exist between the target and the viewport
-            if (block === "start") {
-                blockScroll = targetBlock - top - borderTop;
-            }
-            else if (block === "end") {
-                blockScroll = targetBlock - bottom + borderBottom + scrollbarHeight;
-            }
-            else if (block === "nearest") {
-                blockScroll = alignNearest(top, bottom, height, borderTop, borderBottom + scrollbarHeight, targetBlock, targetBlock + targetHeight, targetHeight);
-            }
-            else {
-                // block === 'center' is the default
-                blockScroll = targetBlock - (top + height / 2) + scrollbarHeight / 2;
-            }
-            if (inline === "start") {
-                inlineScroll = targetInline - left - borderLeft;
-            }
-            else if (inline === "center") {
-                inlineScroll = targetInline - (left + width / 2) + scrollbarWidth / 2;
-            }
-            else if (inline === "end") {
-                inlineScroll = targetInline - right + borderRight + scrollbarWidth;
-            }
-            else {
-                // inline === 'nearest' is the default
-                inlineScroll = alignNearest(left, right, width, borderLeft, borderRight + scrollbarWidth, targetInline, targetInline + targetWidth, targetWidth);
-            }
-            var scrollLeft = scroller.scrollLeft, scrollTop = scroller.scrollTop;
-            // Ensure scroll coordinates are not out of bounds while applying scroll offsets
-            blockScroll = Math.max(0, Math.min(scrollTop + blockScroll, scroller.scrollHeight - height + scrollbarHeight));
-            inlineScroll = Math.max(0, Math.min(scrollLeft + inlineScroll, scroller.scrollWidth - width + scrollbarWidth));
-        }
-        return {
-            top: blockScroll,
-            left: inlineScroll
-        };
-    }
-
-    /**
-     * Patches the 'scrollIntoView' method on the Element prototype
-     */
-    function patchElementScrollIntoView() {
-        Element.prototype.scrollIntoView = function (arg) {
-            var normalizedOptions = arg == null || arg === true
-                ? {
-                    block: "start",
-                    inline: "nearest"
-                }
-                : arg === false
-                    ? {
-                        block: "end",
-                        inline: "nearest"
-                    }
-                    : arg;
-            // Find the nearest ancestor that can be scrolled
-            var _a = __read(findNearestAncestorsWithScrollBehavior(this), 2), ancestorWithScroll = _a[0], ancestorWithScrollBehavior = _a[1];
-            var behavior = normalizedOptions.behavior != null ? normalizedOptions.behavior : ancestorWithScrollBehavior;
-            // If the behavior isn't smooth, simply invoke the original implementation and do no more
-            if (behavior !== "smooth") {
-                // Assert that 'scrollIntoView' is actually defined
-                if (ELEMENT_ORIGINAL_SCROLL_INTO_VIEW != null) {
-                    ELEMENT_ORIGINAL_SCROLL_INTO_VIEW.call(this, normalizedOptions);
-                }
-                // Otherwise, invoke 'scrollTo' instead and provide the scroll coordinates
-                else {
-                    var _b = computeScrollIntoView(this, ancestorWithScroll, normalizedOptions), top_1 = _b.top, left = _b.left;
-                    getOriginalScrollMethodForKind("scrollTo", this).call(this, left, top_1);
-                }
-                return;
-            }
-            ancestorWithScroll.scrollTo(__assign({ behavior: behavior }, computeScrollIntoView(this, ancestorWithScroll, normalizedOptions)));
-        };
-        // On IE11, HTMLElement has its own declaration of scrollIntoView and does not inherit this from the prototype chain, so we'll need to patch that one too.
-        if (HTMLElement.prototype.scrollIntoView != null && HTMLElement.prototype.scrollIntoView !== Element.prototype.scrollIntoView) {
-            HTMLElement.prototype.scrollIntoView = Element.prototype.scrollIntoView;
-        }
-    }
-
-    var ELEMENT_ORIGINAL_SCROLL_TOP_SET_DESCRIPTOR = UNSUPPORTED_ENVIRONMENT
-        ? undefined
-        : Object.getOwnPropertyDescriptor(Element.prototype, "scrollTop").set;
-
-    /**
-     * Patches the 'scrollTop' property descriptor on the Element prototype
-     */
-    function patchElementScrollTop() {
-        Object.defineProperty(Element.prototype, "scrollTop", {
-            set: function (scrollTop) {
-                if (this.__adjustingScrollPosition) {
-                    return ELEMENT_ORIGINAL_SCROLL_TOP_SET_DESCRIPTOR.call(this, scrollTop);
-                }
-                handleScrollMethod(this, "scrollTo", this.scrollLeft, scrollTop);
-                return scrollTop;
-            }
-        });
-    }
-
-    var ELEMENT_ORIGINAL_SCROLL_LEFT_SET_DESCRIPTOR = UNSUPPORTED_ENVIRONMENT
-        ? undefined
-        : Object.getOwnPropertyDescriptor(Element.prototype, "scrollLeft").set;
-
-    /**
-     * Patches the 'scrollLeft' property descriptor on the Element prototype
-     */
-    function patchElementScrollLeft() {
-        Object.defineProperty(Element.prototype, "scrollLeft", {
-            set: function (scrollLeft) {
-                if (this.__adjustingScrollPosition) {
-                    return ELEMENT_ORIGINAL_SCROLL_LEFT_SET_DESCRIPTOR.call(this, scrollLeft);
-                }
-                handleScrollMethod(this, "scrollTo", scrollLeft, this.scrollTop);
-                return scrollLeft;
-            }
-        });
-    }
-
-    /**
-     * Applies the polyfill
-     */
-    function patch() {
-        // Element.prototype methods
-        patchElementScroll();
-        patchElementScrollBy();
-        patchElementScrollTo();
-        patchElementScrollIntoView();
-        // Element.prototype descriptors
-        patchElementScrollLeft();
-        patchElementScrollTop();
-        // window methods
-        patchWindowScroll();
-        patchWindowScrollBy();
-        patchWindowScrollTo();
-        // Navigation
-        catchNavigation();
-    }
-
-    /**
-     * Is true if the browser natively supports the Element.prototype.[scroll|scrollTo|scrollBy|scrollIntoView] methods
-     * @type {boolean}
-     */
-    var SUPPORTS_ELEMENT_PROTOTYPE_SCROLL_METHODS = UNSUPPORTED_ENVIRONMENT
-        ? false
-        : "scroll" in Element.prototype && "scrollTo" in Element.prototype && "scrollBy" in Element.prototype && "scrollIntoView" in Element.prototype;
-
-    if (!UNSUPPORTED_ENVIRONMENT && (!SUPPORTS_SCROLL_BEHAVIOR || !SUPPORTS_ELEMENT_PROTOTYPE_SCROLL_METHODS)) {
-        patch();
-    }
-
-}());
+      }
+      const deltaX = x - startX;
+      const deltaY = y - startY;
+      const distance = deltaX * deltaX + deltaY * deltaY;
+      if (distance < threshold) {
+        return false;
+      }
+      const hypotenuse = Math.sqrt(distance);
+      const cosine = (isDirX ? deltaX : deltaY) / hypotenuse;
+      if (cosine > maxCosine) {
+        isPan = 1;
+      }
+      else if (cosine < -maxCosine) {
+        isPan = -1;
+      }
+      else {
+        isPan = 0;
+      }
+      dirty = false;
+      return true;
+    },
+    isGesture() {
+      return isPan !== 0;
+    },
+    getDirection() {
+      return isPan;
+    },
+  };
+};
+
+const createGesture = (config) => {
+  let hasCapturedPan = false;
+  let hasStartedPan = false;
+  let hasFiredStart = true;
+  let isMoveQueued = false;
+  const finalConfig = Object.assign({ disableScroll: false, direction: 'x', gesturePriority: 0, passive: true, maxAngle: 40, threshold: 10 }, config);
+  const canStart = finalConfig.canStart;
+  const onWillStart = finalConfig.onWillStart;
+  const onStart = finalConfig.onStart;
+  const onEnd = finalConfig.onEnd;
+  const notCaptured = finalConfig.notCaptured;
+  const onMove = finalConfig.onMove;
+  const threshold = finalConfig.threshold;
+  const passive = finalConfig.passive;
+  const blurOnStart = finalConfig.blurOnStart;
+  const detail = {
+    type: 'pan',
+    startX: 0,
+    startY: 0,
+    startTime: 0,
+    currentX: 0,
+    currentY: 0,
+    velocityX: 0,
+    velocityY: 0,
+    deltaX: 0,
+    deltaY: 0,
+    currentTime: 0,
+    event: undefined,
+    data: undefined,
+  };
+  const pan = createPanRecognizer(finalConfig.direction, finalConfig.threshold, finalConfig.maxAngle);
+  const gesture = GESTURE_CONTROLLER.createGesture({
+    name: config.gestureName,
+    priority: config.gesturePriority,
+    disableScroll: config.disableScroll,
+  });
+  const pointerDown = (ev) => {
+    const timeStamp = now(ev);
+    if (hasStartedPan || !hasFiredStart) {
+      return false;
+    }
+    updateDetail(ev, detail);
+    detail.startX = detail.currentX;
+    detail.startY = detail.currentY;
+    detail.startTime = detail.currentTime = timeStamp;
+    detail.velocityX = detail.velocityY = detail.deltaX = detail.deltaY = 0;
+    detail.event = ev;
+    // Check if gesture can start
+    if (canStart && canStart(detail) === false) {
+      return false;
+    }
+    // Release fallback
+    gesture.release();
+    // Start gesture
+    if (!gesture.start()) {
+      return false;
+    }
+    hasStartedPan = true;
+    if (threshold === 0) {
+      return tryToCapturePan();
+    }
+    pan.start(detail.startX, detail.startY);
+    return true;
+  };
+  const pointerMove = (ev) => {
+    // fast path, if gesture is currently captured
+    // do minimum job to get user-land even dispatched
+    if (hasCapturedPan) {
+      if (!isMoveQueued && hasFiredStart) {
+        isMoveQueued = true;
+        calcGestureData(detail, ev);
+        requestAnimationFrame(fireOnMove);
+      }
+      return;
+    }
+    // gesture is currently being detected
+    calcGestureData(detail, ev);
+    if (pan.detect(detail.currentX, detail.currentY)) {
+      if (!pan.isGesture() || !tryToCapturePan()) {
+        abortGesture();
+      }
+    }
+  };
+  const fireOnMove = () => {
+    // Since fireOnMove is called inside a RAF, onEnd() might be called,
+    // we must double check hasCapturedPan
+    if (!hasCapturedPan) {
+      return;
+    }
+    isMoveQueued = false;
+    if (onMove) {
+      onMove(detail);
+    }
+  };
+  const tryToCapturePan = () => {
+    if (gesture && !gesture.capture()) {
+      return false;
+    }
+    hasCapturedPan = true;
+    hasFiredStart = false;
+    // reset start position since the real user-land event starts here
+    // If the pan detector threshold is big, not resetting the start position
+    // will cause a jump in the animation equal to the detector threshold.
+    // the array of positions used to calculate the gesture velocity does not
+    // need to be cleaned, more points in the positions array always results in a
+    // more accurate value of the velocity.
+    detail.startX = detail.currentX;
+    detail.startY = detail.currentY;
+    detail.startTime = detail.currentTime;
+    if (onWillStart) {
+      onWillStart(detail).then(fireOnStart);
+    }
+    else {
+      fireOnStart();
+    }
+    return true;
+  };
+  const blurActiveElement = () => {
+    /* tslint:disable-next-line */
+    if (typeof document !== 'undefined') {
+      const activeElement = document.activeElement;
+      if (activeElement !== null && activeElement.blur) {
+        activeElement.blur();
+      }
+    }
+  };
+  const fireOnStart = () => {
+    if (blurOnStart) {
+      blurActiveElement();
+    }
+    if (onStart) {
+      onStart(detail);
+    }
+    hasFiredStart = true;
+  };
+  const reset = () => {
+    hasCapturedPan = false;
+    hasStartedPan = false;
+    isMoveQueued = false;
+    hasFiredStart = true;
+    gesture.release();
+  };
+  // END *************************
+  const pointerUp = (ev) => {
+    const tmpHasCaptured = hasCapturedPan;
+    const tmpHasFiredStart = hasFiredStart;
+    reset();
+    if (!tmpHasFiredStart) {
+      return;
+    }
+    calcGestureData(detail, ev);
+    // Try to capture press
+    if (tmpHasCaptured) {
+      if (onEnd) {
+        onEnd(detail);
+      }
+      return;
+    }
+    // Not captured any event
+    if (notCaptured) {
+      notCaptured(detail);
+    }
+  };
+  const pointerEvents = createPointerEvents(finalConfig.el, pointerDown, pointerMove, pointerUp, {
+    capture: false,
+    passive,
+  });
+  const abortGesture = () => {
+    reset();
+    pointerEvents.stop();
+    if (notCaptured) {
+      notCaptured(detail);
+    }
+  };
+  return {
+    enable(enable = true) {
+      if (!enable) {
+        if (hasCapturedPan) {
+          pointerUp(undefined);
+        }
+        reset();
+      }
+      pointerEvents.enable(enable);
+    },
+    destroy() {
+      gesture.destroy();
+      pointerEvents.destroy();
+    },
+  };
+};
+const calcGestureData = (detail, ev) => {
+  if (!ev) {
+    return;
+  }
+  const prevX = detail.currentX;
+  const prevY = detail.currentY;
+  const prevT = detail.currentTime;
+  updateDetail(ev, detail);
+  const currentX = detail.currentX;
+  const currentY = detail.currentY;
+  const timestamp = (detail.currentTime = now(ev));
+  const timeDelta = timestamp - prevT;
+  if (timeDelta > 0 && timeDelta < 100) {
+    const velocityX = (currentX - prevX) / timeDelta;
+    const velocityY = (currentY - prevY) / timeDelta;
+    detail.velocityX = velocityX * 0.7 + detail.velocityX * 0.3;
+    detail.velocityY = velocityY * 0.7 + detail.velocityY * 0.3;
+  }
+  detail.deltaX = currentX - detail.startX;
+  detail.deltaY = currentY - detail.startY;
+  detail.event = ev;
+};
+const updateDetail = (ev, detail) => {
+  // get X coordinates for either a mouse click
+  // or a touch depending on the given event
+  let x = 0;
+  let y = 0;
+  if (ev) {
+    const changedTouches = ev.changedTouches;
+    if (changedTouches && changedTouches.length > 0) {
+      const touch = changedTouches[0];
+      x = touch.clientX;
+      y = touch.clientY;
+    }
+    else if (ev.pageX !== undefined) {
+      x = ev.pageX;
+      y = ev.pageY;
+    }
+  }
+  detail.currentX = x;
+  detail.currentY = y;
+};
+const now = (ev) => {
+  return ev.timeStamp || Date.now();
+};
+
+export { GESTURE_CONTROLLER, createGesture };
 
 //# sourceMappingURL=index3.js.map