@wordpress/block-editor 15.9.1-next.8fd3f8831.0 → 15.10.1-next.06ee73755.0

package/build-module/store/utils.mjs

@@ -0,0 +1,130 @@
+// packages/block-editor/src/store/utils.js
+import { parse } from "@wordpress/blocks";
+import { parse as grammarParse } from "@wordpress/block-serialization-default-parser";
+import { selectBlockPatternsKey } from "./private-keys.mjs";
+import { unlock } from "../lock-unlock.mjs";
+import { STORE_NAME } from "./constants.mjs";
+import { getSectionRootClientId, isSectionBlock } from "./private-selectors.mjs";
+import { getBlockEditingMode } from "./selectors.mjs";
+import { INSERTER_PATTERN_TYPES } from "../components/inserter/block-patterns-tab/utils.mjs";
+var isFiltered = /* @__PURE__ */ Symbol("isFiltered");
+var parsedPatternCache = /* @__PURE__ */ new WeakMap();
+var grammarMapCache = /* @__PURE__ */ new WeakMap();
+function mapUserPattern(userPattern, __experimentalUserPatternCategories = []) {
+  return {
+    name: `core/block/${userPattern.id}`,
+    id: userPattern.id,
+    type: INSERTER_PATTERN_TYPES.user,
+    title: userPattern.title?.raw,
+    categories: userPattern.wp_pattern_category?.map((catId) => {
+      const category = __experimentalUserPatternCategories.find(
+        ({ id }) => id === catId
+      );
+      return category ? category.slug : catId;
+    }),
+    content: userPattern.content?.raw,
+    syncStatus: userPattern.wp_pattern_sync_status
+  };
+}
+function parsePattern(pattern) {
+  const blocks = parse(pattern.content, {
+    __unstableSkipMigrationLogs: true
+  });
+  if (blocks.length === 1) {
+    blocks[0].attributes = {
+      ...blocks[0].attributes,
+      metadata: {
+        ...blocks[0].attributes.metadata || {},
+        categories: pattern.categories,
+        patternName: pattern.name,
+        name: blocks[0].attributes.metadata?.name || pattern.title
+      }
+    };
+  }
+  return {
+    ...pattern,
+    blocks
+  };
+}
+function getParsedPattern(pattern) {
+  let parsedPattern = parsedPatternCache.get(pattern);
+  if (!parsedPattern) {
+    parsedPattern = parsePattern(pattern);
+    parsedPatternCache.set(pattern, parsedPattern);
+  }
+  return parsedPattern;
+}
+function getGrammar(pattern) {
+  let grammarMap = grammarMapCache.get(pattern);
+  if (!grammarMap) {
+    grammarMap = grammarParse(pattern.content);
+    grammarMap = grammarMap.filter((block) => block.blockName !== null);
+    grammarMapCache.set(pattern, grammarMap);
+  }
+  return grammarMap;
+}
+var checkAllowList = (list, item, defaultResult = null) => {
+  if (typeof list === "boolean") {
+    return list;
+  }
+  if (Array.isArray(list)) {
+    if (list.includes("core/post-content") && item === null) {
+      return true;
+    }
+    return list.includes(item);
+  }
+  return defaultResult;
+};
+var checkAllowListRecursive = (blocks, allowedBlockTypes) => {
+  if (typeof allowedBlockTypes === "boolean") {
+    return allowedBlockTypes;
+  }
+  const blocksQueue = [...blocks];
+  while (blocksQueue.length > 0) {
+    const block = blocksQueue.shift();
+    const isAllowed = checkAllowList(
+      allowedBlockTypes,
+      block.name || block.blockName,
+      true
+    );
+    if (!isAllowed) {
+      return false;
+    }
+    block.innerBlocks?.forEach((innerBlock) => {
+      blocksQueue.push(innerBlock);
+    });
+  }
+  return true;
+};
+var getAllPatternsDependants = (select) => (state) => {
+  return [
+    state.settings.__experimentalBlockPatterns,
+    state.settings.__experimentalUserPatternCategories,
+    state.settings.__experimentalReusableBlocks,
+    state.settings[selectBlockPatternsKey]?.(select),
+    state.blockPatterns,
+    unlock(select(STORE_NAME)).getReusableBlocks()
+  ];
+};
+var getInsertBlockTypeDependants = () => (state, rootClientId) => {
+  return [
+    state.blockListSettings[rootClientId],
+    state.blocks.byClientId.get(rootClientId),
+    state.settings.allowedBlockTypes,
+    state.settings.templateLock,
+    getBlockEditingMode(state, rootClientId),
+    getSectionRootClientId(state),
+    isSectionBlock(state, rootClientId)
+  ];
+};
+export {
+  checkAllowList,
+  checkAllowListRecursive,
+  getAllPatternsDependants,
+  getGrammar,
+  getInsertBlockTypeDependants,
+  getParsedPattern,
+  isFiltered,
+  mapUserPattern
+};
+//# sourceMappingURL=utils.mjs.map

package/build-module/store/utils.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/store/utils.js"],
+  "sourcesContent": ["/**\n * WordPress dependencies\n */\nimport { parse } from '@wordpress/blocks';\nimport { parse as grammarParse } from '@wordpress/block-serialization-default-parser';\n\n/**\n * Internal dependencies\n */\nimport { selectBlockPatternsKey } from './private-keys';\nimport { unlock } from '../lock-unlock';\nimport { STORE_NAME } from './constants';\nimport { getSectionRootClientId, isSectionBlock } from './private-selectors';\nimport { getBlockEditingMode } from './selectors';\nimport { INSERTER_PATTERN_TYPES } from '../components/inserter/block-patterns-tab/utils';\n\nexport const isFiltered = Symbol( 'isFiltered' );\nconst parsedPatternCache = new WeakMap();\nconst grammarMapCache = new WeakMap();\n\nexport function mapUserPattern(\n\tuserPattern,\n\t__experimentalUserPatternCategories = []\n) {\n\treturn {\n\t\tname: `core/block/${ userPattern.id }`,\n\t\tid: userPattern.id,\n\t\ttype: INSERTER_PATTERN_TYPES.user,\n\t\ttitle: userPattern.title?.raw,\n\t\tcategories: userPattern.wp_pattern_category?.map( ( catId ) => {\n\t\t\tconst category = __experimentalUserPatternCategories.find(\n\t\t\t\t( { id } ) => id === catId\n\t\t\t);\n\t\t\treturn category ? category.slug : catId;\n\t\t} ),\n\t\tcontent: userPattern.content?.raw,\n\t\tsyncStatus: userPattern.wp_pattern_sync_status,\n\t};\n}\n\nfunction parsePattern( pattern ) {\n\tconst blocks = parse( pattern.content, {\n\t\t__unstableSkipMigrationLogs: true,\n\t} );\n\tif ( blocks.length === 1 ) {\n\t\tblocks[ 0 ].attributes = {\n\t\t\t...blocks[ 0 ].attributes,\n\t\t\tmetadata: {\n\t\t\t\t...( blocks[ 0 ].attributes.metadata || {} ),\n\t\t\t\tcategories: pattern.categories,\n\t\t\t\tpatternName: pattern.name,\n\t\t\t\tname: blocks[ 0 ].attributes.metadata?.name || pattern.title,\n\t\t\t},\n\t\t};\n\t}\n\treturn {\n\t\t...pattern,\n\t\tblocks,\n\t};\n}\n\nexport function getParsedPattern( pattern ) {\n\tlet parsedPattern = parsedPatternCache.get( pattern );\n\tif ( ! parsedPattern ) {\n\t\tparsedPattern = parsePattern( pattern );\n\t\tparsedPatternCache.set( pattern, parsedPattern );\n\t}\n\treturn parsedPattern;\n}\n\nexport function getGrammar( pattern ) {\n\tlet grammarMap = grammarMapCache.get( pattern );\n\tif ( ! grammarMap ) {\n\t\tgrammarMap = grammarParse( pattern.content );\n\t\t// Block names are null only at the top level for whitespace.\n\t\tgrammarMap = grammarMap.filter( ( block ) => block.blockName !== null );\n\t\tgrammarMapCache.set( pattern, grammarMap );\n\t}\n\treturn grammarMap;\n}\n\nexport const checkAllowList = ( list, item, defaultResult = null ) => {\n\tif ( typeof list === 'boolean' ) {\n\t\treturn list;\n\t}\n\tif ( Array.isArray( list ) ) {\n\t\t// TODO: when there is a canonical way to detect that we are editing a post\n\t\t// the following check should be changed to something like:\n\t\t// if ( list.includes( 'core/post-content' ) && getEditorMode() === 'post-content' && item === null )\n\t\tif ( list.includes( 'core/post-content' ) && item === null ) {\n\t\t\treturn true;\n\t\t}\n\t\treturn list.includes( item );\n\t}\n\treturn defaultResult;\n};\n\nexport const checkAllowListRecursive = ( blocks, allowedBlockTypes ) => {\n\tif ( typeof allowedBlockTypes === 'boolean' ) {\n\t\treturn allowedBlockTypes;\n\t}\n\n\tconst blocksQueue = [ ...blocks ];\n\twhile ( blocksQueue.length > 0 ) {\n\t\tconst block = blocksQueue.shift();\n\n\t\tconst isAllowed = checkAllowList(\n\t\t\tallowedBlockTypes,\n\t\t\tblock.name || block.blockName,\n\t\t\ttrue\n\t\t);\n\t\tif ( ! isAllowed ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tblock.innerBlocks?.forEach( ( innerBlock ) => {\n\t\t\tblocksQueue.push( innerBlock );\n\t\t} );\n\t}\n\n\treturn true;\n};\n\nexport const getAllPatternsDependants = ( select ) => ( state ) => {\n\treturn [\n\t\tstate.settings.__experimentalBlockPatterns,\n\t\tstate.settings.__experimentalUserPatternCategories,\n\t\tstate.settings.__experimentalReusableBlocks,\n\t\tstate.settings[ selectBlockPatternsKey ]?.( select ),\n\t\tstate.blockPatterns,\n\t\tunlock( select( STORE_NAME ) ).getReusableBlocks(),\n\t];\n};\n\nexport const getInsertBlockTypeDependants = () => ( state, rootClientId ) => {\n\treturn [\n\t\tstate.blockListSettings[ rootClientId ],\n\t\tstate.blocks.byClientId.get( rootClientId ),\n\t\tstate.settings.allowedBlockTypes,\n\t\tstate.settings.templateLock,\n\t\tgetBlockEditingMode( state, rootClientId ),\n\t\tgetSectionRootClientId( state ),\n\t\tisSectionBlock( state, rootClientId ),\n\t];\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/build-module/utils/block-bindings.mjs

@@ -0,0 +1,22 @@
+// packages/block-editor/src/utils/block-bindings.js
+var DEFAULT_ATTRIBUTE = "__default";
+var PATTERN_OVERRIDES_SOURCE = "core/pattern-overrides";
+function hasPatternOverridesDefaultBinding(bindings) {
+  return bindings?.[DEFAULT_ATTRIBUTE]?.source === PATTERN_OVERRIDES_SOURCE;
+}
+function replacePatternOverridesDefaultBinding(bindings, supportedAttributes) {
+  if (hasPatternOverridesDefaultBinding(bindings)) {
+    const bindingsWithDefaults = {};
+    for (const attributeName of supportedAttributes) {
+      const bindingSource = bindings[attributeName] ? bindings[attributeName] : { source: PATTERN_OVERRIDES_SOURCE };
+      bindingsWithDefaults[attributeName] = bindingSource;
+    }
+    return bindingsWithDefaults;
+  }
+  return bindings;
+}
+export {
+  hasPatternOverridesDefaultBinding,
+  replacePatternOverridesDefaultBinding
+};
+//# sourceMappingURL=block-bindings.mjs.map

package/build-module/utils/dom.mjs

@@ -0,0 +1,108 @@
+// packages/block-editor/src/utils/dom.js
+var BLOCK_SELECTOR = ".block-editor-block-list__block";
+var APPENDER_SELECTOR = ".block-list-appender";
+var BLOCK_APPENDER_CLASS = ".block-editor-button-block-appender";
+function isInSameBlock(a, b) {
+  return a.closest(BLOCK_SELECTOR) === b.closest(BLOCK_SELECTOR);
+}
+function isInsideRootBlock(blockElement, element) {
+  const parentBlock = element.closest(
+    [BLOCK_SELECTOR, APPENDER_SELECTOR, BLOCK_APPENDER_CLASS].join(",")
+  );
+  return parentBlock === blockElement;
+}
+function getBlockClientId(node) {
+  while (node && node.nodeType !== node.ELEMENT_NODE) {
+    node = node.parentNode;
+  }
+  if (!node) {
+    return;
+  }
+  const elementNode = (
+    /** @type {Element} */
+    node
+  );
+  const blockNode = elementNode.closest(BLOCK_SELECTOR);
+  if (!blockNode) {
+    return;
+  }
+  return blockNode.id.slice("block-".length);
+}
+function rectUnion(rect1, rect2) {
+  const left = Math.min(rect1.left, rect2.left);
+  const right = Math.max(rect1.right, rect2.right);
+  const bottom = Math.max(rect1.bottom, rect2.bottom);
+  const top = Math.min(rect1.top, rect2.top);
+  return new window.DOMRectReadOnly(left, top, right - left, bottom - top);
+}
+function isElementVisible(element) {
+  const viewport = element.ownerDocument.defaultView;
+  if (!viewport) {
+    return false;
+  }
+  if (element.classList.contains("components-visually-hidden")) {
+    return false;
+  }
+  const bounds = element.getBoundingClientRect();
+  if (bounds.width === 0 || bounds.height === 0) {
+    return false;
+  }
+  if (element.checkVisibility) {
+    return element.checkVisibility?.({
+      opacityProperty: true,
+      contentVisibilityAuto: true,
+      visibilityProperty: true
+    });
+  }
+  const style = viewport.getComputedStyle(element);
+  if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
+    return false;
+  }
+  return true;
+}
+function isScrollable(element) {
+  const style = window.getComputedStyle(element);
+  return style.overflowX === "auto" || style.overflowX === "scroll" || style.overflowY === "auto" || style.overflowY === "scroll";
+}
+var WITH_OVERFLOW_ELEMENT_BLOCKS = ["core/navigation"];
+function getElementBounds(element) {
+  const viewport = element.ownerDocument.defaultView;
+  if (!viewport) {
+    return new window.DOMRectReadOnly();
+  }
+  let bounds = element.getBoundingClientRect();
+  const dataType = element.getAttribute("data-type");
+  if (dataType && WITH_OVERFLOW_ELEMENT_BLOCKS.includes(dataType)) {
+    const stack = [element];
+    let currentElement;
+    while (currentElement = stack.pop()) {
+      if (!isScrollable(currentElement)) {
+        for (const child of currentElement.children) {
+          if (isElementVisible(child)) {
+            const childBounds = child.getBoundingClientRect();
+            bounds = rectUnion(bounds, childBounds);
+            stack.push(child);
+          }
+        }
+      }
+    }
+  }
+  const left = Math.max(bounds.left, 0);
+  const right = Math.min(bounds.right, viewport.innerWidth);
+  bounds = new window.DOMRectReadOnly(
+    left,
+    bounds.top,
+    right - left,
+    bounds.height
+  );
+  return bounds;
+}
+export {
+  WITH_OVERFLOW_ELEMENT_BLOCKS,
+  getBlockClientId,
+  getElementBounds,
+  isInSameBlock,
+  isInsideRootBlock,
+  rectUnion
+};
+//# sourceMappingURL=dom.mjs.map

package/build-module/utils/fit-text-frontend.mjs

@@ -0,0 +1,32 @@
+// packages/block-editor/src/utils/fit-text-frontend.js
+import { store, getElement, getContext } from "@wordpress/interactivity";
+import { optimizeFitText } from "./fit-text-utils.mjs";
+store("core/fit-text", {
+  callbacks: {
+    init() {
+      const context = getContext();
+      const { ref } = getElement();
+      const applyFontSize = (fontSize) => {
+        if (fontSize === 0) {
+          ref.style.fontSize = "";
+        } else {
+          ref.style.fontSize = `${fontSize}px`;
+        }
+      };
+      context.fontSize = optimizeFitText(ref, applyFontSize);
+      if (window.ResizeObserver && ref.parentElement) {
+        const resizeObserver = new window.ResizeObserver(() => {
+          context.fontSize = optimizeFitText(ref, applyFontSize);
+        });
+        resizeObserver.observe(ref.parentElement);
+        resizeObserver.observe(ref);
+        return () => {
+          if (resizeObserver) {
+            resizeObserver.disconnect();
+          }
+        };
+      }
+    }
+  }
+});
+//# sourceMappingURL=fit-text-frontend.mjs.map

package/build-module/utils/fit-text-utils.mjs

@@ -0,0 +1,41 @@
+// packages/block-editor/src/utils/fit-text-utils.js
+function findOptimalFontSize(textElement, applyFontSize) {
+  const alreadyHasScrollableHeight = textElement.scrollHeight > textElement.clientHeight;
+  let minSize = 0;
+  let maxSize = 2400;
+  let bestSize = minSize;
+  const computedStyle = window.getComputedStyle(textElement);
+  const paddingLeft = parseFloat(computedStyle.paddingLeft) || 0;
+  const paddingRight = parseFloat(computedStyle.paddingRight) || 0;
+  const range = document.createRange();
+  range.selectNodeContents(textElement);
+  while (minSize <= maxSize) {
+    const midSize = Math.floor((minSize + maxSize) / 2);
+    applyFontSize(midSize);
+    const rect = range.getBoundingClientRect();
+    const textWidth = rect.width;
+    const fitsWidth = textElement.scrollWidth <= textElement.clientWidth && textWidth <= textElement.clientWidth - paddingLeft - paddingRight;
+    const fitsHeight = alreadyHasScrollableHeight || textElement.scrollHeight <= textElement.clientHeight;
+    if (fitsWidth && fitsHeight) {
+      bestSize = midSize;
+      minSize = midSize + 1;
+    } else {
+      maxSize = midSize - 1;
+    }
+  }
+  range.detach();
+  return bestSize;
+}
+function optimizeFitText(textElement, applyFontSize) {
+  if (!textElement) {
+    return;
+  }
+  applyFontSize(0);
+  const optimalSize = findOptimalFontSize(textElement, applyFontSize);
+  applyFontSize(optimalSize);
+  return optimalSize;
+}
+export {
+  optimizeFitText
+};
+//# sourceMappingURL=fit-text-utils.mjs.map

package/build-module/utils/format-font-style.mjs

@@ -0,0 +1,30 @@
+// packages/block-editor/src/utils/format-font-style.js
+import { _x } from "@wordpress/i18n";
+function formatFontStyle(fontStyle) {
+  if (!fontStyle) {
+    return {};
+  }
+  if (typeof fontStyle === "object") {
+    return fontStyle;
+  }
+  let name;
+  switch (fontStyle) {
+    case "normal":
+      name = _x("Regular", "font style");
+      break;
+    case "italic":
+      name = _x("Italic", "font style");
+      break;
+    case "oblique":
+      name = _x("Oblique", "font style");
+      break;
+    default:
+      name = fontStyle;
+      break;
+  }
+  return { name, value: fontStyle };
+}
+export {
+  formatFontStyle
+};
+//# sourceMappingURL=format-font-style.mjs.map

package/build-module/utils/format-font-weight.mjs

@@ -0,0 +1,53 @@
+// packages/block-editor/src/utils/format-font-weight.js
+import { _x } from "@wordpress/i18n";
+function formatFontWeight(fontWeight) {
+  if (!fontWeight) {
+    return {};
+  }
+  if (typeof fontWeight === "object") {
+    return fontWeight;
+  }
+  let name;
+  switch (fontWeight) {
+    case "normal":
+    case "400":
+      name = _x("Regular", "font weight");
+      break;
+    case "bold":
+    case "700":
+      name = _x("Bold", "font weight");
+      break;
+    case "100":
+      name = _x("Thin", "font weight");
+      break;
+    case "200":
+      name = _x("Extra Light", "font weight");
+      break;
+    case "300":
+      name = _x("Light", "font weight");
+      break;
+    case "500":
+      name = _x("Medium", "font weight");
+      break;
+    case "600":
+      name = _x("Semi Bold", "font weight");
+      break;
+    case "800":
+      name = _x("Extra Bold", "font weight");
+      break;
+    case "900":
+      name = _x("Black", "font weight");
+      break;
+    case "1000":
+      name = _x("Extra Black", "font weight");
+      break;
+    default:
+      name = fontWeight;
+      break;
+  }
+  return { name, value: fontWeight };
+}
+export {
+  formatFontWeight
+};
+//# sourceMappingURL=format-font-weight.mjs.map

package/build-module/utils/get-editor-region.mjs

@@ -0,0 +1,17 @@
+// packages/block-editor/src/utils/get-editor-region.js
+function getEditorRegion(editor) {
+  if (!editor) {
+    return null;
+  }
+  const editorCanvas = Array.from(
+    document.querySelectorAll('iframe[name="editor-canvas"]').values()
+  ).find((iframe) => {
+    const iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
+    return iframeDocument === editor.ownerDocument;
+  }) ?? editor;
+  return editorCanvas?.closest('[role="region"]') ?? editorCanvas;
+}
+export {
+  getEditorRegion as default
+};
+//# sourceMappingURL=get-editor-region.mjs.map

package/build-module/utils/get-font-styles-and-weights.mjs

@@ -0,0 +1,150 @@
+// packages/block-editor/src/utils/get-font-styles-and-weights.js
+import { _x, sprintf } from "@wordpress/i18n";
+import { formatFontStyle } from "./format-font-style.mjs";
+import { formatFontWeight } from "./format-font-weight.mjs";
+var FONT_STYLES = [
+  {
+    name: _x("Regular", "font style"),
+    value: "normal"
+  },
+  {
+    name: _x("Italic", "font style"),
+    value: "italic"
+  }
+];
+var FONT_WEIGHTS = [
+  {
+    name: _x("Thin", "font weight"),
+    value: "100"
+  },
+  {
+    name: _x("Extra Light", "font weight"),
+    value: "200"
+  },
+  {
+    name: _x("Light", "font weight"),
+    value: "300"
+  },
+  {
+    name: _x("Regular", "font weight"),
+    value: "400"
+  },
+  {
+    name: _x("Medium", "font weight"),
+    value: "500"
+  },
+  {
+    name: _x("Semi Bold", "font weight"),
+    value: "600"
+  },
+  {
+    name: _x("Bold", "font weight"),
+    value: "700"
+  },
+  {
+    name: _x("Extra Bold", "font weight"),
+    value: "800"
+  },
+  {
+    name: _x("Black", "font weight"),
+    value: "900"
+  },
+  {
+    name: _x("Extra Black", "font weight"),
+    value: "1000"
+  }
+];
+function getFontStylesAndWeights(fontFamilyFaces) {
+  let fontStyles = [];
+  let fontWeights = [];
+  const combinedStyleAndWeightOptions = [];
+  const isSystemFont = !fontFamilyFaces || fontFamilyFaces?.length === 0;
+  let isVariableFont = false;
+  fontFamilyFaces?.forEach((face) => {
+    if ("string" === typeof face.fontWeight && /\s/.test(face.fontWeight.trim())) {
+      isVariableFont = true;
+      let [startValue, endValue] = face.fontWeight.split(" ");
+      startValue = parseInt(startValue.slice(0, 1));
+      if (endValue === "1000") {
+        endValue = 10;
+      } else {
+        endValue = parseInt(endValue.slice(0, 1));
+      }
+      for (let i = startValue; i <= endValue; i++) {
+        const fontWeightValue = `${i.toString()}00`;
+        if (!fontWeights.some(
+          (weight) => weight.value === fontWeightValue
+        )) {
+          fontWeights.push(formatFontWeight(fontWeightValue));
+        }
+      }
+    }
+    const fontWeight = formatFontWeight(
+      "number" === typeof face.fontWeight ? face.fontWeight.toString() : face.fontWeight
+    );
+    const fontStyle = formatFontStyle(face.fontStyle);
+    if (fontStyle && Object.keys(fontStyle).length) {
+      if (!fontStyles.some(
+        (style) => style.value === fontStyle.value
+      )) {
+        fontStyles.push(fontStyle);
+      }
+    }
+    if (fontWeight && Object.keys(fontWeight).length) {
+      if (!fontWeights.some(
+        (weight) => weight.value === fontWeight.value
+      )) {
+        if (!isVariableFont) {
+          fontWeights.push(fontWeight);
+        }
+      }
+    }
+  });
+  if (!fontWeights.some((weight) => weight.value >= "600")) {
+    fontWeights.push({
+      name: _x("Bold", "font weight"),
+      value: "700"
+    });
+  }
+  if (!fontStyles.some((style) => style.value === "italic")) {
+    fontStyles.push({
+      name: _x("Italic", "font style"),
+      value: "italic"
+    });
+  }
+  if (isSystemFont) {
+    fontStyles = FONT_STYLES;
+    fontWeights = FONT_WEIGHTS;
+  }
+  fontStyles = fontStyles.length === 0 ? FONT_STYLES : fontStyles;
+  fontWeights = fontWeights.length === 0 ? FONT_WEIGHTS : fontWeights;
+  fontStyles.forEach(({ name: styleName, value: styleValue }) => {
+    fontWeights.forEach(({ name: weightName, value: weightValue }) => {
+      const optionName = styleValue === "normal" ? weightName : sprintf(
+        /* translators: 1: Font weight name. 2: Font style name. */
+        _x("%1$s %2$s", "font"),
+        weightName,
+        styleName
+      );
+      combinedStyleAndWeightOptions.push({
+        key: `${styleValue}-${weightValue}`,
+        name: optionName,
+        style: {
+          fontStyle: styleValue,
+          fontWeight: weightValue
+        }
+      });
+    });
+  });
+  return {
+    fontStyles,
+    fontWeights,
+    combinedStyleAndWeightOptions,
+    isSystemFont,
+    isVariableFont
+  };
+}
+export {
+  getFontStylesAndWeights
+};
+//# sourceMappingURL=get-font-styles-and-weights.mjs.map

package/build-module/utils/get-px-from-css-unit.mjs

@@ -0,0 +1,6 @@
+// packages/block-editor/src/utils/get-px-from-css-unit.js
+var get_px_from_css_unit_default = () => "";
+export {
+  get_px_from_css_unit_default as default
+};
+//# sourceMappingURL=get-px-from-css-unit.mjs.map

package/build-module/utils/index.mjs

@@ -0,0 +1,8 @@
+// packages/block-editor/src/utils/index.js
+import { default as default2 } from "./transform-styles/index.mjs";
+import { default as default3 } from "./get-px-from-css-unit.mjs";
+export {
+  default3 as getPxFromCssUnit,
+  default2 as transformStyles
+};
+//# sourceMappingURL=index.mjs.map

package/build-module/utils/math.mjs

@@ -0,0 +1,46 @@
+// packages/block-editor/src/utils/math.js
+function getDistanceFromPointToEdge(point, rect, edge) {
+  const isHorizontal = edge === "top" || edge === "bottom";
+  const { x, y } = point;
+  const pointLateralPosition = isHorizontal ? x : y;
+  const pointForwardPosition = isHorizontal ? y : x;
+  const edgeStart = isHorizontal ? rect.left : rect.top;
+  const edgeEnd = isHorizontal ? rect.right : rect.bottom;
+  const edgeForwardPosition = rect[edge];
+  let edgeLateralPosition;
+  if (pointLateralPosition >= edgeStart && pointLateralPosition <= edgeEnd) {
+    edgeLateralPosition = pointLateralPosition;
+  } else if (pointLateralPosition < edgeEnd) {
+    edgeLateralPosition = edgeStart;
+  } else {
+    edgeLateralPosition = edgeEnd;
+  }
+  return Math.sqrt(
+    (pointLateralPosition - edgeLateralPosition) ** 2 + (pointForwardPosition - edgeForwardPosition) ** 2
+  );
+}
+function getDistanceToNearestEdge(point, rect, allowedEdges = ["top", "bottom", "left", "right"]) {
+  let candidateDistance;
+  let candidateEdge;
+  allowedEdges.forEach((edge) => {
+    const distance = getDistanceFromPointToEdge(point, rect, edge);
+    if (candidateDistance === void 0 || distance < candidateDistance) {
+      candidateDistance = distance;
+      candidateEdge = edge;
+    }
+  });
+  return [candidateDistance, candidateEdge];
+}
+function isPointContainedByRect(point, rect) {
+  return rect.left <= point.x && rect.right >= point.x && rect.top <= point.y && rect.bottom >= point.y;
+}
+function isPointWithinTopAndBottomBoundariesOfRect(point, rect) {
+  return rect.top <= point.y && rect.bottom >= point.y;
+}
+export {
+  getDistanceFromPointToEdge,
+  getDistanceToNearestEdge,
+  isPointContainedByRect,
+  isPointWithinTopAndBottomBoundariesOfRect
+};
+//# sourceMappingURL=math.mjs.map