@swisspost/design-system-components 2.0.0 → 2.0.2

package/dist/cjs/{post-tooltip-659af1e3.js → post-tooltip-e5b22230.js}

@@ -1,11 +1,31 @@
 'use strict';
 
-const index = require('./index-13695f3f.js');
-const _package = require('./package-8152e25e.js');
+const index = require('./index-f243643b.js');
+const _package = require('./package-e8091039.js');
 
-// input may be undefined, selector-tring, Node, NodeList, HTMLCollection, array of Nodes
-// yes, to some extent this is a bad replica of jQuery's constructor function
-function nodeArray (input) {
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var focusable = {exports: {}};
+
+var focusRelevant = {exports: {}};
+
+var parents = {exports: {}};
+
+var contextToElement = {exports: {}};
+
+var nodeArray = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (input) {
   if (!input) {
     return [];
   }
@@ -28,16 +48,28 @@ function nodeArray (input) {
   }
 
   throw new TypeError('unexpected input ' + String(input));
-}
+};
 
-function contextToElement (_ref) {
+module.exports = exports['default'];
+// input may be undefined, selector-tring, Node, NodeList, HTMLCollection, array of Nodes
+// yes, to some extent this is a bad replica of jQuery's constructor function
+
+}(nodeArray, nodeArray.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (_ref) {
   var context = _ref.context,
       _ref$label = _ref.label,
       label = _ref$label === undefined ? 'context-to-element' : _ref$label,
       resolveDocument = _ref.resolveDocument,
       defaultToDocument = _ref.defaultToDocument;
 
-  var element = nodeArray(context)[0];
+  var element = (0, _nodeArray2.default)(context)[0];
 
   if (resolveDocument && element && element.nodeType === Node.DOCUMENT_NODE) {
     element = element.documentElement;
@@ -56,16 +88,30 @@ function contextToElement (_ref) {
   }
 
   return element;
-}
+};
 
-// [elem, elem.parent, elem.parent.parent, …, html]
-// will not contain the shadowRoot (DOCUMENT_FRAGMENT_NODE) and shadowHost
-function getParents () {
+var _nodeArray = nodeArray.exports;
+
+var _nodeArray2 = _interopRequireDefault(_nodeArray);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = exports['default'];
+
+}(contextToElement, contextToElement.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function () {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
       context = _ref.context;
 
   var list = [];
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'get/parents',
     context: context
   });
@@ -80,7 +126,29 @@ function getParents () {
   }
 
   return list;
-}
+};
+
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = exports['default'];
+
+// [elem, elem.parent, elem.parent.parent, …, html]
+// will not contain the shadowRoot (DOCUMENT_FRAGMENT_NODE) and shadowHost
+
+}(parents, parents.exports));
+
+var elementMatches = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = elementMatches;
 
 // Element.prototype.matches may be available at a different name
 // https://developer.mozilla.org/en/docs/Web/API/Element/matches
@@ -106,24 +174,30 @@ function elementMatches(element, selector) {
 
   return element[name](selector);
 }
+module.exports = exports['default'];
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+}(elementMatches, elementMatches.exports));
 
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire();
-		}
-	}, fn(module, module.exports), module.exports;
-}
+var tabindexValue = {exports: {}};
 
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
+var validTabindex = {exports: {}};
+
+var supports = {exports: {}};
+
+var detectFocus = {exports: {}};
+
+var platform$1 = {exports: {}};
 
-var platform$1 = createCommonjsModule(function (module, exports) {
+var platform = {exports: {}};
+
+/*!
+ * Platform.js <https://mths.be/platform>
+ * Copyright 2014-2016 Benjamin Tan <https://demoneaux.github.io/>
+ * Copyright 2011-2013 John-David Dalton <http://allyoucanleet.com/>
+ * Available under MIT license <https://mths.be/mit>
+ */
+
+(function (module, exports) {
 (function() {
 
   /** Used to determine if values are of the language type `Object`. */
@@ -139,10 +213,10 @@ var platform$1 = createCommonjsModule(function (module, exports) {
   var oldRoot = root;
 
   /** Detect free variable `exports`. */
-  var freeExports = objectTypes['object'] && exports;
+  var freeExports = exports;
 
   /** Detect free variable `module`. */
-  var freeModule = objectTypes['object'] && module && !module.nodeType && module;
+  var freeModule = module && !module.nodeType && module;
 
   /** Detect free variable `global` from Node.js or Browserified code and use it as `root`. */
   var freeGlobal = freeExports && freeModule && typeof commonjsGlobal == 'object' && commonjsGlobal;
@@ -1259,31 +1333,49 @@ var platform$1 = createCommonjsModule(function (module, exports) {
     root.platform = platform;
   }
 }.call(commonjsGlobal));
+}(platform, platform.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
 
+var _platform2 = platform.exports;
+
+var _platform3 = _interopRequireDefault(_platform2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 // deep clone of original platform
-var platform = JSON.parse(JSON.stringify(platform$1));
+var platform$1 = JSON.parse(JSON.stringify(_platform3.default));
 
 // operating system
-var os = platform.os.family || '';
+
+// sugar for https://github.com/bestiejs/platform.js
+// make sure to ALWAYS reference the layout engine,
+// even if it is not necessary for the condition,
+// as this makes grepping for this stuff simpler
+
+var os = platform$1.os.family || '';
 var ANDROID = os === 'Android';
 var WINDOWS = os.slice(0, 7) === 'Windows';
 var OSX = os === 'OS X';
 var IOS = os === 'iOS';
 
 // layout
-var BLINK = platform.layout === 'Blink';
-var GECKO = platform.layout === 'Gecko';
-var TRIDENT = platform.layout === 'Trident';
-var EDGE = platform.layout === 'EdgeHTML';
-var WEBKIT = platform.layout === 'WebKit';
+var BLINK = platform$1.layout === 'Blink';
+var GECKO = platform$1.layout === 'Gecko';
+var TRIDENT = platform$1.layout === 'Trident';
+var EDGE = platform$1.layout === 'EdgeHTML';
+var WEBKIT = platform$1.layout === 'WebKit';
 
 // browser version (not layout engine version!)
-var version$1 = parseFloat(platform.version);
-var majorVersion = Math.floor(version$1);
-platform.majorVersion = majorVersion;
+var version = parseFloat(platform$1.version);
+var majorVersion = Math.floor(version);
+platform$1.majorVersion = majorVersion;
 
-platform.is = {
+platform$1.is = {
   // operating system
   ANDROID: ANDROID,
   WINDOWS: WINDOWS,
@@ -1301,6 +1393,35 @@ platform.is = {
   IE11: TRIDENT && majorVersion === 11
 };
 
+exports.default = platform$1;
+module.exports = exports['default'];
+
+}(platform$1, platform$1.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (tests) {
+  var data = before();
+
+  var results = {};
+  Object.keys(tests).map(function (key) {
+    results[key] = test(data, tests[key]);
+  });
+
+  after(data);
+  return results;
+};
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function before() {
   var data = {
     // remember what had focus to restore after test
@@ -1368,7 +1489,7 @@ function after(data) {
   // restore focus to what it was before test and cleanup
   if (data.activeElement === document.body) {
     document.activeElement && document.activeElement.blur && document.activeElement.blur();
-    if (platform.is.IE10) {
+    if (_platform2.default.is.IE10) {
       // IE10 does not redirect focus to <body> when the activeElement is removed
       document.body.focus();
     }
@@ -1385,28 +1506,38 @@ function after(data) {
   document.body.scrollLeft = data.bodyScrollLeft;
 }
 
-function detectFocus (tests) {
-  var data = before();
+module.exports = exports['default'];
 
-  var results = {};
-  Object.keys(tests).map(function (key) {
-    results[key] = test(data, tests[key]);
-  });
+}(detectFocus, detectFocus.exports));
 
-  after(data);
-  return results;
-}
+var supportsCache = {exports: {}};
+
+var version = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // this file is overwritten by `npm run build:pre`
 var version = '1.4.1';
+exports.default = version;
+module.exports = exports['default'];
 
-/*
-    Facility to cache test results in localStorage.
+}(version, version.exports));
 
-    USAGE:
-      cache.get('key');
-      cache.set('key', 'value');
- */
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _version = version.exports;
+
+var _version2 = _interopRequireDefault(_version);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function readLocalStorage(key) {
   // allow reading from storage to retrieve previous support results
@@ -1421,7 +1552,13 @@ function readLocalStorage(key) {
   }
 
   return data;
-}
+} /*
+      Facility to cache test results in localStorage.
+  
+      USAGE:
+        cache.get('key');
+        cache.set('key', 'value');
+   */
 
 function writeLocalStorage(key, value) {
   if (!document.hasFocus()) {
@@ -1449,14 +1586,14 @@ var cacheKey = 'ally-supports-cache';
 var cache = readLocalStorage(cacheKey);
 
 // update the cache if ally or the user agent changed (newer version, etc)
-if (cache.userAgent !== userAgent || cache.version !== version) {
+if (cache.userAgent !== userAgent || cache.version !== _version2.default) {
   cache = {};
 }
 
 cache.userAgent = userAgent;
-cache.version = version;
+cache.version = _version2.default;
 
-const cache$1 = {
+exports.default = {
   get: function get() {
     return cache;
   },
@@ -1469,8 +1606,19 @@ const cache$1 = {
     writeLocalStorage(cacheKey, cache);
   }
 };
+module.exports = exports['default'];
 
-function cssShadowPiercingDeepCombinator () {
+}(supportsCache, supportsCache.exports));
+
+var cssShadowPiercingDeepCombinator = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function () {
   var combinator = void 0;
 
   // see https://dev.w3.org/csswg/css-scoping-1/#deep-combinator
@@ -1491,30 +1639,79 @@ function cssShadowPiercingDeepCombinator () {
   }
 
   return combinator;
-}
+};
+
+module.exports = exports['default'];
 
-const gif = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+}(cssShadowPiercingDeepCombinator, cssShadowPiercingDeepCombinator.exports));
+
+var focusAreaImgTabindex = {exports: {}};
+
+var gif = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+module.exports = exports['default'];
+
+}(gif, gif.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
-const focusAreaImgTabindex = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = '<map name="image-map-tabindex-test">' + '<area shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-tabindex-test" tabindex="-1" alt="" src="' + gif + '">';
+    element.innerHTML = '<map name="image-map-tabindex-test">' + '<area shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-tabindex-test" tabindex="-1" alt="" src="' + _gif2.default + '">';
 
     return element.querySelector('area');
   }
 };
+module.exports = exports['default'];
+
+}(focusAreaImgTabindex, focusAreaImgTabindex.exports));
+
+var focusAreaTabindex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
-const focusAreaTabindex = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = '<map name="image-map-tabindex-test">' + '<area href="#void" tabindex="-1" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-tabindex-test" alt="" src="' + gif + '">';
+    element.innerHTML = '<map name="image-map-tabindex-test">' + '<area href="#void" tabindex="-1" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-tabindex-test" alt="" src="' + _gif2.default + '">';
 
     return false;
   },
   validate: function validate(element, focusTarget, _document) {
-    if (platform.is.GECKO) {
+    if (_platform2.default.is.GECKO) {
       // fixes https://github.com/medialize/ally.js/issues/35
       // Firefox loads the DataURI asynchronously, causing a false-negative
       return true;
@@ -1525,17 +1722,38 @@ const focusAreaTabindex = {
     return _document.activeElement === focus;
   }
 };
+module.exports = exports['default'];
+
+}(focusAreaTabindex, focusAreaTabindex.exports));
+
+var focusAreaWithoutHref = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
-const focusAreaWithoutHref = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = '<map name="image-map-area-href-test">' + '<area shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-area-href-test" alt="" src="' + gif + '">';
+    element.innerHTML = '<map name="image-map-area-href-test">' + '<area shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-area-href-test" alt="" src="' + _gif2.default + '">';
 
     return element.querySelector('area');
   },
   validate: function validate(element, focusTarget, _document) {
-    if (platform.is.GECKO) {
+    if (_platform2.default.is.GECKO) {
       // fixes https://github.com/medialize/ally.js/issues/35
       // Firefox loads the DataURI asynchronously, causing a false-negative
       return true;
@@ -1544,35 +1762,111 @@ const focusAreaWithoutHref = {
     return _document.activeElement === focusTarget;
   }
 };
+module.exports = exports['default'];
+
+}(focusAreaWithoutHref, focusAreaWithoutHref.exports));
+
+var focusAudioWithoutControls = {exports: {}};
+
+var mp3 = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = _gif2.default;
+// export default 'data:audio/mp3;base64,audio-focus-test';
+
+module.exports = exports['default'];
+
+}(mp3, mp3.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _mp = mp3.exports;
 
-const focusAudioWithoutControls = {
+var _mp2 = _interopRequireDefault(_mp);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
   name: 'can-focus-audio-without-controls',
   element: 'audio',
   mutate: function mutate(element) {
     try {
       // invalid media file can trigger warning in console, data-uri to prevent HTTP request
-      element.setAttribute('src', gif);
+      element.setAttribute('src', _mp2.default);
     } catch (e) {
       // IE9 may throw "Error: Not implemented"
     }
   }
 };
+module.exports = exports['default'];
+
+}(focusAudioWithoutControls, focusAudioWithoutControls.exports));
+
+var focusBrokenImageMap = {exports: {}};
+
+var gif_invalid = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ';
+module.exports = exports['default'];
 
-const invalidGif = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ';
+}(gif_invalid, gif_invalid.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif_invalid.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // NOTE: https://github.com/medialize/ally.js/issues/35
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
-const focusBrokenImageMap = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = '<map name="broken-image-map-test"><area href="#void" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#broken-image-map-test" alt="" src="' + invalidGif + '">';
+    element.innerHTML = '<map name="broken-image-map-test"><area href="#void" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#broken-image-map-test" alt="" src="' + _gif2.default + '">';
 
     return element.querySelector('area');
   }
 };
+module.exports = exports['default'];
+
+}(focusBrokenImageMap, focusBrokenImageMap.exports));
+
+var focusChildrenOfFocusableFlexbox = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // Children of focusable elements with display:flex are focusable in IE10-11
-const focusChildrenOfFocusableFlexbox = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
     element.setAttribute('tabindex', '-1');
@@ -1581,70 +1875,157 @@ const focusChildrenOfFocusableFlexbox = {
     return element.querySelector('span');
   }
 };
+module.exports = exports['default'];
+
+}(focusChildrenOfFocusableFlexbox, focusChildrenOfFocusableFlexbox.exports));
+
+var focusFieldsetDisabled = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // fieldset[tabindex=0][disabled] should not be focusable, but Blink and WebKit disagree
 // @specification https://www.w3.org/TR/html5/disabled-elements.html#concept-element-disabled
 // @browser-issue Chromium https://crbug.com/453847
 // @browser-issue WebKit https://bugs.webkit.org/show_bug.cgi?id=141086
-const focusFieldsetDisabled = {
+exports.default = {
   element: 'fieldset',
   mutate: function mutate(element) {
     element.setAttribute('tabindex', 0);
     element.setAttribute('disabled', 'disabled');
   }
 };
+module.exports = exports['default'];
 
-const focusFieldset = {
+}(focusFieldsetDisabled, focusFieldsetDisabled.exports));
+
+var focusFieldset = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
   element: 'fieldset',
   mutate: function mutate(element) {
     element.innerHTML = '<legend>legend</legend><p>content</p>';
   }
 };
+module.exports = exports['default'];
+
+}(focusFieldset, focusFieldset.exports));
+
+var focusFlexboxContainer = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // elements with display:flex are focusable in IE10-11
-const focusFlexboxContainer = {
+exports.default = {
   element: 'span',
   mutate: function mutate(element) {
     element.setAttribute('style', 'display: -webkit-flex; display: -ms-flexbox; display: flex;');
     element.innerHTML = '<span style="display: block;">hello</span>';
   }
 };
+module.exports = exports['default'];
+
+}(focusFlexboxContainer, focusFlexboxContainer.exports));
+
+var focusFormDisabled = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // form[tabindex=0][disabled] should be focusable as the
 // specification doesn't know the disabled attribute on the form element
 // @specification https://www.w3.org/TR/html5/forms.html#the-form-element
-const focusFormDisabled = {
+exports.default = {
   element: 'form',
   mutate: function mutate(element) {
     element.setAttribute('tabindex', 0);
     element.setAttribute('disabled', 'disabled');
   }
 };
+module.exports = exports['default'];
+
+}(focusFormDisabled, focusFormDisabled.exports));
+
+var focusImgIsmap = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // NOTE: https://github.com/medialize/ally.js/issues/35
 // fixes https://github.com/medialize/ally.js/issues/20
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-ismap
-const focusImgIsmap = {
+exports.default = {
   element: 'a',
   mutate: function mutate(element) {
     element.href = '#void';
-    element.innerHTML = '<img ismap src="' + gif + '" alt="">';
+    element.innerHTML = '<img ismap src="' + _gif2.default + '" alt="">';
     return element.querySelector('img');
   }
 };
+module.exports = exports['default'];
+
+}(focusImgIsmap, focusImgIsmap.exports));
+
+var focusImgUsemapTabindex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // NOTE: https://github.com/medialize/ally.js/issues/35
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
-const focusImgUsemapTabindex = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = '<map name="image-map-tabindex-test"><area href="#void" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-tabindex-test" tabindex="-1" alt="" ' + 'src="' + gif + '">';
+    element.innerHTML = '<map name="image-map-tabindex-test"><area href="#void" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#image-map-tabindex-test" tabindex="-1" alt="" ' + 'src="' + _gif2.default + '">';
 
     return element.querySelector('img');
   }
 };
+module.exports = exports['default'];
+
+}(focusImgUsemapTabindex, focusImgUsemapTabindex.exports));
+
+var focusInHiddenIframe = {exports: {}};
 
-const focusInHiddenIframe = {
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
   element: function element(wrapper, _document) {
     var iframe = _document.createElement('iframe');
 
@@ -1671,23 +2052,62 @@ const focusInHiddenIframe = {
     return iframeDocument.activeElement === focus;
   }
 };
+module.exports = exports['default'];
 
-var result$3 = !platform.is.WEBKIT;
+}(focusInHiddenIframe, focusInHiddenIframe.exports));
 
-function focusInZeroDimensionObject () {
-  return result$3;
-}
+var focusInZeroDimensionObject = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function () {
+  return result;
+};
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var result = !_platform2.default.is.WEBKIT;
+
+module.exports = exports['default'];
+
+}(focusInZeroDimensionObject, focusInZeroDimensionObject.exports));
+
+var focusInvalidTabindex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // Firefox allows *any* value and treats invalid values like tabindex="-1"
 // @browser-issue Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
-const focusInvalidTabindex = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
     element.setAttribute('tabindex', 'invalid-value');
   }
 };
+module.exports = exports['default'];
+
+}(focusInvalidTabindex, focusInvalidTabindex.exports));
 
-const focusLabelTabindex = {
+var focusLabelTabindex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
   element: 'label',
   mutate: function mutate(element) {
     element.setAttribute('tabindex', '-1');
@@ -1698,35 +2118,83 @@ const focusLabelTabindex = {
     return _document.activeElement === element;
   }
 };
+module.exports = exports['default'];
+
+}(focusLabelTabindex, focusLabelTabindex.exports));
 
-const svg = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtb' + 'G5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiBpZD0ic3ZnIj48dGV4dCB4PSIxMCIgeT0iMjAiIGlkPSJ' + 'zdmctbGluay10ZXh0Ij50ZXh0PC90ZXh0Pjwvc3ZnPg==';
+var focusObjectSvgHidden = {exports: {}};
+
+var svg$1 = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtb' + 'G5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiBpZD0ic3ZnIj48dGV4dCB4PSIxMCIgeT0iMjAiIGlkPSJ' + 'zdmctbGluay10ZXh0Ij50ZXh0PC90ZXh0Pjwvc3ZnPg==';
+module.exports = exports['default'];
+
+}(svg$1, svg$1.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg$1.exports;
+
+var _svg2 = _interopRequireDefault(_svg);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Note: IE10 on BrowserStack does not like this test
 
-const focusObjectSvgHidden = {
+exports.default = {
   element: 'object',
   mutate: function mutate(element) {
     element.setAttribute('type', 'image/svg+xml');
-    element.setAttribute('data', svg);
+    element.setAttribute('data', _svg2.default);
     element.setAttribute('width', '200');
     element.setAttribute('height', '50');
     element.style.visibility = 'hidden';
   }
 };
+module.exports = exports['default'];
 
-// Note: IE10 on BrowserStack does not like this test
+}(focusObjectSvgHidden, focusObjectSvgHidden.exports));
 
-const focusObjectSvg = {
-  name: 'can-focus-object-svg',
-  element: 'object',
-  mutate: function mutate(element) {
-    element.setAttribute('type', 'image/svg+xml');
-    element.setAttribute('data', svg);
+var focusObjectSvg = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg$1.exports;
+
+var _svg2 = _interopRequireDefault(_svg);
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Note: IE10 on BrowserStack does not like this test
+
+exports.default = {
+  name: 'can-focus-object-svg',
+  element: 'object',
+  mutate: function mutate(element) {
+    element.setAttribute('type', 'image/svg+xml');
+    element.setAttribute('data', _svg2.default);
     element.setAttribute('width', '200');
     element.setAttribute('height', '50');
   },
   validate: function validate(element, focusTarget, _document) {
-    if (platform.is.GECKO) {
+    if (_platform2.default.is.GECKO) {
       // Firefox seems to be handling the object creation asynchronously and thereby produces a false negative test result.
       // Because we know Firefox is able to focus object elements referencing SVGs, we simply cheat by sniffing the user agent string
       return true;
@@ -1735,18 +2203,53 @@ const focusObjectSvg = {
     return _document.activeElement === element;
   }
 };
+module.exports = exports['default'];
+
+}(focusObjectSvg, focusObjectSvg.exports));
+
+var focusObjectSwf = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function () {
+  return result;
+};
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Every Environment except IE9 considers SWF objects focusable
-var result$2 = !platform.is.IE9;
+var result = !_platform2.default.is.IE9;
 
-function focusObjectSwf () {
-  return result$2;
-}
+module.exports = exports['default'];
+
+}(focusObjectSwf, focusObjectSwf.exports));
+
+var focusRedirectImgUsemap = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
 
-const focusRedirectImgUsemap = {
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = '<map name="focus-redirect-img-usemap"><area href="#void" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#focus-redirect-img-usemap" alt="" ' + 'src="' + gif + '">';
+    element.innerHTML = '<map name="focus-redirect-img-usemap"><area href="#void" shape="rect" coords="63,19,144,45"></map>' + '<img usemap="#focus-redirect-img-usemap" alt="" ' + 'src="' + _gif2.default + '">';
 
     // focus the <img>, not the <div>
     return element.querySelector('img');
@@ -1756,10 +2259,21 @@ const focusRedirectImgUsemap = {
     return _document.activeElement === target;
   }
 };
+module.exports = exports['default'];
+
+}(focusRedirectImgUsemap, focusRedirectImgUsemap.exports));
+
+var focusRedirectLegend = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // see https://jsbin.com/nenirisage/edit?html,js,console,output
 
-const focusRedirectLegend = {
+exports.default = {
   element: 'fieldset',
   mutate: function mutate(element) {
     element.innerHTML = '<legend>legend</legend><input tabindex="-1"><input tabindex="0">';
@@ -1778,9 +2292,20 @@ const focusRedirectLegend = {
     return _document.activeElement === focusable && 'focusable' || _document.activeElement === tabbable && 'tabbable' || '';
   }
 };
+module.exports = exports['default'];
+
+}(focusRedirectLegend, focusRedirectLegend.exports));
+
+var focusScrollBody = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // https://github.com/medialize/ally.js/issues/21
-const focusScrollBody = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
     element.setAttribute('style', 'width: 100px; height: 50px; overflow: auto;');
@@ -1788,41 +2313,81 @@ const focusScrollBody = {
     return element.querySelector('div');
   }
 };
+module.exports = exports['default'];
+
+}(focusScrollBody, focusScrollBody.exports));
+
+var focusScrollContainerWithoutOverflow = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // https://github.com/medialize/ally.js/issues/21
-const focusScrollContainerWithoutOverflow = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
     element.setAttribute('style', 'width: 100px; height: 50px;');
     element.innerHTML = '<div style="width: 500px; height: 40px;">scrollable content</div>';
   }
 };
+module.exports = exports['default'];
+
+}(focusScrollContainerWithoutOverflow, focusScrollContainerWithoutOverflow.exports));
+
+var focusScrollContainer = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // https://github.com/medialize/ally.js/issues/21
-const focusScrollContainer = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
     element.setAttribute('style', 'width: 100px; height: 50px; overflow: auto;');
     element.innerHTML = '<div style="width: 500px; height: 40px;">scrollable content</div>';
   }
 };
+module.exports = exports['default'];
+
+}(focusScrollContainer, focusScrollContainer.exports));
 
-const focusSummary = {
+var focusSummary = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
   element: 'details',
   mutate: function mutate(element) {
     element.innerHTML = '<summary>foo</summary><p>content</p>';
     return element.firstElementChild;
   }
 };
+module.exports = exports['default'];
 
-function makeFocusableForeignObject() {
-  var fragment = document.createElement('div');
-  fragment.innerHTML = '<svg><foreignObject width="30" height="30">\n      <input type="text"/>\n  </foreignObject></svg>';
+}(focusSummary, focusSummary.exports));
 
-  return fragment.firstChild.firstChild;
-}
+var focusSvgFocusableAttribute = {exports: {}};
+
+var svg = {};
+
+var focus_svgForeignObjectHack = {exports: {}};
 
-function focusSvgForeignObjectHack (element) {
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (element) {
   // Edge13, Edge14: foreignObject focus hack
   // https://jsbin.com/kunehinugi/edit?html,js,output
   // https://jsbin.com/fajagi/3/edit?html,js,output
@@ -1846,8 +2411,32 @@ function focusSvgForeignObjectHack (element) {
   // clean up
   element.removeChild(foreignObject);
   return true;
+};
+
+function makeFocusableForeignObject() {
+  var fragment = document.createElement('div');
+  fragment.innerHTML = '<svg><foreignObject width="30" height="30">\n      <input type="text"/>\n  </foreignObject></svg>';
+
+  return fragment.firstChild.firstChild;
 }
 
+module.exports = exports['default'];
+
+}(focus_svgForeignObjectHack, focus_svgForeignObjectHack.exports));
+
+Object.defineProperty(svg, "__esModule", {
+  value: true
+});
+svg.generate = generate;
+svg.focus = focus;
+svg.validate = validate;
+
+var _focus = focus_svgForeignObjectHack.exports;
+
+var _focus2 = _interopRequireDefault$1(_focus);
+
+function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function generate(element) {
   return '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">' + element + '</svg>';
 }
@@ -1860,7 +2449,7 @@ function focus(element) {
   try {
     HTMLElement.prototype.focus.call(element);
   } catch (e) {
-    focusSvgForeignObjectHack(element);
+    (0, _focus2.default)(element);
   }
 }
 
@@ -1869,84 +2458,196 @@ function validate(element, focusTarget, _document) {
   return _document.activeElement === focusTarget;
 }
 
-const focusSvgFocusableAttribute = {
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = generate('<text focusable="true">a</text>');
+    element.innerHTML = (0, _svg.generate)('<text focusable="true">a</text>');
     return element.querySelector('text');
   },
-  validate: validate
+  validate: _svg.validate
 };
+module.exports = exports['default'];
+
+}(focusSvgFocusableAttribute, focusSvgFocusableAttribute.exports));
+
+var focusSvgTabindexAttribute = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-const focusSvgTabindexAttribute = {
+var _svg = svg;
+
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = generate('<text tabindex="0">a</text>');
+    element.innerHTML = (0, _svg.generate)('<text tabindex="0">a</text>');
     return element.querySelector('text');
   },
-  validate: validate
+  validate: _svg.validate
 };
+module.exports = exports['default'];
+
+}(focusSvgTabindexAttribute, focusSvgTabindexAttribute.exports));
+
+var focusSvgNegativeTabindexAttribute = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
 
-const focusSvgNegativeTabindexAttribute = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = generate('<text tabindex="-1">a</text>');
+    element.innerHTML = (0, _svg.generate)('<text tabindex="-1">a</text>');
     return element.querySelector('text');
   },
-  validate: validate
+  validate: _svg.validate
 };
+module.exports = exports['default'];
+
+}(focusSvgNegativeTabindexAttribute, focusSvgNegativeTabindexAttribute.exports));
+
+var focusSvgUseTabindex = {exports: {}};
+
+(function (module, exports) {
 
-const focusSvgUseTabindex = {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = generate(['<g id="ally-test-target"><a xlink:href="#void"><text>link</text></a></g>', '<use xlink:href="#ally-test-target" x="0" y="0" tabindex="-1" />'].join(''));
+    element.innerHTML = (0, _svg.generate)(['<g id="ally-test-target"><a xlink:href="#void"><text>link</text></a></g>', '<use xlink:href="#ally-test-target" x="0" y="0" tabindex="-1" />'].join(''));
 
     return element.querySelector('use');
   },
-  validate: validate
+  validate: _svg.validate
 };
+module.exports = exports['default'];
+
+}(focusSvgUseTabindex, focusSvgUseTabindex.exports));
+
+var focusSvgForeignobjectTabindex = {exports: {}};
 
-const focusSvgForeignobjectTabindex = {
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = generate('<foreignObject tabindex="-1"><input type="text" /></foreignObject>');
+    element.innerHTML = (0, _svg.generate)('<foreignObject tabindex="-1"><input type="text" /></foreignObject>');
     // Safari 8's quersSelector() can't identify foreignObject, but getElementyByTagName() can
     return element.querySelector('foreignObject') || element.getElementsByTagName('foreignObject')[0];
   },
-  validate: validate
+  validate: _svg.validate
+
+};
+module.exports = exports['default'];
+
+}(focusSvgForeignobjectTabindex, focusSvgForeignobjectTabindex.exports));
+
+var focusSvgInIframe = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+exports.default = function () {
+  return result;
 };
 
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 // Firefox seems to be handling the SVG-document-in-iframe creation asynchronously
 // and thereby produces a false negative test result. Thus the test is pointless
 // and we resort to UA sniffing once again.
 // see http://jsbin.com/vunadohoko/1/edit?js,console,output
 
-var result$1 = Boolean(platform.is.GECKO && typeof SVGElement !== 'undefined' && SVGElement.prototype.focus);
+var result = Boolean(_platform2.default.is.GECKO && typeof SVGElement !== 'undefined' && SVGElement.prototype.focus);
 
-function focusSvgInIframe () {
-  return result$1;
-}
+module.exports = exports['default'];
+
+}(focusSvgInIframe, focusSvgInIframe.exports));
+
+var focusSvg = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
 
-const focusSvg = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
-    element.innerHTML = generate('');
+    element.innerHTML = (0, _svg.generate)('');
     return element.firstChild;
   },
-  validate: validate
+  validate: _svg.validate
 };
+module.exports = exports['default'];
+
+}(focusSvg, focusSvg.exports));
+
+var focusTabindexTrailingCharacters = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
 // Firefox allows *any* value and treats invalid values like tabindex="-1"
 // @browser-issue Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
-const focusTabindexTrailingCharacters = {
+exports.default = {
   element: 'div',
   mutate: function mutate(element) {
     element.setAttribute('tabindex', '3x');
   }
 };
+module.exports = exports['default'];
+
+}(focusTabindexTrailingCharacters, focusTabindexTrailingCharacters.exports));
+
+var focusTable = {exports: {}};
+
+(function (module, exports) {
 
-const focusTable = {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
   element: 'table',
   mutate: function mutate(element, wrapper, _document) {
     // IE9 has a problem replacing TBODY contents with innerHTML.
@@ -1957,71 +2658,308 @@ const focusTable = {
     element.appendChild(fragment);
   }
 };
+module.exports = exports['default'];
+
+}(focusTable, focusTable.exports));
+
+var focusVideoWithoutControls = {exports: {}};
+
+var mp4 = {exports: {}};
+
+(function (module, exports) {
 
-const focusVideoWithoutControls = {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _gif = gif.exports;
+
+var _gif2 = _interopRequireDefault(_gif);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = _gif2.default;
+// export default 'data:video/mp4;base64,video-focus-test';
+
+module.exports = exports['default'];
+
+}(mp4, mp4.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _mp = mp4.exports;
+
+var _mp2 = _interopRequireDefault(_mp);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
   element: 'video',
   mutate: function mutate(element) {
     try {
       // invalid media file can trigger warning in console, data-uri to prevent HTTP request
-      element.setAttribute('src', gif);
+      element.setAttribute('src', _mp2.default);
     } catch (e) {
       // IE9 may throw "Error: Not implemented"
     }
   }
 };
+module.exports = exports['default'];
 
-// https://jsbin.com/vafaba/3/edit?html,js,console,output
-var result = platform.is.GECKO || platform.is.TRIDENT || platform.is.EDGE;
+}(focusVideoWithoutControls, focusVideoWithoutControls.exports));
 
-function tabsequenceAreaAtImgPosition () {
+var tabsequenceAreaAtImgPosition = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function () {
   return result;
-}
+};
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// https://jsbin.com/vafaba/3/edit?html,js,console,output
+var result = _platform2.default.is.GECKO || _platform2.default.is.TRIDENT || _platform2.default.is.EDGE;
+
+module.exports = exports['default'];
+
+}(tabsequenceAreaAtImgPosition, tabsequenceAreaAtImgPosition.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function () {
+  if (supportsCache$1) {
+    return supportsCache$1;
+  }
+
+  supportsCache$1 = _supportsCache2.default.get();
+  if (!supportsCache$1.time) {
+    _supportsCache2.default.set(executeTests());
+    supportsCache$1 = _supportsCache2.default.get();
+  }
+
+  return supportsCache$1;
+};
+
+var _detectFocus = detectFocus.exports;
+
+var _detectFocus2 = _interopRequireDefault(_detectFocus);
+
+var _supportsCache = supportsCache.exports;
+
+var _supportsCache2 = _interopRequireDefault(_supportsCache);
+
+var _cssShadowPiercingDeepCombinator = cssShadowPiercingDeepCombinator.exports;
+
+var _cssShadowPiercingDeepCombinator2 = _interopRequireDefault(_cssShadowPiercingDeepCombinator);
+
+var _focusAreaImgTabindex = focusAreaImgTabindex.exports;
+
+var _focusAreaImgTabindex2 = _interopRequireDefault(_focusAreaImgTabindex);
+
+var _focusAreaTabindex = focusAreaTabindex.exports;
+
+var _focusAreaTabindex2 = _interopRequireDefault(_focusAreaTabindex);
+
+var _focusAreaWithoutHref = focusAreaWithoutHref.exports;
+
+var _focusAreaWithoutHref2 = _interopRequireDefault(_focusAreaWithoutHref);
+
+var _focusAudioWithoutControls = focusAudioWithoutControls.exports;
+
+var _focusAudioWithoutControls2 = _interopRequireDefault(_focusAudioWithoutControls);
+
+var _focusBrokenImageMap = focusBrokenImageMap.exports;
+
+var _focusBrokenImageMap2 = _interopRequireDefault(_focusBrokenImageMap);
+
+var _focusChildrenOfFocusableFlexbox = focusChildrenOfFocusableFlexbox.exports;
+
+var _focusChildrenOfFocusableFlexbox2 = _interopRequireDefault(_focusChildrenOfFocusableFlexbox);
+
+var _focusFieldsetDisabled = focusFieldsetDisabled.exports;
+
+var _focusFieldsetDisabled2 = _interopRequireDefault(_focusFieldsetDisabled);
+
+var _focusFieldset = focusFieldset.exports;
+
+var _focusFieldset2 = _interopRequireDefault(_focusFieldset);
+
+var _focusFlexboxContainer = focusFlexboxContainer.exports;
+
+var _focusFlexboxContainer2 = _interopRequireDefault(_focusFlexboxContainer);
+
+var _focusFormDisabled = focusFormDisabled.exports;
+
+var _focusFormDisabled2 = _interopRequireDefault(_focusFormDisabled);
+
+var _focusImgIsmap = focusImgIsmap.exports;
+
+var _focusImgIsmap2 = _interopRequireDefault(_focusImgIsmap);
+
+var _focusImgUsemapTabindex = focusImgUsemapTabindex.exports;
+
+var _focusImgUsemapTabindex2 = _interopRequireDefault(_focusImgUsemapTabindex);
+
+var _focusInHiddenIframe = focusInHiddenIframe.exports;
+
+var _focusInHiddenIframe2 = _interopRequireDefault(_focusInHiddenIframe);
+
+var _focusInZeroDimensionObject = focusInZeroDimensionObject.exports;
+
+var _focusInZeroDimensionObject2 = _interopRequireDefault(_focusInZeroDimensionObject);
+
+var _focusInvalidTabindex = focusInvalidTabindex.exports;
+
+var _focusInvalidTabindex2 = _interopRequireDefault(_focusInvalidTabindex);
+
+var _focusLabelTabindex = focusLabelTabindex.exports;
+
+var _focusLabelTabindex2 = _interopRequireDefault(_focusLabelTabindex);
+
+var _focusObjectSvgHidden = focusObjectSvgHidden.exports;
+
+var _focusObjectSvgHidden2 = _interopRequireDefault(_focusObjectSvgHidden);
+
+var _focusObjectSvg = focusObjectSvg.exports;
+
+var _focusObjectSvg2 = _interopRequireDefault(_focusObjectSvg);
+
+var _focusObjectSwf = focusObjectSwf.exports;
+
+var _focusObjectSwf2 = _interopRequireDefault(_focusObjectSwf);
+
+var _focusRedirectImgUsemap = focusRedirectImgUsemap.exports;
+
+var _focusRedirectImgUsemap2 = _interopRequireDefault(_focusRedirectImgUsemap);
+
+var _focusRedirectLegend = focusRedirectLegend.exports;
+
+var _focusRedirectLegend2 = _interopRequireDefault(_focusRedirectLegend);
+
+var _focusScrollBody = focusScrollBody.exports;
+
+var _focusScrollBody2 = _interopRequireDefault(_focusScrollBody);
+
+var _focusScrollContainerWithoutOverflow = focusScrollContainerWithoutOverflow.exports;
+
+var _focusScrollContainerWithoutOverflow2 = _interopRequireDefault(_focusScrollContainerWithoutOverflow);
+
+var _focusScrollContainer = focusScrollContainer.exports;
+
+var _focusScrollContainer2 = _interopRequireDefault(_focusScrollContainer);
+
+var _focusSummary = focusSummary.exports;
+
+var _focusSummary2 = _interopRequireDefault(_focusSummary);
+
+var _focusSvgFocusableAttribute = focusSvgFocusableAttribute.exports;
+
+var _focusSvgFocusableAttribute2 = _interopRequireDefault(_focusSvgFocusableAttribute);
+
+var _focusSvgTabindexAttribute = focusSvgTabindexAttribute.exports;
+
+var _focusSvgTabindexAttribute2 = _interopRequireDefault(_focusSvgTabindexAttribute);
+
+var _focusSvgNegativeTabindexAttribute = focusSvgNegativeTabindexAttribute.exports;
+
+var _focusSvgNegativeTabindexAttribute2 = _interopRequireDefault(_focusSvgNegativeTabindexAttribute);
+
+var _focusSvgUseTabindex = focusSvgUseTabindex.exports;
+
+var _focusSvgUseTabindex2 = _interopRequireDefault(_focusSvgUseTabindex);
+
+var _focusSvgForeignobjectTabindex = focusSvgForeignobjectTabindex.exports;
+
+var _focusSvgForeignobjectTabindex2 = _interopRequireDefault(_focusSvgForeignobjectTabindex);
+
+var _focusSvgInIframe = focusSvgInIframe.exports;
+
+var _focusSvgInIframe2 = _interopRequireDefault(_focusSvgInIframe);
+
+var _focusSvg = focusSvg.exports;
+
+var _focusSvg2 = _interopRequireDefault(_focusSvg);
+
+var _focusTabindexTrailingCharacters = focusTabindexTrailingCharacters.exports;
+
+var _focusTabindexTrailingCharacters2 = _interopRequireDefault(_focusTabindexTrailingCharacters);
+
+var _focusTable = focusTable.exports;
+
+var _focusTable2 = _interopRequireDefault(_focusTable);
+
+var _focusVideoWithoutControls = focusVideoWithoutControls.exports;
+
+var _focusVideoWithoutControls2 = _interopRequireDefault(_focusVideoWithoutControls);
+
+var _tabsequenceAreaAtImgPosition = tabsequenceAreaAtImgPosition.exports;
+
+var _tabsequenceAreaAtImgPosition2 = _interopRequireDefault(_tabsequenceAreaAtImgPosition);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var testCallbacks = {
-  cssShadowPiercingDeepCombinator: cssShadowPiercingDeepCombinator,
-  focusInZeroDimensionObject: focusInZeroDimensionObject,
-  focusObjectSwf: focusObjectSwf,
-  focusSvgInIframe: focusSvgInIframe,
-  tabsequenceAreaAtImgPosition: tabsequenceAreaAtImgPosition
+  cssShadowPiercingDeepCombinator: _cssShadowPiercingDeepCombinator2.default,
+  focusInZeroDimensionObject: _focusInZeroDimensionObject2.default,
+  focusObjectSwf: _focusObjectSwf2.default,
+  focusSvgInIframe: _focusSvgInIframe2.default,
+  tabsequenceAreaAtImgPosition: _tabsequenceAreaAtImgPosition2.default
 };
 
 var testDescriptions = {
-  focusAreaImgTabindex: focusAreaImgTabindex,
-  focusAreaTabindex: focusAreaTabindex,
-  focusAreaWithoutHref: focusAreaWithoutHref,
-  focusAudioWithoutControls: focusAudioWithoutControls,
-  focusBrokenImageMap: focusBrokenImageMap,
-  focusChildrenOfFocusableFlexbox: focusChildrenOfFocusableFlexbox,
-  focusFieldsetDisabled: focusFieldsetDisabled,
-  focusFieldset: focusFieldset,
-  focusFlexboxContainer: focusFlexboxContainer,
-  focusFormDisabled: focusFormDisabled,
-  focusImgIsmap: focusImgIsmap,
-  focusImgUsemapTabindex: focusImgUsemapTabindex,
-  focusInHiddenIframe: focusInHiddenIframe,
-  focusInvalidTabindex: focusInvalidTabindex,
-  focusLabelTabindex: focusLabelTabindex,
-  focusObjectSvg: focusObjectSvg,
-  focusObjectSvgHidden: focusObjectSvgHidden,
-  focusRedirectImgUsemap: focusRedirectImgUsemap,
-  focusRedirectLegend: focusRedirectLegend,
-  focusScrollBody: focusScrollBody,
-  focusScrollContainerWithoutOverflow: focusScrollContainerWithoutOverflow,
-  focusScrollContainer: focusScrollContainer,
-  focusSummary: focusSummary,
-  focusSvgFocusableAttribute: focusSvgFocusableAttribute,
-  focusSvgTabindexAttribute: focusSvgTabindexAttribute,
-  focusSvgNegativeTabindexAttribute: focusSvgNegativeTabindexAttribute,
-  focusSvgUseTabindex: focusSvgUseTabindex,
-  focusSvgForeignobjectTabindex: focusSvgForeignobjectTabindex,
-  focusSvg: focusSvg,
-  focusTabindexTrailingCharacters: focusTabindexTrailingCharacters,
-  focusTable: focusTable,
-  focusVideoWithoutControls: focusVideoWithoutControls
+  focusAreaImgTabindex: _focusAreaImgTabindex2.default,
+  focusAreaTabindex: _focusAreaTabindex2.default,
+  focusAreaWithoutHref: _focusAreaWithoutHref2.default,
+  focusAudioWithoutControls: _focusAudioWithoutControls2.default,
+  focusBrokenImageMap: _focusBrokenImageMap2.default,
+  focusChildrenOfFocusableFlexbox: _focusChildrenOfFocusableFlexbox2.default,
+  focusFieldsetDisabled: _focusFieldsetDisabled2.default,
+  focusFieldset: _focusFieldset2.default,
+  focusFlexboxContainer: _focusFlexboxContainer2.default,
+  focusFormDisabled: _focusFormDisabled2.default,
+  focusImgIsmap: _focusImgIsmap2.default,
+  focusImgUsemapTabindex: _focusImgUsemapTabindex2.default,
+  focusInHiddenIframe: _focusInHiddenIframe2.default,
+  focusInvalidTabindex: _focusInvalidTabindex2.default,
+  focusLabelTabindex: _focusLabelTabindex2.default,
+  focusObjectSvg: _focusObjectSvg2.default,
+  focusObjectSvgHidden: _focusObjectSvgHidden2.default,
+  focusRedirectImgUsemap: _focusRedirectImgUsemap2.default,
+  focusRedirectLegend: _focusRedirectLegend2.default,
+  focusScrollBody: _focusScrollBody2.default,
+  focusScrollContainerWithoutOverflow: _focusScrollContainerWithoutOverflow2.default,
+  focusScrollContainer: _focusScrollContainer2.default,
+  focusSummary: _focusSummary2.default,
+  focusSvgFocusableAttribute: _focusSvgFocusableAttribute2.default,
+  focusSvgTabindexAttribute: _focusSvgTabindexAttribute2.default,
+  focusSvgNegativeTabindexAttribute: _focusSvgNegativeTabindexAttribute2.default,
+  focusSvgUseTabindex: _focusSvgUseTabindex2.default,
+  focusSvgForeignobjectTabindex: _focusSvgForeignobjectTabindex2.default,
+  focusSvg: _focusSvg2.default,
+  focusTabindexTrailingCharacters: _focusTabindexTrailingCharacters2.default,
+  focusTable: _focusTable2.default,
+  focusVideoWithoutControls: _focusVideoWithoutControls2.default
 };
 
 function executeTests() {
-  var results = detectFocus(testDescriptions);
+  var results = (0, _detectFocus2.default)(testDescriptions);
   Object.keys(testCallbacks).forEach(function (key) {
     results[key] = testCallbacks[key]();
   });
@@ -2029,37 +2967,26 @@ function executeTests() {
   return results;
 }
 
-var supportsCache = null;
+var supportsCache$1 = null;
 
-function _supports () {
-  if (supportsCache) {
-    return supportsCache;
-  }
+module.exports = exports['default'];
 
-  supportsCache = cache$1.get();
-  if (!supportsCache.time) {
-    cache$1.set(executeTests());
-    supportsCache = cache$1.get();
-  }
+}(supports, supports.exports));
 
-  return supportsCache;
-}
+(function (module, exports) {
 
-var supports$5 = void 0;
-
-// https://www.w3.org/TR/html5/infrastructure.html#rules-for-parsing-integers
-// NOTE: all browsers agree to allow trailing spaces as well
-var validIntegerPatternNoTrailing = /^\s*(-|\+)?[0-9]+\s*$/;
-var validIntegerPatternWithTrailing = /^\s*(-|\+)?[0-9]+.*$/;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-function isValidTabindex (context) {
-  if (!supports$5) {
-    supports$5 = _supports();
+exports.default = function (context) {
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
   }
 
-  var validIntegerPattern = supports$5.focusTabindexTrailingCharacters ? validIntegerPatternWithTrailing : validIntegerPatternNoTrailing;
+  var validIntegerPattern = supports$1.focusTabindexTrailingCharacters ? validIntegerPatternWithTrailing : validIntegerPatternNoTrailing;
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/valid-tabindex',
     resolveDocument: true,
     context: context
@@ -2076,12 +3003,12 @@ function isValidTabindex (context) {
 
   // older Firefox and Internet Explorer don't support tabindex on SVG elements
   var isSvgElement = element.ownerSVGElement || element.nodeName.toLowerCase() === 'svg';
-  if (isSvgElement && !supports$5.focusSvgTabindexAttribute) {
+  if (isSvgElement && !supports$1.focusSvgTabindexAttribute) {
     return false;
   }
 
   // @browser-issue Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
-  if (supports$5.focusInvalidTabindex) {
+  if (supports$1.focusInvalidTabindex) {
     return true;
   }
 
@@ -2094,10 +3021,39 @@ function isValidTabindex (context) {
   }
 
   return Boolean(tabindex && validIntegerPattern.test(tabindex));
-}
+};
+
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _supports2 = supports.exports;
+
+var _supports3 = _interopRequireDefault(_supports2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// determine if an element's tabindex attribute has a valid value
+
+var supports$1 = void 0;
+
+// https://www.w3.org/TR/html5/infrastructure.html#rules-for-parsing-integers
+// NOTE: all browsers agree to allow trailing spaces as well
+var validIntegerPatternNoTrailing = /^\s*(-|\+)?[0-9]+\s*$/;
+var validIntegerPatternWithTrailing = /^\s*(-|\+)?[0-9]+.*$/;
 
-function tabindexValue (element) {
-  if (!isValidTabindex(element)) {
+module.exports = exports['default'];
+
+}(validTabindex, validTabindex.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (element) {
+  if (!(0, _validTabindex2.default)(element)) {
     return null;
   }
 
@@ -2109,7 +3065,27 @@ function tabindexValue (element) {
   // @browser-issue Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
   var tabindex = parseInt(element.getAttribute(attributeName), 10);
   return isNaN(tabindex) ? -1 : tabindex;
-}
+};
+
+var _validTabindex = validTabindex.exports;
+
+var _validTabindex2 = _interopRequireDefault(_validTabindex);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = exports['default'];
+
+}(tabindexValue, tabindexValue.exports));
+
+var is_util = {};
+
+Object.defineProperty(is_util, "__esModule", {
+  value: true
+});
+is_util.isUserModifyWritable = isUserModifyWritable;
+is_util.hasCssOverflowScroll = hasCssOverflowScroll;
+is_util.hasCssDisplayFlex = hasCssDisplayFlex;
+is_util.isScrollableContainer = isScrollableContainer;
 
 // this is a shared utility file for focus-relevant.js and tabbable.js
 // separate testing of this file's functions is not necessary,
@@ -2147,7 +3123,44 @@ function isScrollableContainer(element, nodeName, parentNodeName, parentStyle) {
   return element.offsetHeight < element.scrollHeight || element.offsetWidth < element.scrollWidth;
 }
 
-var supports$4 = void 0;
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _parents = parents.exports;
+
+var _parents2 = _interopRequireDefault(_parents);
+
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _elementMatches = elementMatches.exports;
+
+var _elementMatches2 = _interopRequireDefault(_elementMatches);
+
+var _tabindexValue = tabindexValue.exports;
+
+var _tabindexValue2 = _interopRequireDefault(_tabindexValue);
+
+var _validTabindex = validTabindex.exports;
+
+var _validTabindex2 = _interopRequireDefault(_validTabindex);
+
+var _is = is_util;
+
+var _supports2 = supports.exports;
+
+var _supports3 = _interopRequireDefault(_supports2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var supports$1 = void 0;
+// determine if an element supports.can be focused by script regardless
+// of the element actually being focusable at the time of execution
+// i.e. <input disabled> is conisdered focus-relevant, but not focusable
 
 function isFocusRelevantRules() {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
@@ -2159,11 +3172,11 @@ function isFocusRelevantRules() {
     shadow: false
   } : _ref$except;
 
-  if (!supports$4) {
-    supports$4 = _supports();
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
   }
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/focus-relevant',
     resolveDocument: true,
     context: context
@@ -2185,7 +3198,7 @@ function isFocusRelevantRules() {
     return true;
   }
 
-  if (nodeName === 'legend' && supports$4.focusRedirectLegend) {
+  if (nodeName === 'legend' && supports$1.focusRedirectLegend) {
     // specifics filtered in is/focusable
     return true;
   }
@@ -2211,10 +3224,10 @@ function isFocusRelevantRules() {
 
   if (nodeName === 'object') {
     var svgType = element.getAttribute('type');
-    if (!supports$4.focusObjectSvg && svgType === 'image/svg+xml') {
+    if (!supports$1.focusObjectSvg && svgType === 'image/svg+xml') {
       // object[type="image/svg+xml"] is not focusable in Internet Explorer
       return false;
-    } else if (!supports$4.focusObjectSwf && svgType === 'application/x-shockwave-flash') {
+    } else if (!supports$1.focusObjectSwf && svgType === 'application/x-shockwave-flash') {
       // object[type="application/x-shockwave-flash"] is not focusable in Internet Explorer 9
       return false;
     }
@@ -2236,32 +3249,32 @@ function isFocusRelevantRules() {
     return true;
   }
 
-  if (nodeName === 'audio' && (supports$4.focusAudioWithoutControls || element.hasAttribute('controls'))) {
+  if (nodeName === 'audio' && (supports$1.focusAudioWithoutControls || element.hasAttribute('controls'))) {
     return true;
   }
 
-  if (nodeName === 'video' && (supports$4.focusVideoWithoutControls || element.hasAttribute('controls'))) {
+  if (nodeName === 'video' && (supports$1.focusVideoWithoutControls || element.hasAttribute('controls'))) {
     return true;
   }
 
-  if (supports$4.focusSummary && nodeName === 'summary') {
+  if (supports$1.focusSummary && nodeName === 'summary') {
     return true;
   }
 
-  var validTabindex = isValidTabindex(element);
+  var validTabindex = (0, _validTabindex2.default)(element);
 
   if (nodeName === 'img' && element.hasAttribute('usemap')) {
     // Gecko, Trident and Edge do not allow an image with an image map and tabindex to be focused,
     // it appears the tabindex is overruled so focus is still forwarded to the <map>
-    return validTabindex && supports$4.focusImgUsemapTabindex || supports$4.focusRedirectImgUsemap;
+    return validTabindex && supports$1.focusImgUsemapTabindex || supports$1.focusRedirectImgUsemap;
   }
 
-  if (supports$4.focusTable && (nodeName === 'table' || nodeName === 'td')) {
+  if (supports$1.focusTable && (nodeName === 'table' || nodeName === 'td')) {
     // IE10-11 supports.can focus <table> and <td>
     return true;
   }
 
-  if (supports$4.focusFieldset && nodeName === 'fieldset') {
+  if (supports$1.focusFieldset && nodeName === 'fieldset') {
     // IE10-11 supports.can focus <fieldset>
     return true;
   }
@@ -2269,23 +3282,23 @@ function isFocusRelevantRules() {
   var isSvgElement = nodeName === 'svg';
   var isSvgContent = element.ownerSVGElement;
   var focusableAttribute = element.getAttribute('focusable');
-  var tabindex = tabindexValue(element);
+  var tabindex = (0, _tabindexValue2.default)(element);
 
-  if (nodeName === 'use' && tabindex !== null && !supports$4.focusSvgUseTabindex) {
+  if (nodeName === 'use' && tabindex !== null && !supports$1.focusSvgUseTabindex) {
     // <use> cannot be made focusable by adding a tabindex attribute anywhere but Blink and WebKit
     return false;
   }
 
   if (nodeName === 'foreignobject') {
     // <use> can only be made focusable in Blink and WebKit
-    return tabindex !== null && supports$4.focusSvgForeignobjectTabindex;
+    return tabindex !== null && supports$1.focusSvgForeignobjectTabindex;
   }
 
-  if (elementMatches(element, 'svg a') && element.hasAttribute('xlink:href')) {
+  if ((0, _elementMatches2.default)(element, 'svg a') && element.hasAttribute('xlink:href')) {
     return true;
   }
 
-  if ((isSvgElement || isSvgContent) && element.focus && !supports$4.focusSvgNegativeTabindexAttribute && tabindex < 0) {
+  if ((isSvgElement || isSvgContent) && element.focus && !supports$1.focusSvgNegativeTabindexAttribute && tabindex < 0) {
     // Firefox 51 and 52 treat any natively tabbable SVG element with
     // tabindex="-1" as tabbable and everything else as inert
     // see https://bugzilla.mozilla.org/show_bug.cgi?id=1302340
@@ -2293,17 +3306,17 @@ function isFocusRelevantRules() {
   }
 
   if (isSvgElement) {
-    return validTabindex || supports$4.focusSvg || supports$4.focusSvgInIframe
+    return validTabindex || supports$1.focusSvg || supports$1.focusSvgInIframe
     // Internet Explorer understands the focusable attribute introduced in SVG Tiny 1.2
-    || Boolean(supports$4.focusSvgFocusableAttribute && focusableAttribute && focusableAttribute === 'true');
+    || Boolean(supports$1.focusSvgFocusableAttribute && focusableAttribute && focusableAttribute === 'true');
   }
 
   if (isSvgContent) {
-    if (supports$4.focusSvgTabindexAttribute && validTabindex) {
+    if (supports$1.focusSvgTabindexAttribute && validTabindex) {
       return true;
     }
 
-    if (supports$4.focusSvgFocusableAttribute) {
+    if (supports$1.focusSvgFocusableAttribute) {
       // Internet Explorer understands the focusable attribute introduced in SVG Tiny 1.2
       return focusableAttribute === 'true';
     }
@@ -2315,14 +3328,14 @@ function isFocusRelevantRules() {
   }
 
   var style = window.getComputedStyle(element, null);
-  if (isUserModifyWritable(style)) {
+  if ((0, _is.isUserModifyWritable)(style)) {
     return true;
   }
 
-  if (supports$4.focusImgIsmap && nodeName === 'img' && element.hasAttribute('ismap')) {
+  if (supports$1.focusImgIsmap && nodeName === 'img' && element.hasAttribute('ismap')) {
     // IE10-11 considers the <img> in <a href><img ismap> focusable
     // https://github.com/medialize/ally.js/issues/20
-    var hasLinkParent = getParents({ context: element }).some(function (parent) {
+    var hasLinkParent = (0, _parents2.default)({ context: element }).some(function (parent) {
       return parent.nodeName.toLowerCase() === 'a' && parent.hasAttribute('href');
     });
 
@@ -2332,22 +3345,22 @@ function isFocusRelevantRules() {
   }
 
   // https://github.com/medialize/ally.js/issues/21
-  if (!except.scrollable && supports$4.focusScrollContainer) {
-    if (supports$4.focusScrollContainerWithoutOverflow) {
+  if (!except.scrollable && supports$1.focusScrollContainer) {
+    if (supports$1.focusScrollContainerWithoutOverflow) {
       // Internet Explorer does will consider the scrollable area focusable
       // if the element is a <div> or a <span> and it is in fact scrollable,
       // regardless of the CSS overflow property
-      if (isScrollableContainer(element, nodeName)) {
+      if ((0, _is.isScrollableContainer)(element, nodeName)) {
         return true;
       }
-    } else if (hasCssOverflowScroll(style)) {
+    } else if ((0, _is.hasCssOverflowScroll)(style)) {
       // Firefox requires proper overflow setting, IE does not necessarily
       // https://developer.mozilla.org/en-US/docs/Web/CSS/overflow
       return true;
     }
   }
 
-  if (!except.flexbox && supports$4.focusFlexboxContainer && hasCssDisplayFlex(style)) {
+  if (!except.flexbox && supports$1.focusFlexboxContainer && (0, _is.hasCssDisplayFlex)(style)) {
     // elements with display:flex are focusable in IE10-11
     return true;
   }
@@ -2356,15 +3369,15 @@ function isFocusRelevantRules() {
   if (!except.scrollable && parent) {
     var parentNodeName = parent.nodeName.toLowerCase();
     var parentStyle = window.getComputedStyle(parent, null);
-    if (supports$4.focusScrollBody && isScrollableContainer(parent, nodeName, parentNodeName, parentStyle)) {
+    if (supports$1.focusScrollBody && (0, _is.isScrollableContainer)(parent, nodeName, parentNodeName, parentStyle)) {
       // scrollable bodies are focusable Internet Explorer
       // https://github.com/medialize/ally.js/issues/21
       return true;
     }
 
     // Children of focusable elements with display:flex are focusable in IE10-11
-    if (supports$4.focusChildrenOfFocusableFlexbox) {
-      if (hasCssDisplayFlex(parentStyle)) {
+    if (supports$1.focusChildrenOfFocusableFlexbox) {
+      if ((0, _is.hasCssDisplayFlex)(parentStyle)) {
         return true;
       }
     }
@@ -2394,7 +3407,23 @@ isFocusRelevantRules.except = function () {
 
 // provide isFocusRelevant(context) as default iterator callback
 var isFocusRelevant = isFocusRelevantRules.except({});
+exports.default = isFocusRelevant;
+module.exports = exports['default'];
+
+}(focusRelevant, focusRelevant.exports));
 
+var validArea = {exports: {}};
+
+var visible = {exports: {}};
+
+var arrayFindIndex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = findIndex;
 function findIndex(array, callback) {
   // attempt to use native or polyfilled Array#findIndex first
   if (array.findIndex) {
@@ -2417,8 +3446,21 @@ function findIndex(array, callback) {
 
   return -1;
 }
+module.exports = exports["default"];
 
-function getContentDocument (node) {
+}(arrayFindIndex, arrayFindIndex.exports));
+
+var getFrameElement = {exports: {}};
+
+var getContentDocument = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (node) {
   try {
     // works on <object> and <iframe>
     return node.contentDocument
@@ -2431,9 +3473,23 @@ function getContentDocument (node) {
     // also IE may throw member not found exception e.g. on <object type="image/png">
     return null;
   }
-}
+};
 
-function getDocument (node) {
+module.exports = exports["default"];
+
+}(getContentDocument, getContentDocument.exports));
+
+var getWindow = {exports: {}};
+
+var getDocument = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (node) {
   if (!node) {
     return document;
   }
@@ -2443,18 +3499,44 @@ function getDocument (node) {
   }
 
   return node.ownerDocument || document;
-}
+};
+
+module.exports = exports["default"];
+
+}(getDocument, getDocument.exports));
+
+(function (module, exports) {
 
-function getWindow (node) {
-  var _document = getDocument(node);
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (node) {
+  var _document = (0, _getDocument2.default)(node);
   return _document.defaultView || window;
-}
+};
 
-var shadowPrefix = void 0;
+var _getDocument = getDocument.exports;
+
+var _getDocument2 = _interopRequireDefault(_getDocument);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+module.exports = exports['default'];
+
+}(getWindow, getWindow.exports));
+
+var selectInShadows = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-function selectInShadows (selector) {
+exports.default = function (selector) {
   if (typeof shadowPrefix !== 'string') {
-    var operator = cssShadowPiercingDeepCombinator();
+    var operator = (0, _cssShadowPiercingDeepCombinator2.default)();
     if (operator) {
       shadowPrefix = ', html ' + operator + ' ';
     }
@@ -2465,13 +3547,48 @@ function selectInShadows (selector) {
   }
 
   return selector + shadowPrefix + selector.replace(/\s*,\s*/g, ',').split(',').join(shadowPrefix);
-}
+};
+
+var _cssShadowPiercingDeepCombinator = cssShadowPiercingDeepCombinator.exports;
+
+var _cssShadowPiercingDeepCombinator2 = _interopRequireDefault(_cssShadowPiercingDeepCombinator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var shadowPrefix = void 0;
+// convert a CSS selector so that it also pierces ShadowDOM
+// takes ".a, #b" and turns it into ".a, #b, html >>> .a, html >>> #b"
+
+module.exports = exports['default'];
+
+}(selectInShadows, selectInShadows.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getFrameElement;
+
+var _getContentDocument = getContentDocument.exports;
+
+var _getContentDocument2 = _interopRequireDefault(_getContentDocument);
+
+var _getWindow = getWindow.exports;
+
+var _getWindow2 = _interopRequireDefault(_getWindow);
+
+var _selectInShadows = selectInShadows.exports;
+
+var _selectInShadows2 = _interopRequireDefault(_selectInShadows);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var selector = void 0;
 
 function findDocumentHostElement(_window) {
   if (!selector) {
-    selector = selectInShadows('object, iframe');
+    selector = (0, _selectInShadows2.default)('object, iframe');
   }
 
   if (_window._frameElement !== undefined) {
@@ -2482,7 +3599,7 @@ function findDocumentHostElement(_window) {
 
   var potentialHosts = _window.parent.document.querySelectorAll(selector);
   [].some.call(potentialHosts, function (element) {
-    var _document = getContentDocument(element);
+    var _document = (0, _getContentDocument2.default)(element);
     if (_document !== _window.document) {
       return false;
     }
@@ -2495,7 +3612,7 @@ function findDocumentHostElement(_window) {
 }
 
 function getFrameElement(element) {
-  var _window = getWindow(element);
+  var _window = (0, _getWindow2.default)(element);
   if (!_window.parent || _window.parent === _window) {
     // if there is no parent browsing context,
     // we're not going to get a frameElement either way
@@ -2510,9 +3627,40 @@ function getFrameElement(element) {
     return null;
   }
 }
+module.exports = exports['default'];
+
+}(getFrameElement, getFrameElement.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _arrayFindIndex = arrayFindIndex.exports;
+
+var _arrayFindIndex2 = _interopRequireDefault(_arrayFindIndex);
+
+var _parents = parents.exports;
+
+var _parents2 = _interopRequireDefault(_parents);
+
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _getFrameElement = getFrameElement.exports;
+
+var _getFrameElement2 = _interopRequireDefault(_getFrameElement);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // https://www.w3.org/TR/html5/rendering.html#being-rendered
 // <area> is not rendered, but we *consider* it visible to simplfiy this function's usage
+
+// determine if an element is rendered
+// NOTE: that does not mean an element is visible in the viewport, see util/visible-area
+
 var notRenderedElementsPattern = /^(area)$/;
 
 function computedStyle(element, property) {
@@ -2530,7 +3678,7 @@ function notVisible(_path) {
   // https://github.com/jquery/jquery-ui/blob/master/ui/core.js#L109-L114
   // NOTE: a nested element can reverse visibility:hidden|collapse by explicitly setting visibility:visible
   // NOTE: visibility can be ["", "visible", "hidden", "collapse"]
-  var hidden = findIndex(_path, function (element) {
+  var hidden = (0, _arrayFindIndex2.default)(_path, function (element) {
     var visibility = computedStyle(element, 'visibility');
     return visibility === 'hidden' || visibility === 'collapse';
   });
@@ -2540,7 +3688,7 @@ function notVisible(_path) {
     return false;
   }
 
-  var visible = findIndex(_path, function (element) {
+  var visible = (0, _arrayFindIndex2.default)(_path, function (element) {
     return computedStyle(element, 'visibility') === 'visible';
   });
 
@@ -2582,7 +3730,7 @@ function isVisibleRules() {
     browsingContext: false
   } : _ref$except;
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/visible',
     resolveDocument: true,
     context: context
@@ -2593,7 +3741,7 @@ function isVisibleRules() {
     return true;
   }
 
-  var _path = getParents({ context: element });
+  var _path = (0, _parents2.default)({ context: element });
 
   // in Internet Explorer <audio> has a default display: none, where others have display: inline
   // but IE allows focusing <audio style="display:none">, but not <div display:none><audio>
@@ -2614,7 +3762,7 @@ function isVisibleRules() {
   if (!except.browsingContext) {
     // elements within a browsing context are affected by the
     // browsing context host element's visibility and tabindex
-    var frameElement = getFrameElement(element);
+    var frameElement = (0, _getFrameElement2.default)(element);
     var _isVisible = isVisibleRules.except(except);
     if (frameElement && !_isVisible(frameElement)) {
       return false;
@@ -2641,8 +3789,18 @@ isVisibleRules.except = function () {
 
 // provide isVisible(context) as default iterator callback
 var isVisible = isVisibleRules.except({});
+exports.default = isVisible;
+module.exports = exports['default'];
+
+}(visible, visible.exports));
 
-var css_escape = createCommonjsModule(function (module, exports) {
+var imageMap = {};
+
+var css_escape = {exports: {}};
+
+/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
+
+(function (module, exports) {
 (function(root, factory) {
 	// https://github.com/umdjs/umd/blob/master/returnExports.js
 	{
@@ -2742,7 +3900,41 @@ var css_escape = createCommonjsModule(function (module, exports) {
 	return cssEscape;
 
 }));
+}(css_escape));
+
+Object.defineProperty(imageMap, "__esModule", {
+  value: true
 });
+imageMap.getMapByName = getMapByName;
+imageMap.getMapOfImage = getMapOfImage;
+imageMap.getImageOfArea = getImageOfArea;
+
+var _css = css_escape.exports;
+
+var _css2 = _interopRequireDefault(_css);
+
+var _getDocument = getDocument.exports;
+
+var _getDocument2 = _interopRequireDefault(_getDocument);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getMapByName(name, _document) {
+  // apparently getElementsByName() also considers id attribute in IE & opera
+  // https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByName
+  var map = _document.querySelector('map[name="' + (0, _css2.default)(name) + '"]');
+  return map || null;
+}
+
+function getMapOfImage(element) {
+  var usemap = element.getAttribute('usemap');
+  if (!usemap) {
+    return null;
+  }
+
+  var _document = (0, _getDocument2.default)(element);
+  return getMapByName(usemap.slice(1), _document);
+}
 
 function getImageOfArea(element) {
   var map = element.parentElement;
@@ -2759,21 +3951,22 @@ function getImageOfArea(element) {
   //   https://www.w3.org/TR/html5/embedded-content-0.html#the-map-element
   //   https://developer.mozilla.org/en-US/docs/Web/API/HTMLMapElement
   // the image must be valid and loaded for the map to take effect
-  var _document = getDocument(element);
-  return _document.querySelector('img[usemap="#' + css_escape(map.name) + '"]') || null;
+  var _document = (0, _getDocument2.default)(element);
+  return _document.querySelector('img[usemap="#' + (0, _css2.default)(map.name) + '"]') || null;
 }
 
-var supports$3 = void 0;
+(function (module, exports) {
 
-// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/map
-// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
-// https://github.com/jquery/jquery-ui/blob/master/ui/core.js#L88-L107
-function isValidArea (context) {
-  if (!supports$3) {
-    supports$3 = _supports();
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context) {
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
   }
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/valid-area',
     context: context
   });
@@ -2784,31 +3977,31 @@ function isValidArea (context) {
   }
 
   var hasTabindex = element.hasAttribute('tabindex');
-  if (!supports$3.focusAreaTabindex && hasTabindex) {
+  if (!supports$1.focusAreaTabindex && hasTabindex) {
     // Blink and WebKit do not consider <area tabindex="-1" href="#void"> focusable
     return false;
   }
 
-  var img = getImageOfArea(element);
-  if (!img || !isVisible(img)) {
+  var img = (0, _imageMap.getImageOfArea)(element);
+  if (!img || !(0, _visible2.default)(img)) {
     return false;
   }
 
   // Firefox only allows fully loaded images to reference image maps
   // https://stereochro.me/ideas/detecting-broken-images-js
-  if (!supports$3.focusBrokenImageMap && (!img.complete || !img.naturalHeight || img.offsetWidth <= 0 || img.offsetHeight <= 0)) {
+  if (!supports$1.focusBrokenImageMap && (!img.complete || !img.naturalHeight || img.offsetWidth <= 0 || img.offsetHeight <= 0)) {
     return false;
   }
 
   // Firefox supports.can focus area elements even if they don't have an href attribute
-  if (!supports$3.focusAreaWithoutHref && !element.href) {
+  if (!supports$1.focusAreaWithoutHref && !element.href) {
     // Internet explorer supports.can focus area elements without href if either
     // the area element or the image element has a tabindex attribute
-    return supports$3.focusAreaTabindex && hasTabindex || supports$3.focusAreaImgTabindex && img.hasAttribute('tabindex');
+    return supports$1.focusAreaTabindex && hasTabindex || supports$1.focusAreaImgTabindex && img.hasAttribute('tabindex');
   }
 
   // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
-  var childOfInteractive = getParents({ context: img }).slice(1).some(function (_element) {
+  var childOfInteractive = (0, _parents2.default)({ context: img }).slice(1).some(function (_element) {
     var name = _element.nodeName.toLowerCase();
     return name === 'button' || name === 'a';
   });
@@ -2818,63 +4011,115 @@ function isValidArea (context) {
   }
 
   return true;
-}
+};
 
-var supports$2 = void 0;
+var _contextToElement = contextToElement.exports;
 
-// https://www.w3.org/TR/html5/disabled-elements.html#concept-element-disabled
-var disabledElementsPattern = void 0;
-var disabledElements = {
-  input: true,
-  select: true,
-  textarea: true,
-  button: true,
-  fieldset: true,
-  form: true
-};
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _visible = visible.exports;
+
+var _visible2 = _interopRequireDefault(_visible);
+
+var _parents = parents.exports;
+
+var _parents2 = _interopRequireDefault(_parents);
+
+var _imageMap = imageMap;
+
+var _supports2 = supports.exports;
+
+var _supports3 = _interopRequireDefault(_supports2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var supports$1 = void 0;
 
-function isNativeDisabledSupported (context) {
-  if (!supports$2) {
-    supports$2 = _supports();
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/map
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
+// https://github.com/jquery/jquery-ui/blob/master/ui/core.js#L88-L107
+
+// determine if an <area> element is being properly used by and <img> via a <map>
+
+module.exports = exports['default'];
+
+}(validArea, validArea.exports));
+
+var disabled = {exports: {}};
+
+var nativeDisabledSupported = {exports: {}};
 
-    if (supports$2.focusFieldsetDisabled) {
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context) {
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
+
+    if (supports$1.focusFieldsetDisabled) {
       delete disabledElements.fieldset;
     }
 
-    if (supports$2.focusFormDisabled) {
+    if (supports$1.focusFormDisabled) {
       delete disabledElements.form;
     }
 
     disabledElementsPattern = new RegExp('^(' + Object.keys(disabledElements).join('|') + ')$');
   }
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/native-disabled-supported',
     context: context
   });
 
   var nodeName = element.nodeName.toLowerCase();
   return Boolean(disabledElementsPattern.test(nodeName));
-}
+};
+
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _supports2 = supports.exports;
+
+var _supports3 = _interopRequireDefault(_supports2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Determine if an element supports the disabled attribute
 
 var supports$1 = void 0;
 
-function isDisabledFieldset(element) {
-  var nodeName = element.nodeName.toLowerCase();
-  return nodeName === 'fieldset' && element.disabled;
-}
+// https://www.w3.org/TR/html5/disabled-elements.html#concept-element-disabled
+var disabledElementsPattern = void 0;
+var disabledElements = {
+  input: true,
+  select: true,
+  textarea: true,
+  button: true,
+  fieldset: true,
+  form: true
+};
 
-function isDisabledForm(element) {
-  var nodeName = element.nodeName.toLowerCase();
-  return nodeName === 'form' && element.disabled;
-}
+module.exports = exports['default'];
+
+}(nativeDisabledSupported, nativeDisabledSupported.exports));
 
-function isDisabled (context) {
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context) {
   if (!supports$1) {
-    supports$1 = _supports();
+    supports$1 = (0, _supports3.default)();
   }
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/disabled',
     context: context
   });
@@ -2884,7 +4129,7 @@ function isDisabled (context) {
     return true;
   }
 
-  if (!isNativeDisabledSupported(element)) {
+  if (!(0, _nativeDisabledSupported2.default)(element)) {
     // non-form elements do not support the disabled attribute
     return false;
   }
@@ -2894,7 +4139,7 @@ function isDisabled (context) {
     return true;
   }
 
-  var parents = getParents({ context: element });
+  var parents = (0, _parents2.default)({ context: element });
   if (parents.some(isDisabledFieldset)) {
     // a parental <fieldset> is disabld and inherits the state onto this element
     return true;
@@ -2906,8 +4151,74 @@ function isDisabled (context) {
   }
 
   return false;
+};
+
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _parents = parents.exports;
+
+var _parents2 = _interopRequireDefault(_parents);
+
+var _nativeDisabledSupported = nativeDisabledSupported.exports;
+
+var _nativeDisabledSupported2 = _interopRequireDefault(_nativeDisabledSupported);
+
+var _supports2 = supports.exports;
+
+var _supports3 = _interopRequireDefault(_supports2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Determine if an element is disabled (i.e. not editable)
+
+var supports$1 = void 0;
+
+function isDisabledFieldset(element) {
+  var nodeName = element.nodeName.toLowerCase();
+  return nodeName === 'fieldset' && element.disabled;
+}
+
+function isDisabledForm(element) {
+  var nodeName = element.nodeName.toLowerCase();
+  return nodeName === 'form' && element.disabled;
 }
 
+module.exports = exports['default'];
+
+}(disabled, disabled.exports));
+
+var onlyTabbable = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _visible = visible.exports;
+
+var _visible2 = _interopRequireDefault(_visible);
+
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _getFrameElement = getFrameElement.exports;
+
+var _getFrameElement2 = _interopRequireDefault(_getFrameElement);
+
+var _tabindexValue = tabindexValue.exports;
+
+var _tabindexValue2 = _interopRequireDefault(_tabindexValue);
+
+var _platform = platform$1.exports;
+
+var _platform2 = _interopRequireDefault(_platform);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function isOnlyTabbableRules() {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
       context = _ref.context,
@@ -2917,20 +4228,20 @@ function isOnlyTabbableRules() {
     visible: false
   } : _ref$except;
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/only-tabbable',
     resolveDocument: true,
     context: context
   });
 
-  if (!except.visible && !isVisible(element)) {
+  if (!except.visible && !(0, _visible2.default)(element)) {
     return false;
   }
 
-  if (!except.onlyFocusableBrowsingContext && (platform.is.GECKO || platform.is.TRIDENT || platform.is.EDGE)) {
-    var frameElement = getFrameElement(element);
+  if (!except.onlyFocusableBrowsingContext && (_platform2.default.is.GECKO || _platform2.default.is.TRIDENT || _platform2.default.is.EDGE)) {
+    var frameElement = (0, _getFrameElement2.default)(element);
     if (frameElement) {
-      if (tabindexValue(frameElement) < 0) {
+      if ((0, _tabindexValue2.default)(frameElement) < 0) {
         // iframe[tabindex="-1"] and object[tabindex="-1"] inherit the
         // tabbable demotion onto elements of their browsing contexts
         return false;
@@ -2939,9 +4250,9 @@ function isOnlyTabbableRules() {
   }
 
   var nodeName = element.nodeName.toLowerCase();
-  var tabindex = tabindexValue(element);
+  var tabindex = (0, _tabindexValue2.default)(element);
 
-  if (nodeName === 'label' && platform.is.GECKO) {
+  if (nodeName === 'label' && _platform2.default.is.GECKO) {
     // Firefox cannot focus, but tab to: label[tabindex=0]
     return tabindex !== null && tabindex >= 0;
   }
@@ -2949,10 +4260,10 @@ function isOnlyTabbableRules() {
   // SVG Elements were keyboard focusable but not script focusable before Firefox 51.
   // Firefox 51 added the focus management DOM API (.focus and .blur) to SVGElement,
   // see https://bugzilla.mozilla.org/show_bug.cgi?id=778654
-  if (platform.is.GECKO && element.ownerSVGElement && !element.focus) {
+  if (_platform2.default.is.GECKO && element.ownerSVGElement && !element.focus) {
     if (nodeName === 'a' && element.hasAttribute('xlink:href')) {
       // any focusable child of <svg> cannot be focused, but tabbed to
-      if (platform.is.GECKO) {
+      if (_platform2.default.is.GECKO) {
         return true;
       }
     }
@@ -2978,8 +4289,63 @@ isOnlyTabbableRules.except = function () {
 
 // provide isOnlyTabbable(context) as default iterator callback
 var isOnlyTabbable = isOnlyTabbableRules.except({});
+exports.default = isOnlyTabbable;
+module.exports = exports['default'];
+
+}(onlyTabbable, onlyTabbable.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _focusRelevant = focusRelevant.exports;
+
+var _focusRelevant2 = _interopRequireDefault(_focusRelevant);
+
+var _validArea = validArea.exports;
+
+var _validArea2 = _interopRequireDefault(_validArea);
+
+var _visible = visible.exports;
+
+var _visible2 = _interopRequireDefault(_visible);
+
+var _disabled = disabled.exports;
+
+var _disabled2 = _interopRequireDefault(_disabled);
+
+var _onlyTabbable = onlyTabbable.exports;
+
+var _onlyTabbable2 = _interopRequireDefault(_onlyTabbable);
 
-var supports = void 0;
+var _contextToElement = contextToElement.exports;
+
+var _contextToElement2 = _interopRequireDefault(_contextToElement);
+
+var _getFrameElement = getFrameElement.exports;
+
+var _getFrameElement2 = _interopRequireDefault(_getFrameElement);
+
+var _tabindexValue = tabindexValue.exports;
+
+var _tabindexValue2 = _interopRequireDefault(_tabindexValue);
+
+var _supports2 = supports.exports;
+
+var _supports3 = _interopRequireDefault(_supports2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var supports$1 = void 0;
+// determine if an element can be focused
+
+// https://www.w3.org/TR/html5/editing.html#focus-management
+
+// NOTE: The following known issues exist:
+//   Gecko: `svg a[xlink|href]` is not identified as focusable (because SVGElement.prototype.focus is missing)
+//   Blink, WebKit: SVGElements that have been made focusable by adding a focus event listener are not identified as focusable
 
 function isOnlyFocusRelevant(element) {
   var nodeName = element.nodeName.toLowerCase();
@@ -2989,7 +4355,7 @@ function isOnlyFocusRelevant(element) {
     return true;
   }
 
-  var _tabindex = tabindexValue(element);
+  var _tabindex = (0, _tabindexValue2.default)(element);
   if (element.shadowRoot && _tabindex === null) {
     // ShadowDOM host elements *may* receive focus
     // even though they are not considered focuable
@@ -3001,14 +4367,14 @@ function isOnlyFocusRelevant(element) {
     // there's no way to make an element focusable other than by adding a tabindex,
     // and focus behavior of the label element seems hard-wired to ignore tabindex
     // in some browsers (like Gecko, Blink and WebKit)
-    return !supports.focusLabelTabindex || _tabindex === null;
+    return !supports$1.focusLabelTabindex || _tabindex === null;
   }
 
   if (nodeName === 'legend') {
     return _tabindex === null;
   }
 
-  if (supports.focusSvgFocusableAttribute && (element.ownerSVGElement || nodeName === 'svg')) {
+  if (supports$1.focusSvgFocusableAttribute && (element.ownerSVGElement || nodeName === 'svg')) {
     // Internet Explorer understands the focusable attribute introduced in SVG Tiny 1.2
     var focusableAttribute = element.getAttribute('focusable');
     return focusableAttribute && focusableAttribute === 'false';
@@ -3017,13 +4383,13 @@ function isOnlyFocusRelevant(element) {
   if (nodeName === 'img' && element.hasAttribute('usemap')) {
     // Gecko, Trident and Edge do not allow an image with an image map and tabindex to be focused,
     // it appears the tabindex is overruled so focus is still forwarded to the <map>
-    return _tabindex === null || !supports.focusImgUsemapTabindex;
+    return _tabindex === null || !supports$1.focusImgUsemapTabindex;
   }
 
   if (nodeName === 'area') {
     // all <area>s are considered relevant,
     // but only the valid <area>s are focusable
-    return !isValidArea(element);
+    return !(0, _validArea2.default)(element);
   }
 
   return false;
@@ -3039,22 +4405,22 @@ function isFocusableRules() {
     onlyTabbable: false
   } : _ref$except;
 
-  if (!supports) {
-    supports = _supports();
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
   }
 
-  var _isOnlyTabbable = isOnlyTabbable.rules.except({
+  var _isOnlyTabbable = _onlyTabbable2.default.rules.except({
     onlyFocusableBrowsingContext: true,
     visible: except.visible
   });
 
-  var element = contextToElement({
+  var element = (0, _contextToElement2.default)({
     label: 'is/focusable',
     resolveDocument: true,
     context: context
   });
 
-  var focusRelevant = isFocusRelevant.rules({
+  var focusRelevant = _focusRelevant2.default.rules({
     context: element,
     except: except
   });
@@ -3063,7 +4429,7 @@ function isFocusableRules() {
     return false;
   }
 
-  if (!except.disabled && isDisabled(element)) {
+  if (!except.disabled && (0, _disabled2.default)(element)) {
     return false;
   }
 
@@ -3079,12 +4445,12 @@ function isFocusableRules() {
       except: {}
     };
 
-    if (supports.focusInHiddenIframe) {
+    if (supports$1.focusInHiddenIframe) {
       // WebKit and Blink can focus content in hidden <iframe> and <object>
       visibilityOptions.except.browsingContext = true;
     }
 
-    if (supports.focusObjectSvgHidden) {
+    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();
@@ -3093,15 +4459,15 @@ function isFocusableRules() {
       }
     }
 
-    if (!isVisible.rules(visibilityOptions)) {
+    if (!_visible2.default.rules(visibilityOptions)) {
       return false;
     }
   }
 
-  var frameElement = getFrameElement(element);
+  var frameElement = (0, _getFrameElement2.default)(element);
   if (frameElement) {
     var _nodeName = frameElement.nodeName.toLowerCase();
-    if (_nodeName === 'object' && !supports.focusInZeroDimensionObject) {
+    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;
@@ -3110,7 +4476,7 @@ function isFocusableRules() {
   }
 
   var nodeName = element.nodeName.toLowerCase();
-  if (nodeName === 'svg' && supports.focusSvgInIframe && !frameElement && element.getAttribute('tabindex') === null) {
+  if (nodeName === 'svg' && supports$1.focusSvgInIframe && !frameElement && element.getAttribute('tabindex') === null) {
     return false;
   }
 
@@ -3134,6 +4500,12 @@ isFocusableRules.except = function () {
 
 // 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@
@@ -3399,17 +4771,105 @@ var isFocusable = isFocusableRules.except({});
 
 }(window, document));
 
-const postTooltipCss = ":host{--post-contrast-color:#fff;--post-bg-rgb:51, 51, 51}post-popovercontainer::part(popover){padding:.25rem .5rem;max-width:13.5rem;min-height:1rem}";
+const postTooltipCss = ":host{--post-contrast-color:#fff;--post-bg-rgb:51, 51, 51}post-popovercontainer::part(popover){padding:.25rem .5rem;max-width:13.5rem;min-height:1rem}post-popovercontainer.has-arrow::part(popover)::after{position:absolute;content:\"\";inset:-13px;z-index:-1}";
+const PostTooltipStyle0 = postTooltipCss;
 
+/**
+ * @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;
+/**
+ * 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
+ * @param e Event
+ * @returns
+ */
+const globalInterestHandler = (e) => {
+    const target = e.target;
+    if (!(e === null || e === void 0 ? void 0 : e.target) || !('getAttribute' in e.target))
+        return;
+    const tooltipTarget = target.getAttribute('data-tooltip-target');
+    if (!tooltipTarget || tooltipTarget === '')
+        return;
+    const tooltip = document.getElementById(tooltipTarget);
+    tooltip === null || tooltip === void 0 ? void 0 : tooltip.show(target);
+    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 target = e.target;
+    const tooltipTarget = target.getAttribute('data-tooltip-target');
+    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('data-tooltip-target');
+    // 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');
+    }
+};
+/**
+ * Handle attribute changes and childList changes from the observer
+ * @param {MutationRecord[]} mutationList
+ */
+const triggerObserverHandler = mutationList => {
+    mutationList.forEach(mutation => {
+        if (mutation.type === 'attributes' && mutation.attributeName === 'data-tooltip-target') {
+            patchAccessibilityFeatures(mutation.target);
+        }
+        if (mutation.type === 'childList') {
+            mutation.addedNodes.forEach(node => {
+                if (node.nodeType === Node.ELEMENT_NODE &&
+                    node.hasAttribute('data-tooltip-target')) {
+                    patchAccessibilityFeatures(node);
+                }
+            });
+        }
+    });
+};
+// Initialize a mutation observer for patching accessibility features
+const triggerObserver = new MutationObserver(triggerObserverHandler);
 const PostTooltip = class {
     constructor(hostRef) {
         index.registerInstance(this, hostRef);
         this.placement = 'top';
         this.arrow = true;
-        // Create local versions of event handlers for de-registration
-        // https://stackoverflow.com/questions/33859113/javascript-removeeventlistener-not-working-inside-a-class
-        this.localShowTooltip = e => this.show(e.target);
-        this.localHideTooltip = this.hide.bind(this);
     }
     connectedCallback() {
         if (!this.host.id) {
@@ -3417,29 +4877,45 @@ const PostTooltip = class {
             /*prettier-ignore*/
             'No id set: <post-tooltip> must have an id, linking it to it\'s target element using the data-tooltip-target attribute.');
         }
-        if (!this.triggers) {
-            throw new Error(`No trigger found for <post-tooltip id="${this.host.id}">, please add the 'data-tooltip-target="${this.host.id}" attribute to the trigger element.`);
+    }
+    /**
+     * 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: ['data-tooltip-target'],
+            });
         }
-        // Patch popovertargetaction="interest" until it's implemented
-        // https://github.com/openui/open-ui/issues/767#issuecomment-1654177227
-        this.triggers.forEach(trigger => this.patchPopoverTargetActionInterest(trigger));
+        tooltipInstances++;
     }
     /**
      * Remove a bunch of event listeners if the tooltip gets removed from the DOM
+     * and disconnect the accessibility patcher
      */
     disconnectedCallback() {
-        this.triggers.forEach(trigger => {
-            trigger.removeEventListener('mouseenter', this.localShowTooltip);
-            trigger.removeEventListener('mouseleave', this.localHideTooltip);
-            trigger.removeEventListener('focus', this.localShowTooltip);
-            trigger.removeEventListener('blur', this.localHideTooltip);
-            trigger.removeEventListener('long-press', this.localShowTooltip);
-        });
-    }
-    componentWillLoad() {
-        // Append tooltip host to the end of the body to get around overflow: hidden restrictions
-        // for browsers that don't support popover yet
-        document.body.appendChild(this.host);
+        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();
+        }
     }
     /**
      * Programmatically display the tooltip
@@ -3462,33 +4938,27 @@ const PostTooltip = class {
     async toggle(target, force) {
         this.popoverRef.toggle(target, force);
     }
-    get triggers() {
-        return document.querySelectorAll(`[data-tooltip-target="${this.host.id}"]`);
-    }
-    patchPopoverTargetActionInterest(trigger) {
-        trigger.addEventListener('mouseenter', this.localShowTooltip);
-        trigger.addEventListener('mouseleave', this.localHideTooltip);
-        trigger.addEventListener('focus', this.localShowTooltip);
-        trigger.addEventListener('blur', this.localHideTooltip);
-        trigger.addEventListener('long-press', this.localShowTooltip);
-        // Patch missing aria-describedby attribute on the trigger without overriding existing values
-        const describedBy = trigger.getAttribute('aria-describedby');
-        if (!(describedBy === null || describedBy === void 0 ? void 0 : describedBy.includes(this.host.id))) {
-            const newDescribedBy = describedBy ? `${describedBy} ${this.host.id}` : this.host.id;
-            trigger.setAttribute('aria-describedby', newDescribedBy);
-        }
-        // Patch missing focus ability on the trigger element
-        if (!isFocusable(trigger)) {
-            trigger.setAttribute('tabindex', '0');
+    /**
+     * Pointer or focus is on the tooltip, stop the tooltip from disappearing
+     */
+    handleInterest() {
+        if (hideTooltipTimeout) {
+            window.clearTimeout(hideTooltipTimeout);
+            hideTooltipTimeout = null;
         }
     }
+    /**
+     * Pointer or focus left the tooltip, initiate the hiding process
+     */
+    handleInterestLost() {
+        globalHideTooltip(this);
+    }
     render() {
-        return (index.h(index.Host, { "data-version": _package.version }, index.h("post-popovercontainer", { role: "tooltip", tabindex: "-1", arrow: this.arrow, placement: this.placement, ref: (el) => (this.popoverRef = el) }, index.h("slot", null))));
+        const popoverClass = `${this.arrow ? ' has-arrow' : ''}`;
+        return (index.h(index.Host, { key: 'd773ddc0ce1a4dc682dfd05aea2191edb592a1a9', "data-version": _package.version, role: "tooltip", onPointerOver: this.handleInterest, onPointerOut: this.handleInterestLost, onFocusIn: this.handleInterest, onFocusOut: this.handleInterestLost }, index.h("post-popovercontainer", { key: '4465e819738b663ef9961e61b2b58a4a0a3a1039', class: popoverClass, arrow: this.arrow, placement: this.placement, ref: (el) => (this.popoverRef = el) }, index.h("slot", { key: 'c97e4c780acf110048b8415d2714273abbe5e479' }))));
     }
     get host() { return index.getElement(this); }
 };
-PostTooltip.style = postTooltipCss;
+PostTooltip.style = PostTooltipStyle0;
 
 exports.PostTooltip = PostTooltip;
-
-//# sourceMappingURL=post-tooltip-659af1e3.js.map