?<h3>D¨ązenle: edit-post.js</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>/******/ (() =&gt; { // webpackBootstrap
/******/ 	&quot;use strict&quot;;
/******/ 	// The require scope
/******/ 	var __webpack_require__ = {};
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	(() =&gt; {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = (module) =&gt; {
/******/ 			var getter = module &amp;&amp; module.__esModule ?
/******/ 				() =&gt; (module[&#039;default&#039;]) :
/******/ 				() =&gt; (module);
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() =&gt; {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) =&gt; {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) &amp;&amp; !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() =&gt; {
/******/ 		__webpack_require__.o = (obj, prop) =&gt; (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() =&gt; {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) =&gt; {
/******/ 			if(typeof Symbol !== &#039;undefined&#039; &amp;&amp; Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: &#039;Module&#039; });
/******/ 			}
/******/ 			Object.defineProperty(exports, &#039;__esModule&#039;, { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  PluginBlockSettingsMenuItem: () =&gt; (/* reexport */ PluginBlockSettingsMenuItem),
  PluginDocumentSettingPanel: () =&gt; (/* reexport */ PluginDocumentSettingPanel),
  PluginMoreMenuItem: () =&gt; (/* reexport */ PluginMoreMenuItem),
  PluginPostPublishPanel: () =&gt; (/* reexport */ PluginPostPublishPanel),
  PluginPostStatusInfo: () =&gt; (/* reexport */ PluginPostStatusInfo),
  PluginPrePublishPanel: () =&gt; (/* reexport */ PluginPrePublishPanel),
  PluginSidebar: () =&gt; (/* reexport */ PluginSidebar),
  PluginSidebarMoreMenuItem: () =&gt; (/* reexport */ PluginSidebarMoreMenuItem),
  __experimentalFullscreenModeClose: () =&gt; (/* reexport */ fullscreen_mode_close),
  __experimentalMainDashboardButton: () =&gt; (/* binding */ __experimentalMainDashboardButton),
  __experimentalPluginPostExcerpt: () =&gt; (/* reexport */ __experimentalPluginPostExcerpt),
  initializeEditor: () =&gt; (/* binding */ initializeEditor),
  reinitializeEditor: () =&gt; (/* binding */ reinitializeEditor),
  store: () =&gt; (/* reexport */ store)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/edit-post/build-module/store/actions.js
var actions_namespaceObject = {};
__webpack_require__.r(actions_namespaceObject);
__webpack_require__.d(actions_namespaceObject, {
  __experimentalSetPreviewDeviceType: () =&gt; (__experimentalSetPreviewDeviceType),
  __unstableCreateTemplate: () =&gt; (__unstableCreateTemplate),
  closeGeneralSidebar: () =&gt; (closeGeneralSidebar),
  closeModal: () =&gt; (closeModal),
  closePublishSidebar: () =&gt; (closePublishSidebar),
  hideBlockTypes: () =&gt; (hideBlockTypes),
  initializeMetaBoxes: () =&gt; (initializeMetaBoxes),
  metaBoxUpdatesFailure: () =&gt; (metaBoxUpdatesFailure),
  metaBoxUpdatesSuccess: () =&gt; (metaBoxUpdatesSuccess),
  openGeneralSidebar: () =&gt; (openGeneralSidebar),
  openModal: () =&gt; (openModal),
  openPublishSidebar: () =&gt; (openPublishSidebar),
  removeEditorPanel: () =&gt; (removeEditorPanel),
  requestMetaBoxUpdates: () =&gt; (requestMetaBoxUpdates),
  setAvailableMetaBoxesPerLocation: () =&gt; (setAvailableMetaBoxesPerLocation),
  setIsEditingTemplate: () =&gt; (setIsEditingTemplate),
  setIsInserterOpened: () =&gt; (setIsInserterOpened),
  setIsListViewOpened: () =&gt; (setIsListViewOpened),
  showBlockTypes: () =&gt; (showBlockTypes),
  switchEditorMode: () =&gt; (switchEditorMode),
  toggleDistractionFree: () =&gt; (toggleDistractionFree),
  toggleEditorPanelEnabled: () =&gt; (toggleEditorPanelEnabled),
  toggleEditorPanelOpened: () =&gt; (toggleEditorPanelOpened),
  toggleFeature: () =&gt; (toggleFeature),
  toggleFullscreenMode: () =&gt; (toggleFullscreenMode),
  togglePinnedPluginItem: () =&gt; (togglePinnedPluginItem),
  togglePublishSidebar: () =&gt; (togglePublishSidebar),
  updatePreferredStyleVariations: () =&gt; (updatePreferredStyleVariations)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/edit-post/build-module/store/selectors.js
var selectors_namespaceObject = {};
__webpack_require__.r(selectors_namespaceObject);
__webpack_require__.d(selectors_namespaceObject, {
  __experimentalGetInsertionPoint: () =&gt; (__experimentalGetInsertionPoint),
  __experimentalGetPreviewDeviceType: () =&gt; (__experimentalGetPreviewDeviceType),
  areMetaBoxesInitialized: () =&gt; (areMetaBoxesInitialized),
  getActiveGeneralSidebarName: () =&gt; (getActiveGeneralSidebarName),
  getActiveMetaBoxLocations: () =&gt; (getActiveMetaBoxLocations),
  getAllMetaBoxes: () =&gt; (getAllMetaBoxes),
  getEditedPostTemplate: () =&gt; (getEditedPostTemplate),
  getEditorMode: () =&gt; (getEditorMode),
  getHiddenBlockTypes: () =&gt; (getHiddenBlockTypes),
  getMetaBoxesPerLocation: () =&gt; (getMetaBoxesPerLocation),
  getPreference: () =&gt; (getPreference),
  getPreferences: () =&gt; (getPreferences),
  hasMetaBoxes: () =&gt; (hasMetaBoxes),
  isEditingTemplate: () =&gt; (isEditingTemplate),
  isEditorPanelEnabled: () =&gt; (isEditorPanelEnabled),
  isEditorPanelOpened: () =&gt; (isEditorPanelOpened),
  isEditorPanelRemoved: () =&gt; (isEditorPanelRemoved),
  isEditorSidebarOpened: () =&gt; (isEditorSidebarOpened),
  isFeatureActive: () =&gt; (isFeatureActive),
  isInserterOpened: () =&gt; (isInserterOpened),
  isListViewOpened: () =&gt; (isListViewOpened),
  isMetaBoxLocationActive: () =&gt; (isMetaBoxLocationActive),
  isMetaBoxLocationVisible: () =&gt; (isMetaBoxLocationVisible),
  isModalActive: () =&gt; (isModalActive),
  isPluginItemPinned: () =&gt; (isPluginItemPinned),
  isPluginSidebarOpened: () =&gt; (isPluginSidebarOpened),
  isPublishSidebarOpened: () =&gt; (isPublishSidebarOpened),
  isSavingMetaBoxes: () =&gt; (selectors_isSavingMetaBoxes)
});

;// external [&quot;wp&quot;,&quot;blocks&quot;]
const external_wp_blocks_namespaceObject = window[&quot;wp&quot;][&quot;blocks&quot;];
;// external [&quot;wp&quot;,&quot;blockLibrary&quot;]
const external_wp_blockLibrary_namespaceObject = window[&quot;wp&quot;][&quot;blockLibrary&quot;];
;// external [&quot;wp&quot;,&quot;deprecated&quot;]
const external_wp_deprecated_namespaceObject = window[&quot;wp&quot;][&quot;deprecated&quot;];
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
;// external [&quot;wp&quot;,&quot;element&quot;]
const external_wp_element_namespaceObject = window[&quot;wp&quot;][&quot;element&quot;];
;// external [&quot;wp&quot;,&quot;data&quot;]
const external_wp_data_namespaceObject = window[&quot;wp&quot;][&quot;data&quot;];
;// external [&quot;wp&quot;,&quot;preferences&quot;]
const external_wp_preferences_namespaceObject = window[&quot;wp&quot;][&quot;preferences&quot;];
;// external [&quot;wp&quot;,&quot;widgets&quot;]
const external_wp_widgets_namespaceObject = window[&quot;wp&quot;][&quot;widgets&quot;];
;// external [&quot;wp&quot;,&quot;editor&quot;]
const external_wp_editor_namespaceObject = window[&quot;wp&quot;][&quot;editor&quot;];
;// ./node_modules/clsx/dist/clsx.mjs
function r(e){var t,f,n=&quot;&quot;;if(&quot;string&quot;==typeof e||&quot;number&quot;==typeof e)n+=e;else if(&quot;object&quot;==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t&lt;o;t++)e[t]&amp;&amp;(f=r(e[t]))&amp;&amp;(n&amp;&amp;(n+=&quot; &quot;),n+=f)}else for(f in e)e[f]&amp;&amp;(n&amp;&amp;(n+=&quot; &quot;),n+=f);return n}function clsx(){for(var e,t,f=0,n=&quot;&quot;,o=arguments.length;f&lt;o;f++)(e=arguments[f])&amp;&amp;(t=r(e))&amp;&amp;(n&amp;&amp;(n+=&quot; &quot;),n+=t);return n}/* harmony default export */ const dist_clsx = (clsx);
;// external [&quot;wp&quot;,&quot;blockEditor&quot;]
const external_wp_blockEditor_namespaceObject = window[&quot;wp&quot;][&quot;blockEditor&quot;];
;// external [&quot;wp&quot;,&quot;plugins&quot;]
const external_wp_plugins_namespaceObject = window[&quot;wp&quot;][&quot;plugins&quot;];
;// external [&quot;wp&quot;,&quot;i18n&quot;]
const external_wp_i18n_namespaceObject = window[&quot;wp&quot;][&quot;i18n&quot;];
;// external [&quot;wp&quot;,&quot;primitives&quot;]
const external_wp_primitives_namespaceObject = window[&quot;wp&quot;][&quot;primitives&quot;];
;// external &quot;ReactJSXRuntime&quot;
const external_ReactJSXRuntime_namespaceObject = window[&quot;ReactJSXRuntime&quot;];
;// ./node_modules/@wordpress/icons/build-module/library/chevron-up.js
/**
 * WordPress dependencies
 */


const chevronUp = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M6.5 12.4L12 8l5.5 4.4-.9 1.2L12 10l-4.5 3.6-1-1.2z&quot;
  })
});
/* harmony default export */ const chevron_up = (chevronUp);

;// ./node_modules/@wordpress/icons/build-module/library/chevron-down.js
/**
 * WordPress dependencies
 */


const chevronDown = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  viewBox: &quot;0 0 24 24&quot;,
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M17.5 11.6L12 16l-5.5-4.4.9-1.2L12 14l4.5-3.6 1 1.2z&quot;
  })
});
/* harmony default export */ const chevron_down = (chevronDown);

;// external [&quot;wp&quot;,&quot;notices&quot;]
const external_wp_notices_namespaceObject = window[&quot;wp&quot;][&quot;notices&quot;];
;// external [&quot;wp&quot;,&quot;commands&quot;]
const external_wp_commands_namespaceObject = window[&quot;wp&quot;][&quot;commands&quot;];
;// external [&quot;wp&quot;,&quot;coreCommands&quot;]
const external_wp_coreCommands_namespaceObject = window[&quot;wp&quot;][&quot;coreCommands&quot;];
;// external [&quot;wp&quot;,&quot;url&quot;]
const external_wp_url_namespaceObject = window[&quot;wp&quot;][&quot;url&quot;];
;// external [&quot;wp&quot;,&quot;htmlEntities&quot;]
const external_wp_htmlEntities_namespaceObject = window[&quot;wp&quot;][&quot;htmlEntities&quot;];
;// external [&quot;wp&quot;,&quot;coreData&quot;]
const external_wp_coreData_namespaceObject = window[&quot;wp&quot;][&quot;coreData&quot;];
;// external [&quot;wp&quot;,&quot;components&quot;]
const external_wp_components_namespaceObject = window[&quot;wp&quot;][&quot;components&quot;];
;// external [&quot;wp&quot;,&quot;compose&quot;]
const external_wp_compose_namespaceObject = window[&quot;wp&quot;][&quot;compose&quot;];
;// ./node_modules/@wordpress/icons/build-module/library/wordpress.js
/**
 * WordPress dependencies
 */


const wordpress = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;-2 -2 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M20 10c0-5.51-4.49-10-10-10C4.48 0 0 4.49 0 10c0 5.52 4.48 10 10 10 5.51 0 10-4.48 10-10zM7.78 15.37L4.37 6.22c.55-.02 1.17-.08 1.17-.08.5-.06.44-1.13-.06-1.11 0 0-1.45.11-2.37.11-.18 0-.37 0-.58-.01C4.12 2.69 6.87 1.11 10 1.11c2.33 0 4.45.87 6.05 2.34-.68-.11-1.65.39-1.65 1.58 0 .74.45 1.36.9 2.1.35.61.55 1.36.55 2.46 0 1.49-1.4 5-1.4 5l-3.03-8.37c.54-.02.82-.17.82-.17.5-.05.44-1.25-.06-1.22 0 0-1.44.12-2.38.12-.87 0-2.33-.12-2.33-.12-.5-.03-.56 1.2-.06 1.22l.92.08 1.26 3.41zM17.41 10c.24-.64.74-1.87.43-4.25.7 1.29 1.05 2.71 1.05 4.25 0 3.29-1.73 6.24-4.4 7.78.97-2.59 1.94-5.2 2.92-7.78zM6.1 18.09C3.12 16.65 1.11 13.53 1.11 10c0-1.3.23-2.48.72-3.59C3.25 10.3 4.67 14.2 6.1 18.09zm4.03-6.63l2.58 6.98c-.86.29-1.76.45-2.71.45-.79 0-1.57-.11-2.29-.33.81-2.38 1.62-4.74 2.42-7.1z&quot;
  })
});
/* harmony default export */ const library_wordpress = (wordpress);

;// ./node_modules/@wordpress/edit-post/build-module/components/back-button/fullscreen-mode-close.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */









function FullscreenModeClose({
  showTooltip,
  icon,
  href,
  initialPost
}) {
  var _postType$labels$view;
  const {
    isRequestingSiteIcon,
    postType,
    siteIconUrl
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getCurrentPostType
    } = select(external_wp_editor_namespaceObject.store);
    const {
      getEntityRecord,
      getPostType,
      isResolving
    } = select(external_wp_coreData_namespaceObject.store);
    const siteData = getEntityRecord(&#039;root&#039;, &#039;__unstableBase&#039;, undefined) || {};
    const _postType = initialPost?.type || getCurrentPostType();
    return {
      isRequestingSiteIcon: isResolving(&#039;getEntityRecord&#039;, [&#039;root&#039;, &#039;__unstableBase&#039;, undefined]),
      postType: getPostType(_postType),
      siteIconUrl: siteData.site_icon_url
    };
  }, []);
  const disableMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
  if (!postType) {
    return null;
  }
  let buttonIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
    size: &quot;36px&quot;,
    icon: library_wordpress
  });
  const effect = {
    expand: {
      scale: 1.25,
      transition: {
        type: &#039;tween&#039;,
        duration: &#039;0.3&#039;
      }
    }
  };
  if (siteIconUrl) {
    buttonIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.img, {
      variants: !disableMotion &amp;&amp; effect,
      alt: (0,external_wp_i18n_namespaceObject.__)(&#039;Site Icon&#039;),
      className: &quot;edit-post-fullscreen-mode-close_site-icon&quot;,
      src: siteIconUrl
    });
  }
  if (isRequestingSiteIcon) {
    buttonIcon = null;
  }

  // Override default icon if custom icon is provided via props.
  if (icon) {
    buttonIcon = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
      size: &quot;36px&quot;,
      icon: icon
    });
  }
  const classes = dist_clsx(&#039;edit-post-fullscreen-mode-close&#039;, {
    &#039;has-icon&#039;: siteIconUrl
  });
  const buttonHref = href !== null &amp;&amp; href !== void 0 ? href : (0,external_wp_url_namespaceObject.addQueryArgs)(&#039;edit.php&#039;, {
    post_type: postType.slug
  });
  const buttonLabel = (_postType$labels$view = postType?.labels?.view_items) !== null &amp;&amp; _postType$labels$view !== void 0 ? _postType$labels$view : (0,external_wp_i18n_namespaceObject.__)(&#039;Back&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
    whileHover: &quot;expand&quot;,
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      className: classes,
      href: buttonHref,
      label: buttonLabel,
      showTooltip: showTooltip,
      children: buttonIcon
    })
  });
}
/* harmony default export */ const fullscreen_mode_close = (FullscreenModeClose);

;// external [&quot;wp&quot;,&quot;privateApis&quot;]
const external_wp_privateApis_namespaceObject = window[&quot;wp&quot;][&quot;privateApis&quot;];
;// ./node_modules/@wordpress/edit-post/build-module/lock-unlock.js
/**
 * WordPress dependencies
 */

const {
  lock,
  unlock
} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(&#039;I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.&#039;, &#039;@wordpress/edit-post&#039;);

;// ./node_modules/@wordpress/edit-post/build-module/components/back-button/index.js
/**
 * WordPress dependencies
 */



/**
 * Internal dependencies
 */



const {
  BackButton: BackButtonFill
} = unlock(external_wp_editor_namespaceObject.privateApis);
const slideX = {
  hidden: {
    x: &#039;-100%&#039;
  },
  distractionFreeInactive: {
    x: 0
  },
  hover: {
    x: 0,
    transition: {
      type: &#039;tween&#039;,
      delay: 0.2
    }
  }
};
function BackButton({
  initialPost
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BackButtonFill, {
    children: ({
      length
    }) =&gt; length &lt;= 1 &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__unstableMotion.div, {
      variants: slideX,
      transition: {
        type: &#039;tween&#039;,
        delay: 0.8
      },
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(fullscreen_mode_close, {
        showTooltip: true,
        initialPost: initialPost
      })
    })
  });
}
/* harmony default export */ const back_button = (BackButton);

;// ./node_modules/@wordpress/edit-post/build-module/store/constants.js
/**
 * The identifier for the data store.
 *
 * @type {string}
 */
const STORE_NAME = &#039;core/edit-post&#039;;

/**
 * CSS selector string for the admin bar view post link anchor tag.
 *
 * @type {string}
 */
const VIEW_AS_LINK_SELECTOR = &#039;#wp-admin-bar-view a&#039;;

/**
 * CSS selector string for the admin bar preview post link anchor tag.
 *
 * @type {string}
 */
const VIEW_AS_PREVIEW_LINK_SELECTOR = &#039;#wp-admin-bar-preview a&#039;;

;// ./node_modules/@wordpress/edit-post/build-module/components/editor-initialization/listener-hooks.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * This listener hook monitors any change in permalink and updates the view
 * post link in the admin bar.
 */
const useUpdatePostLinkListener = () =&gt; {
  const {
    newPermalink
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; ({
    newPermalink: select(external_wp_editor_namespaceObject.store).getCurrentPost().link
  }), []);
  const nodeToUpdateRef = (0,external_wp_element_namespaceObject.useRef)();
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    nodeToUpdateRef.current = document.querySelector(VIEW_AS_PREVIEW_LINK_SELECTOR) || document.querySelector(VIEW_AS_LINK_SELECTOR);
  }, []);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (!newPermalink || !nodeToUpdateRef.current) {
      return;
    }
    nodeToUpdateRef.current.setAttribute(&#039;href&#039;, newPermalink);
  }, [newPermalink]);
};

;// ./node_modules/@wordpress/edit-post/build-module/components/editor-initialization/index.js
/**
 * Internal dependencies
 */


/**
 * Data component used for initializing the editor and re-initializes
 * when postId changes or on unmount.
 *
 * @return {null} This is a data component so does not render any ui.
 */
function EditorInitialization() {
  useUpdatePostLinkListener();
  return null;
}

;// external [&quot;wp&quot;,&quot;keyboardShortcuts&quot;]
const external_wp_keyboardShortcuts_namespaceObject = window[&quot;wp&quot;][&quot;keyboardShortcuts&quot;];
;// ./node_modules/@wordpress/edit-post/build-module/store/reducer.js
/**
 * WordPress dependencies
 */


/**
 * Reducer keeping track of the meta boxes isSaving state.
 * A &quot;true&quot; value means the meta boxes saving request is in-flight.
 *
 *
 * @param {boolean} state  Previous state.
 * @param {Object}  action Action Object.
 *
 * @return {Object} Updated state.
 */
function isSavingMetaBoxes(state = false, action) {
  switch (action.type) {
    case &#039;REQUEST_META_BOX_UPDATES&#039;:
      return true;
    case &#039;META_BOX_UPDATES_SUCCESS&#039;:
    case &#039;META_BOX_UPDATES_FAILURE&#039;:
      return false;
    default:
      return state;
  }
}
function mergeMetaboxes(metaboxes = [], newMetaboxes) {
  const mergedMetaboxes = [...metaboxes];
  for (const metabox of newMetaboxes) {
    const existing = mergedMetaboxes.findIndex(box =&gt; box.id === metabox.id);
    if (existing !== -1) {
      mergedMetaboxes[existing] = metabox;
    } else {
      mergedMetaboxes.push(metabox);
    }
  }
  return mergedMetaboxes;
}

/**
 * Reducer keeping track of the meta boxes per location.
 *
 * @param {boolean} state  Previous state.
 * @param {Object}  action Action Object.
 *
 * @return {Object} Updated state.
 */
function metaBoxLocations(state = {}, action) {
  switch (action.type) {
    case &#039;SET_META_BOXES_PER_LOCATIONS&#039;:
      {
        const newState = {
          ...state
        };
        for (const [location, metaboxes] of Object.entries(action.metaBoxesPerLocation)) {
          newState[location] = mergeMetaboxes(newState[location], metaboxes);
        }
        return newState;
      }
  }
  return state;
}

/**
 * Reducer tracking whether meta boxes are initialized.
 *
 * @param {boolean} state
 * @param {Object}  action
 *
 * @return {boolean} Updated state.
 */
function metaBoxesInitialized(state = false, action) {
  switch (action.type) {
    case &#039;META_BOXES_INITIALIZED&#039;:
      return true;
  }
  return state;
}
const metaBoxes = (0,external_wp_data_namespaceObject.combineReducers)({
  isSaving: isSavingMetaBoxes,
  locations: metaBoxLocations,
  initialized: metaBoxesInitialized
});
/* harmony default export */ const reducer = ((0,external_wp_data_namespaceObject.combineReducers)({
  metaBoxes
}));

;// external [&quot;wp&quot;,&quot;apiFetch&quot;]
const external_wp_apiFetch_namespaceObject = window[&quot;wp&quot;][&quot;apiFetch&quot;];
var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject);
;// external [&quot;wp&quot;,&quot;hooks&quot;]
const external_wp_hooks_namespaceObject = window[&quot;wp&quot;][&quot;hooks&quot;];
;// ./node_modules/@wordpress/edit-post/build-module/utils/meta-boxes.js
/**
 * Function returning the current Meta Boxes DOM Node in the editor
 * whether the meta box area is opened or not.
 * If the MetaBox Area is visible returns it, and returns the original container instead.
 *
 * @param {string} location Meta Box location.
 *
 * @return {string} HTML content.
 */
const getMetaBoxContainer = location =&gt; {
  const area = document.querySelector(`.edit-post-meta-boxes-area.is-${location} .metabox-location-${location}`);
  if (area) {
    return area;
  }
  return document.querySelector(&#039;#metaboxes .metabox-location-&#039; + location);
};

;// ./node_modules/@wordpress/edit-post/build-module/store/actions.js
/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */


const {
  interfaceStore
} = unlock(external_wp_editor_namespaceObject.privateApis);

/**
 * Returns an action object used in signalling that the user opened an editor sidebar.
 *
 * @param {?string} name Sidebar name to be opened.
 */
const openGeneralSidebar = name =&gt; ({
  registry
}) =&gt; {
  registry.dispatch(interfaceStore).enableComplementaryArea(&#039;core&#039;, name);
};

/**
 * Returns an action object signalling that the user closed the sidebar.
 */
const closeGeneralSidebar = () =&gt; ({
  registry
}) =&gt; registry.dispatch(interfaceStore).disableComplementaryArea(&#039;core&#039;);

/**
 * Returns an action object used in signalling that the user opened a modal.
 *
 * @deprecated since WP 6.3 use `core/interface` store&#039;s action with the same name instead.
 *
 *
 * @param {string} name A string that uniquely identifies the modal.
 *
 * @return {Object} Action object.
 */
const openModal = name =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;select( &#039;core/edit-post&#039; ).openModal( name )&quot;, {
    since: &#039;6.3&#039;,
    alternative: &quot;select( &#039;core/interface&#039;).openModal( name )&quot;
  });
  return registry.dispatch(interfaceStore).openModal(name);
};

/**
 * Returns an action object signalling that the user closed a modal.
 *
 * @deprecated since WP 6.3 use `core/interface` store&#039;s action with the same name instead.
 *
 * @return {Object} Action object.
 */
const closeModal = () =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;select( &#039;core/edit-post&#039; ).closeModal()&quot;, {
    since: &#039;6.3&#039;,
    alternative: &quot;select( &#039;core/interface&#039;).closeModal()&quot;
  });
  return registry.dispatch(interfaceStore).closeModal();
};

/**
 * Returns an action object used in signalling that the user opened the publish
 * sidebar.
 * @deprecated
 *
 * @return {Object} Action object
 */
const openPublishSidebar = () =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).openPublishSidebar&quot;, {
    since: &#039;6.6&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).openPublishSidebar&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).openPublishSidebar();
};

/**
 * Returns an action object used in signalling that the user closed the
 * publish sidebar.
 * @deprecated
 *
 * @return {Object} Action object.
 */
const closePublishSidebar = () =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).closePublishSidebar&quot;, {
    since: &#039;6.6&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).closePublishSidebar&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).closePublishSidebar();
};

/**
 * Returns an action object used in signalling that the user toggles the publish sidebar.
 * @deprecated
 *
 * @return {Object} Action object
 */
const togglePublishSidebar = () =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).togglePublishSidebar&quot;, {
    since: &#039;6.6&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).togglePublishSidebar&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).togglePublishSidebar();
};

/**
 * Returns an action object used to enable or disable a panel in the editor.
 *
 * @deprecated
 *
 * @param {string} panelName A string that identifies the panel to enable or disable.
 *
 * @return {Object} Action object.
 */
const toggleEditorPanelEnabled = panelName =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).toggleEditorPanelEnabled&quot;, {
    since: &#039;6.5&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).toggleEditorPanelEnabled&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).toggleEditorPanelEnabled(panelName);
};

/**
 * Opens a closed panel and closes an open panel.
 *
 * @deprecated
 *
 * @param {string} panelName A string that identifies the panel to open or close.
 */
const toggleEditorPanelOpened = panelName =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).toggleEditorPanelOpened&quot;, {
    since: &#039;6.5&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).toggleEditorPanelOpened&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).toggleEditorPanelOpened(panelName);
};

/**
 * Returns an action object used to remove a panel from the editor.
 *
 * @deprecated
 *
 * @param {string} panelName A string that identifies the panel to remove.
 *
 * @return {Object} Action object.
 */
const removeEditorPanel = panelName =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).removeEditorPanel&quot;, {
    since: &#039;6.5&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).removeEditorPanel&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).removeEditorPanel(panelName);
};

/**
 * Triggers an action used to toggle a feature flag.
 *
 * @param {string} feature Feature name.
 */
const toggleFeature = feature =&gt; ({
  registry
}) =&gt; registry.dispatch(external_wp_preferences_namespaceObject.store).toggle(&#039;core/edit-post&#039;, feature);

/**
 * Triggers an action used to switch editor mode.
 *
 * @deprecated
 *
 * @param {string} mode The editor mode.
 */
const switchEditorMode = mode =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).switchEditorMode&quot;, {
    since: &#039;6.6&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).switchEditorMode&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).switchEditorMode(mode);
};

/**
 * Triggers an action object used to toggle a plugin name flag.
 *
 * @param {string} pluginName Plugin name.
 */
const togglePinnedPluginItem = pluginName =&gt; ({
  registry
}) =&gt; {
  const isPinned = registry.select(interfaceStore).isItemPinned(&#039;core&#039;, pluginName);
  registry.dispatch(interfaceStore)[isPinned ? &#039;unpinItem&#039; : &#039;pinItem&#039;](&#039;core&#039;, pluginName);
};

/**
 * Returns an action object used in signaling that a style should be auto-applied when a block is created.
 *
 * @deprecated
 */
function updatePreferredStyleVariations() {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).updatePreferredStyleVariations&quot;, {
    since: &#039;6.6&#039;,
    hint: &#039;Preferred Style Variations are not supported anymore.&#039;
  });
  return {
    type: &#039;NOTHING&#039;
  };
}

/**
 * Update the provided block types to be visible.
 *
 * @param {string[]} blockNames Names of block types to show.
 */
const showBlockTypes = blockNames =&gt; ({
  registry
}) =&gt; {
  unlock(registry.dispatch(external_wp_editor_namespaceObject.store)).showBlockTypes(blockNames);
};

/**
 * Update the provided block types to be hidden.
 *
 * @param {string[]} blockNames Names of block types to hide.
 */
const hideBlockTypes = blockNames =&gt; ({
  registry
}) =&gt; {
  unlock(registry.dispatch(external_wp_editor_namespaceObject.store)).hideBlockTypes(blockNames);
};

/**
 * Stores info about which Meta boxes are available in which location.
 *
 * @param {Object} metaBoxesPerLocation Meta boxes per location.
 */
function setAvailableMetaBoxesPerLocation(metaBoxesPerLocation) {
  return {
    type: &#039;SET_META_BOXES_PER_LOCATIONS&#039;,
    metaBoxesPerLocation
  };
}

/**
 * Update a metabox.
 */
const requestMetaBoxUpdates = () =&gt; async ({
  registry,
  select,
  dispatch
}) =&gt; {
  dispatch({
    type: &#039;REQUEST_META_BOX_UPDATES&#039;
  });

  // Saves the wp_editor fields.
  if (window.tinyMCE) {
    window.tinyMCE.triggerSave();
  }

  // We gather the base form data.
  const baseFormData = new window.FormData(document.querySelector(&#039;.metabox-base-form&#039;));
  const postId = baseFormData.get(&#039;post_ID&#039;);
  const postType = baseFormData.get(&#039;post_type&#039;);

  // Additional data needed for backward compatibility.
  // If we do not provide this data, the post will be overridden with the default values.
  // We cannot rely on getCurrentPost because right now on the editor we may be editing a pattern or a template.
  // We need to retrieve the post that the base form data is referring to.
  const post = registry.select(external_wp_coreData_namespaceObject.store).getEditedEntityRecord(&#039;postType&#039;, postType, postId);
  const additionalData = [post.comment_status ? [&#039;comment_status&#039;, post.comment_status] : false, post.ping_status ? [&#039;ping_status&#039;, post.ping_status] : false, post.sticky ? [&#039;sticky&#039;, post.sticky] : false, post.author ? [&#039;post_author&#039;, post.author] : false].filter(Boolean);

  // We gather all the metaboxes locations.
  const activeMetaBoxLocations = select.getActiveMetaBoxLocations();
  const formDataToMerge = [baseFormData, ...activeMetaBoxLocations.map(location =&gt; new window.FormData(getMetaBoxContainer(location)))];

  // Merge all form data objects into a single one.
  const formData = formDataToMerge.reduce((memo, currentFormData) =&gt; {
    for (const [key, value] of currentFormData) {
      memo.append(key, value);
    }
    return memo;
  }, new window.FormData());
  additionalData.forEach(([key, value]) =&gt; formData.append(key, value));
  try {
    // Save the metaboxes.
    await external_wp_apiFetch_default()({
      url: window._wpMetaBoxUrl,
      method: &#039;POST&#039;,
      body: formData,
      parse: false
    });
    dispatch.metaBoxUpdatesSuccess();
  } catch {
    dispatch.metaBoxUpdatesFailure();
  }
};

/**
 * Returns an action object used to signal a successful meta box update.
 *
 * @return {Object} Action object.
 */
function metaBoxUpdatesSuccess() {
  return {
    type: &#039;META_BOX_UPDATES_SUCCESS&#039;
  };
}

/**
 * Returns an action object used to signal a failed meta box update.
 *
 * @return {Object} Action object.
 */
function metaBoxUpdatesFailure() {
  return {
    type: &#039;META_BOX_UPDATES_FAILURE&#039;
  };
}

/**
 * Action that changes the width of the editing canvas.
 *
 * @deprecated
 *
 * @param {string} deviceType
 */
const __experimentalSetPreviewDeviceType = deviceType =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).__experimentalSetPreviewDeviceType&quot;, {
    since: &#039;6.5&#039;,
    version: &#039;6.7&#039;,
    hint: &#039;registry.dispatch( editorStore ).setDeviceType&#039;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).setDeviceType(deviceType);
};

/**
 * Returns an action object used to open/close the inserter.
 *
 * @deprecated
 *
 * @param {boolean|Object} value Whether the inserter should be opened (true) or closed (false).
 */
const setIsInserterOpened = value =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).setIsInserterOpened&quot;, {
    since: &#039;6.5&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).setIsInserterOpened&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).setIsInserterOpened(value);
};

/**
 * Returns an action object used to open/close the list view.
 *
 * @deprecated
 *
 * @param {boolean} isOpen A boolean representing whether the list view should be opened or closed.
 */
const setIsListViewOpened = isOpen =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).setIsListViewOpened&quot;, {
    since: &#039;6.5&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).setIsListViewOpened&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).setIsListViewOpened(isOpen);
};

/**
 * Returns an action object used to switch to template editing.
 *
 * @deprecated
 */
function setIsEditingTemplate() {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).setIsEditingTemplate&quot;, {
    since: &#039;6.5&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).setRenderingMode&quot;
  });
  return {
    type: &#039;NOTHING&#039;
  };
}

/**
 * Create a block based template.
 *
 * @deprecated
 */
function __unstableCreateTemplate() {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).__unstableCreateTemplate&quot;, {
    since: &#039;6.5&#039;
  });
  return {
    type: &#039;NOTHING&#039;
  };
}
let actions_metaBoxesInitialized = false;

/**
 * Initializes WordPress `postboxes` script and the logic for saving meta boxes.
 */
const initializeMetaBoxes = () =&gt; ({
  registry,
  select,
  dispatch
}) =&gt; {
  const isEditorReady = registry.select(external_wp_editor_namespaceObject.store).__unstableIsEditorReady();
  if (!isEditorReady) {
    return;
  }
  // Only initialize once.
  if (actions_metaBoxesInitialized) {
    return;
  }
  const postType = registry.select(external_wp_editor_namespaceObject.store).getCurrentPostType();
  if (window.postboxes.page !== postType) {
    window.postboxes.add_postbox_toggles(postType);
  }
  actions_metaBoxesInitialized = true;

  // Save metaboxes on save completion, except for autosaves.
  (0,external_wp_hooks_namespaceObject.addAction)(&#039;editor.savePost&#039;, &#039;core/edit-post/save-metaboxes&#039;, async (post, options) =&gt; {
    if (!options.isAutosave &amp;&amp; select.hasMetaBoxes()) {
      await dispatch.requestMetaBoxUpdates();
    }
  });
  dispatch({
    type: &#039;META_BOXES_INITIALIZED&#039;
  });
};

/**
 * Action that toggles Distraction free mode.
 * Distraction free mode expects there are no sidebars, as due to the
 * z-index values set, you can&#039;t close sidebars.
 *
 * @deprecated
 */
const toggleDistractionFree = () =&gt; ({
  registry
}) =&gt; {
  external_wp_deprecated_default()(&quot;dispatch( &#039;core/edit-post&#039; ).toggleDistractionFree&quot;, {
    since: &#039;6.6&#039;,
    alternative: &quot;dispatch( &#039;core/editor&#039;).toggleDistractionFree&quot;
  });
  registry.dispatch(external_wp_editor_namespaceObject.store).toggleDistractionFree();
};

/**
 * Action that toggles the Fullscreen Mode view option.
 */
const toggleFullscreenMode = () =&gt; ({
  registry
}) =&gt; {
  const isFullscreen = registry.select(external_wp_preferences_namespaceObject.store).get(&#039;core/edit-post&#039;, &#039;fullscreenMode&#039;);
  registry.dispatch(external_wp_preferences_namespaceObject.store).toggle(&#039;core/edit-post&#039;, &#039;fullscreenMode&#039;);
  registry.dispatch(external_wp_notices_namespaceObject.store).createInfoNotice(isFullscreen ? (0,external_wp_i18n_namespaceObject.__)(&#039;Fullscreen mode deactivated.&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Fullscreen mode activated.&#039;), {
    id: &#039;core/edit-post/toggle-fullscreen-mode/notice&#039;,
    type: &#039;snackbar&#039;,
    actions: [{
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Undo&#039;),
      onClick: () =&gt; {
        registry.dispatch(external_wp_preferences_namespaceObject.store).toggle(&#039;core/edit-post&#039;, &#039;fullscreenMode&#039;);
      }
    }]
  });
};

;// ./node_modules/@wordpress/edit-post/build-module/store/selectors.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */

const {
  interfaceStore: selectors_interfaceStore
} = unlock(external_wp_editor_namespaceObject.privateApis);
const EMPTY_ARRAY = [];
const EMPTY_OBJECT = {};

/**
 * Returns the current editing mode.
 *
 * @param {Object} state Global application state.
 *
 * @return {string} Editing mode.
 */
const getEditorMode = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  var _select$get;
  return (_select$get = select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;editorMode&#039;)) !== null &amp;&amp; _select$get !== void 0 ? _select$get : &#039;visual&#039;;
});

/**
 * Returns true if the editor sidebar is opened.
 *
 * @param {Object} state Global application state
 *
 * @return {boolean} Whether the editor sidebar is opened.
 */
const isEditorSidebarOpened = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  const activeGeneralSidebar = select(selectors_interfaceStore).getActiveComplementaryArea(&#039;core&#039;);
  return [&#039;edit-post/document&#039;, &#039;edit-post/block&#039;].includes(activeGeneralSidebar);
});

/**
 * Returns true if the plugin sidebar is opened.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether the plugin sidebar is opened.
 */
const isPluginSidebarOpened = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  const activeGeneralSidebar = select(selectors_interfaceStore).getActiveComplementaryArea(&#039;core&#039;);
  return !!activeGeneralSidebar &amp;&amp; ![&#039;edit-post/document&#039;, &#039;edit-post/block&#039;].includes(activeGeneralSidebar);
});

/**
 * Returns the current active general sidebar name, or null if there is no
 * general sidebar active. The active general sidebar is a unique name to
 * identify either an editor or plugin sidebar.
 *
 * Examples:
 *
 *  - `edit-post/document`
 *  - `my-plugin/insert-image-sidebar`
 *
 * @param {Object} state Global application state.
 *
 * @return {?string} Active general sidebar name.
 */
const getActiveGeneralSidebarName = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  return select(selectors_interfaceStore).getActiveComplementaryArea(&#039;core&#039;);
});

/**
 * Converts panels from the new preferences store format to the old format
 * that the post editor previously used.
 *
 * The resultant converted data should look like this:
 * {
 *     panelName: {
 *         enabled: false,
 *         opened: true,
 *     },
 *     anotherPanelName: {
 *         opened: true
 *     },
 * }
 *
 * @param {string[] | undefined} inactivePanels An array of inactive panel names.
 * @param {string[] | undefined} openPanels     An array of open panel names.
 *
 * @return {Object} The converted panel data.
 */
function convertPanelsToOldFormat(inactivePanels, openPanels) {
  var _ref;
  // First reduce the inactive panels.
  const panelsWithEnabledState = inactivePanels?.reduce((accumulatedPanels, panelName) =&gt; ({
    ...accumulatedPanels,
    [panelName]: {
      enabled: false
    }
  }), {});

  // Then reduce the open panels, passing in the result of the previous
  // reduction as the initial value so that both open and inactive
  // panel state is combined.
  const panels = openPanels?.reduce((accumulatedPanels, panelName) =&gt; {
    const currentPanelState = accumulatedPanels?.[panelName];
    return {
      ...accumulatedPanels,
      [panelName]: {
        ...currentPanelState,
        opened: true
      }
    };
  }, panelsWithEnabledState !== null &amp;&amp; panelsWithEnabledState !== void 0 ? panelsWithEnabledState : {});

  // The panels variable will only be set if openPanels wasn&#039;t `undefined`.
  // If it isn&#039;t set just return `panelsWithEnabledState`, and if that isn&#039;t
  // set return an empty object.
  return (_ref = panels !== null &amp;&amp; panels !== void 0 ? panels : panelsWithEnabledState) !== null &amp;&amp; _ref !== void 0 ? _ref : EMPTY_OBJECT;
}

/**
 * Returns the preferences (these preferences are persisted locally).
 *
 * @param {Object} state Global application state.
 *
 * @return {Object} Preferences Object.
 */
const getPreferences = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).getPreferences`, {
    since: &#039;6.0&#039;,
    alternative: `select( &#039;core/preferences&#039; ).get`
  });
  const corePreferences = [&#039;editorMode&#039;, &#039;hiddenBlockTypes&#039;].reduce((accumulatedPrefs, preferenceKey) =&gt; {
    const value = select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, preferenceKey);
    return {
      ...accumulatedPrefs,
      [preferenceKey]: value
    };
  }, {});

  // Panels were a preference, but the data structure changed when the state
  // was migrated to the preferences store. They need to be converted from
  // the new preferences store format to old format to ensure no breaking
  // changes for plugins.
  const inactivePanels = select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;inactivePanels&#039;);
  const openPanels = select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;openPanels&#039;);
  const panels = convertPanelsToOldFormat(inactivePanels, openPanels);
  return {
    ...corePreferences,
    panels
  };
});

/**
 *
 * @param {Object} state         Global application state.
 * @param {string} preferenceKey Preference Key.
 * @param {*}      defaultValue  Default Value.
 *
 * @return {*} Preference Value.
 */
function getPreference(state, preferenceKey, defaultValue) {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).getPreference`, {
    since: &#039;6.0&#039;,
    alternative: `select( &#039;core/preferences&#039; ).get`
  });

  // Avoid using the `getPreferences` registry selector where possible.
  const preferences = getPreferences(state);
  const value = preferences[preferenceKey];
  return value === undefined ? defaultValue : value;
}

/**
 * Returns an array of blocks that are hidden.
 *
 * @return {Array} A list of the hidden block types
 */
const getHiddenBlockTypes = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  var _select$get2;
  return (_select$get2 = select(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;hiddenBlockTypes&#039;)) !== null &amp;&amp; _select$get2 !== void 0 ? _select$get2 : EMPTY_ARRAY;
});

/**
 * Returns true if the publish sidebar is opened.
 *
 * @deprecated
 *
 * @param {Object} state Global application state
 *
 * @return {boolean} Whether the publish sidebar is open.
 */
const isPublishSidebarOpened = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isPublishSidebarOpened`, {
    since: &#039;6.6&#039;,
    alternative: `select( &#039;core/editor&#039; ).isPublishSidebarOpened`
  });
  return select(external_wp_editor_namespaceObject.store).isPublishSidebarOpened();
});

/**
 * Returns true if the given panel was programmatically removed, or false otherwise.
 * All panels are not removed by default.
 *
 * @deprecated
 *
 * @param {Object} state     Global application state.
 * @param {string} panelName A string that identifies the panel.
 *
 * @return {boolean} Whether or not the panel is removed.
 */
const isEditorPanelRemoved = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, panelName) =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isEditorPanelRemoved`, {
    since: &#039;6.5&#039;,
    alternative: `select( &#039;core/editor&#039; ).isEditorPanelRemoved`
  });
  return select(external_wp_editor_namespaceObject.store).isEditorPanelRemoved(panelName);
});

/**
 * Returns true if the given panel is enabled, or false otherwise. Panels are
 * enabled by default.
 *
 * @deprecated
 *
 * @param {Object} state     Global application state.
 * @param {string} panelName A string that identifies the panel.
 *
 * @return {boolean} Whether or not the panel is enabled.
 */
const isEditorPanelEnabled = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, panelName) =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isEditorPanelEnabled`, {
    since: &#039;6.5&#039;,
    alternative: `select( &#039;core/editor&#039; ).isEditorPanelEnabled`
  });
  return select(external_wp_editor_namespaceObject.store).isEditorPanelEnabled(panelName);
});

/**
 * Returns true if the given panel is open, or false otherwise. Panels are
 * closed by default.
 *
 * @deprecated
 *
 * @param {Object} state     Global application state.
 * @param {string} panelName A string that identifies the panel.
 *
 * @return {boolean} Whether or not the panel is open.
 */
const isEditorPanelOpened = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, panelName) =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isEditorPanelOpened`, {
    since: &#039;6.5&#039;,
    alternative: `select( &#039;core/editor&#039; ).isEditorPanelOpened`
  });
  return select(external_wp_editor_namespaceObject.store).isEditorPanelOpened(panelName);
});

/**
 * Returns true if a modal is active, or false otherwise.
 *
 * @deprecated since WP 6.3 use `core/interface` store&#039;s selector with the same name instead.
 *
 * @param {Object} state     Global application state.
 * @param {string} modalName A string that uniquely identifies the modal.
 *
 * @return {boolean} Whether the modal is active.
 */
const isModalActive = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, modalName) =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isModalActive`, {
    since: &#039;6.3&#039;,
    alternative: `select( &#039;core/interface&#039; ).isModalActive`
  });
  return !!select(selectors_interfaceStore).isModalActive(modalName);
});

/**
 * Returns whether the given feature is enabled or not.
 *
 * @param {Object} state   Global application state.
 * @param {string} feature Feature slug.
 *
 * @return {boolean} Is active.
 */
const isFeatureActive = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, feature) =&gt; {
  return !!select(external_wp_preferences_namespaceObject.store).get(&#039;core/edit-post&#039;, feature);
});

/**
 * Returns true if the plugin item is pinned to the header.
 * When the value is not set it defaults to true.
 *
 * @param {Object} state      Global application state.
 * @param {string} pluginName Plugin item name.
 *
 * @return {boolean} Whether the plugin item is pinned.
 */
const isPluginItemPinned = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, pluginName) =&gt; {
  return select(selectors_interfaceStore).isItemPinned(&#039;core&#039;, pluginName);
});

/**
 * Returns an array of active meta box locations.
 *
 * @param {Object} state Post editor state.
 *
 * @return {string[]} Active meta box locations.
 */
const getActiveMetaBoxLocations = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  return Object.keys(state.metaBoxes.locations).filter(location =&gt; isMetaBoxLocationActive(state, location));
}, state =&gt; [state.metaBoxes.locations]);

/**
 * Returns true if a metabox location is active and visible
 *
 * @param {Object} state    Post editor state.
 * @param {string} location Meta box location to test.
 *
 * @return {boolean} Whether the meta box location is active and visible.
 */
const isMetaBoxLocationVisible = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; (state, location) =&gt; {
  return isMetaBoxLocationActive(state, location) &amp;&amp; getMetaBoxesPerLocation(state, location)?.some(({
    id
  }) =&gt; {
    return select(external_wp_editor_namespaceObject.store).isEditorPanelEnabled(`meta-box-${id}`);
  });
});

/**
 * Returns true if there is an active meta box in the given location, or false
 * otherwise.
 *
 * @param {Object} state    Post editor state.
 * @param {string} location Meta box location to test.
 *
 * @return {boolean} Whether the meta box location is active.
 */
function isMetaBoxLocationActive(state, location) {
  const metaBoxes = getMetaBoxesPerLocation(state, location);
  return !!metaBoxes &amp;&amp; metaBoxes.length !== 0;
}

/**
 * Returns the list of all the available meta boxes for a given location.
 *
 * @param {Object} state    Global application state.
 * @param {string} location Meta box location to test.
 *
 * @return {?Array} List of meta boxes.
 */
function getMetaBoxesPerLocation(state, location) {
  return state.metaBoxes.locations[location];
}

/**
 * Returns the list of all the available meta boxes.
 *
 * @param {Object} state Global application state.
 *
 * @return {Array} List of meta boxes.
 */
const getAllMetaBoxes = (0,external_wp_data_namespaceObject.createSelector)(state =&gt; {
  return Object.values(state.metaBoxes.locations).flat();
}, state =&gt; [state.metaBoxes.locations]);

/**
 * Returns true if the post is using Meta Boxes
 *
 * @param {Object} state Global application state
 *
 * @return {boolean} Whether there are metaboxes or not.
 */
function hasMetaBoxes(state) {
  return getActiveMetaBoxLocations(state).length &gt; 0;
}

/**
 * Returns true if the Meta Boxes are being saved.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether the metaboxes are being saved.
 */
function selectors_isSavingMetaBoxes(state) {
  return state.metaBoxes.isSaving;
}

/**
 * Returns the current editing canvas device type.
 *
 * @deprecated
 *
 * @param {Object} state Global application state.
 *
 * @return {string} Device type.
 */
const __experimentalGetPreviewDeviceType = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-site&#039; ).__experimentalGetPreviewDeviceType`, {
    since: &#039;6.5&#039;,
    version: &#039;6.7&#039;,
    alternative: `select( &#039;core/editor&#039; ).getDeviceType`
  });
  return select(external_wp_editor_namespaceObject.store).getDeviceType();
});

/**
 * Returns true if the inserter is opened.
 *
 * @deprecated
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether the inserter is opened.
 */
const isInserterOpened = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isInserterOpened`, {
    since: &#039;6.5&#039;,
    alternative: `select( &#039;core/editor&#039; ).isInserterOpened`
  });
  return select(external_wp_editor_namespaceObject.store).isInserterOpened();
});

/**
 * Get the insertion point for the inserter.
 *
 * @deprecated
 *
 * @param {Object} state Global application state.
 *
 * @return {Object} The root client ID, index to insert at and starting filter value.
 */
const __experimentalGetInsertionPoint = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).__experimentalGetInsertionPoint`, {
    since: &#039;6.5&#039;,
    version: &#039;6.7&#039;
  });
  return unlock(select(external_wp_editor_namespaceObject.store)).getInserter();
});

/**
 * Returns true if the list view is opened.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether the list view is opened.
 */
const isListViewOpened = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isListViewOpened`, {
    since: &#039;6.5&#039;,
    alternative: `select( &#039;core/editor&#039; ).isListViewOpened`
  });
  return select(external_wp_editor_namespaceObject.store).isListViewOpened();
});

/**
 * Returns true if the template editing mode is enabled.
 *
 * @deprecated
 */
const isEditingTemplate = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  external_wp_deprecated_default()(`select( &#039;core/edit-post&#039; ).isEditingTemplate`, {
    since: &#039;6.5&#039;,
    alternative: `select( &#039;core/editor&#039; ).getRenderingMode`
  });
  return select(external_wp_editor_namespaceObject.store).getCurrentPostType() === &#039;wp_template&#039;;
});

/**
 * Returns true if meta boxes are initialized.
 *
 * @param {Object} state Global application state.
 *
 * @return {boolean} Whether meta boxes are initialized.
 */
function areMetaBoxesInitialized(state) {
  return state.metaBoxes.initialized;
}

/**
 * Retrieves the template of the currently edited post.
 *
 * @return {?Object} Post Template.
 */
const getEditedPostTemplate = (0,external_wp_data_namespaceObject.createRegistrySelector)(select =&gt; () =&gt; {
  const {
    id: postId,
    type: postType
  } = select(external_wp_editor_namespaceObject.store).getCurrentPost();
  const templateId = unlock(select(external_wp_coreData_namespaceObject.store)).getTemplateId(postType, postId);
  if (!templateId) {
    return undefined;
  }
  return select(external_wp_coreData_namespaceObject.store).getEditedEntityRecord(&#039;postType&#039;, &#039;wp_template&#039;, templateId);
});

;// ./node_modules/@wordpress/edit-post/build-module/store/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */





/**
 * Store definition for the edit post 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, {
  reducer: reducer,
  actions: actions_namespaceObject,
  selectors: selectors_namespaceObject
});
(0,external_wp_data_namespaceObject.register)(store);

;// ./node_modules/@wordpress/edit-post/build-module/components/keyboard-shortcuts/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */

function KeyboardShortcuts() {
  const {
    toggleFullscreenMode
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  const {
    registerShortcut
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_keyboardShortcuts_namespaceObject.store);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    registerShortcut({
      name: &#039;core/edit-post/toggle-fullscreen&#039;,
      category: &#039;global&#039;,
      description: (0,external_wp_i18n_namespaceObject.__)(&#039;Enable or disable fullscreen mode.&#039;),
      keyCombination: {
        modifier: &#039;secondary&#039;,
        character: &#039;f&#039;
      }
    });
  }, []);
  (0,external_wp_keyboardShortcuts_namespaceObject.useShortcut)(&#039;core/edit-post/toggle-fullscreen&#039;, () =&gt; {
    toggleFullscreenMode();
  });
  return null;
}
/* harmony default export */ const keyboard_shortcuts = (KeyboardShortcuts);

;// ./node_modules/@wordpress/edit-post/build-module/components/init-pattern-modal/index.js
/**
 * WordPress dependencies
 */






function InitPatternModal() {
  const {
    editPost
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_editor_namespaceObject.store);
  const [syncType, setSyncType] = (0,external_wp_element_namespaceObject.useState)(undefined);
  const [title, setTitle] = (0,external_wp_element_namespaceObject.useState)(&#039;&#039;);
  const {
    postType,
    isNewPost
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getEditedPostAttribute,
      isCleanNewPost
    } = select(external_wp_editor_namespaceObject.store);
    return {
      postType: getEditedPostAttribute(&#039;type&#039;),
      isNewPost: isCleanNewPost()
    };
  }, []);
  const [isModalOpen, setIsModalOpen] = (0,external_wp_element_namespaceObject.useState)(() =&gt; isNewPost &amp;&amp; postType === &#039;wp_block&#039;);
  if (postType !== &#039;wp_block&#039; || !isNewPost) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: isModalOpen &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Modal, {
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Create pattern&#039;),
      onRequestClose: () =&gt; {
        setIsModalOpen(false);
      },
      overlayClassName: &quot;reusable-blocks-menu-items__convert-modal&quot;,
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;form&quot;, {
        onSubmit: event =&gt; {
          event.preventDefault();
          setIsModalOpen(false);
          editPost({
            title,
            meta: {
              wp_pattern_sync_status: syncType
            }
          });
        },
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_components_namespaceObject.__experimentalVStack, {
          spacing: &quot;5&quot;,
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.TextControl, {
            label: (0,external_wp_i18n_namespaceObject.__)(&#039;Name&#039;),
            value: title,
            onChange: setTitle,
            placeholder: (0,external_wp_i18n_namespaceObject.__)(&#039;My pattern&#039;),
            className: &quot;patterns-create-modal__name-input&quot;,
            __nextHasNoMarginBottom: true,
            __next40pxDefaultSize: true
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ToggleControl, {
            __nextHasNoMarginBottom: true,
            label: (0,external_wp_i18n_namespaceObject._x)(&#039;Synced&#039;, &#039;pattern (singular)&#039;),
            help: (0,external_wp_i18n_namespaceObject.__)(&#039;Sync this pattern across multiple locations.&#039;),
            checked: !syncType,
            onChange: () =&gt; {
              setSyncType(!syncType ? &#039;unsynced&#039; : undefined);
            }
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.__experimentalHStack, {
            justify: &quot;right&quot;,
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
              __next40pxDefaultSize: true,
              variant: &quot;primary&quot;,
              type: &quot;submit&quot;,
              disabled: !title,
              accessibleWhenDisabled: true,
              children: (0,external_wp_i18n_namespaceObject.__)(&#039;Create&#039;)
            })
          })]
        })
      })
    })
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/browser-url/index.js
/**
 * WordPress dependencies
 */





/**
 * Returns the Post&#039;s Edit URL.
 *
 * @param {number} postId Post ID.
 *
 * @return {string} Post edit URL.
 */
function getPostEditURL(postId) {
  return (0,external_wp_url_namespaceObject.addQueryArgs)(&#039;post.php&#039;, {
    post: postId,
    action: &#039;edit&#039;
  });
}
class BrowserURL extends external_wp_element_namespaceObject.Component {
  constructor() {
    super(...arguments);
    this.state = {
      historyId: null
    };
  }
  componentDidUpdate(prevProps) {
    const {
      postId,
      postStatus
    } = this.props;
    const {
      historyId
    } = this.state;
    if ((postId !== prevProps.postId || postId !== historyId) &amp;&amp; postStatus !== &#039;auto-draft&#039; &amp;&amp; postId) {
      this.setBrowserURL(postId);
    }
  }

  /**
   * Replaces the browser URL with a post editor link for the given post ID.
   *
   * Note it is important that, since this function may be called when the
   * editor first loads, the result generated `getPostEditURL` matches that
   * produced by the server. Otherwise, the URL will change unexpectedly.
   *
   * @param {number} postId Post ID for which to generate post editor URL.
   */
  setBrowserURL(postId) {
    window.history.replaceState({
      id: postId
    }, &#039;Post &#039; + postId, getPostEditURL(postId));
    this.setState(() =&gt; ({
      historyId: postId
    }));
  }
  render() {
    return null;
  }
}
/* harmony default export */ const browser_url = ((0,external_wp_data_namespaceObject.withSelect)(select =&gt; {
  const {
    getCurrentPost
  } = select(external_wp_editor_namespaceObject.store);
  const post = getCurrentPost();
  let {
    id,
    status,
    type
  } = post;
  const isTemplate = [&#039;wp_template&#039;, &#039;wp_template_part&#039;].includes(type);
  if (isTemplate) {
    id = post.wp_id;
  }
  return {
    postId: id,
    postStatus: status
  };
})(BrowserURL));

;// ./node_modules/@wordpress/edit-post/build-module/components/meta-boxes/meta-boxes-area/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * Render metabox area.
 *
 * @param {Object} props          Component props.
 * @param {string} props.location metabox location.
 * @return {Component} The component to be rendered.
 */

function MetaBoxesArea({
  location
}) {
  const container = (0,external_wp_element_namespaceObject.useRef)(null);
  const formRef = (0,external_wp_element_namespaceObject.useRef)(null);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    formRef.current = document.querySelector(&#039;.metabox-location-&#039; + location);
    if (formRef.current) {
      container.current.appendChild(formRef.current);
    }
    return () =&gt; {
      if (formRef.current) {
        document.querySelector(&#039;#metaboxes&#039;).appendChild(formRef.current);
      }
    };
  }, [location]);
  const isSaving = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return select(store).isSavingMetaBoxes();
  }, []);
  const classes = dist_clsx(&#039;edit-post-meta-boxes-area&#039;, `is-${location}`, {
    &#039;is-loading&#039;: isSaving
  });
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    className: classes,
    children: [isSaving &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Spinner, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;edit-post-meta-boxes-area__container&quot;,
      ref: container
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
      className: &quot;edit-post-meta-boxes-area__clear&quot;
    })]
  });
}
/* harmony default export */ const meta_boxes_area = (MetaBoxesArea);

;// ./node_modules/@wordpress/edit-post/build-module/components/meta-boxes/meta-box-visibility.js
/**
 * WordPress dependencies
 */



function MetaBoxVisibility({
  id
}) {
  const isVisible = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return select(external_wp_editor_namespaceObject.store).isEditorPanelEnabled(`meta-box-${id}`);
  }, [id]);
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    const element = document.getElementById(id);
    if (!element) {
      return;
    }
    if (isVisible) {
      element.classList.remove(&#039;is-hidden&#039;);
    } else {
      element.classList.add(&#039;is-hidden&#039;);
    }
  }, [id, isVisible]);
  return null;
}

;// ./node_modules/@wordpress/edit-post/build-module/components/meta-boxes/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




function MetaBoxes({
  location
}) {
  const metaBoxes = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(store).getMetaBoxesPerLocation(location), [location]);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [(metaBoxes !== null &amp;&amp; metaBoxes !== void 0 ? metaBoxes : []).map(({
      id
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MetaBoxVisibility, {
      id: id
    }, id)), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(meta_boxes_area, {
      location: location
    })]
  });
}

;// external [&quot;wp&quot;,&quot;keycodes&quot;]
const external_wp_keycodes_namespaceObject = window[&quot;wp&quot;][&quot;keycodes&quot;];
;// ./node_modules/@wordpress/edit-post/build-module/components/more-menu/manage-patterns-menu-item.js
/**
 * WordPress dependencies
 */






function ManagePatternsMenuItem() {
  const url = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      canUser
    } = select(external_wp_coreData_namespaceObject.store);
    const defaultUrl = (0,external_wp_url_namespaceObject.addQueryArgs)(&#039;edit.php&#039;, {
      post_type: &#039;wp_block&#039;
    });
    const patternsUrl = (0,external_wp_url_namespaceObject.addQueryArgs)(&#039;site-editor.php&#039;, {
      path: &#039;/patterns&#039;
    });

    // The site editor and templates both check whether the user has
    // edit_theme_options capabilities. We can leverage that here and not
    // display the manage patterns link if the user can&#039;t access it.
    return canUser(&#039;create&#039;, {
      kind: &#039;postType&#039;,
      name: &#039;wp_template&#039;
    }) ? patternsUrl : defaultUrl;
  }, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.MenuItem, {
    role: &quot;menuitem&quot;,
    href: url,
    children: (0,external_wp_i18n_namespaceObject.__)(&#039;Manage patterns&#039;)
  });
}
/* harmony default export */ const manage_patterns_menu_item = (ManagePatternsMenuItem);

;// ./node_modules/@wordpress/edit-post/build-module/components/more-menu/welcome-guide-menu-item.js
/**
 * WordPress dependencies
 */





function WelcomeGuideMenuItem() {
  const isEditingTemplate = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; select(external_wp_editor_namespaceObject.store).getCurrentPostType() === &#039;wp_template&#039;, []);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
    scope: &quot;core/edit-post&quot;,
    name: isEditingTemplate ? &#039;welcomeGuideTemplate&#039; : &#039;welcomeGuide&#039;,
    label: (0,external_wp_i18n_namespaceObject.__)(&#039;Welcome Guide&#039;)
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/preferences-modal/enable-custom-fields.js
/**
 * WordPress dependencies
 */








/**
 * Internal dependencies
 */


const {
  PreferenceBaseOption
} = unlock(external_wp_preferences_namespaceObject.privateApis);
function submitCustomFieldsForm() {
  const customFieldsForm = document.getElementById(&#039;toggle-custom-fields-form&#039;);

  // Ensure the referrer values is up to update with any
  customFieldsForm.querySelector(&#039;[name=&quot;_wp_http_referer&quot;]&#039;).setAttribute(&#039;value&#039;, (0,external_wp_url_namespaceObject.getPathAndQueryString)(window.location.href));
  customFieldsForm.submit();
}
function CustomFieldsConfirmation({
  willEnable
}) {
  const [isReloading, setIsReloading] = (0,external_wp_element_namespaceObject.useState)(false);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
      className: &quot;edit-post-preferences-modal__custom-fields-confirmation-message&quot;,
      children: (0,external_wp_i18n_namespaceObject.__)(&#039;A page reload is required for this change. Make sure your content is saved before reloading.&#039;)
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
      __next40pxDefaultSize: true,
      variant: &quot;secondary&quot;,
      isBusy: isReloading,
      accessibleWhenDisabled: true,
      disabled: isReloading,
      onClick: () =&gt; {
        setIsReloading(true);
        submitCustomFieldsForm();
      },
      children: willEnable ? (0,external_wp_i18n_namespaceObject.__)(&#039;Show &amp; Reload Page&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Hide &amp; Reload Page&#039;)
    })]
  });
}
function EnableCustomFieldsOption({
  label
}) {
  const areCustomFieldsEnabled = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return !!select(external_wp_editor_namespaceObject.store).getEditorSettings().enableCustomFields;
  }, []);
  const [isChecked, setIsChecked] = (0,external_wp_element_namespaceObject.useState)(areCustomFieldsEnabled);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreferenceBaseOption, {
    label: label,
    isChecked: isChecked,
    onChange: setIsChecked,
    children: isChecked !== areCustomFieldsEnabled &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomFieldsConfirmation, {
      willEnable: isChecked
    })
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/preferences-modal/enable-panel.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const {
  PreferenceBaseOption: enable_panel_PreferenceBaseOption
} = unlock(external_wp_preferences_namespaceObject.privateApis);
function EnablePanelOption(props) {
  const {
    toggleEditorPanelEnabled
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_editor_namespaceObject.store);
  const {
    isChecked,
    isRemoved
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isEditorPanelEnabled,
      isEditorPanelRemoved
    } = select(external_wp_editor_namespaceObject.store);
    return {
      isChecked: isEditorPanelEnabled(props.panelName),
      isRemoved: isEditorPanelRemoved(props.panelName)
    };
  }, [props.panelName]);
  if (isRemoved) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(enable_panel_PreferenceBaseOption, {
    isChecked: isChecked,
    onChange: () =&gt; toggleEditorPanelEnabled(props.panelName),
    ...props
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/preferences-modal/meta-boxes-section.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */





const {
  PreferencesModalSection
} = unlock(external_wp_preferences_namespaceObject.privateApis);
function MetaBoxesSection({
  areCustomFieldsRegistered,
  metaBoxes,
  ...sectionProps
}) {
  // The &#039;Custom Fields&#039; meta box is a special case that we handle separately.
  const thirdPartyMetaBoxes = metaBoxes.filter(({
    id
  }) =&gt; id !== &#039;postcustom&#039;);
  if (!areCustomFieldsRegistered &amp;&amp; thirdPartyMetaBoxes.length === 0) {
    return null;
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(PreferencesModalSection, {
    ...sectionProps,
    children: [areCustomFieldsRegistered &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EnableCustomFieldsOption, {
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Custom fields&#039;)
    }), thirdPartyMetaBoxes.map(({
      id,
      title
    }) =&gt; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EnablePanelOption, {
      label: title,
      panelName: `meta-box-${id}`
    }, id))]
  });
}
/* harmony default export */ const meta_boxes_section = ((0,external_wp_data_namespaceObject.withSelect)(select =&gt; {
  const {
    getEditorSettings
  } = select(external_wp_editor_namespaceObject.store);
  const {
    getAllMetaBoxes
  } = select(store);
  return {
    // This setting should not live in the block editor&#039;s store.
    areCustomFieldsRegistered: getEditorSettings().enableCustomFields !== undefined,
    metaBoxes: getAllMetaBoxes()
  };
})(MetaBoxesSection));

;// ./node_modules/@wordpress/edit-post/build-module/components/preferences-modal/index.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



const {
  PreferenceToggleControl
} = unlock(external_wp_preferences_namespaceObject.privateApis);
const {
  PreferencesModal
} = unlock(external_wp_editor_namespaceObject.privateApis);
function EditPostPreferencesModal() {
  const extraSections = {
    general: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(meta_boxes_section, {
      title: (0,external_wp_i18n_namespaceObject.__)(&#039;Advanced&#039;)
    }),
    appearance: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreferenceToggleControl, {
      scope: &quot;core/edit-post&quot;,
      featureName: &quot;themeStyles&quot;,
      help: (0,external_wp_i18n_namespaceObject.__)(&#039;Make the editor look like your theme.&#039;),
      label: (0,external_wp_i18n_namespaceObject.__)(&#039;Use theme styles&#039;)
    })
  };
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(PreferencesModal, {
    extraSections: extraSections
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/more-menu/index.js
/**
 * WordPress dependencies
 */






/**
 * Internal dependencies
 */





const {
  ToolsMoreMenuGroup,
  ViewMoreMenuGroup
} = unlock(external_wp_editor_namespaceObject.privateApis);
const MoreMenu = () =&gt; {
  const isLargeViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;large&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
    children: [isLargeViewport &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(ViewMoreMenuGroup, {
      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_preferences_namespaceObject.PreferenceToggleMenuItem, {
        scope: &quot;core/edit-post&quot;,
        name: &quot;fullscreenMode&quot;,
        label: (0,external_wp_i18n_namespaceObject.__)(&#039;Fullscreen mode&#039;),
        info: (0,external_wp_i18n_namespaceObject.__)(&#039;Show and hide the admin user interface&#039;),
        messageActivated: (0,external_wp_i18n_namespaceObject.__)(&#039;Fullscreen mode activated.&#039;),
        messageDeactivated: (0,external_wp_i18n_namespaceObject.__)(&#039;Fullscreen mode deactivated.&#039;),
        shortcut: external_wp_keycodes_namespaceObject.displayShortcut.secondary(&#039;f&#039;)
      })
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(ToolsMoreMenuGroup, {
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(manage_patterns_menu_item, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideMenuItem, {})]
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditPostPreferencesModal, {})]
  });
};
/* harmony default export */ const more_menu = (MoreMenu);

;// ./node_modules/@wordpress/edit-post/build-module/components/welcome-guide/image.js

function WelcomeGuideImage({
  nonAnimatedSrc,
  animatedSrc
}) {
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;picture&quot;, {
    className: &quot;edit-post-welcome-guide__image&quot;,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;source&quot;, {
      srcSet: nonAnimatedSrc,
      media: &quot;(prefers-reduced-motion: reduce)&quot;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;img&quot;, {
      src: animatedSrc,
      width: &quot;312&quot;,
      height: &quot;240&quot;,
      alt: &quot;&quot;
    })]
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/welcome-guide/default.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */



function WelcomeGuideDefault() {
  const {
    toggleFeature
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Guide, {
    className: &quot;edit-post-welcome-guide&quot;,
    contentLabel: (0,external_wp_i18n_namespaceObject.__)(&#039;Welcome to the editor&#039;),
    finishButtonText: (0,external_wp_i18n_namespaceObject.__)(&#039;Get started&#039;),
    onFinish: () =&gt; toggleFeature(&#039;welcomeGuide&#039;),
    pages: [{
      image: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideImage, {
        nonAnimatedSrc: &quot;https://s.w.org/images/block-editor/welcome-canvas.svg&quot;,
        animatedSrc: &quot;https://s.w.org/images/block-editor/welcome-canvas.gif&quot;
      }),
      content: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h1&quot;, {
          className: &quot;edit-post-welcome-guide__heading&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Welcome to the editor&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          className: &quot;edit-post-welcome-guide__text&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;In the WordPress editor, each paragraph, image, or video is presented as a distinct “block” of content.&#039;)
        })]
      })
    }, {
      image: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideImage, {
        nonAnimatedSrc: &quot;https://s.w.org/images/block-editor/welcome-editor.svg&quot;,
        animatedSrc: &quot;https://s.w.org/images/block-editor/welcome-editor.gif&quot;
      }),
      content: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h1&quot;, {
          className: &quot;edit-post-welcome-guide__heading&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Customize each block&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          className: &quot;edit-post-welcome-guide__text&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Each block comes with its own set of controls for changing things like color, width, and alignment. These will show and hide automatically when you have a block selected.&#039;)
        })]
      })
    }, {
      image: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideImage, {
        nonAnimatedSrc: &quot;https://s.w.org/images/block-editor/welcome-library.svg&quot;,
        animatedSrc: &quot;https://s.w.org/images/block-editor/welcome-library.gif&quot;
      }),
      content: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h1&quot;, {
          className: &quot;edit-post-welcome-guide__heading&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Explore all blocks&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          className: &quot;edit-post-welcome-guide__text&quot;,
          children: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)(&#039;All of the blocks available to you live in the block library. You’ll find it wherever you see the &lt;InserterIconImage /&gt; icon.&#039;), {
            InserterIconImage: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;img&quot;, {
              alt: (0,external_wp_i18n_namespaceObject.__)(&#039;inserter&#039;),
              src: &quot;data:image/svg+xml,%3Csvg width=&#039;18&#039; height=&#039;18&#039; viewBox=&#039;0 0 18 18&#039; fill=&#039;none&#039; xmlns=&#039;http://www.w3.org/2000/svg&#039;%3E%3Crect width=&#039;18&#039; height=&#039;18&#039; rx=&#039;2&#039; fill=&#039;%231E1E1E&#039;/%3E%3Cpath d=&#039;M9.22727 4V14M4 8.77273H14&#039; stroke=&#039;white&#039; stroke-width=&#039;1.5&#039;/%3E%3C/svg%3E%0A&quot;
            })
          })
        })]
      })
    }, {
      image: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideImage, {
        nonAnimatedSrc: &quot;https://s.w.org/images/block-editor/welcome-documentation.svg&quot;,
        animatedSrc: &quot;https://s.w.org/images/block-editor/welcome-documentation.gif&quot;
      }),
      content: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h1&quot;, {
          className: &quot;edit-post-welcome-guide__heading&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Learn more&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          className: &quot;edit-post-welcome-guide__text&quot;,
          children: (0,external_wp_element_namespaceObject.createInterpolateElement)((0,external_wp_i18n_namespaceObject.__)(&quot;New to the block editor? Want to learn more about using it? &lt;a&gt;Here&#039;s a detailed guide.&lt;/a&gt;&quot;), {
            a: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.ExternalLink, {
              href: (0,external_wp_i18n_namespaceObject.__)(&#039;https://wordpress.org/documentation/article/wordpress-block-editor/&#039;)
            })
          })
        })]
      })
    }]
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/welcome-guide/template.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */



function WelcomeGuideTemplate() {
  const {
    toggleFeature
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Guide, {
    className: &quot;edit-template-welcome-guide&quot;,
    contentLabel: (0,external_wp_i18n_namespaceObject.__)(&#039;Welcome to the template editor&#039;),
    finishButtonText: (0,external_wp_i18n_namespaceObject.__)(&#039;Get started&#039;),
    onFinish: () =&gt; toggleFeature(&#039;welcomeGuideTemplate&#039;),
    pages: [{
      image: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideImage, {
        nonAnimatedSrc: &quot;https://s.w.org/images/block-editor/welcome-template-editor.svg&quot;,
        animatedSrc: &quot;https://s.w.org/images/block-editor/welcome-template-editor.gif&quot;
      }),
      content: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
        children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;h1&quot;, {
          className: &quot;edit-post-welcome-guide__heading&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Welcome to the template editor&#039;)
        }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;p&quot;, {
          className: &quot;edit-post-welcome-guide__text&quot;,
          children: (0,external_wp_i18n_namespaceObject.__)(&#039;Templates help define the layout of the site. You can customize all aspects of your posts and pages using blocks and patterns in this editor.&#039;)
        })]
      })
    }]
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/welcome-guide/index.js
/**
 * WordPress dependencies
 */


/**
 * Internal dependencies
 */




function WelcomeGuide({
  postType
}) {
  const {
    isActive,
    isEditingTemplate
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      isFeatureActive
    } = select(store);
    const _isEditingTemplate = postType === &#039;wp_template&#039;;
    const feature = _isEditingTemplate ? &#039;welcomeGuideTemplate&#039; : &#039;welcomeGuide&#039;;
    return {
      isActive: isFeatureActive(feature),
      isEditingTemplate: _isEditingTemplate
    };
  }, [postType]);
  if (!isActive) {
    return null;
  }
  return isEditingTemplate ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideTemplate, {}) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuideDefault, {});
}

;// ./node_modules/@wordpress/icons/build-module/library/fullscreen.js
/**
 * WordPress dependencies
 */


const fullscreen = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
  xmlns: &quot;http://www.w3.org/2000/svg&quot;,
  viewBox: &quot;0 0 24 24&quot;,
  children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
    d: &quot;M6 4a2 2 0 0 0-2 2v3h1.5V6a.5.5 0 0 1 .5-.5h3V4H6Zm3 14.5H6a.5.5 0 0 1-.5-.5v-3H4v3a2 2 0 0 0 2 2h3v-1.5Zm6 1.5v-1.5h3a.5.5 0 0 0 .5-.5v-3H20v3a2 2 0 0 1-2 2h-3Zm3-16a2 2 0 0 1 2 2v3h-1.5V6a.5.5 0 0 0-.5-.5h-3V4h3Z&quot;
  })
});
/* harmony default export */ const library_fullscreen = (fullscreen);

;// ./node_modules/@wordpress/edit-post/build-module/commands/use-commands.js
/**
 * WordPress dependencies
 */






function useCommands() {
  const {
    isFullscreen
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      get
    } = select(external_wp_preferences_namespaceObject.store);
    return {
      isFullscreen: get(&#039;core/edit-post&#039;, &#039;fullscreenMode&#039;)
    };
  }, []);
  const {
    toggle
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store);
  const {
    createInfoNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  (0,external_wp_commands_namespaceObject.useCommand)({
    name: &#039;core/toggle-fullscreen-mode&#039;,
    label: isFullscreen ? (0,external_wp_i18n_namespaceObject.__)(&#039;Exit fullscreen&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Enter fullscreen&#039;),
    icon: library_fullscreen,
    callback: ({
      close
    }) =&gt; {
      toggle(&#039;core/edit-post&#039;, &#039;fullscreenMode&#039;);
      close();
      createInfoNotice(isFullscreen ? (0,external_wp_i18n_namespaceObject.__)(&#039;Fullscreen off.&#039;) : (0,external_wp_i18n_namespaceObject.__)(&#039;Fullscreen on.&#039;), {
        id: &#039;core/edit-post/toggle-fullscreen-mode/notice&#039;,
        type: &#039;snackbar&#039;,
        actions: [{
          label: (0,external_wp_i18n_namespaceObject.__)(&#039;Undo&#039;),
          onClick: () =&gt; {
            toggle(&#039;core/edit-post&#039;, &#039;fullscreenMode&#039;);
          }
        }]
      });
    }
  });
}

;// ./node_modules/@wordpress/edit-post/build-module/components/layout/use-padding-appender.js
/**
 * WordPress dependencies
 */





// Ruleset to add space for the typewriter effect. When typing in the last
// block, there needs to be room to scroll up.
const CSS = &#039;:root :where(.editor-styles-wrapper)::after {content: &quot;&quot;; display: block; height: 40vh;}&#039;;
function usePaddingAppender(enabled) {
  const registry = (0,external_wp_data_namespaceObject.useRegistry)();
  const effect = (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    function onMouseDown(event) {
      if (event.target !== node &amp;&amp;
      // Tests for the parent element because in the iframed editor if the click is
      // below the padding the target will be the parent element (html) and should
      // still be treated as intent to append.
      event.target !== node.parentElement) {
        return;
      }

      // Only handle clicks under the last child.
      const lastChild = node.lastElementChild;
      if (!lastChild) {
        return;
      }
      const lastChildRect = lastChild.getBoundingClientRect();
      if (event.clientY &lt; lastChildRect.bottom) {
        return;
      }
      event.preventDefault();
      const blockOrder = registry.select(external_wp_blockEditor_namespaceObject.store).getBlockOrder(&#039;&#039;);
      const lastBlockClientId = blockOrder[blockOrder.length - 1];
      const lastBlock = registry.select(external_wp_blockEditor_namespaceObject.store).getBlock(lastBlockClientId);
      const {
        selectBlock,
        insertDefaultBlock
      } = registry.dispatch(external_wp_blockEditor_namespaceObject.store);
      if (lastBlock &amp;&amp; (0,external_wp_blocks_namespaceObject.isUnmodifiedDefaultBlock)(lastBlock)) {
        selectBlock(lastBlockClientId);
      } else {
        insertDefaultBlock();
      }
    }
    const {
      ownerDocument
    } = node;
    // Adds the listener on the document so that in the iframed editor clicks below the
    // padding can be handled as they too should be treated as intent to append.
    ownerDocument.addEventListener(&#039;mousedown&#039;, onMouseDown);
    return () =&gt; {
      ownerDocument.removeEventListener(&#039;mousedown&#039;, onMouseDown);
    };
  }, [registry]);
  return enabled ? [effect, CSS] : [];
}

;// ./node_modules/@wordpress/edit-post/build-module/components/layout/use-should-iframe.js
/**
 * WordPress dependencies
 */





/**
 * Internal dependencies
 */

const isGutenbergPlugin =  false ? 0 : false;
function useShouldIframe() {
  return (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      getEditorSettings,
      getCurrentPostType,
      getDeviceType
    } = select(external_wp_editor_namespaceObject.store);
    return (
      // If the theme is block based and the Gutenberg plugin is active,
      // we ALWAYS use the iframe for consistency across the post and site
      // editor.
      isGutenbergPlugin &amp;&amp; getEditorSettings().__unstableIsBlockBasedTheme ||
      // We also still want to iframe all the special
      // editor features and modes such as device previews, zoom out, and
      // template/pattern editing.
      getDeviceType() !== &#039;Desktop&#039; || [&#039;wp_template&#039;, &#039;wp_block&#039;].includes(getCurrentPostType()) || unlock(select(external_wp_blockEditor_namespaceObject.store)).isZoomOut() ||
      // Finally, still iframe the editor if all blocks are v3 (which means
      // they are marked as iframe-compatible).
      select(external_wp_blocks_namespaceObject.store).getBlockTypes().every(type =&gt; type.apiVersion &gt;= 3)
    );
  }, []);
}

;// ./node_modules/@wordpress/edit-post/build-module/hooks/use-navigate-to-entity-record.js
/**
 * WordPress dependencies
 */




/**
 * A hook that records the &#039;entity&#039; history in the post editor as a user
 * navigates between editing a post and editing the post template or patterns.
 *
 * Implemented as a stack, so a little similar to the browser history API.
 *
 * Used to control displaying UI elements like the back button.
 *
 * @param {number} initialPostId        The post id of the post when the editor loaded.
 * @param {string} initialPostType      The post type of the post when the editor loaded.
 * @param {string} defaultRenderingMode The rendering mode to switch to when navigating.
 *
 * @return {Object} An object containing the `currentPost` variable and
 *                 `onNavigateToEntityRecord` and `onNavigateToPreviousEntityRecord` functions.
 */
function useNavigateToEntityRecord(initialPostId, initialPostType, defaultRenderingMode) {
  const [postHistory, dispatch] = (0,external_wp_element_namespaceObject.useReducer)((historyState, {
    type,
    post,
    previousRenderingMode
  }) =&gt; {
    if (type === &#039;push&#039;) {
      return [...historyState, {
        post,
        previousRenderingMode
      }];
    }
    if (type === &#039;pop&#039;) {
      // Try to leave one item in the history.
      if (historyState.length &gt; 1) {
        return historyState.slice(0, -1);
      }
    }
    return historyState;
  }, [{
    post: {
      postId: initialPostId,
      postType: initialPostType
    }
  }]);
  const {
    post,
    previousRenderingMode
  } = postHistory[postHistory.length - 1];
  const {
    getRenderingMode
  } = (0,external_wp_data_namespaceObject.useSelect)(external_wp_editor_namespaceObject.store);
  const {
    setRenderingMode
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_editor_namespaceObject.store);
  const onNavigateToEntityRecord = (0,external_wp_element_namespaceObject.useCallback)(params =&gt; {
    dispatch({
      type: &#039;push&#039;,
      post: {
        postId: params.postId,
        postType: params.postType
      },
      // Save the current rendering mode so we can restore it when navigating back.
      previousRenderingMode: getRenderingMode()
    });
    setRenderingMode(defaultRenderingMode);
  }, [getRenderingMode, setRenderingMode, defaultRenderingMode]);
  const onNavigateToPreviousEntityRecord = (0,external_wp_element_namespaceObject.useCallback)(() =&gt; {
    dispatch({
      type: &#039;pop&#039;
    });
    if (previousRenderingMode) {
      setRenderingMode(previousRenderingMode);
    }
  }, [setRenderingMode, previousRenderingMode]);
  return {
    currentPost: post,
    onNavigateToEntityRecord,
    onNavigateToPreviousEntityRecord: postHistory.length &gt; 1 ? onNavigateToPreviousEntityRecord : undefined
  };
}

;// ./node_modules/@wordpress/edit-post/build-module/components/meta-boxes/use-meta-box-initialization.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


/**
 * Initializes WordPress `postboxes` script and the logic for saving meta boxes.
 *
 * @param { boolean } enabled
 */
const useMetaBoxInitialization = enabled =&gt; {
  const isEnabledAndEditorReady = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; enabled &amp;&amp; select(external_wp_editor_namespaceObject.store).__unstableIsEditorReady(), [enabled]);
  const {
    initializeMetaBoxes
  } = (0,external_wp_data_namespaceObject.useDispatch)(store);
  // The effect has to rerun when the editor is ready because initializeMetaBoxes
  // will noop until then.
  (0,external_wp_element_namespaceObject.useEffect)(() =&gt; {
    if (isEnabledAndEditorReady) {
      initializeMetaBoxes();
    }
  }, [isEnabledAndEditorReady, initializeMetaBoxes]);
};

;// ./node_modules/@wordpress/edit-post/build-module/components/layout/index.js
/**
 * External dependencies
 */


/**
 * WordPress dependencies
 */


















/**
 * Internal dependencies
 */
















const {
  getLayoutStyles
} = unlock(external_wp_blockEditor_namespaceObject.privateApis);
const {
  useCommands: layout_useCommands
} = unlock(external_wp_coreCommands_namespaceObject.privateApis);
const {
  useCommandContext
} = unlock(external_wp_commands_namespaceObject.privateApis);
const {
  Editor,
  FullscreenMode,
  NavigableRegion
} = unlock(external_wp_editor_namespaceObject.privateApis);
const {
  BlockKeyboardShortcuts
} = unlock(external_wp_blockLibrary_namespaceObject.privateApis);
const DESIGN_POST_TYPES = [&#039;wp_template&#039;, &#039;wp_template_part&#039;, &#039;wp_block&#039;, &#039;wp_navigation&#039;];
function useEditorStyles(...additionalStyles) {
  const {
    hasThemeStyleSupport,
    editorSettings
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    return {
      hasThemeStyleSupport: select(store).isFeatureActive(&#039;themeStyles&#039;),
      editorSettings: select(external_wp_editor_namespaceObject.store).getEditorSettings()
    };
  }, []);
  const addedStyles = additionalStyles.join(&#039;\n&#039;);

  // Compute the default styles.
  return (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    var _editorSettings$style, _editorSettings$defau, _editorSettings$style2, _editorSettings$style3;
    const presetStyles = (_editorSettings$style = editorSettings.styles?.filter(style =&gt; style.__unstableType &amp;&amp; style.__unstableType !== &#039;theme&#039;)) !== null &amp;&amp; _editorSettings$style !== void 0 ? _editorSettings$style : [];
    const defaultEditorStyles = [...((_editorSettings$defau = editorSettings?.defaultEditorStyles) !== null &amp;&amp; _editorSettings$defau !== void 0 ? _editorSettings$defau : []), ...presetStyles];

    // Has theme styles if the theme supports them and if some styles were not preset styles (in which case they&#039;re theme styles).
    const hasThemeStyles = hasThemeStyleSupport &amp;&amp; presetStyles.length !== ((_editorSettings$style2 = editorSettings.styles?.length) !== null &amp;&amp; _editorSettings$style2 !== void 0 ? _editorSettings$style2 : 0);

    // If theme styles are not present or displayed, ensure that
    // base layout styles are still present in the editor.
    if (!editorSettings.disableLayoutStyles &amp;&amp; !hasThemeStyles) {
      defaultEditorStyles.push({
        css: getLayoutStyles({
          style: {},
          selector: &#039;body&#039;,
          hasBlockGapSupport: false,
          hasFallbackGapSupport: true,
          fallbackGapValue: &#039;0.5em&#039;
        })
      });
    }
    const baseStyles = hasThemeStyles ? (_editorSettings$style3 = editorSettings.styles) !== null &amp;&amp; _editorSettings$style3 !== void 0 ? _editorSettings$style3 : [] : defaultEditorStyles;
    if (addedStyles) {
      return [...baseStyles, {
        css: addedStyles
      }];
    }
    return baseStyles;
  }, [editorSettings.defaultEditorStyles, editorSettings.disableLayoutStyles, editorSettings.styles, hasThemeStyleSupport, addedStyles]);
}
function MetaBoxesMain() {
  const [isOpen, openHeight, hasAnyVisible] = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    const {
      get
    } = select(external_wp_preferences_namespaceObject.store);
    const {
      isMetaBoxLocationVisible
    } = select(store);
    return [get(&#039;core/edit-post&#039;, &#039;metaBoxesMainIsOpen&#039;), get(&#039;core/edit-post&#039;, &#039;metaBoxesMainOpenHeight&#039;), isMetaBoxLocationVisible(&#039;normal&#039;) || isMetaBoxLocationVisible(&#039;advanced&#039;) || isMetaBoxLocationVisible(&#039;side&#039;)];
  }, []);
  const {
    set: setPreference
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_preferences_namespaceObject.store);
  const metaBoxesMainRef = (0,external_wp_element_namespaceObject.useRef)();
  const isShort = (0,external_wp_compose_namespaceObject.useMediaQuery)(&#039;(max-height: 549px)&#039;);
  const [{
    min,
    max
  }, setHeightConstraints] = (0,external_wp_element_namespaceObject.useState)(() =&gt; ({}));
  // Keeps the resizable area’s size constraints updated taking into account
  // editor notices. The constraints are also used to derive the value for the
  // aria-valuenow attribute on the separator.
  const effectSizeConstraints = (0,external_wp_compose_namespaceObject.useRefEffect)(node =&gt; {
    const container = node.closest(&#039;.interface-interface-skeleton__content&#039;);
    const noticeLists = container.querySelectorAll(&#039;:scope &gt; .components-notice-list&#039;);
    const resizeHandle = container.querySelector(&#039;.edit-post-meta-boxes-main__presenter&#039;);
    const deriveConstraints = () =&gt; {
      const fullHeight = container.offsetHeight;
      let nextMax = fullHeight;
      for (const element of noticeLists) {
        nextMax -= element.offsetHeight;
      }
      const nextMin = resizeHandle.offsetHeight;
      setHeightConstraints({
        min: nextMin,
        max: nextMax
      });
    };
    const observer = new window.ResizeObserver(deriveConstraints);
    observer.observe(container);
    for (const element of noticeLists) {
      observer.observe(element);
    }
    return () =&gt; observer.disconnect();
  }, []);
  const separatorRef = (0,external_wp_element_namespaceObject.useRef)();
  const separatorHelpId = (0,external_wp_element_namespaceObject.useId)();
  const [isUntouched, setIsUntouched] = (0,external_wp_element_namespaceObject.useState)(true);
  const applyHeight = (candidateHeight, isPersistent, isInstant) =&gt; {
    const nextHeight = Math.min(max, Math.max(min, candidateHeight));
    if (isPersistent) {
      setPreference(&#039;core/edit-post&#039;, &#039;metaBoxesMainOpenHeight&#039;, nextHeight);
    } else {
      separatorRef.current.ariaValueNow = getAriaValueNow(nextHeight);
    }
    if (isInstant) {
      metaBoxesMainRef.current.updateSize({
        height: nextHeight,
        // Oddly, when the event that triggered this was not from the mouse (e.g. keydown),
        // if `width` is left unspecified a subsequent drag gesture applies a fixed
        // width and the pane fails to widen/narrow with parent width changes from
        // sidebars opening/closing or window resizes.
        width: &#039;auto&#039;
      });
    }
  };
  if (!hasAnyVisible) {
    return;
  }
  const contents = /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;div&quot;, {
    // The class name &#039;edit-post-layout__metaboxes&#039; is retained because some plugins use it.
    className: &quot;edit-post-layout__metaboxes edit-post-meta-boxes-main__liner&quot;,
    hidden: isShort &amp;&amp; !isOpen,
    children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MetaBoxes, {
      location: &quot;normal&quot;
    }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MetaBoxes, {
      location: &quot;advanced&quot;
    })]
  });
  const isAutoHeight = openHeight === undefined;
  let usedMax = &#039;50%&#039;; // Approximation before max has a value.
  if (max !== undefined) {
    // Halves the available max height until a user height is set.
    usedMax = isAutoHeight &amp;&amp; isUntouched ? max / 2 : max;
  }
  const getAriaValueNow = height =&gt; Math.round((height - min) / (max - min) * 100);
  const usedAriaValueNow = max === undefined || isAutoHeight ? 50 : getAriaValueNow(openHeight);
  const toggle = () =&gt; setPreference(&#039;core/edit-post&#039;, &#039;metaBoxesMainIsOpen&#039;, !isOpen);

  // TODO: Support more/all keyboard interactions from the window splitter pattern:
  // https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/
  const onSeparatorKeyDown = event =&gt; {
    const delta = {
      ArrowUp: 20,
      ArrowDown: -20
    }[event.key];
    if (delta) {
      const pane = metaBoxesMainRef.current.resizable;
      const fromHeight = isAutoHeight ? pane.offsetHeight : openHeight;
      const nextHeight = delta + fromHeight;
      applyHeight(nextHeight, true, true);
      event.preventDefault();
    }
  };
  const className = &#039;edit-post-meta-boxes-main&#039;;
  const paneLabel = (0,external_wp_i18n_namespaceObject.__)(&#039;Meta Boxes&#039;);
  let Pane, paneProps;
  if (isShort) {
    Pane = NavigableRegion;
    paneProps = {
      className: dist_clsx(className, &#039;is-toggle-only&#039;)
    };
  } else {
    Pane = external_wp_components_namespaceObject.ResizableBox;
    paneProps = /** @type {Parameters&lt;typeof ResizableBox&gt;[0]} */{
      as: NavigableRegion,
      ref: metaBoxesMainRef,
      className: dist_clsx(className, &#039;is-resizable&#039;),
      defaultSize: {
        height: openHeight
      },
      minHeight: min,
      maxHeight: usedMax,
      enable: {
        top: true,
        right: false,
        bottom: false,
        left: false,
        topLeft: false,
        topRight: false,
        bottomRight: false,
        bottomLeft: false
      },
      handleClasses: {
        top: &#039;edit-post-meta-boxes-main__presenter&#039;
      },
      handleComponent: {
        top: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Tooltip, {
            text: (0,external_wp_i18n_namespaceObject.__)(&#039;Drag to resize&#039;),
            children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;button&quot;, {
              // eslint-disable-line jsx-a11y/role-supports-aria-props
              ref: separatorRef,
              role: &quot;separator&quot; // eslint-disable-line jsx-a11y/no-interactive-element-to-noninteractive-role
              ,
              &quot;aria-valuenow&quot;: usedAriaValueNow,
              &quot;aria-label&quot;: (0,external_wp_i18n_namespaceObject.__)(&#039;Drag to resize&#039;),
              &quot;aria-describedby&quot;: separatorHelpId,
              onKeyDown: onSeparatorKeyDown
            })
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.VisuallyHidden, {
            id: separatorHelpId,
            children: (0,external_wp_i18n_namespaceObject.__)(&#039;Use up and down arrow keys to resize the meta box panel.&#039;)
          })]
        })
      },
      // Avoids hiccups while dragging over objects like iframes and ensures that
      // the event to end the drag is captured by the target (resize handle)
      // whether or not it’s under the pointer.
      onPointerDown: ({
        pointerId,
        target
      }) =&gt; {
        if (separatorRef.current.parentElement.contains(target)) {
          target.setPointerCapture(pointerId);
        }
      },
      onResizeStart: (event, direction, elementRef) =&gt; {
        if (isAutoHeight) {
          // Sets the starting height to avoid visual jumps in height and
          // aria-valuenow being `NaN` for the first (few) resize events.
          applyHeight(elementRef.offsetHeight, false, true);
          setIsUntouched(false);
        }
      },
      onResize: () =&gt; applyHeight(metaBoxesMainRef.current.state.height),
      onResizeStop: () =&gt; applyHeight(metaBoxesMainRef.current.state.height, true)
    };
  }
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Pane, {
    &quot;aria-label&quot;: paneLabel,
    ...paneProps,
    children: [isShort ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(&quot;button&quot;, {
      &quot;aria-expanded&quot;: isOpen,
      className: &quot;edit-post-meta-boxes-main__presenter&quot;,
      onClick: toggle,
      children: [paneLabel, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Icon, {
        icon: isOpen ? chevron_up : chevron_down
      })]
    }) : /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;meta&quot;, {
      ref: effectSizeConstraints
    }), contents]
  });
}
function Layout({
  postId: initialPostId,
  postType: initialPostType,
  settings,
  initialEdits
}) {
  layout_useCommands();
  useCommands();
  const shouldIframe = useShouldIframe();
  const {
    createErrorNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const {
    currentPost: {
      postId: currentPostId,
      postType: currentPostType
    },
    onNavigateToEntityRecord,
    onNavigateToPreviousEntityRecord
  } = useNavigateToEntityRecord(initialPostId, initialPostType, &#039;post-only&#039;);
  const isEditingTemplate = currentPostType === &#039;wp_template&#039;;
  const {
    mode,
    isFullscreenActive,
    hasResolvedMode,
    hasActiveMetaboxes,
    hasBlockSelected,
    showIconLabels,
    isDistractionFree,
    showMetaBoxes,
    isWelcomeGuideVisible,
    templateId,
    enablePaddingAppender
  } = (0,external_wp_data_namespaceObject.useSelect)(select =&gt; {
    var _getPostType$viewable;
    const {
      get
    } = select(external_wp_preferences_namespaceObject.store);
    const {
      isFeatureActive,
      hasMetaBoxes
    } = select(store);
    const {
      canUser,
      getPostType,
      getTemplateId
    } = unlock(select(external_wp_coreData_namespaceObject.store));
    const supportsTemplateMode = settings.supportsTemplateMode;
    const isViewable = (_getPostType$viewable = getPostType(currentPostType)?.viewable) !== null &amp;&amp; _getPostType$viewable !== void 0 ? _getPostType$viewable : false;
    const canViewTemplate = canUser(&#039;read&#039;, {
      kind: &#039;postType&#039;,
      name: &#039;wp_template&#039;
    });
    const {
      getBlockSelectionStart,
      isZoomOut
    } = unlock(select(external_wp_blockEditor_namespaceObject.store));
    const {
      getEditorMode,
      getRenderingMode,
      getDefaultRenderingMode
    } = unlock(select(external_wp_editor_namespaceObject.store));
    const isRenderingPostOnly = getRenderingMode() === &#039;post-only&#039;;
    const isNotDesignPostType = !DESIGN_POST_TYPES.includes(currentPostType);
    const isDirectlyEditingPattern = currentPostType === &#039;wp_block&#039; &amp;&amp; !onNavigateToPreviousEntityRecord;
    const _templateId = getTemplateId(currentPostType, currentPostId);
    const defaultMode = getDefaultRenderingMode(currentPostType);
    return {
      mode: getEditorMode(),
      isFullscreenActive: isFeatureActive(&#039;fullscreenMode&#039;),
      hasActiveMetaboxes: hasMetaBoxes(),
      hasResolvedMode: defaultMode === &#039;template-locked&#039; ? !!_templateId : defaultMode !== undefined,
      hasBlockSelected: !!getBlockSelectionStart(),
      showIconLabels: get(&#039;core&#039;, &#039;showIconLabels&#039;),
      isDistractionFree: get(&#039;core&#039;, &#039;distractionFree&#039;),
      showMetaBoxes: isNotDesignPostType &amp;&amp; !isZoomOut() || isDirectlyEditingPattern,
      isWelcomeGuideVisible: isFeatureActive(&#039;welcomeGuide&#039;),
      templateId: supportsTemplateMode &amp;&amp; isViewable &amp;&amp; canViewTemplate &amp;&amp; !isEditingTemplate ? _templateId : null,
      enablePaddingAppender: !isZoomOut() &amp;&amp; isRenderingPostOnly &amp;&amp; isNotDesignPostType
    };
  }, [currentPostType, currentPostId, isEditingTemplate, settings.supportsTemplateMode, onNavigateToPreviousEntityRecord]);
  useMetaBoxInitialization(hasActiveMetaboxes &amp;&amp; hasResolvedMode);
  const [paddingAppenderRef, paddingStyle] = usePaddingAppender(enablePaddingAppender);

  // Set the right context for the command palette
  const commandContext = hasBlockSelected ? &#039;block-selection-edit&#039; : &#039;entity-edit&#039;;
  useCommandContext(commandContext);
  const editorSettings = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; ({
    ...settings,
    onNavigateToEntityRecord,
    onNavigateToPreviousEntityRecord,
    defaultRenderingMode: &#039;post-only&#039;
  }), [settings, onNavigateToEntityRecord, onNavigateToPreviousEntityRecord]);
  const styles = useEditorStyles(paddingStyle);

  // We need to add the show-icon-labels class to the body element so it is applied to modals.
  if (showIconLabels) {
    document.body.classList.add(&#039;show-icon-labels&#039;);
  } else {
    document.body.classList.remove(&#039;show-icon-labels&#039;);
  }
  const navigateRegionsProps = (0,external_wp_components_namespaceObject.__unstableUseNavigateRegions)();
  const className = dist_clsx(&#039;edit-post-layout&#039;, &#039;is-mode-&#039; + mode, {
    &#039;has-metaboxes&#039;: hasActiveMetaboxes
  });
  function onPluginAreaError(name) {
    createErrorNotice((0,external_wp_i18n_namespaceObject.sprintf)(/* translators: %s: plugin name */
    (0,external_wp_i18n_namespaceObject.__)(&#039;The &quot;%s&quot; plugin has encountered an error and cannot be rendered.&#039;), name));
  }
  const {
    createSuccessNotice
  } = (0,external_wp_data_namespaceObject.useDispatch)(external_wp_notices_namespaceObject.store);
  const onActionPerformed = (0,external_wp_element_namespaceObject.useCallback)((actionId, items) =&gt; {
    switch (actionId) {
      case &#039;move-to-trash&#039;:
        {
          document.location.href = (0,external_wp_url_namespaceObject.addQueryArgs)(&#039;edit.php&#039;, {
            trashed: 1,
            post_type: items[0].type,
            ids: items[0].id
          });
        }
        break;
      case &#039;duplicate-post&#039;:
        {
          const newItem = items[0];
          const title = typeof newItem.title === &#039;string&#039; ? newItem.title : newItem.title?.rendered;
          createSuccessNotice((0,external_wp_i18n_namespaceObject.sprintf)(
          // translators: %s: Title of the created post or template, e.g: &quot;Hello world&quot;.
          (0,external_wp_i18n_namespaceObject.__)(&#039;&quot;%s&quot; successfully created.&#039;), (0,external_wp_htmlEntities_namespaceObject.decodeEntities)(title)), {
            type: &#039;snackbar&#039;,
            id: &#039;duplicate-post-action&#039;,
            actions: [{
              label: (0,external_wp_i18n_namespaceObject.__)(&#039;Edit&#039;),
              onClick: () =&gt; {
                const postId = newItem.id;
                document.location.href = (0,external_wp_url_namespaceObject.addQueryArgs)(&#039;post.php&#039;, {
                  post: postId,
                  action: &#039;edit&#039;
                });
              }
            }]
          });
        }
        break;
    }
  }, [createSuccessNotice]);
  const initialPost = (0,external_wp_element_namespaceObject.useMemo)(() =&gt; {
    return {
      type: initialPostType,
      id: initialPostId
    };
  }, [initialPostType, initialPostId]);
  const backButton = (0,external_wp_compose_namespaceObject.useViewportMatch)(&#039;medium&#039;) &amp;&amp; isFullscreenActive ? /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(back_button, {
    initialPost: initialPost
  }) : null;
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.SlotFillProvider, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_editor_namespaceObject.ErrorBoundary, {
      canCopyContent: true,
      children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_commands_namespaceObject.CommandMenu, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(WelcomeGuide, {
        postType: currentPostType
      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(&quot;div&quot;, {
        className: navigateRegionsProps.className,
        ...navigateRegionsProps,
        ref: navigateRegionsProps.ref,
        children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)(Editor, {
          settings: editorSettings,
          initialEdits: initialEdits,
          postType: currentPostType,
          postId: currentPostId,
          templateId: templateId,
          className: className,
          styles: styles,
          forceIsDirty: hasActiveMetaboxes,
          contentRef: paddingAppenderRef,
          disableIframe: !shouldIframe
          // We should auto-focus the canvas (title) on load.
          // eslint-disable-next-line jsx-a11y/no-autofocus
          ,
          autoFocus: !isWelcomeGuideVisible,
          onActionPerformed: onActionPerformed,
          extraSidebarPanels: showMetaBoxes &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MetaBoxes, {
            location: &quot;side&quot;
          }),
          extraContent: !isDistractionFree &amp;&amp; showMetaBoxes &amp;&amp; /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(MetaBoxesMain, {}),
          children: [/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PostLockedModal, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(EditorInitialization, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(FullscreenMode, {
            isActive: isFullscreenActive
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(browser_url, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.UnsavedChangesWarning, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.AutosaveMonitor, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.LocalAutosaveMonitor, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(keyboard_shortcuts, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.EditorKeyboardShortcutsRegister, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(BlockKeyboardShortcuts, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(InitPatternModal, {}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_plugins_namespaceObject.PluginArea, {
            onError: onPluginAreaError
          }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(more_menu, {}), backButton, /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.EditorSnackbars, {})]
        })
      })]
    })
  });
}
/* harmony default export */ const layout = (Layout);

;// ./node_modules/@wordpress/edit-post/build-module/deprecated.js
/**
 * WordPress dependencies
 */




/**
 * Internal dependencies
 */


const {
  PluginPostExcerpt
} = unlock(external_wp_editor_namespaceObject.privateApis);
const isSiteEditor = (0,external_wp_url_namespaceObject.getPath)(window.location.href)?.includes(&#039;site-editor.php&#039;);
const deprecateSlot = name =&gt; {
  external_wp_deprecated_default()(`wp.editPost.${name}`, {
    since: &#039;6.6&#039;,
    alternative: `wp.editor.${name}`
  });
};

/* eslint-disable jsdoc/require-param */
/**
 * @see PluginBlockSettingsMenuItem in @wordpress/editor package.
 */
function PluginBlockSettingsMenuItem(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginBlockSettingsMenuItem&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginBlockSettingsMenuItem, {
    ...props
  });
}

/**
 * @see PluginDocumentSettingPanel in @wordpress/editor package.
 */
function PluginDocumentSettingPanel(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginDocumentSettingPanel&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginDocumentSettingPanel, {
    ...props
  });
}

/**
 * @see PluginMoreMenuItem in @wordpress/editor package.
 */
function PluginMoreMenuItem(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginMoreMenuItem&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginMoreMenuItem, {
    ...props
  });
}

/**
 * @see PluginPrePublishPanel in @wordpress/editor package.
 */
function PluginPrePublishPanel(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginPrePublishPanel&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginPrePublishPanel, {
    ...props
  });
}

/**
 * @see PluginPostPublishPanel in @wordpress/editor package.
 */
function PluginPostPublishPanel(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginPostPublishPanel&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginPostPublishPanel, {
    ...props
  });
}

/**
 * @see PluginPostStatusInfo in @wordpress/editor package.
 */
function PluginPostStatusInfo(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginPostStatusInfo&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginPostStatusInfo, {
    ...props
  });
}

/**
 * @see PluginSidebar in @wordpress/editor package.
 */
function PluginSidebar(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginSidebar&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginSidebar, {
    ...props
  });
}

/**
 * @see PluginSidebarMoreMenuItem in @wordpress/editor package.
 */
function PluginSidebarMoreMenuItem(props) {
  if (isSiteEditor) {
    return null;
  }
  deprecateSlot(&#039;PluginSidebarMoreMenuItem&#039;);
  return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_editor_namespaceObject.PluginSidebarMoreMenuItem, {
    ...props
  });
}

/**
 * @see PluginPostExcerpt in @wordpress/editor package.
 */
function __experimentalPluginPostExcerpt() {
  if (isSiteEditor) {
    return null;
  }
  external_wp_deprecated_default()(&#039;wp.editPost.__experimentalPluginPostExcerpt&#039;, {
    since: &#039;6.6&#039;,
    hint: &#039;Core and custom panels can be access programmatically using their panel name.&#039;,
    link: &#039;https://developer.wordpress.org/block-editor/reference-guides/slotfills/plugin-document-setting-panel/#accessing-a-panel-programmatically&#039;
  });
  return PluginPostExcerpt;
}

/* eslint-enable jsdoc/require-param */

;// ./node_modules/@wordpress/edit-post/build-module/index.js
/**
 * WordPress dependencies
 */









/**
 * Internal dependencies
 */



const {
  BackButton: __experimentalMainDashboardButton,
  registerCoreBlockBindingsSources
} = unlock(external_wp_editor_namespaceObject.privateApis);

/**
 * Initializes and returns an instance of Editor.
 *
 * @param {string}  id           Unique identifier for editor instance.
 * @param {string}  postType     Post type of the post to edit.
 * @param {Object}  postId       ID of the post to edit.
 * @param {?Object} settings     Editor settings object.
 * @param {Object}  initialEdits Programmatic edits to apply initially, to be
 *                               considered as non-user-initiated (bypass for
 *                               unsaved changes prompt).
 */
function initializeEditor(id, postType, postId, settings, initialEdits) {
  const isMediumOrBigger = window.matchMedia(&#039;(min-width: 782px)&#039;).matches;
  const target = document.getElementById(id);
  const root = (0,external_wp_element_namespaceObject.createRoot)(target);
  (0,external_wp_data_namespaceObject.dispatch)(external_wp_preferences_namespaceObject.store).setDefaults(&#039;core/edit-post&#039;, {
    fullscreenMode: true,
    themeStyles: true,
    welcomeGuide: true,
    welcomeGuideTemplate: true
  });
  (0,external_wp_data_namespaceObject.dispatch)(external_wp_preferences_namespaceObject.store).setDefaults(&#039;core&#039;, {
    allowRightClickOverrides: true,
    editorMode: &#039;visual&#039;,
    editorTool: &#039;edit&#039;,
    fixedToolbar: false,
    hiddenBlockTypes: [],
    inactivePanels: [],
    openPanels: [&#039;post-status&#039;],
    showBlockBreadcrumbs: true,
    showIconLabels: false,
    showListViewByDefault: false,
    enableChoosePatternModal: true,
    isPublishSidebarEnabled: true
  });
  if (window.__experimentalMediaProcessing) {
    (0,external_wp_data_namespaceObject.dispatch)(external_wp_preferences_namespaceObject.store).setDefaults(&#039;core/media&#039;, {
      requireApproval: true,
      optimizeOnUpload: true
    });
  }
  (0,external_wp_data_namespaceObject.dispatch)(external_wp_blocks_namespaceObject.store).reapplyBlockTypeFilters();

  // Check if the block list view should be open by default.
  // If `distractionFree` mode is enabled, the block list view should not be open.
  // This behavior is disabled for small viewports.
  if (isMediumOrBigger &amp;&amp; (0,external_wp_data_namespaceObject.select)(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;showListViewByDefault&#039;) &amp;&amp; !(0,external_wp_data_namespaceObject.select)(external_wp_preferences_namespaceObject.store).get(&#039;core&#039;, &#039;distractionFree&#039;)) {
    (0,external_wp_data_namespaceObject.dispatch)(external_wp_editor_namespaceObject.store).setIsListViewOpened(true);
  }
  (0,external_wp_blockLibrary_namespaceObject.registerCoreBlocks)();
  registerCoreBlockBindingsSources();
  (0,external_wp_widgets_namespaceObject.registerLegacyWidgetBlock)({
    inserter: false
  });
  (0,external_wp_widgets_namespaceObject.registerWidgetGroupBlock)({
    inserter: false
  });
  if (false) {}

  // Show a console log warning if the browser is not in Standards rendering mode.
  const documentMode = document.compatMode === &#039;CSS1Compat&#039; ? &#039;Standards&#039; : &#039;Quirks&#039;;
  if (documentMode !== &#039;Standards&#039;) {
    // eslint-disable-next-line no-console
    console.warn(&quot;Your browser is using Quirks Mode. \nThis can cause rendering issues such as blocks overlaying meta boxes in the editor. Quirks Mode can be triggered by PHP errors or HTML code appearing before the opening &lt;!DOCTYPE html&gt;. Try checking the raw page source or your site&#039;s PHP error log and resolving errors there, removing any HTML before the doctype, or disabling plugins.&quot;);
  }

  // This is a temporary fix for a couple of issues specific to Webkit on iOS.
  // Without this hack the browser scrolls the mobile toolbar off-screen.
  // Once supported in Safari we can replace this in favor of preventScroll.
  // For details see issue #18632 and PR #18686
  // Specifically, we scroll `interface-interface-skeleton__body` to enable a fixed top toolbar.
  // But Mobile Safari forces the `html` element to scroll upwards, hiding the toolbar.

  const isIphone = window.navigator.userAgent.indexOf(&#039;iPhone&#039;) !== -1;
  if (isIphone) {
    window.addEventListener(&#039;scroll&#039;, event =&gt; {
      const editorScrollContainer = document.getElementsByClassName(&#039;interface-interface-skeleton__body&#039;)[0];
      if (event.target === document) {
        // Scroll element into view by scrolling the editor container by the same amount
        // that Mobile Safari tried to scroll the html element upwards.
        if (window.scrollY &gt; 100) {
          editorScrollContainer.scrollTop = editorScrollContainer.scrollTop + window.scrollY;
        }
        // Undo unwanted scroll on html element, but only in the visual editor.
        if (document.getElementsByClassName(&#039;is-mode-visual&#039;)[0]) {
          window.scrollTo(0, 0);
        }
      }
    });
  }

  // Prevent the default browser action for files dropped outside of dropzones.
  window.addEventListener(&#039;dragover&#039;, e =&gt; e.preventDefault(), false);
  window.addEventListener(&#039;drop&#039;, e =&gt; e.preventDefault(), false);
  root.render(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.StrictMode, {
    children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(layout, {
      settings: settings,
      postId: postId,
      postType: postType,
      initialEdits: initialEdits
    })
  }));
  return root;
}

/**
 * Used to reinitialize the editor after an error. Now it&#039;s a deprecated noop function.
 */
function reinitializeEditor() {
  external_wp_deprecated_default()(&#039;wp.editPost.reinitializeEditor&#039;, {
    since: &#039;6.2&#039;,
    version: &#039;6.3&#039;
  });
}





(window.wp = window.wp || {}).editPost = __webpack_exports__;
/******/ })()
;</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes%2Fjs'>?? Yukar?</a>