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

package/dist/components/post-tooltip-trigger2.js

@@ -0,0 +1,4968 @@
+import { proxyCustomElement, HTMLElement as HTMLElement$1, h, Host } from '@stencil/core/internal/client';
+import { c as checkType } from './check-type.js';
+import { v as version$1 } from './package.js';
+
+/*!
+ * long-press-event - v@version@
+ * Pure JavaScript long-press-event
+ * https://github.com/john-doherty/long-press-event
+ * @author John Doherty <www.johndoherty.info>
+ * @license MIT
+ */
+(function (window, document) {
+
+    // local timer object based on rAF
+    var timer = null;
+
+    // check if we're using a touch screen
+    var hasPointerEvents = (('PointerEvent' in window) || (window.navigator && 'msPointerEnabled' in window.navigator));
+    var isTouch = (('ontouchstart' in window) || (navigator.MaxTouchPoints > 0) || (navigator.msMaxTouchPoints > 0));
+
+    // switch to pointer events or touch events if using a touch screen
+    var mouseDown = hasPointerEvents ? 'pointerdown' : isTouch ? 'touchstart' : 'mousedown';
+    var mouseUp = hasPointerEvents ? 'pointerup' : isTouch ? 'touchend' : 'mouseup';
+    var mouseMove = hasPointerEvents ? 'pointermove' : isTouch ? 'touchmove' : 'mousemove';
+    var mouseLeave = hasPointerEvents ? 'pointerleave' : isTouch ? 'touchleave' : 'mouseleave';
+
+    // track number of pixels the mouse moves during long press
+    var startX = 0; // mouse x position when timer started
+    var startY = 0; // mouse y position when timer started
+    var maxDiffX = 10; // max number of X pixels the mouse can move during long press before it is canceled
+    var maxDiffY = 10; // max number of Y pixels the mouse can move during long press before it is canceled
+
+    // patch CustomEvent to allow constructor creation (IE/Chrome)
+    if (typeof window.CustomEvent !== 'function') {
+
+        window.CustomEvent = function (event, params) {
+
+            params = params || { bubbles: false, cancelable: false, detail: undefined };
+
+            var evt = document.createEvent('CustomEvent');
+            evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+            return evt;
+        };
+
+        window.CustomEvent.prototype = window.Event.prototype;
+    }
+
+    // requestAnimationFrame() shim by Paul Irish
+    window.requestAnimFrame = (function () {
+        return window.requestAnimationFrame ||
+            window.webkitRequestAnimationFrame ||
+            window.mozRequestAnimationFrame ||
+            window.oRequestAnimationFrame ||
+            window.msRequestAnimationFrame || function (callback) {
+                window.setTimeout(callback, 1000 / 60);
+            };
+    })();
+
+    /**
+     * Behaves the same as setTimeout except uses requestAnimationFrame() where possible for better performance
+     * @param {function} fn The callback function
+     * @param {int} delay The delay in milliseconds
+     * @returns {object} handle to the timeout object
+     */
+    function requestTimeout(fn, delay) {
+
+        if (!window.requestAnimationFrame && !window.webkitRequestAnimationFrame &&
+            !(window.mozRequestAnimationFrame && window.mozCancelRequestAnimationFrame) && // Firefox 5 ships without cancel support
+            !window.oRequestAnimationFrame && !window.msRequestAnimationFrame) return window.setTimeout(fn, delay);
+
+        var start = new Date().getTime();
+        var handle = {};
+
+        var loop = function () {
+            var current = new Date().getTime();
+            var delta = current - start;
+
+            if (delta >= delay) {
+                fn.call();
+            }
+            else {
+                handle.value = requestAnimFrame(loop);
+            }
+        };
+
+        handle.value = requestAnimFrame(loop);
+
+        return handle;
+    }
+
+    /**
+     * Behaves the same as clearTimeout except uses cancelRequestAnimationFrame() where possible for better performance
+     * @param {object} handle The callback function
+     * @returns {void}
+     */
+    function clearRequestTimeout(handle) {
+        if (handle) {
+            window.cancelAnimationFrame ? window.cancelAnimationFrame(handle.value) :
+                window.webkitCancelAnimationFrame ? window.webkitCancelAnimationFrame(handle.value) :
+                    window.webkitCancelRequestAnimationFrame ? window.webkitCancelRequestAnimationFrame(handle.value) : /* Support for legacy API */
+                        window.mozCancelRequestAnimationFrame ? window.mozCancelRequestAnimationFrame(handle.value) :
+                            window.oCancelRequestAnimationFrame ? window.oCancelRequestAnimationFrame(handle.value) :
+                                window.msCancelRequestAnimationFrame ? window.msCancelRequestAnimationFrame(handle.value) :
+                                    clearTimeout(handle);
+        }
+    }
+
+    /**
+     * Fires the 'long-press' event on element
+     * @param {MouseEvent|PointerEvent|TouchEvent} originalEvent The original event being fired
+     * @returns {void}
+     */
+    function fireLongPressEvent(originalEvent) {
+
+        clearLongPressTimer();
+
+        originalEvent = unifyEvent(originalEvent);
+
+        // fire the long-press event
+        var allowClickEvent = this.dispatchEvent(new CustomEvent('long-press', {
+            bubbles: true,
+            cancelable: true,
+
+            // custom event data (legacy)
+            detail: {
+                clientX: originalEvent.clientX,
+                clientY: originalEvent.clientY,
+                offsetX: originalEvent.offsetX,
+                offsetY: originalEvent.offsetY,
+                pageX: originalEvent.pageX,
+                pageY: originalEvent.pageY
+            },
+
+            // add coordinate data that would typically acompany a touch/click event
+            clientX: originalEvent.clientX,
+            clientY: originalEvent.clientY,
+            offsetX: originalEvent.offsetX,
+            offsetY: originalEvent.offsetY,
+            pageX: originalEvent.pageX,
+            pageY: originalEvent.pageY,
+            screenX: originalEvent.screenX,
+            screenY: originalEvent.screenY
+        }));
+
+        if (!allowClickEvent) {
+            // suppress the next click event if e.preventDefault() was called in long-press handler
+            document.addEventListener('click', function suppressEvent(e) {
+                document.removeEventListener('click', suppressEvent, true);
+                cancelEvent(e);
+            }, true);
+        }
+    }
+
+    /**
+     * consolidates mouse, touch, and Pointer events
+     * @param {MouseEvent|PointerEvent|TouchEvent} e The original event being fired
+     * @returns {MouseEvent|PointerEvent|Touch}
+     */
+    function unifyEvent(e) {
+        if (e.changedTouches !== undefined) {
+            return e.changedTouches[0];
+        }
+        return e;
+    }
+
+    /**
+     * method responsible for starting the long press timer
+     * @param {event} e - event object
+     * @returns {void}
+     */
+    function startLongPressTimer(e) {
+
+        clearLongPressTimer();
+
+        var el = e.target;
+
+        // get delay from html attribute if it exists, otherwise default to 1500
+        var longPressDelayInMs = parseInt(getNearestAttribute(el, 'data-long-press-delay', '1500'), 10); // default 1500
+
+        // start the timer
+        timer = requestTimeout(fireLongPressEvent.bind(el, e), longPressDelayInMs);
+    }
+
+    /**
+     * method responsible for clearing a pending long press timer
+     * @param {event} e - event object
+     * @returns {void}
+     */
+    function clearLongPressTimer(e) {
+        clearRequestTimeout(timer);
+        timer = null;
+    }
+
+    /**
+    * Cancels the current event
+    * @param {object} e - browser event object
+    * @returns {void}
+    */
+    function cancelEvent(e) {
+        e.stopImmediatePropagation();
+        e.preventDefault();
+        e.stopPropagation();
+    }
+
+    /**
+     * Starts the timer on mouse down and logs current position
+     * @param {object} e - browser event object
+     * @returns {void}
+     */
+    function mouseDownHandler(e) {
+        startX = e.clientX;
+        startY = e.clientY;
+        startLongPressTimer(e);
+    }
+
+    /**
+     * If the mouse moves n pixels during long-press, cancel the timer
+     * @param {object} e - browser event object
+     * @returns {void}
+     */
+    function mouseMoveHandler(e) {
+
+        // calculate total number of pixels the pointer has moved
+        var diffX = Math.abs(startX - e.clientX);
+        var diffY = Math.abs(startY - e.clientY);
+
+        // if pointer has moved more than allowed, cancel the long-press timer and therefore the event
+        if (diffX >= maxDiffX || diffY >= maxDiffY) {
+            clearLongPressTimer();
+        }
+    }
+
+    /**
+     * Gets attribute off HTML element or nearest parent
+     * @param {object} el - HTML element to retrieve attribute from
+     * @param {string} attributeName - name of the attribute
+     * @param {any} defaultValue - default value to return if no match found
+     * @returns {any} attribute value or defaultValue
+     */
+    function getNearestAttribute(el, attributeName, defaultValue) {
+
+        // walk up the dom tree looking for data-action and data-trigger
+        while (el && el !== document.documentElement) {
+
+            var attributeValue = el.getAttribute(attributeName);
+
+            if (attributeValue) {
+                return attributeValue;
+            }
+
+            el = el.parentNode;
+        }
+
+        return defaultValue;
+    }
+
+    // hook events that clear a pending long press event
+    document.addEventListener(mouseUp, clearLongPressTimer, true);
+    document.addEventListener(mouseLeave, clearLongPressTimer, true);
+    document.addEventListener(mouseMove, mouseMoveHandler, true);
+    document.addEventListener('wheel', clearLongPressTimer, true);
+    document.addEventListener('scroll', clearLongPressTimer, true);
+    document.addEventListener('contextmenu', clearLongPressTimer, true);
+
+    // hook events that can trigger a long press event
+    document.addEventListener(mouseDown, mouseDownHandler, true); // <- start
+
+}(window, document));
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+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 [];
+  }
+
+  if (Array.isArray(input)) {
+    return input;
+  }
+
+  // instanceof Node - does not work with iframes
+  if (input.nodeType !== undefined) {
+    return [input];
+  }
+
+  if (typeof input === 'string') {
+    input = document.querySelectorAll(input);
+  }
+
+  if (input.length !== undefined) {
+    return [].slice.call(input, 0);
+  }
+
+  throw new TypeError('unexpected input ' + String(input));
+};
+
+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 = (0, _nodeArray2.default)(context)[0];
+
+  if (resolveDocument && element && element.nodeType === Node.DOCUMENT_NODE) {
+    element = element.documentElement;
+  }
+
+  if (!element && defaultToDocument) {
+    return document.documentElement;
+  }
+
+  if (!element) {
+    throw new TypeError(label + ' requires valid options.context');
+  }
+
+  if (element.nodeType !== Node.ELEMENT_NODE && element.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {
+    throw new TypeError(label + ' requires options.context to be an Element');
+  }
+
+  return element;
+};
+
+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 = (0, _contextToElement2.default)({
+    label: 'get/parents',
+    context: context
+  });
+
+  while (element) {
+    list.push(element);
+    // IE does know support parentElement on SVGElement
+    element = element.parentNode;
+    if (element && element.nodeType !== Node.ELEMENT_NODE) {
+      element = null;
+    }
+  }
+
+  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
+
+var names = ['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector'];
+var name = null;
+
+function findMethodName(element) {
+  names.some(function (_name) {
+    if (!element[_name]) {
+      return false;
+    }
+
+    name = _name;
+    return true;
+  });
+}
+
+function elementMatches(element, selector) {
+  if (!name) {
+    findMethodName(element);
+  }
+
+  return element[name](selector);
+}
+module.exports = exports['default'];
+
+}(elementMatches, elementMatches.exports));
+
+var tabindexValue = {exports: {}};
+
+var validTabindex = {exports: {}};
+
+var supports = {exports: {}};
+
+var detectFocus = {exports: {}};
+
+var platform$1 = {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`. */
+  var objectTypes = {
+    'function': true,
+    'object': true
+  };
+
+  /** Used as a reference to the global object. */
+  var root = (objectTypes[typeof window] && window) || this;
+
+  /** Backup possible global object. */
+  var oldRoot = root;
+
+  /** Detect free variable `exports`. */
+  var freeExports = exports;
+
+  /** Detect free variable `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;
+  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
+    root = freeGlobal;
+  }
+
+  /**
+   * Used as the maximum length of an array-like object.
+   * See the [ES6 spec](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength)
+   * for more details.
+   */
+  var maxSafeInteger = Math.pow(2, 53) - 1;
+
+  /** Regular expression to detect Opera. */
+  var reOpera = /\bOpera/;
+
+  /** Possible global object. */
+  var thisBinding = this;
+
+  /** Used for native method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check for own properties of an object. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /** Used to resolve the internal `[[Class]]` of values. */
+  var toString = objectProto.toString;
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Capitalizes a string value.
+   *
+   * @private
+   * @param {string} string The string to capitalize.
+   * @returns {string} The capitalized string.
+   */
+  function capitalize(string) {
+    string = String(string);
+    return string.charAt(0).toUpperCase() + string.slice(1);
+  }
+
+  /**
+   * A utility function to clean up the OS name.
+   *
+   * @private
+   * @param {string} os The OS name to clean up.
+   * @param {string} [pattern] A `RegExp` pattern matching the OS name.
+   * @param {string} [label] A label for the OS.
+   */
+  function cleanupOS(os, pattern, label) {
+    // Platform tokens are defined at:
+    // http://msdn.microsoft.com/en-us/library/ms537503(VS.85).aspx
+    // http://web.archive.org/web/20081122053950/http://msdn.microsoft.com/en-us/library/ms537503(VS.85).aspx
+    var data = {
+      '10.0': '10',
+      '6.4':  '10 Technical Preview',
+      '6.3':  '8.1',
+      '6.2':  '8',
+      '6.1':  'Server 2008 R2 / 7',
+      '6.0':  'Server 2008 / Vista',
+      '5.2':  'Server 2003 / XP 64-bit',
+      '5.1':  'XP',
+      '5.01': '2000 SP1',
+      '5.0':  '2000',
+      '4.0':  'NT',
+      '4.90': 'ME'
+    };
+    // Detect Windows version from platform tokens.
+    if (pattern && label && /^Win/i.test(os) && !/^Windows Phone /i.test(os) &&
+        (data = data[/[\d.]+$/.exec(os)])) {
+      os = 'Windows ' + data;
+    }
+    // Correct character case and cleanup string.
+    os = String(os);
+
+    if (pattern && label) {
+      os = os.replace(RegExp(pattern, 'i'), label);
+    }
+
+    os = format(
+      os.replace(/ ce$/i, ' CE')
+        .replace(/\bhpw/i, 'web')
+        .replace(/\bMacintosh\b/, 'Mac OS')
+        .replace(/_PowerPC\b/i, ' OS')
+        .replace(/\b(OS X) [^ \d]+/i, '$1')
+        .replace(/\bMac (OS X)\b/, '$1')
+        .replace(/\/(\d)/, ' $1')
+        .replace(/_/g, '.')
+        .replace(/(?: BePC|[ .]*fc[ \d.]+)$/i, '')
+        .replace(/\bx86\.64\b/gi, 'x86_64')
+        .replace(/\b(Windows Phone) OS\b/, '$1')
+        .replace(/\b(Chrome OS \w+) [\d.]+\b/, '$1')
+        .split(' on ')[0]
+    );
+
+    return os;
+  }
+
+  /**
+   * An iteration utility for arrays and objects.
+   *
+   * @private
+   * @param {Array|Object} object The object to iterate over.
+   * @param {Function} callback The function called per iteration.
+   */
+  function each(object, callback) {
+    var index = -1,
+        length = object ? object.length : 0;
+
+    if (typeof length == 'number' && length > -1 && length <= maxSafeInteger) {
+      while (++index < length) {
+        callback(object[index], index, object);
+      }
+    } else {
+      forOwn(object, callback);
+    }
+  }
+
+  /**
+   * Trim and conditionally capitalize string values.
+   *
+   * @private
+   * @param {string} string The string to format.
+   * @returns {string} The formatted string.
+   */
+  function format(string) {
+    string = trim(string);
+    return /^(?:webOS|i(?:OS|P))/.test(string)
+      ? string
+      : capitalize(string);
+  }
+
+  /**
+   * Iterates over an object's own properties, executing the `callback` for each.
+   *
+   * @private
+   * @param {Object} object The object to iterate over.
+   * @param {Function} callback The function executed per own property.
+   */
+  function forOwn(object, callback) {
+    for (var key in object) {
+      if (hasOwnProperty.call(object, key)) {
+        callback(object[key], key, object);
+      }
+    }
+  }
+
+  /**
+   * Gets the internal `[[Class]]` of a value.
+   *
+   * @private
+   * @param {*} value The value.
+   * @returns {string} The `[[Class]]`.
+   */
+  function getClassOf(value) {
+    return value == null
+      ? capitalize(value)
+      : toString.call(value).slice(8, -1);
+  }
+
+  /**
+   * Host objects can return type values that are different from their actual
+   * data type. The objects we are concerned with usually return non-primitive
+   * types of "object", "function", or "unknown".
+   *
+   * @private
+   * @param {*} object The owner of the property.
+   * @param {string} property The property to check.
+   * @returns {boolean} Returns `true` if the property value is a non-primitive, else `false`.
+   */
+  function isHostType(object, property) {
+    var type = object != null ? typeof object[property] : 'number';
+    return !/^(?:boolean|number|string|undefined)$/.test(type) &&
+      (type == 'object' ? !!object[property] : true);
+  }
+
+  /**
+   * Prepares a string for use in a `RegExp` by making hyphens and spaces optional.
+   *
+   * @private
+   * @param {string} string The string to qualify.
+   * @returns {string} The qualified string.
+   */
+  function qualify(string) {
+    return String(string).replace(/([ -])(?!$)/g, '$1?');
+  }
+
+  /**
+   * A bare-bones `Array#reduce` like utility function.
+   *
+   * @private
+   * @param {Array} array The array to iterate over.
+   * @param {Function} callback The function called per iteration.
+   * @returns {*} The accumulated result.
+   */
+  function reduce(array, callback) {
+    var accumulator = null;
+    each(array, function(value, index) {
+      accumulator = callback(accumulator, value, index, array);
+    });
+    return accumulator;
+  }
+
+  /**
+   * Removes leading and trailing whitespace from a string.
+   *
+   * @private
+   * @param {string} string The string to trim.
+   * @returns {string} The trimmed string.
+   */
+  function trim(string) {
+    return String(string).replace(/^ +| +$/g, '');
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Creates a new platform object.
+   *
+   * @memberOf platform
+   * @param {Object|string} [ua=navigator.userAgent] The user agent string or
+   *  context object.
+   * @returns {Object} A platform object.
+   */
+  function parse(ua) {
+
+    /** The environment context object. */
+    var context = root;
+
+    /** Used to flag when a custom context is provided. */
+    var isCustomContext = ua && typeof ua == 'object' && getClassOf(ua) != 'String';
+
+    // Juggle arguments.
+    if (isCustomContext) {
+      context = ua;
+      ua = null;
+    }
+
+    /** Browser navigator object. */
+    var nav = context.navigator || {};
+
+    /** Browser user agent string. */
+    var userAgent = nav.userAgent || '';
+
+    ua || (ua = userAgent);
+
+    /** Used to flag when `thisBinding` is the [ModuleScope]. */
+    var isModuleScope = isCustomContext || thisBinding == oldRoot;
+
+    /** Used to detect if browser is like Chrome. */
+    var likeChrome = isCustomContext
+      ? !!nav.likeChrome
+      : /\bChrome\b/.test(ua) && !/internal|\n/i.test(toString.toString());
+
+    /** Internal `[[Class]]` value shortcuts. */
+    var objectClass = 'Object',
+        airRuntimeClass = isCustomContext ? objectClass : 'ScriptBridgingProxyObject',
+        enviroClass = isCustomContext ? objectClass : 'Environment',
+        javaClass = (isCustomContext && context.java) ? 'JavaPackage' : getClassOf(context.java),
+        phantomClass = isCustomContext ? objectClass : 'RuntimeObject';
+
+    /** Detect Java environments. */
+    var java = /\bJava/.test(javaClass) && context.java;
+
+    /** Detect Rhino. */
+    var rhino = java && getClassOf(context.environment) == enviroClass;
+
+    /** A character to represent alpha. */
+    var alpha = java ? 'a' : '\u03b1';
+
+    /** A character to represent beta. */
+    var beta = java ? 'b' : '\u03b2';
+
+    /** Browser document object. */
+    var doc = context.document || {};
+
+    /**
+     * Detect Opera browser (Presto-based).
+     * http://www.howtocreate.co.uk/operaStuff/operaObject.html
+     * http://dev.opera.com/articles/view/opera-mini-web-content-authoring-guidelines/#operamini
+     */
+    var opera = context.operamini || context.opera;
+
+    /** Opera `[[Class]]`. */
+    var operaClass = reOpera.test(operaClass = (isCustomContext && opera) ? opera['[[Class]]'] : getClassOf(opera))
+      ? operaClass
+      : (opera = null);
+
+    /*------------------------------------------------------------------------*/
+
+    /** Temporary variable used over the script's lifetime. */
+    var data;
+
+    /** The CPU architecture. */
+    var arch = ua;
+
+    /** Platform description array. */
+    var description = [];
+
+    /** Platform alpha/beta indicator. */
+    var prerelease = null;
+
+    /** A flag to indicate that environment features should be used to resolve the platform. */
+    var useFeatures = ua == userAgent;
+
+    /** The browser/environment version. */
+    var version = useFeatures && opera && typeof opera.version == 'function' && opera.version();
+
+    /** A flag to indicate if the OS ends with "/ Version" */
+    var isSpecialCasedOS;
+
+    /* Detectable layout engines (order is important). */
+    var layout = getLayout([
+      { 'label': 'EdgeHTML', 'pattern': 'Edge' },
+      'Trident',
+      { 'label': 'WebKit', 'pattern': 'AppleWebKit' },
+      'iCab',
+      'Presto',
+      'NetFront',
+      'Tasman',
+      'KHTML',
+      'Gecko'
+    ]);
+
+    /* Detectable browser names (order is important). */
+    var name = getName([
+      'Adobe AIR',
+      'Arora',
+      'Avant Browser',
+      'Breach',
+      'Camino',
+      'Epiphany',
+      'Fennec',
+      'Flock',
+      'Galeon',
+      'GreenBrowser',
+      'iCab',
+      'Iceweasel',
+      'K-Meleon',
+      'Konqueror',
+      'Lunascape',
+      'Maxthon',
+      { 'label': 'Microsoft Edge', 'pattern': 'Edge' },
+      'Midori',
+      'Nook Browser',
+      'PaleMoon',
+      'PhantomJS',
+      'Raven',
+      'Rekonq',
+      'RockMelt',
+      'SeaMonkey',
+      { 'label': 'Silk', 'pattern': '(?:Cloud9|Silk-Accelerated)' },
+      'Sleipnir',
+      'SlimBrowser',
+      { 'label': 'SRWare Iron', 'pattern': 'Iron' },
+      'Sunrise',
+      'Swiftfox',
+      'WebPositive',
+      'Opera Mini',
+      { 'label': 'Opera Mini', 'pattern': 'OPiOS' },
+      'Opera',
+      { 'label': 'Opera', 'pattern': 'OPR' },
+      'Chrome',
+      { 'label': 'Chrome Mobile', 'pattern': '(?:CriOS|CrMo)' },
+      { 'label': 'Firefox', 'pattern': '(?:Firefox|Minefield)' },
+      { 'label': 'Firefox for iOS', 'pattern': 'FxiOS' },
+      { 'label': 'IE', 'pattern': 'IEMobile' },
+      { 'label': 'IE', 'pattern': 'MSIE' },
+      'Safari'
+    ]);
+
+    /* Detectable products (order is important). */
+    var product = getProduct([
+      { 'label': 'BlackBerry', 'pattern': 'BB10' },
+      'BlackBerry',
+      { 'label': 'Galaxy S', 'pattern': 'GT-I9000' },
+      { 'label': 'Galaxy S2', 'pattern': 'GT-I9100' },
+      { 'label': 'Galaxy S3', 'pattern': 'GT-I9300' },
+      { 'label': 'Galaxy S4', 'pattern': 'GT-I9500' },
+      'Google TV',
+      'Lumia',
+      'iPad',
+      'iPod',
+      'iPhone',
+      'Kindle',
+      { 'label': 'Kindle Fire', 'pattern': '(?:Cloud9|Silk-Accelerated)' },
+      'Nexus',
+      'Nook',
+      'PlayBook',
+      'PlayStation 3',
+      'PlayStation 4',
+      'PlayStation Vita',
+      'TouchPad',
+      'Transformer',
+      { 'label': 'Wii U', 'pattern': 'WiiU' },
+      'Wii',
+      'Xbox One',
+      { 'label': 'Xbox 360', 'pattern': 'Xbox' },
+      'Xoom'
+    ]);
+
+    /* Detectable manufacturers. */
+    var manufacturer = getManufacturer({
+      'Apple': { 'iPad': 1, 'iPhone': 1, 'iPod': 1 },
+      'Archos': {},
+      'Amazon': { 'Kindle': 1, 'Kindle Fire': 1 },
+      'Asus': { 'Transformer': 1 },
+      'Barnes & Noble': { 'Nook': 1 },
+      'BlackBerry': { 'PlayBook': 1 },
+      'Google': { 'Google TV': 1, 'Nexus': 1 },
+      'HP': { 'TouchPad': 1 },
+      'HTC': {},
+      'LG': {},
+      'Microsoft': { 'Xbox': 1, 'Xbox One': 1 },
+      'Motorola': { 'Xoom': 1 },
+      'Nintendo': { 'Wii U': 1,  'Wii': 1 },
+      'Nokia': { 'Lumia': 1 },
+      'Samsung': { 'Galaxy S': 1, 'Galaxy S2': 1, 'Galaxy S3': 1, 'Galaxy S4': 1 },
+      'Sony': { 'PlayStation 4': 1, 'PlayStation 3': 1, 'PlayStation Vita': 1 }
+    });
+
+    /* Detectable operating systems (order is important). */
+    var os = getOS([
+      'Windows Phone',
+      'Android',
+      'CentOS',
+      { 'label': 'Chrome OS', 'pattern': 'CrOS' },
+      'Debian',
+      'Fedora',
+      'FreeBSD',
+      'Gentoo',
+      'Haiku',
+      'Kubuntu',
+      'Linux Mint',
+      'OpenBSD',
+      'Red Hat',
+      'SuSE',
+      'Ubuntu',
+      'Xubuntu',
+      'Cygwin',
+      'Symbian OS',
+      'hpwOS',
+      'webOS ',
+      'webOS',
+      'Tablet OS',
+      'Linux',
+      'Mac OS X',
+      'Macintosh',
+      'Mac',
+      'Windows 98;',
+      'Windows '
+    ]);
+
+    /*------------------------------------------------------------------------*/
+
+    /**
+     * Picks the layout engine from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected layout engine.
+     */
+    function getLayout(guesses) {
+      return reduce(guesses, function(result, guess) {
+        return result || RegExp('\\b' + (
+          guess.pattern || qualify(guess)
+        ) + '\\b', 'i').exec(ua) && (guess.label || guess);
+      });
+    }
+
+    /**
+     * Picks the manufacturer from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An object of guesses.
+     * @returns {null|string} The detected manufacturer.
+     */
+    function getManufacturer(guesses) {
+      return reduce(guesses, function(result, value, key) {
+        // Lookup the manufacturer by product or scan the UA for the manufacturer.
+        return result || (
+          value[product] ||
+          value[/^[a-z]+(?: +[a-z]+\b)*/i.exec(product)] ||
+          RegExp('\\b' + qualify(key) + '(?:\\b|\\w*\\d)', 'i').exec(ua)
+        ) && key;
+      });
+    }
+
+    /**
+     * Picks the browser name from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected browser name.
+     */
+    function getName(guesses) {
+      return reduce(guesses, function(result, guess) {
+        return result || RegExp('\\b' + (
+          guess.pattern || qualify(guess)
+        ) + '\\b', 'i').exec(ua) && (guess.label || guess);
+      });
+    }
+
+    /**
+     * Picks the OS name from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected OS name.
+     */
+    function getOS(guesses) {
+      return reduce(guesses, function(result, guess) {
+        var pattern = guess.pattern || qualify(guess);
+        if (!result && (result =
+              RegExp('\\b' + pattern + '(?:/[\\d.]+|[ \\w.]*)', 'i').exec(ua)
+            )) {
+          result = cleanupOS(result, pattern, guess.label || guess);
+        }
+        return result;
+      });
+    }
+
+    /**
+     * Picks the product name from an array of guesses.
+     *
+     * @private
+     * @param {Array} guesses An array of guesses.
+     * @returns {null|string} The detected product name.
+     */
+    function getProduct(guesses) {
+      return reduce(guesses, function(result, guess) {
+        var pattern = guess.pattern || qualify(guess);
+        if (!result && (result =
+              RegExp('\\b' + pattern + ' *\\d+[.\\w_]*', 'i').exec(ua) ||
+              RegExp('\\b' + pattern + '(?:; *(?:[a-z]+[_-])?[a-z]+\\d+|[^ ();-]*)', 'i').exec(ua)
+            )) {
+          // Split by forward slash and append product version if needed.
+          if ((result = String((guess.label && !RegExp(pattern, 'i').test(guess.label)) ? guess.label : result).split('/'))[1] && !/[\d.]+/.test(result[0])) {
+            result[0] += ' ' + result[1];
+          }
+          // Correct character case and cleanup string.
+          guess = guess.label || guess;
+          result = format(result[0]
+            .replace(RegExp(pattern, 'i'), guess)
+            .replace(RegExp('; *(?:' + guess + '[_-])?', 'i'), ' ')
+            .replace(RegExp('(' + guess + ')[-_.]?(\\w)', 'i'), '$1 $2'));
+        }
+        return result;
+      });
+    }
+
+    /**
+     * Resolves the version using an array of UA patterns.
+     *
+     * @private
+     * @param {Array} patterns An array of UA patterns.
+     * @returns {null|string} The detected version.
+     */
+    function getVersion(patterns) {
+      return reduce(patterns, function(result, pattern) {
+        return result || (RegExp(pattern +
+          '(?:-[\\d.]+/|(?: for [\\w-]+)?[ /-])([\\d.]+[^ ();/_-]*)', 'i').exec(ua) || 0)[1] || null;
+      });
+    }
+
+    /**
+     * Returns `platform.description` when the platform object is coerced to a string.
+     *
+     * @name toString
+     * @memberOf platform
+     * @returns {string} Returns `platform.description` if available, else an empty string.
+     */
+    function toStringPlatform() {
+      return this.description || '';
+    }
+
+    /*------------------------------------------------------------------------*/
+
+    // Convert layout to an array so we can add extra details.
+    layout && (layout = [layout]);
+
+    // Detect product names that contain their manufacturer's name.
+    if (manufacturer && !product) {
+      product = getProduct([manufacturer]);
+    }
+    // Clean up Google TV.
+    if ((data = /\bGoogle TV\b/.exec(product))) {
+      product = data[0];
+    }
+    // Detect simulators.
+    if (/\bSimulator\b/i.test(ua)) {
+      product = (product ? product + ' ' : '') + 'Simulator';
+    }
+    // Detect Opera Mini 8+ running in Turbo/Uncompressed mode on iOS.
+    if (name == 'Opera Mini' && /\bOPiOS\b/.test(ua)) {
+      description.push('running in Turbo/Uncompressed mode');
+    }
+    // Detect IE Mobile 11.
+    if (name == 'IE' && /\blike iPhone OS\b/.test(ua)) {
+      data = parse(ua.replace(/like iPhone OS/, ''));
+      manufacturer = data.manufacturer;
+      product = data.product;
+    }
+    // Detect iOS.
+    else if (/^iP/.test(product)) {
+      name || (name = 'Safari');
+      os = 'iOS' + ((data = / OS ([\d_]+)/i.exec(ua))
+        ? ' ' + data[1].replace(/_/g, '.')
+        : '');
+    }
+    // Detect Kubuntu.
+    else if (name == 'Konqueror' && !/buntu/i.test(os)) {
+      os = 'Kubuntu';
+    }
+    // Detect Android browsers.
+    else if ((manufacturer && manufacturer != 'Google' &&
+        ((/Chrome/.test(name) && !/\bMobile Safari\b/i.test(ua)) || /\bVita\b/.test(product))) ||
+        (/\bAndroid\b/.test(os) && /^Chrome/.test(name) && /\bVersion\//i.test(ua))) {
+      name = 'Android Browser';
+      os = /\bAndroid\b/.test(os) ? os : 'Android';
+    }
+    // Detect Silk desktop/accelerated modes.
+    else if (name == 'Silk') {
+      if (!/\bMobi/i.test(ua)) {
+        os = 'Android';
+        description.unshift('desktop mode');
+      }
+      if (/Accelerated *= *true/i.test(ua)) {
+        description.unshift('accelerated');
+      }
+    }
+    // Detect PaleMoon identifying as Firefox.
+    else if (name == 'PaleMoon' && (data = /\bFirefox\/([\d.]+)\b/.exec(ua))) {
+      description.push('identifying as Firefox ' + data[1]);
+    }
+    // Detect Firefox OS and products running Firefox.
+    else if (name == 'Firefox' && (data = /\b(Mobile|Tablet|TV)\b/i.exec(ua))) {
+      os || (os = 'Firefox OS');
+      product || (product = data[1]);
+    }
+    // Detect false positives for Firefox/Safari.
+    else if (!name || (data = !/\bMinefield\b/i.test(ua) && /\b(?:Firefox|Safari)\b/.exec(name))) {
+      // Escape the `/` for Firefox 1.
+      if (name && !product && /[\/,]|^[^(]+?\)/.test(ua.slice(ua.indexOf(data + '/') + 8))) {
+        // Clear name of false positives.
+        name = null;
+      }
+      // Reassign a generic name.
+      if ((data = product || manufacturer || os) &&
+          (product || manufacturer || /\b(?:Android|Symbian OS|Tablet OS|webOS)\b/.test(os))) {
+        name = /[a-z]+(?: Hat)?/i.exec(/\bAndroid\b/.test(os) ? os : data) + ' Browser';
+      }
+    }
+    // Detect non-Opera (Presto-based) versions (order is important).
+    if (!version) {
+      version = getVersion([
+        '(?:Cloud9|CriOS|CrMo|Edge|FxiOS|IEMobile|Iron|Opera ?Mini|OPiOS|OPR|Raven|Silk(?!/[\\d.]+$))',
+        'Version',
+        qualify(name),
+        '(?:Firefox|Minefield|NetFront)'
+      ]);
+    }
+    // Detect stubborn layout engines.
+    if ((data =
+          layout == 'iCab' && parseFloat(version) > 3 && 'WebKit' ||
+          /\bOpera\b/.test(name) && (/\bOPR\b/.test(ua) ? 'Blink' : 'Presto') ||
+          /\b(?:Midori|Nook|Safari)\b/i.test(ua) && !/^(?:Trident|EdgeHTML)$/.test(layout) && 'WebKit' ||
+          !layout && /\bMSIE\b/i.test(ua) && (os == 'Mac OS' ? 'Tasman' : 'Trident') ||
+          layout == 'WebKit' && /\bPlayStation\b(?! Vita\b)/i.test(name) && 'NetFront'
+        )) {
+      layout = [data];
+    }
+    // Detect Windows Phone 7 desktop mode.
+    if (name == 'IE' && (data = (/; *(?:XBLWP|ZuneWP)(\d+)/i.exec(ua) || 0)[1])) {
+      name += ' Mobile';
+      os = 'Windows Phone ' + (/\+$/.test(data) ? data : data + '.x');
+      description.unshift('desktop mode');
+    }
+    // Detect Windows Phone 8.x desktop mode.
+    else if (/\bWPDesktop\b/i.test(ua)) {
+      name = 'IE Mobile';
+      os = 'Windows Phone 8.x';
+      description.unshift('desktop mode');
+      version || (version = (/\brv:([\d.]+)/.exec(ua) || 0)[1]);
+    }
+    // Detect IE 11.
+    else if (name != 'IE' && layout == 'Trident' && (data = /\brv:([\d.]+)/.exec(ua))) {
+      if (name) {
+        description.push('identifying as ' + name + (version ? ' ' + version : ''));
+      }
+      name = 'IE';
+      version = data[1];
+    }
+    // Leverage environment features.
+    if (useFeatures) {
+      // Detect server-side environments.
+      // Rhino has a global function while others have a global object.
+      if (isHostType(context, 'global')) {
+        if (java) {
+          data = java.lang.System;
+          arch = data.getProperty('os.arch');
+          os = os || data.getProperty('os.name') + ' ' + data.getProperty('os.version');
+        }
+        if (isModuleScope && isHostType(context, 'system') && (data = [context.system])[0]) {
+          os || (os = data[0].os || null);
+          try {
+            data[1] = context.require('ringo/engine').version;
+            version = data[1].join('.');
+            name = 'RingoJS';
+          } catch(e) {
+            if (data[0].global.system == context.system) {
+              name = 'Narwhal';
+            }
+          }
+        }
+        else if (
+          typeof context.process == 'object' && !context.process.browser &&
+          (data = context.process)
+        ) {
+          name = 'Node.js';
+          arch = data.arch;
+          os = data.platform;
+          version = /[\d.]+/.exec(data.version)[0];
+        }
+        else if (rhino) {
+          name = 'Rhino';
+        }
+      }
+      // Detect Adobe AIR.
+      else if (getClassOf((data = context.runtime)) == airRuntimeClass) {
+        name = 'Adobe AIR';
+        os = data.flash.system.Capabilities.os;
+      }
+      // Detect PhantomJS.
+      else if (getClassOf((data = context.phantom)) == phantomClass) {
+        name = 'PhantomJS';
+        version = (data = data.version || null) && (data.major + '.' + data.minor + '.' + data.patch);
+      }
+      // Detect IE compatibility modes.
+      else if (typeof doc.documentMode == 'number' && (data = /\bTrident\/(\d+)/i.exec(ua))) {
+        // We're in compatibility mode when the Trident version + 4 doesn't
+        // equal the document mode.
+        version = [version, doc.documentMode];
+        if ((data = +data[1] + 4) != version[1]) {
+          description.push('IE ' + version[1] + ' mode');
+          layout && (layout[1] = '');
+          version[1] = data;
+        }
+        version = name == 'IE' ? String(version[1].toFixed(1)) : version[0];
+      }
+      os = os && format(os);
+    }
+    // Detect prerelease phases.
+    if (version && (data =
+          /(?:[ab]|dp|pre|[ab]\d+pre)(?:\d+\+?)?$/i.exec(version) ||
+          /(?:alpha|beta)(?: ?\d)?/i.exec(ua + ';' + (useFeatures && nav.appMinorVersion)) ||
+          /\bMinefield\b/i.test(ua) && 'a'
+        )) {
+      prerelease = /b/i.test(data) ? 'beta' : 'alpha';
+      version = version.replace(RegExp(data + '\\+?$'), '') +
+        (prerelease == 'beta' ? beta : alpha) + (/\d+\+?/.exec(data) || '');
+    }
+    // Detect Firefox Mobile.
+    if (name == 'Fennec' || name == 'Firefox' && /\b(?:Android|Firefox OS)\b/.test(os)) {
+      name = 'Firefox Mobile';
+    }
+    // Obscure Maxthon's unreliable version.
+    else if (name == 'Maxthon' && version) {
+      version = version.replace(/\.[\d.]+/, '.x');
+    }
+    // Detect Xbox 360 and Xbox One.
+    else if (/\bXbox\b/i.test(product)) {
+      os = null;
+      if (product == 'Xbox 360' && /\bIEMobile\b/.test(ua)) {
+        description.unshift('mobile mode');
+      }
+    }
+    // Add mobile postfix.
+    else if ((/^(?:Chrome|IE|Opera)$/.test(name) || name && !product && !/Browser|Mobi/.test(name)) &&
+        (os == 'Windows CE' || /Mobi/i.test(ua))) {
+      name += ' Mobile';
+    }
+    // Detect IE platform preview.
+    else if (name == 'IE' && useFeatures && context.external === null) {
+      description.unshift('platform preview');
+    }
+    // Detect BlackBerry OS version.
+    // http://docs.blackberry.com/en/developers/deliverables/18169/HTTP_headers_sent_by_BB_Browser_1234911_11.jsp
+    else if ((/\bBlackBerry\b/.test(product) || /\bBB10\b/.test(ua)) && (data =
+          (RegExp(product.replace(/ +/g, ' *') + '/([.\\d]+)', 'i').exec(ua) || 0)[1] ||
+          version
+        )) {
+      data = [data, /BB10/.test(ua)];
+      os = (data[1] ? (product = null, manufacturer = 'BlackBerry') : 'Device Software') + ' ' + data[0];
+      version = null;
+    }
+    // Detect Opera identifying/masking itself as another browser.
+    // http://www.opera.com/support/kb/view/843/
+    else if (this != forOwn && product != 'Wii' && (
+          (useFeatures && opera) ||
+          (/Opera/.test(name) && /\b(?:MSIE|Firefox)\b/i.test(ua)) ||
+          (name == 'Firefox' && /\bOS X (?:\d+\.){2,}/.test(os)) ||
+          (name == 'IE' && (
+            (os && !/^Win/.test(os) && version > 5.5) ||
+            /\bWindows XP\b/.test(os) && version > 8 ||
+            version == 8 && !/\bTrident\b/.test(ua)
+          ))
+        ) && !reOpera.test((data = parse.call(forOwn, ua.replace(reOpera, '') + ';'))) && data.name) {
+      // When "identifying", the UA contains both Opera and the other browser's name.
+      data = 'ing as ' + data.name + ((data = data.version) ? ' ' + data : '');
+      if (reOpera.test(name)) {
+        if (/\bIE\b/.test(data) && os == 'Mac OS') {
+          os = null;
+        }
+        data = 'identify' + data;
+      }
+      // When "masking", the UA contains only the other browser's name.
+      else {
+        data = 'mask' + data;
+        if (operaClass) {
+          name = format(operaClass.replace(/([a-z])([A-Z])/g, '$1 $2'));
+        } else {
+          name = 'Opera';
+        }
+        if (/\bIE\b/.test(data)) {
+          os = null;
+        }
+        if (!useFeatures) {
+          version = null;
+        }
+      }
+      layout = ['Presto'];
+      description.push(data);
+    }
+    // Detect WebKit Nightly and approximate Chrome/Safari versions.
+    if ((data = (/\bAppleWebKit\/([\d.]+\+?)/i.exec(ua) || 0)[1])) {
+      // Correct build number for numeric comparison.
+      // (e.g. "532.5" becomes "532.05")
+      data = [parseFloat(data.replace(/\.(\d)$/, '.0$1')), data];
+      // Nightly builds are postfixed with a "+".
+      if (name == 'Safari' && data[1].slice(-1) == '+') {
+        name = 'WebKit Nightly';
+        prerelease = 'alpha';
+        version = data[1].slice(0, -1);
+      }
+      // Clear incorrect browser versions.
+      else if (version == data[1] ||
+          version == (data[2] = (/\bSafari\/([\d.]+\+?)/i.exec(ua) || 0)[1])) {
+        version = null;
+      }
+      // Use the full Chrome version when available.
+      data[1] = (/\bChrome\/([\d.]+)/i.exec(ua) || 0)[1];
+      // Detect Blink layout engine.
+      if (data[0] == 537.36 && data[2] == 537.36 && parseFloat(data[1]) >= 28 && layout == 'WebKit') {
+        layout = ['Blink'];
+      }
+      // Detect JavaScriptCore.
+      // http://stackoverflow.com/questions/6768474/how-can-i-detect-which-javascript-engine-v8-or-jsc-is-used-at-runtime-in-androi
+      if (!useFeatures || (!likeChrome && !data[1])) {
+        layout && (layout[1] = 'like Safari');
+        data = (data = data[0], data < 400 ? 1 : data < 500 ? 2 : data < 526 ? 3 : data < 533 ? 4 : data < 534 ? '4+' : data < 535 ? 5 : data < 537 ? 6 : data < 538 ? 7 : data < 601 ? 8 : '8');
+      } else {
+        layout && (layout[1] = 'like Chrome');
+        data = data[1] || (data = data[0], data < 530 ? 1 : data < 532 ? 2 : data < 532.05 ? 3 : data < 533 ? 4 : data < 534.03 ? 5 : data < 534.07 ? 6 : data < 534.10 ? 7 : data < 534.13 ? 8 : data < 534.16 ? 9 : data < 534.24 ? 10 : data < 534.30 ? 11 : data < 535.01 ? 12 : data < 535.02 ? '13+' : data < 535.07 ? 15 : data < 535.11 ? 16 : data < 535.19 ? 17 : data < 536.05 ? 18 : data < 536.10 ? 19 : data < 537.01 ? 20 : data < 537.11 ? '21+' : data < 537.13 ? 23 : data < 537.18 ? 24 : data < 537.24 ? 25 : data < 537.36 ? 26 : layout != 'Blink' ? '27' : '28');
+      }
+      // Add the postfix of ".x" or "+" for approximate versions.
+      layout && (layout[1] += ' ' + (data += typeof data == 'number' ? '.x' : /[.+]/.test(data) ? '' : '+'));
+      // Obscure version for some Safari 1-2 releases.
+      if (name == 'Safari' && (!version || parseInt(version) > 45)) {
+        version = data;
+      }
+    }
+    // Detect Opera desktop modes.
+    if (name == 'Opera' &&  (data = /\bzbov|zvav$/.exec(os))) {
+      name += ' ';
+      description.unshift('desktop mode');
+      if (data == 'zvav') {
+        name += 'Mini';
+        version = null;
+      } else {
+        name += 'Mobile';
+      }
+      os = os.replace(RegExp(' *' + data + '$'), '');
+    }
+    // Detect Chrome desktop mode.
+    else if (name == 'Safari' && /\bChrome\b/.exec(layout && layout[1])) {
+      description.unshift('desktop mode');
+      name = 'Chrome Mobile';
+      version = null;
+
+      if (/\bOS X\b/.test(os)) {
+        manufacturer = 'Apple';
+        os = 'iOS 4.3+';
+      } else {
+        os = null;
+      }
+    }
+    // Strip incorrect OS versions.
+    if (version && version.indexOf((data = /[\d.]+$/.exec(os))) == 0 &&
+        ua.indexOf('/' + data + '-') > -1) {
+      os = trim(os.replace(data, ''));
+    }
+    // Add layout engine.
+    if (layout && !/\b(?:Avant|Nook)\b/.test(name) && (
+        /Browser|Lunascape|Maxthon/.test(name) ||
+        name != 'Safari' && /^iOS/.test(os) && /\bSafari\b/.test(layout[1]) ||
+        /^(?:Adobe|Arora|Breach|Midori|Opera|Phantom|Rekonq|Rock|Sleipnir|Web)/.test(name) && layout[1])) {
+      // Don't add layout details to description if they are falsey.
+      (data = layout[layout.length - 1]) && description.push(data);
+    }
+    // Combine contextual information.
+    if (description.length) {
+      description = ['(' + description.join('; ') + ')'];
+    }
+    // Append manufacturer to description.
+    if (manufacturer && product && product.indexOf(manufacturer) < 0) {
+      description.push('on ' + manufacturer);
+    }
+    // Append product to description.
+    if (product) {
+      description.push((/^on /.test(description[description.length - 1]) ? '' : 'on ') + product);
+    }
+    // Parse the OS into an object.
+    if (os) {
+      data = / ([\d.+]+)$/.exec(os);
+      isSpecialCasedOS = data && os.charAt(os.length - data[0].length - 1) == '/';
+      os = {
+        'architecture': 32,
+        'family': (data && !isSpecialCasedOS) ? os.replace(data[0], '') : os,
+        'version': data ? data[1] : null,
+        'toString': function() {
+          var version = this.version;
+          return this.family + ((version && !isSpecialCasedOS) ? ' ' + version : '') + (this.architecture == 64 ? ' 64-bit' : '');
+        }
+      };
+    }
+    // Add browser/OS architecture.
+    if ((data = /\b(?:AMD|IA|Win|WOW|x86_|x)64\b/i.exec(arch)) && !/\bi686\b/i.test(arch)) {
+      if (os) {
+        os.architecture = 64;
+        os.family = os.family.replace(RegExp(' *' + data), '');
+      }
+      if (
+          name && (/\bWOW64\b/i.test(ua) ||
+          (useFeatures && /\w(?:86|32)$/.test(nav.cpuClass || nav.platform) && !/\bWin64; x64\b/i.test(ua)))
+      ) {
+        description.unshift('32-bit');
+      }
+    }
+    // Chrome 39 and above on OS X is always 64-bit.
+    else if (
+        os && /^OS X/.test(os.family) &&
+        name == 'Chrome' && parseFloat(version) >= 39
+    ) {
+      os.architecture = 64;
+    }
+
+    ua || (ua = null);
+
+    /*------------------------------------------------------------------------*/
+
+    /**
+     * The platform object.
+     *
+     * @name platform
+     * @type Object
+     */
+    var platform = {};
+
+    /**
+     * The platform description.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.description = ua;
+
+    /**
+     * The name of the browser's layout engine.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.layout = layout && layout[0];
+
+    /**
+     * The name of the product's manufacturer.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.manufacturer = manufacturer;
+
+    /**
+     * The name of the browser/environment.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.name = name;
+
+    /**
+     * The alpha/beta release indicator.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.prerelease = prerelease;
+
+    /**
+     * The name of the product hosting the browser.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.product = product;
+
+    /**
+     * The browser's user agent string.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.ua = ua;
+
+    /**
+     * The browser/environment version.
+     *
+     * @memberOf platform
+     * @type string|null
+     */
+    platform.version = name && version;
+
+    /**
+     * The name of the operating system.
+     *
+     * @memberOf platform
+     * @type Object
+     */
+    platform.os = os || {
+
+      /**
+       * The CPU architecture the OS is built for.
+       *
+       * @memberOf platform.os
+       * @type number|null
+       */
+      'architecture': null,
+
+      /**
+       * The family of the OS.
+       *
+       * Common values include:
+       * "Windows", "Windows Server 2008 R2 / 7", "Windows Server 2008 / Vista",
+       * "Windows XP", "OS X", "Ubuntu", "Debian", "Fedora", "Red Hat", "SuSE",
+       * "Android", "iOS" and "Windows Phone"
+       *
+       * @memberOf platform.os
+       * @type string|null
+       */
+      'family': null,
+
+      /**
+       * The version of the OS.
+       *
+       * @memberOf platform.os
+       * @type string|null
+       */
+      'version': null,
+
+      /**
+       * Returns the OS string.
+       *
+       * @memberOf platform.os
+       * @returns {string} The OS string.
+       */
+      'toString': function() { return 'null'; }
+    };
+
+    platform.parse = parse;
+    platform.toString = toStringPlatform;
+
+    if (platform.version) {
+      description.unshift(version);
+    }
+    if (platform.name) {
+      description.unshift(name);
+    }
+    if (os && name && !(os == String(os).split(' ')[0] && (os == name.split(' ')[0] || product))) {
+      description.push(product ? '(' + os + ')' : 'on ' + os);
+    }
+    if (description.length) {
+      platform.description = description.join(' ');
+    }
+    return platform;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  // Export platform.
+  var platform = parse();
+
+  // Some AMD build optimizers, like r.js, check for condition patterns like the following:
+  if (freeExports && freeModule) {
+    // Export for CommonJS support.
+    forOwn(platform, function(value, key) {
+      freeExports[key] = value;
+    });
+  }
+  else {
+    // Export to the global object.
+    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$1 = JSON.parse(JSON.stringify(_platform3.default));
+
+// operating system
+
+// 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$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 = parseFloat(platform$1.version);
+var majorVersion = Math.floor(version);
+platform$1.majorVersion = majorVersion;
+
+platform$1.is = {
+  // operating system
+  ANDROID: ANDROID,
+  WINDOWS: WINDOWS,
+  OSX: OSX,
+  IOS: IOS,
+  // layout
+  BLINK: BLINK, // "Chrome", "Chrome Mobile", "Opera"
+  GECKO: GECKO, // "Firefox"
+  TRIDENT: TRIDENT, // "Internet Explorer"
+  EDGE: EDGE, // "Microsoft Edge"
+  WEBKIT: WEBKIT, // "Safari"
+  // INTERNET EXPLORERS
+  IE9: TRIDENT && majorVersion === 9,
+  IE10: TRIDENT && majorVersion === 10,
+  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
+    activeElement: document.activeElement,
+    // remember scroll positions to restore after test
+    windowScrollTop: window.scrollTop,
+    windowScrollLeft: window.scrollLeft,
+    bodyScrollTop: document.body.scrollTop,
+    bodyScrollLeft: document.body.scrollLeft
+  };
+
+  // wrap tests in an element hidden from screen readers to prevent them
+  // from announcing focus, which can be quite irritating to the user
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('style', 'position:absolute; position:fixed; top:0; left:-2px; width:1px; height:1px; overflow:hidden;');
+  iframe.setAttribute('aria-live', 'off');
+  iframe.setAttribute('aria-busy', 'true');
+  iframe.setAttribute('aria-hidden', 'true');
+  document.body.appendChild(iframe);
+
+  var _window = iframe.contentWindow;
+  var _document = _window.document;
+
+  _document.open();
+  _document.close();
+  var wrapper = _document.createElement('div');
+  _document.body.appendChild(wrapper);
+
+  data.iframe = iframe;
+  data.wrapper = wrapper;
+  data.window = _window;
+  data.document = _document;
+
+  return data;
+}
+
+// options.element:
+//  {string} element name
+//  {function} callback(wrapper, document) to generate an element
+// options.mutate: (optional)
+//  {function} callback(element, wrapper, document) to manipulate element prior to focus-test.
+//             Can return DOMElement to define focus target (default: element)
+// options.validate: (optional)
+//  {function} callback(element, focusTarget, document) to manipulate test-result
+function test(data, options) {
+  // make sure we operate on a clean slate
+  data.wrapper.innerHTML = '';
+  // create dummy element to test focusability of
+  var element = typeof options.element === 'string' ? data.document.createElement(options.element) : options.element(data.wrapper, data.document);
+  // allow callback to further specify dummy element
+  // and optionally define element to focus
+  var focus = options.mutate && options.mutate(element, data.wrapper, data.document);
+  if (!focus && focus !== false) {
+    focus = element;
+  }
+  // element needs to be part of the DOM to be focusable
+  !element.parentNode && data.wrapper.appendChild(element);
+  // test if the element with invalid tabindex can be focused
+  focus && focus.focus && focus.focus();
+  // validate test's result
+  return options.validate ? options.validate(element, focus, data.document) : data.document.activeElement === focus;
+}
+
+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 (_platform2.default.is.IE10) {
+      // IE10 does not redirect focus to <body> when the activeElement is removed
+      document.body.focus();
+    }
+  } else {
+    data.activeElement && data.activeElement.focus && data.activeElement.focus();
+  }
+
+  document.body.removeChild(data.iframe);
+
+  // restore scroll position
+  window.scrollTop = data.windowScrollTop;
+  window.scrollLeft = data.windowScrollLeft;
+  document.body.scrollTop = data.bodyScrollTop;
+  document.body.scrollLeft = data.bodyScrollLeft;
+}
+
+module.exports = exports['default'];
+
+}(detectFocus, detectFocus.exports));
+
+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'];
+
+}(version, version.exports));
+
+(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
+  // even while the document does not have focus
+  var data = void 0;
+
+  try {
+    data = window.localStorage && window.localStorage.getItem(key);
+    data = data ? JSON.parse(data) : {};
+  } catch (e) {
+    data = {};
+  }
+
+  return data;
+} /*
+      Facility to cache test results in localStorage.
+  
+      USAGE:
+        cache.get('key');
+        cache.set('key', 'value');
+   */
+
+function writeLocalStorage(key, value) {
+  if (!document.hasFocus()) {
+    // if the document does not have focus when tests are executed, focus() may
+    // not be handled properly and events may not be dispatched immediately.
+    // This can happen when a document is reloaded while Developer Tools have focus.
+    try {
+      window.localStorage && window.localStorage.removeItem(key);
+    } catch (e) {
+      // ignore
+    }
+
+    return;
+  }
+
+  try {
+    window.localStorage && window.localStorage.setItem(key, JSON.stringify(value));
+  } catch (e) {
+    // ignore
+  }
+}
+
+var userAgent = typeof window !== 'undefined' && window.navigator.userAgent || '';
+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 !== _version2.default) {
+  cache = {};
+}
+
+cache.userAgent = userAgent;
+cache.version = _version2.default;
+
+exports.default = {
+  get: function get() {
+    return cache;
+  },
+  set: function set(values) {
+    Object.keys(values).forEach(function (key) {
+      cache[key] = values[key];
+    });
+
+    cache.time = new Date().toISOString();
+    writeLocalStorage(cacheKey, cache);
+  }
+};
+module.exports = exports['default'];
+
+}(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
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=1117572
+  // https://code.google.com/p/chromium/issues/detail?id=446051
+  try {
+    document.querySelector('html >>> :first-child');
+    combinator = '>>>';
+  } catch (noArrowArrowArrow) {
+    try {
+      // old syntax supported at least up to Chrome 41
+      // https://code.google.com/p/chromium/issues/detail?id=446051
+      document.querySelector('html /deep/ :first-child');
+      combinator = '/deep/';
+    } catch (noDeep) {
+      combinator = '';
+    }
+  }
+
+  return combinator;
+};
+
+module.exports = exports['default'];
+
+}(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
+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="' + _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
+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="' + _gif2.default + '">';
+
+    return false;
+  },
+  validate: function validate(element, focusTarget, _document) {
+    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;
+    }
+
+    var focus = element.querySelector('area');
+    focus.focus();
+    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
+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="' + _gif2.default + '">';
+
+    return element.querySelector('area');
+  },
+  validate: function validate(element, focusTarget, _document) {
+    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;
+    }
+
+    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;
+
+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', _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'];
+
+}(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
+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="' + _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
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    element.setAttribute('tabindex', '-1');
+    element.setAttribute('style', 'display: -webkit-flex; display: -ms-flexbox; display: flex;');
+    element.innerHTML = '<span style="display: block;">hello</span>';
+    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
+exports.default = {
+  element: 'fieldset',
+  mutate: function mutate(element) {
+    element.setAttribute('tabindex', 0);
+    element.setAttribute('disabled', 'disabled');
+  }
+};
+module.exports = exports['default'];
+
+}(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
+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
+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
+exports.default = {
+  element: 'a',
+  mutate: function mutate(element) {
+    element.href = '#void';
+    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
+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="' + _gif2.default + '">';
+
+    return element.querySelector('img');
+  }
+};
+module.exports = exports['default'];
+
+}(focusImgUsemapTabindex, focusImgUsemapTabindex.exports));
+
+var focusInHiddenIframe = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
+  element: function element(wrapper, _document) {
+    var iframe = _document.createElement('iframe');
+
+    // iframe must be part of the DOM before accessing the contentWindow is possible
+    wrapper.appendChild(iframe);
+
+    // create the iframe's default document (<html><head></head><body></body></html>)
+    var iframeDocument = iframe.contentWindow.document;
+    iframeDocument.open();
+    iframeDocument.close();
+    return iframe;
+  },
+  mutate: function mutate(iframe) {
+    iframe.style.visibility = 'hidden';
+
+    var iframeDocument = iframe.contentWindow.document;
+    var input = iframeDocument.createElement('input');
+    iframeDocument.body.appendChild(input);
+    return input;
+  },
+  validate: function validate(iframe) {
+    var iframeDocument = iframe.contentWindow.document;
+    var focus = iframeDocument.querySelector('input');
+    return iframeDocument.activeElement === focus;
+  }
+};
+module.exports = exports['default'];
+
+}(focusInHiddenIframe, focusInHiddenIframe.exports));
+
+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
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    element.setAttribute('tabindex', 'invalid-value');
+  }
+};
+module.exports = exports['default'];
+
+}(focusInvalidTabindex, focusInvalidTabindex.exports));
+
+var focusLabelTabindex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
+  element: 'label',
+  mutate: function mutate(element) {
+    element.setAttribute('tabindex', '-1');
+  },
+  validate: function validate(element, focusTarget, _document) {
+    /* eslint-enable no-unused-vars */
+    element.focus();
+    return _document.activeElement === element;
+  }
+};
+module.exports = exports['default'];
+
+}(focusLabelTabindex, focusLabelTabindex.exports));
+
+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
+
+exports.default = {
+  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');
+    element.style.visibility = 'hidden';
+  }
+};
+module.exports = exports['default'];
+
+}(focusObjectSvgHidden, focusObjectSvgHidden.exports));
+
+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 (_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;
+    }
+
+    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 = !_platform2.default.is.IE9;
+
+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);
+
+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="' + _gif2.default + '">';
+
+    // focus the <img>, not the <div>
+    return element.querySelector('img');
+  },
+  validate: function validate(element, focusTarget, _document) {
+    var target = element.querySelector('area');
+    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
+
+exports.default = {
+  element: 'fieldset',
+  mutate: function mutate(element) {
+    element.innerHTML = '<legend>legend</legend><input tabindex="-1"><input tabindex="0">';
+    // take care of focus in validate();
+    return false;
+  },
+  validate: function validate(element, focusTarget, _document) {
+    var focusable = element.querySelector('input[tabindex="-1"]');
+    var tabbable = element.querySelector('input[tabindex="0"]');
+
+    // Firefox requires this test to focus the <fieldset> first, while this is not necessary in
+    // https://jsbin.com/nenirisage/edit?html,js,console,output
+    element.focus();
+
+    element.querySelector('legend').focus();
+    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
+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>';
+    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
+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
+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));
+
+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'];
+
+}(focusSummary, focusSummary.exports));
+
+var focusSvgFocusableAttribute = {exports: {}};
+
+var svg = {};
+
+var focus_svgForeignObjectHack = {exports: {}};
+
+(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
+  var isSvgElement = element.ownerSVGElement || element.nodeName.toLowerCase() === 'svg';
+  if (!isSvgElement) {
+    return false;
+  }
+
+  // inject and focus an <input> element into the SVG element to receive focus
+  var foreignObject = makeFocusableForeignObject();
+  element.appendChild(foreignObject);
+  var input = foreignObject.querySelector('input');
+  input.focus();
+
+  // upon disabling the activeElement, IE and Edge
+  // will not shift focus to <body> like all the other
+  // browsers, but instead find the first focusable
+  // ancestor and shift focus to that
+  input.disabled = true;
+
+  // 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>';
+}
+
+function focus(element) {
+  if (element.focus) {
+    return;
+  }
+
+  try {
+    HTMLElement.prototype.focus.call(element);
+  } catch (e) {
+    (0, _focus2.default)(element);
+  }
+}
+
+function validate(element, focusTarget, _document) {
+  focus(focusTarget);
+  return _document.activeElement === focusTarget;
+}
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    element.innerHTML = (0, _svg.generate)('<text focusable="true">a</text>');
+    return element.querySelector('text');
+  },
+  validate: _svg.validate
+};
+module.exports = exports['default'];
+
+}(focusSvgFocusableAttribute, focusSvgFocusableAttribute.exports));
+
+var focusSvgTabindexAttribute = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    element.innerHTML = (0, _svg.generate)('<text tabindex="0">a</text>');
+    return element.querySelector('text');
+  },
+  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;
+
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    element.innerHTML = (0, _svg.generate)('<text tabindex="-1">a</text>');
+    return element.querySelector('text');
+  },
+  validate: _svg.validate
+};
+module.exports = exports['default'];
+
+}(focusSvgNegativeTabindexAttribute, focusSvgNegativeTabindexAttribute.exports));
+
+var focusSvgUseTabindex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    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: _svg.validate
+};
+module.exports = exports['default'];
+
+}(focusSvgUseTabindex, focusSvgUseTabindex.exports));
+
+var focusSvgForeignobjectTabindex = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    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: _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 = Boolean(_platform2.default.is.GECKO && typeof SVGElement !== 'undefined' && SVGElement.prototype.focus);
+
+module.exports = exports['default'];
+
+}(focusSvgInIframe, focusSvgInIframe.exports));
+
+var focusSvg = {exports: {}};
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _svg = svg;
+
+exports.default = {
+  element: 'div',
+  mutate: function mutate(element) {
+    element.innerHTML = (0, _svg.generate)('');
+    return element.firstChild;
+  },
+  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
+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) {
+
+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.
+    // https://stackoverflow.com/a/8097055/515124
+    // element.innerHTML = '<tr><td>cell</td></tr>';
+    var fragment = _document.createDocumentFragment();
+    fragment.innerHTML = '<tr><td>cell</td></tr>';
+    element.appendChild(fragment);
+  }
+};
+module.exports = exports['default'];
+
+}(focusTable, focusTable.exports));
+
+var focusVideoWithoutControls = {exports: {}};
+
+var mp4 = {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: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', _mp2.default);
+    } catch (e) {
+      // IE9 may throw "Error: Not implemented"
+    }
+  }
+};
+module.exports = exports['default'];
+
+}(focusVideoWithoutControls, focusVideoWithoutControls.exports));
+
+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: _cssShadowPiercingDeepCombinator2.default,
+  focusInZeroDimensionObject: _focusInZeroDimensionObject2.default,
+  focusObjectSwf: _focusObjectSwf2.default,
+  focusSvgInIframe: _focusSvgInIframe2.default,
+  tabsequenceAreaAtImgPosition: _tabsequenceAreaAtImgPosition2.default
+};
+
+var testDescriptions = {
+  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 = (0, _detectFocus2.default)(testDescriptions);
+  Object.keys(testCallbacks).forEach(function (key) {
+    results[key] = testCallbacks[key]();
+  });
+
+  return results;
+}
+
+var supportsCache$1 = null;
+
+module.exports = exports['default'];
+
+}(supports, supports.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context) {
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
+  }
+
+  var validIntegerPattern = supports$1.focusTabindexTrailingCharacters ? validIntegerPatternWithTrailing : validIntegerPatternNoTrailing;
+
+  var element = (0, _contextToElement2.default)({
+    label: 'is/valid-tabindex',
+    resolveDocument: true,
+    context: context
+  });
+
+  // Edge 14 has a capitalization problem on SVG elements,
+  // see https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/9282058/
+  var hasTabindex = element.hasAttribute('tabindex');
+  var hasTabIndex = element.hasAttribute('tabIndex');
+
+  if (!hasTabindex && !hasTabIndex) {
+    return false;
+  }
+
+  // older Firefox and Internet Explorer don't support tabindex on SVG elements
+  var isSvgElement = element.ownerSVGElement || element.nodeName.toLowerCase() === 'svg';
+  if (isSvgElement && !supports$1.focusSvgTabindexAttribute) {
+    return false;
+  }
+
+  // @browser-issue Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
+  if (supports$1.focusInvalidTabindex) {
+    return true;
+  }
+
+  // an element matches the tabindex selector even if its value is invalid
+  var tabindex = element.getAttribute(hasTabindex ? 'tabindex' : 'tabIndex');
+  // IE11 parses tabindex="" as the value "-32768"
+  // @browser-issue Trident https://connect.microsoft.com/IE/feedback/details/1072965
+  if (tabindex === '-32768') {
+    return false;
+  }
+
+  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]+.*$/;
+
+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;
+  }
+
+  // Edge 14 has a capitalization problem on SVG elements,
+  // see https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/9282058/
+  var hasTabindex = element.hasAttribute('tabindex');
+  var attributeName = hasTabindex ? 'tabindex' : 'tabIndex';
+
+  // @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,
+// as they're implicitly tested by way of the consumers
+
+function isUserModifyWritable(style) {
+  // https://www.w3.org/TR/1999/WD-css3-userint-19990916#user-modify
+  // https://github.com/medialize/ally.js/issues/17
+  var userModify = style.webkitUserModify || '';
+  return Boolean(userModify && userModify.indexOf('write') !== -1);
+}
+
+function hasCssOverflowScroll(style) {
+  return [style.getPropertyValue('overflow'), style.getPropertyValue('overflow-x'), style.getPropertyValue('overflow-y')].some(function (overflow) {
+    return overflow === 'auto' || overflow === 'scroll';
+  });
+}
+
+function hasCssDisplayFlex(style) {
+  return style.display.indexOf('flex') > -1;
+}
+
+function isScrollableContainer(element, nodeName, parentNodeName, parentStyle) {
+  if (nodeName !== 'div' && nodeName !== 'span') {
+    // Internet Explorer advances scrollable containers and bodies to focusable
+    // only if the scrollable container is <div> or <span> - this does *not*
+    // happen for <section>, <article>, …
+    return false;
+  }
+
+  if (parentNodeName && parentNodeName !== 'div' && parentNodeName !== 'span' && !hasCssOverflowScroll(parentStyle)) {
+    return false;
+  }
+
+  return element.offsetHeight < element.scrollHeight || element.offsetWidth < element.scrollWidth;
+}
+
+(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] : {},
+      context = _ref.context,
+      _ref$except = _ref.except,
+      except = _ref$except === undefined ? {
+    flexbox: false,
+    scrollable: false,
+    shadow: false
+  } : _ref$except;
+
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
+  }
+
+  var element = (0, _contextToElement2.default)({
+    label: 'is/focus-relevant',
+    resolveDocument: true,
+    context: context
+  });
+
+  if (!except.shadow && element.shadowRoot) {
+    // a ShadowDOM host receives focus when the focus moves to its content
+    return true;
+  }
+
+  var nodeName = element.nodeName.toLowerCase();
+
+  if (nodeName === 'input' && element.type === 'hidden') {
+    // input[type="hidden"] supports.cannot be focused
+    return false;
+  }
+
+  if (nodeName === 'input' || nodeName === 'select' || nodeName === 'button' || nodeName === 'textarea') {
+    return true;
+  }
+
+  if (nodeName === 'legend' && supports$1.focusRedirectLegend) {
+    // specifics filtered in is/focusable
+    return true;
+  }
+
+  if (nodeName === 'label') {
+    // specifics filtered in is/focusable
+    return true;
+  }
+
+  if (nodeName === 'area') {
+    // specifics filtered in is/focusable
+    return true;
+  }
+
+  if (nodeName === 'a' && element.hasAttribute('href')) {
+    return true;
+  }
+
+  if (nodeName === 'object' && element.hasAttribute('usemap')) {
+    // object[usemap] is not focusable in any browser
+    return false;
+  }
+
+  if (nodeName === 'object') {
+    var svgType = element.getAttribute('type');
+    if (!supports$1.focusObjectSvg && svgType === 'image/svg+xml') {
+      // object[type="image/svg+xml"] is not focusable in Internet Explorer
+      return false;
+    } 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;
+    }
+  }
+
+  if (nodeName === 'iframe' || nodeName === 'object') {
+    // browsing context containers
+    return true;
+  }
+
+  if (nodeName === 'embed' || nodeName === 'keygen') {
+    // embed is considered focus-relevant but not focusable
+    // see https://github.com/medialize/ally.js/issues/82
+    return true;
+  }
+
+  if (element.hasAttribute('contenteditable')) {
+    // also see CSS property user-modify below
+    return true;
+  }
+
+  if (nodeName === 'audio' && (supports$1.focusAudioWithoutControls || element.hasAttribute('controls'))) {
+    return true;
+  }
+
+  if (nodeName === 'video' && (supports$1.focusVideoWithoutControls || element.hasAttribute('controls'))) {
+    return true;
+  }
+
+  if (supports$1.focusSummary && nodeName === 'summary') {
+    return true;
+  }
+
+  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$1.focusImgUsemapTabindex || supports$1.focusRedirectImgUsemap;
+  }
+
+  if (supports$1.focusTable && (nodeName === 'table' || nodeName === 'td')) {
+    // IE10-11 supports.can focus <table> and <td>
+    return true;
+  }
+
+  if (supports$1.focusFieldset && nodeName === 'fieldset') {
+    // IE10-11 supports.can focus <fieldset>
+    return true;
+  }
+
+  var isSvgElement = nodeName === 'svg';
+  var isSvgContent = element.ownerSVGElement;
+  var focusableAttribute = element.getAttribute('focusable');
+  var tabindex = (0, _tabindexValue2.default)(element);
+
+  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$1.focusSvgForeignobjectTabindex;
+  }
+
+  if ((0, _elementMatches2.default)(element, 'svg a') && element.hasAttribute('xlink:href')) {
+    return true;
+  }
+
+  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
+    return false;
+  }
+
+  if (isSvgElement) {
+    return validTabindex || supports$1.focusSvg || supports$1.focusSvgInIframe
+    // Internet Explorer understands the focusable attribute introduced in SVG Tiny 1.2
+    || Boolean(supports$1.focusSvgFocusableAttribute && focusableAttribute && focusableAttribute === 'true');
+  }
+
+  if (isSvgContent) {
+    if (supports$1.focusSvgTabindexAttribute && validTabindex) {
+      return true;
+    }
+
+    if (supports$1.focusSvgFocusableAttribute) {
+      // Internet Explorer understands the focusable attribute introduced in SVG Tiny 1.2
+      return focusableAttribute === 'true';
+    }
+  }
+
+  // https://www.w3.org/TR/html5/editing.html#sequential-focus-navigation-and-the-tabindex-attribute
+  if (validTabindex) {
+    return true;
+  }
+
+  var style = window.getComputedStyle(element, null);
+  if ((0, _is.isUserModifyWritable)(style)) {
+    return true;
+  }
+
+  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 = (0, _parents2.default)({ context: element }).some(function (parent) {
+      return parent.nodeName.toLowerCase() === 'a' && parent.hasAttribute('href');
+    });
+
+    if (hasLinkParent) {
+      return true;
+    }
+  }
+
+  // https://github.com/medialize/ally.js/issues/21
+  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 ((0, _is.isScrollableContainer)(element, nodeName)) {
+        return true;
+      }
+    } 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$1.focusFlexboxContainer && (0, _is.hasCssDisplayFlex)(style)) {
+    // elements with display:flex are focusable in IE10-11
+    return true;
+  }
+
+  var parent = element.parentElement;
+  if (!except.scrollable && parent) {
+    var parentNodeName = parent.nodeName.toLowerCase();
+    var parentStyle = window.getComputedStyle(parent, null);
+    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$1.focusChildrenOfFocusableFlexbox) {
+      if ((0, _is.hasCssDisplayFlex)(parentStyle)) {
+        return true;
+      }
+    }
+  }
+
+  // NOTE: elements marked as inert are not focusable,
+  // but that property is not exposed to the DOM
+  // https://www.w3.org/TR/html5/editing.html#inert
+
+  return false;
+}
+
+// bind exceptions to an iterator callback
+isFocusRelevantRules.except = function () {
+  var except = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var isFocusRelevant = function isFocusRelevant(context) {
+    return isFocusRelevantRules({
+      context: context,
+      except: except
+    });
+  };
+
+  isFocusRelevant.rules = isFocusRelevantRules;
+  return isFocusRelevant;
+};
+
+// 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) {
+    return array.findIndex(callback);
+  }
+
+  var length = array.length;
+
+  // shortcut if the array is empty
+  if (length === 0) {
+    return -1;
+  }
+
+  // otherwise loop over array
+  for (var i = 0; i < length; i++) {
+    if (callback(array[i], i, array)) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+module.exports = exports["default"];
+
+}(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
+    // works on <object> and <iframe>
+    || node.contentWindow && node.contentWindow.document
+    // works on <object> and <iframe> that contain SVG
+    || node.getSVGDocument && node.getSVGDocument() || null;
+  } catch (e) {
+    // SecurityError: Failed to read the 'contentDocument' property from 'HTMLObjectElement'
+    // also IE may throw member not found exception e.g. on <object type="image/png">
+    return null;
+  }
+};
+
+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;
+  }
+
+  if (node.nodeType === Node.DOCUMENT_NODE) {
+    return node;
+  }
+
+  return node.ownerDocument || document;
+};
+
+module.exports = exports["default"];
+
+}(getDocument, getDocument.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (node) {
+  var _document = (0, _getDocument2.default)(node);
+  return _document.defaultView || window;
+};
+
+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
+});
+
+exports.default = function (selector) {
+  if (typeof shadowPrefix !== 'string') {
+    var operator = (0, _cssShadowPiercingDeepCombinator2.default)();
+    if (operator) {
+      shadowPrefix = ', html ' + operator + ' ';
+    }
+  }
+
+  if (!shadowPrefix) {
+    return 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 = (0, _selectInShadows2.default)('object, iframe');
+  }
+
+  if (_window._frameElement !== undefined) {
+    return _window._frameElement;
+  }
+
+  _window._frameElement = null;
+
+  var potentialHosts = _window.parent.document.querySelectorAll(selector);
+  [].some.call(potentialHosts, function (element) {
+    var _document = (0, _getContentDocument2.default)(element);
+    if (_document !== _window.document) {
+      return false;
+    }
+
+    _window._frameElement = element;
+    return true;
+  });
+
+  return _window._frameElement;
+}
+
+function getFrameElement(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
+    return null;
+  }
+
+  try {
+    // see https://developer.mozilla.org/en-US/docs/Web/API/Window/frameElement
+    // does not work within <embed> anywhere, and not within in <object> in IE
+    return _window.frameElement || findDocumentHostElement(_window);
+  } catch (e) {
+    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) {
+  return window.getComputedStyle(element, null).getPropertyValue(property);
+}
+
+function notDisplayed(_path) {
+  return _path.some(function (element) {
+    // display:none is not visible (optimized away at layout)
+    return computedStyle(element, 'display') === 'none';
+  });
+}
+
+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 = (0, _arrayFindIndex2.default)(_path, function (element) {
+    var visibility = computedStyle(element, 'visibility');
+    return visibility === 'hidden' || visibility === 'collapse';
+  });
+
+  if (hidden === -1) {
+    // there is no hidden element
+    return false;
+  }
+
+  var visible = (0, _arrayFindIndex2.default)(_path, function (element) {
+    return computedStyle(element, 'visibility') === 'visible';
+  });
+
+  if (visible === -1) {
+    // there is no visible element (but a hidden element)
+    return true;
+  }
+
+  if (hidden < visible) {
+    // there is a hidden element and it's closer than the first visible element
+    return true;
+  }
+
+  // there may be a hidden element, but the closest element is visible
+  return false;
+}
+
+function collapsedParent(_path) {
+  var offset = 1;
+  if (_path[0].nodeName.toLowerCase() === 'summary') {
+    offset = 2;
+  }
+
+  return _path.slice(offset).some(function (element) {
+    // "content children" of a closed details element are not visible
+    return element.nodeName.toLowerCase() === 'details' && element.open === false;
+  });
+}
+
+function isVisibleRules() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      context = _ref.context,
+      _ref$except = _ref.except,
+      except = _ref$except === undefined ? {
+    notRendered: false,
+    cssDisplay: false,
+    cssVisibility: false,
+    detailsElement: false,
+    browsingContext: false
+  } : _ref$except;
+
+  var element = (0, _contextToElement2.default)({
+    label: 'is/visible',
+    resolveDocument: true,
+    context: context
+  });
+
+  var nodeName = element.nodeName.toLowerCase();
+  if (!except.notRendered && notRenderedElementsPattern.test(nodeName)) {
+    return true;
+  }
+
+  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>
+  // this is irrelevant to other browsers, as the controls attribute is required to make <audio> focusable
+  var isAudioWithoutControls = nodeName === 'audio' && !element.hasAttribute('controls');
+  if (!except.cssDisplay && notDisplayed(isAudioWithoutControls ? _path.slice(1) : _path)) {
+    return false;
+  }
+
+  if (!except.cssVisibility && notVisible(_path)) {
+    return false;
+  }
+
+  if (!except.detailsElement && collapsedParent(_path)) {
+    return false;
+  }
+
+  if (!except.browsingContext) {
+    // elements within a browsing context are affected by the
+    // browsing context host element's visibility and tabindex
+    var frameElement = (0, _getFrameElement2.default)(element);
+    var _isVisible = isVisibleRules.except(except);
+    if (frameElement && !_isVisible(frameElement)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// bind exceptions to an iterator callback
+isVisibleRules.except = function () {
+  var except = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var isVisible = function isVisible(context) {
+    return isVisibleRules({
+      context: context,
+      except: except
+    });
+  };
+
+  isVisible.rules = isVisibleRules;
+  return isVisible;
+};
+
+// provide isVisible(context) as default iterator callback
+var isVisible = isVisibleRules.except({});
+exports.default = isVisible;
+module.exports = exports['default'];
+
+}(visible, visible.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
+	{
+		// For Node.js.
+		module.exports = factory(root);
+	}
+}(typeof commonjsGlobal != 'undefined' ? commonjsGlobal : commonjsGlobal, function(root) {
+
+	if (root.CSS && root.CSS.escape) {
+		return root.CSS.escape;
+	}
+
+	// https://drafts.csswg.org/cssom/#serialize-an-identifier
+	var cssEscape = function(value) {
+		if (arguments.length == 0) {
+			throw new TypeError('`CSS.escape` requires an argument.');
+		}
+		var string = String(value);
+		var length = string.length;
+		var index = -1;
+		var codeUnit;
+		var result = '';
+		var firstCodeUnit = string.charCodeAt(0);
+		while (++index < length) {
+			codeUnit = string.charCodeAt(index);
+			// Note: there’s no need to special-case astral symbols, surrogate
+			// pairs, or lone surrogates.
+
+			// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+			// (U+FFFD).
+			if (codeUnit == 0x0000) {
+				result += '\uFFFD';
+				continue;
+			}
+
+			if (
+				// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+				// U+007F, […]
+				(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
+				// If the character is the first character and is in the range [0-9]
+				// (U+0030 to U+0039), […]
+				(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+				// If the character is the second character and is in the range [0-9]
+				// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+				(
+					index == 1 &&
+					codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
+					firstCodeUnit == 0x002D
+				)
+			) {
+				// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+				result += '\\' + codeUnit.toString(16) + ' ';
+				continue;
+			}
+
+			if (
+				// If the character is the first character and is a `-` (U+002D), and
+				// there is no second character, […]
+				index == 0 &&
+				length == 1 &&
+				codeUnit == 0x002D
+			) {
+				result += '\\' + string.charAt(index);
+				continue;
+			}
+
+			// If the character is not handled by one of the above rules and is
+			// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+			// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+			// U+005A), or [a-z] (U+0061 to U+007A), […]
+			if (
+				codeUnit >= 0x0080 ||
+				codeUnit == 0x002D ||
+				codeUnit == 0x005F ||
+				codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
+				codeUnit >= 0x0041 && codeUnit <= 0x005A ||
+				codeUnit >= 0x0061 && codeUnit <= 0x007A
+			) {
+				// the character itself
+				result += string.charAt(index);
+				continue;
+			}
+
+			// Otherwise, the escaped character.
+			// https://drafts.csswg.org/cssom/#escape-a-character
+			result += '\\' + string.charAt(index);
+
+		}
+		return result;
+	};
+
+	if (!root.CSS) {
+		root.CSS = {};
+	}
+
+	root.CSS.escape = cssEscape;
+	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;
+
+  if (!map.name || map.nodeName.toLowerCase() !== 'map') {
+    return null;
+  }
+
+  // NOTE: image maps can also be applied to <object> with image content,
+  // but no browser supports this at the moment
+
+  // HTML5 specifies HTMLMapElement.images to be an HTMLCollection of all
+  // <img> and <object> referencing the <map> element, but no browser implements this
+  //   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 = (0, _getDocument2.default)(element);
+  return _document.querySelector('img[usemap="#' + (0, _css2.default)(map.name) + '"]') || null;
+}
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context) {
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
+  }
+
+  var element = (0, _contextToElement2.default)({
+    label: 'is/valid-area',
+    context: context
+  });
+
+  var nodeName = element.nodeName.toLowerCase();
+  if (nodeName !== 'area') {
+    return false;
+  }
+
+  var hasTabindex = element.hasAttribute('tabindex');
+  if (!supports$1.focusAreaTabindex && hasTabindex) {
+    // Blink and WebKit do not consider <area tabindex="-1" href="#void"> focusable
+    return false;
+  }
+
+  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$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$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$1.focusAreaTabindex && hasTabindex || supports$1.focusAreaImgTabindex && img.hasAttribute('tabindex');
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
+  var childOfInteractive = (0, _parents2.default)({ context: img }).slice(1).some(function (_element) {
+    var name = _element.nodeName.toLowerCase();
+    return name === 'button' || name === 'a';
+  });
+
+  if (childOfInteractive) {
+    return false;
+  }
+
+  return true;
+};
+
+var _contextToElement = contextToElement.exports;
+
+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;
+
+// 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: {}};
+
+(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$1.focusFormDisabled) {
+      delete disabledElements.form;
+    }
+
+    disabledElementsPattern = new RegExp('^(' + Object.keys(disabledElements).join('|') + ')$');
+  }
+
+  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;
+
+// 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
+};
+
+module.exports = exports['default'];
+
+}(nativeDisabledSupported, nativeDisabledSupported.exports));
+
+(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (context) {
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
+  }
+
+  var element = (0, _contextToElement2.default)({
+    label: 'is/disabled',
+    context: context
+  });
+
+  if (element.hasAttribute('data-ally-disabled')) {
+    // treat ally's element/disabled like the DOM native element.disabled
+    return true;
+  }
+
+  if (!(0, _nativeDisabledSupported2.default)(element)) {
+    // non-form elements do not support the disabled attribute
+    return false;
+  }
+
+  if (element.disabled) {
+    // the element itself is disabled
+    return true;
+  }
+
+  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;
+  }
+
+  if (!supports$1.focusFormDisabled && parents.some(isDisabledForm)) {
+    // a parental <form> is disabld and inherits the state onto this element
+    return true;
+  }
+
+  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,
+      _ref$except = _ref.except,
+      except = _ref$except === undefined ? {
+    onlyFocusableBrowsingContext: false,
+    visible: false
+  } : _ref$except;
+
+  var element = (0, _contextToElement2.default)({
+    label: 'is/only-tabbable',
+    resolveDocument: true,
+    context: context
+  });
+
+  if (!except.visible && !(0, _visible2.default)(element)) {
+    return false;
+  }
+
+  if (!except.onlyFocusableBrowsingContext && (_platform2.default.is.GECKO || _platform2.default.is.TRIDENT || _platform2.default.is.EDGE)) {
+    var frameElement = (0, _getFrameElement2.default)(element);
+    if (frameElement) {
+      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;
+      }
+    }
+  }
+
+  var nodeName = element.nodeName.toLowerCase();
+  var tabindex = (0, _tabindexValue2.default)(element);
+
+  if (nodeName === 'label' && _platform2.default.is.GECKO) {
+    // Firefox cannot focus, but tab to: label[tabindex=0]
+    return tabindex !== null && tabindex >= 0;
+  }
+
+  // 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 (_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 (_platform2.default.is.GECKO) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// bind exceptions to an iterator callback
+isOnlyTabbableRules.except = function () {
+  var except = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var isOnlyTabbable = function isOnlyTabbable(context) {
+    return isOnlyTabbableRules({
+      context: context,
+      except: except
+    });
+  };
+
+  isOnlyTabbable.rules = isOnlyTabbableRules;
+  return isOnlyTabbable;
+};
+
+// 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 _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();
+  if (nodeName === 'embed' || nodeName === 'keygen') {
+    // embed is considered focus-relevant but not focusable
+    // see https://github.com/medialize/ally.js/issues/82
+    return true;
+  }
+
+  var _tabindex = (0, _tabindexValue2.default)(element);
+  if (element.shadowRoot && _tabindex === null) {
+    // ShadowDOM host elements *may* receive focus
+    // even though they are not considered focuable
+    return true;
+  }
+
+  if (nodeName === 'label') {
+    // <label tabindex="0"> is only tabbable in Firefox, not script-focusable
+    // 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$1.focusLabelTabindex || _tabindex === null;
+  }
+
+  if (nodeName === 'legend') {
+    return _tabindex === null;
+  }
+
+  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';
+  }
+
+  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$1.focusImgUsemapTabindex;
+  }
+
+  if (nodeName === 'area') {
+    // all <area>s are considered relevant,
+    // but only the valid <area>s are focusable
+    return !(0, _validArea2.default)(element);
+  }
+
+  return false;
+}
+
+function isFocusableRules() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      context = _ref.context,
+      _ref$except = _ref.except,
+      except = _ref$except === undefined ? {
+    disabled: false,
+    visible: false,
+    onlyTabbable: false
+  } : _ref$except;
+
+  if (!supports$1) {
+    supports$1 = (0, _supports3.default)();
+  }
+
+  var _isOnlyTabbable = _onlyTabbable2.default.rules.except({
+    onlyFocusableBrowsingContext: true,
+    visible: except.visible
+  });
+
+  var element = (0, _contextToElement2.default)({
+    label: 'is/focusable',
+    resolveDocument: true,
+    context: context
+  });
+
+  var focusRelevant = _focusRelevant2.default.rules({
+    context: element,
+    except: except
+  });
+
+  if (!focusRelevant || isOnlyFocusRelevant(element)) {
+    return false;
+  }
+
+  if (!except.disabled && (0, _disabled2.default)(element)) {
+    return false;
+  }
+
+  if (!except.onlyTabbable && _isOnlyTabbable(element)) {
+    // some elements may be keyboard focusable, but not script focusable
+    return false;
+  }
+
+  // elements that are not rendered, cannot be focused
+  if (!except.visible) {
+    var visibilityOptions = {
+      context: element,
+      except: {}
+    };
+
+    if (supports$1.focusInHiddenIframe) {
+      // WebKit and Blink can focus content in hidden <iframe> and <object>
+      visibilityOptions.except.browsingContext = true;
+    }
+
+    if (supports$1.focusObjectSvgHidden) {
+      // Blink allows focusing the object element, even if it has visibility: hidden;
+      // @browser-issue Blink https://code.google.com/p/chromium/issues/detail?id=586191
+      var _nodeName2 = element.nodeName.toLowerCase();
+      if (_nodeName2 === 'object') {
+        visibilityOptions.except.cssVisibility = true;
+      }
+    }
+
+    if (!_visible2.default.rules(visibilityOptions)) {
+      return false;
+    }
+  }
+
+  var frameElement = (0, _getFrameElement2.default)(element);
+  if (frameElement) {
+    var _nodeName = frameElement.nodeName.toLowerCase();
+    if (_nodeName === 'object' && !supports$1.focusInZeroDimensionObject) {
+      if (!frameElement.offsetWidth || !frameElement.offsetHeight) {
+        // WebKit can not focus content in <object> if it doesn't have dimensions
+        return false;
+      }
+    }
+  }
+
+  var nodeName = element.nodeName.toLowerCase();
+  if (nodeName === 'svg' && supports$1.focusSvgInIframe && !frameElement && element.getAttribute('tabindex') === null) {
+    return false;
+  }
+
+  return true;
+}
+
+// bind exceptions to an iterator callback
+isFocusableRules.except = function () {
+  var except = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var isFocusable = function isFocusable(context) {
+    return isFocusableRules({
+      context: context,
+      except: except
+    });
+  };
+
+  isFocusable.rules = isFocusableRules;
+  return isFocusable;
+};
+
+// provide isFocusRelevant(context) as default iterator callback
+var isFocusable = isFocusableRules.except({});
+exports.default = isFocusable;
+module.exports = exports['default'];
+
+}(focusable, focusable.exports));
+
+const isFocusable = /*@__PURE__*/getDefaultExportFromCjs(focusable.exports);
+
+const postTooltipTriggerCss = "post-tooltip-trigger{vertical-align:top}";
+const PostTooltipTriggerStyle0 = postTooltipTriggerCss;
+
+const TRIGGER_EVENTS = ['pointerenter', 'pointerleave', 'focusin', 'focusout', 'long-press'];
+const PostTooltipTrigger = /*@__PURE__*/ proxyCustomElement(class PostTooltipTrigger extends HTMLElement$1 {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        /**
+         * Reference to the element inside the host that will act as the trigger.
+         */
+        this.trigger = null;
+        /**
+         * Timeout ID for the delay.
+         */
+        this.delayTimeout = null;
+        this.for = undefined;
+        this.delay = 0;
+        this.boundTriggerHandler = this.handleTriggerEvent.bind(this);
+        this.boundTooltipHandler = this.handleTooltipEvent.bind(this);
+    }
+    validateControlFor() {
+        checkType(this.for, // The actual property value
+        'string', // The expected type
+        'The "for" property must be a string' // A meaningful error message
+        );
+    }
+    get tooltip() {
+        const ref = document.getElementById(this.for);
+        return (ref === null || ref === void 0 ? void 0 : ref.localName) === 'post-tooltip'
+            ? ref
+            : null;
+    }
+    componentDidLoad() {
+        this.setupTrigger();
+        this.attachListeners();
+        this.attachTooltipListeners();
+    }
+    disconnectedCallback() {
+        this.removeListeners();
+        this.removeTooltipListeners();
+        this.cleanupTrigger();
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
+    }
+    handleSlotChange() {
+        this.cleanupTrigger();
+        this.setupTrigger();
+    }
+    cleanupTrigger() {
+        if (this.trigger) {
+            const describedBy = this.trigger.getAttribute('aria-describedby') || '';
+            if (describedBy.includes(this.for)) {
+                const newDescribedBy = describedBy
+                    .split(' ')
+                    .filter(id => id !== this.for)
+                    .join(' ');
+                if (newDescribedBy) {
+                    this.trigger.setAttribute('aria-describedby', newDescribedBy);
+                }
+                else {
+                    this.trigger.removeAttribute('aria-describedby');
+                }
+            }
+            this.trigger = null;
+        }
+    }
+    setupTrigger() {
+        this.trigger = this.host.querySelector('*');
+        if (this.trigger) {
+            if (!isFocusable(this.trigger)) {
+                this.trigger.setAttribute('tabindex', '0');
+            }
+            const describedBy = this.trigger.getAttribute('aria-describedby') || '';
+            if (!describedBy.includes(this.for)) {
+                this.trigger.setAttribute('aria-describedby', `${describedBy} ${this.for}`.trim());
+            }
+        }
+        else {
+            console.warn('No content found in the post-tooltip-trigger slot. Please insert a focusable element or content that can receive focus.');
+        }
+    }
+    attachListeners() {
+        TRIGGER_EVENTS.forEach(event => {
+            this.host.addEventListener(event, this.boundTriggerHandler);
+        });
+    }
+    removeListeners() {
+        TRIGGER_EVENTS.forEach(event => {
+            this.host.removeEventListener(event, this.boundTriggerHandler);
+        });
+    }
+    attachTooltipListeners() {
+        if (this.tooltip) {
+            this.tooltip.addEventListener('pointerenter', this.boundTooltipHandler);
+            this.tooltip.addEventListener('pointerleave', this.boundTooltipHandler);
+        }
+    }
+    removeTooltipListeners() {
+        if (this.tooltip) {
+            this.tooltip.removeEventListener('pointerenter', this.boundTooltipHandler);
+            this.tooltip.removeEventListener('pointerleave', this.boundTooltipHandler);
+        }
+    }
+    handleTriggerEvent(event) {
+        switch (event.type) {
+            case 'pointerenter':
+            case 'focusin':
+            case 'long-press':
+                this.handleEnter();
+                break;
+            case 'pointerleave':
+            case 'focusout':
+                this.handleLeave(event);
+                break;
+        }
+    }
+    handleTooltipEvent(event) {
+        switch (event.type) {
+            case 'pointerenter':
+                this.handleEnter();
+                break;
+            case 'pointerleave':
+                this.handleLeave(event);
+                break;
+        }
+    }
+    handleEnter() {
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
+        this.interestHandler();
+    }
+    handleLeave(event) {
+        const newTarget = event.relatedTarget;
+        if ((this.tooltip && newTarget && this.tooltip.contains(newTarget)) ||
+            (newTarget === this.trigger)) {
+            return;
+        }
+        this.interestLostHandler();
+    }
+    interestHandler() {
+        var _a;
+        if (this.delay > 0) {
+            this.delayTimeout = window.setTimeout(() => {
+                var _a;
+                (_a = this.tooltip) === null || _a === void 0 ? void 0 : _a.show(this.trigger);
+                this.delayTimeout = null;
+            }, this.delay);
+        }
+        else {
+            (_a = this.tooltip) === null || _a === void 0 ? void 0 : _a.show(this.trigger);
+        }
+    }
+    interestLostHandler() {
+        var _a;
+        if (this.delayTimeout) {
+            clearTimeout(this.delayTimeout);
+            this.delayTimeout = null;
+        }
+        (_a = this.tooltip) === null || _a === void 0 ? void 0 : _a.hide();
+    }
+    render() {
+        return (h(Host, { key: 'a37c76972c4db24292fa95ddacf097055dea70f0', "data-version": version$1 }, h("slot", { key: '51de3cd7dedfc1c5fe5ef86fbf0ab953d07945cb', onSlotchange: () => this.handleSlotChange() })));
+    }
+    get host() { return this; }
+    static get watchers() { return {
+        "for": ["validateControlFor"]
+    }; }
+    static get style() { return PostTooltipTriggerStyle0; }
+}, [1, "post-tooltip-trigger", {
+        "for": [513],
+        "delay": [2]
+    }, undefined, {
+        "for": ["validateControlFor"]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["post-tooltip-trigger"];
+    components.forEach(tagName => { switch (tagName) {
+        case "post-tooltip-trigger":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, PostTooltipTrigger);
+            }
+            break;
+    } });
+}
+
+export { PostTooltipTrigger as P, defineCustomElement as d };