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

package/dist/difftochanges.d.ts

@@ -1,59 +1,59 @@
 /**
- * @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/difftochanges
- */
-import type { DiffResult } from './diff.js';
+* @module utils/difftochanges
+*/
+import type { DiffResult } from "./diff.js";
 /**
- * Creates a set of changes which need to be applied to the input in order to transform
- * it into the output. This function can be used with strings or arrays.
- *
- * ```ts
- * const input = Array.from( 'abc' );
- * const output = Array.from( 'xaby' );
- * const changes = diffToChanges( diff( input, output ), output );
- *
- * changes.forEach( change => {
- * 	if ( change.type == 'insert' ) {
- * 		input.splice( change.index, 0, ...change.values );
- * 	} else if ( change.type == 'delete' ) {
- * 		input.splice( change.index, change.howMany );
- * 	}
- * } );
- *
- * input.join( '' ) == output.join( '' ); // -> true
- * ```
- *
- * @typeParam T The type of output array element.
- * @param diff Result of {@link module:utils/diff~diff}.
- * @param output The string or array which was passed as diff's output.
- * @returns Set of changes (insert or delete) which need to be applied to the input
- * in order to transform it into the output.
- */
+* Creates a set of changes which need to be applied to the input in order to transform
+* it into the output. This function can be used with strings or arrays.
+*
+* ```ts
+* const input = Array.from( 'abc' );
+* const output = Array.from( 'xaby' );
+* const changes = diffToChanges( diff( input, output ), output );
+*
+* changes.forEach( change => {
+* 	if ( change.type == 'insert' ) {
+* 		input.splice( change.index, 0, ...change.values );
+* 	} else if ( change.type == 'delete' ) {
+* 		input.splice( change.index, change.howMany );
+* 	}
+* } );
+*
+* input.join( '' ) == output.join( '' ); // -> true
+* ```
+*
+* @typeParam T The type of output array element.
+* @param diff Result of {@link module:utils/diff~diff}.
+* @param output The string or array which was passed as diff's output.
+* @returns Set of changes (insert or delete) which need to be applied to the input
+* in order to transform it into the output.
+*/
 export declare function diffToChanges<T>(diff: ReadonlyArray<DiffResult>, output: ArrayLike<T>): Array<Change<T>>;
 /**
- * An object describing insertion change.
- *
- * @typeParam T The type of output array element.
- */
+* An object describing insertion change.
+*
+* @typeParam T The type of output array element.
+*/
 export interface InsertChange<T> {
-    type: 'insert';
-    index: number;
-    values: Array<T>;
+	type: "insert";
+	index: number;
+	values: Array<T>;
 }
 /**
- * An object describing deletion change.
- */
+* An object describing deletion change.
+*/
 export interface DeleteChange {
-    type: 'delete';
-    index: number;
-    howMany: number;
+	type: "delete";
+	index: number;
+	howMany: number;
 }
 /**
- * The element of the result of {@link module:utils/difftochanges~diffToChanges} function.
- *
- * @typeParam T The type of output array element.
- */
+* The element of the result of {@link module:utils/difftochanges~diffToChanges} function.
+*
+* @typeParam T The type of output array element.
+*/
 export type Change<T> = InsertChange<T> | DeleteChange;

package/dist/dom/adoptglobalstylesheet.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
+*/
+/**
+* Ships a stylesheet that has to reach the light DOM, whatever tree the editor itself lives in.
+*
+* For the few rules that a shadow-scoped theme stylesheet cannot express, because they style nodes no shadow
+* root can contain: the `<html>` and `<body>` elements, or third-party UI mounted in `document.body`. Anything
+* that styles the editor UI belongs in a theme stylesheet instead, where an integrator can see and override it.
+*
+* Safe to call from any number of editors sharing a document, and at any time: the same stylesheet text is
+* adopted once per document. The stylesheet then stays for the lifetime of the document, inert unless the
+* classes it targets are present.
+*
+* @param doc The document to adopt the stylesheet into.
+* @param css The stylesheet text. Pass a constant – repeated calls with the same text are a no-op.
+*/
+export declare function adoptGlobalStyleSheet(doc: Document, css: string): void;

package/dist/dom/containsnode.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
+*/
+/**
+* Checks whether `node` is inside `container`, looking through shadow roots on the way.
+*
+* Use it instead of `Node#contains()`, which stops at a shadow root: that one says `false` even when
+* `container` really is an ancestor, as long as a shadow root sits between the two. A node contains itself
+* here, just like it does there.
+*
+* `container` can also be a `Document` or a `ShadowRoot` – useful for a `scroll` event, for example, whose
+* target is the document and not an element. Works with open and closed shadow roots.
+*
+* @param container The node that may be the ancestor.
+* @param node The node to look for. May be `null`, which always gives `false`.
+*/
+export declare function containsNode(container: Node, node: Node | null): boolean;

package/dist/dom/createelement.d.ts

@@ -1,56 +1,56 @@
 /**
- * @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
+*/
 /**
- * Attributes to be applied to the HTML element.
- */
+* Attributes to be applied to the HTML element.
+*/
 export type HTMLElementAttributes = {
-    readonly [key: string]: string;
+	readonly [key: string]: string;
 };
 /**
- * Attributes to be applied to the SVG element.
- */
+* Attributes to be applied to the SVG element.
+*/
 export type SVGElementAttributes = HTMLElementAttributes & {
-    xmlns: string;
+	xmlns: string;
 };
 /**
- * Element or elements that will be added to the created element as children. Strings will be automatically turned into Text nodes.
- */
+* Element or elements that will be added to the created element as children. Strings will be automatically turned into Text nodes.
+*/
 export type ChildrenElements = Node | string | Iterable<Node | string>;
 /**
- * Creates an SVG element with attributes and children elements.
- *
- * ```ts
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' } ); // <mask>
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg', id: 'foo' } ); // <mask id="foo">
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, 'foo' ); // <mask>foo</mask>
- * createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, [ createElement(...) ] ); // <mask><...></mask>
- * ```
- *
- * @label SVG_ELEMENT
- * @param doc Document used to create the element.
- * @param name Name of the SVG element.
- * @param attributes Object where keys represent attribute keys and values represent attribute values.
- * @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
- * @returns SVG element.
- */
+* Creates an SVG element with attributes and children elements.
+*
+* ```ts
+* createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' } ); // <mask>
+* createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg', id: 'foo' } ); // <mask id="foo">
+* createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, 'foo' ); // <mask>foo</mask>
+* createElement( document, 'mask', { xmlns: 'http://www.w3.org/2000/svg' }, [ createElement(...) ] ); // <mask><...></mask>
+* ```
+*
+* @label SVG_ELEMENT
+* @param doc Document used to create the element.
+* @param name Name of the SVG element.
+* @param attributes Object where keys represent attribute keys and values represent attribute values.
+* @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
+* @returns SVG element.
+*/
 export declare function createElement<T extends keyof SVGElementTagNameMap>(doc: Document, name: T, attributes: SVGElementAttributes, children?: ChildrenElements): SVGElementTagNameMap[T];
 /**
- * Creates an HTML element with attributes and children elements.
- *
- * ```ts
- * createElement( document, 'p' ); // <p>
- * createElement( document, 'p', { class: 'foo' } ); // <p class="foo">
- * createElement( document, 'p', null, 'foo' ); // <p>foo</p>
- * createElement( document, 'p', null, [ createElement(...) ] ); // <p><...></p>
- * ```
- *
- * @label HTML_ELEMENT
- * @param doc Document used to create the element.
- * @param name Name of the HTML element.
- * @param attributes Object where keys represent attribute keys and values represent attribute values.
- * @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
- * @returns HTML element.
- */
+* Creates an HTML element with attributes and children elements.
+*
+* ```ts
+* createElement( document, 'p' ); // <p>
+* createElement( document, 'p', { class: 'foo' } ); // <p class="foo">
+* createElement( document, 'p', null, 'foo' ); // <p>foo</p>
+* createElement( document, 'p', null, [ createElement(...) ] ); // <p><...></p>
+* ```
+*
+* @label HTML_ELEMENT
+* @param doc Document used to create the element.
+* @param name Name of the HTML element.
+* @param attributes Object where keys represent attribute keys and values represent attribute values.
+* @param children Child or any iterable of children. Strings will be automatically turned into Text nodes.
+* @returns HTML element.
+*/
 export declare function createElement<T extends keyof HTMLElementTagNameMap>(doc: Document, name: T, attributes?: HTMLElementAttributes, children?: ChildrenElements): HTMLElementTagNameMap[T];

package/dist/dom/emittermixin.d.ts

@@ -1,142 +1,148 @@
 /**
- * @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/emittermixin
- */
-import { type Emitter, type CallbackOptions, type BaseEvent, type GetCallback } from '../emittermixin.js';
-import { type EventInfo } from '../eventinfo.js';
-import type { Constructor, Mixed } from '../mix.js';
+* @module utils/dom/emittermixin
+*/
+import { type Emitter, type CallbackOptions, type BaseEvent, type GetCallback } from "../emittermixin.js";
+import { type EventInfo } from "../eventinfo.js";
+import type { Constructor, Mixed } from "../mix.js";
 /**
- * Mixin that injects the DOM events API into its host. It provides the API
- * compatible with {@link module:utils/emittermixin~Emitter}.
- *
- * This function creates a class that inherits from the provided `base` and implements `Emitter` interface.
- *
- * DOM emitter mixin is by default available in the {@link module:ui/view~View} class,
- * but it can also be mixed into any other class:
- *
- * ```ts
- * import { DomEmitterMixin } from '../utils/dom/emittermixin.js';
- *
- * class BaseClass { ... }
- *
- * class SomeView extends DomEmitterMixin( BaseClass ) {}
- *
- * const view = new SomeView();
- * view.listenTo( domElement, ( evt, domEvt ) => {
- * 	console.log( evt, domEvt );
- * } );
- * ```
- *
- * @label EXTENDS
- */
-export declare function DomEmitterMixin<Base extends Constructor<Emitter>>(base: Base): Mixed<Base, DomEmitter>;
+* Constructor returned by {@link ~DomEmitterMixin}. Use it to name a mixin base class before extending it.
+*
+* ```ts
+* const MyDomEmitterBase: DomEmitterMixinConstructor<typeof BaseClass> = DomEmitterMixin( BaseClass );
+*
+* class MyDomEmitter extends MyDomEmitterBase {}
+* ```
+*/
+export type DomEmitterMixinConstructor<Base extends Constructor<Emitter> = new () => Emitter> = Mixed<Base, DomEmitter>;
 /**
- * Mixin that injects the DOM events API into its host. It provides the API
- * compatible with {@link module:utils/emittermixin~Emitter}.
- *
- * This function creates a class that implements `Emitter` interface.
- *
- * DOM emitter mixin is by default available in the {@link module:ui/view~View} class,
- * but it can also be mixed into any other class:
- *
- * ```ts
- * import { DomEmitterMixin } from '../utils/dom/emittermixin.js';
- *
- * class SomeView extends DomEmitterMixin() {}
- *
- * const view = new SomeView();
- * view.listenTo( domElement, ( evt, domEvt ) => {
- * 	console.log( evt, domEvt );
- * } );
- * ```
- *
- * @label NO_ARGUMENTS
- */
-export declare function DomEmitterMixin(): {
-    new (): DomEmitter;
-    prototype: DomEmitter;
-};
-export interface DomEventMap extends HTMLElementEventMap, WindowEventMap {
-}
+* Mixin that injects the DOM events API into its host. It provides the API
+* compatible with {@link module:utils/emittermixin~Emitter}.
+*
+* This function creates a class that inherits from the provided `base` and implements `Emitter` interface.
+*
+* DOM emitter mixin is by default available in the {@link module:ui/view~View} class,
+* but it can also be mixed into any other class:
+*
+* ```ts
+* import { DomEmitterMixin } from '../utils/dom/emittermixin.js';
+*
+* class BaseClass { ... }
+*
+* class SomeView extends DomEmitterMixin( BaseClass ) {}
+*
+* const view = new SomeView();
+* view.listenTo( domElement, ( evt, domEvt ) => {
+* 	console.log( evt, domEvt );
+* } );
+* ```
+*
+* @label EXTENDS
+*/
+export declare function DomEmitterMixin<Base extends Constructor<Emitter>>(base: Base): DomEmitterMixinConstructor<Base>;
+/**
+* Mixin that injects the DOM events API into its host. It provides the API
+* compatible with {@link module:utils/emittermixin~Emitter}.
+*
+* This function creates a class that implements `Emitter` interface.
+*
+* DOM emitter mixin is by default available in the {@link module:ui/view~View} class,
+* but it can also be mixed into any other class:
+*
+* ```ts
+* import { DomEmitterMixin } from '../utils/dom/emittermixin.js';
+*
+* class SomeView extends DomEmitterMixin() {}
+*
+* const view = new SomeView();
+* view.listenTo( domElement, ( evt, domEvt ) => {
+* 	console.log( evt, domEvt );
+* } );
+* ```
+*
+* @label NO_ARGUMENTS
+*/
+export declare function DomEmitterMixin(): DomEmitterMixinConstructor;
+export interface DomEventMap extends HTMLElementEventMap, WindowEventMap {}
 /**
- * Interface representing classes which mix in {@link module:utils/dom/emittermixin~DomEmitterMixin}.
- *
- * Can be easily implemented by a class by mixing the {@link module:utils/dom/emittermixin~DomEmitterMixin} mixin.
- *
- * ```ts
- * class MyClass extends DomEmitterMixin( OtherBaseClass ) {
- * 	// This class now implements the `Emitter` interface.
- * }
- * ```
- */
+* Interface representing classes which mix in {@link module:utils/dom/emittermixin~DomEmitterMixin}.
+*
+* Can be easily implemented by a class by mixing the {@link module:utils/dom/emittermixin~DomEmitterMixin} mixin.
+*
+* ```ts
+* class MyClass extends DomEmitterMixin( OtherBaseClass ) {
+* 	// This class now implements the `Emitter` interface.
+* }
+* ```
+*/
 export interface DomEmitter extends Emitter {
-    /**
-     * Registers a callback function to be executed when an event is fired in a specific Emitter or DOM Node.
-     * It is backwards compatible with {@link module:utils/emittermixin~Emitter#listenTo}.
-     *
-     * @label HTML_EMITTER
-     * @param emitter The object that fires the event.
-     * @param event The name of the event.
-     * @param callback The function to be called on event.
-     * @param options Additional options.
-     * @param options.useCapture Indicates that events of this type will be dispatched to the registered
-     * listener before being dispatched to any EventTarget beneath it in the DOM tree.
-     * @param options.usePassive Indicates that the function specified by listener will never call preventDefault()
-     * and prevents blocking browser's main thread by this event handler.
-     */
-    listenTo<K extends keyof DomEventMap>(emitter: Node | Window | EventTarget, event: K, callback: (this: this, ev: EventInfo, event: DomEventMap[K]) => void, options?: CallbackOptions & {
-        readonly useCapture?: boolean;
-        readonly usePassive?: boolean;
-    }): void;
-    /**
-     * Registers a callback function to be executed when an event is fired in a specific (emitter) object.
-     *
-     * Events can be grouped in namespaces using `:`.
-     * When namespaced event is fired, it additionally fires all callbacks for that namespace.
-     *
-     * ```ts
-     * // myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ).
-     * myEmitter.on( 'myGroup', genericCallback );
-     * myEmitter.on( 'myGroup:myEvent', specificCallback );
-     *
-     * // genericCallback is fired.
-     * myEmitter.fire( 'myGroup' );
-     * // both genericCallback and specificCallback are fired.
-     * myEmitter.fire( 'myGroup:myEvent' );
-     * // genericCallback is fired even though there are no callbacks for "foo".
-     * myEmitter.fire( 'myGroup:foo' );
-     * ```
-     *
-     * An event callback can {@link module:utils/eventinfo~EventInfo#stop stop the event} and
-     * set the {@link module:utils/eventinfo~EventInfo#return return value} of the {@link #fire} method.
-     *
-     * @label DOM_EMITTER
-     * @typeParam TEvent The type describing the event. See {@link module:utils/emittermixin~BaseEvent}.
-     * @param emitter The object that fires the event.
-     * @param event The name of the event.
-     * @param callback The function to be called on event.
-     * @param options Additional options.
-     */
-    listenTo<TEvent extends BaseEvent>(emitter: Emitter, event: TEvent['name'], callback: GetCallback<TEvent>, options?: CallbackOptions): void;
-    /**
-     * Stops listening for events. It can be used at different levels:
-     * It is backwards compatible with {@link module:utils/emittermixin~Emitter#listenTo}.
-     *
-     * * To stop listening to a specific callback.
-     * * To stop listening to a specific event.
-     * * To stop listening to all events fired by a specific object.
-     * * To stop listening to all events fired by all objects.
-     *
-     * @label DOM_STOP
-     * @param emitter The object to stop listening to.
-     * If omitted, stops it for all objects.
-     * @param event (Requires the `emitter`) The name of the event to stop listening to. If omitted, stops it
-     * for all events from `emitter`.
-     * @param callback (Requires the `event`) The function to be removed from the call list for the given
-     * `event`.
-     */
-    stopListening(emitter?: Emitter | Node | Window | EventTarget, event?: string, callback?: Function): void;
+	/**
+	* Registers a callback function to be executed when an event is fired in a specific Emitter or DOM Node.
+	* It is backwards compatible with {@link module:utils/emittermixin~Emitter#listenTo}.
+	*
+	* @label HTML_EMITTER
+	* @param emitter The object that fires the event.
+	* @param event The name of the event.
+	* @param callback The function to be called on event.
+	* @param options Additional options.
+	* @param options.useCapture Indicates that events of this type will be dispatched to the registered
+	* listener before being dispatched to any EventTarget beneath it in the DOM tree.
+	* @param options.usePassive Indicates that the function specified by listener will never call preventDefault()
+	* and prevents blocking browser's main thread by this event handler.
+	*/
+	listenTo<K extends keyof DomEventMap>(emitter: Node | Window | EventTarget, event: K, callback: (this: this, ev: EventInfo, event: DomEventMap[K]) => void, options?: CallbackOptions & {
+		readonly useCapture?: boolean;
+		readonly usePassive?: boolean;
+	}): void;
+	/**
+	* Registers a callback function to be executed when an event is fired in a specific (emitter) object.
+	*
+	* Events can be grouped in namespaces using `:`.
+	* When namespaced event is fired, it additionally fires all callbacks for that namespace.
+	*
+	* ```ts
+	* // myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ).
+	* myEmitter.on( 'myGroup', genericCallback );
+	* myEmitter.on( 'myGroup:myEvent', specificCallback );
+	*
+	* // genericCallback is fired.
+	* myEmitter.fire( 'myGroup' );
+	* // both genericCallback and specificCallback are fired.
+	* myEmitter.fire( 'myGroup:myEvent' );
+	* // genericCallback is fired even though there are no callbacks for "foo".
+	* myEmitter.fire( 'myGroup:foo' );
+	* ```
+	*
+	* An event callback can {@link module:utils/eventinfo~EventInfo#stop stop the event} and
+	* set the {@link module:utils/eventinfo~EventInfo#return return value} of the {@link #fire} method.
+	*
+	* @label DOM_EMITTER
+	* @typeParam TEvent The type describing the event. See {@link module:utils/emittermixin~BaseEvent}.
+	* @param emitter The object that fires the event.
+	* @param event The name of the event.
+	* @param callback The function to be called on event.
+	* @param options Additional options.
+	*/
+	listenTo<TEvent extends BaseEvent>(emitter: Emitter, event: TEvent["name"], callback: GetCallback<TEvent>, options?: CallbackOptions): void;
+	/**
+	* Stops listening for events. It can be used at different levels:
+	* It is backwards compatible with {@link module:utils/emittermixin~Emitter#listenTo}.
+	*
+	* * To stop listening to a specific callback.
+	* * To stop listening to a specific event.
+	* * To stop listening to all events fired by a specific object.
+	* * To stop listening to all events fired by all objects.
+	*
+	* @label DOM_STOP
+	* @param emitter The object to stop listening to.
+	* If omitted, stops it for all objects.
+	* @param event (Requires the `emitter`) The name of the event to stop listening to. If omitted, stops it
+	* for all events from `emitter`.
+	* @param callback (Requires the `event`) The function to be removed from the call list for the given
+	* `event`.
+	*/
+	stopListening(emitter?: Emitter | Node | Window | EventTarget, event?: string, callback?: Function): void;
 }

package/dist/dom/findclosestscrollableancestor.d.ts

@@ -1,11 +1,16 @@
 /**
- * @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 closest scrollable ancestor of a DOM element.
- *
- * @param domElement DOM element.
- * @returns First ancestor of `domElement` that is scrollable or null if such ancestor doesn't exist.
- */
+* Returns the closest scrollable ancestor of a DOM element.
+*
+* The search crosses shadow DOM boundaries, continuing from the host element of a shadow root instead of
+* stopping at it. Without that, an element rendered inside a shadow tree would report no scrollable ancestor at
+* all, even when one exists further up in the surrounding document, because the walk goes over `parentElement`,
+* which is `null` for a direct child of a shadow root. Works for both open and closed shadow roots.
+*
+* @param domElement DOM element.
+* @returns First ancestor of `domElement` that is scrollable or null if such ancestor doesn't exist.
+*/
 export declare function findClosestScrollableAncestor(domElement: HTMLElement): HTMLElement | null;

package/dist/dom/getactiveelement.d.ts

@@ -0,0 +1,17 @@
+/**
+* @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/getactiveelement
+*/
+/**
+* Returns the focused element in the tree the given node lives in.
+*
+* The shadow-aware replacement for `document.activeElement`, which reports the host of a shadow tree rather
+* than the focused element inside it. Pass any node from the tree whose focus is in question – typically the
+* element being checked itself. Works for open and closed roots alike.
+*
+* @param node The node whose tree's active element should be returned.
+*/
+export declare function getActiveElement(node: Node): Element | null;

package/dist/dom/getancestors.d.ts

@@ -1,17 +1,17 @@
 /**
- * @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/getancestors
- */
+* @module utils/dom/getancestors
+*/
 /**
- * Returns all ancestors of given DOM node, starting from the top-most (root). Includes the given node itself. If the
- * node is a part of `DocumentFragment` that `DocumentFragment` will be returned. In contrary, if the node is
- * appended to a `Document`, that `Document` will not be returned (algorithms operating on DOM tree care for `Document#documentElement`
- * at most, which will be returned).
- *
- * @param node DOM node.
- * @returns Array of given `node` parents.
- */
+* Returns all ancestors of given DOM node, starting from the top-most (root). Includes the given node itself. If the
+* node is a part of `DocumentFragment` that `DocumentFragment` will be returned. In contrary, if the node is
+* appended to a `Document`, that `Document` will not be returned (algorithms operating on DOM tree care for `Document#documentElement`
+* at most, which will be returned).
+*
+* @param node DOM node.
+* @returns Array of given `node` parents.
+*/
 export declare function getAncestors(node: Node): Array<Node>;