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

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

/******/ 	var __webpack_modules__ = ({});

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

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

/******/ 	var __webpack_module_cache__ = {};

/******/ 	

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

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

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

/******/ 		var cachedModule = __webpack_module_cache__[moduleId];

/******/ 		if (cachedModule !== undefined) {

/******/ 			return cachedModule.exports;

/******/ 		}

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

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

/******/ 			// no module.id needed

/******/ 			// no module.loaded needed

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

/******/ 		};

/******/ 	

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

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

/******/ 	

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

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

/******/ 	}

/******/ 	

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

/******/ 	/* webpack/runtime/create fake namespace object */

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

/******/ 		var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);

/******/ 		var leafPrototypes;

/******/ 		// 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 & 16: return value when it's Promise-like

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

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

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

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

/******/ 			if(typeof value === 'object' && value) {

/******/ 				if((mode & 4) && value.__esModule) return value;

/******/ 				if((mode & 16) && typeof value.then === 'function') return value;

/******/ 			}

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

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

/******/ 			var def = {};

/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];

/******/ 			for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {

/******/ 				Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));

/******/ 			}

/******/ 			def['default'] = () => (value);

/******/ 			__webpack_require__.d(ns, def);

/******/ 			return ns;

/******/ 		};

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

/******/ 	

/******/ 	/* 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 });

/******/ 		};

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

/******/ 	

/******/ 	/* webpack/runtime/nonce */

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

/******/ 		__webpack_require__.nc = undefined;

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

/******/ 	

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

var __webpack_exports__ = {};

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

__webpack_require__.d(__webpack_exports__, {

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

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

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

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

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

});

// NAMESPACE OBJECT: ./node_modules/@wordpress/commands/build-module/store/actions.js

var actions_namespaceObject = {};

__webpack_require__.r(actions_namespaceObject);

__webpack_require__.d(actions_namespaceObject, {

  close: () => (actions_close),

  open: () => (actions_open),

  registerCommand: () => (registerCommand),

  registerCommandLoader: () => (registerCommandLoader),

  unregisterCommand: () => (unregisterCommand),

  unregisterCommandLoader: () => (unregisterCommandLoader)

});

// NAMESPACE OBJECT: ./node_modules/@wordpress/commands/build-module/store/selectors.js

var selectors_namespaceObject = {};

__webpack_require__.r(selectors_namespaceObject);

__webpack_require__.d(selectors_namespaceObject, {

  getCommandLoaders: () => (getCommandLoaders),

  getCommands: () => (getCommands),

  getContext: () => (getContext),

  isOpen: () => (selectors_isOpen)

});

// NAMESPACE OBJECT: ./node_modules/@wordpress/commands/build-module/store/private-actions.js

var private_actions_namespaceObject = {};

__webpack_require__.r(private_actions_namespaceObject);

__webpack_require__.d(private_actions_namespaceObject, {

  setContext: () => (setContext)

});

;// ./node_modules/cmdk/dist/chunk-NZJY6EH4.mjs

var U=1,Y=.9,H=.8,J=.17,p=.1,u=.999,$=.9999;var k=.99,m=/[\\\/_+.#"@\[\(\{&]/,B=/[\\\/_+.#"@\[\(\{&]/g,K=/[\s-]/,X=/[\s-]/g;function G(_,C,h,P,A,f,O){if(f===C.length)return A===_.length?U:k;var T=`${A},${f}`;if(O[T]!==void 0)return O[T];for(var L=P.charAt(f),c=h.indexOf(L,A),S=0,E,N,R,M;c>=0;)E=G(_,C,h,P,c+1,f+1,O),E>S&&(c===A?E*=U:m.test(_.charAt(c-1))?(E*=H,R=_.slice(A,c-1).match(B),R&&A>0&&(E*=Math.pow(u,R.length))):K.test(_.charAt(c-1))?(E*=Y,M=_.slice(A,c-1).match(X),M&&A>0&&(E*=Math.pow(u,M.length))):(E*=J,A>0&&(E*=Math.pow(u,c-A))),_.charAt(c)!==C.charAt(f)&&(E*=$)),(E<p&&h.charAt(c-1)===P.charAt(f+1)||P.charAt(f+1)===P.charAt(f)&&h.charAt(c-1)!==P.charAt(f))&&(N=G(_,C,h,P,c+1,f+2,O),N*p>E&&(E=N*p)),E>S&&(S=E),c=h.indexOf(L,c+1);return O[T]=S,S}function D(_){return _.toLowerCase().replace(X," ")}function W(_,C,h){return _=h&&h.length>0?`${_+" "+h.join(" ")}`:_,G(_,C,D(_),D(C),0,0,{})}

;// ./node_modules/@babel/runtime/helpers/esm/extends.js

function _extends() {

  return _extends = Object.assign ? Object.assign.bind() : function (n) {

    for (var e = 1; e < arguments.length; e++) {

      var t = arguments[e];

      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);

    }

    return n;

  }, _extends.apply(null, arguments);

}

;// external "React"

const external_React_namespaceObject = window["React"];

var external_React_namespaceObject_0 = /*#__PURE__*/__webpack_require__.t(external_React_namespaceObject, 2);

;// ./node_modules/@radix-ui/primitive/dist/index.mjs

function $e42e1063c40fb3ef$export$b9ecd428b558ff10(originalEventHandler, ourEventHandler, { checkForDefaultPrevented: checkForDefaultPrevented = true  } = {}) {

    return function handleEvent(event) {

        originalEventHandler === null || originalEventHandler === void 0 || originalEventHandler(event);

        if (checkForDefaultPrevented === false || !event.defaultPrevented) return ourEventHandler === null || ourEventHandler === void 0 ? void 0 : ourEventHandler(event);

    };

}

;// ./node_modules/@radix-ui/react-compose-refs/dist/index.mjs

/**

 * Set a given ref to a given value

 * This utility takes care of different types of refs: callback refs and RefObject(s)

 */ function $6ed0406888f73fc4$var$setRef(ref, value) {

    if (typeof ref === 'function') ref(value);

    else if (ref !== null && ref !== undefined) ref.current = value;

}

/**

 * A utility to compose multiple refs together

 * Accepts callback refs and RefObject(s)

 */ function $6ed0406888f73fc4$export$43e446d32b3d21af(...refs) {

    return (node)=>refs.forEach((ref)=>$6ed0406888f73fc4$var$setRef(ref, node)

        )

    ;

}

/**

 * A custom hook that composes multiple refs

 * Accepts callback refs and RefObject(s)

 */ function $6ed0406888f73fc4$export$c7b2cbe3552a0d05(...refs) {

    // eslint-disable-next-line react-hooks/exhaustive-deps

    return (0,external_React_namespaceObject.useCallback)($6ed0406888f73fc4$export$43e446d32b3d21af(...refs), refs);

}

;// ./node_modules/@radix-ui/react-context/dist/index.mjs

function $c512c27ab02ef895$export$fd42f52fd3ae1109(rootComponentName, defaultContext) {

    const Context = /*#__PURE__*/ (0,external_React_namespaceObject.createContext)(defaultContext);

    function Provider(props) {

        const { children: children , ...context } = props; // Only re-memoize when prop values change

        // eslint-disable-next-line react-hooks/exhaustive-deps

        const value = (0,external_React_namespaceObject.useMemo)(()=>context

        , Object.values(context));

        return /*#__PURE__*/ (0,external_React_namespaceObject.createElement)(Context.Provider, {

            value: value

        }, children);

    }

    function useContext(consumerName) {

        const context = (0,external_React_namespaceObject.useContext)(Context);

        if (context) return context;

        if (defaultContext !== undefined) return defaultContext; // if a defaultContext wasn't specified, it's a required context.

        throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);

    }

    Provider.displayName = rootComponentName + 'Provider';

    return [

        Provider,

        useContext

    ];

}

/* -------------------------------------------------------------------------------------------------

 * createContextScope

 * -----------------------------------------------------------------------------------------------*/ function $c512c27ab02ef895$export$50c7b4e9d9f19c1(scopeName, createContextScopeDeps = []) {

    let defaultContexts = [];

    /* -----------------------------------------------------------------------------------------------

   * createContext

   * ---------------------------------------------------------------------------------------------*/ function $c512c27ab02ef895$export$fd42f52fd3ae1109(rootComponentName, defaultContext) {

        const BaseContext = /*#__PURE__*/ (0,external_React_namespaceObject.createContext)(defaultContext);

        const index = defaultContexts.length;

        defaultContexts = [

            ...defaultContexts,

            defaultContext

        ];

        function Provider(props) {

            const { scope: scope , children: children , ...context } = props;

            const Context = (scope === null || scope === void 0 ? void 0 : scope[scopeName][index]) || BaseContext; // Only re-memoize when prop values change

            // eslint-disable-next-line react-hooks/exhaustive-deps

            const value = (0,external_React_namespaceObject.useMemo)(()=>context

            , Object.values(context));

            return /*#__PURE__*/ (0,external_React_namespaceObject.createElement)(Context.Provider, {

                value: value

            }, children);

        }

        function useContext(consumerName, scope) {

            const Context = (scope === null || scope === void 0 ? void 0 : scope[scopeName][index]) || BaseContext;

            const context = (0,external_React_namespaceObject.useContext)(Context);

            if (context) return context;

            if (defaultContext !== undefined) return defaultContext; // if a defaultContext wasn't specified, it's a required context.

            throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);

        }

        Provider.displayName = rootComponentName + 'Provider';

        return [

            Provider,

            useContext

        ];

    }

    /* -----------------------------------------------------------------------------------------------

   * createScope

   * ---------------------------------------------------------------------------------------------*/ const createScope = ()=>{

        const scopeContexts = defaultContexts.map((defaultContext)=>{

            return /*#__PURE__*/ (0,external_React_namespaceObject.createContext)(defaultContext);

        });

        return function useScope(scope) {

            const contexts = (scope === null || scope === void 0 ? void 0 : scope[scopeName]) || scopeContexts;

            return (0,external_React_namespaceObject.useMemo)(()=>({

                    [`__scope${scopeName}`]: {

                        ...scope,

                        [scopeName]: contexts

                    }

                })

            , [

                scope,

                contexts

            ]);

        };

    };

    createScope.scopeName = scopeName;

    return [

        $c512c27ab02ef895$export$fd42f52fd3ae1109,

        $c512c27ab02ef895$var$composeContextScopes(createScope, ...createContextScopeDeps)

    ];

}

/* -------------------------------------------------------------------------------------------------

 * composeContextScopes

 * -----------------------------------------------------------------------------------------------*/ function $c512c27ab02ef895$var$composeContextScopes(...scopes) {

    const baseScope = scopes[0];

    if (scopes.length === 1) return baseScope;

    const createScope1 = ()=>{

        const scopeHooks = scopes.map((createScope)=>({

                useScope: createScope(),

                scopeName: createScope.scopeName

            })

        );

        return function useComposedScopes(overrideScopes) {

            const nextScopes1 = scopeHooks.reduce((nextScopes, { useScope: useScope , scopeName: scopeName  })=>{

                // We are calling a hook inside a callback which React warns against to avoid inconsistent

                // renders, however, scoping doesn't have render side effects so we ignore the rule.

                // eslint-disable-next-line react-hooks/rules-of-hooks

                const scopeProps = useScope(overrideScopes);

                const currentScope = scopeProps[`__scope${scopeName}`];

                return {

                    ...nextScopes,

                    ...currentScope

                };

            }, {});

            return (0,external_React_namespaceObject.useMemo)(()=>({

                    [`__scope${baseScope.scopeName}`]: nextScopes1

                })

            , [

                nextScopes1

            ]);

        };

    };

    createScope1.scopeName = baseScope.scopeName;

    return createScope1;

}

;// ./node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs

/**

 * On the server, React emits a warning when calling `useLayoutEffect`.

 * This is because neither `useLayoutEffect` nor `useEffect` run on the server.

 * We use this safe version which suppresses the warning by replacing it with a noop on the server.

 *

 * See: https://reactjs.org/docs/hooks-reference.html#uselayouteffect

 */ const $9f79659886946c16$export$e5c5a5f917a5871c = Boolean(globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) ? external_React_namespaceObject.useLayoutEffect : ()=>{};

;// ./node_modules/@radix-ui/react-id/dist/index.mjs

const $1746a345f3d73bb7$var$useReactId = external_React_namespaceObject_0['useId'.toString()] || (()=>undefined

);

let $1746a345f3d73bb7$var$count = 0;

function $1746a345f3d73bb7$export$f680877a34711e37(deterministicId) {

    const [id, setId] = external_React_namespaceObject.useState($1746a345f3d73bb7$var$useReactId()); // React versions older than 18 will have client-side ids only.

    $9f79659886946c16$export$e5c5a5f917a5871c(()=>{

        if (!deterministicId) setId((reactId)=>reactId !== null && reactId !== void 0 ? reactId : String($1746a345f3d73bb7$var$count++)

        );

    }, [

        deterministicId

    ]);

    return deterministicId || (id ? `radix-${id}` : '');

}

;// ./node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs

/**

 * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a

 * prop or avoid re-executing effects when passed as a dependency

 */ function $b1b2314f5f9a1d84$export$25bec8c6f54ee79a(callback) {

    const callbackRef = (0,external_React_namespaceObject.useRef)(callback);

    (0,external_React_namespaceObject.useEffect)(()=>{

        callbackRef.current = callback;

    }); // https://github.com/facebook/react/issues/19240

    return (0,external_React_namespaceObject.useMemo)(()=>(...args)=>{

            var _callbackRef$current;

            return (_callbackRef$current = callbackRef.current) === null || _callbackRef$current === void 0 ? void 0 : _callbackRef$current.call(callbackRef, ...args);

        }

    , []);

}

;// ./node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs

function $71cd76cc60e0454e$export$6f32135080cb4c3({ prop: prop , defaultProp: defaultProp , onChange: onChange = ()=>{}  }) {

    const [uncontrolledProp, setUncontrolledProp] = $71cd76cc60e0454e$var$useUncontrolledState({

        defaultProp: defaultProp,

        onChange: onChange

    });

    const isControlled = prop !== undefined;

    const value1 = isControlled ? prop : uncontrolledProp;

    const handleChange = $b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onChange);

    const setValue = (0,external_React_namespaceObject.useCallback)((nextValue)=>{

        if (isControlled) {

            const setter = nextValue;

            const value = typeof nextValue === 'function' ? setter(prop) : nextValue;

            if (value !== prop) handleChange(value);

        } else setUncontrolledProp(nextValue);

    }, [

        isControlled,

        prop,

        setUncontrolledProp,

        handleChange

    ]);

    return [

        value1,

        setValue

    ];

}

function $71cd76cc60e0454e$var$useUncontrolledState({ defaultProp: defaultProp , onChange: onChange  }) {

    const uncontrolledState = (0,external_React_namespaceObject.useState)(defaultProp);

    const [value] = uncontrolledState;

    const prevValueRef = (0,external_React_namespaceObject.useRef)(value);

    const handleChange = $b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onChange);

    (0,external_React_namespaceObject.useEffect)(()=>{

        if (prevValueRef.current !== value) {

            handleChange(value);

            prevValueRef.current = value;

        }

    }, [

        value,

        prevValueRef,

        handleChange

    ]);

    return uncontrolledState;

}

;// external "ReactDOM"

const external_ReactDOM_namespaceObject = window["ReactDOM"];

;// ./node_modules/@radix-ui/react-slot/dist/index.mjs

/* -------------------------------------------------------------------------------------------------

 * Slot

 * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$export$8c6ed5c666ac1360 = /*#__PURE__*/ (0,external_React_namespaceObject.forwardRef)((props, forwardedRef)=>{

    const { children: children , ...slotProps } = props;

    const childrenArray = external_React_namespaceObject.Children.toArray(children);

    const slottable = childrenArray.find($5e63c961fc1ce211$var$isSlottable);

    if (slottable) {

        // the new element to render is the one passed as a child of `Slottable`

        const newElement = slottable.props.children;

        const newChildren = childrenArray.map((child)=>{

            if (child === slottable) {

                // because the new element will be the one rendered, we are only interested

                // in grabbing its children (`newElement.props.children`)

                if (external_React_namespaceObject.Children.count(newElement) > 1) return external_React_namespaceObject.Children.only(null);

                return /*#__PURE__*/ (0,external_React_namespaceObject.isValidElement)(newElement) ? newElement.props.children : null;

            } else return child;

        });

        return /*#__PURE__*/ (0,external_React_namespaceObject.createElement)($5e63c961fc1ce211$var$SlotClone, _extends({}, slotProps, {

            ref: forwardedRef

        }), /*#__PURE__*/ (0,external_React_namespaceObject.isValidElement)(newElement) ? /*#__PURE__*/ (0,external_React_namespaceObject.cloneElement)(newElement, undefined, newChildren) : null);

    }

    return /*#__PURE__*/ (0,external_React_namespaceObject.createElement)($5e63c961fc1ce211$var$SlotClone, _extends({}, slotProps, {

        ref: forwardedRef

    }), children);

});

$5e63c961fc1ce211$export$8c6ed5c666ac1360.displayName = 'Slot';

/* -------------------------------------------------------------------------------------------------

 * SlotClone

 * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$var$SlotClone = /*#__PURE__*/ (0,external_React_namespaceObject.forwardRef)((props, forwardedRef)=>{

    const { children: children , ...slotProps } = props;

    if (/*#__PURE__*/ (0,external_React_namespaceObject.isValidElement)(children)) return /*#__PURE__*/ (0,external_React_namespaceObject.cloneElement)(children, {

        ...$5e63c961fc1ce211$var$mergeProps(slotProps, children.props),

        ref: forwardedRef ? $6ed0406888f73fc4$export$43e446d32b3d21af(forwardedRef, children.ref) : children.ref

    });

    return external_React_namespaceObject.Children.count(children) > 1 ? external_React_namespaceObject.Children.only(null) : null;

});

$5e63c961fc1ce211$var$SlotClone.displayName = 'SlotClone';

/* -------------------------------------------------------------------------------------------------

 * Slottable

 * -----------------------------------------------------------------------------------------------*/ const $5e63c961fc1ce211$export$d9f1ccf0bdb05d45 = ({ children: children  })=>{

    return /*#__PURE__*/ (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, children);

};

/* ---------------------------------------------------------------------------------------------- */ function $5e63c961fc1ce211$var$isSlottable(child) {

    return /*#__PURE__*/ (0,external_React_namespaceObject.isValidElement)(child) && child.type === $5e63c961fc1ce211$export$d9f1ccf0bdb05d45;

}

function $5e63c961fc1ce211$var$mergeProps(slotProps, childProps) {

    // all child props should override

    const overrideProps = {

        ...childProps

    };

    for(const propName in childProps){

        const slotPropValue = slotProps[propName];

        const childPropValue = childProps[propName];

        const isHandler = /^on[A-Z]/.test(propName);

        if (isHandler) {

            // if the handler exists on both, we compose them

            if (slotPropValue && childPropValue) overrideProps[propName] = (...args)=>{

                childPropValue(...args);

                slotPropValue(...args);

            };

            else if (slotPropValue) overrideProps[propName] = slotPropValue;

        } else if (propName === 'style') overrideProps[propName] = {

            ...slotPropValue,

            ...childPropValue

        };

        else if (propName === 'className') overrideProps[propName] = [

            slotPropValue,

            childPropValue

        ].filter(Boolean).join(' ');

    }

    return {

        ...slotProps,

        ...overrideProps