/******/ (() => { // webpackBootstrap

/******/ 	"use strict";

/******/ 	// The require scope

/******/ 	var __webpack_require__ = {};

/******/ 	

/************************************************************************/

/******/ 	/* webpack/runtime/compat get default export */

/******/ 	(() => {

/******/ 		// getDefaultExport function for compatibility with non-harmony modules

/******/ 		__webpack_require__.n = (module) => {

/******/ 			var getter = module && module.__esModule ?

/******/ 				() => (module['default']) :

/******/ 				() => (module);

/******/ 			__webpack_require__.d(getter, { a: getter });

/******/ 			return getter;

/******/ 		};

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/define property getters */

/******/ 	(() => {

/******/ 		// define getter functions for harmony exports

/******/ 		__webpack_require__.d = (exports, definition) => {

/******/ 			for(var key in definition) {

/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {

/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });

/******/ 				}

/******/ 			}

/******/ 		};

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/hasOwnProperty shorthand */

/******/ 	(() => {

/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/make namespace object */

/******/ 	(() => {

/******/ 		// define __esModule on exports

/******/ 		__webpack_require__.r = (exports) => {

/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

/******/ 			}

/******/ 			Object.defineProperty(exports, '__esModule', { value: true });

/******/ 		};

/******/ 	})();

/******/ 	

/************************************************************************/

var __webpack_exports__ = {};

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

__webpack_require__.d(__webpack_exports__, {

  __unstableStripHTML: () => (/* reexport */ stripHTML),

  computeCaretRect: () => (/* reexport */ computeCaretRect),

  documentHasSelection: () => (/* reexport */ documentHasSelection),

  documentHasTextSelection: () => (/* reexport */ documentHasTextSelection),

  documentHasUncollapsedSelection: () => (/* reexport */ documentHasUncollapsedSelection),

  focus: () => (/* binding */ build_module_focus),

  getFilesFromDataTransfer: () => (/* reexport */ getFilesFromDataTransfer),

  getOffsetParent: () => (/* reexport */ getOffsetParent),

  getPhrasingContentSchema: () => (/* reexport */ getPhrasingContentSchema),

  getRectangleFromRange: () => (/* reexport */ getRectangleFromRange),

  getScrollContainer: () => (/* reexport */ getScrollContainer),

  insertAfter: () => (/* reexport */ insertAfter),

  isEmpty: () => (/* reexport */ isEmpty),

  isEntirelySelected: () => (/* reexport */ isEntirelySelected),

  isFormElement: () => (/* reexport */ isFormElement),

  isHorizontalEdge: () => (/* reexport */ isHorizontalEdge),

  isNumberInput: () => (/* reexport */ isNumberInput),

  isPhrasingContent: () => (/* reexport */ isPhrasingContent),

  isRTL: () => (/* reexport */ isRTL),

  isTextContent: () => (/* reexport */ isTextContent),

  isTextField: () => (/* reexport */ isTextField),

  isVerticalEdge: () => (/* reexport */ isVerticalEdge),

  placeCaretAtHorizontalEdge: () => (/* reexport */ placeCaretAtHorizontalEdge),

  placeCaretAtVerticalEdge: () => (/* reexport */ placeCaretAtVerticalEdge),

  remove: () => (/* reexport */ remove),

  removeInvalidHTML: () => (/* reexport */ removeInvalidHTML),

  replace: () => (/* reexport */ replace),

  replaceTag: () => (/* reexport */ replaceTag),

  safeHTML: () => (/* reexport */ safeHTML),

  unwrap: () => (/* reexport */ unwrap),

  wrap: () => (/* reexport */ wrap)

});

// NAMESPACE OBJECT: ./node_modules/@wordpress/dom/build-module/focusable.js

var focusable_namespaceObject = {};

__webpack_require__.r(focusable_namespaceObject);

__webpack_require__.d(focusable_namespaceObject, {

  find: () => (find)

});

// NAMESPACE OBJECT: ./node_modules/@wordpress/dom/build-module/tabbable.js

var tabbable_namespaceObject = {};

__webpack_require__.r(tabbable_namespaceObject);

__webpack_require__.d(tabbable_namespaceObject, {

  find: () => (tabbable_find),

  findNext: () => (findNext),

  findPrevious: () => (findPrevious),

  isTabbableIndex: () => (isTabbableIndex)

});

/**

 * References:

 *

 * Focusable:

 *  - https://www.w3.org/TR/html5/editing.html#focus-management

 *

 * Sequential focus navigation:

 *  - https://www.w3.org/TR/html5/editing.html#sequential-focus-navigation-and-the-tabindex-attribute

 *

 * Disabled elements:

 *  - https://www.w3.org/TR/html5/disabled-elements.html#disabled-elements

 *

 * getClientRects algorithm (requiring layout box):

 *  - https://www.w3.org/TR/cssom-view-1/#extension-to-the-element-interface

 *

 * AREA elements associated with an IMG:

 *  - https://w3c.github.io/html/editing.html#data-model

 */

/**

 * Returns a CSS selector used to query for focusable elements.

 *

 * @param {boolean} sequential If set, only query elements that are sequentially

 *                             focusable. Non-interactive elements with a

 *                             negative `tabindex` are focusable but not

 *                             sequentially focusable.

 *                             https://html.spec.whatwg.org/multipage/interaction.html#the-tabindex-attribute

 *

 * @return {string} CSS selector.

 */

function buildSelector(sequential) {

}

/**

 * Returns true if the specified element is visible (i.e. neither display: none

 * nor visibility: hidden).

 *

 * @param {HTMLElement} element DOM element to test.

 *

 * @return {boolean} Whether element is visible.

 */

function isVisible(element) {

  return element.offsetWidth > 0 || element.offsetHeight > 0 || element.getClientRects().length > 0;

}

/**

 * Returns true if the specified area element is a valid focusable element, or

 * false otherwise. Area is only focusable if within a map where a named map

 * referenced by an image somewhere in the document.

 *

 * @param {HTMLAreaElement} element DOM area element to test.

 *

 * @return {boolean} Whether area element is valid for focus.

 */

function isValidFocusableArea(element) {

  /** @type {HTMLMapElement | null} */

  const map = element.closest('map[name]');

  if (!map) {

    return false;

  }

  /** @type {HTMLImageElement | null} */

  const img = element.ownerDocument.querySelector('img[usemap="#' + map.name + '"]');

  return !!img && isVisible(img);

}

/**

 * Returns all focusable elements within a given context.

 *

 * @param {Element} context              Element in which to search.

 * @param {Object}  options

 * @param {boolean} [options.sequential] If set, only return elements that are

 *                                       sequentially focusable.

 *                                       Non-interactive elements with a

 *                                       negative `tabindex` are focusable but

 *                                       not sequentially focusable.

 *                                       https://html.spec.whatwg.org/multipage/interaction.html#the-tabindex-attribute

 *

 * @return {HTMLElement[]} Focusable elements.

 */

function find(context, {

  sequential = false

} = {}) {

  /** @type {NodeListOf<HTMLElement>} */

  const elements = context.querySelectorAll(buildSelector(sequential));

  return Array.from(elements).filter(element => {

    if (!isVisible(element)) {

      return false;

    }

    const {

      nodeName

    } = element;

    if ('AREA' === nodeName) {

    }

    return true;

  });

}

/**

 * Internal dependencies

 */

/**

 * Returns the tab index of the given element. In contrast with the tabIndex

 * property, this normalizes the default (0) to avoid browser inconsistencies,

 * operating under the assumption that this function is only ever called with a

 * focusable node.

 *

 * @see https://bugzilla.mozilla.org/show_bug.cgi?id=1190261

 *

 * @param {Element} element Element from which to retrieve.

 *

 * @return {number} Tab index of element (default 0).

 */

function getTabIndex(element) {

  const tabIndex = element.getAttribute('tabindex');

  return tabIndex === null ? 0 : parseInt(tabIndex, 10);

}

/**

 * Returns true if the specified element is tabbable, or false otherwise.

 *

 * @param {Element} element Element to test.

 *

 * @return {boolean} Whether element is tabbable.

 */

function isTabbableIndex(element) {

  return getTabIndex(element) !== -1;

}

/** @typedef {HTMLElement & { type?: string, checked?: boolean, name?: string }} MaybeHTMLInputElement */

/**

 * Returns a stateful reducer function which constructs a filtered array of

 * tabbable elements, where at most one radio input is selected for a given

 * name, giving priority to checked input, falling back to the first

 * encountered.

 *

 * @return {(acc: MaybeHTMLInputElement[], el: MaybeHTMLInputElement) => MaybeHTMLInputElement[]} Radio group collapse reducer.

 */

function createStatefulCollapseRadioGroup() {

  /** @type {Record<string, MaybeHTMLInputElement>} */

  const CHOSEN_RADIO_BY_NAME = {};

    const {

      nodeName,

      type,

      checked,

      name

    } = element;

    // For all non-radio tabbables, construct to array by concatenating.

    if (nodeName !== 'INPUT' || type !== 'radio' || !name) {

      return result.concat(element);

    }

    const hasChosen = CHOSEN_RADIO_BY_NAME.hasOwnProperty(name);

    // Omit by skipping concatenation if the radio element is not chosen.

    const isChosen = checked || !hasChosen;

    if (!isChosen) {

      return result;

    }

    // At this point, if there had been a chosen element, the current

    // element is checked and should take priority. Retroactively remove

    // the element which had previously been considered the chosen one.

    if (hasChosen) {

      const hadChosenElement = CHOSEN_RADIO_BY_NAME[name];

      result = result.filter(e => e !== hadChosenElement);

    }

    CHOSEN_RADIO_BY_NAME[name] = element;

    return result.concat(element);

  };

}

/**

 * An array map callback, returning an object with the element value and its

 * array index location as properties. This is used to emulate a proper stable

 * sort where equal tabIndex should be left in order of their occurrence in the

 * document.

 *

 * @param {HTMLElement} element Element.

 * @param {number}      index   Array index of element.

 *

 * @return {{ element: HTMLElement, index: number }} Mapped object with element, index.

 */

function mapElementToObjectTabbable(element, index) {

  return {

    element,

    index

  };

}

/**

 * An array map callback, returning an element of the given mapped object's

 * element value.

 *

 * @param {{ element: HTMLElement }} object Mapped object with element.

 *

 * @return {HTMLElement} Mapped object element.

 */

function mapObjectTabbableToElement(object) {

  return object.element;

}

/**

 * A sort comparator function used in comparing two objects of mapped elements.

 *

 * @see mapElementToObjectTabbable

 *

 * @param {{ element: HTMLElement, index: number }} a First object to compare.

 * @param {{ element: HTMLElement, index: number }} b Second object to compare.

 *

 * @return {number} Comparator result.

 */

function compareObjectTabbables(a, b) {

  const aTabIndex = getTabIndex(a.element);

  const bTabIndex = getTabIndex(b.element);

  if (aTabIndex === bTabIndex) {

    return a.index - b.index;

  }

  return aTabIndex - bTabIndex;

}

/**

 * Givin focusable elements, filters out tabbable element.

 *

 * @param {HTMLElement[]} focusables Focusable elements to filter.

 *

 * @return {HTMLElement[]} Tabbable elements.

 */

function filterTabbable(focusables) {

  return focusables.filter(isTabbableIndex).map(mapElementToObjectTabbable).sort(compareObjectTabbables).map(mapObjectTabbableToElement).reduce(createStatefulCollapseRadioGroup(), []);

}

/**

 * @param {Element} context

 * @return {HTMLElement[]} Tabbable elements within the context.

 */

function tabbable_find(context) {

  return filterTabbable(find(context));

}

/**

 * Given a focusable element, find the preceding tabbable element.

 *

 * @param {Element} element The focusable element before which to look. Defaults

 *                          to the active element.

 *

 * @return {HTMLElement|undefined} Preceding tabbable element.

 */

function findPrevious(element) {

  return filterTabbable(find(element.ownerDocument.body)).reverse().find(focusable =>

  // eslint-disable-next-line no-bitwise

  element.compareDocumentPosition(focusable) & element.DOCUMENT_POSITION_PRECEDING);

}

/**

 * Given a focusable element, find the next tabbable element.

 *

 * @param {Element} element The focusable element after which to look. Defaults

 *                          to the active element.

 *

 * @return {HTMLElement|undefined} Next tabbable element.

 */

function findNext(element) {

  return filterTabbable(find(element.ownerDocument.body)).find(focusable =>

  // eslint-disable-next-line no-bitwise

  element.compareDocumentPosition(focusable) & element.DOCUMENT_POSITION_FOLLOWING);