@ckeditor/ckeditor5-utils 41.2.0 → 41.3.0-alpha.1

package/dist/types/dom/isnode.d.ts

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

package/dist/types/dom/isrange.d.ts

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

package/dist/types/dom/istext.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/dom/istext
+ */
+/**
+ * Checks if the object is a native DOM Text node.
+ */
+export default function isText(obj: unknown): obj is Text;

package/dist/types/dom/isvalidattributename.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * Checks if the given attribute name is valid in terms of HTML.
+ *
+ * @param name Attribute name.
+ */
+export default function isValidAttributeName(name: string): boolean;

package/dist/types/dom/isvisible.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/dom/isvisible
+ */
+/**
+ * Checks whether the element is visible to the user in DOM:
+ *
+ * * connected to the root of the document,
+ * * has no `display: none`,
+ * * has no ancestors with `display: none`.
+ *
+ * **Note**: This helper does not check whether the element is hidden by cropping, overflow, etc..
+ * To check that, use {@link module:utils/dom/rect~Rect} instead.
+ */
+export default function isVisible(element: HTMLElement | null | undefined): boolean;

package/dist/types/dom/iswindow.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/dom/iswindow
+ */
+/**
+ * Checks if the object is a native DOM Window.
+ */
+export default function isWindow(obj: unknown): obj is Window;

package/dist/types/dom/position.d.ts

@@ -0,0 +1,211 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import Rect, { type RectSource } from './rect.js';
+/**
+ * Calculates the `position: absolute` coordinates of a given element so it can be positioned with respect to the
+ * target in the visually most efficient way, taking various restrictions like viewport or limiter geometry
+ * into consideration.
+ *
+ * **Note**: If there are no position coordinates found that meet the requirements (arguments of this helper),
+ * `null` is returned.
+ *
+ * ```ts
+ * // The element which is to be positioned.
+ * const element = document.body.querySelector( '#toolbar' );
+ *
+ * // A target to which the element is positioned relatively.
+ * const target = document.body.querySelector( '#container' );
+ *
+ * // Finding the optimal coordinates for the positioning.
+ * const { left, top, name } = getOptimalPosition( {
+ * 	element: element,
+ * 	target: target,
+ *
+ * 	// The algorithm will chose among these positions to meet the requirements such
+ * 	// as "limiter" element or "fitInViewport", set below. The positions are considered
+ * 	// in the order of the array.
+ * 	positions: [
+ * 		//
+ * 	 	//	[ Target ]
+ * 		//	+-----------------+
+ * 		//	|     Element     |
+ * 		//	+-----------------+
+ * 		//
+ * 		targetRect => ( {
+ * 			top: targetRect.bottom,
+ * 			left: targetRect.left,
+ * 			name: 'mySouthEastPosition'
+ * 		} ),
+ *
+ * 		//
+ * 		//	+-----------------+
+ * 		//	|     Element     |
+ * 		//	+-----------------+
+ * 		//	[ Target ]
+ * 		//
+ * 		( targetRect, elementRect ) => ( {
+ * 			top: targetRect.top - elementRect.height,
+ * 			left: targetRect.left,
+ * 			name: 'myNorthEastPosition'
+ * 		} )
+ * 	],
+ *
+ * 	// Find a position such guarantees the element remains within visible boundaries of <body>.
+ * 	limiter: document.body,
+ *
+ * 	// Find a position such guarantees the element remains within visible boundaries of the browser viewport.
+ * 	fitInViewport: true
+ * } );
+ *
+ * // The best position which fits into document.body and the viewport. May be useful
+ * // to set proper class on the `element`.
+ * console.log( name ); // -> "myNorthEastPosition"
+ *
+ * // Using the absolute coordinates which has been found to position the element
+ * // as in the diagram depicting the "myNorthEastPosition" position.
+ * element.style.top = top;
+ * element.style.left = left;
+ * ```
+ *
+ * @param options The input data and configuration of the helper.
+ */
+export declare function getOptimalPosition({ element, target, positions, limiter, fitInViewport, viewportOffsetConfig }: Options): DomPoint | null;
+/**
+ * A position object which instances are created and used by the {@link module:utils/dom/position~getOptimalPosition} helper.
+ *
+ * {@link module:utils/dom/position~DomPoint#top} and {@link module:utils/dom/position~DomPoint#left} properties of the position instance
+ * translate directly to the `top` and `left` properties in CSS "`position: absolute` coordinate system". If set on the positioned element
+ * in DOM, they will make it display it in the right place in the viewport.
+ */
+export interface DomPoint {
+    /**
+     * Position name.
+     */
+    readonly name?: string;
+    /**
+     * Additional position configuration, as passed from the {@link module:utils/dom/position~PositioningFunction positioning function}.
+     *
+     * This object can be use, for instance, to pass through presentation options used by the consumer of the
+     * {@link module:utils/dom/position~getOptimalPosition} helper.
+     */
+    readonly config?: object;
+    /**
+     * The left value in pixels in the CSS `position: absolute` coordinate system.
+     * Set it on the positioned element in DOM to move it to the position.
+     */
+    readonly left: number;
+    /**
+     * The top value in pixels in the CSS `position: absolute` coordinate system.
+     * Set it on the positioned element in DOM to move it to the position.
+     */
+    readonly top: number;
+}
+/**
+ * The `getOptimalPosition()` helper options.
+ */
+export interface Options {
+    /**
+     * Element that is to be positioned.
+     */
+    readonly element: HTMLElement;
+    /**
+     * Target with respect to which the `element` is to be positioned.
+     */
+    readonly target: RectSource | (() => RectSource);
+    /**
+     * An array of positioning functions.
+     *
+     * **Note**: Positioning functions are processed in the order of preference. The first function that works
+     * in the current environment (e.g. offers the complete fit in the viewport geometry) will be picked by
+     * `getOptimalPosition()`.
+     *
+     * **Note**: Any positioning function returning `null` is ignored.
+     */
+    readonly positions: ReadonlyArray<PositioningFunction>;
+    /**
+     * When set, the algorithm will chose position which fits the most in the
+     * limiter's bounding rect.
+     */
+    readonly limiter?: RectSource | (() => (RectSource | null)) | null;
+    /**
+     * When set, the algorithm will chose such a position which fits `element`
+     * the most inside visible viewport.
+     */
+    readonly fitInViewport?: boolean;
+    /**
+     * Viewport offset config object. It restricts the visible viewport available to the `getOptimalPosition()` from each side.
+     *
+     * ```ts
+     * {
+     * 	top: 50,
+     * 	right: 50,
+     * 	bottom: 50,
+     * 	left: 50
+     * }
+     * ```
+     */
+    readonly viewportOffsetConfig?: {
+        readonly top?: number;
+        readonly right?: number;
+        readonly bottom?: number;
+        readonly left?: number;
+    };
+}
+/**
+ * A positioning function which, based on positioned element and target {@link module:utils/dom/rect~Rect Rects}, returns rect coordinates
+ * representing the geometrical relation between them. Used by the {@link module:utils/dom/position~getOptimalPosition} helper.
+ *
+ * ```ts
+ * // This simple position will place the element directly under the target, in the middle:
+ * //
+ * //	    [ Target ]
+ * //	+-----------------+
+ * //	|     Element     |
+ * //	+-----------------+
+ * //
+ * const position = ( targetRect, elementRect, [ viewportRect ] ) => ( {
+ * 	top: targetRect.bottom,
+ * 	left: targetRect.left + targetRect.width / 2 - elementRect.width / 2,
+ * 	name: 'bottomMiddle',
+ *
+ * 	// Note: The config is optional.
+ * 	config: {
+ * 		zIndex: '999'
+ * 	}
+ * } );
+ * ```
+ *
+ * @param elementRect The rect of the element to be positioned.
+ * @param targetRect The rect of the target the element (its rect) is relatively positioned to.
+ * @param viewportRect The rect of the visual browser viewport.
+ * @returns When the function returns `null`, it will not be considered by {@link module:utils/dom/position~getOptimalPosition}.
+ */
+export type PositioningFunction = (elementRect: Rect, targetRect: Rect, viewportRect: Rect, limiterRect?: Rect) => PositioningFunctionResult | null;
+/**
+ * The result of {@link module:utils/dom/position~PositioningFunction}.
+ */
+export interface PositioningFunctionResult {
+    /**
+     * The `top` value of the element rect that would represent the position.
+     */
+    top: number;
+    /**
+     * The `left` value of the element rect that would represent the position.
+     */
+    left: number;
+    /**
+     * The name of the position. It helps the user of the {@link module:utils/dom/position~getOptimalPosition}
+     * helper to recognize different positioning function results. It will pass through to the {@link module:utils/dom/position~DomPoint}
+     * returned by the helper.
+     */
+    name?: string;
+    /**
+     * An optional configuration that will pass-through the {@link module:utils/dom/position~getOptimalPosition} helper
+     * to the {@link module:utils/dom/position~DomPoint} returned by this helper.
+     * This configuration may, for instance, let the user of {@link module:utils/dom/position~getOptimalPosition} know that this particular
+     * position comes with a certain presentation.
+     */
+    config?: object;
+}

package/dist/types/dom/rect.d.ts

@@ -0,0 +1,195 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * A helper class representing a `ClientRect` object, e.g. value returned by
+ * the native `object.getBoundingClientRect()` method. Provides a set of methods
+ * to manipulate the rect and compare it against other rect instances.
+ */
+export default class Rect {
+    /**
+     * The "top" value of the rect.
+     *
+     * @readonly
+     */
+    top: number;
+    /**
+     * The "right" value of the rect.
+     *
+     * @readonly
+     */
+    right: number;
+    /**
+     * The "bottom" value of the rect.
+     *
+     * @readonly
+     */
+    bottom: number;
+    /**
+     * The "left" value of the rect.
+     *
+     * @readonly
+     */
+    left: number;
+    /**
+     * The "width" value of the rect.
+     *
+     * @readonly
+     */
+    width: number;
+    /**
+     * The "height" value of the rect.
+     *
+     * @readonly
+     */
+    height: number;
+    /**
+     * The object this rect is for.
+     *
+     * @readonly
+     */
+    private _source;
+    /**
+     * Creates an instance of rect.
+     *
+     * ```ts
+     * // Rect of an HTMLElement.
+     * const rectA = new Rect( document.body );
+     *
+     * // Rect of a DOM Range.
+     * const rectB = new Rect( document.getSelection().getRangeAt( 0 ) );
+     *
+     * // Rect of a window (web browser viewport).
+     * const rectC = new Rect( window );
+     *
+     * // Rect out of an object.
+     * const rectD = new Rect( { top: 0, right: 10, bottom: 10, left: 0, width: 10, height: 10 } );
+     *
+     * // Rect out of another Rect instance.
+     * const rectE = new Rect( rectD );
+     *
+     * // Rect out of a ClientRect.
+     * const rectF = new Rect( document.body.getClientRects().item( 0 ) );
+     * ```
+     *
+     * **Note**: By default a rect of an HTML element includes its CSS borders and scrollbars (if any)
+     * ant the rect of a `window` includes scrollbars too. Use {@link #excludeScrollbarsAndBorders}
+     * to get the inner part of the rect.
+     *
+     * @param source A source object to create the rect.
+     */
+    constructor(source: RectSource);
+    /**
+     * Returns a clone of the rect.
+     *
+     * @returns A cloned rect.
+     */
+    clone(): Rect;
+    /**
+     * Moves the rect so that its upper–left corner lands in desired `[ x, y ]` location.
+     *
+     * @param x Desired horizontal location.
+     * @param y Desired vertical location.
+     * @returns A rect which has been moved.
+     */
+    moveTo(x: number, y: number): this;
+    /**
+     * Moves the rect in–place by a dedicated offset.
+     *
+     * @param x A horizontal offset.
+     * @param y A vertical offset
+     * @returns A rect which has been moved.
+     */
+    moveBy(x: number, y: number): this;
+    /**
+     * Returns a new rect a a result of intersection with another rect.
+     */
+    getIntersection(anotherRect: Rect): Rect | null;
+    /**
+     * Returns the area of intersection with another rect.
+     *
+     * @returns Area of intersection.
+     */
+    getIntersectionArea(anotherRect: Rect): number;
+    /**
+     * Returns the area of the rect.
+     */
+    getArea(): number;
+    /**
+     * Returns a new rect, a part of the original rect, which is actually visible to the user and is relative to the,`body`,
+     * e.g. an original rect cropped by parent element rects which have `overflow` set in CSS
+     * other than `"visible"`.
+     *
+     * If there's no such visible rect, which is when the rect is limited by one or many of
+     * the ancestors, `null` is returned.
+     *
+     * **Note**: This method does not consider the boundaries of the viewport (window).
+     * To get a rect cropped by all ancestors and the viewport, use an intersection such as:
+     *
+     * ```ts
+     * const visibleInViewportRect = new Rect( window ).getIntersection( new Rect( source ).getVisible() );
+     * ```
+     *
+     * @returns A visible rect instance or `null`, if there's none.
+     */
+    getVisible(): Rect | null;
+    /**
+     * Checks if all property values ({@link #top}, {@link #left}, {@link #right},
+     * {@link #bottom}, {@link #width} and {@link #height}) are the equal in both rect
+     * instances.
+     *
+     * @param anotherRect A rect instance to compare with.
+     * @returns `true` when Rects are equal. `false` otherwise.
+     */
+    isEqual(anotherRect: Rect): boolean;
+    /**
+     * Checks whether a rect fully contains another rect instance.
+     *
+     * @param anotherRect
+     * @returns `true` if contains, `false` otherwise.
+     */
+    contains(anotherRect: Rect): boolean;
+    /**
+     * Recalculates screen coordinates to coordinates relative to the positioned ancestor offset.
+     */
+    toAbsoluteRect(): Rect;
+    /**
+     * Excludes scrollbars and CSS borders from the rect.
+     *
+     * * Borders are removed when {@link #_source} is an HTML element.
+     * * Scrollbars are excluded from HTML elements and the `window`.
+     *
+     * @returns A rect which has been updated.
+     */
+    excludeScrollbarsAndBorders(): this;
+    /**
+     * Returns an array of rects of the given native DOM Range.
+     *
+     * @param range A native DOM range.
+     * @returns DOM Range rects.
+     */
+    static getDomRangeRects(range: Range): Array<Rect>;
+    /**
+     * Returns a bounding rectangle that contains all the given `rects`.
+     *
+     * @param rects A list of rectangles that should be contained in the result rectangle.
+     * @returns Bounding rectangle or `null` if no `rects` were given.
+     */
+    static getBoundingRect(rects: Iterable<Rect>): Rect | null;
+}
+/**
+ * A source of {@link module:utils/dom/rect~Rect}.
+ */
+export type RectSource = HTMLElement | Range | Window | RectLike;
+/**
+ * An object that describes properties of `ClientRect` object.
+ */
+export interface RectLike {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+    readonly width: number;
+    readonly height: number;
+}

package/dist/types/dom/remove.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/dom/remove
+ */
+/**
+ * Removes given node from parent.
+ *
+ * @param node Node to remove.
+ */
+export default function remove(node: Node): void;

package/dist/types/dom/resizeobserver.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * A helper class which instances allow performing custom actions when native DOM elements are resized.
+ *
+ * ```ts
+ * const editableElement = editor.editing.view.getDomRoot();
+ *
+ * const observer = new ResizeObserver( editableElement, entry => {
+ * 	console.log( 'The editable element has been resized in DOM.' );
+ * 	console.log( entry.target ); // -> editableElement
+ * 	console.log( entry.contentRect.width ); // -> e.g. '423px'
+ * } );
+ * ```
+ *
+ * It uses the [native DOM resize observer](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)
+ * under the hood.
+ */
+export default class ResizeObserver {
+    /**
+     * The element observed by this observer.
+     */
+    private readonly _element;
+    /**
+     * The callback executed each time {@link #_element} is resized.
+     */
+    private readonly _callback;
+    /**
+     * The single native observer instance shared across all {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+     */
+    private static _observerInstance;
+    /**
+     * A mapping of native DOM elements and their callbacks shared across all
+     * {@link module:utils/dom/resizeobserver~ResizeObserver} instances.
+     */
+    private static _elementCallbacks;
+    /**
+     * Creates an instance of the `ResizeObserver` class.
+     *
+     * @param element A DOM element that is to be observed for resizing. Note that
+     * the element must be visible (i.e. not detached from DOM) for the observer to work.
+     * @param callback A function called when the observed element was resized. It passes
+     * the [`ResizeObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserverEntry)
+     * object with information about the resize event.
+     */
+    constructor(element: Element, callback: (entry: ResizeObserverEntry) => void);
+    /**
+     * The element observed by this observer.
+     */
+    get element(): Element;
+    /**
+     * Destroys the observer which disables the `callback` passed to the {@link #constructor}.
+     */
+    destroy(): void;
+    /**
+     * Registers a new resize callback for the DOM element.
+     */
+    private static _addElementCallback;
+    /**
+     * Removes a resize callback from the DOM element. If no callbacks are left
+     * for the element, it removes the element from the native observer.
+     */
+    private static _deleteElementCallback;
+    /**
+     * Returns are registered resize callbacks for the DOM element.
+     */
+    private static _getElementCallbacks;
+    /**
+     * Creates the single native observer shared across all `ResizeObserver` instances.
+     */
+    private static _createObserver;
+}

package/dist/types/dom/scroll.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+type IfTrue<T> = T extends true ? true : never;
+/**
+ * Makes any page `HTMLElement` or `Range` (`target`) visible inside the browser viewport.
+ * This helper will scroll all `target` ancestors and the web browser viewport to reveal the target to
+ * the user. If the `target` is already visible, nothing will happen.
+ *
+ * @param options Additional configuration of the scrolling behavior.
+ * @param options.target A target, which supposed to become visible to the user.
+ * @param options.viewportOffset An offset from the edge of the viewport (in pixels)
+ * the `target` will be moved by if the viewport is scrolled. It enhances the user experience
+ * by keeping the `target` some distance from the edge of the viewport and thus making it easier to
+ * read or edit by the user.
+ * @param options.ancestorOffset An offset from the boundary of scrollable ancestors (if any)
+ * the `target` will be moved by if the viewport is scrolled. It enhances the user experience
+ * by keeping the `target` some distance from the edge of the ancestors and thus making it easier to
+ * read or edit by the user.
+ * @param options.alignToTop When set `true`, the helper will make sure the `target` is scrolled up
+ * to the top boundary of the viewport and/or scrollable ancestors if scrolled up. When not set
+ * (default), the `target` will be revealed by scrolling as little as possible. This option will
+ * not affect `targets` that must be scrolled down because they will appear at the top of the boundary
+ * anyway.
+ *
+ * ```
+ *                                             scrollViewportToShowTarget() with            scrollViewportToShowTarget() with
+ *          Initial state                        alignToTop unset (default)                        alignToTop = true
+ *
+ * ┌────────────────────────────────┬─┐       ┌────────────────────────────────┬─┐        ┌────────────────────────────────┬─┐
+ * │                                │▲│       │                                │▲│        │   [ Target to be revealed ]    │▲│
+ * │                                │ │       │                                │ │        │                                │ │
+ * │                                │█│       │                                │ │        │                                │ │
+ * │                                │█│       │                                │ │        │                                │ │
+ * │                                │ │       │                                │█│        │                                │ │
+ * │                                │ │       │                                │█│        │                                │█│
+ * │                                │ │       │                                │ │        │                                │█│
+ * │                                │▼│       │   [ Target to be revealed ]    │▼│        │                                │▼│
+ * └────────────────────────────────┴─┘       └────────────────────────────────┴─┘        └────────────────────────────────┴─┘
+ *
+ *
+ *     [ Target to be revealed ]
+ *```
+ *
+ * @param options.forceScroll When set `true`, the `target` will be aligned to the top of the viewport
+ * and scrollable ancestors whether it is already visible or not. This option will only work when `alignToTop`
+ * is `true`
+ */
+export declare function scrollViewportToShowTarget<T extends boolean, U extends IfTrue<T>>({ target, viewportOffset, ancestorOffset, alignToTop, forceScroll }: {
+    readonly target: HTMLElement | Range;
+    readonly viewportOffset?: number | {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    readonly ancestorOffset?: number;
+    readonly alignToTop?: T;
+    readonly forceScroll?: U;
+}): void;
+/**
+ * Makes any page `HTMLElement` or `Range` (target) visible within its scrollable ancestors,
+ * e.g. if they have `overflow: scroll` CSS style.
+ *
+ * @param target A target, which supposed to become visible to the user.
+ * @param ancestorOffset An offset between the target and the boundary of scrollable ancestors
+ * to be maintained while scrolling.
+ * @param limiterElement The outermost ancestor that should be scrolled. If specified, it can prevent
+ * scrolling the whole page.
+ */
+export declare function scrollAncestorsToShowTarget(target: HTMLElement | Range, ancestorOffset?: number, limiterElement?: HTMLElement): void;
+export {};

package/dist/types/dom/setdatainelement.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module utils/dom/setdatainelement
+ */
+/**
+ * Sets data in a given element.
+ *
+ * @param el The element in which the data will be set.
+ * @param data The data string.
+ */
+export default function setDataInElement(el: HTMLElement, data: string): void;