@ckeditor/ckeditor5-utils 48.8.1-alpha.4 → 49.0.0-alpha.1

package/dist/dom/getborderwidths.d.ts

@@ -1,24 +1,24 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/getborderwidths
- */
+* @module utils/dom/getborderwidths
+*/
 /**
- * Returns an object containing CSS border widths of a specified HTML element.
- *
- * @param element An element which has CSS borders.
- * @returns An object containing `top`, `left`, `right` and `bottom` properties
- * with numerical values of the `border-[top,left,right,bottom]-width` CSS styles.
- */
+* Returns an object containing CSS border widths of a specified HTML element.
+*
+* @param element An element which has CSS borders.
+* @returns An object containing `top`, `left`, `right` and `bottom` properties
+* with numerical values of the `border-[top,left,right,bottom]-width` CSS styles.
+*/
 export declare function getBorderWidths(element: HTMLElement): BorderWidths;
 /**
- * An object describing widths of `HTMLElement` borders.
+* An object describing widths of `HTMLElement` borders.
 */
 export interface BorderWidths {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
+	top: number;
+	right: number;
+	bottom: number;
+	left: number;
 }

package/dist/dom/getdatafromelement.d.ts

@@ -1,14 +1,14 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/getdatafromelement
- */
+* @module utils/dom/getdatafromelement
+*/
 /**
- * Gets data from a given source element.
- *
- * @param el The element from which the data will be retrieved.
- * @returns The data string.
- */
+* Gets data from a given source element.
+*
+* @param el The element from which the data will be retrieved.
+* @returns The data string.
+*/
 export declare function getDataFromElement(el: HTMLElement): string;

package/dist/dom/getelementfrompoint.d.ts

@@ -0,0 +1,23 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Returns the topmost element at the given viewport point, looking inside the given shadow roots.
+*
+* The shadow-aware replacement for `Document#elementFromPoint()`, which retargets a point inside a shadow tree
+* to that tree's host and so cannot report the element actually under it.
+*
+* Pass every shadow root a hit may land in – typically each editable's own `getRootNode()`. Only the innermost
+* root containing the point matters, so ancestor roots do not need to be listed, and a point in the light DOM
+* needs no roots at all.
+*
+* The point is hit tested strictly, honoring `pointer-events`, so the answer is the element that a click at
+* those coordinates would reach. The exception is an engine that cannot hit test a shadow root, where the point
+* is resolved from the nearest caret position instead and may land beside what it really hit.
+*
+* @param x The horizontal coordinate, relative to the viewport.
+* @param y The vertical coordinate, relative to the viewport.
+* @param shadowRoots The shadow roots the lookup is allowed to look inside. Empty for the light DOM.
+*/
+export declare function getElementFromPoint(x: number, y: number, shadowRoots?: Array<ShadowRoot>): Element | null;

package/dist/dom/getlayoutparentelement.d.ts

@@ -0,0 +1,18 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Returns the parent element in the **flattened tree**, the one the browser lays out and paints.
+*
+* The layout-aware counterpart of {@link module:utils/dom/getparentelement~getParentElement}, and the element-only
+* form of {@link module:utils/dom/getlayoutparentnode~getLayoutParentNode} – see that one for why the flattened
+* tree and the node tree disagree for slotted content, and for when to prefer which.
+*
+* Use it to walk outwards over the elements that lay a node out: its scrollable ancestors, its clipping ancestors.
+* Works for open and closed roots alike, and falls back to the node tree for slotted content inside a closed root,
+* whose slot the DOM standard does not expose.
+*
+* @param node The node to get the layout parent element of.
+*/
+export declare function getLayoutParentElement(node: Node): Element | null;

package/dist/dom/getlayoutparentnode.d.ts

@@ -0,0 +1,24 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Returns the node one step up the **flattened tree**, the one the browser lays out and paints.
+*
+* The layout-aware counterpart of {@link module:utils/dom/getparentnode~getParentNode}, which walks the node
+* tree. The two agree everywhere except for slotted content: assigning a node to a `<slot>` does not move it, so
+* it stays a child of the host in the node tree while rendering inside the slot. A node-tree walk out of such a
+* node therefore leaves into the light DOM and skips every element of the shadow tree that actually lays it out.
+*
+* Use this one for questions about geometry – what scrolls a node, what clips it, what it renders inside – and
+* {@link module:utils/dom/getparentnode~getParentNode} for questions about structure, such as what a node is a
+* descendant of for the purposes of DOM manipulation or event retargeting. Both cross shadow boundaries and both
+* work for open and closed roots alike.
+*
+* **Note**: `Element#assignedSlot` is `null` when the slot lives in a *closed* shadow root, which the DOM
+* standard does not expose. For slotted content inside a closed root this falls back to the node tree and
+* answers exactly as {@link module:utils/dom/getparentnode~getParentNode} does.
+*
+* @param node The node to step up from.
+*/
+export declare function getLayoutParentNode(node: Node): ParentNode | null;

package/dist/dom/getoverlaymountroot.d.ts

@@ -0,0 +1,24 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Returns the DOM tree that a feature's floating UI – its balloons, dialogs and tooltips – should be put in:
+* the same one the feature itself is in.
+*
+* Floating UI would otherwise go into `document.body`. That is outside the shadow root an editor may live in,
+* so the UI would leave the tree the editor's styles were loaded into, and lose them.
+*
+* Being in the same tree means one of three things:
+*
+* * the shadow root the given element is in, if it is in one. A shadow root passed in returns itself.
+* * the `<body>` of that element's own document otherwise, so an editor in an iframe stays in that iframe.
+* * `null` while the element is detached, because there is no telling yet which tree it will end up in. Put
+*   the UI nowhere for now and ask again once the element is in the DOM.
+*
+* Feed the result to {@link module:ui/editorui/bodycollection~BodyCollection#syncMountTarget}, and call this
+* again whenever the element may have moved. Works with open and closed shadow roots.
+*
+* @param containerNode The element the floating UI belongs to – usually the feature's container.
+*/
+export declare function getOverlayMountRoot(containerNode: Element | ShadowRoot): HTMLElement | ShadowRoot | null;

package/dist/dom/getparentelement.d.ts

@@ -0,0 +1,13 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Returns the parent element of the given node, crossing shadow boundaries.
+*
+* The shadow-aware replacement for `Node#parentElement`, which is `null` for a node sitting directly in a
+* `ShadowRoot` and so stops an outward walk at the boundary. Works for open and closed roots alike.
+*
+* @param node The node to get the parent element of.
+*/
+export declare function getParentElement(node: Node): Element | null;

package/dist/dom/getparentnode.d.ts

@@ -0,0 +1,15 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Returns the node one step up the composed tree, crossing shadow boundaries.
+*
+* The shadow-aware replacement for `Node#parentNode`, and the primitive for walking from a node outwards to the
+* document. It steps over any node, so such a walk visits the `ShadowRoot` nodes on the way and reaches the
+* `Document` at the top – to walk elements only, use
+* {@link module:utils/dom/getparentelement~getParentElement}. Works for open and closed roots alike.
+*
+* @param node The node to step up from.
+*/
+export declare function getParentNode(node: Node): ParentNode | null;

package/dist/dom/getpositionedancestor.d.ts

@@ -1,10 +1,21 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * For a given element, returns the nearest ancestor element which CSS position is not "static".
- *
- * @param element The native DOM element to be checked.
- */
+* Returns the element the given one is laid out against while absolutely positioned – the element whose padding
+* box its `top` and `left` are relative to. Returns `null` when there is nothing to compensate for: the element
+* is laid out against the initial containing block, is `position: fixed`, or is not rendered at all.
+*
+* Use it when turning a position measured against the viewport into the `top` and `left` to set on an absolutely
+* positioned element, by subtracting the returned element's padding-box offset – the way
+* {@link module:utils/dom/rect~Rect#toAbsoluteRect} and {@link module:utils/dom/position~getOptimalPosition} do.
+*
+* The layout-aware counterpart of `Element#offsetParent`, and what to reach for instead of it: this one follows
+* the **flattened tree**, the one the browser lays out, so it stays right for slotted content – an editor slotted
+* into a container component – where `offsetParent` names an element that does not lay that content out. Falls
+* back to `offsetParent` for slotted content inside a closed root, whose slot the DOM standard does not expose.
+*
+* @param element The native DOM element to be checked.
+*/
 export declare function getPositionedAncestor(element?: HTMLElement): HTMLElement | null;

package/dist/dom/getrangefrommouseevent.d.ts

@@ -1,17 +1,19 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/getrangefrommouseevent
- */
-/**
- * Returns a DOM range from a given point specified by a mouse event.
- *
- * @param domEvent The mouse event.
- * @returns The DOM range.
- */
+* Returns a DOM range from a given point specified by a mouse event.
+*
+* **Note**: The point is resolved inside the shadow root the event was dispatched in, so a click inside a shadow
+* tree gives a range in that tree rather than one at its host. Works for open and closed shadow roots alike, on
+* the engines that honor the `shadowRoots` option of `Document#caretPositionFromPoint()`; elsewhere the range
+* still lands beside the host.
+*
+* @param domEvent The mouse event.
+* @returns The DOM range.
+*/
 export declare function getRangeFromMouseEvent(domEvent: MouseEvent & {
-    rangeParent?: HTMLElement;
-    rangeOffset?: number;
+	rangeParent?: HTMLElement;
+	rangeOffset?: number;
 }): Range | null;

package/dist/dom/getselection.d.ts

@@ -0,0 +1,106 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module utils/dom/getselection
+*/
+import { type ArrayOrItem } from "../toarray.js";
+/**
+* Returns the selection of the tree the given node lives in.
+*
+* Use it instead of `window.getSelection()`, which cannot see into a shadow root: its `anchorNode` and
+* `focusNode` point at the host of the tree, not at the nodes selected inside it.
+*
+* Pass the node the selection is read for, usually an editable. Pass several nodes to cover several editables
+* at once. A node in the light DOM gives the document selection, unchanged. Works with open and closed shadow
+* roots.
+*
+* The result behaves like a `Selection` – the part of one the editor uses – so read it and change it the same
+* way. It is `null` when there is no selection to read: a detached node, or a document with no window.
+*
+* One thing this helper cannot fix. In Safari and Chromium browsers, a selection made with the mouse inside a
+* shadow root reports no direction, so a backward selection may look forward. Chromium is asked through its own
+* API where possible. Safari has none.
+*
+* @param nodeOrNodes The node (or nodes) whose tree's selection should be returned.
+*/
+export declare function getSelection(nodeOrNodes: ArrayOrItem<Node>): Selection | ShadowSelection | null;
+/**
+* A `Selection` view over the composed ranges of a set of shadow roots. Read accessors are resolved live
+* from the composed ranges on each access, so the view stays in sync with the underlying document selection;
+* selection mutations are delegated to it. Only the subset of the `Selection` interface consumed by the
+* editor is implemented, so `getSelection()` returns it alongside the native `Selection`.
+*/
+export declare class ShadowSelection {
+	/**
+	* The underlying document-level selection that mutations are delegated to and composed ranges read
+	* from.
+	*/
+	private readonly _domSelection;
+	/**
+	* The shadow roots the composed ranges are resolved against.
+	*/
+	private readonly _shadowRoots;
+	/**
+	* Whether the engine only accepts the legacy rest-parameter form of `getComposedRanges()`. This is
+	* a fixed property of the engine, so it is detected once (the first call throws on the dictionary
+	* form) and cached for all instances, keeping the exception off the selection-read hot path.
+	*/
+	private static _useLegacyComposedRanges;
+	/**
+	* @internal
+	*/
+	constructor(domSelection: Selection, shadowRoots: Array<ShadowRoot>);
+	get rangeCount(): number;
+	get isCollapsed(): boolean;
+	get anchorNode(): Node | null;
+	get anchorOffset(): number;
+	get focusNode(): Node | null;
+	get focusOffset(): number;
+	/**
+	* The direction of the selection, resolved against the tree the first composed range lives in. It is
+	* already computed to orient the anchor and focus endpoints, so exposing it lets consumers read the
+	* orientation directly instead of re-deriving it from the endpoints.
+	*/
+	get direction(): "forward" | "backward" | "none";
+	getRangeAt(index: number): Range;
+	removeAllRanges(): void;
+	addRange(range: Range): void;
+	collapse(node: Node | null, offset?: number): void;
+	extend(node: Node, offset?: number): void;
+	setBaseAndExtent(anchorNode: Node, anchorOffset: number, focusNode: Node, focusOffset: number): void;
+	/**
+	* The composed ranges fully contained in one of the trees on the path from the given nodes to the
+	* document, in document order (start before end).
+	*
+	* Only ranges whose both endpoints resolve into the same tree can be represented as a live, single-tree
+	* `Range`. A range crossing a shadow boundary is therefore dropped, and so is one resolving into an
+	* unrelated tree, rather than surfacing foreign nodes. The document itself is one of those trees: it is
+	* where every node ends up when walking out of its shadow roots, and it is where a selection made in a
+	* sibling light-DOM editable lives, so such a selection is kept rather than dropped.
+	*
+	* A range with an endpoint outside its container is dropped as well, see `isOffsetInNode()` below.
+	*/
+	private _getRanges;
+	/**
+	* The raw composed ranges reported for the shadow roots by the underlying selection.
+	*/
+	private _getComposedRanges;
+	/**
+	* The direction of the underlying selection, preferring the one reported by Blink's shadow-scoped
+	* selection, which stays meaningful for a mouse selection made inside a shadow root.
+	*/
+	private _getDirection;
+	/**
+	* The anchor or focus endpoint of the first composed range.
+	*
+	* `getComposedRanges()` returns ranges in document order (start before end); the anchor/focus
+	* orientation therefore has to come from `Selection#direction`. Known limitation: WebKit and Blink
+	* report `direction` as `'none'` for a selection made *with the mouse* inside a shadow root (a
+	* keyboard selection reports it correctly). Blink's shadow-scoped selection still knows the direction
+	* in that case, so it is consulted first; it is of no use for the ranges themselves, as it covers
+	* a single tree only. Safari has no such API, so its mouse selections fall back to forward.
+	*/
+	private _getEndpoint;
+}

package/dist/dom/getshadowroots.d.ts

@@ -0,0 +1,19 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Returns every shadow root the given node renders in, innermost first.
+*
+* For code that has to act on *all* the shadow boundaries above a node – attaching listeners, injecting styles –
+* rather than only the nearest one. Empty for a node in the light DOM, and one entry per boundary for a node
+* inside nested trees. Works for open and closed roots alike.
+*
+* Derived from the tree the node sits in, not from whether that tree is in a document: a node inside a shadow
+* root reports that root even while its host is detached, because `attachShadow()` makes the shadow tree – and
+* its root – real right away. Callers that only care about the roots a node is currently *rendered* in should
+* check `Node#isConnected` themselves.
+*
+* @param node The node to collect the hosting shadow roots of.
+*/
+export declare function getShadowRoots(node: Node): Array<ShadowRoot>;

package/dist/dom/getvisualviewportoffset.d.ts

@@ -1,11 +1,11 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * Returns the visual viewport offsets to adjust elements with `position: fixed` style.
- */
+* Returns the visual viewport offsets to adjust elements with `position: fixed` style.
+*/
 export declare function getVisualViewportOffset(): {
-    left: number;
-    top: number;
+	left: number;
+	top: number;
 };

package/dist/dom/global.d.ts

@@ -1,32 +1,32 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/global
- */
+* @module utils/dom/global
+*/
 /**
- * A helper (module) giving an access to the global DOM objects such as `window` and `document`.
- */
+* A helper (module) giving an access to the global DOM objects such as `window` and `document`.
+*/
 export interface GlobalType {
-    readonly window: Window & typeof globalThis;
-    readonly document: Document;
+	readonly window: Window & typeof globalThis;
+	readonly document: Document;
 }
 /**
- * A helper (module) giving an access to the global DOM objects such as `window` and
- * `document`. Accessing these objects using this helper allows easy and bulletproof
- * testing, i.e. stubbing native properties:
- *
- * ```ts
- * import { global } from 'ckeditor5';
- *
- * // This stub will work for any code using global module.
- * testUtils.sinon.stub( global, 'window', {
- * 	innerWidth: 10000
- * } );
- *
- * console.log( global.window.innerWidth );
- * ```
- */
+* A helper (module) giving an access to the global DOM objects such as `window` and
+* `document`. Accessing these objects using this helper allows easy and bulletproof
+* testing, i.e. stubbing native properties:
+*
+* ```ts
+* import { global } from 'ckeditor5';
+*
+* // This stub will work for any code using global module.
+* vi.spyOn( global, 'window', 'get' ).mockReturnValue( {
+* 	innerWidth: 10000
+* } );
+*
+* console.log( global.window.innerWidth );
+* ```
+*/
 declare let globalVar: GlobalType;
 export { globalVar as global };

package/dist/dom/indexof.d.ts

@@ -1,14 +1,14 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/indexof
- */
+* @module utils/dom/indexof
+*/
 /**
- * Returns index of the node in the parent element.
- *
- * @param node Node which index is tested.
- * @returns Index of the node in the parent element. Returns 0 if node has no parent.
- */
+* Returns index of the node in the parent element.
+*
+* @param node Node which index is tested.
+* @returns Index of the node in the parent element. Returns 0 if node has no parent.
+*/
 export declare function indexOf(node: Node): number;

package/dist/dom/insertat.d.ts

@@ -1,15 +1,15 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/insertat
- */
+* @module utils/dom/insertat
+*/
 /**
- * Inserts node to the parent at given index.
- *
- * @param parentElement Parent element.
- * @param index Insertions index.
- * @param nodeToInsert Node to insert.
- */
+* Inserts node to the parent at given index.
+*
+* @param parentElement Parent element.
+* @param index Insertions index.
+* @param nodeToInsert Node to insert.
+*/
 export declare function insertAt(parentElement: Element, index: number, nodeToInsert: Node): void;

package/dist/dom/iscomment.d.ts

@@ -1,11 +1,11 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/iscomment
- */
+* @module utils/dom/iscomment
+*/
 /**
- * Checks whether the object is a native DOM Comment node.
- */
+* Checks whether the object is a native DOM Comment node.
+*/
 export declare function isComment(obj: any): obj is Comment;

package/dist/dom/isdomselectionbackward.d.ts

@@ -0,0 +1,18 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module utils/dom/isdomselectionbackward
+*/
+import { type ShadowSelection } from "./getselection.js";
+/**
+* Returns `true` if the given selection is backward, that is, if its `focus` is positioned before its `anchor`.
+*
+* A replacement for reading `Selection#direction`, which is absent on older engines and reports `'none'` for a
+* selection made with the mouse inside a shadow root. The orientation is then recovered from the anchor and
+* focus positions instead, so an answer is always available.
+*
+* @param selection The selection to check.
+*/
+export declare function isDomSelectionBackward(selection: Selection | ShadowSelection): boolean;

package/dist/dom/isnode.d.ts

@@ -1,11 +1,11 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/isnode
- */
+* @module utils/dom/isnode
+*/
 /**
- * Checks if the object is a native DOM Node.
- */
+* Checks if the object is a native DOM Node.
+*/
 export declare function isNode(obj: any): obj is Node;

package/dist/dom/isoffline.d.ts

@@ -0,0 +1,8 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* Checks whether the browser reports that there is no network connection.
+*/
+export declare function isOffline(): boolean;

package/dist/dom/isrange.d.ts

@@ -1,11 +1,11 @@
 /**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
 /**
- * @module utils/dom/isrange
- */
+* @module utils/dom/isrange
+*/
 /**
- * Checks if the object is a native DOM Range.
- */
+* Checks if the object is a native DOM Range.
+*/
 export declare function isRange(obj: unknown): obj is Range;

package/dist/dom/isshadowhostof.d.ts

@@ -0,0 +1,18 @@
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+/**
+* @module utils/dom/isshadowhostof
+*/
+/**
+* Checks whether the given node is the host of any of the given shadow roots.
+*
+* Answers "is this a stand-in for something inside one of these roots, rather than the real thing?". A DOM API
+* that cannot reach into a shadow tree reports its host in place of the node inside it – most commonly an event
+* target, retargeted for a listener that does not live in that tree. Works for open and closed roots alike.
+*
+* @param node The node to test.
+* @param shadowRoots The shadow roots to test against.
+*/
+export declare function isShadowHostOf(node: EventTarget | null, shadowRoots: Iterable<ShadowRoot>): boolean;