Adding upstream version 6.4.3+dfsg1.upstream/6.4.3+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3222 insertions, 0 deletions

diff --git a/wp-includes/js/dist/customize-widgets.js b/wp-includes/js/dist/customize-widgets.js
new file mode 100644
index 0000000..70f8854
--- /dev/null
+++ b/wp-includes/js/dist/customize-widgets.js
@@ -0,0 +1,3222 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 4403:
+/***/ (function(module, exports) {
+
+var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+	'use strict';
+
+	var hasOwn = {}.hasOwnProperty;
+	var nativeCodeString = '[native code]';
+
+	function classNames() {
+		var classes = [];
+
+		for (var i = 0; i < arguments.length; i++) {
+			var arg = arguments[i];
+			if (!arg) continue;
+
+			var argType = typeof arg;
+
+			if (argType === 'string' || argType === 'number') {
+				classes.push(arg);
+			} else if (Array.isArray(arg)) {
+				if (arg.length) {
+					var inner = classNames.apply(null, arg);
+					if (inner) {
+						classes.push(inner);
+					}
+				}
+			} else if (argType === 'object') {
+				if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
+					classes.push(arg.toString());
+					continue;
+				}
+
+				for (var key in arg) {
+					if (hasOwn.call(arg, key) && arg[key]) {
+						classes.push(key);
+					}
+				}
+			}
+		}
+
+		return classes.join(' ');
+	}
+
+	if ( true && module.exports) {
+		classNames.default = classNames;
+		module.exports = classNames;
+	} else if (true) {
+		// register as 'classnames', consistent with npm package name
+		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
+			return classNames;
+		}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+	} else {}
+}());
+
+
+/***/ }),
+
+/***/ 5619:
+/***/ (function(module) {
+
+"use strict";
+
+
+// do not edit .js files directly - edit src/index.jst
+
+
+  var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
+
+
+module.exports = function equal(a, b) {
+  if (a === b) return true;
+
+  if (a && b && typeof a == 'object' && typeof b == 'object') {
+    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) && (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) && (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) && 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 && 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;
+  }
+
+  // true if both NaN, false otherwise
+  return a!==a && b!==b;
+};
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	!function() {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = function(module) {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				function() { return module['default']; } :
+/******/ 				function() { return module; };
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	!function() {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = function(exports) {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+!function() {
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  initialize: function() { return /* binding */ initialize; },
+  store: function() { return /* reexport */ store; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/customize-widgets/build-module/store/selectors.js
+var selectors_namespaceObject = {};
+__webpack_require__.r(selectors_namespaceObject);
+__webpack_require__.d(selectors_namespaceObject, {
+  __experimentalGetInsertionPoint: function() { return __experimentalGetInsertionPoint; },
+  isInserterOpened: function() { return isInserterOpened; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/customize-widgets/build-module/store/actions.js
+var actions_namespaceObject = {};
+__webpack_require__.r(actions_namespaceObject);
+__webpack_require__.d(actions_namespaceObject, {
+  setIsInserterOpened: function() { return setIsInserterOpened; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/actions.js
+var store_actions_namespaceObject = {};
+__webpack_require__.r(store_actions_namespaceObject);
+__webpack_require__.d(store_actions_namespaceObject, {
+  closeModal: function() { return closeModal; },
+  disableComplementaryArea: function() { return disableComplementaryArea; },
+  enableComplementaryArea: function() { return enableComplementaryArea; },
+  openModal: function() { return openModal; },
+  pinItem: function() { return pinItem; },
+  setDefaultComplementaryArea: function() { return setDefaultComplementaryArea; },
+  setFeatureDefaults: function() { return setFeatureDefaults; },
+  setFeatureValue: function() { return setFeatureValue; },
+  toggleFeature: function() { return toggleFeature; },
+  unpinItem: function() { return unpinItem; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/selectors.js
+var store_selectors_namespaceObject = {};
+__webpack_require__.r(store_selectors_namespaceObject);
+__webpack_require__.d(store_selectors_namespaceObject, {
+  getActiveComplementaryArea: function() { return getActiveComplementaryArea; },
+  isComplementaryAreaLoading: function() { return isComplementaryAreaLoading; },
+  isFeatureActive: function() { return isFeatureActive; },
+  isItemPinned: function() { return isItemPinned; },
+  isModalActive: function() { return isModalActive; }
+});
+
+;// CONCATENATED MODULE: external ["wp","element"]
+var external_wp_element_namespaceObject = window["wp"]["element"];
+;// CONCATENATED MODULE: external ["wp","blockLibrary"]
+var external_wp_blockLibrary_namespaceObject = window["wp"]["blockLibrary"];
+;// CONCATENATED MODULE: external ["wp","widgets"]
+var external_wp_widgets_namespaceObject = window["wp"]["widgets"];
+;// CONCATENATED MODULE: external ["wp","blocks"]
+var external_wp_blocks_namespaceObject = window["wp"]["blocks"];
+;// CONCATENATED MODULE: external ["wp","data"]
+var external_wp_data_namespaceObject = window["wp"]["data"];
+;// CONCATENATED MODULE: external ["wp","preferences"]
+var external_wp_preferences_namespaceObject = window["wp"]["preferences"];
+;// CONCATENATED MODULE: external ["wp","components"]
+var external_wp_components_namespaceObject = window["wp"]["components"];
+;// CONCATENATED MODULE: external ["wp","i18n"]
+var external_wp_i18n_namespaceObject = window["wp"]["i18n"];
+;// CONCATENATED MODULE: external ["wp","blockEditor"]
+var external_wp_blockEditor_namespaceObject = window["wp"]["blockEditor"];
+;// CONCATENATED MODULE: external ["wp","compose"]
+var external_wp_compose_namespaceObject = window["wp"]["compose"];
+;// CONCATENATED MODULE: external ["wp","hooks"]
+var external_wp_hooks_namespaceObject = window["wp"]["hooks"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/error-boundary/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+function CopyButton({
+  text,
+  children
+}) {
+  const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(text);
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+    variant: "secondary",
+    ref: ref
+  }, children);
+}
+class ErrorBoundary extends external_wp_element_namespaceObject.Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      error: null
+    };
+  }
+  componentDidCatch(error) {
+    this.setState({
+      error
+    });
+    (0,external_wp_hooks_namespaceObject.doAction)('editor.ErrorBoundary.errorLogged', error);
+  }
+  render() {
+    const {
+      error
+    } = this.state;
+    if (!error) {
+      return this.props.children;
+    }
+    return (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.Warning, {
+      className: "customize-widgets-error-boundary",
+      actions: [(0,external_wp_element_namespaceObject.createElement)(CopyButton, {
+        key: "copy-error",
+        text: error.stack
+      }, (0,external_wp_i18n_namespaceObject.__)('Copy Error'))]
+    }, (0,external_wp_i18n_namespaceObject.__)('The editor has encountered an unexpected error.'));
+  }
+}
+
+;// CONCATENATED MODULE: external ["wp","coreData"]
+var external_wp_coreData_namespaceObject = window["wp"]["coreData"];
+;// CONCATENATED MODULE: external ["wp","mediaUtils"]
+var external_wp_mediaUtils_namespaceObject = window["wp"]["mediaUtils"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/block-inspector-button/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+function BlockInspectorButton({
+  inspector,
+  closeMenu,
+  ...props
+}) {
+  const selectedBlockClientId = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blockEditor_namespaceObject.store).getSelectedBlockClientId(), []);
+  const selectedBlock = (0,external_wp_element_namespaceObject.useMemo)(() => document.getElementById(`block-${selectedBlockClientId}`), [selectedBlockClientId]);
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
+    onClick: () => {
+      // Open the inspector.
+      inspector.open({
+        returnFocusWhenClose: selectedBlock
+      });
+      // Then close the dropdown menu.
+      closeMenu();
+    },
+    ...props
+  }, (0,external_wp_i18n_namespaceObject.__)('Show more settings'));
+}
+/* harmony default export */ var block_inspector_button = (BlockInspectorButton);
+
+// EXTERNAL MODULE: ./node_modules/classnames/index.js
+var classnames = __webpack_require__(4403);
+var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
+;// CONCATENATED MODULE: external ["wp","keycodes"]
+var external_wp_keycodes_namespaceObject = window["wp"]["keycodes"];
+;// CONCATENATED MODULE: external ["wp","primitives"]
+var external_wp_primitives_namespaceObject = window["wp"]["primitives"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/undo.js
+
+/**
+ * WordPress dependencies
+ */
+
+const undo = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+  d: "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"
+}));
+/* harmony default export */ var library_undo = (undo);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/redo.js
+
+/**
+ * WordPress dependencies
+ */
+
+const redo = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+  d: "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"
+}));
+/* harmony default export */ var library_redo = (redo);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/plus.js
+
+/**
+ * WordPress dependencies
+ */
+
+const plus = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+  d: "M18 11.2h-5.2V6h-1.6v5.2H6v1.6h5.2V18h1.6v-5.2H18z"
+}));
+/* harmony default export */ var library_plus = (plus);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/close-small.js
+
+/**
+ * WordPress dependencies
+ */
+
+const closeSmall = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+  d: "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"
+}));
+/* harmony default export */ var close_small = (closeSmall);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/reducer.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Reducer tracking whether the inserter is open.
+ *
+ * @param {boolean|Object} state
+ * @param {Object}         action
+ */
+function blockInserterPanel(state = false, action) {
+  switch (action.type) {
+    case 'SET_IS_INSERTER_OPENED':
+      return action.value;
+  }
+  return state;
+}
+/* harmony default export */ var reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
+  blockInserterPanel
+}));
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/selectors.js
+const EMPTY_INSERTION_POINT = {
+  rootClientId: undefined,
+  insertionIndex: undefined
+};
+
+/**
+ * Returns true if the inserter is opened.
+ *
+ * @param {Object} state Global application state.
+ *
+ * @example
+ * ```js
+ * import { store as customizeWidgetsStore } from '@wordpress/customize-widgets';
+ * import { __ } from '@wordpress/i18n';
+ * import { useSelect } from '@wordpress/data';
+ *
+ * const ExampleComponent = () => {
+ *    const { isInserterOpened } = useSelect(
+ *        ( select ) => select( customizeWidgetsStore ),
+ *        []
+ *    );
+ *
+ *    return isInserterOpened()
+ *        ? __( 'Inserter is open' )
+ *        : __( 'Inserter is closed.' );
+ * };
+ * ```
+ *
+ * @return {boolean} Whether the inserter is opened.
+ */
+function isInserterOpened(state) {
+  return !!state.blockInserterPanel;
+}
+
+/**
+ * Get the insertion point for the inserter.
+ *
+ * @param {Object} state Global application state.
+ *
+ * @return {Object} The root client ID and index to insert at.
+ */
+function __experimentalGetInsertionPoint(state) {
+  if (typeof state.blockInserterPanel === 'boolean') {
+    return EMPTY_INSERTION_POINT;
+  }
+  return state.blockInserterPanel;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/actions.js
+/**
+ * Returns an action object used to open/close the inserter.
+ *
+ * @param {boolean|Object} value                Whether the inserter should be
+ *                                              opened (true) or closed (false).
+ *                                              To specify an insertion point,
+ *                                              use an object.
+ * @param {string}         value.rootClientId   The root client ID to insert at.
+ * @param {number}         value.insertionIndex The index to insert at.
+ *
+ * @example
+ * ```js
+ * import { store as customizeWidgetsStore } from '@wordpress/customize-widgets';
+ * import { __ } from '@wordpress/i18n';
+ * import { useDispatch } from '@wordpress/data';
+ * import { Button } from '@wordpress/components';
+ * import { useState } from '@wordpress/element';
+ *
+ * const ExampleComponent = () => {
+ *   const { setIsInserterOpened } = useDispatch( customizeWidgetsStore );
+ *   const [ isOpen, setIsOpen ] = useState( false );
+ *
+ *    return (
+ *        <Button
+ *            onClick={ () => {
+ *                setIsInserterOpened( ! isOpen );
+ *                setIsOpen( ! isOpen );
+ *            } }
+ *        >
+ *            { __( 'Open/close inserter' ) }
+ *        </Button>
+ *    );
+ * };
+ * ```
+ *
+ * @return {Object} Action object.
+ */
+function setIsInserterOpened(value) {
+  return {
+    type: 'SET_IS_INSERTER_OPENED',
+    value
+  };
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/constants.js
+/**
+ * Module Constants
+ */
+const STORE_NAME = 'core/customize-widgets';
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/store/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+/**
+ * Block editor data store configuration.
+ *
+ * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#registering-a-store
+ *
+ * @type {Object}
+ */
+const storeConfig = {
+  reducer: reducer,
+  selectors: selectors_namespaceObject,
+  actions: actions_namespaceObject
+};
+
+/**
+ * Store definition for the edit widgets namespace.
+ *
+ * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
+ *
+ * @type {Object}
+ */
+const store = (0,external_wp_data_namespaceObject.createReduxStore)(STORE_NAME, storeConfig);
+(0,external_wp_data_namespaceObject.register)(store);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/inserter/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function Inserter({
+  setIsOpened
+}) {
+  const inserterTitleId = (0,external_wp_compose_namespaceObject.useInstanceId)(Inserter, 'customize-widget-layout__inserter-panel-title');
+  const insertionPoint = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).__experimentalGetInsertionPoint(), []);
+  return (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-layout__inserter-panel",
+    "aria-labelledby": inserterTitleId
+  }, (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-layout__inserter-panel-header"
+  }, (0,external_wp_element_namespaceObject.createElement)("h2", {
+    id: inserterTitleId,
+    className: "customize-widgets-layout__inserter-panel-header-title"
+  }, (0,external_wp_i18n_namespaceObject.__)('Add a block')), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+    className: "customize-widgets-layout__inserter-panel-header-close-button",
+    icon: close_small,
+    onClick: () => setIsOpened(false),
+    "aria-label": (0,external_wp_i18n_namespaceObject.__)('Close inserter')
+  })), (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-layout__inserter-panel-content"
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__experimentalLibrary, {
+    rootClientId: insertionPoint.rootClientId,
+    __experimentalInsertionIndex: insertionPoint.insertionIndex,
+    showInserterHelpPanel: true,
+    onSelect: () => setIsOpened(false)
+  })));
+}
+/* harmony default export */ var components_inserter = (Inserter);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/external.js
+
+/**
+ * WordPress dependencies
+ */
+
+const external = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+  d: "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"
+}));
+/* harmony default export */ var library_external = (external);
+
+;// CONCATENATED MODULE: external ["wp","keyboardShortcuts"]
+var external_wp_keyboardShortcuts_namespaceObject = window["wp"]["keyboardShortcuts"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/icons/build-module/library/more-vertical.js
+
+/**
+ * WordPress dependencies
+ */
+
+const moreVertical = (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.SVG, {
+  xmlns: "http://www.w3.org/2000/svg",
+  viewBox: "0 0 24 24"
+}, (0,external_wp_element_namespaceObject.createElement)(external_wp_primitives_namespaceObject.Path, {
+  d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z"
+}));
+/* harmony default export */ var more_vertical = (moreVertical);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/more-menu-dropdown/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+function MoreMenuDropdown({
+  as: DropdownComponent = external_wp_components_namespaceObject.DropdownMenu,
+  className,
+  /* translators: button label text should, if possible, be under 16 characters. */
+  label = (0,external_wp_i18n_namespaceObject.__)('Options'),
+  popoverProps,
+  toggleProps,
+  children
+}) {
+  return (0,external_wp_element_namespaceObject.createElement)(DropdownComponent, {
+    className: classnames_default()('interface-more-menu-dropdown', className),
+    icon: more_vertical,
+    label: label,
+    popoverProps: {
+      placement: 'bottom-end',
+      ...popoverProps,
+      className: classnames_default()('interface-more-menu-dropdown__content', popoverProps?.className)
+    },
+    toggleProps: {
+      tooltipPosition: 'bottom',
+      ...toggleProps
+    }
+  }, onClose => children(onClose));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/components/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: external ["wp","deprecated"]
+var external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
+var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/actions.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Set a default complementary area.
+ *
+ * @param {string} scope Complementary area scope.
+ * @param {string} area  Area identifier.
+ *
+ * @return {Object} Action object.
+ */
+const setDefaultComplementaryArea = (scope, area) => ({
+  type: 'SET_DEFAULT_COMPLEMENTARY_AREA',
+  scope,
+  area
+});
+
+/**
+ * Enable the complementary area.
+ *
+ * @param {string} scope Complementary area scope.
+ * @param {string} area  Area identifier.
+ */
+const enableComplementaryArea = (scope, area) => ({
+  registry,
+  dispatch
+}) => {
+  // Return early if there's no area.
+  if (!area) {
+    return;
+  }
+  const isComplementaryAreaVisible = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+  if (!isComplementaryAreaVisible) {
+    registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'isComplementaryAreaVisible', true);
+  }
+  dispatch({
+    type: 'ENABLE_COMPLEMENTARY_AREA',
+    scope,
+    area
+  });
+};
+
+/**
+ * Disable the complementary area.
+ *
+ * @param {string} scope Complementary area scope.
+ */
+const disableComplementaryArea = scope => ({
+  registry
+}) => {
+  const isComplementaryAreaVisible = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+  if (isComplementaryAreaVisible) {
+    registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'isComplementaryAreaVisible', false);
+  }
+};
+
+/**
+ * Pins an item.
+ *
+ * @param {string} scope Item scope.
+ * @param {string} item  Item identifier.
+ *
+ * @return {Object} Action object.
+ */
+const pinItem = (scope, item) => ({
+  registry
+}) => {
+  // Return early if there's no item.
+  if (!item) {
+    return;
+  }
+  const pinnedItems = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
+
+  // The item is already pinned, there's nothing to do.
+  if (pinnedItems?.[item] === true) {
+    return;
+  }
+  registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'pinnedItems', {
+    ...pinnedItems,
+    [item]: true
+  });
+};
+
+/**
+ * Unpins an item.
+ *
+ * @param {string} scope Item scope.
+ * @param {string} item  Item identifier.
+ */
+const unpinItem = (scope, item) => ({
+  registry
+}) => {
+  // Return early if there's no item.
+  if (!item) {
+    return;
+  }
+  const pinnedItems = registry.select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
+  registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, 'pinnedItems', {
+    ...pinnedItems,
+    [item]: false
+  });
+};
+
+/**
+ * Returns an action object used in signalling that a feature should be toggled.
+ *
+ * @param {string} scope       The feature scope (e.g. core/edit-post).
+ * @param {string} featureName The feature name.
+ */
+function toggleFeature(scope, featureName) {
+  return function ({
+    registry
+  }) {
+    external_wp_deprecated_default()(`dispatch( 'core/interface' ).toggleFeature`, {
+      since: '6.0',
+      alternative: `dispatch( 'core/preferences' ).toggle`
+    });
+    registry.dispatch(external_wp_preferences_namespaceObject.store).toggle(scope, featureName);
+  };
+}
+
+/**
+ * Returns an action object used in signalling that a feature should be set to
+ * a true or false value
+ *
+ * @param {string}  scope       The feature scope (e.g. core/edit-post).
+ * @param {string}  featureName The feature name.
+ * @param {boolean} value       The value to set.
+ *
+ * @return {Object} Action object.
+ */
+function setFeatureValue(scope, featureName, value) {
+  return function ({
+    registry
+  }) {
+    external_wp_deprecated_default()(`dispatch( 'core/interface' ).setFeatureValue`, {
+      since: '6.0',
+      alternative: `dispatch( 'core/preferences' ).set`
+    });
+    registry.dispatch(external_wp_preferences_namespaceObject.store).set(scope, featureName, !!value);
+  };
+}
+
+/**
+ * Returns an action object used in signalling that defaults should be set for features.
+ *
+ * @param {string}                  scope    The feature scope (e.g. core/edit-post).
+ * @param {Object<string, boolean>} defaults A key/value map of feature names to values.
+ *
+ * @return {Object} Action object.
+ */
+function setFeatureDefaults(scope, defaults) {
+  return function ({
+    registry
+  }) {
+    external_wp_deprecated_default()(`dispatch( 'core/interface' ).setFeatureDefaults`, {
+      since: '6.0',
+      alternative: `dispatch( 'core/preferences' ).setDefaults`
+    });
+    registry.dispatch(external_wp_preferences_namespaceObject.store).setDefaults(scope, defaults);
+  };
+}
+
+/**
+ * Returns an action object used in signalling that the user opened a modal.
+ *
+ * @param {string} name A string that uniquely identifies the modal.
+ *
+ * @return {Object} Action object.
+ */
+function openModal(name) {
+  return {
+    type: 'OPEN_MODAL',
+    name
+  };
+}
+
+/**
+ * Returns an action object signalling that the user closed a modal.
+ *
+ * @return {Object} Action object.
+ */
+function closeModal() {
+  return {
+    type: 'CLOSE_MODAL'
+  };
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/selectors.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Returns the complementary area that is active in a given scope.
+ *
+ * @param {Object} state Global application state.
+ * @param {string} scope Item scope.
+ *
+ * @return {string | null | undefined} The complementary area that is active in the given scope.
+ */
+const getActiveComplementaryArea = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope) => {
+  const isComplementaryAreaVisible = select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+
+  // Return `undefined` to indicate that the user has never toggled
+  // visibility, this is the vanilla default. Other code relies on this
+  // nuance in the return value.
+  if (isComplementaryAreaVisible === undefined) {
+    return undefined;
+  }
+
+  // Return `null` to indicate the user hid the complementary area.
+  if (isComplementaryAreaVisible === false) {
+    return null;
+  }
+  return state?.complementaryAreas?.[scope];
+});
+const isComplementaryAreaLoading = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope) => {
+  const isVisible = select(external_wp_preferences_namespaceObject.store).get(scope, 'isComplementaryAreaVisible');
+  const identifier = state?.complementaryAreas?.[scope];
+  return isVisible && identifier === undefined;
+});
+
+/**
+ * Returns a boolean indicating if an item is pinned or not.
+ *
+ * @param {Object} state Global application state.
+ * @param {string} scope Scope.
+ * @param {string} item  Item to check.
+ *
+ * @return {boolean} True if the item is pinned and false otherwise.
+ */
+const isItemPinned = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope, item) => {
+  var _pinnedItems$item;
+  const pinnedItems = select(external_wp_preferences_namespaceObject.store).get(scope, 'pinnedItems');
+  return (_pinnedItems$item = pinnedItems?.[item]) !== null && _pinnedItems$item !== void 0 ? _pinnedItems$item : true;
+});
+
+/**
+ * Returns a boolean indicating whether a feature is active for a particular
+ * scope.
+ *
+ * @param {Object} state       The store state.
+ * @param {string} scope       The scope of the feature (e.g. core/edit-post).
+ * @param {string} featureName The name of the feature.
+ *
+ * @return {boolean} Is the feature enabled?
+ */
+const isFeatureActive = (0,external_wp_data_namespaceObject.createRegistrySelector)(select => (state, scope, featureName) => {
+  external_wp_deprecated_default()(`select( 'core/interface' ).isFeatureActive( scope, featureName )`, {
+    since: '6.0',
+    alternative: `select( 'core/preferences' ).get( scope, featureName )`
+  });
+  return !!select(external_wp_preferences_namespaceObject.store).get(scope, featureName);
+});
+
+/**
+ * Returns true if a modal is active, or false otherwise.
+ *
+ * @param {Object} state     Global application state.
+ * @param {string} modalName A string that uniquely identifies the modal.
+ *
+ * @return {boolean} Whether the modal is active.
+ */
+function isModalActive(state, modalName) {
+  return state.activeModal === modalName;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/reducer.js
+/**
+ * WordPress dependencies
+ */
+
+function complementaryAreas(state = {}, action) {
+  switch (action.type) {
+    case 'SET_DEFAULT_COMPLEMENTARY_AREA':
+      {
+        const {
+          scope,
+          area
+        } = action;
+
+        // If there's already an area, don't overwrite it.
+        if (state[scope]) {
+          return state;
+        }
+        return {
+          ...state,
+          [scope]: area
+        };
+      }
+    case 'ENABLE_COMPLEMENTARY_AREA':
+      {
+        const {
+          scope,
+          area
+        } = action;
+        return {
+          ...state,
+          [scope]: area
+        };
+      }
+  }
+  return state;
+}
+
+/**
+ * Reducer for storing the name of the open modal, or null if no modal is open.
+ *
+ * @param {Object} state  Previous state.
+ * @param {Object} action Action object containing the `name` of the modal
+ *
+ * @return {Object} Updated state
+ */
+function activeModal(state = null, action) {
+  switch (action.type) {
+    case 'OPEN_MODAL':
+      return action.name;
+    case 'CLOSE_MODAL':
+      return null;
+  }
+  return state;
+}
+/* harmony default export */ var store_reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
+  complementaryAreas,
+  activeModal
+}));
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/constants.js
+/**
+ * The identifier for the data store.
+ *
+ * @type {string}
+ */
+const constants_STORE_NAME = 'core/interface';
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/store/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+/**
+ * Store definition for the interface namespace.
+ *
+ * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
+ *
+ * @type {Object}
+ */
+const store_store = (0,external_wp_data_namespaceObject.createReduxStore)(constants_STORE_NAME, {
+  reducer: store_reducer,
+  actions: store_actions_namespaceObject,
+  selectors: store_selectors_namespaceObject
+});
+
+// Once we build a more generic persistence plugin that works across types of stores
+// we'd be able to replace this with a register call.
+(0,external_wp_data_namespaceObject.register)(store_store);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/interface/build-module/index.js
+
+
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/config.js
+/**
+ * WordPress dependencies
+ */
+
+const textFormattingShortcuts = [{
+  keyCombination: {
+    modifier: 'primary',
+    character: 'b'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Make the selected text bold.')
+}, {
+  keyCombination: {
+    modifier: 'primary',
+    character: 'i'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Make the selected text italic.')
+}, {
+  keyCombination: {
+    modifier: 'primary',
+    character: 'k'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Convert the selected text into a link.')
+}, {
+  keyCombination: {
+    modifier: 'primaryShift',
+    character: 'k'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Remove a link.')
+}, {
+  keyCombination: {
+    character: '[['
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Insert a link to a post or page.')
+}, {
+  keyCombination: {
+    modifier: 'primary',
+    character: 'u'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Underline the selected text.')
+}, {
+  keyCombination: {
+    modifier: 'access',
+    character: 'd'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Strikethrough the selected text.')
+}, {
+  keyCombination: {
+    modifier: 'access',
+    character: 'x'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Make the selected text inline code.')
+}, {
+  keyCombination: {
+    modifier: 'access',
+    character: '0'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Convert the current heading to a paragraph.')
+}, {
+  keyCombination: {
+    modifier: 'access',
+    character: '1-6'
+  },
+  description: (0,external_wp_i18n_namespaceObject.__)('Convert the current paragraph or heading to a heading of level 1 to 6.')
+}];
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/shortcut.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+function KeyCombination({
+  keyCombination,
+  forceAriaLabel
+}) {
+  const shortcut = keyCombination.modifier ? external_wp_keycodes_namespaceObject.displayShortcutList[keyCombination.modifier](keyCombination.character) : keyCombination.character;
+  const ariaLabel = keyCombination.modifier ? external_wp_keycodes_namespaceObject.shortcutAriaLabel[keyCombination.modifier](keyCombination.character) : keyCombination.character;
+  return (0,external_wp_element_namespaceObject.createElement)("kbd", {
+    className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-key-combination",
+    "aria-label": forceAriaLabel || ariaLabel
+  }, (Array.isArray(shortcut) ? shortcut : [shortcut]).map((character, index) => {
+    if (character === '+') {
+      return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, {
+        key: index
+      }, character);
+    }
+    return (0,external_wp_element_namespaceObject.createElement)("kbd", {
+      key: index,
+      className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-key"
+    }, character);
+  }));
+}
+function Shortcut({
+  description,
+  keyCombination,
+  aliases = [],
+  ariaLabel
+}) {
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-description"
+  }, description), (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-term"
+  }, (0,external_wp_element_namespaceObject.createElement)(KeyCombination, {
+    keyCombination: keyCombination,
+    forceAriaLabel: ariaLabel
+  }), aliases.map((alias, index) => (0,external_wp_element_namespaceObject.createElement)(KeyCombination, {
+    keyCombination: alias,
+    forceAriaLabel: ariaLabel,
+    key: index
+  }))));
+}
+/* harmony default export */ var keyboard_shortcut_help_modal_shortcut = (Shortcut);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/dynamic-shortcut.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function DynamicShortcut({
+  name
+}) {
+  const {
+    keyCombination,
+    description,
+    aliases
+  } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+    const {
+      getShortcutKeyCombination,
+      getShortcutDescription,
+      getShortcutAliases
+    } = select(external_wp_keyboardShortcuts_namespaceObject.store);
+    return {
+      keyCombination: getShortcutKeyCombination(name),
+      aliases: getShortcutAliases(name),
+      description: getShortcutDescription(name)
+    };
+  }, [name]);
+  if (!keyCombination) {
+    return null;
+  }
+  return (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
+    keyCombination: keyCombination,
+    description: description,
+    aliases: aliases
+  });
+}
+/* harmony default export */ var dynamic_shortcut = (DynamicShortcut);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcut-help-modal/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+const ShortcutList = ({
+  shortcuts
+}) =>
+/*
+ * Disable reason: The `list` ARIA role is redundant but
+ * Safari+VoiceOver won't announce the list otherwise.
+ */
+/* eslint-disable jsx-a11y/no-redundant-roles */
+(0,external_wp_element_namespaceObject.createElement)("ul", {
+  className: "customize-widgets-keyboard-shortcut-help-modal__shortcut-list",
+  role: "list"
+}, shortcuts.map((shortcut, index) => (0,external_wp_element_namespaceObject.createElement)("li", {
+  className: "customize-widgets-keyboard-shortcut-help-modal__shortcut",
+  key: index
+}, typeof shortcut === 'string' ? (0,external_wp_element_namespaceObject.createElement)(dynamic_shortcut, {
+  name: shortcut
+}) : (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcut_help_modal_shortcut, {
+  ...shortcut
+}))))
+/* eslint-enable jsx-a11y/no-redundant-roles */;
+
+const ShortcutSection = ({
+  title,
+  shortcuts,
+  className
+}) => (0,external_wp_element_namespaceObject.createElement)("section", {
+  className: classnames_default()('customize-widgets-keyboard-shortcut-help-modal__section', className)
+}, !!title && (0,external_wp_element_namespaceObject.createElement)("h2", {
+  className: "customize-widgets-keyboard-shortcut-help-modal__section-title"
+}, title), (0,external_wp_element_namespaceObject.createElement)(ShortcutList, {
+  shortcuts: shortcuts
+}));
+const ShortcutCategorySection = ({
+  title,
+  categoryName,
+  additionalShortcuts = []
+}) => {
+  const categoryShortcuts = (0,external_wp_data_namespaceObject.useSelect)(select => {
+    return select(external_wp_keyboardShortcuts_namespaceObject.store).getCategoryShortcuts(categoryName);
+  }, [categoryName]);
+  return (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
+    title: title,
+    shortcuts: categoryShortcuts.concat(additionalShortcuts)
+  });
+};
+function KeyboardShortcutHelpModal({
+  isModalActive,
+  toggleModal
+}) {
+  const {
+    registerShortcut
+  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
+  registerShortcut({
+    name: 'core/customize-widgets/keyboard-shortcuts',
+    category: 'main',
+    description: (0,external_wp_i18n_namespaceObject.__)('Display these keyboard shortcuts.'),
+    keyCombination: {
+      modifier: 'access',
+      character: 'h'
+    }
+  });
+  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/keyboard-shortcuts', toggleModal);
+  if (!isModalActive) {
+    return null;
+  }
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Modal, {
+    className: "customize-widgets-keyboard-shortcut-help-modal",
+    title: (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts'),
+    onRequestClose: toggleModal
+  }, (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
+    className: "customize-widgets-keyboard-shortcut-help-modal__main-shortcuts",
+    shortcuts: ['core/customize-widgets/keyboard-shortcuts']
+  }), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
+    title: (0,external_wp_i18n_namespaceObject.__)('Global shortcuts'),
+    categoryName: "global"
+  }), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
+    title: (0,external_wp_i18n_namespaceObject.__)('Selection shortcuts'),
+    categoryName: "selection"
+  }), (0,external_wp_element_namespaceObject.createElement)(ShortcutCategorySection, {
+    title: (0,external_wp_i18n_namespaceObject.__)('Block shortcuts'),
+    categoryName: "block",
+    additionalShortcuts: [{
+      keyCombination: {
+        character: '/'
+      },
+      description: (0,external_wp_i18n_namespaceObject.__)('Change the block type after adding a new paragraph.'),
+      /* translators: The forward-slash character. e.g. '/'. */
+      ariaLabel: (0,external_wp_i18n_namespaceObject.__)('Forward-slash')
+    }]
+  }), (0,external_wp_element_namespaceObject.createElement)(ShortcutSection, {
+    title: (0,external_wp_i18n_namespaceObject.__)('Text formatting'),
+    shortcuts: textFormattingShortcuts
+  }));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/more-menu/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function MoreMenu() {
+  const [isKeyboardShortcutsModalActive, setIsKeyboardShortcutsModalVisible] = (0,external_wp_element_namespaceObject.useState)(false);
+  const toggleKeyboardShortcutsModal = () => setIsKeyboardShortcutsModalVisible(!isKeyboardShortcutsModalActive);
+  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/keyboard-shortcuts', toggleKeyboardShortcutsModal);
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(MoreMenuDropdown, {
+    as: external_wp_components_namespaceObject.ToolbarDropdownMenu
+  }, () => (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
+    label: (0,external_wp_i18n_namespaceObject._x)('View', 'noun')
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+    scope: "core/customize-widgets",
+    name: "fixedToolbar",
+    label: (0,external_wp_i18n_namespaceObject.__)('Top toolbar'),
+    info: (0,external_wp_i18n_namespaceObject.__)('Access all block and document tools in a single place'),
+    messageActivated: (0,external_wp_i18n_namespaceObject.__)('Top toolbar activated'),
+    messageDeactivated: (0,external_wp_i18n_namespaceObject.__)('Top toolbar deactivated')
+  })), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
+    label: (0,external_wp_i18n_namespaceObject.__)('Tools')
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
+    onClick: () => {
+      setIsKeyboardShortcutsModalVisible(true);
+    },
+    shortcut: external_wp_keycodes_namespaceObject.displayShortcut.access('h')
+  }, (0,external_wp_i18n_namespaceObject.__)('Keyboard shortcuts')), (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+    scope: "core/customize-widgets",
+    name: "welcomeGuide",
+    label: (0,external_wp_i18n_namespaceObject.__)('Welcome Guide')
+  }), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuItem, {
+    role: "menuitem",
+    icon: library_external,
+    href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/block-based-widgets-editor/'),
+    target: "_blank",
+    rel: "noopener noreferrer"
+  }, (0,external_wp_i18n_namespaceObject.__)('Help'), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.VisuallyHidden, {
+    as: "span"
+  }, /* translators: accessibility text */
+  (0,external_wp_i18n_namespaceObject.__)('(opens in a new tab)')))), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.MenuGroup, {
+    label: (0,external_wp_i18n_namespaceObject.__)('Preferences')
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
+    scope: "core/customize-widgets",
+    name: "keepCaretInsideBlock",
+    label: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block'),
+    info: (0,external_wp_i18n_namespaceObject.__)('Aids screen readers by stopping text caret from leaving blocks.'),
+    messageActivated: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block activated'),
+    messageDeactivated: (0,external_wp_i18n_namespaceObject.__)('Contain text cursor inside block deactivated')
+  })))), (0,external_wp_element_namespaceObject.createElement)(KeyboardShortcutHelpModal, {
+    isModalActive: isKeyboardShortcutsModalActive,
+    toggleModal: toggleKeyboardShortcutsModal
+  }));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/header/index.js
+
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+function Header({
+  sidebar,
+  inserter,
+  isInserterOpened,
+  setIsInserterOpened,
+  isFixedToolbarActive
+}) {
+  const [[hasUndo, hasRedo], setUndoRedo] = (0,external_wp_element_namespaceObject.useState)([sidebar.hasUndo(), sidebar.hasRedo()]);
+  const shortcut = (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? external_wp_keycodes_namespaceObject.displayShortcut.primaryShift('z') : external_wp_keycodes_namespaceObject.displayShortcut.primary('y');
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    return sidebar.subscribeHistory(() => {
+      setUndoRedo([sidebar.hasUndo(), sidebar.hasRedo()]);
+    });
+  }, [sidebar]);
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: classnames_default()('customize-widgets-header', {
+      'is-fixed-toolbar-active': isFixedToolbarActive
+    })
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.NavigableToolbar, {
+    className: "customize-widgets-header-toolbar",
+    "aria-label": (0,external_wp_i18n_namespaceObject.__)('Document tools')
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
+    icon: !(0,external_wp_i18n_namespaceObject.isRTL)() ? library_undo : library_redo
+    /* translators: button label text should, if possible, be under 16 characters. */,
+    label: (0,external_wp_i18n_namespaceObject.__)('Undo'),
+    shortcut: external_wp_keycodes_namespaceObject.displayShortcut.primary('z')
+    // If there are no undo levels we don't want to actually disable this
+    // button, because it will remove focus for keyboard users.
+    // See: https://github.com/WordPress/gutenberg/issues/3486
+    ,
+    "aria-disabled": !hasUndo,
+    onClick: sidebar.undo,
+    className: "customize-widgets-editor-history-button undo-button"
+  }), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
+    icon: !(0,external_wp_i18n_namespaceObject.isRTL)() ? library_redo : library_undo
+    /* translators: button label text should, if possible, be under 16 characters. */,
+    label: (0,external_wp_i18n_namespaceObject.__)('Redo'),
+    shortcut: shortcut
+    // If there are no undo levels we don't want to actually disable this
+    // button, because it will remove focus for keyboard users.
+    // See: https://github.com/WordPress/gutenberg/issues/3486
+    ,
+    "aria-disabled": !hasRedo,
+    onClick: sidebar.redo,
+    className: "customize-widgets-editor-history-button redo-button"
+  }), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ToolbarButton, {
+    className: "customize-widgets-header-toolbar__inserter-toggle",
+    isPressed: isInserterOpened,
+    variant: "primary",
+    icon: library_plus,
+    label: (0,external_wp_i18n_namespaceObject._x)('Add block', 'Generic label for block inserter button'),
+    onClick: () => {
+      setIsInserterOpened(isOpen => !isOpen);
+    }
+  }), (0,external_wp_element_namespaceObject.createElement)(MoreMenu, null))), (0,external_wp_element_namespaceObject.createPortal)((0,external_wp_element_namespaceObject.createElement)(components_inserter, {
+    setIsOpened: setIsInserterOpened
+  }), inserter.contentContainer[0]));
+}
+/* harmony default export */ var header = (Header);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/inserter/use-inserter.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function useInserter(inserter) {
+  const isInserterOpened = (0,external_wp_data_namespaceObject.useSelect)(select => select(store).isInserterOpened(), []);
+  const {
+    setIsInserterOpened
+  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    if (isInserterOpened) {
+      inserter.open();
+    } else {
+      inserter.close();
+    }
+  }, [inserter, isInserterOpened]);
+  return [isInserterOpened, (0,external_wp_element_namespaceObject.useCallback)(updater => {
+    let isOpen = updater;
+    if (typeof updater === 'function') {
+      isOpen = updater((0,external_wp_data_namespaceObject.select)(store).isInserterOpened());
+    }
+    setIsInserterOpened(isOpen);
+  }, [setIsInserterOpened])];
+}
+
+// EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js
+var es6 = __webpack_require__(5619);
+var es6_default = /*#__PURE__*/__webpack_require__.n(es6);
+;// CONCATENATED MODULE: external ["wp","isShallowEqual"]
+var external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
+var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/utils.js
+// @ts-check
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Convert settingId to widgetId.
+ *
+ * @param {string} settingId The setting id.
+ * @return {string} The widget id.
+ */
+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;
+}
+
+/**
+ * Transform a block to a customizable widget.
+ *
+ * @param {WPBlock} block          The block to be transformed from.
+ * @param {Object}  existingWidget The widget to be extended from.
+ * @return {Object} The transformed widget.
+ */
+function blockToWidget(block, existingWidget = null) {
+  let widget;
+  const isValidLegacyWidgetBlock = block.name === 'core/legacy-widget' && (block.attributes.id || block.attributes.instance);
+  if (isValidLegacyWidgetBlock) {
+    if (block.attributes.id) {
+      // Widget that does not extend WP_Widget.
+      widget = {
+        id: block.attributes.id
+      };
+    } else {
+      const {
+        encoded,
+        hash,
+        raw,
+        ...rest
+      } = block.attributes.instance;
+
+      // Widget that extends WP_Widget.
+      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,external_wp_blocks_namespaceObject.serialize)(block)
+    };
+    widget = {
+      idBase: 'block',
+      widgetClass: 'WP_Widget_Block',
+      instance: {
+        raw_instance: instance
+      }
+    };
+  }
+  const {
+    form,
+    rendered,
+    ...restExistingWidget
+  } = existingWidget || {};
+  return {
+    ...restExistingWidget,
+    ...widget
+  };
+}
+
+/**
+ * Transform a widget to a block.
+ *
+ * @param {Object} widget          The widget to be transformed from.
+ * @param {string} widget.id       The widget id.
+ * @param {string} widget.idBase   The id base of the widget.
+ * @param {number} widget.number   The number/index of the widget.
+ * @param {Object} widget.instance The instance of the widget.
+ * @return {WPBlock} The transformed block.
+ */
+function widgetToBlock({
+  id,
+  idBase,
+  number,
+  instance
+}) {
+  let block;
+  const {
+    encoded_serialized_instance: encoded,
+    instance_hash_key: hash,
+    raw_instance: raw,
+    ...rest
+  } = instance;
+  if (idBase === 'block') {
+    var _raw$content;
+    const parsedBlocks = (0,external_wp_blocks_namespaceObject.parse)((_raw$content = raw.content) !== null && _raw$content !== void 0 ? _raw$content : '', {
+      __unstableSkipAutop: true
+    });
+    block = parsedBlocks.length ? parsedBlocks[0] : (0,external_wp_blocks_namespaceObject.createBlock)('core/paragraph', {});
+  } else if (number) {
+    // Widget that extends WP_Widget.
+    block = (0,external_wp_blocks_namespaceObject.createBlock)('core/legacy-widget', {
+      idBase,
+      instance: {
+        encoded,
+        hash,
+        raw,
+        ...rest
+      }
+    });
+  } else {
+    // Widget that does not extend WP_Widget.
+    block = (0,external_wp_blocks_namespaceObject.createBlock)('core/legacy-widget', {
+      id
+    });
+  }
+  return (0,external_wp_widgets_namespaceObject.addWidgetIdToBlock)(block, id);
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/use-sidebar-block-editor.js
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function widgetsToBlocks(widgets) {
+  return widgets.map(widget => widgetToBlock(widget));
+}
+function useSidebarBlockEditor(sidebar) {
+  const [blocks, setBlocks] = (0,external_wp_element_namespaceObject.useState)(() => widgetsToBlocks(sidebar.getWidgets()));
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    return sidebar.subscribe((prevWidgets, nextWidgets) => {
+      setBlocks(prevBlocks => {
+        const prevWidgetsMap = new Map(prevWidgets.map(widget => [widget.id, widget]));
+        const prevBlocksMap = new Map(prevBlocks.map(block => [(0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block), block]));
+        const nextBlocks = nextWidgets.map(nextWidget => {
+          const prevWidget = prevWidgetsMap.get(nextWidget.id);
+
+          // Bail out updates.
+          if (prevWidget && prevWidget === nextWidget) {
+            return prevBlocksMap.get(nextWidget.id);
+          }
+          return widgetToBlock(nextWidget);
+        });
+
+        // Bail out updates.
+        if (external_wp_isShallowEqual_default()(prevBlocks, nextBlocks)) {
+          return prevBlocks;
+        }
+        return nextBlocks;
+      });
+    });
+  }, [sidebar]);
+  const onChangeBlocks = (0,external_wp_element_namespaceObject.useCallback)(nextBlocks => {
+    setBlocks(prevBlocks => {
+      if (external_wp_isShallowEqual_default()(prevBlocks, nextBlocks)) {
+        return prevBlocks;
+      }
+      const prevBlocksMap = new Map(prevBlocks.map(block => [(0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block), block]));
+      const nextWidgets = nextBlocks.map(nextBlock => {
+        const widgetId = (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(nextBlock);
+
+        // Update existing widgets.
+        if (widgetId && prevBlocksMap.has(widgetId)) {
+          const prevBlock = prevBlocksMap.get(widgetId);
+          const prevWidget = sidebar.getWidget(widgetId);
+
+          // Bail out updates by returning the previous widgets.
+          // Deep equality is necessary until the block editor's internals changes.
+          if (es6_default()(nextBlock, prevBlock) && prevWidget) {
+            return prevWidget;
+          }
+          return blockToWidget(nextBlock, prevWidget);
+        }
+
+        // Add a new widget.
+        return blockToWidget(nextBlock);
+      });
+
+      // Bail out updates if the updated widgets are the same.
+      if (external_wp_isShallowEqual_default()(sidebar.getWidgets(), nextWidgets)) {
+        return prevBlocks;
+      }
+      const addedWidgetIds = sidebar.setWidgets(nextWidgets);
+      return nextBlocks.reduce((updatedNextBlocks, nextBlock, index) => {
+        const addedWidgetId = addedWidgetIds[index];
+        if (addedWidgetId !== null) {
+          // Only create a new instance if necessary to prevent
+          // the whole editor from re-rendering on every edit.
+          if (updatedNextBlocks === nextBlocks) {
+            updatedNextBlocks = nextBlocks.slice();
+          }
+          updatedNextBlocks[index] = (0,external_wp_widgets_namespaceObject.addWidgetIdToBlock)(nextBlock, addedWidgetId);
+        }
+        return updatedNextBlocks;
+      }, nextBlocks);
+    });
+  }, [sidebar]);
+  return [blocks, onChangeBlocks, onChangeBlocks];
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/focus-control/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+const FocusControlContext = (0,external_wp_element_namespaceObject.createContext)();
+function FocusControl({
+  api,
+  sidebarControls,
+  children
+}) {
+  const [focusedWidgetIdRef, setFocusedWidgetIdRef] = (0,external_wp_element_namespaceObject.useState)({
+    current: null
+  });
+  const focusWidget = (0,external_wp_element_namespaceObject.useCallback)(widgetId => {
+    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't be overridden by the "Back" button focus.
+          completeCallback() {
+            // Create a "ref-like" object every time to ensure
+            // the same widget id can also triggers the focus control.
+            setFocusedWidgetIdRef({
+              current: widgetId
+            });
+          }
+        });
+        break;
+      }
+    }
+  }, [sidebarControls]);
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    function handleFocus(settingId) {
+      const widgetId = settingIdToWidgetId(settingId);
+      focusWidget(widgetId);
+    }
+    let previewBound = false;
+    function handleReady() {
+      api.previewer.preview.bind('focus-control-for-setting', handleFocus);
+      previewBound = true;
+    }
+    api.previewer.bind('ready', handleReady);
+    return () => {
+      api.previewer.unbind('ready', handleReady);
+      if (previewBound) {
+        api.previewer.preview.unbind('focus-control-for-setting', handleFocus);
+      }
+    };
+  }, [api, focusWidget]);
+  const context = (0,external_wp_element_namespaceObject.useMemo)(() => [focusedWidgetIdRef, focusWidget], [focusedWidgetIdRef, focusWidget]);
+  return (0,external_wp_element_namespaceObject.createElement)(FocusControlContext.Provider, {
+    value: context
+  }, children);
+}
+const useFocusControl = () => (0,external_wp_element_namespaceObject.useContext)(FocusControlContext);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/focus-control/use-blocks-focus-control.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function useBlocksFocusControl(blocks) {
+  const {
+    selectBlock
+  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
+  const [focusedWidgetIdRef] = useFocusControl();
+  const blocksRef = (0,external_wp_element_namespaceObject.useRef)(blocks);
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    blocksRef.current = blocks;
+  }, [blocks]);
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    if (focusedWidgetIdRef.current) {
+      const focusedBlock = blocksRef.current.find(block => (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(block) === focusedWidgetIdRef.current);
+      if (focusedBlock) {
+        selectBlock(focusedBlock.clientId);
+        // If the block is already being selected, the DOM node won't
+        // get focused again automatically.
+        // We select the DOM and focus it manually here.
+        const blockNode = document.querySelector(`[data-block="${focusedBlock.clientId}"]`);
+        blockNode?.focus();
+      }
+    }
+  }, [focusedWidgetIdRef, selectBlock]);
+}
+
+;// CONCATENATED MODULE: external ["wp","privateApis"]
+var external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/lock-unlock.js
+/**
+ * WordPress dependencies
+ */
+
+const {
+  lock,
+  unlock
+} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I know using unstable features means my theme or plugin will inevitably break in the next version of WordPress.', '@wordpress/customize-widgets');
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/sidebar-editor-provider.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+const {
+  ExperimentalBlockEditorProvider
+} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
+function SidebarEditorProvider({
+  sidebar,
+  settings,
+  children
+}) {
+  const [blocks, onInput, onChange] = useSidebarBlockEditor(sidebar);
+  useBlocksFocusControl(blocks);
+  return (0,external_wp_element_namespaceObject.createElement)(ExperimentalBlockEditorProvider, {
+    value: blocks,
+    onInput: onInput,
+    onChange: onChange,
+    settings: settings,
+    useSubRegistry: false
+  }, children);
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/welcome-guide/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+function WelcomeGuide({
+  sidebar
+}) {
+  const {
+    toggle
+  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store);
+  const isEntirelyBlockWidgets = sidebar.getWidgets().every(widget => widget.id.startsWith('block-'));
+  return (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-welcome-guide"
+  }, (0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-welcome-guide__image__wrapper"
+  }, (0,external_wp_element_namespaceObject.createElement)("picture", null, (0,external_wp_element_namespaceObject.createElement)("source", {
+    srcSet: "https://s.w.org/images/block-editor/welcome-editor.svg",
+    media: "(prefers-reduced-motion: reduce)"
+  }), (0,external_wp_element_namespaceObject.createElement)("img", {
+    className: "customize-widgets-welcome-guide__image",
+    src: "https://s.w.org/images/block-editor/welcome-editor.gif",
+    width: "312",
+    height: "240",
+    alt: ""
+  }))), (0,external_wp_element_namespaceObject.createElement)("h1", {
+    className: "customize-widgets-welcome-guide__heading"
+  }, (0,external_wp_i18n_namespaceObject.__)('Welcome to block Widgets')), (0,external_wp_element_namespaceObject.createElement)("p", {
+    className: "customize-widgets-welcome-guide__text"
+  }, isEntirelyBlockWidgets ? (0,external_wp_i18n_namespaceObject.__)('Your theme provides different “block” areas for you to add and edit content. Try adding a search bar, social icons, or other types of blocks here and see how they’ll look on your site.') : (0,external_wp_i18n_namespaceObject.__)('You can now add any block to your site’s widget areas. Don’t worry, all of your favorite widgets still work flawlessly.')), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Button, {
+    className: "customize-widgets-welcome-guide__button",
+    variant: "primary",
+    onClick: () => toggle('core/customize-widgets', 'welcomeGuide')
+  }, (0,external_wp_i18n_namespaceObject.__)('Got it')), (0,external_wp_element_namespaceObject.createElement)("hr", {
+    className: "customize-widgets-welcome-guide__separator"
+  }), !isEntirelyBlockWidgets && (0,external_wp_element_namespaceObject.createElement)("p", {
+    className: "customize-widgets-welcome-guide__more-info"
+  }, (0,external_wp_i18n_namespaceObject.__)('Want to stick with the old widgets?'), (0,external_wp_element_namespaceObject.createElement)("br", null), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
+    href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/plugins/classic-widgets/')
+  }, (0,external_wp_i18n_namespaceObject.__)('Get the Classic Widgets plugin.'))), (0,external_wp_element_namespaceObject.createElement)("p", {
+    className: "customize-widgets-welcome-guide__more-info"
+  }, (0,external_wp_i18n_namespaceObject.__)('New to the block editor?'), (0,external_wp_element_namespaceObject.createElement)("br", null), (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.ExternalLink, {
+    href: (0,external_wp_i18n_namespaceObject.__)('https://wordpress.org/documentation/article/wordpress-block-editor/')
+  }, (0,external_wp_i18n_namespaceObject.__)("Here's a detailed guide."))));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/keyboard-shortcuts/index.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+function KeyboardShortcuts({
+  undo,
+  redo,
+  save
+}) {
+  const {
+    replaceBlocks
+  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
+  const {
+    getBlockName,
+    getSelectedBlockClientId,
+    getBlockAttributes
+  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blockEditor_namespaceObject.store);
+  const handleTextLevelShortcut = (event, level) => {
+    event.preventDefault();
+    const destinationBlockName = level === 0 ? 'core/paragraph' : 'core/heading';
+    const currentClientId = getSelectedBlockClientId();
+    if (currentClientId === null) {
+      return;
+    }
+    const blockName = getBlockName(currentClientId);
+    if (blockName !== 'core/paragraph' && blockName !== 'core/heading') {
+      return;
+    }
+    const attributes = getBlockAttributes(currentClientId);
+    const textAlign = blockName === 'core/paragraph' ? 'align' : 'textAlign';
+    const destinationTextAlign = destinationBlockName === 'core/paragraph' ? 'align' : 'textAlign';
+    replaceBlocks(currentClientId, (0,external_wp_blocks_namespaceObject.createBlock)(destinationBlockName, {
+      level,
+      content: attributes.content,
+      ...{
+        [destinationTextAlign]: attributes[textAlign]
+      }
+    }));
+  };
+  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/undo', event => {
+    undo();
+    event.preventDefault();
+  });
+  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/redo', event => {
+    redo();
+    event.preventDefault();
+  });
+  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/save', event => {
+    event.preventDefault();
+    save();
+  });
+  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)('core/customize-widgets/transform-heading-to-paragraph', event => handleTextLevelShortcut(event, 0));
+  [1, 2, 3, 4, 5, 6].forEach(level => {
+    //the loop is based off on a constant therefore
+    //the hook will execute the same way every time
+    //eslint-disable-next-line react-hooks/rules-of-hooks
+    (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)(`core/customize-widgets/transform-paragraph-to-heading-${level}`, event => handleTextLevelShortcut(event, level));
+  });
+  return null;
+}
+function KeyboardShortcutsRegister() {
+  const {
+    registerShortcut,
+    unregisterShortcut
+  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    registerShortcut({
+      name: 'core/customize-widgets/undo',
+      category: 'global',
+      description: (0,external_wp_i18n_namespaceObject.__)('Undo your last changes.'),
+      keyCombination: {
+        modifier: 'primary',
+        character: 'z'
+      }
+    });
+    registerShortcut({
+      name: 'core/customize-widgets/redo',
+      category: 'global',
+      description: (0,external_wp_i18n_namespaceObject.__)('Redo your last undo.'),
+      keyCombination: {
+        modifier: 'primaryShift',
+        character: 'z'
+      },
+      // Disable on Apple OS because it conflicts with the browser's
+      // history shortcut. It's a fine alias for both Windows and Linux.
+      // Since there's no conflict for Ctrl+Shift+Z on both Windows and
+      // Linux, we keep it as the default for consistency.
+      aliases: (0,external_wp_keycodes_namespaceObject.isAppleOS)() ? [] : [{
+        modifier: 'primary',
+        character: 'y'
+      }]
+    });
+    registerShortcut({
+      name: 'core/customize-widgets/save',
+      category: 'global',
+      description: (0,external_wp_i18n_namespaceObject.__)('Save your changes.'),
+      keyCombination: {
+        modifier: 'primary',
+        character: 's'
+      }
+    });
+    registerShortcut({
+      name: 'core/customize-widgets/transform-heading-to-paragraph',
+      category: 'block-library',
+      description: (0,external_wp_i18n_namespaceObject.__)('Transform heading to paragraph.'),
+      keyCombination: {
+        modifier: 'access',
+        character: `0`
+      }
+    });
+    [1, 2, 3, 4, 5, 6].forEach(level => {
+      registerShortcut({
+        name: `core/customize-widgets/transform-paragraph-to-heading-${level}`,
+        category: 'block-library',
+        description: (0,external_wp_i18n_namespaceObject.__)('Transform paragraph to heading.'),
+        keyCombination: {
+          modifier: 'access',
+          character: `${level}`
+        }
+      });
+    });
+    return () => {
+      unregisterShortcut('core/customize-widgets/undo');
+      unregisterShortcut('core/customize-widgets/redo');
+      unregisterShortcut('core/customize-widgets/save');
+    };
+  }, [registerShortcut]);
+  return null;
+}
+KeyboardShortcuts.Register = KeyboardShortcutsRegister;
+/* harmony default export */ var keyboard_shortcuts = (KeyboardShortcuts);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/block-appender/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+function BlockAppender(props) {
+  const ref = (0,external_wp_element_namespaceObject.useRef)();
+  const isBlocksListEmpty = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blockEditor_namespaceObject.store).getBlockCount() === 0);
+
+  // Move the focus to the block appender to prevent focus from
+  // being lost when emptying the widget area.
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    if (isBlocksListEmpty && ref.current) {
+      const {
+        ownerDocument
+      } = ref.current;
+      if (!ownerDocument.activeElement || ownerDocument.activeElement === ownerDocument.body) {
+        ref.current.focus();
+      }
+    }
+  }, [isBlocksListEmpty]);
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.ButtonBlockAppender, {
+    ...props,
+    ref: ref
+  });
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+
+
+
+const {
+  ExperimentalBlockCanvas: BlockCanvas
+} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
+function SidebarBlockEditor({
+  blockEditorSettings,
+  sidebar,
+  inserter,
+  inspector
+}) {
+  const [isInserterOpened, setIsInserterOpened] = useInserter(inserter);
+  const {
+    hasUploadPermissions,
+    isFixedToolbarActive,
+    keepCaretInsideBlock,
+    isWelcomeGuideActive
+  } = (0,external_wp_data_namespaceObject.useSelect)(select => {
+    var _select$canUser;
+    const {
+      get
+    } = select(external_wp_preferences_namespaceObject.store);
+    return {
+      hasUploadPermissions: (_select$canUser = select(external_wp_coreData_namespaceObject.store).canUser('create', 'media')) !== null && _select$canUser !== void 0 ? _select$canUser : true,
+      isFixedToolbarActive: !!get('core/customize-widgets', 'fixedToolbar'),
+      keepCaretInsideBlock: !!get('core/customize-widgets', 'keepCaretInsideBlock'),
+      isWelcomeGuideActive: !!get('core/customize-widgets', 'welcomeGuide')
+    };
+  }, []);
+  const settings = (0,external_wp_element_namespaceObject.useMemo)(() => {
+    let mediaUploadBlockEditor;
+    if (hasUploadPermissions) {
+      mediaUploadBlockEditor = ({
+        onError,
+        ...argumentsObject
+      }) => {
+        (0,external_wp_mediaUtils_namespaceObject.uploadMedia)({
+          wpAllowedMimeTypes: blockEditorSettings.allowedMimeTypes,
+          onError: ({
+            message
+          }) => onError(message),
+          ...argumentsObject
+        });
+      };
+    }
+    return {
+      ...blockEditorSettings,
+      __experimentalSetIsInserterOpened: setIsInserterOpened,
+      mediaUpload: mediaUploadBlockEditor,
+      hasFixedToolbar: isFixedToolbarActive,
+      keepCaretInsideBlock,
+      __unstableHasCustomAppender: true
+    };
+  }, [hasUploadPermissions, blockEditorSettings, isFixedToolbarActive, keepCaretInsideBlock, setIsInserterOpened]);
+  if (isWelcomeGuideActive) {
+    return (0,external_wp_element_namespaceObject.createElement)(WelcomeGuide, {
+      sidebar: sidebar
+    });
+  }
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcuts.Register, null), (0,external_wp_element_namespaceObject.createElement)(SidebarEditorProvider, {
+    sidebar: sidebar,
+    settings: settings
+  }, (0,external_wp_element_namespaceObject.createElement)(keyboard_shortcuts, {
+    undo: sidebar.undo,
+    redo: sidebar.redo,
+    save: sidebar.save
+  }), (0,external_wp_element_namespaceObject.createElement)(header, {
+    sidebar: sidebar,
+    inserter: inserter,
+    isInserterOpened: isInserterOpened,
+    setIsInserterOpened: setIsInserterOpened,
+    isFixedToolbarActive: isFixedToolbarActive
+  }), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockTools, null, (0,external_wp_element_namespaceObject.createElement)(BlockCanvas, {
+    shouldIframe: false,
+    styles: settings.defaultEditorStyles,
+    height: "100%"
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockList, {
+    renderAppender: BlockAppender
+  }))), (0,external_wp_element_namespaceObject.createPortal)(
+  // This is a temporary hack to prevent button component inside <BlockInspector>
+  // from submitting form when type="button" is not specified.
+  (0,external_wp_element_namespaceObject.createElement)("form", {
+    onSubmit: event => event.preventDefault()
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockInspector, null)), inspector.contentContainer[0])), (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.__unstableBlockSettingsMenuFirstItem, null, ({
+    onClose
+  }) => (0,external_wp_element_namespaceObject.createElement)(block_inspector_button, {
+    inspector: inspector,
+    closeMenu: onClose
+  })));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-controls/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+const SidebarControlsContext = (0,external_wp_element_namespaceObject.createContext)();
+function SidebarControls({
+  sidebarControls,
+  activeSidebarControl,
+  children
+}) {
+  const context = (0,external_wp_element_namespaceObject.useMemo)(() => ({
+    sidebarControls,
+    activeSidebarControl
+  }), [sidebarControls, activeSidebarControl]);
+  return (0,external_wp_element_namespaceObject.createElement)(SidebarControlsContext.Provider, {
+    value: context
+  }, children);
+}
+function useSidebarControls() {
+  const {
+    sidebarControls
+  } = (0,external_wp_element_namespaceObject.useContext)(SidebarControlsContext);
+  return sidebarControls;
+}
+function useActiveSidebarControl() {
+  const {
+    activeSidebarControl
+  } = (0,external_wp_element_namespaceObject.useContext)(SidebarControlsContext);
+  return activeSidebarControl;
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/customize-widgets/use-clear-selected-block.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * We can't just use <BlockSelectionClearer> because the customizer has
+ * many root nodes rather than just one in the post editor.
+ * We need to listen to the focus events in all those roots, and also in
+ * the preview iframe.
+ * This hook will clear the selected block when focusing outside the editor,
+ * with a few exceptions:
+ * 1. Focusing on popovers.
+ * 2. Focusing on the inspector.
+ * 3. Focusing on any modals/dialogs.
+ * These cases are normally triggered by user interactions from the editor,
+ * not by explicitly focusing outside the editor, hence no need for clearing.
+ *
+ * @param {Object} sidebarControl The sidebar control instance.
+ * @param {Object} popoverRef     The ref object of the popover node container.
+ */
+function useClearSelectedBlock(sidebarControl, popoverRef) {
+  const {
+    hasSelectedBlock,
+    hasMultiSelection
+  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_blockEditor_namespaceObject.store);
+  const {
+    clearSelectedBlock
+  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    if (popoverRef.current && sidebarControl) {
+      const inspector = sidebarControl.inspector;
+      const container = sidebarControl.container[0];
+      const ownerDocument = container.ownerDocument;
+      const ownerWindow = ownerDocument.defaultView;
+      function handleClearSelectedBlock(element) {
+        if (
+        // 1. Make sure there are blocks being selected.
+        (hasSelectedBlock() || hasMultiSelection()) &&
+        // 2. The element should exist in the DOM (not deleted).
+        element && ownerDocument.contains(element) &&
+        // 3. It should also not exist in the container, the popover, nor the dialog.
+        !container.contains(element) && !popoverRef.current.contains(element) && !element.closest('[role="dialog"]') &&
+        // 4. The inspector should not be opened.
+        !inspector.expanded()) {
+          clearSelectedBlock();
+        }
+      }
+
+      // Handle mouse down in the same document.
+      function handleMouseDown(event) {
+        handleClearSelectedBlock(event.target);
+      }
+      // Handle focusing outside the current document, like to iframes.
+      function handleBlur() {
+        handleClearSelectedBlock(ownerDocument.activeElement);
+      }
+      ownerDocument.addEventListener('mousedown', handleMouseDown);
+      ownerWindow.addEventListener('blur', handleBlur);
+      return () => {
+        ownerDocument.removeEventListener('mousedown', handleMouseDown);
+        ownerWindow.removeEventListener('blur', handleBlur);
+      };
+    }
+  }, [popoverRef, sidebarControl, hasSelectedBlock, hasMultiSelection, clearSelectedBlock]);
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/customize-widgets/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+
+function CustomizeWidgets({
+  api,
+  sidebarControls,
+  blockEditorSettings
+}) {
+  const [activeSidebarControl, setActiveSidebarControl] = (0,external_wp_element_namespaceObject.useState)(null);
+  const parentContainer = document.getElementById('customize-theme-controls');
+  const popoverRef = (0,external_wp_element_namespaceObject.useRef)();
+  useClearSelectedBlock(activeSidebarControl, popoverRef);
+  (0,external_wp_element_namespaceObject.useEffect)(() => {
+    const unsubscribers = sidebarControls.map(sidebarControl => sidebarControl.subscribe(expanded => {
+      if (expanded) {
+        setActiveSidebarControl(sidebarControl);
+      }
+    }));
+    return () => {
+      unsubscribers.forEach(unsubscriber => unsubscriber());
+    };
+  }, [sidebarControls]);
+  const activeSidebar = activeSidebarControl && (0,external_wp_element_namespaceObject.createPortal)((0,external_wp_element_namespaceObject.createElement)(ErrorBoundary, null, (0,external_wp_element_namespaceObject.createElement)(SidebarBlockEditor, {
+    key: activeSidebarControl.id,
+    blockEditorSettings: blockEditorSettings,
+    sidebar: activeSidebarControl.sidebarAdapter,
+    inserter: activeSidebarControl.inserter,
+    inspector: activeSidebarControl.inspector
+  })), activeSidebarControl.container[0]);
+
+  // We have to portal this to the parent of both the editor and the inspector,
+  // so that the popovers will appear above both of them.
+  const popover = parentContainer && (0,external_wp_element_namespaceObject.createPortal)((0,external_wp_element_namespaceObject.createElement)("div", {
+    className: "customize-widgets-popover",
+    ref: popoverRef
+  }, (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.Popover.Slot, null)), parentContainer);
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_components_namespaceObject.SlotFillProvider, null, (0,external_wp_element_namespaceObject.createElement)(SidebarControls, {
+    sidebarControls: sidebarControls,
+    activeSidebarControl: activeSidebarControl
+  }, (0,external_wp_element_namespaceObject.createElement)(FocusControl, {
+    api: api,
+    sidebarControls: sidebarControls
+  }, activeSidebar, popover)));
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/inspector-section.js
+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('customize-widgets-layout__inspector');
+    }
+    isContextuallyActive() {
+      return this.isOpen;
+    }
+    onChangeExpanded(expanded, args) {
+      super.onChangeExpanded(expanded, args);
+      if (this.parentSection && !args.unchanged) {
+        if (expanded) {
+          this.parentSection.collapse({
+            manualTransition: true
+          });
+        } else {
+          this.parentSection.expand({
+            manualTransition: true,
+            completeCallback: () => {
+              // Return focus after finishing the transition.
+              if (this.returnFocusWhenClose && !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) {
+      // Overridden collapse() function. Mostly call the parent collapse(), but also
+      // move our .isOpen to false.
+      // Initially, I tried tracking this with onChangeExpanded(), but it doesn't work
+      // because the block settings sidebar is a layer "on top of" the G editor sidebar.
+      //
+      // For example, when closing the block settings sidebar, the G
+      // editor sidebar would display, and onChangeExpanded in
+      // inspector-section would run with expanded=true, but I want
+      // isOpen to be false when the block settings is closed.
+      this.isOpen = false;
+      super.collapse(options);
+    }
+    triggerActiveCallbacks() {
+      // Manually fire the callbacks associated with moving this.active
+      // from false to true.  "active" is always true for this section,
+      // and "isContextuallyActive" reflects if the block settings
+      // sidebar is currently visible, that is, it has replaced the main
+      // Gutenberg view.
+      // The WP customizer only checks ".isContextuallyActive()" when
+      // ".active" changes values. But our ".active" never changes value.
+      // The WP customizer never foresaw a section being used a way we
+      // fit the block settings sidebar into a section. By manually
+      // triggering the "this.active" callbacks, we force the WP
+      // customizer to query our .isContextuallyActive() function and
+      // update its view of our status.
+      this.active.callbacks.fireWith(this.active, [false, true]);
+    }
+  };
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/sidebar-section.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+const getInspectorSectionId = sidebarId => `widgets-inspector-${sidebarId}`;
+function getSidebarSection() {
+  const {
+    wp: {
+      customize
+    }
+  } = window;
+  const reduceMotionMediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+  let isReducedMotion = reduceMotionMediaQuery.matches;
+  reduceMotionMediaQuery.addEventListener('change', event => {
+    isReducedMotion = event.matches;
+  });
+  return class SidebarSection extends customize.Section {
+    ready() {
+      const InspectorSection = getInspectorSection();
+      this.inspector = new InspectorSection(getInspectorSectionId(this.id), {
+        title: (0,external_wp_i18n_namespaceObject.__)('Block Settings'),
+        parentSection: this,
+        customizeAction: [(0,external_wp_i18n_namespaceObject.__)('Customizing'), (0,external_wp_i18n_namespaceObject.__)('Widgets'), this.params.title].join(' ▸ ')
+      });
+      customize.section.add(this.inspector);
+      this.contentContainer[0].classList.add('customize-widgets__sidebar-section');
+    }
+    hasSubSectionOpened() {
+      return this.inspector.expanded();
+    }
+    onChangeExpanded(expanded, _args) {
+      const controls = this.controls();
+      const args = {
+        ..._args,
+        completeCallback() {
+          controls.forEach(control => {
+            control.onChangeSectionExpanded?.(expanded, args);
+          });
+          _args.completeCallback?.();
+        }
+      };
+      if (args.manualTransition) {
+        if (expanded) {
+          this.contentContainer.addClass(['busy', 'open']);
+          this.contentContainer.removeClass('is-sub-section-open');
+          this.contentContainer.closest('.wp-full-overlay').addClass('section-open');
+        } else {
+          this.contentContainer.addClass(['busy', 'is-sub-section-open']);
+          this.contentContainer.closest('.wp-full-overlay').addClass('section-open');
+          this.contentContainer.removeClass('open');
+        }
+        const handleTransitionEnd = () => {
+          this.contentContainer.removeClass('busy');
+          args.completeCallback();
+        };
+        if (isReducedMotion) {
+          handleTransitionEnd();
+        } else {
+          this.contentContainer.one('transitionend', handleTransitionEnd);
+        }
+      } else {
+        super.onChangeExpanded(expanded, args);
+      }
+    }
+  };
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/components/sidebar-block-editor/sidebar-adapter.js
+/**
+ * Internal dependencies
+ */
+
+const {
+  wp
+} = window;
+function parseWidgetId(widgetId) {
+  const matches = widgetId.match(/^(.+)-(\d+)$/);
+  if (matches) {
+    return {
+      idBase: matches[1],
+      number: parseInt(matches[2], 10)
+    };
+  }
+
+  // Likely an old single widget.
+  return {
+    idBase: widgetId
+  };
+}
+function widgetIdToSettingId(widgetId) {
+  const {
+    idBase,
+    number
+  } = parseWidgetId(widgetId);
+  if (number) {
+    return `widget_${idBase}[${number}]`;
+  }
+  return `widget_${idBase}`;
+}
+
+/**
+ * This is a custom debounce function to call different callbacks depending on
+ * whether it's the _leading_ call or not.
+ *
+ * @param {Function} leading  The callback that gets called first.
+ * @param {Function} callback The callback that gets called after the first time.
+ * @param {number}   timeout  The debounced time in milliseconds.
+ * @return {Function} The debounced function.
+ */
+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(() => {
+      isLeading = false;
+    }, timeout);
+    return result;
+  }
+  debounced.cancel = () => {
+    isLeading = false;
+    clearTimeout(timerID);
+  };
+  return debounced;
+}
+class SidebarAdapter {
+  constructor(setting, api) {
+    this.setting = setting;
+    this.api = api;
+    this.locked = false;
+    this.widgetsCache = new WeakMap();
+    this.subscribers = new Set();
+    this.history = [this._getWidgetIds().map(widgetId => this.getWidget(widgetId))];
+    this.historyIndex = 0;
+    this.historySubscribers = new Set();
+    // Debounce the input for 1 second.
+    this._debounceSetHistory = debounce(this._pushHistory, this._replaceHistory, 1000);
+    this.setting.bind(this._handleSettingChange.bind(this));
+    this.api.bind('change', 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 () => {
+      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 => this.getWidget(widgetId))];
+    this.historyIndex += 1;
+    this.historySubscribers.forEach(listener => listener());
+  }
+  _replaceHistory() {
+    this.history[this.historyIndex] = this._getWidgetIds().map(widgetId => 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('widget_')) {
+      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('is_multi') && !number) {
+      widgetModel.set('multi_number', widgetModel.get('multi_number') + 1);
+      number = widgetModel.get('multi_number');
+    }
+    const settingId = number ? `widget_${widget.idBase}[${number}]` : `widget_${widget.idBase}`;
+    const settingArgs = {
+      transport: wp.customize.Widgets.data.selectiveRefreshableWidgets[widgetModel.get('id_base')] ? 'postMessage' : 'refresh',
+      previewer: this.setting.previewer
+    };
+    const setting = this.api.create(settingId, settingId, '', 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);
+
+    // Bail out update if nothing changed.
+    if (prevWidget === widget) {
+      return widget.id;
+    }
+
+    // Update existing setting if only the widget's instance changed.
+    if (prevWidget.idBase && widget.idBase && prevWidget.idBase === widget.idBase) {
+      const settingId = widgetIdToSettingId(widget.id);
+      this.api(settingId).set(widget.instance);
+      return widget.id;
+    }
+
+    // Otherwise delete and re-create.
+    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 => {
+      if (nextWidget.id && 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 => !nextWidgetIds.includes(widget.id));
+    deletedWidgets.forEach(widget => 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 > 0;
+  }
+  hasRedo() {
+    return this.historyIndex < 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 => 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 () => {
+      this.historySubscribers.delete(listener);
+    };
+  }
+  save() {
+    this.api.previewer.save();
+  }
+}
+
+;// CONCATENATED MODULE: external ["wp","dom"]
+var external_wp_dom_namespaceObject = window["wp"]["dom"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/inserter-outer-section.js
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+function getInserterOuterSection() {
+  const {
+    wp: {
+      customize
+    }
+  } = window;
+  const OuterSection = customize.OuterSection;
+  // Override the OuterSection class to handle multiple outer sections.
+  // It closes all the other outer sections whenever one is opened.
+  // The result is that at most one outer section can be opened at the same time.
+  customize.OuterSection = class extends OuterSection {
+    onChangeExpanded(expanded, args) {
+      if (expanded) {
+        customize.section.each(section => {
+          if (section.params.type === 'outer' && section.id !== this.id) {
+            if (section.expanded()) {
+              section.collapse();
+            }
+          }
+        });
+      }
+      return super.onChangeExpanded(expanded, args);
+    }
+  };
+  // Handle constructor so that "params.type" can be correctly pointed to "outer".
+  customize.sectionConstructor.outer = customize.OuterSection;
+  return class InserterOuterSection extends customize.OuterSection {
+    constructor(...args) {
+      super(...args);
+
+      // This is necessary since we're creating a new class which is not identical to the original OuterSection.
+      // @See https://github.com/WordPress/wordpress-develop/blob/42b05c397c50d9dc244083eff52991413909d4bd/src/js/_enqueues/wp/customize/controls.js#L1427-L1436
+      this.params.type = 'outer';
+      this.activeElementBeforeExpanded = null;
+      const ownerWindow = this.contentContainer[0].ownerDocument.defaultView;
+
+      // Handle closing the inserter when pressing the Escape key.
+      ownerWindow.addEventListener('keydown', event => {
+        if (this.expanded() && (event.keyCode === external_wp_keycodes_namespaceObject.ESCAPE || event.code === 'Escape') && !event.defaultPrevented) {
+          event.preventDefault();
+          event.stopPropagation();
+          (0,external_wp_data_namespaceObject.dispatch)(store).setIsInserterOpened(false);
+        }
+      },
+      // Use capture mode to make this run before other event listeners.
+      true);
+      this.contentContainer.addClass('widgets-inserter');
+
+      // Set a flag if the state is being changed from open() or close().
+      // Don't propagate the event if it's an internal action to prevent infinite loop.
+      this.isFromInternalAction = false;
+      this.expanded.bind(() => {
+        if (!this.isFromInternalAction) {
+          // Propagate the event to React to sync the state.
+          (0,external_wp_data_namespaceObject.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() {
+            // We have to do this in a "completeCallback" or else the elements will not yet be visible/tabbable.
+            // The first one should be the close button,
+            // we want to skip it and choose the second one instead, which is the search box.
+            const searchBox = external_wp_dom_namespaceObject.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() {
+            // Return back the focus when closing the inserter.
+            // Only do this if the active element which triggers the action is inside the inserter,
+            // (the close button for instance). In that case the focus will be lost.
+            // Otherwise, we don't hijack the focus when the user is focusing on other elements
+            // (like the quick inserter).
+            if (contentContainer.contains(activeElement)) {
+              // Return back the focus when closing the inserter.
+              if (this.activeElementBeforeExpanded) {
+                this.activeElementBeforeExpanded.focus();
+              }
+            }
+          }
+        });
+      }
+    }
+  };
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/controls/sidebar-control.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+const getInserterId = controlId => `widgets-inserter-${controlId}`;
+function getSidebarControl() {
+  const {
+    wp: {
+      customize
+    }
+  } = window;
+  return class SidebarControl extends customize.Control {
+    constructor(...args) {
+      super(...args);
+      this.subscribers = 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 () => {
+        this.subscribers.delete(callback);
+      };
+    }
+    onChangeSectionExpanded(expanded, args) {
+      if (!args.unchanged) {
+        // Close the inserter when the section collapses.
+        if (!expanded) {
+          (0,external_wp_data_namespaceObject.dispatch)(store).setIsInserterOpened(false);
+        }
+        this.subscribers.forEach(subscriber => subscriber(expanded, args));
+      }
+    }
+  };
+}
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/filters/move-to-sidebar.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+const withMoveToSidebarToolbarItem = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => {
+  let widgetId = (0,external_wp_widgets_namespaceObject.getWidgetIdFromBlock)(props);
+  const sidebarControls = useSidebarControls();
+  const activeSidebarControl = useActiveSidebarControl();
+  const hasMultipleSidebars = sidebarControls?.length > 1;
+  const blockName = props.name;
+  const clientId = props.clientId;
+  const canInsertBlockInSidebar = (0,external_wp_data_namespaceObject.useSelect)(select => {
+    // Use an empty string to represent the root block list, which
+    // in the customizer editor represents a sidebar/widget area.
+    return select(external_wp_blockEditor_namespaceObject.store).canInsertBlockType(blockName, '');
+  }, [blockName]);
+  const block = (0,external_wp_data_namespaceObject.useSelect)(select => select(external_wp_blockEditor_namespaceObject.store).getBlock(clientId), [clientId]);
+  const {
+    removeBlock
+  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_blockEditor_namespaceObject.store);
+  const [, focusWidget] = useFocusControl();
+  function moveToSidebar(sidebarControlId) {
+    const newSidebarControl = sidebarControls.find(sidebarControl => sidebarControl.id === sidebarControlId);
+    if (widgetId) {
+      /**
+       * If there's a widgetId, move it to the other sidebar.
+       */
+      const oldSetting = activeSidebarControl.setting;
+      const newSetting = newSidebarControl.setting;
+      oldSetting(oldSetting().filter(id => id !== widgetId));
+      newSetting([...newSetting(), widgetId]);
+    } else {
+      /**
+       * If there isn't a widgetId, it's most likely a inner block.
+       * First, remove the block in the original sidebar,
+       * then, create a new widget in the new sidebar and get back its widgetId.
+       */
+      const sidebarAdapter = newSidebarControl.sidebarAdapter;
+      removeBlock(clientId);
+      const addedWidgetIds = sidebarAdapter.setWidgets([...sidebarAdapter.getWidgets(), blockToWidget(block)]);
+      // The last non-null id is the added widget's id.
+      widgetId = addedWidgetIds.reverse().find(id => !!id);
+    }
+
+    // Move focus to the moved widget and expand the sidebar.
+    focusWidget(widgetId);
+  }
+  return (0,external_wp_element_namespaceObject.createElement)(external_wp_element_namespaceObject.Fragment, null, (0,external_wp_element_namespaceObject.createElement)(BlockEdit, {
+    ...props
+  }), hasMultipleSidebars && canInsertBlockInSidebar && (0,external_wp_element_namespaceObject.createElement)(external_wp_blockEditor_namespaceObject.BlockControls, null, (0,external_wp_element_namespaceObject.createElement)(external_wp_widgets_namespaceObject.MoveToWidgetArea, {
+    widgetAreas: sidebarControls.map(sidebarControl => ({
+      id: sidebarControl.id,
+      name: sidebarControl.params.label,
+      description: sidebarControl.params.description
+    })),
+    currentWidgetAreaId: activeSidebarControl?.id,
+    onSelect: moveToSidebar
+  })));
+}, 'withMoveToSidebarToolbarItem');
+(0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/customize-widgets/block-edit', withMoveToSidebarToolbarItem);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/filters/replace-media-upload.js
+/**
+ * WordPress dependencies
+ */
+
+
+const replaceMediaUpload = () => external_wp_mediaUtils_namespaceObject.MediaUpload;
+(0,external_wp_hooks_namespaceObject.addFilter)('editor.MediaUpload', 'core/edit-widgets/replace-media-upload', replaceMediaUpload);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/filters/wide-widget-display.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+const {
+  wp: wide_widget_display_wp
+} = window;
+const withWideWidgetDisplay = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(BlockEdit => props => {
+  var _wp$customize$Widgets;
+  const {
+    idBase
+  } = props.attributes;
+  const isWide = (_wp$customize$Widgets = wide_widget_display_wp.customize.Widgets.data.availableWidgets.find(widget => widget.id_base === idBase)?.is_wide) !== null && _wp$customize$Widgets !== void 0 ? _wp$customize$Widgets : false;
+  return (0,external_wp_element_namespaceObject.createElement)(BlockEdit, {
+    ...props,
+    isWide: isWide
+  });
+}, 'withWideWidgetDisplay');
+(0,external_wp_hooks_namespaceObject.addFilter)('editor.BlockEdit', 'core/customize-widgets/wide-widget-display', withWideWidgetDisplay);
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/filters/index.js
+/**
+ * Internal dependencies
+ */
+
+
+
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/customize-widgets/build-module/index.js
+
+/**
+ * WordPress dependencies
+ */
+
+
+
+
+
+
+
+/**
+ * Internal dependencies
+ */
+
+
+
+
+const {
+  wp: build_module_wp
+} = window;
+const DISABLED_BLOCKS = ['core/more', 'core/block', 'core/freeform', 'core/template-part'];
+const ENABLE_EXPERIMENTAL_FSE_BLOCKS = false;
+
+/**
+ * Initializes the widgets block editor in the customizer.
+ *
+ * @param {string} editorName          The editor name.
+ * @param {Object} blockEditorSettings Block editor settings.
+ */
+function initialize(editorName, blockEditorSettings) {
+  (0,external_wp_data_namespaceObject.dispatch)(external_wp_preferences_namespaceObject.store).setDefaults('core/customize-widgets', {
+    fixedToolbar: false,
+    welcomeGuide: true
+  });
+  (0,external_wp_data_namespaceObject.dispatch)(external_wp_blocks_namespaceObject.store).reapplyBlockTypeFilters();
+  const coreBlocks = (0,external_wp_blockLibrary_namespaceObject.__experimentalGetCoreBlocks)().filter(block => {
+    return !(DISABLED_BLOCKS.includes(block.name) || block.name.startsWith('core/post') || block.name.startsWith('core/query') || block.name.startsWith('core/site') || block.name.startsWith('core/navigation'));
+  });
+  (0,external_wp_blockLibrary_namespaceObject.registerCoreBlocks)(coreBlocks);
+  (0,external_wp_widgets_namespaceObject.registerLegacyWidgetBlock)();
+  if (false) {}
+  (0,external_wp_widgets_namespaceObject.registerLegacyWidgetVariations)(blockEditorSettings);
+  (0,external_wp_widgets_namespaceObject.registerWidgetGroupBlock)();
+
+  // As we are unregistering `core/freeform` to avoid the Classic block, we must
+  // replace it with something as the default freeform content handler. Failure to
+  // do this will result in errors in the default block parser.
+  // see: https://github.com/WordPress/gutenberg/issues/33097
+  (0,external_wp_blocks_namespaceObject.setFreeformContentHandlerName)('core/html');
+  const SidebarControl = getSidebarControl(blockEditorSettings);
+  build_module_wp.customize.sectionConstructor.sidebar = getSidebarSection();
+  build_module_wp.customize.controlConstructor.sidebar_block_editor = SidebarControl;
+  const container = document.createElement('div');
+  document.body.appendChild(container);
+  build_module_wp.customize.bind('ready', () => {
+    const sidebarControls = [];
+    build_module_wp.customize.control.each(control => {
+      if (control instanceof SidebarControl) {
+        sidebarControls.push(control);
+      }
+    });
+    (0,external_wp_element_namespaceObject.createRoot)(container).render((0,external_wp_element_namespaceObject.createElement)(CustomizeWidgets, {
+      api: build_module_wp.customize,
+      sidebarControls: sidebarControls,
+      blockEditorSettings: blockEditorSettings
+    }));
+  });
+}
+
+
+}();
+(window.wp = window.wp || {}).customizeWidgets = __webpack_exports__;
+/******/ })()
+;
\ No newline at end of file