@wordpress/block-editor 15.9.1-next.6deb34194.0 → 15.9.1-next.738bb1424.0

package/build/store/selectors.js

@@ -1,1802 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// packages/block-editor/src/store/selectors.js
-var selectors_exports = {};
-__export(selectors_exports, {
-  __experimentalGetActiveBlockIdByBlockNames: () => __experimentalGetActiveBlockIdByBlockNames,
-  __experimentalGetAllowedBlocks: () => __experimentalGetAllowedBlocks,
-  __experimentalGetAllowedPatterns: () => __experimentalGetAllowedPatterns,
-  __experimentalGetBlockListSettingsForBlocks: () => __experimentalGetBlockListSettingsForBlocks,
-  __experimentalGetDirectInsertBlock: () => __experimentalGetDirectInsertBlock,
-  __experimentalGetGlobalBlocksByName: () => __experimentalGetGlobalBlocksByName,
-  __experimentalGetLastBlockAttributeChanges: () => __experimentalGetLastBlockAttributeChanges,
-  __experimentalGetParsedPattern: () => __experimentalGetParsedPattern,
-  __experimentalGetPatternTransformItems: () => __experimentalGetPatternTransformItems,
-  __experimentalGetPatternsByBlockTypes: () => __experimentalGetPatternsByBlockTypes,
-  __experimentalGetReusableBlockTitle: () => __experimentalGetReusableBlockTitle,
-  __unstableGetBlockWithoutInnerBlocks: () => __unstableGetBlockWithoutInnerBlocks,
-  __unstableGetClientIdWithClientIdsTree: () => __unstableGetClientIdWithClientIdsTree,
-  __unstableGetClientIdsTree: () => __unstableGetClientIdsTree,
-  __unstableGetContentLockingParent: () => __unstableGetContentLockingParent,
-  __unstableGetSelectedBlocksWithPartialSelection: () => __unstableGetSelectedBlocksWithPartialSelection,
-  __unstableGetTemporarilyEditingAsBlocks: () => __unstableGetTemporarilyEditingAsBlocks,
-  __unstableGetVisibleBlocks: () => __unstableGetVisibleBlocks,
-  __unstableHasActiveBlockOverlayActive: () => __unstableHasActiveBlockOverlayActive,
-  __unstableIsFullySelected: () => __unstableIsFullySelected,
-  __unstableIsLastBlockChangeIgnored: () => __unstableIsLastBlockChangeIgnored,
-  __unstableIsSelectionCollapsed: () => __unstableIsSelectionCollapsed,
-  __unstableIsSelectionMergeable: () => __unstableIsSelectionMergeable,
-  __unstableIsWithinBlockOverlay: () => __unstableIsWithinBlockOverlay,
-  __unstableSelectionHasUnmergeableBlock: () => __unstableSelectionHasUnmergeableBlock,
-  areInnerBlocksControlled: () => areInnerBlocksControlled,
-  canEditBlock: () => canEditBlock,
-  canInsertBlockType: () => canInsertBlockType,
-  canInsertBlocks: () => canInsertBlocks,
-  canLockBlockType: () => canLockBlockType,
-  canMoveBlock: () => canMoveBlock,
-  canMoveBlocks: () => canMoveBlocks,
-  canRemoveBlock: () => canRemoveBlock,
-  canRemoveBlocks: () => canRemoveBlocks,
-  didAutomaticChange: () => didAutomaticChange,
-  getAdjacentBlockClientId: () => getAdjacentBlockClientId,
-  getAllowedBlocks: () => getAllowedBlocks,
-  getBlock: () => getBlock,
-  getBlockAttributes: () => getBlockAttributes,
-  getBlockCount: () => getBlockCount,
-  getBlockEditingMode: () => getBlockEditingMode,
-  getBlockHierarchyRootClientId: () => getBlockHierarchyRootClientId,
-  getBlockIndex: () => getBlockIndex,
-  getBlockInsertionPoint: () => getBlockInsertionPoint,
-  getBlockListSettings: () => getBlockListSettings,
-  getBlockMode: () => getBlockMode,
-  getBlockName: () => getBlockName,
-  getBlockNamesByClientId: () => getBlockNamesByClientId,
-  getBlockOrder: () => getBlockOrder,
-  getBlockParents: () => getBlockParents,
-  getBlockParentsByBlockName: () => getBlockParentsByBlockName,
-  getBlockRootClientId: () => getBlockRootClientId,
-  getBlockSelectionEnd: () => getBlockSelectionEnd,
-  getBlockSelectionStart: () => getBlockSelectionStart,
-  getBlockTransformItems: () => getBlockTransformItems,
-  getBlocks: () => getBlocks,
-  getBlocksByClientId: () => getBlocksByClientId,
-  getBlocksByName: () => getBlocksByName,
-  getClientIdsOfDescendants: () => getClientIdsOfDescendants,
-  getClientIdsWithDescendants: () => getClientIdsWithDescendants,
-  getDirectInsertBlock: () => getDirectInsertBlock,
-  getDraggedBlockClientIds: () => getDraggedBlockClientIds,
-  getFirstMultiSelectedBlockClientId: () => getFirstMultiSelectedBlockClientId,
-  getGlobalBlockCount: () => getGlobalBlockCount,
-  getHoveredBlockClientId: () => getHoveredBlockClientId,
-  getInserterItems: () => getInserterItems,
-  getLastMultiSelectedBlockClientId: () => getLastMultiSelectedBlockClientId,
-  getLowestCommonAncestorWithSelectedBlock: () => getLowestCommonAncestorWithSelectedBlock,
-  getMultiSelectedBlockClientIds: () => getMultiSelectedBlockClientIds,
-  getMultiSelectedBlocks: () => getMultiSelectedBlocks,
-  getMultiSelectedBlocksEndClientId: () => getMultiSelectedBlocksEndClientId,
-  getMultiSelectedBlocksStartClientId: () => getMultiSelectedBlocksStartClientId,
-  getNextBlockClientId: () => getNextBlockClientId,
-  getPatternsByBlockTypes: () => getPatternsByBlockTypes,
-  getPreviousBlockClientId: () => getPreviousBlockClientId,
-  getSelectedBlock: () => getSelectedBlock,
-  getSelectedBlockClientId: () => getSelectedBlockClientId,
-  getSelectedBlockClientIds: () => getSelectedBlockClientIds,
-  getSelectedBlockCount: () => getSelectedBlockCount,
-  getSelectedBlocksInitialCaretPosition: () => getSelectedBlocksInitialCaretPosition,
-  getSelectionEnd: () => getSelectionEnd,
-  getSelectionStart: () => getSelectionStart,
-  getSettings: () => getSettings,
-  getTemplate: () => getTemplate,
-  getTemplateLock: () => getTemplateLock,
-  hasBlockMovingClientId: () => hasBlockMovingClientId,
-  hasDraggedInnerBlock: () => hasDraggedInnerBlock,
-  hasInserterItems: () => hasInserterItems,
-  hasMultiSelection: () => hasMultiSelection,
-  hasSelectedBlock: () => hasSelectedBlock,
-  hasSelectedInnerBlock: () => hasSelectedInnerBlock,
-  isAncestorBeingDragged: () => isAncestorBeingDragged,
-  isAncestorMultiSelected: () => isAncestorMultiSelected,
-  isBlockBeingDragged: () => isBlockBeingDragged,
-  isBlockHighlighted: () => isBlockHighlighted,
-  isBlockInsertionPointVisible: () => isBlockInsertionPointVisible,
-  isBlockMultiSelected: () => isBlockMultiSelected,
-  isBlockSelected: () => isBlockSelected,
-  isBlockValid: () => isBlockValid,
-  isBlockVisible: () => isBlockVisible,
-  isBlockWithinSelection: () => isBlockWithinSelection,
-  isCaretWithinFormattedText: () => isCaretWithinFormattedText,
-  isDraggingBlocks: () => isDraggingBlocks,
-  isFirstMultiSelectedBlock: () => isFirstMultiSelectedBlock,
-  isGroupable: () => isGroupable,
-  isLastBlockChangePersistent: () => isLastBlockChangePersistent,
-  isMultiSelecting: () => isMultiSelecting,
-  isSelectionEnabled: () => isSelectionEnabled,
-  isTyping: () => isTyping,
-  isUngroupable: () => isUngroupable,
-  isValidTemplate: () => isValidTemplate,
-  wasBlockJustInserted: () => wasBlockJustInserted
-});
-module.exports = __toCommonJS(selectors_exports);
-var import_blocks = require("@wordpress/blocks");
-var import_element = require("@wordpress/element");
-var import_hooks = require("@wordpress/hooks");
-var import_icons = require("@wordpress/icons");
-var import_rich_text = require("@wordpress/rich-text");
-var import_deprecated = __toESM(require("@wordpress/deprecated"));
-var import_data = require("@wordpress/data");
-var import_utils = require("./utils");
-var import_sorting = require("../utils/sorting");
-var import_constants = require("./constants");
-var import_lock_unlock = require("../lock-unlock");
-var import_private_selectors = require("./private-selectors");
-var { isContentBlock } = (0, import_lock_unlock.unlock)(import_blocks.privateApis);
-var MILLISECONDS_PER_HOUR = 3600 * 1e3;
-var MILLISECONDS_PER_DAY = 24 * 3600 * 1e3;
-var MILLISECONDS_PER_WEEK = 7 * 24 * 3600 * 1e3;
-var EMPTY_ARRAY = [];
-var EMPTY_SET = /* @__PURE__ */ new Set();
-var DEFAULT_INSERTER_OPTIONS = {
-  [import_utils.isFiltered]: true
-};
-function getBlockName(state, clientId) {
-  const block = state.blocks.byClientId.get(clientId);
-  const socialLinkName = "core/social-link";
-  if (import_element.Platform.OS !== "web" && block?.name === socialLinkName) {
-    const attributes = state.blocks.attributes.get(clientId);
-    const { service } = attributes ?? {};
-    return service ? `${socialLinkName}-${service}` : socialLinkName;
-  }
-  return block ? block.name : null;
-}
-function isBlockValid(state, clientId) {
-  const block = state.blocks.byClientId.get(clientId);
-  return !!block && block.isValid;
-}
-function getBlockAttributes(state, clientId) {
-  const block = state.blocks.byClientId.get(clientId);
-  if (!block) {
-    return null;
-  }
-  return state.blocks.attributes.get(clientId);
-}
-function getBlock(state, clientId) {
-  if (!state.blocks.byClientId.has(clientId)) {
-    return null;
-  }
-  return state.blocks.tree.get(clientId);
-}
-var __unstableGetBlockWithoutInnerBlocks = (0, import_data.createSelector)(
-  (state, clientId) => {
-    const block = state.blocks.byClientId.get(clientId);
-    if (!block) {
-      return null;
-    }
-    return {
-      ...block,
-      attributes: getBlockAttributes(state, clientId)
-    };
-  },
-  (state, clientId) => [
-    state.blocks.byClientId.get(clientId),
-    state.blocks.attributes.get(clientId)
-  ]
-);
-function getBlocks(state, rootClientId) {
-  const treeKey = !rootClientId || !areInnerBlocksControlled(state, rootClientId) ? rootClientId || "" : "controlled||" + rootClientId;
-  return state.blocks.tree.get(treeKey)?.innerBlocks || EMPTY_ARRAY;
-}
-var __unstableGetClientIdWithClientIdsTree = (0, import_data.createSelector)(
-  (state, clientId) => {
-    (0, import_deprecated.default)(
-      "wp.data.select( 'core/block-editor' ).__unstableGetClientIdWithClientIdsTree",
-      {
-        since: "6.3",
-        version: "6.5"
-      }
-    );
-    return {
-      clientId,
-      innerBlocks: __unstableGetClientIdsTree(state, clientId)
-    };
-  },
-  (state) => [state.blocks.order]
-);
-var __unstableGetClientIdsTree = (0, import_data.createSelector)(
-  (state, rootClientId = "") => {
-    (0, import_deprecated.default)(
-      "wp.data.select( 'core/block-editor' ).__unstableGetClientIdsTree",
-      {
-        since: "6.3",
-        version: "6.5"
-      }
-    );
-    return getBlockOrder(state, rootClientId).map(
-      (clientId) => __unstableGetClientIdWithClientIdsTree(state, clientId)
-    );
-  },
-  (state) => [state.blocks.order]
-);
-var getClientIdsOfDescendants = (0, import_data.createSelector)(
-  (state, rootIds) => {
-    rootIds = Array.isArray(rootIds) ? [...rootIds] : [rootIds];
-    const ids = [];
-    for (const rootId of rootIds) {
-      const order = state.blocks.order.get(rootId);
-      if (order) {
-        ids.push(...order);
-      }
-    }
-    let index = 0;
-    while (index < ids.length) {
-      const id = ids[index];
-      const order = state.blocks.order.get(id);
-      if (order) {
-        ids.splice(index + 1, 0, ...order);
-      }
-      index++;
-    }
-    return ids;
-  },
-  (state) => [state.blocks.order]
-);
-var getClientIdsWithDescendants = (state) => getClientIdsOfDescendants(state, "");
-var getGlobalBlockCount = (0, import_data.createSelector)(
-  (state, blockName) => {
-    const clientIds = getClientIdsWithDescendants(state);
-    if (!blockName) {
-      return clientIds.length;
-    }
-    let count = 0;
-    for (const clientId of clientIds) {
-      const block = state.blocks.byClientId.get(clientId);
-      if (block.name === blockName) {
-        count++;
-      }
-    }
-    return count;
-  },
-  (state) => [state.blocks.order, state.blocks.byClientId]
-);
-var getBlocksByName = (0, import_data.createSelector)(
-  (state, blockName) => {
-    if (!blockName) {
-      return EMPTY_ARRAY;
-    }
-    const blockNames = Array.isArray(blockName) ? blockName : [blockName];
-    const clientIds = getClientIdsWithDescendants(state);
-    const foundBlocks = clientIds.filter((clientId) => {
-      const block = state.blocks.byClientId.get(clientId);
-      return blockNames.includes(block.name);
-    });
-    return foundBlocks.length > 0 ? foundBlocks : EMPTY_ARRAY;
-  },
-  (state) => [state.blocks.order, state.blocks.byClientId]
-);
-function __experimentalGetGlobalBlocksByName(state, blockName) {
-  (0, import_deprecated.default)(
-    "wp.data.select( 'core/block-editor' ).__experimentalGetGlobalBlocksByName",
-    {
-      since: "6.5",
-      alternative: `wp.data.select( 'core/block-editor' ).getBlocksByName`
-    }
-  );
-  return getBlocksByName(state, blockName);
-}
-var getBlocksByClientId = (0, import_data.createSelector)(
-  (state, clientIds) => (Array.isArray(clientIds) ? clientIds : [clientIds]).map(
-    (clientId) => getBlock(state, clientId)
-  ),
-  (state, clientIds) => (Array.isArray(clientIds) ? clientIds : [clientIds]).map(
-    (clientId) => state.blocks.tree.get(clientId)
-  )
-);
-var getBlockNamesByClientId = (0, import_data.createSelector)(
-  (state, clientIds) => getBlocksByClientId(state, clientIds).filter(Boolean).map((block) => block.name),
-  (state, clientIds) => getBlocksByClientId(state, clientIds)
-);
-function getBlockCount(state, rootClientId) {
-  return getBlockOrder(state, rootClientId).length;
-}
-function getSelectionStart(state) {
-  return state.selection.selectionStart;
-}
-function getSelectionEnd(state) {
-  return state.selection.selectionEnd;
-}
-function getBlockSelectionStart(state) {
-  return state.selection.selectionStart.clientId;
-}
-function getBlockSelectionEnd(state) {
-  return state.selection.selectionEnd.clientId;
-}
-function getSelectedBlockCount(state) {
-  const multiSelectedBlockCount = getMultiSelectedBlockClientIds(state).length;
-  if (multiSelectedBlockCount) {
-    return multiSelectedBlockCount;
-  }
-  return state.selection.selectionStart.clientId ? 1 : 0;
-}
-function hasSelectedBlock(state) {
-  const { selectionStart, selectionEnd } = state.selection;
-  return !!selectionStart.clientId && selectionStart.clientId === selectionEnd.clientId;
-}
-function getSelectedBlockClientId(state) {
-  const { selectionStart, selectionEnd } = state.selection;
-  const { clientId } = selectionStart;
-  if (!clientId || clientId !== selectionEnd.clientId) {
-    return null;
-  }
-  return clientId;
-}
-function getSelectedBlock(state) {
-  const clientId = getSelectedBlockClientId(state);
-  return clientId ? getBlock(state, clientId) : null;
-}
-function getBlockRootClientId(state, clientId) {
-  return state.blocks.parents.get(clientId) ?? null;
-}
-var getBlockParents = (0, import_data.createSelector)(
-  (state, clientId, ascending = false) => {
-    const parents = [];
-    let current = clientId;
-    while (current = state.blocks.parents.get(current)) {
-      parents.push(current);
-    }
-    if (!parents.length) {
-      return EMPTY_ARRAY;
-    }
-    return ascending ? parents : parents.reverse();
-  },
-  (state) => [state.blocks.parents]
-);
-var getBlockParentsByBlockName = (0, import_data.createSelector)(
-  (state, clientId, blockName, ascending = false) => {
-    const parents = getBlockParents(state, clientId, ascending);
-    const hasName = Array.isArray(blockName) ? (name) => blockName.includes(name) : (name) => blockName === name;
-    return parents.filter((id) => hasName(getBlockName(state, id)));
-  },
-  (state) => [state.blocks.parents]
-);
-function getBlockHierarchyRootClientId(state, clientId) {
-  let current = clientId;
-  let parent;
-  do {
-    parent = current;
-    current = state.blocks.parents.get(current);
-  } while (current);
-  return parent;
-}
-function getLowestCommonAncestorWithSelectedBlock(state, clientId) {
-  const selectedId = getSelectedBlockClientId(state);
-  const clientParents = [...getBlockParents(state, clientId), clientId];
-  const selectedParents = [
-    ...getBlockParents(state, selectedId),
-    selectedId
-  ];
-  let lowestCommonAncestor;
-  const maxDepth = Math.min(clientParents.length, selectedParents.length);
-  for (let index = 0; index < maxDepth; index++) {
-    if (clientParents[index] === selectedParents[index]) {
-      lowestCommonAncestor = clientParents[index];
-    } else {
-      break;
-    }
-  }
-  return lowestCommonAncestor;
-}
-function getAdjacentBlockClientId(state, startClientId, modifier = 1) {
-  if (startClientId === void 0) {
-    startClientId = getSelectedBlockClientId(state);
-  }
-  if (startClientId === void 0) {
-    if (modifier < 0) {
-      startClientId = getFirstMultiSelectedBlockClientId(state);
-    } else {
-      startClientId = getLastMultiSelectedBlockClientId(state);
-    }
-  }
-  if (!startClientId) {
-    return null;
-  }
-  const rootClientId = getBlockRootClientId(state, startClientId);
-  if (rootClientId === null) {
-    return null;
-  }
-  const { order } = state.blocks;
-  const orderSet = order.get(rootClientId);
-  const index = orderSet.indexOf(startClientId);
-  const nextIndex = index + 1 * modifier;
-  if (nextIndex < 0) {
-    return null;
-  }
-  if (nextIndex === orderSet.length) {
-    return null;
-  }
-  return orderSet[nextIndex];
-}
-function getPreviousBlockClientId(state, startClientId) {
-  return getAdjacentBlockClientId(state, startClientId, -1);
-}
-function getNextBlockClientId(state, startClientId) {
-  return getAdjacentBlockClientId(state, startClientId, 1);
-}
-function getSelectedBlocksInitialCaretPosition(state) {
-  return state.initialPosition;
-}
-var getSelectedBlockClientIds = (0, import_data.createSelector)(
-  (state) => {
-    const { selectionStart, selectionEnd } = state.selection;
-    if (!selectionStart.clientId || !selectionEnd.clientId) {
-      return EMPTY_ARRAY;
-    }
-    if (selectionStart.clientId === selectionEnd.clientId) {
-      return [selectionStart.clientId];
-    }
-    const rootClientId = getBlockRootClientId(
-      state,
-      selectionStart.clientId
-    );
-    if (rootClientId === null) {
-      return EMPTY_ARRAY;
-    }
-    const blockOrder = getBlockOrder(state, rootClientId);
-    const startIndex = blockOrder.indexOf(selectionStart.clientId);
-    const endIndex = blockOrder.indexOf(selectionEnd.clientId);
-    if (startIndex > endIndex) {
-      return blockOrder.slice(endIndex, startIndex + 1);
-    }
-    return blockOrder.slice(startIndex, endIndex + 1);
-  },
-  (state) => [
-    state.blocks.order,
-    state.selection.selectionStart.clientId,
-    state.selection.selectionEnd.clientId
-  ]
-);
-function getMultiSelectedBlockClientIds(state) {
-  const { selectionStart, selectionEnd } = state.selection;
-  if (selectionStart.clientId === selectionEnd.clientId) {
-    return EMPTY_ARRAY;
-  }
-  return getSelectedBlockClientIds(state);
-}
-var getMultiSelectedBlocks = (0, import_data.createSelector)(
-  (state) => {
-    const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state);
-    if (!multiSelectedBlockClientIds.length) {
-      return EMPTY_ARRAY;
-    }
-    return multiSelectedBlockClientIds.map(
-      (clientId) => getBlock(state, clientId)
-    );
-  },
-  (state) => [
-    ...getSelectedBlockClientIds.getDependants(state),
-    state.blocks.byClientId,
-    state.blocks.order,
-    state.blocks.attributes
-  ]
-);
-function getFirstMultiSelectedBlockClientId(state) {
-  return getMultiSelectedBlockClientIds(state)[0] || null;
-}
-function getLastMultiSelectedBlockClientId(state) {
-  const selectedClientIds = getMultiSelectedBlockClientIds(state);
-  return selectedClientIds[selectedClientIds.length - 1] || null;
-}
-function isFirstMultiSelectedBlock(state, clientId) {
-  return getFirstMultiSelectedBlockClientId(state) === clientId;
-}
-function isBlockMultiSelected(state, clientId) {
-  return getMultiSelectedBlockClientIds(state).indexOf(clientId) !== -1;
-}
-var isAncestorMultiSelected = (0, import_data.createSelector)(
-  (state, clientId) => {
-    let ancestorClientId = clientId;
-    let isMultiSelected = false;
-    while (ancestorClientId && !isMultiSelected) {
-      ancestorClientId = getBlockRootClientId(state, ancestorClientId);
-      isMultiSelected = isBlockMultiSelected(state, ancestorClientId);
-    }
-    return isMultiSelected;
-  },
-  (state) => [
-    state.blocks.order,
-    state.selection.selectionStart.clientId,
-    state.selection.selectionEnd.clientId
-  ]
-);
-function getMultiSelectedBlocksStartClientId(state) {
-  const { selectionStart, selectionEnd } = state.selection;
-  if (selectionStart.clientId === selectionEnd.clientId) {
-    return null;
-  }
-  return selectionStart.clientId || null;
-}
-function getMultiSelectedBlocksEndClientId(state) {
-  const { selectionStart, selectionEnd } = state.selection;
-  if (selectionStart.clientId === selectionEnd.clientId) {
-    return null;
-  }
-  return selectionEnd.clientId || null;
-}
-function __unstableIsFullySelected(state) {
-  const selectionAnchor = getSelectionStart(state);
-  const selectionFocus = getSelectionEnd(state);
-  return !selectionAnchor.attributeKey && !selectionFocus.attributeKey && typeof selectionAnchor.offset === "undefined" && typeof selectionFocus.offset === "undefined";
-}
-function __unstableIsSelectionCollapsed(state) {
-  const selectionAnchor = getSelectionStart(state);
-  const selectionFocus = getSelectionEnd(state);
-  return !!selectionAnchor && !!selectionFocus && selectionAnchor.clientId === selectionFocus.clientId && selectionAnchor.attributeKey === selectionFocus.attributeKey && selectionAnchor.offset === selectionFocus.offset;
-}
-function __unstableSelectionHasUnmergeableBlock(state) {
-  return getSelectedBlockClientIds(state).some((clientId) => {
-    const blockName = getBlockName(state, clientId);
-    const blockType = (0, import_blocks.getBlockType)(blockName);
-    return !blockType.merge;
-  });
-}
-function __unstableIsSelectionMergeable(state, isForward) {
-  const selectionAnchor = getSelectionStart(state);
-  const selectionFocus = getSelectionEnd(state);
-  if (selectionAnchor.clientId === selectionFocus.clientId) {
-    return false;
-  }
-  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === "undefined" || typeof selectionFocus.offset === "undefined") {
-    return false;
-  }
-  const anchorRootClientId = getBlockRootClientId(
-    state,
-    selectionAnchor.clientId
-  );
-  const focusRootClientId = getBlockRootClientId(
-    state,
-    selectionFocus.clientId
-  );
-  if (anchorRootClientId !== focusRootClientId) {
-    return false;
-  }
-  const blockOrder = getBlockOrder(state, anchorRootClientId);
-  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
-  const focusIndex = blockOrder.indexOf(selectionFocus.clientId);
-  let selectionStart, selectionEnd;
-  if (anchorIndex > focusIndex) {
-    selectionStart = selectionFocus;
-    selectionEnd = selectionAnchor;
-  } else {
-    selectionStart = selectionAnchor;
-    selectionEnd = selectionFocus;
-  }
-  const targetBlockClientId = isForward ? selectionEnd.clientId : selectionStart.clientId;
-  const blockToMergeClientId = isForward ? selectionStart.clientId : selectionEnd.clientId;
-  const targetBlockName = getBlockName(state, targetBlockClientId);
-  const targetBlockType = (0, import_blocks.getBlockType)(targetBlockName);
-  if (!targetBlockType.merge) {
-    return false;
-  }
-  const blockToMerge = getBlock(state, blockToMergeClientId);
-  if (blockToMerge.name === targetBlockName) {
-    return true;
-  }
-  const blocksToMerge = (0, import_blocks.switchToBlockType)(blockToMerge, targetBlockName);
-  return blocksToMerge && blocksToMerge.length;
-}
-var __unstableGetSelectedBlocksWithPartialSelection = (state) => {
-  const selectionAnchor = getSelectionStart(state);
-  const selectionFocus = getSelectionEnd(state);
-  if (selectionAnchor.clientId === selectionFocus.clientId) {
-    return EMPTY_ARRAY;
-  }
-  if (!selectionAnchor.attributeKey || !selectionFocus.attributeKey || typeof selectionAnchor.offset === "undefined" || typeof selectionFocus.offset === "undefined") {
-    return EMPTY_ARRAY;
-  }
-  const anchorRootClientId = getBlockRootClientId(
-    state,
-    selectionAnchor.clientId
-  );
-  const focusRootClientId = getBlockRootClientId(
-    state,
-    selectionFocus.clientId
-  );
-  if (anchorRootClientId !== focusRootClientId) {
-    return EMPTY_ARRAY;
-  }
-  const blockOrder = getBlockOrder(state, anchorRootClientId);
-  const anchorIndex = blockOrder.indexOf(selectionAnchor.clientId);
-  const focusIndex = blockOrder.indexOf(selectionFocus.clientId);
-  const [selectionStart, selectionEnd] = anchorIndex > focusIndex ? [selectionFocus, selectionAnchor] : [selectionAnchor, selectionFocus];
-  const blockA = getBlock(state, selectionStart.clientId);
-  const blockB = getBlock(state, selectionEnd.clientId);
-  const htmlA = blockA.attributes[selectionStart.attributeKey];
-  const htmlB = blockB.attributes[selectionEnd.attributeKey];
-  let valueA = (0, import_rich_text.create)({ html: htmlA });
-  let valueB = (0, import_rich_text.create)({ html: htmlB });
-  valueA = (0, import_rich_text.remove)(valueA, 0, selectionStart.offset);
-  valueB = (0, import_rich_text.remove)(valueB, selectionEnd.offset, valueB.text.length);
-  return [
-    {
-      ...blockA,
-      attributes: {
-        ...blockA.attributes,
-        [selectionStart.attributeKey]: (0, import_rich_text.toHTMLString)({
-          value: valueA
-        })
-      }
-    },
-    {
-      ...blockB,
-      attributes: {
-        ...blockB.attributes,
-        [selectionEnd.attributeKey]: (0, import_rich_text.toHTMLString)({
-          value: valueB
-        })
-      }
-    }
-  ];
-};
-function getBlockOrder(state, rootClientId) {
-  return state.blocks.order.get(rootClientId || "") || EMPTY_ARRAY;
-}
-function getBlockIndex(state, clientId) {
-  const rootClientId = getBlockRootClientId(state, clientId);
-  return getBlockOrder(state, rootClientId).indexOf(clientId);
-}
-function isBlockSelected(state, clientId) {
-  const { selectionStart, selectionEnd } = state.selection;
-  if (selectionStart.clientId !== selectionEnd.clientId) {
-    return false;
-  }
-  return selectionStart.clientId === clientId;
-}
-function hasSelectedInnerBlock(state, clientId, deep = false) {
-  const selectedBlockClientIds = getSelectedBlockClientIds(state);
-  if (!selectedBlockClientIds.length) {
-    return false;
-  }
-  if (deep) {
-    return selectedBlockClientIds.some(
-      (id) => (
-        // Pass true because we don't care about order and it's more
-        // performant.
-        getBlockParents(state, id, true).includes(clientId)
-      )
-    );
-  }
-  return selectedBlockClientIds.some(
-    (id) => getBlockRootClientId(state, id) === clientId
-  );
-}
-function hasDraggedInnerBlock(state, clientId, deep = false) {
-  return getBlockOrder(state, clientId).some(
-    (innerClientId) => isBlockBeingDragged(state, innerClientId) || deep && hasDraggedInnerBlock(state, innerClientId, deep)
-  );
-}
-function isBlockWithinSelection(state, clientId) {
-  if (!clientId) {
-    return false;
-  }
-  const clientIds = getMultiSelectedBlockClientIds(state);
-  const index = clientIds.indexOf(clientId);
-  return index > -1 && index < clientIds.length - 1;
-}
-function hasMultiSelection(state) {
-  const { selectionStart, selectionEnd } = state.selection;
-  return selectionStart.clientId !== selectionEnd.clientId;
-}
-function isMultiSelecting(state) {
-  return state.isMultiSelecting;
-}
-function isSelectionEnabled(state) {
-  return state.isSelectionEnabled;
-}
-function getBlockMode(state, clientId) {
-  return state.blocksMode[clientId] || "visual";
-}
-function isTyping(state) {
-  return state.isTyping;
-}
-function isDraggingBlocks(state) {
-  return !!state.draggedBlocks.length;
-}
-function getDraggedBlockClientIds(state) {
-  return state.draggedBlocks;
-}
-function isBlockBeingDragged(state, clientId) {
-  return state.draggedBlocks.includes(clientId);
-}
-function isAncestorBeingDragged(state, clientId) {
-  if (!isDraggingBlocks(state)) {
-    return false;
-  }
-  const parents = getBlockParents(state, clientId);
-  return parents.some(
-    (parentClientId) => isBlockBeingDragged(state, parentClientId)
-  );
-}
-function isCaretWithinFormattedText() {
-  (0, import_deprecated.default)(
-    'wp.data.select( "core/block-editor" ).isCaretWithinFormattedText',
-    {
-      since: "6.1",
-      version: "6.3"
-    }
-  );
-  return false;
-}
-var getBlockInsertionPoint = (0, import_data.createSelector)(
-  (state) => {
-    let rootClientId, index;
-    const {
-      insertionCue,
-      selection: { selectionEnd }
-    } = state;
-    if (insertionCue !== null) {
-      return insertionCue;
-    }
-    const { clientId } = selectionEnd;
-    if (clientId) {
-      rootClientId = getBlockRootClientId(state, clientId) || void 0;
-      index = getBlockIndex(state, selectionEnd.clientId) + 1;
-    } else {
-      index = getBlockOrder(state).length;
-    }
-    return { rootClientId, index };
-  },
-  (state) => [
-    state.insertionCue,
-    state.selection.selectionEnd.clientId,
-    state.blocks.parents,
-    state.blocks.order
-  ]
-);
-function isBlockInsertionPointVisible(state) {
-  return state.insertionCue !== null;
-}
-function isValidTemplate(state) {
-  return state.template.isValid;
-}
-function getTemplate(state) {
-  return state.settings.template;
-}
-function getTemplateLock(state, rootClientId) {
-  if (!rootClientId) {
-    return state.settings.templateLock ?? false;
-  }
-  const blockListTemplateLock = getBlockListSettings(
-    state,
-    rootClientId
-  )?.templateLock;
-  if (blockListTemplateLock === "contentOnly" && state.editedContentOnlySection === rootClientId) {
-    return false;
-  }
-  return blockListTemplateLock ?? false;
-}
-var isBlockVisibleInTheInserter = (state, blockNameOrType, rootClientId = null) => {
-  let blockType;
-  let blockName;
-  if (blockNameOrType && "object" === typeof blockNameOrType) {
-    blockType = blockNameOrType;
-    blockName = blockNameOrType.name;
-  } else {
-    blockType = (0, import_blocks.getBlockType)(blockNameOrType);
-    blockName = blockNameOrType;
-  }
-  if (!blockType) {
-    return false;
-  }
-  const { allowedBlockTypes } = getSettings(state);
-  const isBlockAllowedInEditor = (0, import_utils.checkAllowList)(
-    allowedBlockTypes,
-    blockName,
-    true
-  );
-  if (!isBlockAllowedInEditor) {
-    return false;
-  }
-  const parents = (Array.isArray(blockType.parent) ? blockType.parent : []).concat(Array.isArray(blockType.ancestor) ? blockType.ancestor : []);
-  if (parents.length > 0) {
-    if (parents.includes("core/post-content")) {
-      return true;
-    }
-    let current = rootClientId;
-    let hasParent = false;
-    do {
-      if (parents.includes(getBlockName(state, current))) {
-        hasParent = true;
-        break;
-      }
-      current = state.blocks.parents.get(current);
-    } while (current);
-    return hasParent;
-  }
-  return true;
-};
-var canInsertBlockTypeUnmemoized = (state, blockName, rootClientId = null) => {
-  if (!isBlockVisibleInTheInserter(state, blockName, rootClientId)) {
-    return false;
-  }
-  let blockType;
-  if (blockName && "object" === typeof blockName) {
-    blockType = blockName;
-    blockName = blockType.name;
-  } else {
-    blockType = (0, import_blocks.getBlockType)(blockName);
-  }
-  const rootTemplateLock = getTemplateLock(state, rootClientId);
-  if (rootTemplateLock && rootTemplateLock !== "contentOnly") {
-    return false;
-  }
-  const blockEditingMode = getBlockEditingMode(state, rootClientId ?? "");
-  if (blockEditingMode === "disabled") {
-    return false;
-  }
-  const parentBlockListSettings = getBlockListSettings(state, rootClientId);
-  if (rootClientId && parentBlockListSettings === void 0) {
-    return false;
-  }
-  const isContentRoleBlock = isContentBlock(blockName);
-  const isParentSectionBlock = !!(0, import_private_selectors.isSectionBlock)(state, rootClientId);
-  const isBlockWithinSection = !!(0, import_private_selectors.getParentSectionBlock)(
-    state,
-    rootClientId
-  );
-  if ((isParentSectionBlock || isBlockWithinSection) && !isContentRoleBlock) {
-    return false;
-  }
-  if ((isParentSectionBlock || blockEditingMode === "contentOnly") && !(0, import_private_selectors.isContainerInsertableToInContentOnlyMode)(
-    state,
-    blockName,
-    rootClientId
-  )) {
-    return false;
-  }
-  const parentName = getBlockName(state, rootClientId);
-  const parentBlockType = (0, import_blocks.getBlockType)(parentName);
-  const parentAllowedChildBlocks = parentBlockType?.allowedBlocks;
-  let hasParentAllowedBlock = (0, import_utils.checkAllowList)(
-    parentAllowedChildBlocks,
-    blockName
-  );
-  if (hasParentAllowedBlock !== false) {
-    const parentAllowedBlocks = parentBlockListSettings?.allowedBlocks;
-    const hasParentListAllowedBlock = (0, import_utils.checkAllowList)(
-      parentAllowedBlocks,
-      blockName
-    );
-    if (hasParentListAllowedBlock !== null) {
-      hasParentAllowedBlock = hasParentListAllowedBlock;
-    }
-  }
-  const blockAllowedParentBlocks = blockType.parent;
-  const hasBlockAllowedParent = (0, import_utils.checkAllowList)(
-    blockAllowedParentBlocks,
-    parentName
-  );
-  let hasBlockAllowedAncestor = true;
-  const blockAllowedAncestorBlocks = blockType.ancestor;
-  if (blockAllowedAncestorBlocks) {
-    const ancestors = [
-      rootClientId,
-      ...getBlockParents(state, rootClientId)
-    ];
-    hasBlockAllowedAncestor = ancestors.some(
-      (ancestorClientId) => (0, import_utils.checkAllowList)(
-        blockAllowedAncestorBlocks,
-        getBlockName(state, ancestorClientId)
-      )
-    );
-  }
-  const canInsert = hasBlockAllowedAncestor && (hasParentAllowedBlock === null && hasBlockAllowedParent === null || hasParentAllowedBlock === true || hasBlockAllowedParent === true);
-  if (!canInsert) {
-    return canInsert;
-  }
-  return (0, import_hooks.applyFilters)(
-    "blockEditor.__unstableCanInsertBlockType",
-    canInsert,
-    blockType,
-    rootClientId,
-    {
-      // Pass bound selectors of the current registry. If we're in a nested
-      // context, the data will differ from the one selected from the root
-      // registry.
-      getBlock: getBlock.bind(null, state),
-      getBlockParentsByBlockName: getBlockParentsByBlockName.bind(
-        null,
-        state
-      )
-    }
-  );
-};
-var canInsertBlockType = (0, import_data.createRegistrySelector)(
-  (select) => (0, import_data.createSelector)(
-    canInsertBlockTypeUnmemoized,
-    (state, blockName, rootClientId) => (0, import_utils.getInsertBlockTypeDependants)(select)(state, rootClientId)
-  )
-);
-function canInsertBlocks(state, clientIds, rootClientId = null) {
-  return clientIds.every(
-    (id) => canInsertBlockType(state, getBlockName(state, id), rootClientId)
-  );
-}
-function canRemoveBlock(state, clientId) {
-  const attributes = getBlockAttributes(state, clientId);
-  if (attributes === null) {
-    return true;
-  }
-  if (attributes.lock?.remove !== void 0) {
-    return !attributes.lock.remove;
-  }
-  const rootClientId = getBlockRootClientId(state, clientId);
-  const rootTemplateLock = getTemplateLock(state, rootClientId);
-  if (rootTemplateLock && rootTemplateLock !== "contentOnly") {
-    return false;
-  }
-  const isBlockWithinSection = !!(0, import_private_selectors.getParentSectionBlock)(state, clientId);
-  const isContentRoleBlock = isContentBlock(
-    getBlockName(state, clientId)
-  );
-  if (isBlockWithinSection && !isContentRoleBlock) {
-    return false;
-  }
-  const isParentSectionBlock = !!(0, import_private_selectors.isSectionBlock)(state, rootClientId);
-  const rootBlockEditingMode = getBlockEditingMode(state, rootClientId);
-  if ((isParentSectionBlock || rootBlockEditingMode === "contentOnly") && !(0, import_private_selectors.isContainerInsertableToInContentOnlyMode)(
-    state,
-    getBlockName(state, clientId),
-    rootClientId
-  )) {
-    return false;
-  }
-  return rootBlockEditingMode !== "disabled";
-}
-function canRemoveBlocks(state, clientIds) {
-  return clientIds.every((clientId) => canRemoveBlock(state, clientId));
-}
-function canMoveBlock(state, clientId) {
-  const attributes = getBlockAttributes(state, clientId);
-  if (attributes === null) {
-    return true;
-  }
-  if (attributes.lock?.move !== void 0) {
-    return !attributes.lock.move;
-  }
-  const rootClientId = getBlockRootClientId(state, clientId);
-  const rootTemplateLock = getTemplateLock(state, rootClientId);
-  if (rootTemplateLock === "all") {
-    return false;
-  }
-  const isBlockWithinSection = !!(0, import_private_selectors.getParentSectionBlock)(state, clientId);
-  const isContentRoleBlock = isContentBlock(
-    getBlockName(state, clientId)
-  );
-  if (isBlockWithinSection && !isContentRoleBlock) {
-    return false;
-  }
-  const isParentSectionBlock = !!(0, import_private_selectors.isSectionBlock)(state, rootClientId);
-  const rootBlockEditingMode = getBlockEditingMode(state, rootClientId);
-  if ((isParentSectionBlock || rootBlockEditingMode === "contentOnly") && !(0, import_private_selectors.isContainerInsertableToInContentOnlyMode)(
-    state,
-    getBlockName(state, clientId),
-    rootClientId
-  )) {
-    return false;
-  }
-  return getBlockEditingMode(state, rootClientId) !== "disabled";
-}
-function canMoveBlocks(state, clientIds) {
-  return clientIds.every((clientId) => canMoveBlock(state, clientId));
-}
-function canEditBlock(state, clientId) {
-  const attributes = getBlockAttributes(state, clientId);
-  if (attributes === null) {
-    return true;
-  }
-  const { lock } = attributes;
-  return !lock?.edit;
-}
-function canLockBlockType(state, nameOrType) {
-  if (!(0, import_blocks.hasBlockSupport)(nameOrType, "lock", true)) {
-    return false;
-  }
-  return !!state.settings?.canLockBlocks;
-}
-function getInsertUsage(state, id) {
-  return state.preferences.insertUsage?.[id] ?? null;
-}
-var canIncludeBlockTypeInInserter = (state, blockType, rootClientId) => {
-  if (!(0, import_blocks.hasBlockSupport)(blockType, "inserter", true)) {
-    return false;
-  }
-  return canInsertBlockTypeUnmemoized(state, blockType.name, rootClientId);
-};
-var getItemFromVariation = (state, item) => (variation) => {
-  const variationId = `${item.id}/${variation.name}`;
-  const { time, count = 0 } = getInsertUsage(state, variationId) || {};
-  return {
-    ...item,
-    id: variationId,
-    icon: variation.icon || item.icon,
-    title: variation.title || item.title,
-    description: variation.description || item.description,
-    category: variation.category || item.category,
-    // If `example` is explicitly undefined for the variation, the preview will not be shown.
-    example: variation.hasOwnProperty("example") ? variation.example : item.example,
-    initialAttributes: {
-      ...item.initialAttributes,
-      ...variation.attributes
-    },
-    innerBlocks: variation.innerBlocks,
-    keywords: variation.keywords || item.keywords,
-    frecency: calculateFrecency(time, count)
-  };
-};
-var calculateFrecency = (time, count) => {
-  if (!time) {
-    return count;
-  }
-  const duration = Date.now() - time;
-  switch (true) {
-    case duration < MILLISECONDS_PER_HOUR:
-      return count * 4;
-    case duration < MILLISECONDS_PER_DAY:
-      return count * 2;
-    case duration < MILLISECONDS_PER_WEEK:
-      return count / 2;
-    default:
-      return count / 4;
-  }
-};
-var buildBlockTypeItem = (state, { buildScope = "inserter" }) => (blockType) => {
-  const id = blockType.name;
-  let isDisabled = false;
-  if (!(0, import_blocks.hasBlockSupport)(blockType.name, "multiple", true)) {
-    isDisabled = getBlocksByClientId(
-      state,
-      getClientIdsWithDescendants(state)
-    ).some(({ name }) => name === blockType.name);
-  }
-  const { time, count = 0 } = getInsertUsage(state, id) || {};
-  const blockItemBase = {
-    id,
-    name: blockType.name,
-    title: blockType.title,
-    icon: blockType.icon,
-    isDisabled,
-    frecency: calculateFrecency(time, count)
-  };
-  if (buildScope === "transform") {
-    return blockItemBase;
-  }
-  const inserterVariations = (0, import_blocks.getBlockVariations)(
-    blockType.name,
-    "inserter"
-  );
-  return {
-    ...blockItemBase,
-    initialAttributes: {},
-    description: blockType.description,
-    category: blockType.category,
-    keywords: blockType.keywords,
-    parent: blockType.parent,
-    ancestor: blockType.ancestor,
-    variations: inserterVariations,
-    example: blockType.example,
-    utility: 1
-    // Deprecated.
-  };
-};
-var getInserterItems = (0, import_data.createRegistrySelector)(
-  (select) => (0, import_data.createSelector)(
-    (state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) => {
-      const buildReusableBlockInserterItem = (reusableBlock) => {
-        const icon = !reusableBlock.wp_pattern_sync_status ? {
-          src: import_icons.symbol,
-          foreground: "var(--wp-block-synced-color)"
-        } : import_icons.symbol;
-        const userPattern = (0, import_utils.mapUserPattern)(reusableBlock);
-        const { time, count = 0 } = getInsertUsage(state, userPattern.name) || {};
-        const frecency = calculateFrecency(time, count);
-        return {
-          id: userPattern.name,
-          name: "core/block",
-          initialAttributes: { ref: reusableBlock.id },
-          title: userPattern.title,
-          icon,
-          category: "reusable",
-          keywords: ["reusable"],
-          isDisabled: false,
-          utility: 1,
-          // Deprecated.
-          frecency,
-          content: userPattern.content,
-          get blocks() {
-            return (0, import_utils.getParsedPattern)(userPattern).blocks;
-          },
-          syncStatus: userPattern.syncStatus
-        };
-      };
-      const patternInserterItems = canInsertBlockTypeUnmemoized(
-        state,
-        "core/block",
-        rootClientId
-      ) ? (0, import_lock_unlock.unlock)(select(import_constants.STORE_NAME)).getReusableBlocks().map(buildReusableBlockInserterItem) : [];
-      const buildBlockTypeInserterItem = buildBlockTypeItem(state, {
-        buildScope: "inserter"
-      });
-      let blockTypeInserterItems = (0, import_blocks.getBlockTypes)().filter(
-        (blockType) => (0, import_blocks.hasBlockSupport)(blockType, "inserter", true)
-      ).map(buildBlockTypeInserterItem);
-      if (options[import_utils.isFiltered] !== false) {
-        blockTypeInserterItems = blockTypeInserterItems.filter(
-          (blockType) => canIncludeBlockTypeInInserter(
-            state,
-            blockType,
-            rootClientId
-          )
-        );
-      } else {
-        blockTypeInserterItems = blockTypeInserterItems.filter(
-          (blockType) => isBlockVisibleInTheInserter(
-            state,
-            blockType,
-            rootClientId
-          )
-        ).map((blockType) => ({
-          ...blockType,
-          isAllowedInCurrentRoot: canIncludeBlockTypeInInserter(
-            state,
-            blockType,
-            rootClientId
-          )
-        }));
-      }
-      const stretchVariations = [];
-      const items = blockTypeInserterItems.reduce(
-        (accumulator, item) => {
-          const { variations = [] } = item;
-          if (!variations.some(({ isDefault }) => isDefault)) {
-            accumulator.push(item);
-          }
-          if (variations.length) {
-            const variationMapper = getItemFromVariation(
-              state,
-              item
-            );
-            variations.map(variationMapper).forEach((variation) => {
-              if (variation.id === "core/paragraph/stretchy-paragraph" || variation.id === "core/heading/stretchy-heading") {
-                stretchVariations.push(variation);
-              } else {
-                accumulator.push(variation);
-              }
-            });
-          }
-          return accumulator;
-        },
-        []
-      );
-      items.push(...stretchVariations);
-      const groupByType = (blocks, block) => {
-        const { core, noncore } = blocks;
-        const type = block.name.startsWith("core/") ? core : noncore;
-        type.push(block);
-        return blocks;
-      };
-      const { core: coreItems, noncore: nonCoreItems } = items.reduce(
-        groupByType,
-        { core: [], noncore: [] }
-      );
-      const sortedBlockTypes = [...coreItems, ...nonCoreItems];
-      return [...sortedBlockTypes, ...patternInserterItems];
-    },
-    (state, rootClientId) => [
-      (0, import_blocks.getBlockTypes)(),
-      (0, import_lock_unlock.unlock)(select(import_constants.STORE_NAME)).getReusableBlocks(),
-      state.blocks.order,
-      state.preferences.insertUsage,
-      ...(0, import_utils.getInsertBlockTypeDependants)(select)(state, rootClientId)
-    ]
-  )
-);
-var getBlockTransformItems = (0, import_data.createRegistrySelector)(
-  (select) => (0, import_data.createSelector)(
-    (state, blocks, rootClientId = null) => {
-      const normalizedBlocks = Array.isArray(blocks) ? blocks : [blocks];
-      const buildBlockTypeTransformItem = buildBlockTypeItem(state, {
-        buildScope: "transform"
-      });
-      const blockTypeTransformItems = (0, import_blocks.getBlockTypes)().filter(
-        (blockType) => canIncludeBlockTypeInInserter(
-          state,
-          blockType,
-          rootClientId
-        )
-      ).map(buildBlockTypeTransformItem);
-      const itemsByName = Object.fromEntries(
-        Object.entries(blockTypeTransformItems).map(
-          ([, value]) => [value.name, value]
-        )
-      );
-      const possibleTransforms = (0, import_blocks.getPossibleBlockTransformations)(
-        normalizedBlocks
-      ).reduce((accumulator, block) => {
-        if (itemsByName[block?.name]) {
-          accumulator.push(itemsByName[block.name]);
-        }
-        return accumulator;
-      }, []);
-      return (0, import_sorting.orderBy)(
-        possibleTransforms,
-        (block) => itemsByName[block.name].frecency,
-        "desc"
-      );
-    },
-    (state, blocks, rootClientId) => [
-      (0, import_blocks.getBlockTypes)(),
-      state.preferences.insertUsage,
-      ...(0, import_utils.getInsertBlockTypeDependants)(select)(state, rootClientId)
-    ]
-  )
-);
-var hasInserterItems = (state, rootClientId = null) => {
-  const hasBlockType = (0, import_blocks.getBlockTypes)().some(
-    (blockType) => canIncludeBlockTypeInInserter(state, blockType, rootClientId)
-  );
-  if (hasBlockType) {
-    return true;
-  }
-  const hasReusableBlock = canInsertBlockTypeUnmemoized(
-    state,
-    "core/block",
-    rootClientId
-  );
-  return hasReusableBlock;
-};
-var getAllowedBlocks = (0, import_data.createRegistrySelector)(
-  (select) => (0, import_data.createSelector)(
-    (state, rootClientId = null) => {
-      if (!rootClientId) {
-        return;
-      }
-      const blockTypes = (0, import_blocks.getBlockTypes)().filter(
-        (blockType) => canIncludeBlockTypeInInserter(state, blockType, rootClientId)
-      );
-      const hasReusableBlock = canInsertBlockTypeUnmemoized(
-        state,
-        "core/block",
-        rootClientId
-      );
-      if (hasReusableBlock) {
-        blockTypes.push("core/block");
-      }
-      return blockTypes;
-    },
-    (state, rootClientId) => [
-      (0, import_blocks.getBlockTypes)(),
-      ...(0, import_utils.getInsertBlockTypeDependants)(select)(state, rootClientId)
-    ]
-  )
-);
-var __experimentalGetAllowedBlocks = (0, import_data.createSelector)(
-  (state, rootClientId = null) => {
-    (0, import_deprecated.default)(
-      'wp.data.select( "core/block-editor" ).__experimentalGetAllowedBlocks',
-      {
-        alternative: 'wp.data.select( "core/block-editor" ).getAllowedBlocks',
-        since: "6.2",
-        version: "6.4"
-      }
-    );
-    return getAllowedBlocks(state, rootClientId);
-  },
-  (state, rootClientId) => getAllowedBlocks.getDependants(state, rootClientId)
-);
-function getDirectInsertBlock(state, rootClientId = null) {
-  if (!rootClientId) {
-    return;
-  }
-  const { defaultBlock, directInsert } = state.blockListSettings[rootClientId] ?? {};
-  if (!defaultBlock || !directInsert) {
-    return;
-  }
-  return defaultBlock;
-}
-function __experimentalGetDirectInsertBlock(state, rootClientId = null) {
-  (0, import_deprecated.default)(
-    'wp.data.select( "core/block-editor" ).__experimentalGetDirectInsertBlock',
-    {
-      alternative: 'wp.data.select( "core/block-editor" ).getDirectInsertBlock',
-      since: "6.3",
-      version: "6.4"
-    }
-  );
-  return getDirectInsertBlock(state, rootClientId);
-}
-var __experimentalGetParsedPattern = (0, import_data.createRegistrySelector)(
-  (select) => (state, patternName) => {
-    const pattern = (0, import_lock_unlock.unlock)(select(import_constants.STORE_NAME)).getPatternBySlug(
-      patternName
-    );
-    return pattern ? (0, import_utils.getParsedPattern)(pattern) : null;
-  }
-);
-var getAllowedPatternsDependants = (select) => (state, rootClientId) => [
-  ...(0, import_utils.getAllPatternsDependants)(select)(state),
-  ...(0, import_utils.getInsertBlockTypeDependants)(select)(state, rootClientId)
-];
-var patternsWithParsedBlocks = /* @__PURE__ */ new WeakMap();
-function enhancePatternWithParsedBlocks(pattern) {
-  let enhancedPattern = patternsWithParsedBlocks.get(pattern);
-  if (!enhancedPattern) {
-    enhancedPattern = {
-      ...pattern,
-      get blocks() {
-        return (0, import_utils.getParsedPattern)(pattern).blocks;
-      }
-    };
-    patternsWithParsedBlocks.set(pattern, enhancedPattern);
-  }
-  return enhancedPattern;
-}
-var __experimentalGetAllowedPatterns = (0, import_data.createRegistrySelector)(
-  (select) => {
-    return (0, import_data.createSelector)(
-      (state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) => {
-        const { getAllPatterns } = (0, import_lock_unlock.unlock)(select(import_constants.STORE_NAME));
-        const patterns = getAllPatterns();
-        const { allowedBlockTypes } = getSettings(state);
-        const parsedPatterns = patterns.filter(({ inserter = true }) => !!inserter).map(enhancePatternWithParsedBlocks);
-        const availableParsedPatterns = parsedPatterns.filter(
-          (pattern) => (0, import_utils.checkAllowListRecursive)(
-            (0, import_utils.getGrammar)(pattern),
-            allowedBlockTypes
-          )
-        );
-        const patternsAllowed = availableParsedPatterns.filter(
-          (pattern) => (0, import_utils.getGrammar)(pattern).every(
-            ({ blockName: name }) => options[import_utils.isFiltered] !== false ? canInsertBlockType(
-              state,
-              name,
-              rootClientId
-            ) : isBlockVisibleInTheInserter(
-              state,
-              name,
-              rootClientId
-            )
-          )
-        );
-        return patternsAllowed;
-      },
-      getAllowedPatternsDependants(select)
-    );
-  }
-);
-var getPatternsByBlockTypes = (0, import_data.createRegistrySelector)(
-  (select) => (0, import_data.createSelector)(
-    (state, blockNames, rootClientId = null) => {
-      if (!blockNames) {
-        return EMPTY_ARRAY;
-      }
-      const patterns = select(import_constants.STORE_NAME).__experimentalGetAllowedPatterns(
-        rootClientId
-      );
-      const normalizedBlockNames = Array.isArray(blockNames) ? blockNames : [blockNames];
-      const filteredPatterns = patterns.filter(
-        (pattern) => pattern?.blockTypes?.some?.(
-          (blockName) => normalizedBlockNames.includes(blockName)
-        )
-      );
-      if (filteredPatterns.length === 0) {
-        return EMPTY_ARRAY;
-      }
-      return filteredPatterns;
-    },
-    (state, blockNames, rootClientId) => getAllowedPatternsDependants(select)(state, rootClientId)
-  )
-);
-var __experimentalGetPatternsByBlockTypes = (0, import_data.createRegistrySelector)(
-  (select) => {
-    (0, import_deprecated.default)(
-      'wp.data.select( "core/block-editor" ).__experimentalGetPatternsByBlockTypes',
-      {
-        alternative: 'wp.data.select( "core/block-editor" ).getPatternsByBlockTypes',
-        since: "6.2",
-        version: "6.4"
-      }
-    );
-    return select(import_constants.STORE_NAME).getPatternsByBlockTypes;
-  }
-);
-var __experimentalGetPatternTransformItems = (0, import_data.createRegistrySelector)(
-  (select) => (0, import_data.createSelector)(
-    (state, blocks, rootClientId = null) => {
-      if (!blocks) {
-        return EMPTY_ARRAY;
-      }
-      if (blocks.some(
-        ({ clientId, innerBlocks }) => innerBlocks.length || areInnerBlocksControlled(state, clientId)
-      )) {
-        return EMPTY_ARRAY;
-      }
-      const selectedBlockNames = Array.from(
-        new Set(blocks.map(({ name }) => name))
-      );
-      return select(import_constants.STORE_NAME).getPatternsByBlockTypes(
-        selectedBlockNames,
-        rootClientId
-      );
-    },
-    (state, blocks, rootClientId) => getAllowedPatternsDependants(select)(state, rootClientId)
-  )
-);
-function getBlockListSettings(state, clientId) {
-  return state.blockListSettings[clientId];
-}
-function getSettings(state) {
-  return state.settings;
-}
-function isLastBlockChangePersistent(state) {
-  return state.blocks.isPersistentChange;
-}
-var __experimentalGetBlockListSettingsForBlocks = (0, import_data.createSelector)(
-  (state, clientIds = []) => {
-    return clientIds.reduce((blockListSettingsForBlocks, clientId) => {
-      if (!state.blockListSettings[clientId]) {
-        return blockListSettingsForBlocks;
-      }
-      return {
-        ...blockListSettingsForBlocks,
-        [clientId]: state.blockListSettings[clientId]
-      };
-    }, {});
-  },
-  (state) => [state.blockListSettings]
-);
-var __experimentalGetReusableBlockTitle = (0, import_data.createRegistrySelector)(
-  (select) => (0, import_data.createSelector)(
-    (state, ref) => {
-      (0, import_deprecated.default)(
-        "wp.data.select( 'core/block-editor' ).__experimentalGetReusableBlockTitle",
-        {
-          since: "6.6",
-          version: "6.8"
-        }
-      );
-      const reusableBlock = (0, import_lock_unlock.unlock)(select(import_constants.STORE_NAME)).getReusableBlocks().find((block) => block.id === ref);
-      if (!reusableBlock) {
-        return null;
-      }
-      return reusableBlock.title?.raw;
-    },
-    () => [(0, import_lock_unlock.unlock)(select(import_constants.STORE_NAME)).getReusableBlocks()]
-  )
-);
-function __unstableIsLastBlockChangeIgnored(state) {
-  return state.blocks.isIgnoredChange;
-}
-function __experimentalGetLastBlockAttributeChanges(state) {
-  return state.lastBlockAttributesChange;
-}
-function hasBlockMovingClientId() {
-  (0, import_deprecated.default)(
-    'wp.data.select( "core/block-editor" ).hasBlockMovingClientId',
-    {
-      since: "6.7",
-      hint: "Block moving mode feature has been removed"
-    }
-  );
-  return false;
-}
-function didAutomaticChange(state) {
-  return !!state.automaticChangeStatus;
-}
-function isBlockHighlighted(state, clientId) {
-  return state.highlightedBlock === clientId;
-}
-function areInnerBlocksControlled(state, clientId) {
-  return !!state.blocks.controlledInnerBlocks[clientId];
-}
-var __experimentalGetActiveBlockIdByBlockNames = (0, import_data.createSelector)(
-  (state, validBlockNames) => {
-    if (!validBlockNames.length) {
-      return null;
-    }
-    const selectedBlockClientId = getSelectedBlockClientId(state);
-    if (validBlockNames.includes(
-      getBlockName(state, selectedBlockClientId)
-    )) {
-      return selectedBlockClientId;
-    }
-    const multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state);
-    const entityAreaParents = getBlockParentsByBlockName(
-      state,
-      selectedBlockClientId || multiSelectedBlockClientIds[0],
-      validBlockNames
-    );
-    if (entityAreaParents) {
-      return entityAreaParents[entityAreaParents.length - 1];
-    }
-    return null;
-  },
-  (state, validBlockNames) => [
-    state.selection.selectionStart.clientId,
-    state.selection.selectionEnd.clientId,
-    validBlockNames
-  ]
-);
-function wasBlockJustInserted(state, clientId, source) {
-  const { lastBlockInserted } = state;
-  return lastBlockInserted.clientIds?.includes(clientId) && lastBlockInserted.source === source;
-}
-function isBlockVisible(state, clientId) {
-  return state.blockVisibility?.[clientId] ?? true;
-}
-function getHoveredBlockClientId() {
-  (0, import_deprecated.default)(
-    "wp.data.select( 'core/block-editor' ).getHoveredBlockClientId",
-    {
-      since: "6.9",
-      version: "7.1"
-    }
-  );
-  return void 0;
-}
-var __unstableGetVisibleBlocks = (0, import_data.createSelector)(
-  (state) => {
-    const visibleBlocks = new Set(
-      Object.keys(state.blockVisibility).filter(
-        (key) => state.blockVisibility[key]
-      )
-    );
-    if (visibleBlocks.size === 0) {
-      return EMPTY_SET;
-    }
-    return visibleBlocks;
-  },
-  (state) => [state.blockVisibility]
-);
-function __unstableHasActiveBlockOverlayActive(state, clientId) {
-  if (getBlockEditingMode(state, clientId) !== "default") {
-    return false;
-  }
-  if (!canEditBlock(state, clientId)) {
-    return true;
-  }
-  if ((0, import_private_selectors.isZoomOut)(state)) {
-    const sectionRootClientId = (0, import_private_selectors.getSectionRootClientId)(state);
-    if (sectionRootClientId) {
-      const sectionClientIds = getBlockOrder(
-        state,
-        sectionRootClientId
-      );
-      if (sectionClientIds?.includes(clientId)) {
-        return true;
-      }
-    } else if (clientId && !getBlockRootClientId(state, clientId)) {
-      return true;
-    }
-  }
-  const blockSupportDisable = (0, import_blocks.hasBlockSupport)(
-    getBlockName(state, clientId),
-    "__experimentalDisableBlockOverlay",
-    false
-  );
-  const shouldEnableIfUnselected = blockSupportDisable ? false : areInnerBlocksControlled(state, clientId);
-  return shouldEnableIfUnselected && !isBlockSelected(state, clientId) && !hasSelectedInnerBlock(state, clientId, true);
-}
-function __unstableIsWithinBlockOverlay(state, clientId) {
-  let parent = state.blocks.parents.get(clientId);
-  while (!!parent) {
-    if (__unstableHasActiveBlockOverlayActive(state, parent)) {
-      return true;
-    }
-    parent = state.blocks.parents.get(parent);
-  }
-  return false;
-}
-function getBlockEditingMode(state, clientId = "") {
-  if (clientId === null) {
-    clientId = "";
-  }
-  if (state.derivedBlockEditingModes?.has(clientId)) {
-    return state.derivedBlockEditingModes.get(clientId);
-  }
-  if (state.blockEditingModes.has(clientId)) {
-    return state.blockEditingModes.get(clientId);
-  }
-  return "default";
-}
-var isUngroupable = (0, import_data.createRegistrySelector)(
-  (select) => (state, clientId = "") => {
-    const _clientId = clientId || getSelectedBlockClientId(state);
-    if (!_clientId) {
-      return false;
-    }
-    if ((0, import_private_selectors.isSectionBlock)(state, _clientId)) {
-      return false;
-    }
-    const { getGroupingBlockName } = select(import_blocks.store);
-    const block = getBlock(state, _clientId);
-    const groupingBlockName = getGroupingBlockName();
-    const _isUngroupable = block && (block.name === groupingBlockName || (0, import_blocks.getBlockType)(block.name)?.transforms?.ungroup) && !!block.innerBlocks.length;
-    return _isUngroupable && canRemoveBlock(state, _clientId);
-  }
-);
-var isGroupable = (0, import_data.createRegistrySelector)(
-  (select) => (state, clientIds = EMPTY_ARRAY) => {
-    const { getGroupingBlockName } = select(import_blocks.store);
-    const groupingBlockName = getGroupingBlockName();
-    const _clientIds = clientIds?.length ? clientIds : getSelectedBlockClientIds(state);
-    const rootClientId = _clientIds?.length ? getBlockRootClientId(state, _clientIds[0]) : void 0;
-    const groupingBlockAvailable = canInsertBlockType(
-      state,
-      groupingBlockName,
-      rootClientId
-    );
-    const _isGroupable = groupingBlockAvailable && _clientIds.length;
-    return _isGroupable && canRemoveBlocks(state, _clientIds);
-  }
-);
-var __unstableGetContentLockingParent = (state, clientId) => {
-  (0, import_deprecated.default)(
-    "wp.data.select( 'core/block-editor' ).__unstableGetContentLockingParent",
-    {
-      since: "6.1",
-      version: "6.7"
-    }
-  );
-  return (0, import_private_selectors.getContentLockingParent)(state, clientId);
-};
-function __unstableGetTemporarilyEditingAsBlocks(state) {
-  (0, import_deprecated.default)(
-    "wp.data.select( 'core/block-editor' ).__unstableGetTemporarilyEditingAsBlocks",
-    {
-      since: "6.1",
-      version: "6.7"
-    }
-  );
-  return (0, import_private_selectors.getEditedContentOnlySection)(state);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  __experimentalGetActiveBlockIdByBlockNames,
-  __experimentalGetAllowedBlocks,
-  __experimentalGetAllowedPatterns,
-  __experimentalGetBlockListSettingsForBlocks,
-  __experimentalGetDirectInsertBlock,
-  __experimentalGetGlobalBlocksByName,
-  __experimentalGetLastBlockAttributeChanges,
-  __experimentalGetParsedPattern,
-  __experimentalGetPatternTransformItems,
-  __experimentalGetPatternsByBlockTypes,
-  __experimentalGetReusableBlockTitle,
-  __unstableGetBlockWithoutInnerBlocks,
-  __unstableGetClientIdWithClientIdsTree,
-  __unstableGetClientIdsTree,
-  __unstableGetContentLockingParent,
-  __unstableGetSelectedBlocksWithPartialSelection,
-  __unstableGetTemporarilyEditingAsBlocks,
-  __unstableGetVisibleBlocks,
-  __unstableHasActiveBlockOverlayActive,
-  __unstableIsFullySelected,
-  __unstableIsLastBlockChangeIgnored,
-  __unstableIsSelectionCollapsed,
-  __unstableIsSelectionMergeable,
-  __unstableIsWithinBlockOverlay,
-  __unstableSelectionHasUnmergeableBlock,
-  areInnerBlocksControlled,
-  canEditBlock,
-  canInsertBlockType,
-  canInsertBlocks,
-  canLockBlockType,
-  canMoveBlock,
-  canMoveBlocks,
-  canRemoveBlock,
-  canRemoveBlocks,
-  didAutomaticChange,
-  getAdjacentBlockClientId,
-  getAllowedBlocks,
-  getBlock,
-  getBlockAttributes,
-  getBlockCount,
-  getBlockEditingMode,
-  getBlockHierarchyRootClientId,
-  getBlockIndex,
-  getBlockInsertionPoint,
-  getBlockListSettings,
-  getBlockMode,
-  getBlockName,
-  getBlockNamesByClientId,
-  getBlockOrder,
-  getBlockParents,
-  getBlockParentsByBlockName,
-  getBlockRootClientId,
-  getBlockSelectionEnd,
-  getBlockSelectionStart,
-  getBlockTransformItems,
-  getBlocks,
-  getBlocksByClientId,
-  getBlocksByName,
-  getClientIdsOfDescendants,
-  getClientIdsWithDescendants,
-  getDirectInsertBlock,
-  getDraggedBlockClientIds,
-  getFirstMultiSelectedBlockClientId,
-  getGlobalBlockCount,
-  getHoveredBlockClientId,
-  getInserterItems,
-  getLastMultiSelectedBlockClientId,
-  getLowestCommonAncestorWithSelectedBlock,
-  getMultiSelectedBlockClientIds,
-  getMultiSelectedBlocks,
-  getMultiSelectedBlocksEndClientId,
-  getMultiSelectedBlocksStartClientId,
-  getNextBlockClientId,
-  getPatternsByBlockTypes,
-  getPreviousBlockClientId,
-  getSelectedBlock,
-  getSelectedBlockClientId,
-  getSelectedBlockClientIds,
-  getSelectedBlockCount,
-  getSelectedBlocksInitialCaretPosition,
-  getSelectionEnd,
-  getSelectionStart,
-  getSettings,
-  getTemplate,
-  getTemplateLock,
-  hasBlockMovingClientId,
-  hasDraggedInnerBlock,
-  hasInserterItems,
-  hasMultiSelection,
-  hasSelectedBlock,
-  hasSelectedInnerBlock,
-  isAncestorBeingDragged,
-  isAncestorMultiSelected,
-  isBlockBeingDragged,
-  isBlockHighlighted,
-  isBlockInsertionPointVisible,
-  isBlockMultiSelected,
-  isBlockSelected,
-  isBlockValid,
-  isBlockVisible,
-  isBlockWithinSelection,
-  isCaretWithinFormattedText,
-  isDraggingBlocks,
-  isFirstMultiSelectedBlock,
-  isGroupable,
-  isLastBlockChangePersistent,
-  isMultiSelecting,
-  isSelectionEnabled,
-  isTyping,
-  isUngroupable,
-  isValidTemplate,
-  wasBlockJustInserted
-});
-//# sourceMappingURL=selectors.js.map