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

/******/ 	var __webpack_modules__ = ({

/***/ 6007:

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

// The scores are arranged so that a continuous match of characters will

// result in a total score of 1.

//

// The best case, this character is a match, and either this is the start

// of the string, or the previous character was also a match.

var SCORE_CONTINUE_MATCH = 1,

    // A new match at the start of a word scores better than a new match

    // elsewhere as it's more likely that the user will type the starts

    // of fragments.

    // (Our notion of word includes CamelCase and hypen-separated, etc.)

    SCORE_WORD_JUMP = 0.9,

    // Any other match isn't ideal, but we include it for completeness.

    SCORE_CHARACTER_JUMP = 0.3,

    // If the user transposed two letters, it should be signficantly penalized.

    //

    // i.e. "ouch" is more likely than "curtain" when "uc" is typed.

    SCORE_TRANSPOSITION = 0.1,

    // If the user jumped to half-way through a subsequent word, it should be

    // very significantly penalized.

    //

    // i.e. "loes" is very unlikely to match "loch ness".

    // NOTE: this is set to 0 for superhuman right now, but we may want to revisit.

    SCORE_LONG_JUMP = 0,

    // The goodness of a match should decay slightly with each missing

    // character.

    //

    // i.e. "bad" is more likely than "bard" when "bd" is typed.

    //

    // This will not change the order of suggestions based on SCORE_* until

    // 100 characters are inserted between matches.

    PENALTY_SKIPPED = 0.999,

    // The goodness of an exact-case match should be higher than a

    // case-insensitive match by a small amount.

    //

    // i.e. "HTML" is more likely than "haml" when "HM" is typed.

    //

    // This will not change the order of suggestions based on SCORE_* until

    // 1000 characters are inserted between matches.

    PENALTY_CASE_MISMATCH = 0.9999,

    // If the word has more characters than the user typed, it should

    // be penalised slightly.

    //

    // i.e. "html" is more likely than "html5" if I type "html".

    //

    // However, it may well be the case that there's a sensible secondary

    // ordering (like alphabetical) that it makes sense to rely on when

    // there are many prefix matches, so we don't make the penalty increase

    // with the number of tokens.

    PENALTY_NOT_COMPLETE = 0.99;

var IS_GAP_REGEXP = /[\\\/\-_+.# \t"@\[\(\{&]/,

    COUNT_GAPS_REGEXP = /[\\\/\-_+.# \t"@\[\(\{&]/g;

function commandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, stringIndex, abbreviationIndex) {

    if (abbreviationIndex === abbreviation.length) {

        if (stringIndex === string.length) {

            return SCORE_CONTINUE_MATCH;

        }

        return PENALTY_NOT_COMPLETE;

    }

    var abbreviationChar = lowerAbbreviation.charAt(abbreviationIndex);

    var index = lowerString.indexOf(abbreviationChar, stringIndex);

    var highScore = 0;

    var score, transposedScore, wordBreaks;

    while (index >= 0) {

        score = commandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, index + 1, abbreviationIndex + 1);

        if (score > highScore) {

            if (index === stringIndex) {

                score *= SCORE_CONTINUE_MATCH;

            } else if (IS_GAP_REGEXP.test(string.charAt(index - 1))) {

                score *= SCORE_WORD_JUMP;

                wordBreaks = string.slice(stringIndex, index - 1).match(COUNT_GAPS_REGEXP);

                if (wordBreaks && stringIndex > 0) {

                    score *= Math.pow(PENALTY_SKIPPED, wordBreaks.length);

                }

            } else if (IS_GAP_REGEXP.test(string.slice(stringIndex, index - 1))) {

                score *= SCORE_LONG_JUMP;

                if (stringIndex > 0) {

                    score *= Math.pow(PENALTY_SKIPPED, index - stringIndex);

                }

            } else {

                score *= SCORE_CHARACTER_JUMP;

                if (stringIndex > 0) {

                    score *= Math.pow(PENALTY_SKIPPED, index - stringIndex);

                }

            }

            if (string.charAt(index) !== abbreviation.charAt(abbreviationIndex)) {

                score *= PENALTY_CASE_MISMATCH;

            }

        }

        if (score < SCORE_TRANSPOSITION &&

                lowerString.charAt(index - 1) === lowerAbbreviation.charAt(abbreviationIndex + 1) &&

                lowerString.charAt(index - 1) !== lowerAbbreviation.charAt(abbreviationIndex)) {

            transposedScore = commandScoreInner(string, abbreviation, lowerString, lowerAbbreviation, index + 1, abbreviationIndex + 2);

            if (transposedScore * SCORE_TRANSPOSITION > score) {

                score = transposedScore * SCORE_TRANSPOSITION;

            }

        }

        if (score > highScore) {

            highScore = score;

        }

        index = lowerString.indexOf(abbreviationChar, index + 1);

    }

    return highScore;

}

function commandScore(string, abbreviation) {

    /* NOTE:

     * in the original, we used to do the lower-casing on each recursive call, but this meant that toLowerCase()

     * was the dominating cost in the algorithm, passing both is a little ugly, but considerably faster.

     */

    return commandScoreInner(string, abbreviation, string.toLowerCase(), abbreviation.toLowerCase(), 0, 0);

}

module.exports = commandScore;

/***/ })

/******/ 	});

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

/******/ 	// 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/compat get default export */

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

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

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

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

/******/ 				() => (module['default']) :

/******/ 				() => (module);

/******/ 			__webpack_require__.d(getter, { a: getter });

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

/******/ 		};

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

/******/ 	

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

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

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

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

/******/ 	

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

var __webpack_exports__ = {};

// This entry need to be wrapped in an IIFE because it need to be in strict mode.

(() => {

"use strict";

// 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)

});

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

function _extends() {

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

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

      var source = arguments[i];

      for (var key in source) {

        if (Object.prototype.hasOwnProperty.call(source, key)) {

          target[key] = source[key];

        }

      }

    }

    return target;

  };

  return _extends.apply(this, arguments);

}

;// CONCATENATED MODULE: external "React"

const external_React_namespaceObject = window["React"];

;// CONCATENATED MODULE: ./node_modules/@radix-ui/primitive/dist/index.module.js

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

    };

}

;// CONCATENATED MODULE: ./node_modules/@radix-ui/react-compose-refs/dist/index.module.js

/**

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

}

;// CONCATENATED MODULE: ./node_modules/@radix-ui/react-context/dist/index.module.js

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;

}

;// CONCATENATED MODULE: ./node_modules/@radix-ui/react-use-layout-effect/dist/index.module.js

/**

 * 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 : ()=>{};

;// CONCATENATED MODULE: ./node_modules/@radix-ui/react-id/dist/index.module.js

const $1746a345f3d73bb7$var$useReactId = external_React_namespaceObject['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}` : '');

}

;// CONCATENATED MODULE: ./node_modules/@radix-ui/react-use-callback-ref/dist/index.module.js

/**

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

        }

    , []);

}

;// CONCATENATED MODULE: ./node_modules/@radix-ui/react-use-controllable-state/dist/index.module.js

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

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

        defaultProp: defaultProp,