@swisspost/design-system-components 9.0.0-next.9 → 9.0.0

package/dist/cjs/{post-tooltip-38c839a4.js → post-tooltip-trigger-6f4c9748.js}

@@ -1,9 +1,273 @@
 'use strict';
 
-const index = require('./index-010dc207.js');
-const _package = require('./package-8e810a59.js');
-const attributeObserver = require('./attribute-observer-10f08c04.js');
-const index$1 = require('./index-5d4e0aed.js');
+const index = require('./index-e1f32cce.js');
+const checkType = require('./check-type-64af82a9.js');
+const _package = require('./package-3ed88bb9.js');
+
+/*!
+ * long-press-event - v@version@
+ * Pure JavaScript long-press-event
+ * https://github.com/john-doherty/long-press-event
+ * @author John Doherty <www.johndoherty.info>
+ * @license MIT
+ */
+(function (window, document) {
+
+    // local timer object based on rAF
+    var timer = null;
+
+    // check if we're using a touch screen
+    var hasPointerEvents = (('PointerEvent' in window) || (window.navigator && 'msPointerEnabled' in window.navigator));
+    var isTouch = (('ontouchstart' in window) || (navigator.MaxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0));
+
+    // switch to pointer events or touch events if using a touch screen
+    var mouseDown = hasPointerEvents ? 'pointerdown' : isTouch ? 'touchstart' : 'mousedown';
+    var mouseUp = hasPointerEvents ? 'pointerup' : isTouch ? 'touchend' : 'mouseup';
+    var mouseMove = hasPointerEvents ? 'pointermove' : isTouch ? 'touchmove' : 'mousemove';
+    var mouseLeave = hasPointerEvents ? 'pointerleave' : isTouch ? 'touchleave' : 'mouseleave';
+
+    // track number of pixels the mouse moves during long press
+    var startX = 0; // mouse x position when timer started
+    var startY = 0; // mouse y position when timer started
+    var maxDiffX = 10; // max number of X pixels the mouse can move during long press before it is canceled
+    var maxDiffY = 10; // max number of Y pixels the mouse can move during long press before it is canceled
+
+    // patch CustomEvent to allow constructor creation (IE/Chrome)
+    if (typeof window.CustomEvent !== 'function') {
+
+        window.CustomEvent = function (event, params) {
+
+            params = params || { bubbles: false, cancelable: false, detail: undefined };
+
+            var evt = document.createEvent('CustomEvent');
+            evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+            return evt;
+        };
+
+        window.CustomEvent.prototype = window.Event.prototype;
+    }
+
+    // requestAnimationFrame() shim by Paul Irish
+    window.requestAnimFrame = (function () {
+        return window.requestAnimationFrame ||
+            window.webkitRequestAnimationFrame ||
+            window.mozRequestAnimationFrame ||
+            window.oRequestAnimationFrame ||
+            window.msRequestAnimationFrame || function (callback) {
+                window.setTimeout(callback, 1000 / 60);
+            };
+    })();
+
+    /**
+     * Behaves the same as setTimeout except uses requestAnimationFrame() where possible for better performance
+     * @param {function} fn The callback function
+     * @param {int} delay The delay in milliseconds
+     * @returns {object} handle to the timeout object
+     */
+    function requestTimeout(fn, delay) {
+
+        if (!window.requestAnimationFrame && !window.webkitRequestAnimationFrame &&
+            !(window.mozRequestAnimationFrame && window.mozCancelRequestAnimationFrame) && // Firefox 5 ships without cancel support
+            !window.oRequestAnimationFrame && !window.msRequestAnimationFrame) return window.setTimeout(fn, delay);
+
+        var start = new Date().getTime();
+        var handle = {};
+
+        var loop = function () {
+            var current = new Date().getTime();
+            var delta = current - start;
+
+            if (delta >= delay) {
+                fn.call();
+            }
+            else {
+                handle.value = requestAnimFrame(loop);
+            }
+        };
+
+        handle.value = requestAnimFrame(loop);
+
+        return handle;
+    }
+
+    /**
+     * Behaves the same as clearTimeout except uses cancelRequestAnimationFrame() where possible for better performance
+     * @param {object} handle The callback function
+     * @returns {void}
+     */
+    function clearRequestTimeout(handle) {
+        if (handle) {
+            window.cancelAnimationFrame ? window.cancelAnimationFrame(handle.value) :
+                window.webkitCancelAnimationFrame ? window.webkitCancelAnimationFrame(handle.value) :
+                    window.webkitCancelRequestAnimationFrame ? window.webkitCancelRequestAnimationFrame(handle.value) : /* Support for legacy API */
+                        window.mozCancelRequestAnimationFrame ? window.mozCancelRequestAnimationFrame(handle.value) :
+                            window.oCancelRequestAnimationFrame ? window.oCancelRequestAnimationFrame(handle.value) :
+                                window.msCancelRequestAnimationFrame ? window.msCancelRequestAnimationFrame(handle.value) :
+                                    clearTimeout(handle);
+        }
+    }
+
+    /**
+     * Fires the 'long-press' event on element
+     * @param {MouseEvent|PointerEvent|TouchEvent} originalEvent The original event being fired
+     * @returns {void}
+     */
+    function fireLongPressEvent(originalEvent) {
+
+        clearLongPressTimer();
+
+        originalEvent = unifyEvent(originalEvent);
+
+        // fire the long-press event
+        var allowClickEvent = this.dispatchEvent(new CustomEvent('long-press', {
+            bubbles: true,
+            cancelable: true,
+
+            // custom event data (legacy)
+            detail: {
+                clientX: originalEvent.clientX,
+                clientY: originalEvent.clientY,
+                offsetX: originalEvent.offsetX,
+                offsetY: originalEvent.offsetY,
+                pageX: originalEvent.pageX,
+                pageY: originalEvent.pageY
+            },
+
+            // add coordinate data that would typically acompany a touch/click event
+            clientX: originalEvent.clientX,
+            clientY: originalEvent.clientY,
+            offsetX: originalEvent.offsetX,
+            offsetY: originalEvent.offsetY,
+            pageX: originalEvent.pageX,
+            pageY: originalEvent.pageY,
+            screenX: originalEvent.screenX,
+            screenY: originalEvent.screenY
+        }));
+
+        if (!allowClickEvent) {
+            // suppress the next click event if e.preventDefault() was called in long-press handler
+            document.addEventListener('click', function suppressEvent(e) {
+                document.removeEventListener('click', suppressEvent, true);
+                cancelEvent(e);
+            }, true);
+        }
+    }
+
+    /**
+     * consolidates mouse, touch, and Pointer events
+     * @param {MouseEvent|PointerEvent|TouchEvent} e The original event being fired
+     * @returns {MouseEvent|PointerEvent|Touch}
+     */
+    function unifyEvent(e) {
+        if (e.changedTouches !== undefined) {
+            return e.changedTouches[0];
+        }
+        return e;
+    }
+
+    /**
+     * method responsible for starting the long press timer
+     * @param {event} e - event object
+     * @returns {void}
+     */
+    function startLongPressTimer(e) {
+
+        clearLongPressTimer();
+
+        var el = e.target;
+
+        // get delay from html attribute if it exists, otherwise default to 1500
+        var longPressDelayInMs = parseInt(getNearestAttribute(el, 'data-long-press-delay', '1500'), 10); // default 1500
+
+        // start the timer
+        timer = requestTimeout(fireLongPressEvent.bind(el, e), longPressDelayInMs);
+    }
+
+    /**
+     * method responsible for clearing a pending long press timer
+     * @param {event} e - event object
+     * @returns {void}
+     */
+    function clearLongPressTimer(e) {
+        clearRequestTimeout(timer);
+        timer = null;
+    }
+
+    /**
+    * Cancels the current event
+    * @param {object} e - browser event object
+    * @returns {void}
+    */
+    function cancelEvent(e) {
+        e.stopImmediatePropagation();
+        e.preventDefault();
+        e.stopPropagation();
+    }
+
+    /**
+     * Starts the timer on mouse down and logs current position
+     * @param {object} e - browser event object
+     * @returns {void}
+     */
+    function mouseDownHandler(e) {
+        startX = e.clientX;
+        startY = e.clientY;
+        startLongPressTimer(e);
+    }
+
+    /**
+     * If the mouse moves n pixels during long-press, cancel the timer
+     * @param {object} e - browser event object
+     * @returns {void}
+     */
+    function mouseMoveHandler(e) {
+
+        // calculate total number of pixels the pointer has moved
+        var diffX = Math.abs(startX - e.clientX);
+        var diffY = Math.abs(startY - e.clientY);
+
+        // if pointer has moved more than allowed, cancel the long-press timer and therefore the event
+        if (diffX >= maxDiffX || diffY >= maxDiffY) {
+            clearLongPressTimer();
+        }
+    }
+
+    /**
+     * Gets attribute off HTML element or nearest parent
+     * @param {object} el - HTML element to retrieve attribute from
+     * @param {string} attributeName - name of the attribute
+     * @param {any} defaultValue - default value to return if no match found
+     * @returns {any} attribute value or defaultValue
+     */
+    function getNearestAttribute(el, attributeName, defaultValue) {
+
+        // walk up the dom tree looking for data-action and data-trigger
+        while (el && el !== document.documentElement) {
+
+            var attributeValue = el.getAttribute(attributeName);
+
+            if (attributeValue) {
+                return attributeValue;
+            }
+
+            el = el.parentNode;
+        }
+
+        return defaultValue;
+    }
+
+    // hook events that clear a pending long press event
+    document.addEventListener(mouseUp, clearLongPressTimer, true);
+    document.addEventListener(mouseLeave, clearLongPressTimer, true);
+    document.addEventListener(mouseMove, mouseMoveHandler, true);
+    document.addEventListener('wheel', clearLongPressTimer, true);
+    document.addEventListener('scroll', clearLongPressTimer, true);
+    document.addEventListener('contextmenu', clearLongPressTimer, true);
+
+    // hook events that can trigger a long press event
+    document.addEventListener(mouseDown, mouseDownHandler, true); // <- start
+
+}(window, document));
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -4390,611 +4654,297 @@ function isOnlyFocusRelevant(element) {
 
   if (nodeName === 'area') {
     // all <area>s are considered relevant,
-    // but only the valid <area>s are focusable
-    return !(0, _validArea2.default)(element);
-  }
-
-  return false;
-}
-
-function isFocusableRules() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      context = _ref.context,
-      _ref$except = _ref.except,
-      except = _ref$except === undefined ? {
-    disabled: false,
-    visible: false,
-    onlyTabbable: false
-  } : _ref$except;
-
-  if (!supports$1) {
-    supports$1 = (0, _supports3.default)();
-  }
-
-  var _isOnlyTabbable = _onlyTabbable2.default.rules.except({
-    onlyFocusableBrowsingContext: true,
-    visible: except.visible
-  });
-
-  var element = (0, _contextToElement2.default)({
-    label: 'is/focusable',
-    resolveDocument: true,
-    context: context
-  });
-
-  var focusRelevant = _focusRelevant2.default.rules({
-    context: element,
-    except: except
-  });
-
-  if (!focusRelevant || isOnlyFocusRelevant(element)) {
-    return false;
-  }
-
-  if (!except.disabled && (0, _disabled2.default)(element)) {
-    return false;
-  }
-
-  if (!except.onlyTabbable && _isOnlyTabbable(element)) {
-    // some elements may be keyboard focusable, but not script focusable
-    return false;
-  }
-
-  // elements that are not rendered, cannot be focused
-  if (!except.visible) {
-    var visibilityOptions = {
-      context: element,
-      except: {}
-    };
-
-    if (supports$1.focusInHiddenIframe) {
-      // WebKit and Blink can focus content in hidden <iframe> and <object>
-      visibilityOptions.except.browsingContext = true;
-    }
-
-    if (supports$1.focusObjectSvgHidden) {
-      // Blink allows focusing the object element, even if it has visibility: hidden;
-      // @browser-issue Blink https://code.google.com/p/chromium/issues/detail?id=586191
-      var _nodeName2 = element.nodeName.toLowerCase();
-      if (_nodeName2 === 'object') {
-        visibilityOptions.except.cssVisibility = true;
-      }
-    }
-
-    if (!_visible2.default.rules(visibilityOptions)) {
-      return false;
-    }
-  }
-
-  var frameElement = (0, _getFrameElement2.default)(element);
-  if (frameElement) {
-    var _nodeName = frameElement.nodeName.toLowerCase();
-    if (_nodeName === 'object' && !supports$1.focusInZeroDimensionObject) {
-      if (!frameElement.offsetWidth || !frameElement.offsetHeight) {
-        // WebKit can not focus content in <object> if it doesn't have dimensions
-        return false;
-      }
-    }
-  }
-
-  var nodeName = element.nodeName.toLowerCase();
-  if (nodeName === 'svg' && supports$1.focusSvgInIframe && !frameElement && element.getAttribute('tabindex') === null) {
-    return false;
-  }
-
-  return true;
-}
-
-// bind exceptions to an iterator callback
-isFocusableRules.except = function () {
-  var except = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-  var isFocusable = function isFocusable(context) {
-    return isFocusableRules({
-      context: context,
-      except: except
-    });
-  };
-
-  isFocusable.rules = isFocusableRules;
-  return isFocusable;
-};
-
-// provide isFocusRelevant(context) as default iterator callback
-var isFocusable = isFocusableRules.except({});
-exports.default = isFocusable;
-module.exports = exports['default'];
-
-}(focusable, focusable.exports));
-
-const isFocusable = /*@__PURE__*/getDefaultExportFromCjs(focusable.exports);
-
-/*!
- * long-press-event - v@version@
- * Pure JavaScript long-press-event
- * https://github.com/john-doherty/long-press-event
- * @author John Doherty <www.johndoherty.info>
- * @license MIT
- */
-(function (window, document) {
-
-    // local timer object based on rAF
-    var timer = null;
-
-    // check if we're using a touch screen
-    var hasPointerEvents = (('PointerEvent' in window) || (window.navigator && 'msPointerEnabled' in window.navigator));
-    var isTouch = (('ontouchstart' in window) || (navigator.MaxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0));
-
-    // switch to pointer events or touch events if using a touch screen
-    var mouseDown = hasPointerEvents ? 'pointerdown' : isTouch ? 'touchstart' : 'mousedown';
-    var mouseUp = hasPointerEvents ? 'pointerup' : isTouch ? 'touchend' : 'mouseup';
-    var mouseMove = hasPointerEvents ? 'pointermove' : isTouch ? 'touchmove' : 'mousemove';
-    var mouseLeave = hasPointerEvents ? 'pointerleave' : isTouch ? 'touchleave' : 'mouseleave';
-
-    // track number of pixels the mouse moves during long press
-    var startX = 0; // mouse x position when timer started
-    var startY = 0; // mouse y position when timer started
-    var maxDiffX = 10; // max number of X pixels the mouse can move during long press before it is canceled
-    var maxDiffY = 10; // max number of Y pixels the mouse can move during long press before it is canceled
-
-    // patch CustomEvent to allow constructor creation (IE/Chrome)
-    if (typeof window.CustomEvent !== 'function') {
-
-        window.CustomEvent = function (event, params) {
-
-            params = params || { bubbles: false, cancelable: false, detail: undefined };
-
-            var evt = document.createEvent('CustomEvent');
-            evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
-            return evt;
-        };
-
-        window.CustomEvent.prototype = window.Event.prototype;
-    }
-
-    // requestAnimationFrame() shim by Paul Irish
-    window.requestAnimFrame = (function () {
-        return window.requestAnimationFrame ||
-            window.webkitRequestAnimationFrame ||
-            window.mozRequestAnimationFrame ||
-            window.oRequestAnimationFrame ||
-            window.msRequestAnimationFrame || function (callback) {
-                window.setTimeout(callback, 1000 / 60);
-            };
-    })();
-
-    /**
-     * Behaves the same as setTimeout except uses requestAnimationFrame() where possible for better performance
-     * @param {function} fn The callback function
-     * @param {int} delay The delay in milliseconds
-     * @returns {object} handle to the timeout object
-     */
-    function requestTimeout(fn, delay) {
-
-        if (!window.requestAnimationFrame && !window.webkitRequestAnimationFrame &&
-            !(window.mozRequestAnimationFrame && window.mozCancelRequestAnimationFrame) && // Firefox 5 ships without cancel support
-            !window.oRequestAnimationFrame && !window.msRequestAnimationFrame) return window.setTimeout(fn, delay);
-
-        var start = new Date().getTime();
-        var handle = {};
-
-        var loop = function () {
-            var current = new Date().getTime();
-            var delta = current - start;
-
-            if (delta >= delay) {
-                fn.call();
-            }
-            else {
-                handle.value = requestAnimFrame(loop);
-            }
-        };
-
-        handle.value = requestAnimFrame(loop);
-
-        return handle;
-    }
-
-    /**
-     * Behaves the same as clearTimeout except uses cancelRequestAnimationFrame() where possible for better performance
-     * @param {object} handle The callback function
-     * @returns {void}
-     */
-    function clearRequestTimeout(handle) {
-        if (handle) {
-            window.cancelAnimationFrame ? window.cancelAnimationFrame(handle.value) :
-                window.webkitCancelAnimationFrame ? window.webkitCancelAnimationFrame(handle.value) :
-                    window.webkitCancelRequestAnimationFrame ? window.webkitCancelRequestAnimationFrame(handle.value) : /* Support for legacy API */
-                        window.mozCancelRequestAnimationFrame ? window.mozCancelRequestAnimationFrame(handle.value) :
-                            window.oCancelRequestAnimationFrame ? window.oCancelRequestAnimationFrame(handle.value) :
-                                window.msCancelRequestAnimationFrame ? window.msCancelRequestAnimationFrame(handle.value) :
-                                    clearTimeout(handle);
-        }
-    }
-
-    /**
-     * Fires the 'long-press' event on element
-     * @param {MouseEvent|PointerEvent|TouchEvent} originalEvent The original event being fired
-     * @returns {void}
-     */
-    function fireLongPressEvent(originalEvent) {
-
-        clearLongPressTimer();
-
-        originalEvent = unifyEvent(originalEvent);
-
-        // fire the long-press event
-        var allowClickEvent = this.dispatchEvent(new CustomEvent('long-press', {
-            bubbles: true,
-            cancelable: true,
-
-            // custom event data (legacy)
-            detail: {
-                clientX: originalEvent.clientX,
-                clientY: originalEvent.clientY,
-                offsetX: originalEvent.offsetX,
-                offsetY: originalEvent.offsetY,
-                pageX: originalEvent.pageX,
-                pageY: originalEvent.pageY
-            },
+    // but only the valid <area>s are focusable
+    return !(0, _validArea2.default)(element);
+  }
 
-            // add coordinate data that would typically acompany a touch/click event
-            clientX: originalEvent.clientX,
-            clientY: originalEvent.clientY,
-            offsetX: originalEvent.offsetX,
-            offsetY: originalEvent.offsetY,
-            pageX: originalEvent.pageX,
-            pageY: originalEvent.pageY,
-            screenX: originalEvent.screenX,
-            screenY: originalEvent.screenY
-        }));
+  return false;
+}
 
-        if (!allowClickEvent) {
-            // suppress the next click event if e.preventDefault() was called in long-press handler
-            document.addEventListener('click', function suppressEvent(e) {
-                document.removeEventListener('click', suppressEvent, true);
-                cancelEvent(e);
-            }, true);
-        }
-    }
+function isFocusableRules() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      context = _ref.context,
+      _ref$except = _ref.except,
+      except = _ref$except === undefined ? {
+    disabled: false,
+    visible: false,
+    onlyTabbable: false
+  } : _ref$except;
 
-    /**
-     * consolidates mouse, touch, and Pointer events
-     * @param {MouseEvent|PointerEvent|TouchEvent} e The original event being fired
-     * @returns {MouseEvent|PointerEvent|Touch}
-     */
-    function unifyEvent(e) {
-        if (e.changedTouches !== undefined) {
-            return e.changedTouches[0];
-        }
-        return e;
-    }
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
+  }
 
-    /**
-     * method responsible for starting the long press timer
-     * @param {event} e - event object
-     * @returns {void}
-     */
-    function startLongPressTimer(e) {
+  var _isOnlyTabbable = _onlyTabbable2.default.rules.except({
+    onlyFocusableBrowsingContext: true,
+    visible: except.visible
+  });
 
-        clearLongPressTimer();
+  var element = (0, _contextToElement2.default)({
+    label: 'is/focusable',
+    resolveDocument: true,
+    context: context
+  });
 
-        var el = e.target;
+  var focusRelevant = _focusRelevant2.default.rules({
+    context: element,
+    except: except
+  });
 
-        // get delay from html attribute if it exists, otherwise default to 1500
-        var longPressDelayInMs = parseInt(getNearestAttribute(el, 'data-long-press-delay', '1500'), 10); // default 1500
+  if (!focusRelevant || isOnlyFocusRelevant(element)) {
+    return false;
+  }
 
-        // start the timer
-        timer = requestTimeout(fireLongPressEvent.bind(el, e), longPressDelayInMs);
-    }
+  if (!except.disabled && (0, _disabled2.default)(element)) {
+    return false;
+  }
 
-    /**
-     * method responsible for clearing a pending long press timer
-     * @param {event} e - event object
-     * @returns {void}
-     */
-    function clearLongPressTimer(e) {
-        clearRequestTimeout(timer);
-        timer = null;
-    }
+  if (!except.onlyTabbable && _isOnlyTabbable(element)) {
+    // some elements may be keyboard focusable, but not script focusable
+    return false;
+  }
 
-    /**
-    * Cancels the current event
-    * @param {object} e - browser event object
-    * @returns {void}
-    */
-    function cancelEvent(e) {
-        e.stopImmediatePropagation();
-        e.preventDefault();
-        e.stopPropagation();
-    }
+  // elements that are not rendered, cannot be focused
+  if (!except.visible) {
+    var visibilityOptions = {
+      context: element,
+      except: {}
+    };
 
-    /**
-     * Starts the timer on mouse down and logs current position
-     * @param {object} e - browser event object
-     * @returns {void}
-     */
-    function mouseDownHandler(e) {
-        startX = e.clientX;
-        startY = e.clientY;
-        startLongPressTimer(e);
+    if (supports$1.focusInHiddenIframe) {
+      // WebKit and Blink can focus content in hidden <iframe> and <object>
+      visibilityOptions.except.browsingContext = true;
     }
 
-    /**
-     * If the mouse moves n pixels during long-press, cancel the timer
-     * @param {object} e - browser event object
-     * @returns {void}
-     */
-    function mouseMoveHandler(e) {
-
-        // calculate total number of pixels the pointer has moved
-        var diffX = Math.abs(startX - e.clientX);
-        var diffY = Math.abs(startY - e.clientY);
+    if (supports$1.focusObjectSvgHidden) {
+      // Blink allows focusing the object element, even if it has visibility: hidden;
+      // @browser-issue Blink https://code.google.com/p/chromium/issues/detail?id=586191
+      var _nodeName2 = element.nodeName.toLowerCase();
+      if (_nodeName2 === 'object') {
+        visibilityOptions.except.cssVisibility = true;
+      }
+    }
 
-        // if pointer has moved more than allowed, cancel the long-press timer and therefore the event
-        if (diffX >= maxDiffX || diffY >= maxDiffY) {
-            clearLongPressTimer();
-        }
+    if (!_visible2.default.rules(visibilityOptions)) {
+      return false;
     }
+  }
 
-    /**
-     * Gets attribute off HTML element or nearest parent
-     * @param {object} el - HTML element to retrieve attribute from
-     * @param {string} attributeName - name of the attribute
-     * @param {any} defaultValue - default value to return if no match found
-     * @returns {any} attribute value or defaultValue
-     */
-    function getNearestAttribute(el, attributeName, defaultValue) {
+  var frameElement = (0, _getFrameElement2.default)(element);
+  if (frameElement) {
+    var _nodeName = frameElement.nodeName.toLowerCase();
+    if (_nodeName === 'object' && !supports$1.focusInZeroDimensionObject) {
+      if (!frameElement.offsetWidth || !frameElement.offsetHeight) {
+        // WebKit can not focus content in <object> if it doesn't have dimensions
+        return false;
+      }
+    }
+  }
 
-        // walk up the dom tree looking for data-action and data-trigger
-        while (el && el !== document.documentElement) {
+  var nodeName = element.nodeName.toLowerCase();
+  if (nodeName === 'svg' && supports$1.focusSvgInIframe && !frameElement && element.getAttribute('tabindex') === null) {
+    return false;
+  }
 
-            var attributeValue = el.getAttribute(attributeName);
+  return true;
+}
 
-            if (attributeValue) {
-                return attributeValue;
-            }
+// bind exceptions to an iterator callback
+isFocusableRules.except = function () {
+  var except = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-            el = el.parentNode;
-        }
+  var isFocusable = function isFocusable(context) {
+    return isFocusableRules({
+      context: context,
+      except: except
+    });
+  };
 
-        return defaultValue;
-    }
+  isFocusable.rules = isFocusableRules;
+  return isFocusable;
+};
 
-    // hook events that clear a pending long press event
-    document.addEventListener(mouseUp, clearLongPressTimer, true);
-    document.addEventListener(mouseLeave, clearLongPressTimer, true);
-    document.addEventListener(mouseMove, mouseMoveHandler, true);
-    document.addEventListener('wheel', clearLongPressTimer, true);
-    document.addEventListener('scroll', clearLongPressTimer, true);
-    document.addEventListener('contextmenu', clearLongPressTimer, true);
+// provide isFocusRelevant(context) as default iterator callback
+var isFocusable = isFocusableRules.except({});
+exports.default = isFocusable;
+module.exports = exports['default'];
 
-    // hook events that can trigger a long press event
-    document.addEventListener(mouseDown, mouseDownHandler, true); // <- start
+}(focusable, focusable.exports));
 
-}(window, document));
+const isFocusable = /*@__PURE__*/getDefaultExportFromCjs(focusable.exports);
 
-const postTooltipCss = ":host{--post-contrast-color:#fff;--post-bg-rgb:51, 51, 51}post-popovercontainer{padding:.25rem .5rem;max-width:13.5rem;min-height:1rem}post-popovercontainer[arrow]::after{position:absolute;content:\"\";inset:-13px;z-index:-1}";
-const PostTooltipStyle0 = postTooltipCss;
+const postTooltipTriggerCss = "post-tooltip-trigger{vertical-align:top}";
+const PostTooltipTriggerStyle0 = postTooltipTriggerCss;
 
-const OPEN_DELAY = 650; // matches HTML title delay
-/**
- * @slot default - Slot for the content of the tooltip.
- */
-/**
- * Track how many instances remain on the page. Used for removing global event listeners
- */
-let tooltipInstances = 0;
-let hideTooltipTimeout = null;
-const tooltipTargetAttribute = 'data-tooltip-target';
-const tooltipTargetAttributeSelector = `[${tooltipTargetAttribute}]`;
-let globalCurrentTarget;
-let tooltipTimeout = null;
-/**
- * Global event listener to show tooltips. This is globalized so that triggers that are rendered
- * async will still work without the need to set listeners on the element itself
- *
- * This handler manages both pointer and focus events to properly trigger tooltips.
- * If the event is a focus event (e.g., keyboard navigation), pointer events are ignored to avoid
- * interference with tooltip behavior.
- * @param e Event
- * @returns
- */
-const globalInterestHandler = (e) => {
-    const targetElement = e.target.closest(tooltipTargetAttributeSelector);
-    globalCurrentTarget = targetElement;
-    if (!targetElement || !('getAttribute' in targetElement)) {
-        clearTimeout(tooltipTimeout);
-        return;
-    }
-    const tooltipTarget = targetElement.getAttribute(tooltipTargetAttribute);
-    if (!tooltipTarget || tooltipTarget === '')
-        return;
-    const tooltip = document.getElementById(tooltipTarget);
-    // Determine if the tooltip was triggered by a focus event
-    const triggeredByFocus = e.type === 'focusin';
-    void (tooltip === null || tooltip === void 0 ? void 0 : tooltip.show(targetElement, triggeredByFocus));
-    if (hideTooltipTimeout) {
-        window.clearTimeout(hideTooltipTimeout);
-        hideTooltipTimeout = null;
-    }
-};
-/**
- * Global event listener to hide tooltips. This is globalized so that triggers that are rendered
- * async will still work without the need to set listeners on the element itself
- * @param e Event
- * @returns
- */
-const globalInterestLostHandler = (e) => {
-    const targetElement = e.target.closest(tooltipTargetAttributeSelector);
-    if (!targetElement || !('getAttribute' in targetElement))
-        return;
-    const tooltipTarget = targetElement.getAttribute(tooltipTargetAttribute);
-    if (!tooltipTarget || tooltipTarget === '')
-        return;
-    const tooltip = document.getElementById(tooltipTarget);
-    globalHideTooltip(tooltip);
-};
-/**
- * Start the hiding process through a timeout to give other interest events a chance to
- * intervene and cancel the hide event.
- * @param {HTMLPostTooltipElement} tooltip
- */
-const globalHideTooltip = (tooltip) => {
-    hideTooltipTimeout = window.setTimeout(() => {
-        tooltip.hide();
-        hideTooltipTimeout = null;
-    }, 42);
-};
-/**
- * Patch some accessibility features that are hard to remember or understand
- * @param {HTMLElement} trigger
- */
-const patchAccessibilityFeatures = (trigger) => {
-    const describedBy = trigger.getAttribute('aria-describedby');
-    const id = trigger.getAttribute(tooltipTargetAttribute);
-    // Add tooltip to aria-describedby
-    if (!(describedBy === null || describedBy === void 0 ? void 0 : describedBy.includes(id))) {
-        const newDescribedBy = describedBy ? `${describedBy} ${id}` : id;
-        trigger.setAttribute('aria-describedby', newDescribedBy);
-    }
-    // Make element focusable
-    if (!isFocusable(trigger)) {
-        trigger.setAttribute('tabindex', '0');
-    }
-};
-// Initialize a mutation observer for patching accessibility features
-const triggerObserver = attributeObserver.getAttributeObserver(tooltipTargetAttribute, patchAccessibilityFeatures);
-const PostTooltip = class {
+const TRIGGER_EVENTS = ['pointerenter', 'pointerleave', 'focusin', 'focusout', 'long-press'];
+const PostTooltipTrigger = class {
     constructor(hostRef) {
         index.registerInstance(this, hostRef);
-        this.wasOpenedByFocus = false;
-        this.placement = 'top';
-        this.arrow = true;
-        this.delayed = false;
+        /**
+         * Reference to the element inside the host that will act as the trigger.
+         */
+        this.trigger = null;
+        /**
+         * Timeout ID for the delay.
+         */
+        this.delayTimeout = null;
+        this.for = undefined;
+        this.delay = 0;
+        this.boundTriggerHandler = this.handleTriggerEvent.bind(this);
+        this.boundTooltipHandler = this.handleTooltipEvent.bind(this);
     }
-    validateDelayed() {
-        index$1.checkEmptyOrType(this.delayed, 'boolean', 'The post-tooltip "delayed" property should be a boolean.');
+    validateControlFor() {
+        checkType.checkType(this.for, // The actual property value
+        'string', // The expected type
+        'The "for" property must be a string' // A meaningful error message
+        );
     }
-    connectedCallback() {
-        this.validateDelayed();
+    get tooltip() {
+        const ref = document.getElementById(this.for);
+        return (ref === null || ref === void 0 ? void 0 : ref.localName) === 'post-tooltip'
+            ? ref
+            : null;
     }
     componentDidLoad() {
-        if (!this.host.id) {
-            throw new Error(
-            /*prettier-ignore*/
-            'No id set: <post-tooltip> must have an id, linking it to it\'s target element using the data-tooltip-target attribute.');
-        }
+        this.setupTrigger();
+        this.attachListeners();
+        this.attachTooltipListeners();
     }
-    /**
-     * Add interest event listeners, but only once, and start
-     * the accessibility patcher
-     */
-    componentWillLoad() {
-        if (tooltipInstances === 0) {
-            // This is the first tooltip on the page, add event listeners
-            document.addEventListener('pointerover', globalInterestHandler);
-            document.addEventListener('pointerout', globalInterestLostHandler);
-            document.addEventListener('focusin', globalInterestHandler);
-            document.addEventListener('focusout', globalInterestLostHandler);
-            document.addEventListener('long-press', globalInterestHandler);
-            // Initially run the accessibility patcher on all triggers
-            document.querySelectorAll('[data-tooltip-target]').forEach(patchAccessibilityFeatures);
-            // Start watching for future triggers
-            triggerObserver.observe(document.body, {
-                subtree: true,
-                childList: true,
-                attributeFilter: [tooltipTargetAttribute],
-            });
+    disconnectedCallback() {
+        this.removeListeners();
+        this.removeTooltipListeners();
+        this.cleanupTrigger();
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
         }
-        tooltipInstances++;
     }
-    /**
-     * Remove a bunch of event listeners if the tooltip gets removed from the DOM
-     * and disconnect the accessibility patcher
-     */
-    disconnectedCallback() {
-        tooltipInstances--;
-        if (tooltipInstances <= 0) {
-            // The last tooltip has been removed, stop listening for these kind of events
-            document.removeEventListener('pointerover', globalInterestHandler);
-            document.removeEventListener('pointerout', globalInterestLostHandler);
-            document.removeEventListener('focusin', globalInterestHandler);
-            document.removeEventListener('focusout', globalInterestLostHandler);
-            document.removeEventListener('long-press', globalInterestHandler);
-            triggerObserver.disconnect();
+    handleSlotChange() {
+        this.cleanupTrigger();
+        this.setupTrigger();
+    }
+    cleanupTrigger() {
+        if (this.trigger) {
+            const describedBy = this.trigger.getAttribute('aria-describedby') || '';
+            if (describedBy.includes(this.for)) {
+                const newDescribedBy = describedBy
+                    .split(' ')
+                    .filter(id => id !== this.for)
+                    .join(' ');
+                if (newDescribedBy) {
+                    this.trigger.setAttribute('aria-describedby', newDescribedBy);
+                }
+                else {
+                    this.trigger.removeAttribute('aria-describedby');
+                }
+            }
+            this.trigger = null;
         }
     }
-    /**
-     * Programmatically display the tooltip
-     * @param target An element with [data-tooltip-target="id"] where the tooltip should be shown
-     * @param triggeredByFocus A boolean indicating if the tooltip was triggered by a focus event.
-     */
-    async show(target, triggeredByFocus = false) {
-        const showTooltip = () => {
-            // If focus or pointer event is not on the button anymore, don't show the tooltip
-            if (globalCurrentTarget !== target)
-                return;
-            // Determine if the tooltip was opened by a focus event
-            this.wasOpenedByFocus = triggeredByFocus;
-            // Disable pointer events if triggered by focus, otherwise enable them
-            if (this.wasOpenedByFocus) {
-                this.host.style.pointerEvents = 'none';
+    setupTrigger() {
+        this.trigger = this.host.querySelector('*');
+        if (this.trigger) {
+            if (!isFocusable(this.trigger)) {
+                this.trigger.setAttribute('tabindex', '0');
             }
-            else {
-                this.host.style.pointerEvents = 'auto';
+            const describedBy = this.trigger.getAttribute('aria-describedby') || '';
+            if (!describedBy.includes(this.for)) {
+                this.trigger.setAttribute('aria-describedby', `${describedBy} ${this.for}`.trim());
             }
-            this.popoverRef.show(target);
-        };
-        if (this.delayed) {
-            tooltipTimeout = setTimeout(() => {
-                showTooltip();
-            }, OPEN_DELAY);
         }
         else {
-            showTooltip();
+            console.warn('No content found in the post-tooltip-trigger slot. Please insert a focusable element or content that can receive focus.');
         }
     }
-    /**
-     * Programmatically hide this tooltip
-     */
-    async hide() {
-        this.popoverRef.hide();
+    attachListeners() {
+        TRIGGER_EVENTS.forEach(event => {
+            this.host.addEventListener(event, this.boundTriggerHandler);
+        });
     }
-    /**
-     * Toggle tooltip display
-     * @param target An element with [data-tooltip-target="id"] where the tooltip should be shown
-     * @param force Pass true to always show or false to always hide
-     */
-    async toggle(target, force) {
-        this.popoverRef.toggle(target, force);
+    removeListeners() {
+        TRIGGER_EVENTS.forEach(event => {
+            this.host.removeEventListener(event, this.boundTriggerHandler);
+        });
     }
-    /**
-     * Pointer or focus is on the tooltip, stop the tooltip from disappearing
-     */
-    handleInterest() {
-        if (hideTooltipTimeout) {
-            window.clearTimeout(hideTooltipTimeout);
-            hideTooltipTimeout = null;
+    attachTooltipListeners() {
+        if (this.tooltip) {
+            this.tooltip.addEventListener('pointerenter', this.boundTooltipHandler);
+            this.tooltip.addEventListener('pointerleave', this.boundTooltipHandler);
         }
     }
-    /**
-     * Pointer or focus left the tooltip, initiate the hiding process
-     * Re-enable pointer events when the tooltip is no longer in focus or hovered
-     */
-    handleInterestLost() {
-        globalHideTooltip(this);
-        this.host.style.pointerEvents = 'auto';
+    removeTooltipListeners() {
+        if (this.tooltip) {
+            this.tooltip.removeEventListener('pointerenter', this.boundTooltipHandler);
+            this.tooltip.removeEventListener('pointerleave', this.boundTooltipHandler);
+        }
+    }
+    handleTriggerEvent(event) {
+        switch (event.type) {
+            case 'pointerenter':
+            case 'focusin':
+            case 'long-press':
+                this.handleEnter();
+                break;
+            case 'pointerleave':
+            case 'focusout':
+                this.handleLeave(event);
+                break;
+        }
+    }
+    handleTooltipEvent(event) {
+        switch (event.type) {
+            case 'pointerenter':
+                this.handleEnter();
+                break;
+            case 'pointerleave':
+                this.handleLeave(event);
+                break;
+        }
+    }
+    handleEnter() {
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
+        this.interestHandler();
+    }
+    handleLeave(event) {
+        const newTarget = event.relatedTarget;
+        if ((this.tooltip && newTarget && this.tooltip.contains(newTarget)) ||
+            (newTarget === this.trigger)) {
+            return;
+        }
+        this.interestLostHandler();
+    }
+    interestHandler() {
+        var _a;
+        if (this.delay > 0) {
+            this.delayTimeout = window.setTimeout(() => {
+                var _a;
+                (_a = this.tooltip) === null || _a === void 0 ? void 0 : _a.show(this.trigger);
+                this.delayTimeout = null;
+            }, this.delay);
+        }
+        else {
+            (_a = this.tooltip) === null || _a === void 0 ? void 0 : _a.show(this.trigger);
+        }
+    }
+    interestLostHandler() {
+        var _a;
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
+        (_a = this.tooltip) === null || _a === void 0 ? void 0 : _a.hide();
     }
     render() {
-        const popoverClass = `${this.arrow ? ' has-arrow' : ''}`;
-        return (index.h(index.Host, { key: '71db1ccf3cf929d76550b08e69c8594479eaa84f', "data-version": _package.version, role: "tooltip", onPointerOver: this.handleInterest, onPointerOut: this.handleInterestLost, onFocusIn: this.handleInterest, onFocusOut: this.handleInterestLost }, index.h("post-popovercontainer", { key: 'b9a38cabbfc2cf2eb9b257bca32022b5d97aac7c', class: popoverClass, arrow: this.arrow, placement: this.placement, ref: (el) => (this.popoverRef = el) }, index.h("slot", { key: '316b55f5fc55d9607205496a87f02a0a5fa197cf' }))));
+        return (index.h(index.Host, { key: 'a37c76972c4db24292fa95ddacf097055dea70f0', "data-version": _package.version }, index.h("slot", { key: '51de3cd7dedfc1c5fe5ef86fbf0ab953d07945cb', onSlotchange: () => this.handleSlotChange() })));
     }
     get host() { return index.getElement(this); }
     static get watchers() { return {
-        "delayed": ["validateDelayed"]
+        "for": ["validateControlFor"]
     }; }
 };
-PostTooltip.style = PostTooltipStyle0;
+PostTooltipTrigger.style = PostTooltipTriggerStyle0;
 
-exports.PostTooltip = PostTooltip;
+exports.PostTooltipTrigger = PostTooltipTrigger;