@wordpress/block-editor 15.9.1-next.8fd3f8831.0 → 15.10.1-next.79a2f3cdd.0

package/build-module/store/selectors.mjs

@@ -0,0 +1,1694 @@
+// packages/block-editor/src/store/selectors.js
+import {
+  getBlockType,
+  getBlockTypes,
+  getBlockVariations,
+  hasBlockSupport,
+  getPossibleBlockTransformations,
+  switchToBlockType,
+  store as blocksStore,
+  privateApis as blocksPrivateApis
+} from "@wordpress/blocks";
+import { Platform } from "@wordpress/element";
+import { applyFilters } from "@wordpress/hooks";
+import { symbol } from "@wordpress/icons";
+import { create, remove, toHTMLString } from "@wordpress/rich-text";
+import deprecated from "@wordpress/deprecated";
+import { createSelector, createRegistrySelector } from "@wordpress/data";
+import {
+  isFiltered,
+  checkAllowListRecursive,
+  checkAllowList,
+  getAllPatternsDependants,
+  getInsertBlockTypeDependants,
+  getParsedPattern,
+  getGrammar,
+  mapUserPattern
+} from "./utils.mjs";
+import { orderBy } from "../utils/sorting.mjs";
+import { STORE_NAME } from "./constants.mjs";
+import { unlock } from "../lock-unlock.mjs";
+import {
+  getContentLockingParent,
+  getEditedContentOnlySection,
+  getSectionRootClientId,
+  isSectionBlock,
+  getParentSectionBlock,
+  isZoomOut,
+  isContainerInsertableToInContentOnlyMode
+} from "./private-selectors.mjs";
+var { isContentBlock } = unlock(blocksPrivateApis);
+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 = {
+  [isFiltered]: true
+};
+function getBlockName(state, clientId) {
+  const block = state.blocks.byClientId.get(clientId);
+  const socialLinkName = "core/social-link";
+  if (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 = 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 = createSelector(
+  (state, clientId) => {
+    deprecated(
+      "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 = createSelector(
+  (state, rootClientId = "") => {
+    deprecated(
+      "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 = 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 = 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 = 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) {
+  deprecated(
+    "wp.data.select( 'core/block-editor' ).__experimentalGetGlobalBlocksByName",
+    {
+      since: "6.5",
+      alternative: `wp.data.select( 'core/block-editor' ).getBlocksByName`
+    }
+  );
+  return getBlocksByName(state, blockName);
+}
+var getBlocksByClientId = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = getBlockType(targetBlockName);
+  if (!targetBlockType.merge) {
+    return false;
+  }
+  const blockToMerge = getBlock(state, blockToMergeClientId);
+  if (blockToMerge.name === targetBlockName) {
+    return true;
+  }
+  const blocksToMerge = 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 = create({ html: htmlA });
+  let valueB = create({ html: htmlB });
+  valueA = remove(valueA, 0, selectionStart.offset);
+  valueB = remove(valueB, selectionEnd.offset, valueB.text.length);
+  return [
+    {
+      ...blockA,
+      attributes: {
+        ...blockA.attributes,
+        [selectionStart.attributeKey]: toHTMLString({
+          value: valueA
+        })
+      }
+    },
+    {
+      ...blockB,
+      attributes: {
+        ...blockB.attributes,
+        [selectionEnd.attributeKey]: 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() {
+  deprecated(
+    'wp.data.select( "core/block-editor" ).isCaretWithinFormattedText',
+    {
+      since: "6.1",
+      version: "6.3"
+    }
+  );
+  return false;
+}
+var getBlockInsertionPoint = 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 = getBlockType(blockNameOrType);
+    blockName = blockNameOrType;
+  }
+  if (!blockType) {
+    return false;
+  }
+  const { allowedBlockTypes } = getSettings(state);
+  const isBlockAllowedInEditor = 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 = 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 = !!isSectionBlock(state, rootClientId);
+  const isBlockWithinSection = !!getParentSectionBlock(
+    state,
+    rootClientId
+  );
+  if ((isParentSectionBlock || isBlockWithinSection) && !isContentRoleBlock) {
+    return false;
+  }
+  if ((isParentSectionBlock || blockEditingMode === "contentOnly") && !isContainerInsertableToInContentOnlyMode(
+    state,
+    blockName,
+    rootClientId
+  )) {
+    return false;
+  }
+  const parentName = getBlockName(state, rootClientId);
+  const parentBlockType = getBlockType(parentName);
+  const parentAllowedChildBlocks = parentBlockType?.allowedBlocks;
+  let hasParentAllowedBlock = checkAllowList(
+    parentAllowedChildBlocks,
+    blockName
+  );
+  if (hasParentAllowedBlock !== false) {
+    const parentAllowedBlocks = parentBlockListSettings?.allowedBlocks;
+    const hasParentListAllowedBlock = checkAllowList(
+      parentAllowedBlocks,
+      blockName
+    );
+    if (hasParentListAllowedBlock !== null) {
+      hasParentAllowedBlock = hasParentListAllowedBlock;
+    }
+  }
+  const blockAllowedParentBlocks = blockType.parent;
+  const hasBlockAllowedParent = checkAllowList(
+    blockAllowedParentBlocks,
+    parentName
+  );
+  let hasBlockAllowedAncestor = true;
+  const blockAllowedAncestorBlocks = blockType.ancestor;
+  if (blockAllowedAncestorBlocks) {
+    const ancestors = [
+      rootClientId,
+      ...getBlockParents(state, rootClientId)
+    ];
+    hasBlockAllowedAncestor = ancestors.some(
+      (ancestorClientId) => checkAllowList(
+        blockAllowedAncestorBlocks,
+        getBlockName(state, ancestorClientId)
+      )
+    );
+  }
+  const canInsert = hasBlockAllowedAncestor && (hasParentAllowedBlock === null && hasBlockAllowedParent === null || hasParentAllowedBlock === true || hasBlockAllowedParent === true);
+  if (!canInsert) {
+    return canInsert;
+  }
+  return 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 = createRegistrySelector(
+  (select) => createSelector(
+    canInsertBlockTypeUnmemoized,
+    (state, blockName, rootClientId) => 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 = !!getParentSectionBlock(state, clientId);
+  const isContentRoleBlock = isContentBlock(
+    getBlockName(state, clientId)
+  );
+  if (isBlockWithinSection && !isContentRoleBlock) {
+    return false;
+  }
+  const isParentSectionBlock = !!isSectionBlock(state, rootClientId);
+  const rootBlockEditingMode = getBlockEditingMode(state, rootClientId);
+  if ((isParentSectionBlock || rootBlockEditingMode === "contentOnly") && !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 = !!getParentSectionBlock(state, clientId);
+  const isContentRoleBlock = isContentBlock(
+    getBlockName(state, clientId)
+  );
+  if (isBlockWithinSection && !isContentRoleBlock) {
+    return false;
+  }
+  const isParentSectionBlock = !!isSectionBlock(state, rootClientId);
+  const rootBlockEditingMode = getBlockEditingMode(state, rootClientId);
+  if ((isParentSectionBlock || rootBlockEditingMode === "contentOnly") && !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 (!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 (!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),
+    // Pass through search-only flag for block-scope variations.
+    isSearchOnly: variation.isSearchOnly
+  };
+};
+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 (!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 = getBlockVariations(
+    blockType.name,
+    "inserter"
+  );
+  const blockVariations = getBlockVariations(blockType.name, "block");
+  const inserterVariationNames = new Set(
+    inserterVariations.map((variation) => variation.name)
+  );
+  const allVariations = [
+    ...inserterVariations,
+    ...blockVariations.filter(
+      (variation) => !inserterVariationNames.has(variation.name)
+    ).map((variation) => ({
+      ...variation,
+      isSearchOnly: true,
+      // Block-scope `isDefault` is for the placeholder picker,
+      // not for the inserter, so don't carry it over.
+      isDefault: false
+    }))
+  ];
+  return {
+    ...blockItemBase,
+    initialAttributes: {},
+    description: blockType.description,
+    category: blockType.category,
+    keywords: blockType.keywords,
+    parent: blockType.parent,
+    ancestor: blockType.ancestor,
+    variations: allVariations,
+    example: blockType.example,
+    utility: 1
+    // Deprecated.
+  };
+};
+var getInserterItems = createRegistrySelector(
+  (select) => createSelector(
+    (state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) => {
+      const buildReusableBlockInserterItem = (reusableBlock) => {
+        const icon = !reusableBlock.wp_pattern_sync_status ? {
+          src: symbol,
+          foreground: "var(--wp-block-synced-color)"
+        } : symbol;
+        const userPattern = 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 getParsedPattern(userPattern).blocks;
+          },
+          syncStatus: userPattern.syncStatus
+        };
+      };
+      const patternInserterItems = canInsertBlockTypeUnmemoized(
+        state,
+        "core/block",
+        rootClientId
+      ) ? unlock(select(STORE_NAME)).getReusableBlocks().map(buildReusableBlockInserterItem) : [];
+      const buildBlockTypeInserterItem = buildBlockTypeItem(state, {
+        buildScope: "inserter"
+      });
+      let blockTypeInserterItems = getBlockTypes().filter(
+        (blockType) => hasBlockSupport(blockType, "inserter", true)
+      ).map(buildBlockTypeInserterItem);
+      if (options[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 items = blockTypeInserterItems.reduce(
+        (accumulator, item) => {
+          const { variations = [] } = item;
+          if (!variations.some(({ isDefault }) => isDefault)) {
+            accumulator.push(item);
+          }
+          if (variations.length) {
+            const variationMapper = getItemFromVariation(
+              state,
+              item
+            );
+            accumulator.push(
+              ...variations.map(variationMapper)
+            );
+          }
+          return accumulator;
+        },
+        []
+      );
+      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) => [
+      getBlockTypes(),
+      unlock(select(STORE_NAME)).getReusableBlocks(),
+      state.blocks.order,
+      state.preferences.insertUsage,
+      ...getInsertBlockTypeDependants(select)(state, rootClientId)
+    ]
+  )
+);
+var getBlockTransformItems = createRegistrySelector(
+  (select) => createSelector(
+    (state, blocks, rootClientId = null) => {
+      const normalizedBlocks = Array.isArray(blocks) ? blocks : [blocks];
+      const buildBlockTypeTransformItem = buildBlockTypeItem(state, {
+        buildScope: "transform"
+      });
+      const blockTypeTransformItems = getBlockTypes().filter(
+        (blockType) => canIncludeBlockTypeInInserter(
+          state,
+          blockType,
+          rootClientId
+        )
+      ).map(buildBlockTypeTransformItem);
+      const itemsByName = Object.fromEntries(
+        Object.entries(blockTypeTransformItems).map(
+          ([, value]) => [value.name, value]
+        )
+      );
+      const possibleTransforms = getPossibleBlockTransformations(
+        normalizedBlocks
+      ).reduce((accumulator, block) => {
+        if (itemsByName[block?.name]) {
+          accumulator.push(itemsByName[block.name]);
+        }
+        return accumulator;
+      }, []);
+      return orderBy(
+        possibleTransforms,
+        (block) => itemsByName[block.name].frecency,
+        "desc"
+      );
+    },
+    (state, blocks, rootClientId) => [
+      getBlockTypes(),
+      state.preferences.insertUsage,
+      ...getInsertBlockTypeDependants(select)(state, rootClientId)
+    ]
+  )
+);
+var hasInserterItems = (state, rootClientId = null) => {
+  const hasBlockType = getBlockTypes().some(
+    (blockType) => canIncludeBlockTypeInInserter(state, blockType, rootClientId)
+  );
+  if (hasBlockType) {
+    return true;
+  }
+  const hasReusableBlock = canInsertBlockTypeUnmemoized(
+    state,
+    "core/block",
+    rootClientId
+  );
+  return hasReusableBlock;
+};
+var getAllowedBlocks = createRegistrySelector(
+  (select) => createSelector(
+    (state, rootClientId = null) => {
+      if (!rootClientId) {
+        return;
+      }
+      const blockTypes = getBlockTypes().filter(
+        (blockType) => canIncludeBlockTypeInInserter(state, blockType, rootClientId)
+      );
+      const hasReusableBlock = canInsertBlockTypeUnmemoized(
+        state,
+        "core/block",
+        rootClientId
+      );
+      if (hasReusableBlock) {
+        blockTypes.push("core/block");
+      }
+      return blockTypes;
+    },
+    (state, rootClientId) => [
+      getBlockTypes(),
+      ...getInsertBlockTypeDependants(select)(state, rootClientId)
+    ]
+  )
+);
+var __experimentalGetAllowedBlocks = createSelector(
+  (state, rootClientId = null) => {
+    deprecated(
+      '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) {
+  deprecated(
+    '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 = createRegistrySelector(
+  (select) => (state, patternName) => {
+    const pattern = unlock(select(STORE_NAME)).getPatternBySlug(
+      patternName
+    );
+    return pattern ? getParsedPattern(pattern) : null;
+  }
+);
+var getAllowedPatternsDependants = (select) => (state, rootClientId) => [
+  ...getAllPatternsDependants(select)(state),
+  ...getInsertBlockTypeDependants(select)(state, rootClientId)
+];
+var patternsWithParsedBlocks = /* @__PURE__ */ new WeakMap();
+function enhancePatternWithParsedBlocks(pattern) {
+  let enhancedPattern = patternsWithParsedBlocks.get(pattern);
+  if (!enhancedPattern) {
+    enhancedPattern = {
+      ...pattern,
+      get blocks() {
+        return getParsedPattern(pattern).blocks;
+      }
+    };
+    patternsWithParsedBlocks.set(pattern, enhancedPattern);
+  }
+  return enhancedPattern;
+}
+var __experimentalGetAllowedPatterns = createRegistrySelector(
+  (select) => {
+    return createSelector(
+      (state, rootClientId = null, options = DEFAULT_INSERTER_OPTIONS) => {
+        const { getAllPatterns } = unlock(select(STORE_NAME));
+        const patterns = getAllPatterns();
+        const { allowedBlockTypes } = getSettings(state);
+        const parsedPatterns = patterns.filter(({ inserter = true }) => !!inserter).map(enhancePatternWithParsedBlocks);
+        const availableParsedPatterns = parsedPatterns.filter(
+          (pattern) => checkAllowListRecursive(
+            getGrammar(pattern),
+            allowedBlockTypes
+          )
+        );
+        const patternsAllowed = availableParsedPatterns.filter(
+          (pattern) => getGrammar(pattern).every(
+            ({ blockName: name }) => options[isFiltered] !== false ? canInsertBlockType(
+              state,
+              name,
+              rootClientId
+            ) : isBlockVisibleInTheInserter(
+              state,
+              name,
+              rootClientId
+            )
+          )
+        );
+        return patternsAllowed;
+      },
+      getAllowedPatternsDependants(select)
+    );
+  }
+);
+var getPatternsByBlockTypes = createRegistrySelector(
+  (select) => createSelector(
+    (state, blockNames, rootClientId = null) => {
+      if (!blockNames) {
+        return EMPTY_ARRAY;
+      }
+      const patterns = select(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 = createRegistrySelector(
+  (select) => {
+    deprecated(
+      'wp.data.select( "core/block-editor" ).__experimentalGetPatternsByBlockTypes',
+      {
+        alternative: 'wp.data.select( "core/block-editor" ).getPatternsByBlockTypes',
+        since: "6.2",
+        version: "6.4"
+      }
+    );
+    return select(STORE_NAME).getPatternsByBlockTypes;
+  }
+);
+var __experimentalGetPatternTransformItems = createRegistrySelector(
+  (select) => 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(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 = 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 = createRegistrySelector(
+  (select) => createSelector(
+    (state, ref) => {
+      deprecated(
+        "wp.data.select( 'core/block-editor' ).__experimentalGetReusableBlockTitle",
+        {
+          since: "6.6",
+          version: "6.8"
+        }
+      );
+      const reusableBlock = unlock(select(STORE_NAME)).getReusableBlocks().find((block) => block.id === ref);
+      if (!reusableBlock) {
+        return null;
+      }
+      return reusableBlock.title?.raw;
+    },
+    () => [unlock(select(STORE_NAME)).getReusableBlocks()]
+  )
+);
+function __unstableIsLastBlockChangeIgnored(state) {
+  return state.blocks.isIgnoredChange;
+}
+function __experimentalGetLastBlockAttributeChanges(state) {
+  return state.lastBlockAttributesChange;
+}
+function hasBlockMovingClientId() {
+  deprecated(
+    '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 = 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() {
+  deprecated(
+    "wp.data.select( 'core/block-editor' ).getHoveredBlockClientId",
+    {
+      since: "6.9",
+      version: "7.1"
+    }
+  );
+  return void 0;
+}
+var __unstableGetVisibleBlocks = 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 (isZoomOut(state)) {
+    const sectionRootClientId = 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 = 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 = createRegistrySelector(
+  (select) => (state, clientId = "") => {
+    const _clientId = clientId || getSelectedBlockClientId(state);
+    if (!_clientId) {
+      return false;
+    }
+    if (isSectionBlock(state, _clientId)) {
+      return false;
+    }
+    const { getGroupingBlockName } = select(blocksStore);
+    const block = getBlock(state, _clientId);
+    const groupingBlockName = getGroupingBlockName();
+    const _isUngroupable = block && (block.name === groupingBlockName || getBlockType(block.name)?.transforms?.ungroup) && !!block.innerBlocks.length;
+    return _isUngroupable && canRemoveBlock(state, _clientId);
+  }
+);
+var isGroupable = createRegistrySelector(
+  (select) => (state, clientIds = EMPTY_ARRAY) => {
+    const { getGroupingBlockName } = select(blocksStore);
+    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) => {
+  deprecated(
+    "wp.data.select( 'core/block-editor' ).__unstableGetContentLockingParent",
+    {
+      since: "6.1",
+      version: "6.7"
+    }
+  );
+  return getContentLockingParent(state, clientId);
+};
+function __unstableGetTemporarilyEditingAsBlocks(state) {
+  deprecated(
+    "wp.data.select( 'core/block-editor' ).__unstableGetTemporarilyEditingAsBlocks",
+    {
+      since: "6.1",
+      version: "6.7"
+    }
+  );
+  return getEditedContentOnlySection(state);
+}
+export {
+  __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.mjs.map