this["wp"] = this["wp"] || {}; this["wp"]["dom"] =

/******/ (function(modules) { // webpackBootstrap

/******/ 	// The module cache

/******/ 	var installedModules = {};

/******/

/******/ 	// The require function

/******/ 	function __webpack_require__(moduleId) {

/******/

/******/ 		// Check if module is in cache

/******/ 		if(installedModules[moduleId]) {

/******/ 			return installedModules[moduleId].exports;

/******/ 		}

/******/ 		// Create a new module (and put it into the cache)

/******/ 		var module = installedModules[moduleId] = {

/******/ 			i: moduleId,

/******/ 			l: false,

/******/ 			exports: {}

/******/ 		};

/******/

/******/ 		// Execute the module function

/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/

/******/ 		// Flag the module as loaded

/******/ 		module.l = true;

/******/

/******/ 		// Return the exports of the module

/******/ 		return module.exports;

/******/ 	}

/******/

/******/

/******/ 	// expose the modules object (__webpack_modules__)

/******/ 	__webpack_require__.m = modules;

/******/

/******/ 	// expose the module cache

/******/ 	__webpack_require__.c = installedModules;

/******/

/******/ 	// define getter function for harmony exports

/******/ 	__webpack_require__.d = function(exports, name, getter) {

/******/ 		if(!__webpack_require__.o(exports, name)) {

/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });

/******/ 		}

/******/ 	};

/******/

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

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

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

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

/******/ 		}

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

/******/ 	};

/******/

/******/ 	// create a fake namespace object

/******/ 	// mode & 1: value is a module id, require it

/******/ 	// mode & 2: merge all properties of value into the ns

/******/ 	// mode & 4: return value when already ns object

/******/ 	// mode & 8|1: behave like require

/******/ 	__webpack_require__.t = function(value, mode) {

/******/ 		if(mode & 1) value = __webpack_require__(value);

/******/ 		if(mode & 8) return value;

/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;

/******/ 		var ns = Object.create(null);

/******/ 		__webpack_require__.r(ns);

/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });

/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));

/******/ 		return ns;

/******/ 	};

/******/

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

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

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

/******/ 			function getDefault() { return module['default']; } :

/******/ 			function getModuleExports() { return module; };

/******/ 		__webpack_require__.d(getter, 'a', getter);

/******/ 		return getter;

/******/ 	};

/******/

/******/ 	// Object.prototype.hasOwnProperty.call

/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

/******/

/******/ 	// __webpack_public_path__

/******/ 	__webpack_require__.p = "";

/******/

/******/

/******/ 	// Load entry module and return exports

/******/ 	return __webpack_require__(__webpack_require__.s = 379);

/******/ })

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

/******/ ({

/***/ 17:

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

function _arrayWithoutHoles(arr) {

  if (Array.isArray(arr)) {

    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {

      arr2[i] = arr[i];

    }

    return arr2;

  }

}

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js

var iterableToArray = __webpack_require__(34);

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js

function _nonIterableSpread() {

  throw new TypeError("Invalid attempt to spread non-iterable instance");

}

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; });

function _toConsumableArray(arr) {

  return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread();

}

/***/ }),

/***/ 2:

/***/ (function(module, exports) {

(function() { module.exports = this["lodash"]; }());

/***/ }),

/***/ 34:

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; });

function _iterableToArray(iter) {

  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);

}

/***/ }),

/***/ 379:

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

__webpack_require__.r(__webpack_exports__);

var focusable_namespaceObject = {};

__webpack_require__.r(focusable_namespaceObject);

__webpack_require__.d(focusable_namespaceObject, "find", function() { return find; });

var tabbable_namespaceObject = {};

__webpack_require__.r(tabbable_namespaceObject);

__webpack_require__.d(tabbable_namespaceObject, "isTabbableIndex", function() { return isTabbableIndex; });

__webpack_require__.d(tabbable_namespaceObject, "find", function() { return tabbable_find; });

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules

var toConsumableArray = __webpack_require__(17);

// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/focusable.js

/**

 * 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

 */

var SELECTOR = ['[tabindex]', 'a[href]', 'button:not([disabled])', 'input:not([type="hidden"]):not([disabled])', 'select:not([disabled])', 'textarea:not([disabled])', 'iframe', 'object', 'embed', 'area[href]', '[contenteditable]:not([contenteditable=false])'].join(',');

/**

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

 * nor visibility: hidden).

 *

 * @param {Element} 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 {Element} element DOM area element to test.

 *

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

 */

function isValidFocusableArea(element) {

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

  if (!map) {

    return false;

  }

  var img = document.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.

 *

 * @return {Element[]} Focusable elements.

 */

function find(context) {

  var elements = context.querySelectorAll(SELECTOR);

  return Object(toConsumableArray["a" /* default */])(elements).filter(function (element) {

    if (!isVisible(element)) {

      return false;

    }

    var nodeName = element.nodeName;

    if ('AREA' === nodeName) {

      return isValidFocusableArea(element);

    }

    return true;

  });

}

// EXTERNAL MODULE: external "lodash"

var external_lodash_ = __webpack_require__(2);

// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/tabbable.js

/**

 * External dependencies

 */

/**

 * 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) {

  var 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;

}

/**

 * 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 {Function} Radio group collapse reducer.

 */

function createStatefulCollapseRadioGroup() {

  var CHOSEN_RADIO_BY_NAME = {};

  return function collapseRadioGroup(result, element) {

    var nodeName = element.nodeName,

        type = element.type,

        checked = element.checked,

        name = element.name; // For all non-radio tabbables, construct to array by concatenating.

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

      return result.concat(element);

    }

    var hasChosen = CHOSEN_RADIO_BY_NAME.hasOwnProperty(name); // Omit by skipping concatenation if the radio element is not chosen.

    var 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) {

      var hadChosenElement = CHOSEN_RADIO_BY_NAME[name];

      result = Object(external_lodash_["without"])(result, 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 {Element} element Element.

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

 *

 * @return {Object} Mapped object with element, index.

 */

function mapElementToObjectTabbable(element, index) {

  return {

    element: element,

    index: index

  };

}

/**

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

 * element value.

 *

 * @param {Object} object Mapped object with index.

 *

 * @return {Element} Mapped object element.

 */

function mapObjectTabbableToElement(object) {

  return object.element;

}

/**

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

 *

 * @see mapElementToObjectTabbable

 *

 * @param {Object} a First object to compare.

 * @param {Object} b Second object to compare.

 *

 * @return {number} Comparator result.

 */

function compareObjectTabbables(a, b) {

  var aTabIndex = getTabIndex(a.element);

  var bTabIndex = getTabIndex(b.element);

  if (aTabIndex === bTabIndex) {

    return a.index - b.index;

  }

  return aTabIndex - bTabIndex;

}

function tabbable_find(context) {

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

}

// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/dom.js

/**

 * External dependencies

 */

/**

 * Browser dependencies

 */

var _window = window,

    getComputedStyle = _window.getComputedStyle;

var _window$Node = window.Node,