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

package/build/components/editable-text/index.js

@@ -0,0 +1,46 @@
+"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/components/editable-text/index.js
+var editable_text_exports = {};
+__export(editable_text_exports, {
+  default: () => editable_text_default
+});
+module.exports = __toCommonJS(editable_text_exports);
+var import_element = require("@wordpress/element");
+var import_rich_text = __toESM(require("../rich-text"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var EditableText = (0, import_element.forwardRef)((props, ref) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_rich_text.default, { ref, ...props, __unstableDisableFormats: true });
+});
+EditableText.Content = ({ value = "", tagName: Tag = "div", ...props }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Tag, { ...props, children: value });
+};
+var editable_text_default = EditableText;
+//# sourceMappingURL=index.js.map

package/build/components/editor-styles/index.js

@@ -0,0 +1,129 @@
+"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/components/editor-styles/index.js
+var editor_styles_exports = {};
+__export(editor_styles_exports, {
+  default: () => editor_styles_default
+});
+module.exports = __toCommonJS(editor_styles_exports);
+var import_colord = require("colord");
+var import_names = __toESM(require("colord/plugins/names"));
+var import_a11y = __toESM(require("colord/plugins/a11y"));
+var import_components = require("@wordpress/components");
+var import_element = require("@wordpress/element");
+var import_data = require("@wordpress/data");
+var import_transform_styles = __toESM(require("../../utils/transform-styles"));
+var import_store = require("../../store");
+var import_lock_unlock = require("../../lock-unlock");
+var import_jsx_runtime = require("react/jsx-runtime");
+(0, import_colord.extend)([import_names.default, import_a11y.default]);
+function useDarkThemeBodyClassName(styles, scope) {
+  return (0, import_element.useCallback)(
+    (node) => {
+      if (!node) {
+        return;
+      }
+      const { ownerDocument } = node;
+      const { defaultView, body } = ownerDocument;
+      const canvas = scope ? ownerDocument.querySelector(scope) : body;
+      let backgroundColor;
+      if (!canvas) {
+        const tempCanvas = ownerDocument.createElement("div");
+        tempCanvas.classList.add("editor-styles-wrapper");
+        body.appendChild(tempCanvas);
+        backgroundColor = defaultView?.getComputedStyle(tempCanvas, null).getPropertyValue("background-color");
+        body.removeChild(tempCanvas);
+      } else {
+        backgroundColor = defaultView?.getComputedStyle(canvas, null).getPropertyValue("background-color");
+      }
+      const colordBackgroundColor = (0, import_colord.colord)(backgroundColor);
+      if (colordBackgroundColor.luminance() > 0.5 || colordBackgroundColor.alpha() === 0) {
+        body.classList.remove("is-dark-theme");
+      } else {
+        body.classList.add("is-dark-theme");
+      }
+    },
+    [styles, scope]
+  );
+}
+function EditorStyles({ styles, scope, transformOptions }) {
+  const overrides = (0, import_data.useSelect)(
+    (select) => (0, import_lock_unlock.unlock)(select(import_store.store)).getStyleOverrides(),
+    []
+  );
+  const [transformedStyles, transformedSvgs] = (0, import_element.useMemo)(() => {
+    const _styles = Object.values(styles ?? []);
+    for (const [id, override] of overrides) {
+      const index = _styles.findIndex(({ id: _id }) => id === _id);
+      const overrideWithId = { ...override, id };
+      if (index === -1) {
+        _styles.push(overrideWithId);
+      } else {
+        _styles[index] = overrideWithId;
+      }
+    }
+    return [
+      (0, import_transform_styles.default)(
+        _styles.filter((style) => style?.css),
+        scope,
+        transformOptions
+      ),
+      _styles.filter((style) => style.__unstableType === "svgs").map((style) => style.assets).join("")
+    ];
+  }, [styles, overrides, scope, transformOptions]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "style",
+      {
+        ref: useDarkThemeBodyClassName(transformedStyles, scope)
+      }
+    ),
+    transformedStyles.map((css, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("style", { children: css }, index)),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_components.SVG,
+      {
+        xmlns: "http://www.w3.org/2000/svg",
+        viewBox: "0 0 0 0",
+        width: "0",
+        height: "0",
+        role: "none",
+        style: {
+          visibility: "hidden",
+          position: "absolute",
+          left: "-9999px",
+          overflow: "hidden"
+        },
+        dangerouslySetInnerHTML: { __html: transformedSvgs }
+      }
+    )
+  ] });
+}
+var editor_styles_default = (0, import_element.memo)(EditorStyles);
+//# sourceMappingURL=index.js.map

package/build/components/floating-toolbar/nav-up-icon.js

@@ -0,0 +1,52 @@
+"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/components/floating-toolbar/nav-up-icon.js
+var nav_up_icon_exports = {};
+__export(nav_up_icon_exports, {
+  default: () => nav_up_icon_default
+});
+module.exports = __toCommonJS(nav_up_icon_exports);
+var import_components = require("@wordpress/components");
+var import_i18n = require("@wordpress/i18n");
+var import_jsx_runtime = require("react/jsx-runtime");
+var NavigateUp = () => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+  import_components.SVG,
+  {
+    width: "24",
+    height: "24",
+    viewBox: "0 0 24 24",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_components.Path, { fill: "none", d: "M0 0h24v24H0V0z" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_components.Path,
+        {
+          fill: "white",
+          fillRule: "evenodd",
+          clipRule: "evenodd",
+          d: "M17,11  z L15.58,12.42 L12,8.83 L12,18 L22,18 L22,20 L10,20 L10,8.83 L6.42,12.42 L5,11 L11,5 L17,11",
+          transform: (0, import_i18n.isRTL)() ? "scale(-1,1) translate(-24,0)" : void 0
+        }
+      )
+    ]
+  }
+);
+var nav_up_icon_default = NavigateUp;
+//# sourceMappingURL=nav-up-icon.js.map

package/build/components/font-appearance-control/index.js

@@ -0,0 +1,162 @@
+"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/components/font-appearance-control/index.js
+var font_appearance_control_exports = {};
+__export(font_appearance_control_exports, {
+  default: () => FontAppearanceControl
+});
+module.exports = __toCommonJS(font_appearance_control_exports);
+var import_components = require("@wordpress/components");
+var import_deprecated = __toESM(require("@wordpress/deprecated"));
+var import_element = require("@wordpress/element");
+var import_i18n = require("@wordpress/i18n");
+var import_get_font_styles_and_weights = require("../../utils/get-font-styles-and-weights");
+var import_jsx_runtime = require("react/jsx-runtime");
+var getFontAppearanceLabel = (hasFontStyles, hasFontWeights) => {
+  if (!hasFontStyles) {
+    return (0, import_i18n.__)("Font weight");
+  }
+  if (!hasFontWeights) {
+    return (0, import_i18n.__)("Font style");
+  }
+  return (0, import_i18n.__)("Appearance");
+};
+function FontAppearanceControl(props) {
+  const {
+    /** Start opting into the larger default height that will become the default size in a future version. */
+    __next40pxDefaultSize = false,
+    onChange,
+    hasFontStyles = true,
+    hasFontWeights = true,
+    fontFamilyFaces,
+    value: { fontStyle, fontWeight },
+    ...otherProps
+  } = props;
+  const hasStylesOrWeights = hasFontStyles || hasFontWeights;
+  const label = getFontAppearanceLabel(hasFontStyles, hasFontWeights);
+  const defaultOption = {
+    key: "default",
+    name: (0, import_i18n.__)("Default"),
+    style: { fontStyle: void 0, fontWeight: void 0 }
+  };
+  const { fontStyles, fontWeights, combinedStyleAndWeightOptions } = (0, import_get_font_styles_and_weights.getFontStylesAndWeights)(fontFamilyFaces);
+  const combineOptions = () => {
+    const combinedOptions = [defaultOption];
+    if (combinedStyleAndWeightOptions) {
+      combinedOptions.push(...combinedStyleAndWeightOptions);
+    }
+    return combinedOptions;
+  };
+  const styleOptions = () => {
+    const combinedOptions = [defaultOption];
+    fontStyles.forEach(({ name, value }) => {
+      combinedOptions.push({
+        key: value,
+        name,
+        style: { fontStyle: value, fontWeight: void 0 }
+      });
+    });
+    return combinedOptions;
+  };
+  const weightOptions = () => {
+    const combinedOptions = [defaultOption];
+    fontWeights.forEach(({ name, value }) => {
+      combinedOptions.push({
+        key: value,
+        name,
+        style: { fontStyle: void 0, fontWeight: value }
+      });
+    });
+    return combinedOptions;
+  };
+  const selectOptions = (0, import_element.useMemo)(() => {
+    if (hasFontStyles && hasFontWeights) {
+      return combineOptions();
+    }
+    return hasFontStyles ? styleOptions() : weightOptions();
+  }, [
+    props.options,
+    fontStyles,
+    fontWeights,
+    combinedStyleAndWeightOptions
+  ]);
+  const currentSelection = selectOptions.find(
+    (option) => option.style.fontStyle === fontStyle && option.style.fontWeight === fontWeight
+  ) || selectOptions[0];
+  const getDescribedBy = () => {
+    if (!currentSelection) {
+      return (0, import_i18n.__)("No selected font appearance");
+    }
+    if (!hasFontStyles) {
+      return (0, import_i18n.sprintf)(
+        // translators: %s: Currently selected font weight.
+        (0, import_i18n.__)("Currently selected font weight: %s"),
+        currentSelection.name
+      );
+    }
+    if (!hasFontWeights) {
+      return (0, import_i18n.sprintf)(
+        // translators: %s: Currently selected font style.
+        (0, import_i18n.__)("Currently selected font style: %s"),
+        currentSelection.name
+      );
+    }
+    return (0, import_i18n.sprintf)(
+      // translators: %s: Currently selected font appearance.
+      (0, import_i18n.__)("Currently selected font appearance: %s"),
+      currentSelection.name
+    );
+  };
+  if (!__next40pxDefaultSize && (otherProps.size === void 0 || otherProps.size === "default")) {
+    (0, import_deprecated.default)(
+      `36px default size for wp.blockEditor.__experimentalFontAppearanceControl`,
+      {
+        since: "6.8",
+        version: "7.1",
+        hint: "Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version."
+      }
+    );
+  }
+  return hasStylesOrWeights && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_components.CustomSelectControl,
+    {
+      ...otherProps,
+      className: "components-font-appearance-control",
+      __next40pxDefaultSize,
+      __shouldNotWarnDeprecated36pxSize: true,
+      label,
+      describedBy: getDescribedBy(),
+      options: selectOptions,
+      value: currentSelection,
+      onChange: ({ selectedItem }) => onChange(selectedItem.style)
+    }
+  );
+}
+//# sourceMappingURL=index.js.map

package/build/components/font-family/index.js

@@ -0,0 +1,94 @@
+"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/components/font-family/index.js
+var font_family_exports = {};
+__export(font_family_exports, {
+  default: () => FontFamilyControl
+});
+module.exports = __toCommonJS(font_family_exports);
+var import_clsx = __toESM(require("clsx"));
+var import_components = require("@wordpress/components");
+var import_deprecated = __toESM(require("@wordpress/deprecated"));
+var import_i18n = require("@wordpress/i18n");
+var import_use_settings = require("../use-settings");
+var import_jsx_runtime = require("react/jsx-runtime");
+function FontFamilyControl({
+  /** Start opting into the larger default height that will become the default size in a future version. */
+  __next40pxDefaultSize = false,
+  value = "",
+  onChange,
+  fontFamilies,
+  className,
+  ...props
+}) {
+  const [blockLevelFontFamilies] = (0, import_use_settings.useSettings)("typography.fontFamilies");
+  if (!fontFamilies) {
+    fontFamilies = blockLevelFontFamilies;
+  }
+  if (!fontFamilies || fontFamilies.length === 0) {
+    return null;
+  }
+  const options = [
+    {
+      key: "",
+      name: (0, import_i18n.__)("Default")
+    },
+    ...fontFamilies.map(({ fontFamily, name }) => ({
+      key: fontFamily,
+      name: name || fontFamily,
+      style: { fontFamily }
+    }))
+  ];
+  if (!__next40pxDefaultSize && (props.size === void 0 || props.size === "default")) {
+    (0, import_deprecated.default)(
+      `36px default size for wp.blockEditor.__experimentalFontFamilyControl`,
+      {
+        since: "6.8",
+        version: "7.1",
+        hint: "Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version."
+      }
+    );
+  }
+  const selectedValue = options.find((option) => option.key === value) ?? "";
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_components.CustomSelectControl,
+    {
+      __next40pxDefaultSize,
+      __shouldNotWarnDeprecated36pxSize: true,
+      label: (0, import_i18n.__)("Font"),
+      value: selectedValue,
+      onChange: ({ selectedItem }) => onChange(selectedItem.key),
+      options,
+      className: (0, import_clsx.default)("block-editor-font-family-control", className),
+      ...props
+    }
+  );
+}
+//# sourceMappingURL=index.js.map

package/build/components/font-sizes/fluid-utils.js

@@ -0,0 +1,172 @@
+"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/components/font-sizes/fluid-utils.js
+var fluid_utils_exports = {};
+__export(fluid_utils_exports, {
+  getComputedFluidTypographyValue: () => getComputedFluidTypographyValue,
+  getTypographyValueAndUnit: () => getTypographyValueAndUnit,
+  roundToPrecision: () => roundToPrecision
+});
+module.exports = __toCommonJS(fluid_utils_exports);
+var DEFAULT_MAXIMUM_VIEWPORT_WIDTH = "1600px";
+var DEFAULT_MINIMUM_VIEWPORT_WIDTH = "320px";
+var DEFAULT_SCALE_FACTOR = 1;
+var DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN = 0.25;
+var DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX = 0.75;
+var DEFAULT_MINIMUM_FONT_SIZE_LIMIT = "14px";
+function getComputedFluidTypographyValue({
+  minimumFontSize,
+  maximumFontSize,
+  fontSize,
+  minimumViewportWidth = DEFAULT_MINIMUM_VIEWPORT_WIDTH,
+  maximumViewportWidth = DEFAULT_MAXIMUM_VIEWPORT_WIDTH,
+  scaleFactor = DEFAULT_SCALE_FACTOR,
+  minimumFontSizeLimit
+}) {
+  minimumFontSizeLimit = !!getTypographyValueAndUnit(minimumFontSizeLimit) ? minimumFontSizeLimit : DEFAULT_MINIMUM_FONT_SIZE_LIMIT;
+  if (fontSize) {
+    const fontSizeParsed = getTypographyValueAndUnit(fontSize);
+    if (!fontSizeParsed?.unit) {
+      return null;
+    }
+    const minimumFontSizeLimitParsed = getTypographyValueAndUnit(
+      minimumFontSizeLimit,
+      {
+        coerceTo: fontSizeParsed.unit
+      }
+    );
+    if (!!minimumFontSizeLimitParsed?.value && !minimumFontSize && !maximumFontSize) {
+      if (fontSizeParsed?.value <= minimumFontSizeLimitParsed?.value) {
+        return null;
+      }
+    }
+    if (!maximumFontSize) {
+      maximumFontSize = `${fontSizeParsed.value}${fontSizeParsed.unit}`;
+    }
+    if (!minimumFontSize) {
+      const fontSizeValueInPx = fontSizeParsed.unit === "px" ? fontSizeParsed.value : fontSizeParsed.value * 16;
+      const minimumFontSizeFactor = Math.min(
+        Math.max(
+          1 - 0.075 * Math.log2(fontSizeValueInPx),
+          DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MIN
+        ),
+        DEFAULT_MINIMUM_FONT_SIZE_FACTOR_MAX
+      );
+      const calculatedMinimumFontSize = roundToPrecision(
+        fontSizeParsed.value * minimumFontSizeFactor,
+        3
+      );
+      if (!!minimumFontSizeLimitParsed?.value && calculatedMinimumFontSize < minimumFontSizeLimitParsed?.value) {
+        minimumFontSize = `${minimumFontSizeLimitParsed.value}${minimumFontSizeLimitParsed.unit}`;
+      } else {
+        minimumFontSize = `${calculatedMinimumFontSize}${fontSizeParsed.unit}`;
+      }
+    }
+  }
+  const minimumFontSizeParsed = getTypographyValueAndUnit(minimumFontSize);
+  const fontSizeUnit = minimumFontSizeParsed?.unit || "rem";
+  const maximumFontSizeParsed = getTypographyValueAndUnit(maximumFontSize, {
+    coerceTo: fontSizeUnit
+  });
+  if (!minimumFontSizeParsed || !maximumFontSizeParsed) {
+    return null;
+  }
+  const minimumFontSizeRem = getTypographyValueAndUnit(minimumFontSize, {
+    coerceTo: "rem"
+  });
+  const maximumViewportWidthParsed = getTypographyValueAndUnit(
+    maximumViewportWidth,
+    { coerceTo: fontSizeUnit }
+  );
+  const minimumViewportWidthParsed = getTypographyValueAndUnit(
+    minimumViewportWidth,
+    { coerceTo: fontSizeUnit }
+  );
+  if (!maximumViewportWidthParsed || !minimumViewportWidthParsed || !minimumFontSizeRem) {
+    return null;
+  }
+  const linearDenominator = maximumViewportWidthParsed.value - minimumViewportWidthParsed.value;
+  if (!linearDenominator) {
+    return null;
+  }
+  const minViewportWidthOffsetValue = roundToPrecision(
+    minimumViewportWidthParsed.value / 100,
+    3
+  );
+  const viewportWidthOffset = roundToPrecision(minViewportWidthOffsetValue, 3) + fontSizeUnit;
+  const linearFactor = 100 * ((maximumFontSizeParsed.value - minimumFontSizeParsed.value) / linearDenominator);
+  const linearFactorScaled = roundToPrecision(
+    (linearFactor || 1) * scaleFactor,
+    3
+  );
+  const fluidTargetFontSize = `${minimumFontSizeRem.value}${minimumFontSizeRem.unit} + ((1vw - ${viewportWidthOffset}) * ${linearFactorScaled})`;
+  return `clamp(${minimumFontSize}, ${fluidTargetFontSize}, ${maximumFontSize})`;
+}
+function getTypographyValueAndUnit(rawValue, options = {}) {
+  if (typeof rawValue !== "string" && typeof rawValue !== "number") {
+    return null;
+  }
+  if (isFinite(rawValue)) {
+    rawValue = `${rawValue}px`;
+  }
+  const { coerceTo, rootSizeValue, acceptableUnits } = {
+    coerceTo: "",
+    // Default browser font size. Later we could inject some JS to compute this `getComputedStyle( document.querySelector( "html" ) ).fontSize`.
+    rootSizeValue: 16,
+    acceptableUnits: ["rem", "px", "em"],
+    ...options
+  };
+  const acceptableUnitsGroup = acceptableUnits?.join("|");
+  const regexUnits = new RegExp(
+    `^(\\d*\\.?\\d+)(${acceptableUnitsGroup}){1,1}$`
+  );
+  const matches = rawValue.match(regexUnits);
+  if (!matches || matches.length < 3) {
+    return null;
+  }
+  let [, value, unit] = matches;
+  let returnValue = parseFloat(value);
+  if ("px" === coerceTo && ("em" === unit || "rem" === unit)) {
+    returnValue = returnValue * rootSizeValue;
+    unit = coerceTo;
+  }
+  if ("px" === unit && ("em" === coerceTo || "rem" === coerceTo)) {
+    returnValue = returnValue / rootSizeValue;
+    unit = coerceTo;
+  }
+  if (("em" === coerceTo || "rem" === coerceTo) && ("em" === unit || "rem" === unit)) {
+    unit = coerceTo;
+  }
+  return {
+    value: roundToPrecision(returnValue, 3),
+    unit
+  };
+}
+function roundToPrecision(value, digits = 3) {
+  const base = Math.pow(10, digits);
+  return Number.isFinite(value) ? parseFloat(Math.round(value * base) / base) : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getComputedFluidTypographyValue,
+  getTypographyValueAndUnit,
+  roundToPrecision
+});
+//# sourceMappingURL=fluid-utils.js.map