�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2Fweb%2F'>web</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2F'>franchiseregistrierung.kaisers-original.com</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2F'>htdocs</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2F'>wp-includes</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2Fjs%2F'>js</a>/<a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2Fjs%2Fdist%2F'>dist</a>/</p><hr><h3>✏️ Editing: customize-widgets.js</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>(function() {
var wp;
(wp ||= {}).customizeWidgets = (() =&gt; {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __commonJS = (cb, mod) =&gt; function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) =&gt; {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) =&gt; {
    if (from &amp;&amp; typeof from === &quot;object&quot; || typeof from === &quot;function&quot;) {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) &amp;&amp; key !== except)
          __defProp(to, key, { get: () =&gt; from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) =&gt; (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. &quot;__esModule&quot; has not been set), then set
    // &quot;default&quot; to the CommonJS &quot;module.exports&quot; for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, &quot;default&quot;, { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) =&gt; __copyProps(__defProp({}, &quot;__esModule&quot;, { value: true }), mod);

  // package-external:@wordpress/element
  var require_element = __commonJS({
    &quot;package-external:@wordpress/element&quot;(exports, module) {
      module.exports = window.wp.element;
    }
  });

  // package-external:@wordpress/block-library
  var require_block_library = __commonJS({
    &quot;package-external:@wordpress/block-library&quot;(exports, module) {
      module.exports = window.wp.blockLibrary;
    }
  });

  // package-external:@wordpress/widgets
  var require_widgets = __commonJS({
    &quot;package-external:@wordpress/widgets&quot;(exports, module) {
      module.exports = window.wp.widgets;
    }
  });

  // package-external:@wordpress/blocks
  var require_blocks = __commonJS({
    &quot;package-external:@wordpress/blocks&quot;(exports, module) {
      module.exports = window.wp.blocks;
    }
  });

  // package-external:@wordpress/data
  var require_data = __commonJS({
    &quot;package-external:@wordpress/data&quot;(exports, module) {
      module.exports = window.wp.data;
    }
  });

  // package-external:@wordpress/preferences
  var require_preferences = __commonJS({
    &quot;package-external:@wordpress/preferences&quot;(exports, module) {
      module.exports = window.wp.preferences;
    }
  });

  // package-external:@wordpress/i18n
  var require_i18n = __commonJS({
    &quot;package-external:@wordpress/i18n&quot;(exports, module) {
      module.exports = window.wp.i18n;
    }
  });

  // vendor-external:react
  var require_react = __commonJS({
    &quot;vendor-external:react&quot;(exports, module) {
      module.exports = window.React;
    }
  });

  // vendor-external:react/jsx-runtime
  var require_jsx_runtime = __commonJS({
    &quot;vendor-external:react/jsx-runtime&quot;(exports, module) {
      module.exports = window.ReactJSXRuntime;
    }
  });

  // package-external:@wordpress/primitives
  var require_primitives = __commonJS({
    &quot;package-external:@wordpress/primitives&quot;(exports, module) {
      module.exports = window.wp.primitives;
    }
  });

  // package-external:@wordpress/compose
  var require_compose = __commonJS({
    &quot;package-external:@wordpress/compose&quot;(exports, module) {
      module.exports = window.wp.compose;
    }
  });

  // package-external:@wordpress/theme
  var require_theme = __commonJS({
    &quot;package-external:@wordpress/theme&quot;(exports, module) {
      module.exports = window.wp.theme;
    }
  });

  // package-external:@wordpress/private-apis
  var require_private_apis = __commonJS({
    &quot;package-external:@wordpress/private-apis&quot;(exports, module) {
      module.exports = window.wp.privateApis;
    }
  });

  // package-external:@wordpress/components
  var require_components = __commonJS({
    &quot;package-external:@wordpress/components&quot;(exports, module) {
      module.exports = window.wp.components;
    }
  });

  // package-external:@wordpress/block-editor
  var require_block_editor = __commonJS({
    &quot;package-external:@wordpress/block-editor&quot;(exports, module) {
      module.exports = window.wp.blockEditor;
    }
  });

  // package-external:@wordpress/hooks
  var require_hooks = __commonJS({
    &quot;package-external:@wordpress/hooks&quot;(exports, module) {
      module.exports = window.wp.hooks;
    }
  });

  // package-external:@wordpress/core-data
  var require_core_data = __commonJS({
    &quot;package-external:@wordpress/core-data&quot;(exports, module) {
      module.exports = window.wp.coreData;
    }
  });

  // package-external:@wordpress/media-utils
  var require_media_utils = __commonJS({
    &quot;package-external:@wordpress/media-utils&quot;(exports, module) {
      module.exports = window.wp.mediaUtils;
    }
  });

  // package-external:@wordpress/keycodes
  var require_keycodes = __commonJS({
    &quot;package-external:@wordpress/keycodes&quot;(exports, module) {
      module.exports = window.wp.keycodes;
    }
  });

  // package-external:@wordpress/keyboard-shortcuts
  var require_keyboard_shortcuts = __commonJS({
    &quot;package-external:@wordpress/keyboard-shortcuts&quot;(exports, module) {
      module.exports = window.wp.keyboardShortcuts;
    }
  });

  // node_modules/fast-deep-equal/es6/index.js
  var require_es6 = __commonJS({
    &quot;node_modules/fast-deep-equal/es6/index.js&quot;(exports, module) {
      &quot;use strict&quot;;
      module.exports = function equal(a, b) {
        if (a === b) return true;
        if (a &amp;&amp; b &amp;&amp; typeof a == &quot;object&quot; &amp;&amp; typeof b == &quot;object&quot;) {
          if (a.constructor !== b.constructor) return false;
          var length, i, keys;
          if (Array.isArray(a)) {
            length = a.length;
            if (length != b.length) return false;
            for (i = length; i-- !== 0; )
              if (!equal(a[i], b[i])) return false;
            return true;
          }
          if (a instanceof Map &amp;&amp; b instanceof Map) {
            if (a.size !== b.size) return false;
            for (i of a.entries())
              if (!b.has(i[0])) return false;
            for (i of a.entries())
              if (!equal(i[1], b.get(i[0]))) return false;
            return true;
          }
          if (a instanceof Set &amp;&amp; b instanceof Set) {
            if (a.size !== b.size) return false;
            for (i of a.entries())
              if (!b.has(i[0])) return false;
            return true;
          }
          if (ArrayBuffer.isView(a) &amp;&amp; ArrayBuffer.isView(b)) {
            length = a.length;
            if (length != b.length) return false;
            for (i = length; i-- !== 0; )
              if (a[i] !== b[i]) return false;
            return true;
          }
          if (a.constructor === RegExp) return a.source === b.source &amp;&amp; a.flags === b.flags;
          if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
          if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
          keys = Object.keys(a);
          length = keys.length;
          if (length !== Object.keys(b).length) return false;
          for (i = length; i-- !== 0; )
            if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
          for (i = length; i-- !== 0; ) {
            var key = keys[i];
            if (!equal(a[key], b[key])) return false;
          }
          return true;
        }
        return a !== a &amp;&amp; b !== b;
      };
    }
  });

  // package-external:@wordpress/is-shallow-equal
  var require_is_shallow_equal = __commonJS({
    &quot;package-external:@wordpress/is-shallow-equal&quot;(exports, module) {
      module.exports = window.wp.isShallowEqual;
    }
  });

  // package-external:@wordpress/dom
  var require_dom = __commonJS({
    &quot;package-external:@wordpress/dom&quot;(exports, module) {
      module.exports = window.wp.dom;
    }
  });

  // packages/customize-widgets/build-module/index.mjs
  var index_exports = {};
  __export(index_exports, {
    initialize: () =&gt; initialize,
    store: () =&gt; store
  });
  var import_element18 = __toESM(require_element(), 1);
  var import_block_library2 = __toESM(require_block_library(), 1);
  var import_widgets5 = __toESM(require_widgets(), 1);
  var import_blocks2 = __toESM(require_blocks(), 1);
  var import_data17 = __toESM(require_data(), 1);
  var import_preferences4 = __toESM(require_preferences(), 1);

  // node_modules/clsx/dist/clsx.mjs
  function r(e) {
    var t, f, n = &quot;&quot;;
    if (&quot;string&quot; == typeof e || &quot;number&quot; == typeof e) n += e;
    else if (&quot;object&quot; == typeof e) if (Array.isArray(e)) {
      var o = e.length;
      for (t = 0; t &lt; o; t++) e[t] &amp;&amp; (f = r(e[t])) &amp;&amp; (n &amp;&amp; (n += &quot; &quot;), n += f);
    } else for (f in e) e[f] &amp;&amp; (n &amp;&amp; (n += &quot; &quot;), n += f);
    return n;
  }
  function clsx() {
    for (var e, t, f = 0, n = &quot;&quot;, o = arguments.length; f &lt; o; f++) (e = arguments[f]) &amp;&amp; (t = r(e)) &amp;&amp; (n &amp;&amp; (n += &quot; &quot;), n += t);
    return n;
  }
  var clsx_default = clsx;

  // node_modules/@base-ui/utils/useRefWithInit.mjs
  var React = __toESM(require_react(), 1);
  var UNINITIALIZED = {};
  function useRefWithInit(init, initArg) {
    const ref = React.useRef(UNINITIALIZED);
    if (ref.current === UNINITIALIZED) {
      ref.current = init(initArg);
    }
    return ref;
  }

  // node_modules/@base-ui/utils/warn.mjs
  var set;
  if (true) {
    set = /* @__PURE__ */ new Set();
  }
  function warn(...messages) {
    if (true) {
      const messageKey = messages.join(&quot; &quot;);
      if (!set.has(messageKey)) {
        set.add(messageKey);
        console.warn(`Base UI: ${messageKey}`);
      }
    }
  }

  // node_modules/@base-ui/react/internals/useRenderElement.mjs
  var React4 = __toESM(require_react(), 1);

  // node_modules/@base-ui/utils/useMergedRefs.mjs
  function useMergedRefs(a, b, c, d) {
    const forkRef = useRefWithInit(createForkRef).current;
    if (didChange(forkRef, a, b, c, d)) {
      update(forkRef, [a, b, c, d]);
    }
    return forkRef.callback;
  }
  function useMergedRefsN(refs) {
    const forkRef = useRefWithInit(createForkRef).current;
    if (didChangeN(forkRef, refs)) {
      update(forkRef, refs);
    }
    return forkRef.callback;
  }
  function createForkRef() {
    return {
      callback: null,
      cleanup: null,
      refs: []
    };
  }
  function didChange(forkRef, a, b, c, d) {
    return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
  }
  function didChangeN(forkRef, newRefs) {
    return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) =&gt; ref !== newRefs[index]);
  }
  function update(forkRef, refs) {
    forkRef.refs = refs;
    if (refs.every((ref) =&gt; ref == null)) {
      forkRef.callback = null;
      return;
    }
    forkRef.callback = (instance) =&gt; {
      if (forkRef.cleanup) {
        forkRef.cleanup();
        forkRef.cleanup = null;
      }
      if (instance != null) {
        const cleanupCallbacks = Array(refs.length).fill(null);
        for (let i = 0; i &lt; refs.length; i += 1) {
          const ref = refs[i];
          if (ref == null) {
            continue;
          }
          switch (typeof ref) {
            case &quot;function&quot;: {
              const refCleanup = ref(instance);
              if (typeof refCleanup === &quot;function&quot;) {
                cleanupCallbacks[i] = refCleanup;
              }
              break;
            }
            case &quot;object&quot;: {
              ref.current = instance;
              break;
            }
            default:
          }
        }
        forkRef.cleanup = () =&gt; {
          for (let i = 0; i &lt; refs.length; i += 1) {
            const ref = refs[i];
            if (ref == null) {
              continue;
            }
            switch (typeof ref) {
              case &quot;function&quot;: {
                const cleanupCallback = cleanupCallbacks[i];
                if (typeof cleanupCallback === &quot;function&quot;) {
                  cleanupCallback();
                } else {
                  ref(null);
                }
                break;
              }
              case &quot;object&quot;: {
                ref.current = null;
                break;
              }
              default:
            }
          }
        };
      }
    };
  }

  // node_modules/@base-ui/utils/getReactElementRef.mjs
  var React3 = __toESM(require_react(), 1);

  // node_modules/@base-ui/utils/reactVersion.mjs
  var React2 = __toESM(require_react(), 1);
  var majorVersion = parseInt(React2.version, 10);
  function isReactVersionAtLeast(reactVersionToCheck) {
    return majorVersion &gt;= reactVersionToCheck;
  }

  // node_modules/@base-ui/utils/getReactElementRef.mjs
  function getReactElementRef(element) {
    if (!/* @__PURE__ */ React3.isValidElement(element)) {
      return null;
    }
    const reactElement = element;
    const propsWithRef = reactElement.props;
    return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
  }

  // node_modules/@base-ui/utils/mergeObjects.mjs
  function mergeObjects(a, b) {
    if (a &amp;&amp; !b) {
      return a;
    }
    if (!a &amp;&amp; b) {
      return b;
    }
    if (a || b) {
      return {
        ...a,
        ...b
      };
    }
    return void 0;
  }

  // node_modules/@base-ui/utils/empty.mjs
  var EMPTY_ARRAY = Object.freeze([]);
  var EMPTY_OBJECT = Object.freeze({});

  // node_modules/@base-ui/react/internals/getStateAttributesProps.mjs
  function getStateAttributesProps(state, customMapping) {
    const props = {};
    for (const key in state) {
      const value = state[key];
      if (customMapping?.hasOwnProperty(key)) {
        const customProps = customMapping[key](value);
        if (customProps != null) {
          Object.assign(props, customProps);
        }
        continue;
      }
      if (value === true) {
        props[`data-${key.toLowerCase()}`] = &quot;&quot;;
      } else if (value) {
        props[`data-${key.toLowerCase()}`] = value.toString();
      }
    }
    return props;
  }

  // node_modules/@base-ui/react/utils/resolveClassName.mjs
  function resolveClassName(className, state) {
    return typeof className === &quot;function&quot; ? className(state) : className;
  }

  // node_modules/@base-ui/react/utils/resolveStyle.mjs
  function resolveStyle(style, state) {
    return typeof style === &quot;function&quot; ? style(state) : style;
  }

  // node_modules/@base-ui/react/merge-props/mergeProps.mjs
  var EMPTY_PROPS = {};
  function mergeProps(a, b, c, d, e) {
    if (!c &amp;&amp; !d &amp;&amp; !e &amp;&amp; !a) {
      return createInitialMergedProps(b);
    }
    let merged = createInitialMergedProps(a);
    if (b) {
      merged = mergeInto(merged, b);
    }
    if (c) {
      merged = mergeInto(merged, c);
    }
    if (d) {
      merged = mergeInto(merged, d);
    }
    if (e) {
      merged = mergeInto(merged, e);
    }
    return merged;
  }
  function mergePropsN(props) {
    if (props.length === 0) {
      return EMPTY_PROPS;
    }
    if (props.length === 1) {
      return createInitialMergedProps(props[0]);
    }
    let merged = createInitialMergedProps(props[0]);
    for (let i = 1; i &lt; props.length; i += 1) {
      merged = mergeInto(merged, props[i]);
    }
    return merged;
  }
  function createInitialMergedProps(inputProps) {
    if (isPropsGetter(inputProps)) {
      return {
        ...resolvePropsGetter(inputProps, EMPTY_PROPS)
      };
    }
    return copyInitialProps(inputProps);
  }
  function mergeInto(merged, inputProps) {
    if (isPropsGetter(inputProps)) {
      return resolvePropsGetter(inputProps, merged);
    }
    return mutablyMergeInto(merged, inputProps);
  }
  function copyInitialProps(inputProps) {
    const copiedProps = {
      ...inputProps
    };
    for (const propName in copiedProps) {
      const propValue = copiedProps[propName];
      if (isEventHandler(propName, propValue)) {
        copiedProps[propName] = wrapEventHandler(propValue);
      }
    }
    return copiedProps;
  }
  function mutablyMergeInto(mergedProps, externalProps) {
    if (!externalProps) {
      return mergedProps;
    }
    for (const propName in externalProps) {
      const externalPropValue = externalProps[propName];
      switch (propName) {
        case &quot;style&quot;: {
          mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
          break;
        }
        case &quot;className&quot;: {
          mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
          break;
        }
        default: {
          if (isEventHandler(propName, externalPropValue)) {
            mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
          } else {
            mergedProps[propName] = externalPropValue;
          }
        }
      }
    }
    return mergedProps;
  }
  function isEventHandler(key, value) {
    const code0 = key.charCodeAt(0);
    const code1 = key.charCodeAt(1);
    const code2 = key.charCodeAt(2);
    return code0 === 111 &amp;&amp; code1 === 110 &amp;&amp; code2 &gt;= 65 &amp;&amp; code2 &lt;= 90 &amp;&amp; (typeof value === &quot;function&quot; || typeof value === &quot;undefined&quot;);
  }
  function isPropsGetter(inputProps) {
    return typeof inputProps === &quot;function&quot;;
  }
  function resolvePropsGetter(inputProps, previousProps) {
    if (isPropsGetter(inputProps)) {
      return inputProps(previousProps);
    }
    return inputProps ?? EMPTY_PROPS;
  }
  function mergeEventHandlers(ourHandler, theirHandler) {
    if (!theirHandler) {
      return ourHandler;
    }
    if (!ourHandler) {
      return wrapEventHandler(theirHandler);
    }
    return (...args) =&gt; {
      const event = args[0];
      if (isSyntheticEvent(event)) {
        const baseUIEvent = event;
        makeEventPreventable(baseUIEvent);
        const result2 = theirHandler(...args);
        if (!baseUIEvent.baseUIHandlerPrevented) {
          ourHandler?.(...args);
        }
        return result2;
      }
      const result = theirHandler(...args);
      ourHandler?.(...args);
      return result;
    };
  }
  function wrapEventHandler(handler) {
    if (!handler) {
      return handler;
    }
    return (...args) =&gt; {
      const event = args[0];
      if (isSyntheticEvent(event)) {
        makeEventPreventable(event);
      }
      return handler(...args);
    };
  }
  function makeEventPreventable(event) {
    event.preventBaseUIHandler = () =&gt; {
      event.baseUIHandlerPrevented = true;
    };
    return event;
  }
  function mergeClassNames(ourClassName, theirClassName) {
    if (theirClassName) {
      if (ourClassName) {
        return theirClassName + &quot; &quot; + ourClassName;
      }
      return theirClassName;
    }
    return ourClassName;
  }
  function isSyntheticEvent(event) {
    return event != null &amp;&amp; typeof event === &quot;object&quot; &amp;&amp; &quot;nativeEvent&quot; in event;
  }

  // node_modules/@base-ui/react/internals/useRenderElement.mjs
  var import_react = __toESM(require_react(), 1);
  function useRenderElement(element, componentProps, params = {}) {
    const renderProp = componentProps.render;
    const outProps = useRenderElementProps(componentProps, params);
    if (params.enabled === false) {
      return null;
    }
    const state = params.state ?? EMPTY_OBJECT;
    return evaluateRenderProp(element, renderProp, outProps, state);
  }
  function useRenderElementProps(componentProps, params = {}) {
    const {
      className: classNameProp,
      style: styleProp,
      render: renderProp
    } = componentProps;
    const {
      state = EMPTY_OBJECT,
      ref,
      props,
      stateAttributesMapping,
      enabled = true
    } = params;
    const className = enabled ? resolveClassName(classNameProp, state) : void 0;
    const style = enabled ? resolveStyle(styleProp, state) : void 0;
    const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
    const resolvedProps = enabled &amp;&amp; props ? resolveRenderFunctionProps(props) : void 0;
    const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
    if (typeof document !== &quot;undefined&quot;) {
      if (!enabled) {
        useMergedRefs(null, null);
      } else if (Array.isArray(ref)) {
        outProps.ref = useMergedRefsN([outProps.ref, getReactElementRef(renderProp), ...ref]);
      } else {
        outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
      }
    }
    if (!enabled) {
      return EMPTY_OBJECT;
    }
    if (className !== void 0) {
      outProps.className = mergeClassNames(outProps.className, className);
    }
    if (style !== void 0) {
      outProps.style = mergeObjects(outProps.style, style);
    }
    return outProps;
  }
  function resolveRenderFunctionProps(props) {
    if (Array.isArray(props)) {
      return mergePropsN(props);
    }
    return mergeProps(void 0, props);
  }
  var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for(&quot;react.lazy&quot;);
  var COMPONENT_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9$]*$/;
  var LOWERCASE_CHARACTER_PATTERN = /[a-z]/;
  function evaluateRenderProp(element, render, props, state) {
    if (render) {
      if (typeof render === &quot;function&quot;) {
        if (true) {
          warnIfRenderPropLooksLikeComponent(render);
        }
        return render(props, state);
      }
      const mergedProps = mergeProps(props, render.props);
      mergedProps.ref = props.ref;
      let newElement = render;
      if (newElement?.$$typeof === REACT_LAZY_TYPE) {
        const children = React4.Children.toArray(render);
        newElement = children[0];
      }
      if (true) {
        if (!/* @__PURE__ */ React4.isValidElement(newElement)) {
          throw new Error([&quot;Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.&quot;, &quot;A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.&quot;, &quot;https://base-ui.com/r/invalid-render-prop&quot;].join(&quot;\n&quot;));
        }
      }
      return /* @__PURE__ */ React4.cloneElement(newElement, mergedProps);
    }
    if (element) {
      if (typeof element === &quot;string&quot;) {
        return renderTag(element, props);
      }
    }
    throw new Error(true ? &quot;Base UI: Render element or function are not defined.&quot; : formatErrorMessage_default(8));
  }
  function warnIfRenderPropLooksLikeComponent(renderFn) {
    const functionName = renderFn.name;
    if (functionName.length === 0) {
      return;
    }
    if (!COMPONENT_IDENTIFIER_PATTERN.test(functionName)) {
      return;
    }
    if (!LOWERCASE_CHARACTER_PATTERN.test(functionName)) {
      return;
    }
    warn(`The \`render\` prop received a function named \`${functionName}\` that starts with an uppercase letter.`, &quot;This usually means a React component was passed directly as `render={Component}`.&quot;, &quot;Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.&quot;, &quot;If this is an intentional render callback, rename it to start with a lowercase letter.&quot;, &quot;Use `render={&lt;Component /&gt;}` or `render={(props) =&gt; &lt;Component {...props} /&gt;}` instead.&quot;, &quot;https://base-ui.com/r/invalid-render-prop&quot;);
  }
  function renderTag(Tag, props) {
    if (Tag === &quot;button&quot;) {
      return /* @__PURE__ */ (0, import_react.createElement)(&quot;button&quot;, {
        type: &quot;button&quot;,
        ...props,
        key: props.key
      });
    }
    if (Tag === &quot;img&quot;) {
      return /* @__PURE__ */ (0, import_react.createElement)(&quot;img&quot;, {
        alt: &quot;&quot;,
        ...props,
        key: props.key
      });
    }
    return /* @__PURE__ */ React4.createElement(Tag, props);
  }

  // node_modules/@base-ui/react/use-render/useRender.mjs
  function useRender(params) {
    return useRenderElement(params.defaultTagName ?? &quot;div&quot;, params, params);
  }

  // packages/icons/build-module/library/close-small.mjs
  var import_primitives = __toESM(require_primitives(), 1);
  var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
  var close_small_default = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_primitives.SVG, { xmlns: &quot;http://www.w3.org/2000/svg&quot;, viewBox: &quot;0 0 24 24&quot;, fill: &quot;currentColor&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_primitives.Path, { d: &quot;M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z&quot; }) });

  // packages/icons/build-module/library/external.mjs
  var import_primitives2 = __toESM(require_primitives(), 1);
  var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
  var external_default = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_primitives2.SVG, { xmlns: &quot;http://www.w3.org/2000/svg&quot;, viewBox: &quot;0 0 24 24&quot;, fill: &quot;currentColor&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_primitives2.Path, { d: &quot;M19.5 4.5h-7V6h4.44l-5.97 5.97 1.06 1.06L18 7.06v4.44h1.5v-7Zm-13 1a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2v-3H17v3a.5.5 0 0 1-.5.5h-10a.5.5 0 0 1-.5-.5v-10a.5.5 0 0 1 .5-.5h3V5.5h-3Z&quot; }) });

  // packages/icons/build-module/library/more-vertical.mjs
  var import_primitives3 = __toESM(require_primitives(), 1);
  var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
  var more_vertical_default = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_primitives3.SVG, { xmlns: &quot;http://www.w3.org/2000/svg&quot;, viewBox: &quot;0 0 24 24&quot;, fill: &quot;currentColor&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_primitives3.Path, { d: &quot;M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z&quot; }) });

  // packages/icons/build-module/library/plus.mjs
  var import_primitives4 = __toESM(require_primitives(), 1);
  var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
  var plus_default = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_primitives4.SVG, { xmlns: &quot;http://www.w3.org/2000/svg&quot;, viewBox: &quot;0 0 24 24&quot;, fill: &quot;currentColor&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_primitives4.Path, { d: &quot;M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z&quot; }) });

  // packages/icons/build-module/library/redo.mjs
  var import_primitives5 = __toESM(require_primitives(), 1);
  var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
  var redo_default = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_primitives5.SVG, { xmlns: &quot;http://www.w3.org/2000/svg&quot;, viewBox: &quot;0 0 24 24&quot;, fill: &quot;currentColor&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_primitives5.Path, { d: &quot;M15.6 6.5l-1.1 1 2.9 3.3H8c-.9 0-1.7.3-2.3.9-1.4 1.5-1.4 4.2-1.4 5.6v.2h1.5v-.3c0-1.1 0-3.5 1-4.5.3-.3.7-.5 1.3-.5h9.2L14.5 15l1.1 1.1 4.6-4.6-4.6-5z&quot; }) });

  // packages/icons/build-module/library/undo.mjs
  var import_primitives6 = __toESM(require_primitives(), 1);
  var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
  var undo_default = /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_primitives6.SVG, { xmlns: &quot;http://www.w3.org/2000/svg&quot;, viewBox: &quot;0 0 24 24&quot;, fill: &quot;currentColor&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_primitives6.Path, { d: &quot;M18.3 11.7c-.6-.6-1.4-.9-2.3-.9H6.7l2.9-3.3-1.1-1-4.5 5L8.5 16l1-1-2.7-2.7H16c.5 0 .9.2 1.3.5 1 1 1 3.4 1 4.5v.3h1.5v-.2c0-1.5 0-4.3-1.5-5.7z&quot; }) });

  // packages/ui/build-module/visually-hidden/visually-hidden.mjs
  var import_element = __toESM(require_element(), 1);
  var STYLE_HASH_ATTRIBUTE = &quot;data-wp-hash&quot;;
  function getRuntime() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== &quot;undefined&quot;) {
      registerDocument(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash(targetDocument, hash) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style of targetDocument.head.querySelectorAll(
      `style[${STYLE_HASH_ATTRIBUTE}]`
    )) {
      if (style.getAttribute(STYLE_HASH_ATTRIBUTE) === hash) {
        return true;
      }
    }
    return false;
  }
  function injectStyle(targetDocument, hash, css) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash)) {
      return;
    }
    if (documentContainsStyleHash(targetDocument, hash)) {
      injectedStyles.add(hash);
      return;
    }
    const style = targetDocument.createElement(&quot;style&quot;);
    style.setAttribute(STYLE_HASH_ATTRIBUTE, hash);
    style.appendChild(targetDocument.createTextNode(css));
    targetDocument.head.appendChild(style);
    injectedStyles.add(hash);
  }
  function registerDocument(targetDocument) {
    const runtime = getRuntime();
    runtime.documents.set(
      targetDocument,
      (runtime.documents.get(targetDocument) ?? 0) + 1
    );
    for (const [hash, css] of runtime.styles) {
      injectStyle(targetDocument, hash, css);
    }
    return () =&gt; {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count &lt;= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle(hash, css) {
    const runtime = getRuntime();
    runtime.styles.set(hash, css);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle(targetDocument, hash, css);
    }
  }
  if (typeof process === &quot;undefined&quot; || true) {
    registerStyle(&quot;fa606a57ae&quot;, &quot;@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{.f37b9e2e191ebd66__visually-hidden{word-wrap:normal;border:0;clip-path:inset(50%);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;word-break:normal}}}&quot;);
  }
  var style_default = { &quot;visually-hidden&quot;: &quot;f37b9e2e191ebd66__visually-hidden&quot; };
  var VisuallyHidden = (0, import_element.forwardRef)(
    function VisuallyHidden2({ render, ...restProps }, ref) {
      const element = useRender({
        render,
        ref,
        props: mergeProps(
          { className: style_default[&quot;visually-hidden&quot;] },
          restProps,
          {
            // @ts-expect-error Arbitrary data-* attributes aren&#039;t indexable on the typed div props. Kept hardcoded so consumers can&#039;t change or remove it.
            &quot;data-visually-hidden&quot;: &quot;&quot;
          }
        )
      });
      return element;
    }
  );

  // packages/admin-ui/build-module/admin-theme-colors/index.mjs
  var DEFAULT_THEME_COLORS = {
    primary: &quot;#3858e9&quot;,
    background: &quot;#222524&quot;
  };
  var ADMIN_THEME_COLORS = /* @__PURE__ */ new Map([
    [&quot;modern&quot;, DEFAULT_THEME_COLORS],
    [&quot;fresh&quot;, { primary: &quot;#007cba&quot;, background: &quot;#25292b&quot; }],
    [&quot;midnight&quot;, { primary: &quot;#cf4339&quot;, background: &quot;#3d4042&quot; }],
    [&quot;coffee&quot;, { primary: &quot;#916745&quot;, background: &quot;#5b534d&quot; }],
    [&quot;ocean&quot;, { primary: &quot;#567958&quot;, background: &quot;#5f787f&quot; }],
    [&quot;blue&quot;, { primary: &quot;#437aa8&quot;, background: &quot;#3876a8&quot; }],
    [&quot;ectoplasm&quot;, { primary: &quot;#646c3e&quot;, background: &quot;#4f386e&quot; }],
    [&quot;sunrise&quot;, { primary: &quot;#ad631e&quot;, background: &quot;#cc4541&quot; }],
    [&quot;light&quot;, { primary: &quot;#007cba&quot;, background: &quot;#eaeeed&quot; }]
  ]);
  function getAdminThemeColors() {
    const scheme = document.body.className.match(/admin-color-([\w-]+)/)?.[1] ?? &quot;modern&quot;;
    return ADMIN_THEME_COLORS.get(scheme) ?? DEFAULT_THEME_COLORS;
  }

  // packages/customize-widgets/build-module/components/customize-widgets/index.mjs
  var import_element17 = __toESM(require_element(), 1);
  var import_components8 = __toESM(require_components(), 1);
  var import_theme = __toESM(require_theme(), 1);

  // packages/customize-widgets/build-module/components/error-boundary/index.mjs
  var import_element2 = __toESM(require_element(), 1);
  var import_i18n = __toESM(require_i18n(), 1);
  var import_components = __toESM(require_components(), 1);
  var import_block_editor = __toESM(require_block_editor(), 1);
  var import_compose = __toESM(require_compose(), 1);
  var import_hooks = __toESM(require_hooks(), 1);
  var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
  function CopyButton({ text, children }) {
    const ref = (0, import_compose.useCopyToClipboard)(text);
    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_components.Button, { size: &quot;compact&quot;, variant: &quot;secondary&quot;, ref, children });
  }
  var ErrorBoundary = class extends import_element2.Component {
    constructor() {
      super(...arguments);
      this.state = {
        error: null
      };
    }
    componentDidCatch(error) {
      this.setState({ error });
      (0, import_hooks.doAction)(&quot;editor.ErrorBoundary.errorLogged&quot;, error);
    }
    render() {
      const { error } = this.state;
      if (!error) {
        return this.props.children;
      }
      return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
        import_block_editor.Warning,
        {
          className: &quot;customize-widgets-error-boundary&quot;,
          actions: [
            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(CopyButton, { text: error.stack, children: (0, import_i18n.__)(&quot;Copy Error&quot;) }, &quot;copy-error&quot;)
          ],
          children: (0, import_i18n.__)(&quot;The editor has encountered an unexpected error.&quot;)
        }
      );
    }
  };

  // packages/customize-widgets/build-module/components/sidebar-block-editor/index.mjs
  var import_compose3 = __toESM(require_compose(), 1);
  var import_core_data = __toESM(require_core_data(), 1);
  var import_data12 = __toESM(require_data(), 1);
  var import_element14 = __toESM(require_element(), 1);
  var import_block_editor9 = __toESM(require_block_editor(), 1);
  var import_media_utils = __toESM(require_media_utils(), 1);
  var import_preferences3 = __toESM(require_preferences(), 1);
  var import_block_library = __toESM(require_block_library(), 1);

  // packages/customize-widgets/build-module/components/block-inspector-button/index.mjs
  var import_element3 = __toESM(require_element(), 1);
  var import_i18n2 = __toESM(require_i18n(), 1);
  var import_components2 = __toESM(require_components(), 1);
  var import_data = __toESM(require_data(), 1);
  var import_block_editor2 = __toESM(require_block_editor(), 1);
  var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
  function BlockInspectorButton({ inspector, closeMenu, ...props }) {
    const selectedBlockClientId = (0, import_data.useSelect)(
      (select) =&gt; select(import_block_editor2.store).getSelectedBlockClientId(),
      []
    );
    const selectedBlock = (0, import_element3.useMemo)(
      () =&gt; document.getElementById(`block-${selectedBlockClientId}`),
      [selectedBlockClientId]
    );
    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
      import_components2.MenuItem,
      {
        onClick: () =&gt; {
          inspector.open({
            returnFocusWhenClose: selectedBlock
          });
          closeMenu();
        },
        ...props,
        children: (0, import_i18n2.__)(&quot;Show more settings&quot;)
      }
    );
  }
  var block_inspector_button_default = BlockInspectorButton;

  // packages/customize-widgets/build-module/components/header/index.mjs
  var import_components6 = __toESM(require_components(), 1);
  var import_block_editor4 = __toESM(require_block_editor(), 1);
  var import_element7 = __toESM(require_element(), 1);
  var import_keycodes3 = __toESM(require_keycodes(), 1);
  var import_i18n7 = __toESM(require_i18n(), 1);

  // packages/customize-widgets/build-module/components/inserter/index.mjs
  var import_i18n3 = __toESM(require_i18n(), 1);
  var import_block_editor3 = __toESM(require_block_editor(), 1);
  var import_components3 = __toESM(require_components(), 1);
  var import_compose2 = __toESM(require_compose(), 1);
  var import_data4 = __toESM(require_data(), 1);

  // packages/customize-widgets/build-module/store/index.mjs
  var import_data3 = __toESM(require_data(), 1);

  // packages/customize-widgets/build-module/store/reducer.mjs
  var import_data2 = __toESM(require_data(), 1);
  function blockInserterPanel(state = false, action) {
    switch (action.type) {
      case &quot;SET_IS_INSERTER_OPENED&quot;:
        return action.value;
    }
    return state;
  }
  var reducer_default = (0, import_data2.combineReducers)({
    blockInserterPanel
  });

  // packages/customize-widgets/build-module/store/selectors.mjs
  var selectors_exports = {};
  __export(selectors_exports, {
    __experimentalGetInsertionPoint: () =&gt; __experimentalGetInsertionPoint,
    isInserterOpened: () =&gt; isInserterOpened
  });
  var EMPTY_INSERTION_POINT = {
    rootClientId: void 0,
    insertionIndex: void 0
  };
  function isInserterOpened(state) {
    return !!state.blockInserterPanel;
  }
  function __experimentalGetInsertionPoint(state) {
    if (typeof state.blockInserterPanel === &quot;boolean&quot;) {
      return EMPTY_INSERTION_POINT;
    }
    return state.blockInserterPanel;
  }

  // packages/customize-widgets/build-module/store/actions.mjs
  var actions_exports = {};
  __export(actions_exports, {
    setIsInserterOpened: () =&gt; setIsInserterOpened
  });
  function setIsInserterOpened(value) {
    return {
      type: &quot;SET_IS_INSERTER_OPENED&quot;,
      value
    };
  }

  // packages/customize-widgets/build-module/store/constants.mjs
  var STORE_NAME = &quot;core/customize-widgets&quot;;

  // packages/customize-widgets/build-module/store/index.mjs
  var storeConfig = {
    reducer: reducer_default,
    selectors: selectors_exports,
    actions: actions_exports
  };
  var store = (0, import_data3.createReduxStore)(STORE_NAME, storeConfig);
  (0, import_data3.register)(store);

  // packages/customize-widgets/build-module/components/inserter/index.mjs
  var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
  function Inserter({ setIsOpened }) {
    const inserterTitleId = (0, import_compose2.useInstanceId)(
      Inserter,
      &quot;customize-widget-layout__inserter-panel-title&quot;
    );
    const insertionPoint = (0, import_data4.useSelect)(
      (select) =&gt; select(store).__experimentalGetInsertionPoint(),
      []
    );
    return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(
      &quot;div&quot;,
      {
        className: &quot;customize-widgets-layout__inserter-panel&quot;,
        &quot;aria-labelledby&quot;: inserterTitleId,
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(&quot;div&quot;, { className: &quot;customize-widgets-layout__inserter-panel-header&quot;, children: [
            /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
              &quot;h2&quot;,
              {
                id: inserterTitleId,
                className: &quot;customize-widgets-layout__inserter-panel-header-title&quot;,
                children: (0, import_i18n3.__)(&quot;Add a block&quot;)
              }
            ),
            /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
              import_components3.Button,
              {
                size: &quot;small&quot;,
                icon: close_small_default,
                onClick: () =&gt; setIsOpened(false),
                &quot;aria-label&quot;: (0, import_i18n3.__)(&quot;Close inserter&quot;)
              }
            )
          ] }),
          /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(&quot;div&quot;, { className: &quot;customize-widgets-layout__inserter-panel-content&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
            import_block_editor3.__experimentalLibrary,
            {
              rootClientId: insertionPoint.rootClientId,
              __experimentalInsertionIndex: insertionPoint.insertionIndex,
              showInserterHelpPanel: true,
              onSelect: () =&gt; setIsOpened(false)
            }
          ) })
        ]
      }
    );
  }
  var inserter_default = Inserter;

  // packages/customize-widgets/build-module/components/more-menu/index.mjs
  var import_components5 = __toESM(require_components(), 1);
  var import_element6 = __toESM(require_element(), 1);
  var import_i18n6 = __toESM(require_i18n(), 1);
  var import_keycodes2 = __toESM(require_keycodes(), 1);
  var import_keyboard_shortcuts3 = __toESM(require_keyboard_shortcuts(), 1);
  var import_preferences = __toESM(require_preferences(), 1);

  // packages/customize-widgets/build-module/components/keyboard-shortcut-help-modal/index.mjs
  var import_components4 = __toESM(require_components(), 1);
  var import_i18n5 = __toESM(require_i18n(), 1);
  var import_keyboard_shortcuts2 = __toESM(require_keyboard_shortcuts(), 1);
  var import_data6 = __toESM(require_data(), 1);
  var import_element5 = __toESM(require_element(), 1);

  // packages/customize-widgets/build-module/components/keyboard-shortcut-help-modal/config.mjs
  var import_i18n4 = __toESM(require_i18n(), 1);
  var textFormattingShortcuts = [
    {
      keyCombination: { modifier: &quot;primary&quot;, character: &quot;b&quot; },
      description: (0, import_i18n4.__)(&quot;Make the selected text bold.&quot;)
    },
    {
      keyCombination: { modifier: &quot;primary&quot;, character: &quot;i&quot; },
      description: (0, import_i18n4.__)(&quot;Make the selected text italic.&quot;)
    },
    {
      keyCombination: { modifier: &quot;primary&quot;, character: &quot;k&quot; },
      description: (0, import_i18n4.__)(&quot;Convert the selected text into a link.&quot;)
    },
    {
      keyCombination: { modifier: &quot;primaryShift&quot;, character: &quot;k&quot; },
      description: (0, import_i18n4.__)(&quot;Remove a link.&quot;)
    },
    {
      keyCombination: { character: &quot;[[&quot; },
      description: (0, import_i18n4.__)(&quot;Insert a link to a post or page.&quot;)
    },
    {
      keyCombination: { modifier: &quot;primary&quot;, character: &quot;u&quot; },
      description: (0, import_i18n4.__)(&quot;Underline the selected text.&quot;)
    },
    {
      keyCombination: { modifier: &quot;access&quot;, character: &quot;d&quot; },
      description: (0, import_i18n4.__)(&quot;Strikethrough the selected text.&quot;)
    },
    {
      keyCombination: { modifier: &quot;access&quot;, character: &quot;x&quot; },
      description: (0, import_i18n4.__)(&quot;Make the selected text inline code.&quot;)
    },
    {
      keyCombination: {
        modifier: &quot;access&quot;,
        character: &quot;0&quot;
      },
      aliases: [
        {
          modifier: &quot;access&quot;,
          character: &quot;7&quot;
        }
      ],
      description: (0, import_i18n4.__)(&quot;Convert the current heading to a paragraph.&quot;)
    },
    {
      keyCombination: { modifier: &quot;access&quot;, character: &quot;1-6&quot; },
      description: (0, import_i18n4.__)(
        &quot;Convert the current paragraph or heading to a heading of level 1 to 6.&quot;
      )
    },
    {
      keyCombination: { modifier: &quot;primaryShift&quot;, character: &quot;SPACE&quot; },
      description: (0, import_i18n4.__)(&quot;Add non breaking space.&quot;)
    }
  ];

  // packages/customize-widgets/build-module/components/keyboard-shortcut-help-modal/shortcut.mjs
  var import_element4 = __toESM(require_element(), 1);
  var import_keycodes = __toESM(require_keycodes(), 1);
  var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
  function KeyCombination({ keyCombination, forceAriaLabel }) {
    const shortcut = keyCombination.modifier ? import_keycodes.displayShortcutList[keyCombination.modifier](
      keyCombination.character
    ) : keyCombination.character;
    const ariaLabel = keyCombination.modifier ? import_keycodes.shortcutAriaLabel[keyCombination.modifier](
      keyCombination.character
    ) : keyCombination.character;
    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
      &quot;kbd&quot;,
      {
        className: &quot;customize-widgets-keyboard-shortcut-help-modal__shortcut-key-combination&quot;,
        &quot;aria-label&quot;: forceAriaLabel || ariaLabel,
        children: (Array.isArray(shortcut) ? shortcut : [shortcut]).map(
          (character, index) =&gt; {
            if (character === &quot;+&quot;) {
              return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_element4.Fragment, { children: character }, index);
            }
            return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
              &quot;kbd&quot;,
              {
                className: &quot;customize-widgets-keyboard-shortcut-help-modal__shortcut-key&quot;,
                children: character
              },
              index
            );
          }
        )
      }
    );
  }
  function Shortcut({ description, keyCombination, aliases = [], ariaLabel }) {
    return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_jsx_runtime10.Fragment, { children: [
      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(&quot;div&quot;, { className: &quot;customize-widgets-keyboard-shortcut-help-modal__shortcut-description&quot;, children: description }),
      /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(&quot;div&quot;, { className: &quot;customize-widgets-keyboard-shortcut-help-modal__shortcut-term&quot;, children: [
        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
          KeyCombination,
          {
            keyCombination,
            forceAriaLabel: ariaLabel
          }
        ),
        aliases.map((alias, index) =&gt; /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
          KeyCombination,
          {
            keyCombination: alias,
            forceAriaLabel: ariaLabel
          },
          index
        ))
      ] })
    ] });
  }
  var shortcut_default = Shortcut;

  // packages/customize-widgets/build-module/components/keyboard-shortcut-help-modal/dynamic-shortcut.mjs
  var import_data5 = __toESM(require_data(), 1);
  var import_keyboard_shortcuts = __toESM(require_keyboard_shortcuts(), 1);
  var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
  function DynamicShortcut({ name }) {
    const { keyCombination, description, aliases } = (0, import_data5.useSelect)(
      (select) =&gt; {
        const {
          getShortcutKeyCombination,
          getShortcutDescription,
          getShortcutAliases
        } = select(import_keyboard_shortcuts.store);
        return {
          keyCombination: getShortcutKeyCombination(name),
          aliases: getShortcutAliases(name),
          description: getShortcutDescription(name)
        };
      },
      [name]
    );
    if (!keyCombination) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
      shortcut_default,
      {
        keyCombination,
        description,
        aliases
      }
    );
  }
  var dynamic_shortcut_default = DynamicShortcut;

  // packages/customize-widgets/build-module/components/keyboard-shortcut-help-modal/index.mjs
  var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
  var ShortcutList = ({ shortcuts }) =&gt; (
    /*
     * Disable reason: The `list` ARIA role is redundant but
     * Safari+VoiceOver won&#039;t announce the list otherwise.
     */
    /* eslint-disable jsx-a11y/no-redundant-roles */
    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
      &quot;ul&quot;,
      {
        className: &quot;customize-widgets-keyboard-shortcut-help-modal__shortcut-list&quot;,
        role: &quot;list&quot;,
        children: shortcuts.map((shortcut, index) =&gt; /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
          &quot;li&quot;,
          {
            className: &quot;customize-widgets-keyboard-shortcut-help-modal__shortcut&quot;,
            children: typeof shortcut === &quot;string&quot; ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(dynamic_shortcut_default, { name: shortcut }) : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(shortcut_default, { ...shortcut })
          },
          index
        ))
      }
    )
  );
  var ShortcutSection = ({ title, shortcuts, className }) =&gt; /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
    &quot;section&quot;,
    {
      className: clsx_default(
        &quot;customize-widgets-keyboard-shortcut-help-modal__section&quot;,
        className
      ),
      children: [
        !!title &amp;&amp; /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(&quot;h2&quot;, { className: &quot;customize-widgets-keyboard-shortcut-help-modal__section-title&quot;, children: title }),
        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(ShortcutList, { shortcuts })
      ]
    }
  );
  var ShortcutCategorySection = ({
    title,
    categoryName,
    additionalShortcuts = []
  }) =&gt; {
    const categoryShortcuts = (0, import_data6.useSelect)(
      (select) =&gt; {
        return select(import_keyboard_shortcuts2.store).getCategoryShortcuts(
          categoryName
        );
      },
      [categoryName]
    );
    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
      ShortcutSection,
      {
        title,
        shortcuts: categoryShortcuts.concat(additionalShortcuts)
      }
    );
  };
  function KeyboardShortcutHelpModal({
    isModalActive,
    toggleModal
  }) {
    const { registerShortcut } = (0, import_data6.useDispatch)(import_keyboard_shortcuts2.store);
    (0, import_element5.useEffect)(() =&gt; {
      registerShortcut({
        name: &quot;core/customize-widgets/keyboard-shortcuts&quot;,
        category: &quot;main&quot;,
        description: (0, import_i18n5.__)(&quot;Display these keyboard shortcuts.&quot;),
        keyCombination: {
          modifier: &quot;access&quot;,
          character: &quot;h&quot;
        }
      });
    }, [registerShortcut]);
    (0, import_keyboard_shortcuts2.useShortcut)(&quot;core/customize-widgets/keyboard-shortcuts&quot;, toggleModal);
    if (!isModalActive) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
      import_components4.Modal,
      {
        className: &quot;customize-widgets-keyboard-shortcut-help-modal&quot;,
        title: (0, import_i18n5.__)(&quot;Keyboard shortcuts&quot;),
        onRequestClose: toggleModal,
        children: [
          /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
            ShortcutSection,
            {
              className: &quot;customize-widgets-keyboard-shortcut-help-modal__main-shortcuts&quot;,
              shortcuts: [&quot;core/customize-widgets/keyboard-shortcuts&quot;]
            }
          ),
          /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
            ShortcutCategorySection,
            {
              title: (0, import_i18n5.__)(&quot;Global shortcuts&quot;),
              categoryName: &quot;global&quot;
            }
          ),
          /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
            ShortcutCategorySection,
            {
              title: (0, import_i18n5.__)(&quot;Selection shortcuts&quot;),
              categoryName: &quot;selection&quot;
            }
          ),
          /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
            ShortcutCategorySection,
            {
              title: (0, import_i18n5.__)(&quot;Block shortcuts&quot;),
              categoryName: &quot;block&quot;,
              additionalShortcuts: [
                {
                  keyCombination: { character: &quot;/&quot; },
                  description: (0, import_i18n5.__)(
                    &quot;Change the block type after adding a new paragraph.&quot;
                  ),
                  /* translators: The forward-slash character. e.g. &#039;/&#039;. */
                  ariaLabel: (0, import_i18n5.__)(&quot;Forward-slash&quot;)
                }
              ]
            }
          ),
          /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
            ShortcutSection,
            {
              title: (0, import_i18n5.__)(&quot;Text formatting&quot;),
              shortcuts: textFormattingShortcuts
            }
          )
        ]
      }
    );
  }

  // packages/customize-widgets/build-module/components/more-menu/index.mjs
  var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
  function MoreMenu() {
    const [
      isKeyboardShortcutsModalActive,
      setIsKeyboardShortcutsModalVisible
    ] = (0, import_element6.useState)(false);
    const toggleKeyboardShortcutsModal = () =&gt; setIsKeyboardShortcutsModalVisible(!isKeyboardShortcutsModalActive);
    (0, import_keyboard_shortcuts3.useShortcut)(
      &quot;core/customize-widgets/keyboard-shortcuts&quot;,
      toggleKeyboardShortcutsModal
    );
    return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_jsx_runtime13.Fragment, { children: [
      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
        import_components5.ToolbarDropdownMenu,
        {
          icon: more_vertical_default,
          label: (0, import_i18n6.__)(&quot;Options&quot;),
          popoverProps: {
            placement: &quot;bottom-end&quot;,
            className: &quot;more-menu-dropdown__content&quot;
          },
          toggleProps: {
            tooltipPosition: &quot;bottom&quot;,
            size: &quot;compact&quot;
          },
          children: () =&gt; /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_jsx_runtime13.Fragment, { children: [
            /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_components5.MenuGroup, { label: (0, import_i18n6._x)(&quot;View&quot;, &quot;noun&quot;), children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
              import_preferences.PreferenceToggleMenuItem,
              {
                scope: &quot;core/customize-widgets&quot;,
                name: &quot;fixedToolbar&quot;,
                label: (0, import_i18n6.__)(&quot;Top toolbar&quot;),
                info: (0, import_i18n6.__)(
                  &quot;Access all block and document tools in a single place&quot;
                ),
                messageActivated: (0, import_i18n6.__)(
                  &quot;Top toolbar activated&quot;
                ),
                messageDeactivated: (0, import_i18n6.__)(
                  &quot;Top toolbar deactivated&quot;
                )
              }
            ) }),
            /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_components5.MenuGroup, { label: (0, import_i18n6.__)(&quot;Tools&quot;), children: [
              /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
                import_components5.MenuItem,
                {
                  onClick: () =&gt; {
                    setIsKeyboardShortcutsModalVisible(true);
                  },
                  shortcut: import_keycodes2.displayShortcut.access(&quot;h&quot;),
                  children: (0, import_i18n6.__)(&quot;Keyboard shortcuts&quot;)
                }
              ),
              /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
                import_preferences.PreferenceToggleMenuItem,
                {
                  scope: &quot;core/customize-widgets&quot;,
                  name: &quot;welcomeGuide&quot;,
                  label: (0, import_i18n6.__)(&quot;Welcome Guide&quot;)
                }
              ),
              /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
                import_components5.MenuItem,
                {
                  role: &quot;menuitem&quot;,
                  icon: external_default,
                  href: (0, import_i18n6.__)(
                    &quot;https://wordpress.org/documentation/article/block-based-widgets-editor/&quot;
                  ),
                  target: &quot;_blank&quot;,
                  rel: &quot;noopener&quot;,
                  children: [
                    (0, import_i18n6.__)(&quot;Help&quot;),
                    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(VisuallyHidden, {
                      render: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(&quot;span&quot;, {}),
                      /* translators: accessibility text */
                      children: (0, import_i18n6.__)(&quot;(opens in a new tab)&quot;)
                    })
                  ]
                }
              )
            ] }),
            /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_components5.MenuGroup, { label: (0, import_i18n6.__)(&quot;Preferences&quot;), children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
              import_preferences.PreferenceToggleMenuItem,
              {
                scope: &quot;core/customize-widgets&quot;,
                name: &quot;keepCaretInsideBlock&quot;,
                label: (0, import_i18n6.__)(
                  &quot;Contain text cursor inside block&quot;
                ),
                info: (0, import_i18n6.__)(
                  &quot;Aids screen readers by stopping text caret from leaving blocks.&quot;
                ),
                messageActivated: (0, import_i18n6.__)(
                  &quot;Contain text cursor inside block activated&quot;
                ),
                messageDeactivated: (0, import_i18n6.__)(
                  &quot;Contain text cursor inside block deactivated&quot;
                )
              }
            ) })
          ] })
        }
      ),
      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
        KeyboardShortcutHelpModal,
        {
          isModalActive: isKeyboardShortcutsModalActive,
          toggleModal: toggleKeyboardShortcutsModal
        }
      )
    ] });
  }

  // packages/customize-widgets/build-module/components/header/index.mjs
  var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
  function Header({
    sidebar,
    inserter,
    isInserterOpened: isInserterOpened2,
    setIsInserterOpened: setIsInserterOpened2,
    isFixedToolbarActive
  }) {
    const [[hasUndo, hasRedo], setUndoRedo] = (0, import_element7.useState)([
      sidebar.hasUndo(),
      sidebar.hasRedo()
    ]);
    const shortcut = (0, import_keycodes3.isAppleOS)() ? import_keycodes3.displayShortcut.primaryShift(&quot;z&quot;) : import_keycodes3.displayShortcut.primary(&quot;y&quot;);
    (0, import_element7.useEffect)(() =&gt; {
      return sidebar.subscribeHistory(() =&gt; {
        setUndoRedo([sidebar.hasUndo(), sidebar.hasRedo()]);
      });
    }, [sidebar]);
    return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [
      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
        &quot;div&quot;,
        {
          className: clsx_default(&quot;customize-widgets-header&quot;, {
            &quot;is-fixed-toolbar-active&quot;: isFixedToolbarActive
          }),
          children: /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(
            import_block_editor4.NavigableToolbar,
            {
              className: &quot;customize-widgets-header-toolbar&quot;,
              &quot;aria-label&quot;: (0, import_i18n7.__)(&quot;Document tools&quot;),
              children: [
                /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
                  import_components6.ToolbarButton,
                  {
                    icon: !(0, import_i18n7.isRTL)() ? undo_default : redo_default,
                    label: (0, import_i18n7.__)(&quot;Undo&quot;),
                    shortcut: import_keycodes3.displayShortcut.primary(&quot;z&quot;),
                    disabled: !hasUndo,
                    onClick: sidebar.undo,
                    className: &quot;customize-widgets-editor-history-button undo-button&quot;
                  }
                ),
                /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
                  import_components6.ToolbarButton,
                  {
                    icon: !(0, import_i18n7.isRTL)() ? redo_default : undo_default,
                    label: (0, import_i18n7.__)(&quot;Redo&quot;),
                    shortcut,
                    disabled: !hasRedo,
                    onClick: sidebar.redo,
                    className: &quot;customize-widgets-editor-history-button redo-button&quot;
                  }
                ),
                /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
                  import_components6.ToolbarButton,
                  {
                    className: &quot;customize-widgets-header-toolbar__inserter-toggle&quot;,
                    isPressed: isInserterOpened2,
                    variant: &quot;primary&quot;,
                    icon: plus_default,
                    label: (0, import_i18n7._x)(
                      &quot;Add block&quot;,
                      &quot;Generic label for block inserter button&quot;
                    ),
                    onClick: () =&gt; {
                      setIsInserterOpened2((isOpen) =&gt; !isOpen);
                    }
                  }
                ),
                /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(MoreMenu, {})
              ]
            }
          )
        }
      ),
      (0, import_element7.createPortal)(
        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(inserter_default, { setIsOpened: setIsInserterOpened2 }),
        inserter.contentContainer[0]
      )
    ] });
  }
  var header_default = Header;

  // packages/customize-widgets/build-module/components/inserter/use-inserter.mjs
  var import_element8 = __toESM(require_element(), 1);
  var import_data7 = __toESM(require_data(), 1);
  function useInserter(inserter) {
    const isInserterOpened2 = (0, import_data7.useSelect)(
      (select) =&gt; select(store).isInserterOpened(),
      []
    );
    const { setIsInserterOpened: setIsInserterOpened2 } = (0, import_data7.useDispatch)(store);
    (0, import_element8.useEffect)(() =&gt; {
      if (isInserterOpened2) {
        inserter.open();
      } else {
        inserter.close();
      }
    }, [inserter, isInserterOpened2]);
    return [
      isInserterOpened2,
      (0, import_element8.useCallback)(
        (updater) =&gt; {
          let isOpen = updater;
          if (typeof updater === &quot;function&quot;) {
            isOpen = updater(
              (0, import_data7.select)(store).isInserterOpened()
            );
          }
          setIsInserterOpened2(isOpen);
        },
        [setIsInserterOpened2]
      )
    ];
  }

  // packages/customize-widgets/build-module/components/sidebar-block-editor/sidebar-editor-provider.mjs
  var import_block_editor6 = __toESM(require_block_editor(), 1);

  // packages/customize-widgets/build-module/components/sidebar-block-editor/use-sidebar-block-editor.mjs
  var import_es6 = __toESM(require_es6(), 1);
  var import_element9 = __toESM(require_element(), 1);
  var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
  var import_widgets2 = __toESM(require_widgets(), 1);

  // packages/customize-widgets/build-module/utils.mjs
  var import_blocks = __toESM(require_blocks(), 1);
  var import_widgets = __toESM(require_widgets(), 1);
  function settingIdToWidgetId(settingId) {
    const matches = settingId.match(/^widget_(.+)(?:\[(\d+)\])$/);
    if (matches) {
      const idBase = matches[1];
      const number = parseInt(matches[2], 10);
      return `${idBase}-${number}`;
    }
    return settingId;
  }
  function blockToWidget(block, existingWidget = null) {
    let widget;
    const isValidLegacyWidgetBlock = block.name === &quot;core/legacy-widget&quot; &amp;&amp; (block.attributes.id || block.attributes.instance);
    if (isValidLegacyWidgetBlock) {
      if (block.attributes.id) {
        widget = {
          id: block.attributes.id
        };
      } else {
        const { encoded, hash, raw, ...rest } = block.attributes.instance;
        widget = {
          idBase: block.attributes.idBase,
          instance: {
            ...existingWidget?.instance,
            // Required only for the customizer.
            is_widget_customizer_js_value: true,
            encoded_serialized_instance: encoded,
            instance_hash_key: hash,
            raw_instance: raw,
            ...rest
          }
        };
      }
    } else {
      const instance = {
        content: (0, import_blocks.serialize)(block)
      };
      widget = {
        idBase: &quot;block&quot;,
        widgetClass: &quot;WP_Widget_Block&quot;,
        instance: {
          raw_instance: instance
        }
      };
    }
    const { form, rendered, ...restExistingWidget } = existingWidget || {};
    return {
      ...restExistingWidget,
      ...widget
    };
  }
  function widgetToBlock({ id, idBase, number, instance }) {
    let block;
    const {
      encoded_serialized_instance: encoded,
      instance_hash_key: hash,
      raw_instance: raw,
      ...rest
    } = instance;
    if (idBase === &quot;block&quot;) {
      const parsedBlocks = (0, import_blocks.parse)(raw.content ?? &quot;&quot;, {
        __unstableSkipAutop: true
      });
      block = parsedBlocks.length ? parsedBlocks[0] : (0, import_blocks.createBlock)(&quot;core/paragraph&quot;, {});
    } else if (number) {
      block = (0, import_blocks.createBlock)(&quot;core/legacy-widget&quot;, {
        idBase,
        instance: {
          encoded,
          hash,
          raw,
          ...rest
        }
      });
    } else {
      block = (0, import_blocks.createBlock)(&quot;core/legacy-widget&quot;, {
        id
      });
    }
    return (0, import_widgets.addWidgetIdToBlock)(block, id);
  }

  // packages/customize-widgets/build-module/components/sidebar-block-editor/use-sidebar-block-editor.mjs
  function widgetsToBlocks(widgets) {
    return widgets.map((widget) =&gt; widgetToBlock(widget));
  }
  function useSidebarBlockEditor(sidebar) {
    const [blocks, setBlocks] = (0, import_element9.useState)(
      () =&gt; widgetsToBlocks(sidebar.getWidgets())
    );
    (0, import_element9.useEffect)(() =&gt; {
      return sidebar.subscribe((prevWidgets, nextWidgets) =&gt; {
        setBlocks((prevBlocks) =&gt; {
          const prevWidgetsMap = new Map(
            prevWidgets.map((widget) =&gt; [widget.id, widget])
          );
          const prevBlocksMap = new Map(
            prevBlocks.map((block) =&gt; [
              (0, import_widgets2.getWidgetIdFromBlock)(block),
              block
            ])
          );
          const nextBlocks = nextWidgets.map((nextWidget) =&gt; {
            const prevWidget = prevWidgetsMap.get(nextWidget.id);
            if (prevWidget &amp;&amp; prevWidget === nextWidget) {
              return prevBlocksMap.get(nextWidget.id);
            }
            return widgetToBlock(nextWidget);
          });
          if ((0, import_is_shallow_equal.isShallowEqual)(prevBlocks, nextBlocks)) {
            return prevBlocks;
          }
          return nextBlocks;
        });
      });
    }, [sidebar]);
    const onChangeBlocks = (0, import_element9.useCallback)(
      (nextBlocks) =&gt; {
        setBlocks((prevBlocks) =&gt; {
          if ((0, import_is_shallow_equal.isShallowEqual)(prevBlocks, nextBlocks)) {
            return prevBlocks;
          }
          const prevBlocksMap = new Map(
            prevBlocks.map((block) =&gt; [
              (0, import_widgets2.getWidgetIdFromBlock)(block),
              block
            ])
          );
          const nextWidgets = nextBlocks.map((nextBlock) =&gt; {
            const widgetId = (0, import_widgets2.getWidgetIdFromBlock)(nextBlock);
            if (widgetId &amp;&amp; prevBlocksMap.has(widgetId)) {
              const prevBlock = prevBlocksMap.get(widgetId);
              const prevWidget = sidebar.getWidget(widgetId);
              if ((0, import_es6.default)(nextBlock, prevBlock) &amp;&amp; prevWidget) {
                return prevWidget;
              }
              return blockToWidget(nextBlock, prevWidget);
            }
            return blockToWidget(nextBlock);
          });
          if ((0, import_is_shallow_equal.isShallowEqual)(sidebar.getWidgets(), nextWidgets)) {
            return prevBlocks;
          }
          const addedWidgetIds = sidebar.setWidgets(nextWidgets);
          return nextBlocks.reduce(
            (updatedNextBlocks, nextBlock, index) =&gt; {
              const addedWidgetId = addedWidgetIds[index];
              if (addedWidgetId !== null) {
                if (updatedNextBlocks === nextBlocks) {
                  updatedNextBlocks = nextBlocks.slice();
                }
                updatedNextBlocks[index] = (0, import_widgets2.addWidgetIdToBlock)(
                  nextBlock,
                  addedWidgetId
                );
              }
              return updatedNextBlocks;
            },
            nextBlocks
          );
        });
      },
      [sidebar]
    );
    return [blocks, onChangeBlocks, onChangeBlocks];
  }

  // packages/customize-widgets/build-module/components/focus-control/use-blocks-focus-control.mjs
  var import_element11 = __toESM(require_element(), 1);
  var import_data8 = __toESM(require_data(), 1);
  var import_block_editor5 = __toESM(require_block_editor(), 1);
  var import_widgets3 = __toESM(require_widgets(), 1);

  // packages/customize-widgets/build-module/components/focus-control/index.mjs
  var import_element10 = __toESM(require_element(), 1);
  var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
  var FocusControlContext = (0, import_element10.createContext)();
  FocusControlContext.displayName = &quot;FocusControlContext&quot;;
  function FocusControl({ api, sidebarControls, children }) {
    const [focusedWidgetIdRef, setFocusedWidgetIdRef] = (0, import_element10.useState)({
      current: null
    });
    const focusWidget = (0, import_element10.useCallback)(
      (widgetId) =&gt; {
        for (const sidebarControl of sidebarControls) {
          const widgets = sidebarControl.setting.get();
          if (widgets.includes(widgetId)) {
            sidebarControl.sectionInstance.expand({
              // Schedule it after the complete callback so that
              // it won&#039;t be overridden by the &quot;Back&quot; button focus.
              completeCallback() {
                setFocusedWidgetIdRef({ current: widgetId });
              }
            });
            break;
          }
        }
      },
      [sidebarControls]
    );
    (0, import_element10.useEffect)(() =&gt; {
      function handleFocus(settingId) {
        const widgetId = settingIdToWidgetId(settingId);
        focusWidget(widgetId);
      }
      let previewBound = false;
      function handleReady() {
        api.previewer.preview.bind(
          &quot;focus-control-for-setting&quot;,
          handleFocus
        );
        previewBound = true;
      }
      api.previewer.bind(&quot;ready&quot;, handleReady);
      return () =&gt; {
        api.previewer.unbind(&quot;ready&quot;, handleReady);
        if (previewBound) {
          api.previewer.preview.unbind(
            &quot;focus-control-for-setting&quot;,
            handleFocus
          );
        }
      };
    }, [api, focusWidget]);
    const context = (0, import_element10.useMemo)(
      () =&gt; [focusedWidgetIdRef, focusWidget],
      [focusedWidgetIdRef, focusWidget]
    );
    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(FocusControlContext.Provider, { value: context, children });
  }
  var useFocusControl = () =&gt; (0, import_element10.useContext)(FocusControlContext);

  // packages/customize-widgets/build-module/components/focus-control/use-blocks-focus-control.mjs
  function useBlocksFocusControl(blocks) {
    const { selectBlock } = (0, import_data8.useDispatch)(import_block_editor5.store);
    const [focusedWidgetIdRef] = useFocusControl();
    const blocksRef = (0, import_element11.useRef)(blocks);
    (0, import_element11.useEffect)(() =&gt; {
      blocksRef.current = blocks;
    }, [blocks]);
    (0, import_element11.useEffect)(() =&gt; {
      if (focusedWidgetIdRef.current) {
        const focusedBlock = blocksRef.current.find(
          (block) =&gt; (0, import_widgets3.getWidgetIdFromBlock)(block) === focusedWidgetIdRef.current
        );
        if (focusedBlock) {
          selectBlock(focusedBlock.clientId);
          const blockNode = document.querySelector(
            `[data-block=&quot;${focusedBlock.clientId}&quot;]`
          );
          blockNode?.focus();
        }
      }
    }, [focusedWidgetIdRef, selectBlock]);
  }

  // packages/customize-widgets/build-module/lock-unlock.mjs
  var import_private_apis = __toESM(require_private_apis(), 1);
  var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
    &quot;I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.&quot;,
    &quot;@wordpress/customize-widgets&quot;
  );

  // packages/customize-widgets/build-module/components/sidebar-block-editor/sidebar-editor-provider.mjs
  var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
  var { ExperimentalBlockEditorProvider } = unlock(import_block_editor6.privateApis);
  function SidebarEditorProvider({
    sidebar,
    settings,
    children
  }) {
    const [blocks, onInput, onChange] = useSidebarBlockEditor(sidebar);
    useBlocksFocusControl(blocks);
    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
      ExperimentalBlockEditorProvider,
      {
        value: blocks,
        onInput,
        onChange,
        settings,
        useSubRegistry: false,
        children
      }
    );
  }

  // packages/customize-widgets/build-module/components/welcome-guide/index.mjs
  var import_i18n8 = __toESM(require_i18n(), 1);
  var import_components7 = __toESM(require_components(), 1);
  var import_data9 = __toESM(require_data(), 1);
  var import_preferences2 = __toESM(require_preferences(), 1);
  var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
  function WelcomeGuide({ sidebar }) {
    const { toggle } = (0, import_data9.useDispatch)(import_preferences2.store);
    const isEntirelyBlockWidgets = sidebar.getWidgets().every((widget) =&gt; widget.id.startsWith(&quot;block-&quot;));
    return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(&quot;div&quot;, { className: &quot;customize-widgets-welcome-guide&quot;, children: [
      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(&quot;div&quot;, { className: &quot;customize-widgets-welcome-guide__image__wrapper&quot;, children: /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(&quot;picture&quot;, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
          &quot;source&quot;,
          {
            srcSet: &quot;https://s.w.org/images/block-editor/welcome-editor.svg&quot;,
            media: &quot;(prefers-reduced-motion: reduce)&quot;
          }
        ),
        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
          &quot;img&quot;,
          {
            className: &quot;customize-widgets-welcome-guide__image&quot;,
            src: &quot;https://s.w.org/images/block-editor/welcome-editor.gif&quot;,
            width: &quot;312&quot;,
            height: &quot;240&quot;,
            alt: &quot;&quot;
          }
        )
      ] }) }),
      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(&quot;h1&quot;, { className: &quot;customize-widgets-welcome-guide__heading&quot;, children: (0, import_i18n8.__)(&quot;Welcome to block Widgets&quot;) }),
      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(&quot;p&quot;, { className: &quot;customize-widgets-welcome-guide__text&quot;, children: isEntirelyBlockWidgets ? (0, import_i18n8.__)(
        &quot;Your theme provides different \u201Cblock\u201D areas for you to add and edit content.\xA0Try adding a search bar, social icons, or other types of blocks here and see how they\u2019ll look on your site.&quot;
      ) : (0, import_i18n8.__)(
        &quot;You can now add any block to your site\u2019s widget areas. Don\u2019t worry, all of your favorite widgets still work flawlessly.&quot;
      ) }),
      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
        import_components7.Button,
        {
          size: &quot;compact&quot;,
          variant: &quot;primary&quot;,
          onClick: () =&gt; toggle(&quot;core/customize-widgets&quot;, &quot;welcomeGuide&quot;),
          children: (0, import_i18n8.__)(&quot;Got it&quot;)
        }
      ),
      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(&quot;hr&quot;, { className: &quot;customize-widgets-welcome-guide__separator&quot; }),
      !isEntirelyBlockWidgets &amp;&amp; /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(&quot;p&quot;, { className: &quot;customize-widgets-welcome-guide__more-info&quot;, children: [
        (0, import_i18n8.__)(&quot;Want to stick with the old widgets?&quot;),
        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(&quot;br&quot;, {}),
        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
          import_components7.ExternalLink,
          {
            href: (0, import_i18n8.__)(
              &quot;https://wordpress.org/plugins/classic-widgets/&quot;
            ),
            children: (0, import_i18n8.__)(&quot;Get the Classic Widgets plugin.&quot;)
          }
        )
      ] }),
      /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(&quot;p&quot;, { className: &quot;customize-widgets-welcome-guide__more-info&quot;, children: [
        (0, import_i18n8.__)(&quot;New to the block editor?&quot;),
        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(&quot;br&quot;, {}),
        /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
          import_components7.ExternalLink,
          {
            href: (0, import_i18n8.__)(
              &quot;https://wordpress.org/documentation/article/wordpress-block-editor/&quot;
            ),
            children: (0, import_i18n8.__)(&quot;Here&#039;s a detailed guide.&quot;)
          }
        )
      ] })
    ] });
  }

  // packages/customize-widgets/build-module/components/keyboard-shortcuts/index.mjs
  var import_element12 = __toESM(require_element(), 1);
  var import_keyboard_shortcuts4 = __toESM(require_keyboard_shortcuts(), 1);
  var import_keycodes4 = __toESM(require_keycodes(), 1);
  var import_data10 = __toESM(require_data(), 1);
  var import_i18n9 = __toESM(require_i18n(), 1);
  var import_block_editor7 = __toESM(require_block_editor(), 1);
  var { usesNativeUndo } = unlock(import_block_editor7.privateApis);
  function KeyboardShortcuts({ undo, redo, save }) {
    (0, import_keyboard_shortcuts4.useShortcut)(&quot;core/customize-widgets/undo&quot;, (event) =&gt; {
      if (usesNativeUndo(event)) {
        return;
      }
      undo();
      event.preventDefault();
    });
    (0, import_keyboard_shortcuts4.useShortcut)(&quot;core/customize-widgets/redo&quot;, (event) =&gt; {
      if (usesNativeUndo(event)) {
        return;
      }
      redo();
      event.preventDefault();
    });
    (0, import_keyboard_shortcuts4.useShortcut)(&quot;core/customize-widgets/save&quot;, (event) =&gt; {
      event.preventDefault();
      save();
    });
    return null;
  }
  function KeyboardShortcutsRegister() {
    const { registerShortcut, unregisterShortcut } = (0, import_data10.useDispatch)(
      import_keyboard_shortcuts4.store
    );
    (0, import_element12.useEffect)(() =&gt; {
      registerShortcut({
        name: &quot;core/customize-widgets/undo&quot;,
        category: &quot;global&quot;,
        description: (0, import_i18n9.__)(&quot;Undo your last changes.&quot;),
        keyCombination: {
          modifier: &quot;primary&quot;,
          character: &quot;z&quot;
        }
      });
      registerShortcut({
        name: &quot;core/customize-widgets/redo&quot;,
        category: &quot;global&quot;,
        description: (0, import_i18n9.__)(&quot;Redo your last undo.&quot;),
        keyCombination: {
          modifier: &quot;primaryShift&quot;,
          character: &quot;z&quot;
        },
        // Disable on Apple OS because it conflicts with the browser&#039;s
        // history shortcut. It&#039;s a fine alias for both Windows and Linux.
        // Since there&#039;s no conflict for Ctrl+Shift+Z on both Windows and
        // Linux, we keep it as the default for consistency.
        aliases: (0, import_keycodes4.isAppleOS)() ? [] : [
          {
            modifier: &quot;primary&quot;,
            character: &quot;y&quot;
          }
        ]
      });
      registerShortcut({
        name: &quot;core/customize-widgets/save&quot;,
        category: &quot;global&quot;,
        description: (0, import_i18n9.__)(&quot;Save your changes.&quot;),
        keyCombination: {
          modifier: &quot;primary&quot;,
          character: &quot;s&quot;
        }
      });
      return () =&gt; {
        unregisterShortcut(&quot;core/customize-widgets/undo&quot;);
        unregisterShortcut(&quot;core/customize-widgets/redo&quot;);
        unregisterShortcut(&quot;core/customize-widgets/save&quot;);
      };
    }, [registerShortcut]);
    return null;
  }
  KeyboardShortcuts.Register = KeyboardShortcutsRegister;
  var keyboard_shortcuts_default = KeyboardShortcuts;

  // packages/customize-widgets/build-module/components/block-appender/index.mjs
  var import_element13 = __toESM(require_element(), 1);
  var import_block_editor8 = __toESM(require_block_editor(), 1);
  var import_data11 = __toESM(require_data(), 1);
  var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
  function BlockAppender(props) {
    const ref = (0, import_element13.useRef)();
    const isBlocksListEmpty = (0, import_data11.useSelect)(
      (select) =&gt; select(import_block_editor8.store).getBlockCount() === 0
    );
    (0, import_element13.useEffect)(() =&gt; {
      if (isBlocksListEmpty &amp;&amp; ref.current) {
        const { ownerDocument } = ref.current;
        if (!ownerDocument.activeElement || ownerDocument.activeElement === ownerDocument.body) {
          ref.current.focus();
        }
      }
    }, [isBlocksListEmpty]);
    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_block_editor8.ButtonBlockAppender, { ...props, ref });
  }

  // packages/customize-widgets/build-module/components/sidebar-block-editor/index.mjs
  var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
  var { ExperimentalBlockCanvas: BlockCanvas } = unlock(
    import_block_editor9.privateApis
  );
  var { BlockKeyboardShortcuts } = unlock(import_block_library.privateApis);
  function SidebarBlockEditor({
    blockEditorSettings,
    sidebar,
    inserter,
    inspector
  }) {
    const [isInserterOpened2, setIsInserterOpened2] = useInserter(inserter);
    const isMediumViewport = (0, import_compose3.useViewportMatch)(&quot;small&quot;);
    const {
      hasUploadPermissions,
      isFixedToolbarActive,
      keepCaretInsideBlock,
      isWelcomeGuideActive
    } = (0, import_data12.useSelect)((select) =&gt; {
      const { get } = select(import_preferences3.store);
      return {
        hasUploadPermissions: select(import_core_data.store).canUser(&quot;create&quot;, {
          kind: &quot;postType&quot;,
          name: &quot;attachment&quot;
        }) ?? true,
        isFixedToolbarActive: !!get(
          &quot;core/customize-widgets&quot;,
          &quot;fixedToolbar&quot;
        ),
        keepCaretInsideBlock: !!get(
          &quot;core/customize-widgets&quot;,
          &quot;keepCaretInsideBlock&quot;
        ),
        isWelcomeGuideActive: !!get(
          &quot;core/customize-widgets&quot;,
          &quot;welcomeGuide&quot;
        )
      };
    }, []);
    const settings = (0, import_element14.useMemo)(() =&gt; {
      let mediaUploadBlockEditor;
      if (hasUploadPermissions) {
        mediaUploadBlockEditor = ({ onError, ...argumentsObject }) =&gt; {
          (0, import_media_utils.uploadMedia)({
            wpAllowedMimeTypes: blockEditorSettings.allowedMimeTypes,
            onError: ({ message }) =&gt; onError(message),
            ...argumentsObject
          });
        };
      }
      return {
        ...blockEditorSettings,
        __experimentalSetIsInserterOpened: setIsInserterOpened2,
        mediaUpload: mediaUploadBlockEditor,
        hasFixedToolbar: isFixedToolbarActive || !isMediumViewport,
        keepCaretInsideBlock,
        editorTool: &quot;edit&quot;,
        __unstableHasCustomAppender: true
      };
    }, [
      hasUploadPermissions,
      blockEditorSettings,
      isFixedToolbarActive,
      isMediumViewport,
      keepCaretInsideBlock,
      setIsInserterOpened2
    ]);
    if (isWelcomeGuideActive) {
      return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(WelcomeGuide, { sidebar });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_jsx_runtime19.Fragment, { children: [
      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(keyboard_shortcuts_default.Register, {}),
      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(BlockKeyboardShortcuts, {}),
      /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(SidebarEditorProvider, { sidebar, settings, children: [
        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
          keyboard_shortcuts_default,
          {
            undo: sidebar.undo,
            redo: sidebar.redo,
            save: sidebar.save
          }
        ),
        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
          header_default,
          {
            sidebar,
            inserter,
            isInserterOpened: isInserterOpened2,
            setIsInserterOpened: setIsInserterOpened2,
            isFixedToolbarActive: isFixedToolbarActive || !isMediumViewport
          }
        ),
        (isFixedToolbarActive || !isMediumViewport) &amp;&amp; /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_block_editor9.BlockToolbar, { hideDragHandle: true }),
        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
          BlockCanvas,
          {
            shouldIframe: false,
            styles: settings.defaultEditorStyles,
            height: &quot;100%&quot;,
            children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_block_editor9.BlockList, { renderAppender: BlockAppender })
          }
        ),
        (0, import_element14.createPortal)(
          // This is a temporary hack to prevent button component inside &lt;BlockInspector&gt;
          // from submitting form when type=&quot;button&quot; is not specified.
          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(&quot;form&quot;, { onSubmit: (event) =&gt; event.preventDefault(), children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_block_editor9.BlockInspector, {}) }),
          inspector.contentContainer[0]
        )
      ] }),
      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_block_editor9.__unstableBlockSettingsMenuFirstItem, { children: ({ onClose }) =&gt; /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
        block_inspector_button_default,
        {
          inspector,
          closeMenu: onClose
        }
      ) })
    ] });
  }

  // packages/customize-widgets/build-module/components/sidebar-controls/index.mjs
  var import_element15 = __toESM(require_element(), 1);
  var import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
  var SidebarControlsContext = (0, import_element15.createContext)();
  SidebarControlsContext.displayName = &quot;SidebarControlsContext&quot;;
  function SidebarControls({
    sidebarControls,
    activeSidebarControl,
    children
  }) {
    const context = (0, import_element15.useMemo)(
      () =&gt; ({
        sidebarControls,
        activeSidebarControl
      }),
      [sidebarControls, activeSidebarControl]
    );
    return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(SidebarControlsContext.Provider, { value: context, children });
  }
  function useSidebarControls() {
    const { sidebarControls } = (0, import_element15.useContext)(SidebarControlsContext);
    return sidebarControls;
  }
  function useActiveSidebarControl() {
    const { activeSidebarControl } = (0, import_element15.useContext)(SidebarControlsContext);
    return activeSidebarControl;
  }

  // packages/customize-widgets/build-module/components/customize-widgets/use-clear-selected-block.mjs
  var import_element16 = __toESM(require_element(), 1);
  var import_data13 = __toESM(require_data(), 1);
  var import_block_editor10 = __toESM(require_block_editor(), 1);
  function useClearSelectedBlock(sidebarControl, popoverRef) {
    const { hasSelectedBlock, hasMultiSelection } = (0, import_data13.useSelect)(import_block_editor10.store);
    const { clearSelectedBlock } = (0, import_data13.useDispatch)(import_block_editor10.store);
    (0, import_element16.useEffect)(() =&gt; {
      if (popoverRef.current &amp;&amp; sidebarControl) {
        let handleClearSelectedBlock = function(element) {
          if (
            // 1. Make sure there are blocks being selected.
            (hasSelectedBlock() || hasMultiSelection()) &amp;&amp; // 2. The element should exist in the DOM (not deleted).
            element &amp;&amp; ownerDocument.contains(element) &amp;&amp; // 3. It should also not exist in the container, the popover, nor the dialog.
            !container.contains(element) &amp;&amp; !popoverRef.current.contains(element) &amp;&amp; !element.closest(&#039;[role=&quot;dialog&quot;]&#039;) &amp;&amp; // 4. The inspector should not be opened.
            !inspector.expanded()
          ) {
            clearSelectedBlock();
          }
        }, handleMouseDown = function(event) {
          handleClearSelectedBlock(event.target);
        }, handleBlur = function() {
          handleClearSelectedBlock(ownerDocument.activeElement);
        };
        const inspector = sidebarControl.inspector;
        const container = sidebarControl.container[0];
        const ownerDocument = container.ownerDocument;
        const ownerWindow = ownerDocument.defaultView;
        ownerDocument.addEventListener(&quot;mousedown&quot;, handleMouseDown);
        ownerWindow.addEventListener(&quot;blur&quot;, handleBlur);
        return () =&gt; {
          ownerDocument.removeEventListener(
            &quot;mousedown&quot;,
            handleMouseDown
          );
          ownerWindow.removeEventListener(&quot;blur&quot;, handleBlur);
        };
      }
    }, [
      popoverRef,
      sidebarControl,
      hasSelectedBlock,
      hasMultiSelection,
      clearSelectedBlock
    ]);
  }

  // packages/customize-widgets/build-module/components/customize-widgets/index.mjs
  var import_jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
  function CustomizeWidgets({
    api,
    sidebarControls,
    blockEditorSettings
  }) {
    const [activeSidebarControl, setActiveSidebarControl] = (0, import_element17.useState)(null);
    const parentContainer = document.getElementById(
      &quot;customize-theme-controls&quot;
    );
    const popoverRef = (0, import_element17.useRef)();
    const adminPrimary = (0, import_element17.useMemo)(() =&gt; getAdminThemeColors().primary, []);
    useClearSelectedBlock(activeSidebarControl, popoverRef);
    (0, import_element17.useEffect)(() =&gt; {
      const unsubscribers = sidebarControls.map(
        (sidebarControl) =&gt; sidebarControl.subscribe((expanded) =&gt; {
          if (expanded) {
            setActiveSidebarControl(sidebarControl);
          }
        })
      );
      return () =&gt; {
        unsubscribers.forEach((unsubscriber) =&gt; unsubscriber());
      };
    }, [sidebarControls]);
    const activeSidebar = activeSidebarControl &amp;&amp; (0, import_element17.createPortal)(
      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(ErrorBoundary, { children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
        SidebarBlockEditor,
        {
          blockEditorSettings,
          sidebar: activeSidebarControl.sidebarAdapter,
          inserter: activeSidebarControl.inserter,
          inspector: activeSidebarControl.inspector
        },
        activeSidebarControl.id
      ) }),
      activeSidebarControl.container[0]
    );
    const popover = parentContainer &amp;&amp; (0, import_element17.createPortal)(
      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(&quot;div&quot;, { className: &quot;customize-widgets-popover&quot;, ref: popoverRef, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_components8.Popover.Slot, {}) }),
      parentContainer
    );
    return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_components8.SlotFillProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_theme.ThemeProvider, { isRoot: true, color: { primary: adminPrimary }, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
      SidebarControls,
      {
        sidebarControls,
        activeSidebarControl,
        children: /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(
          FocusControl,
          {
            api,
            sidebarControls,
            children: [
              activeSidebar,
              popover
            ]
          }
        )
      }
    ) }) });
  }

  // packages/customize-widgets/build-module/controls/sidebar-section.mjs
  var import_i18n10 = __toESM(require_i18n(), 1);

  // packages/customize-widgets/build-module/controls/inspector-section.mjs
  function getInspectorSection() {
    const {
      wp: { customize }
    } = window;
    return class InspectorSection extends customize.Section {
      constructor(id, options) {
        super(id, options);
        this.parentSection = options.parentSection;
        this.returnFocusWhenClose = null;
        this._isOpen = false;
      }
      get isOpen() {
        return this._isOpen;
      }
      set isOpen(value) {
        this._isOpen = value;
        this.triggerActiveCallbacks();
      }
      ready() {
        this.contentContainer[0].classList.add(
          &quot;customize-widgets-layout__inspector&quot;
        );
      }
      isContextuallyActive() {
        return this.isOpen;
      }
      onChangeExpanded(expanded, args) {
        super.onChangeExpanded(expanded, args);
        if (this.parentSection &amp;&amp; !args.unchanged) {
          if (expanded) {
            this.parentSection.collapse({
              manualTransition: true
            });
          } else {
            this.parentSection.expand({
              manualTransition: true,
              completeCallback: () =&gt; {
                if (this.returnFocusWhenClose &amp;&amp; !this.contentContainer[0].contains(
                  this.returnFocusWhenClose
                )) {
                  this.returnFocusWhenClose.focus();
                }
              }
            });
          }
        }
      }
      open({ returnFocusWhenClose } = {}) {
        this.isOpen = true;
        this.returnFocusWhenClose = returnFocusWhenClose;
        this.expand({
          allowMultiple: true
        });
      }
      close() {
        this.collapse({
          allowMultiple: true
        });
      }
      collapse(options) {
        this.isOpen = false;
        super.collapse(options);
      }
      triggerActiveCallbacks() {
        this.active.callbacks.fireWith(this.active, [false, true]);
      }
    };
  }

  // packages/customize-widgets/build-module/controls/sidebar-section.mjs
  var getInspectorSectionId = (sidebarId) =&gt; `widgets-inspector-${sidebarId}`;
  function getSidebarSection() {
    const {
      wp: { customize }
    } = window;
    const reduceMotionMediaQuery = window.matchMedia(
      &quot;(prefers-reduced-motion: reduce)&quot;
    );
    let isReducedMotion = reduceMotionMediaQuery.matches;
    reduceMotionMediaQuery.addEventListener(&quot;change&quot;, (event) =&gt; {
      isReducedMotion = event.matches;
    });
    return class SidebarSection extends customize.Section {
      ready() {
        const InspectorSection = getInspectorSection();
        this.inspector = new InspectorSection(
          getInspectorSectionId(this.id),
          {
            title: (0, import_i18n10.__)(&quot;Block Settings&quot;),
            parentSection: this,
            customizeAction: [
              (0, import_i18n10.__)(&quot;Customizing&quot;),
              (0, import_i18n10.__)(&quot;Widgets&quot;),
              this.params.title
            ].join(&quot; \u25B8 &quot;)
          }
        );
        customize.section.add(this.inspector);
        this.contentContainer[0].classList.add(
          &quot;customize-widgets__sidebar-section&quot;
        );
      }
      hasSubSectionOpened() {
        return this.inspector.expanded();
      }
      onChangeExpanded(expanded, _args) {
        const controls = this.controls();
        const args = {
          ..._args,
          completeCallback() {
            controls.forEach((control) =&gt; {
              control.onChangeSectionExpanded?.(expanded, args);
            });
            _args.completeCallback?.();
          }
        };
        if (args.manualTransition) {
          if (expanded) {
            this.contentContainer.addClass([&quot;busy&quot;, &quot;open&quot;]);
            this.contentContainer.removeClass(&quot;is-sub-section-open&quot;);
            this.contentContainer.closest(&quot;.wp-full-overlay&quot;).addClass(&quot;section-open&quot;);
          } else {
            this.contentContainer.addClass([
              &quot;busy&quot;,
              &quot;is-sub-section-open&quot;
            ]);
            this.contentContainer.closest(&quot;.wp-full-overlay&quot;).addClass(&quot;section-open&quot;);
            this.contentContainer.removeClass(&quot;open&quot;);
          }
          const handleTransitionEnd = () =&gt; {
            this.contentContainer.removeClass(&quot;busy&quot;);
            args.completeCallback();
          };
          if (isReducedMotion) {
            handleTransitionEnd();
          } else {
            this.contentContainer.one(
              &quot;transitionend&quot;,
              handleTransitionEnd
            );
          }
        } else {
          super.onChangeExpanded(expanded, args);
        }
      }
    };
  }

  // packages/customize-widgets/build-module/controls/sidebar-control.mjs
  var import_data15 = __toESM(require_data(), 1);

  // packages/customize-widgets/build-module/components/sidebar-block-editor/sidebar-adapter.mjs
  var { wp } = window;
  function parseWidgetId(widgetId) {
    const matches = widgetId.match(/^(.+)-(\d+)$/);
    if (matches) {
      return {
        idBase: matches[1],
        number: parseInt(matches[2], 10)
      };
    }
    return { idBase: widgetId };
  }
  function widgetIdToSettingId(widgetId) {
    const { idBase, number } = parseWidgetId(widgetId);
    if (number) {
      return `widget_${idBase}[${number}]`;
    }
    return `widget_${idBase}`;
  }
  function debounce(leading, callback, timeout) {
    let isLeading = false;
    let timerID;
    function debounced(...args) {
      const result = (isLeading ? callback : leading).apply(this, args);
      isLeading = true;
      clearTimeout(timerID);
      timerID = setTimeout(() =&gt; {
        isLeading = false;
      }, timeout);
      return result;
    }
    debounced.cancel = () =&gt; {
      isLeading = false;
      clearTimeout(timerID);
    };
    return debounced;
  }
  var SidebarAdapter = class {
    constructor(setting, api) {
      this.setting = setting;
      this.api = api;
      this.locked = false;
      this.widgetsCache = /* @__PURE__ */ new WeakMap();
      this.subscribers = /* @__PURE__ */ new Set();
      this.history = [
        this._getWidgetIds().map(
          (widgetId) =&gt; this.getWidget(widgetId)
        )
      ];
      this.historyIndex = 0;
      this.historySubscribers = /* @__PURE__ */ new Set();
      this._debounceSetHistory = debounce(
        this._pushHistory,
        this._replaceHistory,
        1e3
      );
      this.setting.bind(this._handleSettingChange.bind(this));
      this.api.bind(&quot;change&quot;, this._handleAllSettingsChange.bind(this));
      this.undo = this.undo.bind(this);
      this.redo = this.redo.bind(this);
      this.save = this.save.bind(this);
    }
    subscribe(callback) {
      this.subscribers.add(callback);
      return () =&gt; {
        this.subscribers.delete(callback);
      };
    }
    getWidgets() {
      return this.history[this.historyIndex];
    }
    _emit(...args) {
      for (const callback of this.subscribers) {
        callback(...args);
      }
    }
    _getWidgetIds() {
      return this.setting.get();
    }
    _pushHistory() {
      this.history = [
        ...this.history.slice(0, this.historyIndex + 1),
        this._getWidgetIds().map(
          (widgetId) =&gt; this.getWidget(widgetId)
        )
      ];
      this.historyIndex += 1;
      this.historySubscribers.forEach((listener) =&gt; listener());
    }
    _replaceHistory() {
      this.history[this.historyIndex] = this._getWidgetIds().map(
        (widgetId) =&gt; this.getWidget(widgetId)
      );
    }
    _handleSettingChange() {
      if (this.locked) {
        return;
      }
      const prevWidgets = this.getWidgets();
      this._pushHistory();
      this._emit(prevWidgets, this.getWidgets());
    }
    _handleAllSettingsChange(setting) {
      if (this.locked) {
        return;
      }
      if (!setting.id.startsWith(&quot;widget_&quot;)) {
        return;
      }
      const widgetId = settingIdToWidgetId(setting.id);
      if (!this.setting.get().includes(widgetId)) {
        return;
      }
      const prevWidgets = this.getWidgets();
      this._pushHistory();
      this._emit(prevWidgets, this.getWidgets());
    }
    _createWidget(widget) {
      const widgetModel = wp.customize.Widgets.availableWidgets.findWhere({
        id_base: widget.idBase
      });
      let number = widget.number;
      if (widgetModel.get(&quot;is_multi&quot;) &amp;&amp; !number) {
        widgetModel.set(
          &quot;multi_number&quot;,
          widgetModel.get(&quot;multi_number&quot;) + 1
        );
        number = widgetModel.get(&quot;multi_number&quot;);
      }
      const settingId = number ? `widget_${widget.idBase}[${number}]` : `widget_${widget.idBase}`;
      const settingArgs = {
        transport: wp.customize.Widgets.data.selectiveRefreshableWidgets[widgetModel.get(&quot;id_base&quot;)] ? &quot;postMessage&quot; : &quot;refresh&quot;,
        previewer: this.setting.previewer
      };
      const setting = this.api.create(
        settingId,
        settingId,
        &quot;&quot;,
        settingArgs
      );
      setting.set(widget.instance);
      const widgetId = settingIdToWidgetId(settingId);
      return widgetId;
    }
    _removeWidget(widget) {
      const settingId = widgetIdToSettingId(widget.id);
      const setting = this.api(settingId);
      if (setting) {
        const instance = setting.get();
        this.widgetsCache.delete(instance);
      }
      this.api.remove(settingId);
    }
    _updateWidget(widget) {
      const prevWidget = this.getWidget(widget.id);
      if (prevWidget === widget) {
        return widget.id;
      }
      if (prevWidget.idBase &amp;&amp; widget.idBase &amp;&amp; prevWidget.idBase === widget.idBase) {
        const settingId = widgetIdToSettingId(widget.id);
        this.api(settingId).set(widget.instance);
        return widget.id;
      }
      this._removeWidget(widget);
      return this._createWidget(widget);
    }
    getWidget(widgetId) {
      if (!widgetId) {
        return null;
      }
      const { idBase, number } = parseWidgetId(widgetId);
      const settingId = widgetIdToSettingId(widgetId);
      const setting = this.api(settingId);
      if (!setting) {
        return null;
      }
      const instance = setting.get();
      if (this.widgetsCache.has(instance)) {
        return this.widgetsCache.get(instance);
      }
      const widget = {
        id: widgetId,
        idBase,
        number,
        instance
      };
      this.widgetsCache.set(instance, widget);
      return widget;
    }
    _updateWidgets(nextWidgets) {
      this.locked = true;
      const addedWidgetIds = [];
      const nextWidgetIds = nextWidgets.map((nextWidget) =&gt; {
        if (nextWidget.id &amp;&amp; this.getWidget(nextWidget.id)) {
          addedWidgetIds.push(null);
          return this._updateWidget(nextWidget);
        }
        const widgetId = this._createWidget(nextWidget);
        addedWidgetIds.push(widgetId);
        return widgetId;
      });
      const deletedWidgets = this.getWidgets().filter(
        (widget) =&gt; !nextWidgetIds.includes(widget.id)
      );
      deletedWidgets.forEach((widget) =&gt; this._removeWidget(widget));
      this.setting.set(nextWidgetIds);
      this.locked = false;
      return addedWidgetIds;
    }
    setWidgets(nextWidgets) {
      const addedWidgetIds = this._updateWidgets(nextWidgets);
      this._debounceSetHistory();
      return addedWidgetIds;
    }
    /**
     * Undo/Redo related features
     */
    hasUndo() {
      return this.historyIndex &gt; 0;
    }
    hasRedo() {
      return this.historyIndex &lt; this.history.length - 1;
    }
    _seek(historyIndex) {
      const currentWidgets = this.getWidgets();
      this.historyIndex = historyIndex;
      const widgets = this.history[this.historyIndex];
      this._updateWidgets(widgets);
      this._emit(currentWidgets, this.getWidgets());
      this.historySubscribers.forEach((listener) =&gt; listener());
      this._debounceSetHistory.cancel();
    }
    undo() {
      if (!this.hasUndo()) {
        return;
      }
      this._seek(this.historyIndex - 1);
    }
    redo() {
      if (!this.hasRedo()) {
        return;
      }
      this._seek(this.historyIndex + 1);
    }
    subscribeHistory(listener) {
      this.historySubscribers.add(listener);
      return () =&gt; {
        this.historySubscribers.delete(listener);
      };
    }
    save() {
      this.api.previewer.save();
    }
  };

  // packages/customize-widgets/build-module/controls/inserter-outer-section.mjs
  var import_keycodes5 = __toESM(require_keycodes(), 1);
  var import_dom = __toESM(require_dom(), 1);
  var import_data14 = __toESM(require_data(), 1);
  function getInserterOuterSection() {
    const {
      wp: { customize }
    } = window;
    const OuterSection = customize.OuterSection;
    customize.OuterSection = class extends OuterSection {
      onChangeExpanded(expanded, args) {
        if (expanded) {
          customize.section.each((section) =&gt; {
            if (section.params.type === &quot;outer&quot; &amp;&amp; section.id !== this.id) {
              if (section.expanded()) {
                section.collapse();
              }
            }
          });
        }
        return super.onChangeExpanded(expanded, args);
      }
    };
    customize.sectionConstructor.outer = customize.OuterSection;
    return class InserterOuterSection extends customize.OuterSection {
      constructor(...args) {
        super(...args);
        this.params.type = &quot;outer&quot;;
        this.activeElementBeforeExpanded = null;
        const ownerWindow = this.contentContainer[0].ownerDocument.defaultView;
        ownerWindow.addEventListener(
          &quot;keydown&quot;,
          (event) =&gt; {
            if (this.expanded() &amp;&amp; (event.keyCode === import_keycodes5.ESCAPE || event.code === &quot;Escape&quot;) &amp;&amp; !event.defaultPrevented) {
              event.preventDefault();
              event.stopPropagation();
              (0, import_data14.dispatch)(store).setIsInserterOpened(
                false
              );
            }
          },
          // Use capture mode to make this run before other event listeners.
          true
        );
        this.contentContainer.addClass(&quot;widgets-inserter&quot;);
        this.isFromInternalAction = false;
        this.expanded.bind(() =&gt; {
          if (!this.isFromInternalAction) {
            (0, import_data14.dispatch)(store).setIsInserterOpened(
              this.expanded()
            );
          }
          this.isFromInternalAction = false;
        });
      }
      open() {
        if (!this.expanded()) {
          const contentContainer = this.contentContainer[0];
          this.activeElementBeforeExpanded = contentContainer.ownerDocument.activeElement;
          this.isFromInternalAction = true;
          this.expand({
            completeCallback() {
              const searchBox = import_dom.focus.tabbable.find(contentContainer)[1];
              if (searchBox) {
                searchBox.focus();
              }
            }
          });
        }
      }
      close() {
        if (this.expanded()) {
          const contentContainer = this.contentContainer[0];
          const activeElement = contentContainer.ownerDocument.activeElement;
          this.isFromInternalAction = true;
          this.collapse({
            completeCallback() {
              if (contentContainer.contains(activeElement)) {
                if (this.activeElementBeforeExpanded) {
                  this.activeElementBeforeExpanded.focus();
                }
              }
            }
          });
        }
      }
    };
  }

  // packages/customize-widgets/build-module/controls/sidebar-control.mjs
  var getInserterId = (controlId) =&gt; `widgets-inserter-${controlId}`;
  function getSidebarControl() {
    const {
      wp: { customize }
    } = window;
    return class SidebarControl extends customize.Control {
      constructor(...args) {
        super(...args);
        this.subscribers = /* @__PURE__ */ new Set();
      }
      ready() {
        const InserterOuterSection = getInserterOuterSection();
        this.inserter = new InserterOuterSection(
          getInserterId(this.id),
          {}
        );
        customize.section.add(this.inserter);
        this.sectionInstance = customize.section(this.section());
        this.inspector = this.sectionInstance.inspector;
        this.sidebarAdapter = new SidebarAdapter(this.setting, customize);
      }
      subscribe(callback) {
        this.subscribers.add(callback);
        return () =&gt; {
          this.subscribers.delete(callback);
        };
      }
      onChangeSectionExpanded(expanded, args) {
        if (!args.unchanged) {
          if (!expanded) {
            (0, import_data15.dispatch)(store).setIsInserterOpened(
              false
            );
          }
          this.subscribers.forEach(
            (subscriber) =&gt; subscriber(expanded, args)
          );
        }
      }
    };
  }

  // packages/customize-widgets/build-module/filters/move-to-sidebar.mjs
  var import_block_editor11 = __toESM(require_block_editor(), 1);
  var import_compose4 = __toESM(require_compose(), 1);
  var import_data16 = __toESM(require_data(), 1);
  var import_hooks2 = __toESM(require_hooks(), 1);
  var import_widgets4 = __toESM(require_widgets(), 1);
  var import_jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
  var withMoveToSidebarToolbarItem = (0, import_compose4.createHigherOrderComponent)(
    (BlockEdit) =&gt; (props) =&gt; {
      let widgetId = (0, import_widgets4.getWidgetIdFromBlock)(props);
      const sidebarControls = useSidebarControls();
      const activeSidebarControl = useActiveSidebarControl();
      const hasMultipleSidebars = sidebarControls?.length &gt; 1;
      const blockName = props.name;
      const clientId = props.clientId;
      const canInsertBlockInSidebar = (0, import_data16.useSelect)(
        (select) =&gt; {
          return select(import_block_editor11.store).canInsertBlockType(
            blockName,
            &quot;&quot;
          );
        },
        [blockName]
      );
      const block = (0, import_data16.useSelect)(
        (select) =&gt; select(import_block_editor11.store).getBlock(clientId),
        [clientId]
      );
      const { removeBlock } = (0, import_data16.useDispatch)(import_block_editor11.store);
      const [, focusWidget] = useFocusControl();
      function moveToSidebar(sidebarControlId) {
        const newSidebarControl = sidebarControls.find(
          (sidebarControl) =&gt; sidebarControl.id === sidebarControlId
        );
        if (widgetId) {
          const oldSetting = activeSidebarControl.setting;
          const newSetting = newSidebarControl.setting;
          oldSetting(oldSetting().filter((id) =&gt; id !== widgetId));
          newSetting([...newSetting(), widgetId]);
        } else {
          const sidebarAdapter = newSidebarControl.sidebarAdapter;
          removeBlock(clientId);
          const addedWidgetIds = sidebarAdapter.setWidgets([
            ...sidebarAdapter.getWidgets(),
            blockToWidget(block)
          ]);
          widgetId = addedWidgetIds.reverse().find((id) =&gt; !!id);
        }
        focusWidget(widgetId);
      }
      return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_jsx_runtime22.Fragment, { children: [
        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(BlockEdit, { ...props }, &quot;edit&quot;),
        hasMultipleSidebars &amp;&amp; canInsertBlockInSidebar &amp;&amp; /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_block_editor11.BlockControls, { children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
          import_widgets4.MoveToWidgetArea,
          {
            widgetAreas: sidebarControls.map(
              (sidebarControl) =&gt; ({
                id: sidebarControl.id,
                name: sidebarControl.params.label,
                description: sidebarControl.params.description
              })
            ),
            currentWidgetAreaId: activeSidebarControl?.id,
            onSelect: moveToSidebar
          }
        ) })
      ] });
    },
    &quot;withMoveToSidebarToolbarItem&quot;
  );
  (0, import_hooks2.addFilter)(
    &quot;editor.BlockEdit&quot;,
    &quot;core/customize-widgets/block-edit&quot;,
    withMoveToSidebarToolbarItem
  );

  // packages/customize-widgets/build-module/filters/replace-media-upload.mjs
  var import_hooks3 = __toESM(require_hooks(), 1);
  var import_media_utils2 = __toESM(require_media_utils(), 1);
  var replaceMediaUpload = () =&gt; import_media_utils2.MediaUpload;
  (0, import_hooks3.addFilter)(
    &quot;editor.MediaUpload&quot;,
    &quot;core/edit-widgets/replace-media-upload&quot;,
    replaceMediaUpload
  );

  // packages/customize-widgets/build-module/filters/wide-widget-display.mjs
  var import_compose5 = __toESM(require_compose(), 1);
  var import_hooks4 = __toESM(require_hooks(), 1);
  var import_jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
  var { wp: wp2 } = window;
  var withWideWidgetDisplay = (0, import_compose5.createHigherOrderComponent)(
    (BlockEdit) =&gt; (props) =&gt; {
      const { idBase } = props.attributes;
      const isWide = wp2.customize.Widgets.data.availableWidgets.find(
        (widget) =&gt; widget.id_base === idBase
      )?.is_wide ?? false;
      return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(BlockEdit, { ...props, isWide }, &quot;edit&quot;);
    },
    &quot;withWideWidgetDisplay&quot;
  );
  (0, import_hooks4.addFilter)(
    &quot;editor.BlockEdit&quot;,
    &quot;core/customize-widgets/wide-widget-display&quot;,
    withWideWidgetDisplay
  );

  // packages/customize-widgets/build-module/index.mjs
  var import_jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
  var { wp: wp3 } = window;
  var DISABLED_BLOCKS = [
    &quot;core/more&quot;,
    &quot;core/block&quot;,
    &quot;core/freeform&quot;,
    &quot;core/template-part&quot;
  ];
  function initialize(editorName, blockEditorSettings) {
    (0, import_data17.dispatch)(import_preferences4.store).setDefaults(&quot;core/customize-widgets&quot;, {
      fixedToolbar: false,
      welcomeGuide: true
    });
    (0, import_data17.dispatch)(import_blocks2.store).reapplyBlockTypeFilters();
    const coreBlocks = (0, import_block_library2.__experimentalGetCoreBlocks)().filter((block) =&gt; {
      return !(DISABLED_BLOCKS.includes(block.name) || block.name.startsWith(&quot;core/post&quot;) || block.name.startsWith(&quot;core/query&quot;) || block.name.startsWith(&quot;core/site&quot;) || block.name.startsWith(&quot;core/navigation&quot;) || block.name.startsWith(&quot;core/term&quot;));
    });
    (0, import_block_library2.registerCoreBlocks)(coreBlocks);
    (0, import_widgets5.registerLegacyWidgetBlock)();
    if (false) {
      (0, import_block_library2.__experimentalRegisterExperimentalCoreBlocks)({
        enableFSEBlocks: ENABLE_EXPERIMENTAL_FSE_BLOCKS
      });
    }
    (0, import_widgets5.registerLegacyWidgetVariations)(blockEditorSettings);
    (0, import_widgets5.registerWidgetGroupBlock)();
    (0, import_blocks2.setFreeformContentHandlerName)(&quot;core/html&quot;);
    const SidebarControl = getSidebarControl(blockEditorSettings);
    wp3.customize.sectionConstructor.sidebar = getSidebarSection();
    wp3.customize.controlConstructor.sidebar_block_editor = SidebarControl;
    const container = document.createElement(&quot;div&quot;);
    document.body.appendChild(container);
    wp3.customize.bind(&quot;ready&quot;, () =&gt; {
      const sidebarControls = [];
      wp3.customize.control.each((control) =&gt; {
        if (control instanceof SidebarControl) {
          sidebarControls.push(control);
        }
      });
      (0, import_element18.createRoot)(container).render(
        /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_element18.StrictMode, { children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
          CustomizeWidgets,
          {
            api: wp3.customize,
            sidebarControls,
            blockEditorSettings
          }
        ) })
      );
    });
  }
  return __toCommonJS(index_exports);
})();
(window.wp ||= {}).customizeWidgets = wp.customizeWidgets;
})();
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2Fweb%2Ffranchiseregistrierung.kaisers-original.com%2Fhtdocs%2Fwp-includes%2Fjs%2Fdist'>🔙 Back</a></p>