+ {hasMultipleErrors ? `Multiple` : `One`} unhandled GraphQL{` `}
+ {hasMultipleErrors ? `errors` : `error`} found in your files. See the
+ list below to fix {hasMultipleErrors ? `them` : `it`}:
+
+ {hasMultipleErrors ? `Multiple` : `One`} unhandled runtime{` `}
+ {hasMultipleErrors ? `errors` : `error`} found in your files. See the
+ list below to fix {hasMultipleErrors ? `them` : `it`}:
+
+
+ {deduplicatedErrors.map((error, index) => (
+
+ ))}
+
+
+
+ )
+}
diff --git a/packages/gatsby/cache-dir/fast-refresh-overlay/components/style.js b/packages/gatsby/cache-dir/fast-refresh-overlay/components/style.js
deleted file mode 100644
index d7bdf8ec5d65d..0000000000000
--- a/packages/gatsby/cache-dir/fast-refresh-overlay/components/style.js
+++ /dev/null
@@ -1,170 +0,0 @@
-import React from "react"
-
-function css(strings, ...keys) {
- const lastIndex = strings.length - 1
- return (
- strings.slice(0, lastIndex).reduce((p, s, i) => p + s + keys[i], ``) +
- strings[lastIndex]
- )
-}
-
-const Style = () => (
-
-)
-
-export default Style
diff --git a/packages/gatsby/cache-dir/fast-refresh-overlay/components/use-id.js b/packages/gatsby/cache-dir/fast-refresh-overlay/components/use-id.js
new file mode 100644
index 0000000000000..cb8ee81d03f9f
--- /dev/null
+++ b/packages/gatsby/cache-dir/fast-refresh-overlay/components/use-id.js
@@ -0,0 +1,56 @@
+// Copied from https://github.com/carbon-design-system/carbon
+// License: Apache-2.0
+// Copyright IBM Corp. 2016, 2018
+// Entrypoint: packages/react/src/internal/useId.js
+
+function setupGetInstanceId() {
+ let instanceId = 0
+ return function getInstanceId() {
+ return ++instanceId
+ }
+}
+
+import * as React from "react"
+
+const getId = setupGetInstanceId()
+const useIsomorphicLayoutEffect = canUseDOM()
+ ? React.useLayoutEffect
+ : React.useEffect
+
+function canUseDOM() {
+ return !!(
+ typeof window !== `undefined` &&
+ window.document &&
+ window.document.createElement
+ )
+}
+
+let serverHandoffCompleted = false
+
+/**
+ * Generate a unique ID with an optional prefix prepended to it
+ * @param {string} [prefix]
+ * @returns {string}
+ */
+export function useId(prefix = `id`) {
+ const [id, setId] = React.useState(() => {
+ if (serverHandoffCompleted) {
+ return `${prefix}-${getId()}`
+ }
+ return null
+ })
+
+ useIsomorphicLayoutEffect(() => {
+ if (id === null) {
+ setId(`${prefix}-${getId()}`)
+ }
+ }, [getId])
+
+ React.useEffect(() => {
+ if (serverHandoffCompleted === false) {
+ serverHandoffCompleted = true
+ }
+ }, [])
+
+ return id
+}
diff --git a/packages/gatsby/cache-dir/fast-refresh-overlay/helpers/focus-trap.js b/packages/gatsby/cache-dir/fast-refresh-overlay/helpers/focus-trap.js
new file mode 100644
index 0000000000000..d5efab2b0932c
--- /dev/null
+++ b/packages/gatsby/cache-dir/fast-refresh-overlay/helpers/focus-trap.js
@@ -0,0 +1,3561 @@
+/* eslint-disable */
+// Adapted from https://github.com/medialize/ally.js
+// License: MIT
+// Copyright (c) 2015 Rodney Rehm
+//
+// Entrypoint: ally.js/maintain/tab-focus
+
+import _platform from 'platform'
+import cssEscape from 'css.escape'
+
+// input may be undefined, selector-tring, Node, NodeList, HTMLCollection, array of Nodes
+// yes, to some extent this is a bad replica of jQuery's constructor function
+function nodeArray(input) {
+ 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))
+}
+
+function contextToElement(_ref) {
+ var context = _ref.context,
+ _ref$label = _ref.label,
+ label = _ref$label === undefined ? 'context-to-element' : _ref$label,
+ resolveDocument = _ref.resolveDocument,
+ defaultToDocument = _ref.defaultToDocument
+
+ var element = nodeArray(context)[0]
+
+ 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
+}
+
+function getShadowHost() {
+ var _ref =
+ arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+ context = _ref.context
+
+ var element = contextToElement({
+ label: 'get/shadow-host',
+ context: context,
+ })
+
+ // walk up to the root
+ var container = null
+
+ while (element) {
+ container = element
+ element = element.parentNode
+ }
+
+ // https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeType
+ // NOTE: Firefox 34 does not expose ShadowRoot.host (but 37 does)
+ if (
+ container.nodeType === container.DOCUMENT_FRAGMENT_NODE &&
+ container.host
+ ) {
+ // the root is attached to a fragment node that has a host
+ return container.host
+ }
+
+ return null
+}
+
+function getDocument(node) {
+ if (!node) {
+ return document
+ }
+
+ if (node.nodeType === Node.DOCUMENT_NODE) {
+ return node
+ }
+
+ return node.ownerDocument || document
+}
+
+function isActiveElement(context) {
+ var element = contextToElement({
+ label: 'is/active-element',
+ resolveDocument: true,
+ context: context,
+ })
+
+ var _document = getDocument(element)
+ if (_document.activeElement === element) {
+ return true
+ }
+
+ var shadowHost = getShadowHost({ context: element })
+ if (shadowHost && shadowHost.shadowRoot.activeElement === element) {
+ return true
+ }
+
+ return false
+}
+
+// [elem, elem.parent, elem.parent.parent, …, html]
+// will not contain the shadowRoot (DOCUMENT_FRAGMENT_NODE) and shadowHost
+function getParents() {
+ var _ref =
+ arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+ context = _ref.context
+
+ var list = []
+ var element = contextToElement({
+ 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
+}
+
+// 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)
+}
+
+// deep clone of original platform
+var platform = JSON.parse(JSON.stringify(_platform))
+
+// operating system
+var os = platform.os.family || ''
+var ANDROID = os === 'Android'
+var WINDOWS = os.slice(0, 7) === 'Windows'
+var OSX = os === 'OS X'
+var IOS = os === 'iOS'
+
+// layout
+var BLINK = platform.layout === 'Blink'
+var GECKO = platform.layout === 'Gecko'
+var TRIDENT = platform.layout === 'Trident'
+var EDGE = platform.layout === 'EdgeHTML'
+var WEBKIT = platform.layout === 'WebKit'
+
+// browser version (not layout engine version!)
+var version = parseFloat(platform.version)
+var majorVersion = Math.floor(version)
+platform.majorVersion = majorVersion
+
+platform.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,
+}
+
+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 (platform.is.IE10) {
+ // IE10 does not redirect focus to 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
+}
+
+function detectFocus(tests) {
+ var data = before()
+
+ var results = {}
+ Object.keys(tests).map(function (key) {
+ results[key] = test(data, tests[key])
+ })
+
+ after(data)
+ return results
+}
+
+// this file is overwritten by `npm run build:pre`
+var version$1 = '1.4.1'
+
+/*
+ Facility to cache test results in localStorage.
+
+ USAGE:
+ cache.get('key');
+ cache.set('key', 'value');
+ */
+
+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
+}
+
+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 !== version$1) {
+ cache = {}
+}
+
+cache.userAgent = userAgent
+cache.version = version$1
+
+var cache$1 = {
+ 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)
+ },
+}
+
+function cssShadowPiercingDeepCombinator() {
+ 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
+}
+
+var gif =
+ 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'
+
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
+var focusAreaImgTabindex = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.innerHTML =
+ '' +
+ ''
+
+ return element.querySelector('area')
+ },
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
+var focusAreaTabindex = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.innerHTML =
+ '' +
+ ''
+
+ return false
+ },
+ validate: function validate(element, focusTarget, _document) {
+ if (platform.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
+ },
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
+var focusAreaWithoutHref = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.innerHTML =
+ '' +
+ ''
+
+ return element.querySelector('area')
+ },
+ validate: function validate(element, focusTarget, _document) {
+ if (platform.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
+ },
+}
+
+var focusAudioWithoutControls = {
+ name: 'can-focus-audio-without-controls',
+ element: 'audio',
+ mutate: function mutate(element) {
+ try {
+ // invalid media file can trigger warning in console, data-uri to prevent HTTP request
+ element.setAttribute('src', gif)
+ } catch (e) {
+ // IE9 may throw "Error: Not implemented"
+ }
+ },
+}
+
+var invalidGif =
+ 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ'
+
+// NOTE: https://github.com/medialize/ally.js/issues/35
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
+var focusBrokenImageMap = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.innerHTML =
+ '' +
+ ''
+
+ return element.querySelector('area')
+ },
+}
+
+// Children of focusable elements with display:flex are focusable in IE10-11
+var focusChildrenOfFocusableFlexbox = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.setAttribute('tabindex', '-1')
+ element.setAttribute(
+ 'style',
+ 'display: -webkit-flex; display: -ms-flexbox; display: flex;'
+ )
+ element.innerHTML = 'hello'
+ return element.querySelector('span')
+ },
+}
+
+// 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
+var focusFieldsetDisabled = {
+ element: 'fieldset',
+ mutate: function mutate(element) {
+ element.setAttribute('tabindex', 0)
+ element.setAttribute('disabled', 'disabled')
+ },
+}
+
+var focusFieldset = {
+ element: 'fieldset',
+ mutate: function mutate(element) {
+ element.innerHTML = '
content
'
+ },
+}
+
+// elements with display:flex are focusable in IE10-11
+var focusFlexboxContainer = {
+ element: 'span',
+ mutate: function mutate(element) {
+ element.setAttribute(
+ 'style',
+ 'display: -webkit-flex; display: -ms-flexbox; display: flex;'
+ )
+ element.innerHTML = 'hello'
+ },
+}
+
+// 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
+var focusFormDisabled = {
+ element: 'form',
+ mutate: function mutate(element) {
+ element.setAttribute('tabindex', 0)
+ element.setAttribute('disabled', 'disabled')
+ },
+}
+
+// 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
+var focusImgIsmap = {
+ element: 'a',
+ mutate: function mutate(element) {
+ element.href = '#void'
+ element.innerHTML = ''
+ return element.querySelector('img')
+ },
+}
+
+// NOTE: https://github.com/medialize/ally.js/issues/35
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#attr-usemap
+var focusImgUsemapTabindex = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.innerHTML =
+ '' +
+ ''
+
+ return element.querySelector('img')
+ },
+}
+
+var focusInHiddenIframe = {
+ 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 ()
+ 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
+ },
+}
+
+var result = !platform.is.WEBKIT
+
+function focusInZeroDimensionObject() {
+ return result
+}
+
+// Firefox allows *any* value and treats invalid values like tabindex="-1"
+// @browser-issue Gecko https://bugzilla.mozilla.org/show_bug.cgi?id=1128054
+var focusInvalidTabindex = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.setAttribute('tabindex', 'invalid-value')
+ },
+}
+
+var focusLabelTabindex = {
+ element: 'label',
+ mutate: function mutate(element) {
+ element.setAttribute('tabindex', '-1')
+ },
+ validate: function validate(element, focusTarget, _document) {
+ // force layout in Chrome 49, otherwise the element won't be focusable
+ /* eslint-disable no-unused-vars */
+ var variableToPreventDeadCodeElimination = element.offsetHeight
+ /* eslint-enable no-unused-vars */
+ element.focus()
+ return _document.activeElement === element
+ },
+}
+
+var svg =
+ 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtb' +
+ 'G5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiBpZD0ic3ZnIj48dGV4dCB4PSIxMCIgeT0iMjAiIGlkPSJ' +
+ 'zdmctbGluay10ZXh0Ij50ZXh0PC90ZXh0Pjwvc3ZnPg=='
+
+// Note: IE10 on BrowserStack does not like this test
+
+var focusObjectSvgHidden = {
+ element: 'object',
+ mutate: function mutate(element) {
+ element.setAttribute('type', 'image/svg+xml')
+ element.setAttribute('data', svg)
+ element.setAttribute('width', '200')
+ element.setAttribute('height', '50')
+ element.style.visibility = 'hidden'
+ },
+}
+
+// Note: IE10 on BrowserStack does not like this test
+
+var focusObjectSvg = {
+ name: 'can-focus-object-svg',
+ element: 'object',
+ mutate: function mutate(element) {
+ element.setAttribute('type', 'image/svg+xml')
+ element.setAttribute('data', svg)
+ element.setAttribute('width', '200')
+ element.setAttribute('height', '50')
+ },
+ validate: function validate(element, focusTarget, _document) {
+ if (platform.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
+ },
+}
+
+// Every Environment except IE9 considers SWF objects focusable
+var result$1 = !platform.is.IE9
+
+function focusObjectSwf() {
+ return result$1
+}
+
+var focusRedirectImgUsemap = {
+ element: 'div',
+ mutate: function mutate(element) {
+ element.innerHTML =
+ '' +
+ ''
+
+ // focus the , not the
+ return element.querySelector('img')
+ },
+ validate: function validate(element, focusTarget, _document) {
+ var target = element.querySelector('area')
+ return _document.activeElement === target
+ },
+}
+
+// see https://jsbin.com/nenirisage/edit?html,js,console,output
+
+var focusRedirectLegend = {
+ element: 'fieldset',
+ mutate: function mutate(element) {
+ element.innerHTML =
+ ''
+ // 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