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

package/build/utils/dom.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/block-editor/src/utils/dom.js
+var dom_exports = {};
+__export(dom_exports, {
+  WITH_OVERFLOW_ELEMENT_BLOCKS: () => WITH_OVERFLOW_ELEMENT_BLOCKS,
+  getBlockClientId: () => getBlockClientId,
+  getElementBounds: () => getElementBounds,
+  isInSameBlock: () => isInSameBlock,
+  isInsideRootBlock: () => isInsideRootBlock,
+  rectUnion: () => rectUnion
+});
+module.exports = __toCommonJS(dom_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WITH_OVERFLOW_ELEMENT_BLOCKS,
+  getBlockClientId,
+  getElementBounds,
+  isInSameBlock,
+  isInsideRootBlock,
+  rectUnion
+});
+//# sourceMappingURL=dom.cjs.map

package/build/utils/fit-text-frontend.cjs

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

package/build/utils/fit-text-utils.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/block-editor/src/utils/fit-text-utils.js
+var fit_text_utils_exports = {};
+__export(fit_text_utils_exports, {
+  optimizeFitText: () => optimizeFitText
+});
+module.exports = __toCommonJS(fit_text_utils_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  optimizeFitText
+});
+//# sourceMappingURL=fit-text-utils.cjs.map

package/build/utils/fit-text-utils.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/fit-text-utils.js"],
+  "sourcesContent": ["/**\n * Shared utility functions for fit text functionality.\n * Uses callback-based approach for maximum code reuse between editor and frontend.\n */\n\n/**\n * Find optimal font size using simple binary search between 0-2400px.\n *\n * @param {HTMLElement} textElement   The text element\n * @param {Function}    applyFontSize Function that receives font size in pixels\n * @return {number} Optimal font size\n */\nfunction findOptimalFontSize( textElement, applyFontSize ) {\n\tconst alreadyHasScrollableHeight =\n\t\ttextElement.scrollHeight > textElement.clientHeight;\n\tlet minSize = 0;\n\tlet maxSize = 2400;\n\tlet bestSize = minSize;\n\n\tconst computedStyle = window.getComputedStyle( textElement );\n\tconst paddingLeft = parseFloat( computedStyle.paddingLeft ) || 0;\n\tconst paddingRight = parseFloat( computedStyle.paddingRight ) || 0;\n\tconst range = document.createRange();\n\trange.selectNodeContents( textElement );\n\n\twhile ( minSize <= maxSize ) {\n\t\tconst midSize = Math.floor( ( minSize + maxSize ) / 2 );\n\t\tapplyFontSize( midSize );\n\n\t\t// When there is padding if the text overflows to the\n\t\t// padding area, it should be considered overflowing.\n\t\t// Use Range API to measure actual text content dimensions.\n\t\tconst rect = range.getBoundingClientRect();\n\t\tconst textWidth = rect.width;\n\n\t\t// Check if text fits within the element's width and is not\n\t\t// overflowing into the padding area.\n\t\tconst fitsWidth =\n\t\t\ttextElement.scrollWidth <= textElement.clientWidth &&\n\t\t\ttextWidth <= textElement.clientWidth - paddingLeft - paddingRight;\n\t\t// Check if text fits within the element's height.\n\t\tconst fitsHeight =\n\t\t\talreadyHasScrollableHeight ||\n\t\t\ttextElement.scrollHeight <= textElement.clientHeight;\n\n\t\tif ( fitsWidth && fitsHeight ) {\n\t\t\tbestSize = midSize;\n\t\t\tminSize = midSize + 1;\n\t\t} else {\n\t\t\tmaxSize = midSize - 1;\n\t\t}\n\t}\n\trange.detach();\n\n\treturn bestSize;\n}\n\n/**\n * Complete fit text optimization for a single text element.\n * Handles the full flow using callbacks for font size application.\n *\n * @param {HTMLElement} textElement   The text element (paragraph, heading, etc.)\n * @param {Function}    applyFontSize Function that receives font size in pixels (0 to clear, >0 to apply)\n */\nexport function optimizeFitText( textElement, applyFontSize ) {\n\tif ( ! textElement ) {\n\t\treturn;\n\t}\n\n\tapplyFontSize( 0 );\n\n\tconst optimalSize = findOptimalFontSize( textElement, applyFontSize );\n\n\tapplyFontSize( optimalSize );\n\treturn optimalSize;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,SAAS,oBAAqB,aAAa,eAAgB;AAC1D,QAAM,6BACL,YAAY,eAAe,YAAY;AACxC,MAAI,UAAU;AACd,MAAI,UAAU;AACd,MAAI,WAAW;AAEf,QAAM,gBAAgB,OAAO,iBAAkB,WAAY;AAC3D,QAAM,cAAc,WAAY,cAAc,WAAY,KAAK;AAC/D,QAAM,eAAe,WAAY,cAAc,YAAa,KAAK;AACjE,QAAM,QAAQ,SAAS,YAAY;AACnC,QAAM,mBAAoB,WAAY;AAEtC,SAAQ,WAAW,SAAU;AAC5B,UAAM,UAAU,KAAK,OAAS,UAAU,WAAY,CAAE;AACtD,kBAAe,OAAQ;AAKvB,UAAM,OAAO,MAAM,sBAAsB;AACzC,UAAM,YAAY,KAAK;AAIvB,UAAM,YACL,YAAY,eAAe,YAAY,eACvC,aAAa,YAAY,cAAc,cAAc;AAEtD,UAAM,aACL,8BACA,YAAY,gBAAgB,YAAY;AAEzC,QAAK,aAAa,YAAa;AAC9B,iBAAW;AACX,gBAAU,UAAU;AAAA,IACrB,OAAO;AACN,gBAAU,UAAU;AAAA,IACrB;AAAA,EACD;AACA,QAAM,OAAO;AAEb,SAAO;AACR;AASO,SAAS,gBAAiB,aAAa,eAAgB;AAC7D,MAAK,CAAE,aAAc;AACpB;AAAA,EACD;AAEA,gBAAe,CAAE;AAEjB,QAAM,cAAc,oBAAqB,aAAa,aAAc;AAEpE,gBAAe,WAAY;AAC3B,SAAO;AACR;",
+  "names": []
+}

package/build/utils/format-font-style.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/block-editor/src/utils/format-font-style.js
+var format_font_style_exports = {};
+__export(format_font_style_exports, {
+  formatFontStyle: () => formatFontStyle
+});
+module.exports = __toCommonJS(format_font_style_exports);
+var import_i18n = require("@wordpress/i18n");
+function formatFontStyle(fontStyle) {
+  if (!fontStyle) {
+    return {};
+  }
+  if (typeof fontStyle === "object") {
+    return fontStyle;
+  }
+  let name;
+  switch (fontStyle) {
+    case "normal":
+      name = (0, import_i18n._x)("Regular", "font style");
+      break;
+    case "italic":
+      name = (0, import_i18n._x)("Italic", "font style");
+      break;
+    case "oblique":
+      name = (0, import_i18n._x)("Oblique", "font style");
+      break;
+    default:
+      name = fontStyle;
+      break;
+  }
+  return { name, value: fontStyle };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatFontStyle
+});
+//# sourceMappingURL=format-font-style.cjs.map

package/build/utils/format-font-weight.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/block-editor/src/utils/format-font-weight.js
+var format_font_weight_exports = {};
+__export(format_font_weight_exports, {
+  formatFontWeight: () => formatFontWeight
+});
+module.exports = __toCommonJS(format_font_weight_exports);
+var import_i18n = require("@wordpress/i18n");
+function formatFontWeight(fontWeight) {
+  if (!fontWeight) {
+    return {};
+  }
+  if (typeof fontWeight === "object") {
+    return fontWeight;
+  }
+  let name;
+  switch (fontWeight) {
+    case "normal":
+    case "400":
+      name = (0, import_i18n._x)("Regular", "font weight");
+      break;
+    case "bold":
+    case "700":
+      name = (0, import_i18n._x)("Bold", "font weight");
+      break;
+    case "100":
+      name = (0, import_i18n._x)("Thin", "font weight");
+      break;
+    case "200":
+      name = (0, import_i18n._x)("Extra Light", "font weight");
+      break;
+    case "300":
+      name = (0, import_i18n._x)("Light", "font weight");
+      break;
+    case "500":
+      name = (0, import_i18n._x)("Medium", "font weight");
+      break;
+    case "600":
+      name = (0, import_i18n._x)("Semi Bold", "font weight");
+      break;
+    case "800":
+      name = (0, import_i18n._x)("Extra Bold", "font weight");
+      break;
+    case "900":
+      name = (0, import_i18n._x)("Black", "font weight");
+      break;
+    case "1000":
+      name = (0, import_i18n._x)("Extra Black", "font weight");
+      break;
+    default:
+      name = fontWeight;
+      break;
+  }
+  return { name, value: fontWeight };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatFontWeight
+});
+//# sourceMappingURL=format-font-weight.cjs.map

package/build/utils/get-editor-region.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/block-editor/src/utils/get-editor-region.js
+var get_editor_region_exports = {};
+__export(get_editor_region_exports, {
+  default: () => getEditorRegion
+});
+module.exports = __toCommonJS(get_editor_region_exports);
+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;
+}
+//# sourceMappingURL=get-editor-region.cjs.map

package/build/utils/get-font-styles-and-weights.cjs

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/block-editor/src/utils/get-font-styles-and-weights.js
+var get_font_styles_and_weights_exports = {};
+__export(get_font_styles_and_weights_exports, {
+  getFontStylesAndWeights: () => getFontStylesAndWeights
+});
+module.exports = __toCommonJS(get_font_styles_and_weights_exports);
+var import_i18n = require("@wordpress/i18n");
+var import_format_font_style = require("./format-font-style.cjs");
+var import_format_font_weight = require("./format-font-weight.cjs");
+var FONT_STYLES = [
+  {
+    name: (0, import_i18n._x)("Regular", "font style"),
+    value: "normal"
+  },
+  {
+    name: (0, import_i18n._x)("Italic", "font style"),
+    value: "italic"
+  }
+];
+var FONT_WEIGHTS = [
+  {
+    name: (0, import_i18n._x)("Thin", "font weight"),
+    value: "100"
+  },
+  {
+    name: (0, import_i18n._x)("Extra Light", "font weight"),
+    value: "200"
+  },
+  {
+    name: (0, import_i18n._x)("Light", "font weight"),
+    value: "300"
+  },
+  {
+    name: (0, import_i18n._x)("Regular", "font weight"),
+    value: "400"
+  },
+  {
+    name: (0, import_i18n._x)("Medium", "font weight"),
+    value: "500"
+  },
+  {
+    name: (0, import_i18n._x)("Semi Bold", "font weight"),
+    value: "600"
+  },
+  {
+    name: (0, import_i18n._x)("Bold", "font weight"),
+    value: "700"
+  },
+  {
+    name: (0, import_i18n._x)("Extra Bold", "font weight"),
+    value: "800"
+  },
+  {
+    name: (0, import_i18n._x)("Black", "font weight"),
+    value: "900"
+  },
+  {
+    name: (0, import_i18n._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((0, import_format_font_weight.formatFontWeight)(fontWeightValue));
+        }
+      }
+    }
+    const fontWeight = (0, import_format_font_weight.formatFontWeight)(
+      "number" === typeof face.fontWeight ? face.fontWeight.toString() : face.fontWeight
+    );
+    const fontStyle = (0, import_format_font_style.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: (0, import_i18n._x)("Bold", "font weight"),
+      value: "700"
+    });
+  }
+  if (!fontStyles.some((style) => style.value === "italic")) {
+    fontStyles.push({
+      name: (0, import_i18n._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 : (0, import_i18n.sprintf)(
+        /* translators: 1: Font weight name. 2: Font style name. */
+        (0, import_i18n._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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFontStylesAndWeights
+});
+//# sourceMappingURL=get-font-styles-and-weights.cjs.map

package/build/utils/get-px-from-css-unit.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/block-editor/src/utils/get-px-from-css-unit.js
+var get_px_from_css_unit_exports = {};
+__export(get_px_from_css_unit_exports, {
+  default: () => get_px_from_css_unit_default
+});
+module.exports = __toCommonJS(get_px_from_css_unit_exports);
+var get_px_from_css_unit_default = () => "";
+//# sourceMappingURL=get-px-from-css-unit.cjs.map

package/build/utils/index.cjs

@@ -0,0 +1,44 @@
+"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/utils/index.js
+var utils_exports = {};
+__export(utils_exports, {
+  getPxFromCssUnit: () => import_get_px_from_css_unit.default,
+  transformStyles: () => import_transform_styles.default
+});
+module.exports = __toCommonJS(utils_exports);
+var import_transform_styles = __toESM(require("./transform-styles/index.cjs"), 1);
+var import_get_px_from_css_unit = __toESM(require("./get-px-from-css-unit.cjs"), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPxFromCssUnit,
+  transformStyles
+});
+//# sourceMappingURL=index.cjs.map