/******/ 	return __webpack_require__(__webpack_require__.s = "PD33");

/***/ "1CF3":

(function() { module.exports = window["wp"]["dom"]; }());

/***/ "GRId":

(function() { module.exports = window["wp"]["element"]; }());

/***/ "NMb1":

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

(function() { module.exports = window["wp"]["deprecated"]; }());

/***/ "PD33":

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

__webpack_require__.d(__webpack_exports__, "createHigherOrderComponent", function() { return /* reexport */ create_higher_order_component; });

__webpack_require__.d(__webpack_exports__, "compose", function() { return /* reexport */ compose; });

__webpack_require__.d(__webpack_exports__, "ifCondition", function() { return /* reexport */ if_condition; });

__webpack_require__.d(__webpack_exports__, "pure", function() { return /* reexport */ higher_order_pure; });

__webpack_require__.d(__webpack_exports__, "withGlobalEvents", function() { return /* reexport */ withGlobalEvents; });

__webpack_require__.d(__webpack_exports__, "withInstanceId", function() { return /* reexport */ with_instance_id; });

__webpack_require__.d(__webpack_exports__, "withSafeTimeout", function() { return /* reexport */ with_safe_timeout; });

__webpack_require__.d(__webpack_exports__, "withState", function() { return /* reexport */ withState; });

__webpack_require__.d(__webpack_exports__, "useConstrainedTabbing", function() { return /* reexport */ use_constrained_tabbing; });

__webpack_require__.d(__webpack_exports__, "useCopyOnClick", function() { return /* reexport */ useCopyOnClick; });

__webpack_require__.d(__webpack_exports__, "useCopyToClipboard", function() { return /* reexport */ useCopyToClipboard; });

__webpack_require__.d(__webpack_exports__, "__experimentalUseDialog", function() { return /* reexport */ use_dialog; });

__webpack_require__.d(__webpack_exports__, "__experimentalUseDragging", function() { return /* reexport */ useDragging; });

__webpack_require__.d(__webpack_exports__, "useFocusOnMount", function() { return /* reexport */ useFocusOnMount; });

__webpack_require__.d(__webpack_exports__, "__experimentalUseFocusOutside", function() { return /* reexport */ useFocusOutside; });

__webpack_require__.d(__webpack_exports__, "useFocusReturn", function() { return /* reexport */ use_focus_return; });

__webpack_require__.d(__webpack_exports__, "useInstanceId", function() { return /* reexport */ useInstanceId; });

__webpack_require__.d(__webpack_exports__, "useIsomorphicLayoutEffect", function() { return /* reexport */ use_isomorphic_layout_effect; });

__webpack_require__.d(__webpack_exports__, "useKeyboardShortcut", function() { return /* reexport */ use_keyboard_shortcut; });

__webpack_require__.d(__webpack_exports__, "useMediaQuery", function() { return /* reexport */ useMediaQuery; });

__webpack_require__.d(__webpack_exports__, "usePrevious", function() { return /* reexport */ usePrevious; });

__webpack_require__.d(__webpack_exports__, "useReducedMotion", function() { return /* reexport */ use_reduced_motion; });

__webpack_require__.d(__webpack_exports__, "useViewportMatch", function() { return /* reexport */ use_viewport_match; });

__webpack_require__.d(__webpack_exports__, "useResizeObserver", function() { return /* reexport */ use_resize_observer; });

__webpack_require__.d(__webpack_exports__, "useAsyncList", function() { return /* reexport */ use_async_list; });

__webpack_require__.d(__webpack_exports__, "useWarnOnChange", function() { return /* reexport */ use_warn_on_change; });

__webpack_require__.d(__webpack_exports__, "useDebounce", function() { return /* reexport */ useDebounce; });

__webpack_require__.d(__webpack_exports__, "useThrottle", function() { return /* reexport */ useThrottle; });

__webpack_require__.d(__webpack_exports__, "useMergeRefs", function() { return /* reexport */ useMergeRefs; });

__webpack_require__.d(__webpack_exports__, "useRefEffect", function() { return /* reexport */ useRefEffect; });

__webpack_require__.d(__webpack_exports__, "__experimentalUseDropZone", function() { return /* reexport */ useDropZone; });

// EXTERNAL MODULE: external "lodash"

var external_lodash_ = __webpack_require__("YLtl");

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/utils/create-higher-order-component/index.js

/**

 * External dependencies

 */

 // eslint-disable-next-line no-restricted-imports

/**

 * Given a function mapping a component to an enhanced component and modifier

 * name, returns the enhanced component augmented with a generated displayName.

 *

 * @param mapComponentToEnhancedComponent Function mapping component to enhanced component.

 * @param modifierName                    Seed name from which to generated display name.

 *

 * @return Component class with generated display name assigned.

 */

function createHigherOrderComponent(mapComponent, modifierName) {

  return Inner => {

    const Outer = mapComponent(Inner);

    const displayName = Inner.displayName || Inner.name || 'Component';

    Outer.displayName = `${Object(external_lodash_["upperFirst"])(Object(external_lodash_["camelCase"])(modifierName))}(${displayName})`;

    return Outer;

  };

/* harmony default export */ var create_higher_order_component = (createHigherOrderComponent);

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/compose.js

/**

 * External dependencies

 */

/**

 * Composes multiple higher-order components into a single higher-order component. Performs right-to-left function

 * composition, where each successive invocation is supplied the return value of the previous.

 *

 * @param {...Function} hocs The HOC functions to invoke.

 *

 * @return {Function} Returns the new composite function.

 */

/* harmony default export */ var compose = (external_lodash_["flowRight"]);

// EXTERNAL MODULE: external ["wp","element"]

var external_wp_element_ = __webpack_require__("GRId");

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/if-condition/index.js

/**

 * Internal dependencies

 */

 // eslint-disable-next-line no-duplicate-imports

/**

 * Higher-order component creator, creating a new component which renders if

 * the given condition is satisfied or with the given optional prop name.

 *

 * @example

 * ```ts

 * type Props = { foo: string };

 * const Component = ( props: Props ) => <div>{ props.foo }</div>;

 * const ConditionalComponent = ifCondition( ( props: Props ) => props.foo.length !== 0 )( Component );

 * <ConditionalComponent foo="" />; // => null

 * <ConditionalComponent foo="bar" />; // => <div>bar</div>;

 * ```

 *

 * @param predicate Function to test condition.

 *

 * @return Higher-order component.

const ifCondition = predicate => create_higher_order_component(WrappedComponent => props => {

  if (!predicate(props)) {

    return null;

  }

  return Object(external_wp_element_["createElement"])(WrappedComponent, props);

}, 'ifCondition');

/* harmony default export */ var if_condition = (ifCondition);

// EXTERNAL MODULE: external ["wp","isShallowEqual"]

var external_wp_isShallowEqual_ = __webpack_require__("rl8x");

var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_);

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/pure/index.js

/**

 * WordPress dependencies

 */

/**

 * Internal dependencies

 */

 // eslint-disable-next-line no-duplicate-imports

/**

 * Given a component returns the enhanced component augmented with a component

 * only rerendering when its props/state change

 */

const pure = create_higher_order_component(Wrapped => {

  if (Wrapped.prototype instanceof external_wp_element_["Component"]) {

    return class extends Wrapped {

      shouldComponentUpdate(nextProps, nextState) {

        return !external_wp_isShallowEqual_default()(nextProps, this.props) || !external_wp_isShallowEqual_default()(nextState, this.state);

      }

    };

  }

  return class extends external_wp_element_["Component"] {

    shouldComponentUpdate(nextProps) {

      return !external_wp_isShallowEqual_default()(nextProps, this.props);

    }

    render() {

      return Object(external_wp_element_["createElement"])(Wrapped, this.props);

  };

}, 'pure');

/* harmony default export */ var higher_order_pure = (pure);

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

var esm_extends = __webpack_require__("wx14");

// EXTERNAL MODULE: external ["wp","deprecated"]

var external_wp_deprecated_ = __webpack_require__("NMb1");

var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/listener.js

/**

 * External dependencies

 */

/**

 * Class responsible for orchestrating event handling on the global window,

 * binding a single event to be shared across all handling instances, and

 * removing the handler when no instances are listening for the event.

 */

class listener_Listener {

  constructor() {

    this.listeners = {};

    this.handleEvent = this.handleEvent.bind(this);

  }

  add(eventType, instance) {

    if (!this.listeners[eventType]) {

      // Adding first listener for this type, so bind event.

      window.addEventListener(eventType, this.handleEvent);

      this.listeners[eventType] = [];

    this.listeners[eventType].push(instance);

  }

  remove(eventType, instance) {

    this.listeners[eventType] = Object(external_lodash_["without"])(this.listeners[eventType], instance);

    if (!this.listeners[eventType].length) {

      // Removing last listener for this type, so unbind event.

      window.removeEventListener(eventType, this.handleEvent);

      delete this.listeners[eventType];

  }

  handleEvent(event) {

    Object(external_lodash_["forEach"])(this.listeners[event.type], instance => {

      instance.handleEvent(event);

}

/* harmony default export */ var listener = (listener_Listener);

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-global-events/index.js

/**

 * External dependencies

 */

/**

 * WordPress dependencies

 */

/**

 * Internal dependencies

 */

 * Listener instance responsible for managing document event handling.

 * @type {Listener}

 */

const with_global_events_listener = new listener();

/**

 * Higher-order component creator which, given an object of DOM event types and

 * values corresponding to a callback function name on the component, will

 * create or update a window event handler to invoke the callback when an event

 * occurs. On behalf of the consuming developer, the higher-order component

 * manages unbinding when the component unmounts, and binding at most a single

 * event handler for the entire application.

 *

 * @deprecated

 *

 * @param {Object<string,string>} eventTypesToHandlers Object with keys of DOM

 *                                                     event type, the value a

 *                                                     name of the function on

 *                                                     the original component's

 *                                                     instance which handles

 *                                                     the event.

 *

 * @return {Function} Higher-order component.

function withGlobalEvents(eventTypesToHandlers) {

  external_wp_deprecated_default()('wp.compose.withGlobalEvents', {

    since: '5.7',

    alternative: 'useEffect'

  });

  return create_higher_order_component(WrappedComponent => {

    class Wrapper extends external_wp_element_["Component"] {

      constructor() {

        super(...arguments);

        this.handleEvent = this.handleEvent.bind(this);

        this.handleRef = this.handleRef.bind(this);

      }

      componentDidMount() {

        Object(external_lodash_["forEach"])(eventTypesToHandlers, (handler, eventType) => {

          with_global_events_listener.add(eventType, this);

        });

      }

      componentWillUnmount() {

        Object(external_lodash_["forEach"])(eventTypesToHandlers, (handler, eventType) => {

          with_global_events_listener.remove(eventType, this);

        });

      }

      handleEvent(event) {

        const handler = eventTypesToHandlers[event.type];

        if (typeof this.wrappedRef[handler] === 'function') {

          this.wrappedRef[handler](event);

        }

      }

      handleRef(el) {

        this.wrappedRef = el; // Any component using `withGlobalEvents` that is not setting a `ref`

        // will cause `this.props.forwardedRef` to be `null`, so we need this

        // check.

        if (this.props.forwardedRef) {

          this.props.forwardedRef(el);

        }

      }

      render() {

        return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, this.props.ownProps, {

          ref: this.handleRef

        }));

      }

    return Object(external_wp_element_["forwardRef"])((props, ref) => {

      return Object(external_wp_element_["createElement"])(Wrapper, {

        ownProps: props,

        forwardedRef: ref

      });

    });

  }, 'withGlobalEvents');

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/hooks/use-instance-id/index.js

// Disable reason: Object and object are distinctly different types in TypeScript and we mean the lowercase object in thise case

// but eslint wants to force us to use `Object`. See https://stackoverflow.com/questions/49464634/difference-between-object-and-object-in-typescript

/* eslint-disable jsdoc/check-types */

 * WordPress dependencies

 * @type {WeakMap<object, number>}

const instanceMap = new WeakMap();

 * Creates a new id for a given object.

 * @param {object} object Object reference to create an id for.

 * @return {number} The instance id (index).

function createId(object) {

  const instances = instanceMap.get(object) || 0;

  instanceMap.set(object, instances + 1);

  return instances;

}

 * Provides a unique instance ID.

 * @param {object} object Object reference to create an id for.

 * @param {string} [prefix] Prefix for the unique id.

 * @param {string} [preferredId=''] Default ID to use.

 * @return {string | number} The unique instance id.

function useInstanceId(object, prefix, preferredId = '') {

  return Object(external_wp_element_["useMemo"])(() => {

    if (preferredId) return preferredId;

    const id = createId(object);

    return prefix ? `${prefix}-${id}` : id;

  }, [object]);

}

/* eslint-enable jsdoc/check-types */

// CONCATENATED MODULE: ./node_modules/@wordpress/compose/build-module/higher-order/with-instance-id/index.js

 * External dependencies

// eslint-disable-next-line no-restricted-imports

/**

 * Internal dependencies

 */

 // eslint-disable-next-line no-duplicate-imports