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

package/build/store/selectors.cjs

@@ -0,0 +1,1814 @@
+"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"), 1);
+var import_data = require("@wordpress/data");
+var import_utils = require("./utils.cjs");
+var import_sorting = require("../utils/sorting.cjs");
+var import_constants = require("./constants.cjs");
+var import_lock_unlock = require("../lock-unlock.cjs");
+var import_private_selectors = require("./private-selectors.cjs");
+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),
+    // 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 (!(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"
+  );
+  const blockVariations = (0, import_blocks.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 = (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 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) => [
+      (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.cjs.map