@wordpress/block-editor 15.22.1-next.v.202606191442.0 → 15.22.1

package/build-style/style.css

@@ -1519,14 +1519,22 @@ iframe[name=editor-canvas] {
   background: linear-gradient(-45deg, transparent 48%, #ddd 48%, #ddd 52%, transparent 52%);
 }
 
+.block-editor-panel-color-gradient-settings__contrast-notice {
+  margin-bottom: 16px;
+}
+
 /**
 * The following styles replicate the separated border of the
 * `ItemGroup` component but allows for hidden items. This is because
 * to maintain the order of `ToolsPanel` controls, each `ToolsPanelItem`
 * must at least render a placeholder which would otherwise interfere
 * with the `:last-child` styles.
+*
+* Applied via the shared `block-editor-color-gradient-item` class on
+* color/gradient dropdown items across the Color, Background, and
+* Typography panels.
 */
-.block-editor-tools-panel-color-gradient-settings__item {
+.block-editor-color-gradient-item {
   padding: 0;
   max-width: 100%;
   position: relative;
@@ -1534,18 +1542,17 @@ iframe[name=editor-canvas] {
   border-right: 1px solid #ddd;
   border-bottom: 1px solid #ddd;
 }
-.block-editor-tools-panel-color-gradient-settings__item:nth-child(1 of .block-editor-tools-panel-color-gradient-settings__item) {
-  margin-top: 24px;
+.block-editor-color-gradient-item:nth-child(1 of .block-editor-color-gradient-item) {
   border-top-left-radius: 2px;
   border-top-right-radius: 2px;
   border-top: 1px solid #ddd;
 }
-.block-editor-tools-panel-color-gradient-settings__item:nth-last-child(1 of .block-editor-tools-panel-color-gradient-settings__item) {
+.block-editor-color-gradient-item:nth-last-child(1 of .block-editor-color-gradient-item) {
   border-bottom-left-radius: 2px;
   border-bottom-right-radius: 2px;
 }
-.block-editor-tools-panel-color-gradient-settings__item > div,
-.block-editor-tools-panel-color-gradient-settings__item > div > button {
+.block-editor-color-gradient-item > div,
+.block-editor-color-gradient-item > div > button {
   border-radius: inherit;
 }
 
@@ -1569,6 +1576,9 @@ iframe[name=editor-canvas] {
   text-overflow: ellipsis;
   max-width: calc(100% - 44px);
 }
+.block-editor-tools-panel-color-gradient-settings__dropdown > button.has-contrast-warning .block-editor-panel-color-gradient-settings__color-name {
+  max-width: calc(100% - 72px);
+}
 
 .block-editor-panel-color-gradient-settings__dropdown {
   width: 100%;
@@ -1600,6 +1610,19 @@ iframe[name=editor-canvas] {
     opacity: 1;
   }
 }
+.block-editor-panel-color-gradient-settings__dropdown.has-contrast-warning + .block-editor-panel-color-gradient-settings__reset {
+  right: 28px;
+}
+
+.block-editor-panel-color-gradient-settings__contrast-warning {
+  position: absolute;
+  right: 0;
+  top: 8px;
+  margin: auto 8px auto;
+}
+.block-editor-panel-color-gradient-settings__contrast-warning.block-editor-panel-color-gradient-settings__contrast-warning {
+  border-radius: 2px;
+}
 
 .block-editor-date-format-picker {
   margin: 0 0 16px;
@@ -3412,33 +3435,6 @@ iframe[name=editor-canvas] {
   font-size: 12px;
 }
 
-/**
- * ItemGroup-like border styles for the background panel's ToolsPanelItems.
- * Replicates the separated border of the `ItemGroup` component while
- * allowing for hidden placeholder items (same approach as the color panel).
- */
-.block-editor-background-panel__item {
-  padding: 0;
-  max-width: 100%;
-  position: relative;
-  border-left: 1px solid #ddd;
-  border-right: 1px solid #ddd;
-  border-bottom: 1px solid #ddd;
-}
-.block-editor-background-panel__item:nth-child(1 of .block-editor-background-panel__item) {
-  border-top-left-radius: 2px;
-  border-top-right-radius: 2px;
-  border-top: 1px solid #ddd;
-}
-.block-editor-background-panel__item:nth-last-child(1 of .block-editor-background-panel__item) {
-  border-bottom-left-radius: 2px;
-  border-bottom-right-radius: 2px;
-}
-.block-editor-background-panel__item > div,
-.block-editor-background-panel__item > div > button {
-  border-radius: inherit;
-}
-
 .background-block-support-panel {
   /* Increased specificity required to remove the slot wrapper's row gap */
 }
@@ -3653,15 +3649,12 @@ div.block-editor-bindings__panel button:hover .block-editor-bindings__item span
 .color-block-support-panel.color-block-support-panel .color-block-support-panel__inner-wrapper {
   row-gap: 0;
 }
-.color-block-support-panel {
-  /**
-   * After converting PanelColorGradientSettings to render as a ToolsPanel
-   * we need to remove the top margin when wrapping inner content due to
-   * rendering via SlotFills.
-   */
+
+.elements-block-support-panel {
+  /* Increased specificity required to remove the slot wrapper's row gap */
 }
-.color-block-support-panel .block-editor-tools-panel-color-gradient-settings__item.first {
-  margin-top: 0;
+.elements-block-support-panel.elements-block-support-panel .elements-block-support-panel__inner-wrapper {
+  row-gap: 0;
 }
 
 .dimensions-block-support-panel .single-column {

package/build-types/utils/block-bindings.d.ts

@@ -0,0 +1,27 @@
+type Binding = {
+    source?: string;
+};
+type Bindings = Record<string, Binding>;
+/**
+ * Checks if the block has the `__default` binding for pattern overrides.
+ *
+ * @param bindings A block's bindings from the metadata attribute.
+ *
+ * @return Whether the block has the `__default` binding for pattern overrides.
+ */
+export declare function hasPatternOverridesDefaultBinding(bindings: Bindings | undefined | null): bindings is Bindings;
+/**
+ * Returns the bindings with the `__default` binding for pattern overrides
+ * replaced with the full-set of supported attributes. e.g.:
+ *
+ * - bindings passed in: `{ __default: { source: 'core/pattern-overrides' } }`
+ * - bindings returned: `{ content: { source: 'core/pattern-overrides' } }`
+ *
+ * @param bindings            A block's bindings from the metadata attribute.
+ * @param supportedAttributes The block's attributes which are supported by block bindings.
+ *
+ * @return The bindings with default replaced for pattern overrides.
+ */
+export declare function replacePatternOverridesDefaultBinding(bindings: Bindings | undefined | null, supportedAttributes: string[]): Bindings | null | undefined;
+export {};
+//# sourceMappingURL=block-bindings.d.ts.map

package/build-types/utils/block-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-bindings.d.ts","sourceRoot":"","sources":["../../src/utils/block-bindings.ts"],"names":[],"mappings":"AAAA,KAAK,OAAO,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACnC,KAAK,QAAQ,GAAG,MAAM,CAAE,MAAM,EAAE,OAAO,CAAE,CAAC;AAK1C;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAChD,QAAQ,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,GACnC,QAAQ,IAAI,QAAQ,CAEtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qCAAqC,CACpD,QAAQ,EAAE,QAAQ,GAAG,SAAS,GAAG,IAAI,EACrC,mBAAmB,EAAE,MAAM,EAAE,+BAiB7B"}

package/build-types/utils/color-values.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Extracts the palette slug from a style value for any preset type, supporting
+ * both the user preset format and the theme CSS-variable format:
+ *
+ * - User format:  `var:preset|<type>|slug`
+ * - Theme format: `var(--wp--preset--<type>--slug)`
+ *
+ * Returns `undefined` for plain values, non-strings, or any other
+ * unrecognised format.
+ *
+ * @param rawValue Raw style value stored in the style object.
+ * @param type     Preset type, e.g. `'color'` or `'gradient'`.
+ * @return The palette slug, or undefined.
+ */
+export declare function extractPresetSlug(rawValue: unknown, type: 'color' | 'gradient'): string | undefined;
+/**
+ * Encodes a color value for storage in the style object.
+ *
+ * When a `slug` is provided it is used directly (the slug-based selection
+ * path). This is important because two palette entries can share the same
+ * hex value (e.g. two custom colors both set to `#e10000`); relying on a
+ * hex lookup alone would collapse them onto whichever entry appears first
+ * in the palette and silently discard the user's actual choice. Only when
+ * no slug is supplied does the function fall back to matching the hex value
+ * against the palette; if a match is found the slug is encoded, otherwise
+ * the raw value is stored as-is.
+ *
+ * Callers pass the flattened palette (`allColors`), typically computed once
+ * per render from the per-origin `colors` array.
+ *
+ * @param allColors  Flat array of `{ color, slug }` objects.
+ * @param colorValue Hex or CSS color string.
+ * @param slug       Optional palette slug from slug-aware selection.
+ * @return Encoded value suitable for the style object.
+ */
+export declare function encodeColorValueWithPalette(allColors: {
+    color: string;
+    slug: string;
+}[], colorValue?: string, slug?: string): string | undefined;
+//# sourceMappingURL=color-values.d.ts.map

package/build-types/utils/color-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-values.d.ts","sourceRoot":"","sources":["../../src/utils/color-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,OAAO,GAAG,UAAU,sBAc1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CAC1C,SAAS,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,EAC5C,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,MAAM,sBAOb"}

package/build-types/utils/dom.d.ts

@@ -1,45 +1,45 @@
 /**
  * Returns true if two elements are contained within the same block.
  *
- * @param {Element} a First element.
- * @param {Element} b Second element.
+ * @param a First element.
+ * @param b Second element.
  *
- * @return {boolean} Whether elements are in the same block.
+ * @return Whether elements are in the same block.
  */
 export declare function isInSameBlock(a: Element, b: Element): boolean;
 /**
  * Returns true if an element is considered part of the block and not its inner
  * blocks or appender.
  *
- * @param {Element} blockElement Block container element.
- * @param {Element} element      Element.
+ * @param blockElement Block container element.
+ * @param element      Element.
  *
- * @return {boolean} Whether an element is considered part of the block and not
- *                   its inner blocks or appender.
+ * @return Whether an element is considered part of the block and not
+ *         its inner blocks or appender.
  */
 export declare function isInsideRootBlock(blockElement: Element, element: Element): boolean;
 /**
  * Finds the block client ID given any DOM node inside the block.
  *
- * @param {Node?} node DOM node.
+ * @param node DOM node.
  *
- * @return {string|undefined} Client ID or undefined if the node is not part of
- *                            a block.
+ * @return Client ID or undefined if the node is not part of
+ *         a block.
  */
 export declare function getBlockClientId(node: Node | null): string | undefined;
 /**
  * Calculates the union of two rectangles.
  *
- * @param {DOMRect} rect1 First rectangle.
- * @param {DOMRect} rect2 Second rectangle.
- * @return {DOMRect} Union of the two rectangles.
+ * @param rect1 First rectangle.
+ * @param rect2 Second rectangle.
+ * @return Union of the two rectangles.
  */
-export declare function rectUnion(rect1: DOMRect, rect2: DOMRect): DOMRect;
+export declare function rectUnion(rect1: DOMRect, rect2: DOMRect): DOMRectReadOnly;
 /**
  * Returns whether an element is visible.
  *
- * @param {Element} element Element.
- * @return {boolean} Whether the element is visible.
+ * @param element Element.
+ * @return Whether the element is visible.
  */
 export declare function isElementVisible(element: Element): boolean;
 export declare const WITH_OVERFLOW_ELEMENT_BLOCKS: string[];
@@ -53,8 +53,8 @@ export declare const WITH_OVERFLOW_ELEMENT_BLOCKS: string[];
  * The returned rect represents the full extent of the element and its visible
  * children, which may extend beyond the viewport.
  *
- * @param {Element} element Element.
- * @return {DOMRect} Bounding client rect of the element and its visible children.
+ * @param element Element.
+ * @return Bounding client rect of the element and its visible children.
  */
-export declare function getElementBounds(element: Element): DOMRect;
+export declare function getElementBounds(element: Element): DOMRectReadOnly;
 //# sourceMappingURL=dom.d.ts.map

package/build-types/utils/dom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/utils/dom.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAE,CAAC,EALrB,OAKqB,EAAE,CAAC,EAJxB,OAIwB,GAFvB,OAAO,CAIlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAE,YAAY,EANpC,OAMoC,EAAE,OAAO,EAL7C,OAK6C,GAH5C,OAAO,CAQlB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAE,IAAI,EAL3B,IAAI,OAKuB,GAH1B,MAAM,GAAC,SAAS,CAoB3B;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAE,KAAK,EAJrB,OAIqB,EAAE,KAAK,EAH5B,OAG4B,GAF3B,OAAO,CASlB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAE,OAAO,EAH9B,OAG8B,GAF7B,OAAO,CAsClB;AAkBD,eAAO,MAAM,4BAA4B,UAAwB,CAAC;AAClE;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAE,OAAO,EAH9B,OAG8B,GAF7B,OAAO,CAoDlB"}
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/utils/dom.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,WAEpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,WAKzE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAE,IAAI,EAAE,IAAI,GAAG,IAAI,sBAiBlD;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,mBAOxD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAE,OAAO,EAAE,OAAO,WAoCjD;AAkBD,eAAO,MAAM,4BAA4B,UAAwB,CAAC;AAClE;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAE,OAAO,EAAE,OAAO,mBAkDjD"}

package/build-types/utils/fit-text-frontend.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Frontend fit text functionality.
+ * Automatically detects and initializes fit text on blocks with the has-fit-text class.
+ * Supports both initial page load and Interactivity API client-side navigation.
+ */
+export {};
+//# sourceMappingURL=fit-text-frontend.d.ts.map

package/build-types/utils/fit-text-frontend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit-text-frontend.d.ts","sourceRoot":"","sources":["../../src/utils/fit-text-frontend.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/build-types/utils/fit-text-utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared utility functions for fit text functionality.
+ * Uses callback-based approach for maximum code reuse between editor and frontend.
+ */
+type ApplyFontSize = (size: number) => void;
+/**
+ * Complete fit text optimization for a single text element.
+ * Handles the full flow using callbacks for font size application.
+ *
+ * @param textElement   The text element (paragraph, heading, etc.)
+ * @param applyFontSize Function that receives font size in pixels (0 to clear, >0 to apply)
+ */
+export declare function optimizeFitText(textElement: HTMLElement | null, applyFontSize: ApplyFontSize): number | undefined;
+export {};
+//# sourceMappingURL=fit-text-utils.d.ts.map

package/build-types/utils/fit-text-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit-text-utils.d.ts","sourceRoot":"","sources":["../../src/utils/fit-text-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,aAAa,GAAG,CAAE,IAAI,EAAE,MAAM,KAAM,IAAI,CAAC;AAmF9C;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,WAAW,GAAG,IAAI,EAC/B,aAAa,EAAE,aAAa,sBAY5B"}

package/build-types/utils/format-font-style.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal dependencies
+ */
+import type { FormattedFont } from './types';
+/**
+ * Formats font styles to human readable names.
+ *
+ * @param fontStyle font style string
+ * @return new object with formatted font style
+ */
+export declare function formatFontStyle(fontStyle: FormattedFont | string | undefined): FormattedFont;
+//# sourceMappingURL=format-font-style.d.ts.map

package/build-types/utils/format-font-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-font-style.d.ts","sourceRoot":"","sources":["../../src/utils/format-font-style.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,SAAS,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,GAC3C,aAAa,CA4Bf"}

package/build-types/utils/format-font-weight.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal dependencies
+ */
+import type { FormattedFont } from './types';
+/**
+ * Formats font weights to human readable names.
+ *
+ * @param fontWeight font weight string
+ * @return new object with formatted font weight
+ */
+export declare function formatFontWeight(fontWeight: FormattedFont | string | undefined): FormattedFont;
+//# sourceMappingURL=format-font-weight.d.ts.map

package/build-types/utils/format-font-weight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-font-weight.d.ts","sourceRoot":"","sources":["../../src/utils/format-font-weight.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,aAAa,GAAG,MAAM,GAAG,SAAS,GAC5C,aAAa,CAmDf"}

package/build-types/utils/get-editor-region.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gets the editor region for a given editor canvas element or
+ * returns the passed element if no region is found
+ *
+ * @param editor The editor canvas element.
+ * @return The editor region or given editor element
+ */
+export default function getEditorRegion(editor: Element | null | undefined): Element | null;
+//# sourceMappingURL=get-editor-region.d.ts.map

package/build-types/utils/get-editor-region.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-editor-region.d.ts","sourceRoot":"","sources":["../../src/utils/get-editor-region.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAE,MAAM,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,kBA2B1E"}

package/build-types/utils/get-font-styles-and-weights.d.ts

@@ -0,0 +1,16 @@
+import type { FontFamilyFace, FormattedFont, CombinedStyleAndWeightOption } from './types';
+/**
+ * Builds a list of font style and weight options based on font family faces.
+ * Defaults to the standard font styles and weights if no font family faces are provided.
+ *
+ * @param fontFamilyFaces font family faces array
+ * @return new object with combined and separated font style and weight properties
+ */
+export declare function getFontStylesAndWeights(fontFamilyFaces: FontFamilyFace[] | undefined): {
+    fontStyles: FormattedFont[];
+    fontWeights: FormattedFont[];
+    combinedStyleAndWeightOptions: CombinedStyleAndWeightOption[];
+    isSystemFont: boolean;
+    isVariableFont: boolean;
+};
+//# sourceMappingURL=get-font-styles-and-weights.d.ts.map

package/build-types/utils/get-font-styles-and-weights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-font-styles-and-weights.d.ts","sourceRoot":"","sources":["../../src/utils/get-font-styles-and-weights.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACX,cAAc,EACd,aAAa,EACb,4BAA4B,EAC5B,MAAM,SAAS,CAAC;AAwDjB;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACtC,eAAe,EAAE,cAAc,EAAE,GAAG,SAAS;;;;;;EA4H7C"}

package/build-types/utils/get-px-from-css-unit.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This function was accidentally exposed for mobile/native usage.
+ *
+ * @deprecated
+ *
+ * @return {string} Empty string.
+ */
+declare const _default: () => string;
+export default _default;
+//# sourceMappingURL=get-px-from-css-unit.d.ts.map

package/build-types/utils/get-px-from-css-unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-px-from-css-unit.d.ts","sourceRoot":"","sources":["../../src/utils/get-px-from-css-unit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/build-types/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { default as transformStyles } from './transform-styles';
+export { default as getPxFromCssUnit } from './get-px-from-css-unit';
+//# sourceMappingURL=index.d.ts.map

package/build-types/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/build-types/utils/math.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A string representing the name of an edge.
+ */
+type EdgeName = 'top' | 'right' | 'bottom' | 'left';
+interface Point {
+    /** The horizontal position. */
+    x: number;
+    /** The vertical position. */
+    y: number;
+}
+/**
+ * Given a point, a DOMRect and the name of an edge, returns the distance to
+ * that edge of the rect.
+ *
+ * This function works for edges that are horizontal or vertical (e.g. not
+ * rotated), the following terms are used so that the function works in both
+ * orientations:
+ *
+ * - Forward, meaning the axis running horizontally when an edge is vertical
+ *   and vertically when an edge is horizontal.
+ * - Lateral, meaning the axis running vertically when an edge is vertical
+ *   and horizontally when an edge is horizontal.
+ *
+ * @param point The point to measure distance from.
+ * @param rect  A DOM Rect containing edge positions.
+ * @param edge  The edge to measure to.
+ */
+export declare function getDistanceFromPointToEdge(point: Point, rect: DOMRect, edge: EdgeName): number;
+/**
+ * Given a point, a DOMRect and a list of allowed edges returns the name of and
+ * distance to the nearest edge.
+ *
+ * @param point        The point to measure distance from.
+ * @param rect         A DOM Rect containing edge positions.
+ * @param allowedEdges A list of the edges included in the
+ *                     calculation. Defaults to all edges.
+ *
+ * @return An array where the first value is the distance
+ *         and a second is the edge name.
+ */
+export declare function getDistanceToNearestEdge(point: Point, rect: DOMRect, allowedEdges?: EdgeName[]): (number | EdgeName | undefined)[];
+/**
+ * Is the point contained by the rectangle.
+ *
+ * @param point The point.
+ * @param rect  The rectangle.
+ *
+ * @return True if the point is contained by the rectangle, false otherwise.
+ */
+export declare function isPointContainedByRect(point: Point, rect: DOMRect): boolean;
+/**
+ * Is the point within the top and bottom boundaries of the rectangle.
+ *
+ * @param point The point.
+ * @param rect  The rectangle.
+ *
+ * @return True if the point is within top and bottom of rectangle, false otherwise.
+ */
+export declare function isPointWithinTopAndBottomBoundariesOfRect(point: Point, rect: DOMRect): boolean;
+export {};
+//# sourceMappingURL=math.d.ts.map

package/build-types/utils/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../src/utils/math.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,KAAK,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEpD,UAAU,KAAK;IACd,+BAA+B;IAC/B,CAAC,EAAE,MAAM,CAAC;IACV,6BAA6B;IAC7B,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CACzC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,QAAQ,UA8Bd;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,OAAO,EACb,YAAY,GAAE,QAAQ,EAAyC,qCAe/D;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,WAOlE;AAED;;;;;;;GAOG;AACH,wBAAgB,yCAAyC,CACxD,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,OAAO,WAGb"}

package/build-types/utils/object.d.ts

@@ -0,0 +1,39 @@
+type AnyObject = Record<string, unknown>;
+type ObjectOrArray = AnyObject | unknown[];
+type ObjectPathKey = number | string;
+type ObjectPath = ObjectPathKey | ObjectPathKey[];
+/**
+ * Immutably sets a value inside an object. Like `lodash#set`, but returning a
+ * new object. Treats nullish initial values as empty objects. Clones any
+ * nested objects. Supports arrays, too.
+ *
+ * @param object Object to set a value in.
+ * @param path   Path in the object to modify.
+ * @param value  New value to set.
+ * @return Cloned object with the new value set.
+ */
+export declare function setImmutably(object: ObjectOrArray | null | undefined, path: ObjectPath, value: unknown): ObjectOrArray;
+/**
+ * Helper util to return a value from a certain path of the object.
+ * Path is specified as either:
+ * - a string of properties, separated by dots, for example: "x.y".
+ * - an array of properties, for example `[ 'x', 'y' ]`.
+ * You can also specify a default value in case the result is nullish.
+ *
+ * @param object       Input object.
+ * @param path         Path to the object property.
+ * @param defaultValue Default value if the value at the specified path is nullish.
+ * @return Value of the object property at the specified path.
+ */
+export declare const getValueFromObjectPath: (object: AnyObject | undefined | null, path: string | string[], defaultValue?: unknown) => unknown;
+/**
+ * Helper util to filter out objects with duplicate values for a given property.
+ *
+ * @param array    Array of objects to filter.
+ * @param property Property to filter unique values by.
+ *
+ * @return Array of objects with unique values for the specified property.
+ */
+export declare function uniqByProperty<T extends AnyObject>(array: T[], property: string): T[];
+export {};
+//# sourceMappingURL=object.d.ts.map

package/build-types/utils/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/utils/object.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,MAAM,CAAE,MAAM,EAAE,OAAO,CAAE,CAAC;AAC3C,KAAK,aAAa,GAAG,SAAS,GAAG,OAAO,EAAE,CAAC;AAC3C,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,CAAC;AACrC,KAAK,UAAU,GAAG,aAAa,GAAG,aAAa,EAAE,CAAC;AAElD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,EACxC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,OAAO,GACZ,aAAa,CAyBf;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,WAC1B,SAAS,GAAG,SAAS,GAAG,IAAI,QAC9B,MAAM,GAAG,MAAM,EAAE,iBACR,OAAO,YAQtB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAE,CAAC,SAAS,SAAS,EAClD,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,EAAE,MAAM,OAOhB"}

package/build-types/utils/order-inserter-block-items.d.ts

@@ -0,0 +1,13 @@
+type EditorInserterItem = {
+    id: string;
+};
+/**
+ * Helper function to order inserter block items according to a provided array of prioritized blocks.
+ *
+ * @param items    The array of editor inserter block items to be sorted.
+ * @param priority The array of block names to be prioritized.
+ * @return The sorted array of editor inserter block items.
+ */
+export declare const orderInserterBlockItems: (items: EditorInserterItem[], priority: string[] | undefined) => EditorInserterItem[];
+export {};
+//# sourceMappingURL=order-inserter-block-items.d.ts.map

package/build-types/utils/order-inserter-block-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-inserter-block-items.d.ts","sourceRoot":"","sources":["../../src/utils/order-inserter-block-items.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,UAC5B,kBAAkB,EAAE,YACjB,MAAM,EAAE,GAAG,SAAS,yBAqB9B,CAAC"}

package/build-types/utils/pasting.d.ts

@@ -0,0 +1,28 @@
+export declare function getPasteEventData({ clipboardData }: {
+    clipboardData: DataTransfer;
+}): {
+    files: File[];
+    html?: undefined;
+    plainText?: undefined;
+} | {
+    html: string;
+    plainText: string;
+    files: never[];
+} | undefined;
+/**
+ * Given a collection of DataTransfer files and HTML and plain text strings,
+ * determine whether the files are to be dismissed in favor of the HTML.
+ *
+ * Certain office-type programs, like Microsoft Word or Apple Numbers,
+ * will, upon copy, generate a screenshot of the content being copied and
+ * attach it to the clipboard alongside the actual rich text that the user
+ * sought to copy. In those cases, we should let Gutenberg handle the rich text
+ * content and not the screenshot, since this allows Gutenberg to insert
+ * meaningful blocks, like paragraphs, lists or even tables.
+ *
+ * @param files File objects obtained from a paste event
+ * @param html  HTML content obtained from a paste event
+ * @return      True if the files should be dismissed
+ */
+export declare function shouldDismissPastedFiles(files: File[], html: string): boolean;
+//# sourceMappingURL=pasting.d.ts.map

package/build-types/utils/pasting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pasting.d.ts","sourceRoot":"","sources":["../../src/utils/pasting.ts"],"names":[],"mappings":"AAkDA,wBAAgB,iBAAiB,CAAE,EAClC,aAAa,EACb,EAAE;IACF,aAAa,EAAE,YAAY,CAAC;CAC5B;;;;;;;;cA2BA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,MAAM,WA+BZ"}

package/build-types/utils/selection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A robust way to retain selection position through various
+ * transforms is to insert a special character at the position and
+ * then recover it.
+ */
+export declare const START_OF_SELECTED_AREA = "\u0086";
+/**
+ * Retrieve the block attribute that contains the selection position.
+ *
+ * @param blockAttributes Block attributes.
+ * @return The name of the block attribute that was previously selected.
+ */
+export declare function retrieveSelectedAttribute(blockAttributes: Record<string, unknown> | undefined): string | undefined;
+type BlockTypeWithAttributes = {
+    attributes: Record<string, {
+        source?: string;
+    }>;
+};
+export declare function findRichTextAttributeKey(blockType: BlockTypeWithAttributes): string | undefined;
+export {};
+//# sourceMappingURL=selection.d.ts.map

package/build-types/utils/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/utils/selection.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,WAAW,CAAC;AAE/C;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACxC,eAAe,EAAE,MAAM,CAAE,MAAM,EAAE,OAAO,CAAE,GAAG,SAAS,sBAetD;AAED,KAAK,uBAAuB,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAE,MAAM,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAE,CAAC;CAClD,CAAC;AAEF,wBAAgB,wBAAwB,CAAE,SAAS,EAAE,uBAAuB,sBAO3E"}

package/build-types/utils/sorting.d.ts

@@ -0,0 +1,17 @@
+type Comparable = string | number | undefined;
+type SortItem = Record<string, Comparable>;
+type SortField<T> = string | ((item: T) => Comparable);
+/**
+ * Order items by a certain key.
+ * Supports decorator functions that allow complex picking of a comparison field.
+ * Sorts in ascending order by default, but supports descending as well.
+ * Stable sort - maintains original order of equal items.
+ *
+ * @param items Items to order.
+ * @param field Field to order by.
+ * @param order Sorting order, `asc` or `desc`.
+ * @return Sorted items.
+ */
+export declare function orderBy<T extends SortItem>(items: T[], field: SortField<T>, order?: string): T[];
+export {};
+//# sourceMappingURL=sorting.d.ts.map

package/build-types/utils/sorting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorting.d.ts","sourceRoot":"","sources":["../../src/utils/sorting.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAC9C,KAAK,QAAQ,GAAG,MAAM,CAAE,MAAM,EAAE,UAAU,CAAE,CAAC;AAC7C,KAAK,SAAS,CAAE,CAAC,IAAK,MAAM,GAAG,CAAE,CAAE,IAAI,EAAE,CAAC,KAAM,UAAU,CAAE,CAAC;AA6D7D;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAE,CAAC,SAAS,QAAQ,EAC1C,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,SAAS,CAAE,CAAC,CAAE,EACrB,KAAK,SAAQ,OAGb"}

package/build-types/utils/transform-styles/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Internal dependencies
+ */
+import type { EditorStyle, TransformOptions } from './types';
+/**
+ * Applies a series of CSS rule transforms to wrap selectors inside a given class and/or rewrite URLs depending on the parameters passed.
+ *
+ * @param styles           CSS rules.
+ * @param wrapperSelector  Wrapper selector.
+ * @param transformOptions Additional options for style transformation.
+ * @return converted rules.
+ */
+declare const transformStyles: (styles: EditorStyle[], wrapperSelector?: string, transformOptions?: TransformOptions) => any[];
+export default transformStyles;
+//# sourceMappingURL=index.d.ts.map