"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

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