: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
}, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
const refs = external_React_.useMemo(() => ({
}), [setReference, setFloating]);
const elements = external_React_.useMemo(() => ({
}), [referenceEl, floatingEl]);
const floatingStyles = external_React_.useMemo(() => {
if (!elements.floating) {
const x = floating_ui_react_dom_roundByDPR(elements.floating, data.x);
const y = floating_ui_react_dom_roundByDPR(elements.floating, data.y);
transform: "translate(" + x + "px, " + y + "px)",
...(getDPR(elements.floating) >= 1.5 && {
}, [strategy, transform, elements.floating, data.x, data.y]);
return external_React_.useMemo(() => ({
}), [data, update, refs, elements, floatingStyles]);
;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/close.js
const close_close = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
d: "M13 11.8l6.1-6.3-1-1-6.1 6.2-6.1-6.2-1 1 6.1 6.3-6.5 6.7 1 1 6.5-6.6 6.5 6.6 1-1z"
/* harmony default export */ const library_close = (close_close);
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/scroll-lock/index.js
* Setting `overflow: hidden` on html and body elements resets body scroll in iOS.
* Save scroll top so we can restore it after locking scroll.
* NOTE: It would be cleaner and possibly safer to find a localized solution such
* as preventing default on certain touchmove events.
let previousScrollTop = 0;
function setLocked(locked) {
const scrollingElement = document.scrollingElement || document.body;
previousScrollTop = scrollingElement.scrollTop;
const methodName = locked ? 'add' : 'remove';
scrollingElement.classList[methodName]('lockscroll');
// Adding the class to the document element seems to be necessary in iOS.
document.documentElement.classList[methodName]('lockscroll');
scrollingElement.scrollTop = previousScrollTop;
* ScrollLock is a content-free React component for declaratively preventing
* scroll bleed from modal UI to the page body. This component applies a
* `lockscroll` class to the `document.documentElement` and
* `document.scrollingElement` elements to stop the body from scrolling. When it
* is present, the lock is applied.
* import { ScrollLock, Button } from '@wordpress/components';
* import { useState } from '@wordpress/element';
* const MyScrollLock = () => {
* const [ isScrollLocked, setIsScrollLocked ] = useState( false );
* const toggleLock = () => {
* setIsScrollLocked( ( locked ) => ! locked ) );
* <Button variant="secondary" onClick={ toggleLock }>
* { isScrollLocked && <ScrollLock /> }
* <strong>{ isScrollLocked ? 'Yes' : 'No' }</strong>
(0,external_wp_element_namespaceObject.useEffect)(() => {
/* harmony default export */ const scroll_lock = (ScrollLock);
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/slot-fill-context.js
const initialContextValue = {
slots: (0,external_wp_compose_namespaceObject.observableMap)(),
fills: (0,external_wp_compose_namespaceObject.observableMap)(),
true ? external_wp_warning_default()('Components must be wrapped within `SlotFillProvider`. ' + 'See https://developer.wordpress.org/block-editor/components/slot-fill/') : 0;
unregisterSlot: () => {},
unregisterFill: () => {},
// This helps the provider know if it's using the default context value or not.
const SlotFillContext = (0,external_wp_element_namespaceObject.createContext)(initialContextValue);
/* harmony default export */ const slot_fill_context = (SlotFillContext);
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/use-slot.js
const registry = (0,external_wp_element_namespaceObject.useContext)(slot_fill_context);
const slot = (0,external_wp_compose_namespaceObject.useObservableValue)(registry.slots, name);
const api = (0,external_wp_element_namespaceObject.useMemo)(() => ({
updateSlot: fillProps => registry.updateSlot(name, fillProps),
unregisterSlot: ref => registry.unregisterSlot(name, ref),
registerFill: ref => registry.registerFill(name, ref),
unregisterFill: ref => registry.unregisterFill(name, ref)
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/context.js
unregisterSlot: () => {},
unregisterFill: () => {},
getSlot: () => undefined,
subscribe: () => () => {}
const context_SlotFillContext = (0,external_wp_element_namespaceObject.createContext)(initialValue);
/* harmony default export */ const context = (context_SlotFillContext);
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/use-slot.js
* React hook returning the active slot given a name.
const use_slot_useSlot = name => {
} = (0,external_wp_element_namespaceObject.useContext)(context);
return (0,external_wp_element_namespaceObject.useSyncExternalStore)(subscribe, () => getSlot(name), () => getSlot(name));
/* harmony default export */ const use_slot = (use_slot_useSlot);
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/fill.js
} = (0,external_wp_element_namespaceObject.useContext)(context);
const slot = use_slot(name);
const ref = (0,external_wp_element_namespaceObject.useRef)({
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
const refValue = ref.current;
registerFill(name, refValue);
return () => unregisterFill(name, refValue);
// Ignore reason: the useLayoutEffects here are written to fire at specific times, and introducing new dependencies could cause unexpected changes in behavior.
// We'll leave them as-is until a more detailed investigation/refactor can be performed.
// eslint-disable-next-line react-hooks/exhaustive-deps
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
ref.current.children = children;
// Ignore reason: the useLayoutEffects here are written to fire at specific times, and introducing new dependencies could cause unexpected changes in behavior.
// We'll leave them as-is until a more detailed investigation/refactor can be performed.
// eslint-disable-next-line react-hooks/exhaustive-deps
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (name === ref.current.name) {
// Ignore initial effect.
unregisterFill(ref.current.name, ref.current);
registerFill(name, ref.current);
// Ignore reason: the useLayoutEffects here are written to fire at specific times, and introducing new dependencies could cause unexpected changes in behavior.
// We'll leave them as-is until a more detailed investigation/refactor can be performed.
// eslint-disable-next-line react-hooks/exhaustive-deps
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/slot.js
* Whether the argument is a function.
* @param maybeFunc The argument to check.
* @return True if the argument is a function, false otherwise.
function isFunction(maybeFunc) {
return typeof maybeFunc === 'function';
class SlotComponent extends external_wp_element_namespaceObject.Component {
this.isUnmounted = false;
this.isUnmounted = false;
registerSlot(this.props.name, this);
unregisterSlot(this.props.name, this);
componentDidUpdate(prevProps) {
if (prevProps.name !== name) {
unregisterSlot(prevProps.name, this);
registerSlot(name, this);
const fills = ((_getFills = getFills(name, this)) !== null && _getFills !== void 0 ? _getFills : []).map(fill => {
const fillChildren = isFunction(fill.children) ? fill.children(fillProps) : fill.children;
return external_wp_element_namespaceObject.Children.map(fillChildren, (child, childIndex) => {
if (!child || typeof child === 'string') {
let childKey = childIndex;
if (typeof child === 'object' && 'key' in child && child?.key) {
return (0,external_wp_element_namespaceObject.cloneElement)(child, {
// In some cases fills are rendered only when some conditions apply.
// This ensures that we only use non-empty fills when rendering, i.e.,
// it allows us to render wrappers only when the fills are actually present.
element => !(0,external_wp_element_namespaceObject.isEmptyElement)(element));
return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: isFunction(children) ? children(fills) : fills
const Slot = props => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(context.Consumer, {
}) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(SlotComponent, {
registerSlot: registerSlot,
unregisterSlot: unregisterSlot,
/* harmony default export */ const slot = (Slot);
;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/native.js
const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
/* harmony default export */ const esm_browser_native = ({
;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/rng.js
// Unique ID creation requires a high quality random # generator. In the browser we therefore
// require the crypto API and do not support built-in fallback to lower quality random number
// generators (like Math.random()).
const rnds8 = new Uint8Array(16);
// lazy load so that environments that need to polyfill have a chance to do so
// getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
return getRandomValues(rnds8);
;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/stringify.js
* Convert array of 16 byte values to UUID string format of the form:
* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
for (let i = 0; i < 256; ++i) {
byteToHex.push((i + 0x100).toString(16).slice(1));
function unsafeStringify(arr, offset = 0) {
// Note: Be careful editing this code! It's been tuned for performance
// and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
function stringify_stringify(arr, offset = 0) {
const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID. If this throws, it's likely due to one
// - One or more input array values don't map to a hex octet (leading to
// "undefined" in the uuid)
// - Invalid input values for the RFC `version` or `variant` fields
throw TypeError('Stringified UUID is invalid');
/* harmony default export */ const esm_browser_stringify = ((/* unused pure expression or super */ null && (stringify_stringify)));
;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-browser/v4.js
function v4(options, buf, offset) {
if (esm_browser_native.randomUUID && !buf && !options) {
return esm_browser_native.randomUUID();
const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
rnds[6] = rnds[6] & 0x0f | 0x40;
rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
for (let i = 0; i < 16; ++i) {
buf[offset + i] = rnds[i];
return unsafeStringify(rnds);
/* harmony default export */ const esm_browser_v4 = (v4);
;// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/style-provider/index.js
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
