: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
/******/ (() => { // webpackBootstrap
/******/ // 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']) :
/******/ __webpack_require__.d(getter, { a: 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__ = {};
__webpack_require__.r(__webpack_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, {
// 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)
;// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/focusable.js
* - 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
* - 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) {
return [sequential ? '[tabindex]:not([tabindex^="-"])' : '[tabindex]', 'a[href]', 'button:not([disabled])', 'input:not([type="hidden"]):not([disabled])', 'select:not([disabled])', 'textarea:not([disabled])', 'iframe:not([tabindex^="-"])', '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 {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]');
/** @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.
/** @type {NodeListOf<HTMLElement>} */
const elements = context.querySelectorAll(buildSelector(sequential));
return Array.from(elements).filter(element => {
if (!isVisible(element)) {
if ('AREA' === nodeName) {
return isValidFocusableArea( /** @type {HTMLAreaElement} */element);
;// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/tabbable.js
* 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
* @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
* @return {(acc: MaybeHTMLInputElement[], el: MaybeHTMLInputElement) => MaybeHTMLInputElement[]} Radio group collapse reducer.
function createStatefulCollapseRadioGroup() {
/** @type {Record<string, MaybeHTMLInputElement>} */
const CHOSEN_RADIO_BY_NAME = {};
return function collapseRadioGroup( /** @type {MaybeHTMLInputElement[]} */result, /** @type {MaybeHTMLInputElement} */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;
// 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.
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
* @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) {
* An array map callback, returning an element of the given mapped object's
* @param {{ element: HTMLElement }} object Mapped object with element.
* @return {HTMLElement} Mapped object element.
function mapObjectTabbableToElement(object) {
* 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
* @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
* @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);
;// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/utils/assert-is-defined.js
function assertIsDefined(val, name) {
;// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/dom/get-rectangle-from-range.js
* Get the rectangle of a given Range. Returns `null` if no suitable rectangle
* @param {Range} range The range.
* @return {DOMRect?} The rectangle.
function getRectangleFromRange(range) {
// For uncollapsed ranges, get the rectangle that bounds the contents of the
// range; this a rectangle enclosing the union of the bounding rectangles
// for all the elements in the range.
const rects = Array.from(range.getClientRects());
// If there's just a single rect, return it.
if (rects.length === 1) {
// Ignore tiny selection at the edge of a range.
const filteredRects = rects.filter(({
// If it's full of tiny selections, return browser default.
if (filteredRects.length === 0) {
return range.getBoundingClientRect();
if (filteredRects.length === 1) {
if (bottom > furthestBottom) {
if (left < furthestLeft) {
if (right > furthestRight) {
return new window.DOMRect(furthestLeft, furthestTop, furthestRight - furthestLeft, furthestBottom - furthestTop);
// Correct invalid "BR" ranges. The cannot contain any children.
if (startContainer.nodeName === 'BR') {
assertIsDefined(parentNode, 'parentNode');
const index = /** @type {Node[]} */Array.from(parentNode.childNodes).indexOf(startContainer);
assertIsDefined(ownerDocument, 'ownerDocument');
range = ownerDocument.createRange();
range.setStart(parentNode, index);
range.setEnd(parentNode, index);
const rects = range.getClientRects();
// If we have multiple rectangles for a collapsed range, there's no way to
// know which it is, so don't return anything.
// If the collapsed range starts (and therefore ends) at an element node,
// `getClientRects` can be empty in some browsers. This can be resolved
// by adding a temporary text node with zero-width space to the range.
// See: https://stackoverflow.com/a/6847328/995445
if (!rect || rect.height === 0) {
assertIsDefined(ownerDocument, 'ownerDocument');
const padNode = ownerDocument.createTextNode('\u200b');
// Do not modify the live range.
range = range.cloneRange();
range.insertNode(padNode);
rect = range.getClientRects()[0];
assertIsDefined(padNode.parentNode, 'padNode.parentNode');
padNode.parentNode.removeChild(padNode);
;// CONCATENATED MODULE: ./node_modules/@wordpress/dom/build-module/dom/compute-caret-rect.js
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
