npm - @ckeditor/ckeditor5-utils - Versions diffs - 35.0.0 → 35.0.1 - Mend

@ckeditor/ckeditor5-utils 35.0.0 → 35.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

package/package.json +5 -5
package/src/areconnectedthroughproperties.js +75 -0
package/src/ckeditorerror.js +195 -0
package/src/collection.js +619 -0
package/src/comparearrays.js +45 -0
package/src/config.js +216 -0
package/src/count.js +22 -0
package/src/diff.js +113 -0
package/src/difftochanges.js +76 -0
package/src/dom/createelement.js +41 -0
package/src/dom/emittermixin.js +301 -0
package/src/dom/getancestors.js +27 -0
package/src/dom/getborderwidths.js +24 -0
package/src/dom/getcommonancestor.js +25 -0
package/src/dom/getdatafromelement.js +20 -0
package/src/dom/getpositionedancestor.js +23 -0
package/src/dom/global.js +23 -0
package/src/dom/indexof.js +21 -0
package/src/dom/insertat.js +17 -0
package/src/dom/iscomment.js +17 -0
package/src/dom/isnode.js +24 -0
package/src/dom/isrange.js +16 -0
package/src/dom/istext.js +16 -0
package/src/dom/isvisible.js +23 -0
package/src/dom/iswindow.js +25 -0
package/src/dom/position.js +328 -0
package/src/dom/rect.js +364 -0
package/src/dom/remove.js +18 -0
package/src/dom/resizeobserver.js +145 -0
package/src/dom/scroll.js +270 -0
package/src/dom/setdatainelement.js +20 -0
package/src/dom/tounit.js +25 -0
package/src/elementreplacer.js +43 -0
package/src/emittermixin.js +471 -0
package/src/env.js +168 -0
package/src/eventinfo.js +26 -0
package/src/fastdiff.js +229 -0
package/src/first.js +20 -0
package/src/focustracker.js +103 -0
package/src/index.js +36 -0
package/src/inserttopriorityarray.js +21 -0
package/src/isiterable.js +16 -0
package/src/keyboard.js +222 -0
package/src/keystrokehandler.js +114 -0
package/src/language.js +20 -0
package/src/locale.js +79 -0
package/src/mapsequal.js +27 -0
package/src/mix.js +44 -0
package/src/nth.js +28 -0
package/src/objecttomap.js +25 -0
package/src/observablemixin.js +605 -0
package/src/priorities.js +32 -0
package/src/spy.js +22 -0
package/src/toarray.js +7 -0
package/src/tomap.js +27 -0
package/src/translation-service.js +180 -0
package/src/uid.js +55 -0
package/src/unicode.js +91 -0
package/src/version.js +148 -0

package/src/dom/position.js ADDED Viewed

@@ -0,0 +1,328 @@
+/**
+ * @license Copyright (c) 2003-2022, 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/position
+ */
+import global from './global';
+import Rect from './rect';
+import getPositionedAncestor from './getpositionedancestor';
+import getBorderWidths from './getborderwidths';
+import { isFunction } from 'lodash-es';
+// @if CK_DEBUG_POSITION // import { RectDrawer } from '@ckeditor/ckeditor5-minimap/src/utils';
+/**
+ * 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.
+ *
+ *		// 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 {module:utils/dom/position~Options} options The input data and configuration of the helper.
+ * @returns {module:utils/dom/position~Position}
+ */
+export function getOptimalPosition({ element, target, positions, limiter, fitInViewport, viewportOffsetConfig }) {
+    // If the {@link module:utils/dom/position~Options#target} is a function, use what it returns.
+    // https://github.com/ckeditor/ckeditor5-utils/issues/157
+    if (isFunction(target)) {
+        target = target();
+    }
+    // If the {@link module:utils/dom/position~Options#limiter} is a function, use what it returns.
+    // https://github.com/ckeditor/ckeditor5-ui/issues/260
+    if (isFunction(limiter)) {
+        limiter = limiter();
+    }
+    const positionedElementAncestor = getPositionedAncestor(element);
+    const elementRect = new Rect(element);
+    const targetRect = new Rect(target);
+    let bestPosition;
+    // @if CK_DEBUG_POSITION // RectDrawer.clear();
+    // @if CK_DEBUG_POSITION // RectDrawer.draw( targetRect, { outlineWidth: '5px' }, 'Target' );
+    const viewportRect = fitInViewport && getConstrainedViewportRect(viewportOffsetConfig) || null;
+    const positionOptions = { targetRect, elementRect, positionedElementAncestor, viewportRect };
+    // If there are no limits, just grab the very first position and be done with that drama.
+    if (!limiter && !fitInViewport) {
+        bestPosition = new PositionObject(positions[0], positionOptions);
+    }
+    else {
+        const limiterRect = limiter && new Rect(limiter).getVisible();
+        // @if CK_DEBUG_POSITION // if ( viewportRect ) {
+        // @if CK_DEBUG_POSITION //		RectDrawer.draw( viewportRect, { outlineWidth: '5px' }, 'Viewport' );
+        // @if CK_DEBUG_POSITION // }
+        // @if CK_DEBUG_POSITION // if ( limiter ) {
+        // @if CK_DEBUG_POSITION // 	RectDrawer.draw( limiterRect, { outlineWidth: '5px', outlineColor: 'green' }, 'Visible limiter' );
+        // @if CK_DEBUG_POSITION // }
+        Object.assign(positionOptions, { limiterRect, viewportRect });
+        // If there's no best position found, i.e. when all intersections have no area because
+        // rects have no width or height, then just use the first available position.
+        bestPosition = getBestPosition(positions, positionOptions) || new PositionObject(positions[0], positionOptions);
+    }
+    return bestPosition;
+}
+// Returns a viewport `Rect` shrunk by the viewport offset config from all sides.
+//
+// @private
+// @param {Object} An object containing viewportOffset config.
+// @returns {module:utils/dom/rect~Rect} A shrunken rect of the viewport.
+function getConstrainedViewportRect(viewportOffsetConfig) {
+    viewportOffsetConfig = Object.assign({ top: 0, bottom: 0, left: 0, right: 0 }, viewportOffsetConfig);
+    const viewportRect = new Rect(global.window);
+    viewportRect.top += viewportOffsetConfig.top;
+    viewportRect.height -= viewportOffsetConfig.top;
+    viewportRect.bottom -= viewportOffsetConfig.bottom;
+    viewportRect.height -= viewportOffsetConfig.bottom;
+    return viewportRect;
+}
+// For a given array of positioning functions, returns such that provides the best
+// fit of the `elementRect` into the `limiterRect` and `viewportRect`.
+//
+// @private
+//
+// @param {module:utils/dom/position~Options#positions} positions Functions returning
+// {@link module:utils/dom/position~Position}to be checked, in the order of preference.
+// @param {Object} options
+// @param {module:utils/dom/rect~Rect} options.elementRect The positioned element rect.
+// @param {module:utils/dom/rect~Rect} options.targetRect The target element rect.
+// @param {module:utils/dom/rect~Rect} options.viewportRect The viewport rect.
+// @param {module:utils/dom/rect~Rect} [options.limiterRect] The limiter rect.
+// @param {HTMLElement|null} [options.positionedElementAncestor] Nearest element ancestor element which CSS position is not "static".
+//
+// @returns {module:utils/dom/position~Position|null} An array containing the name of the position and it's rect.
+function getBestPosition(positions, options) {
+    const { elementRect } = options;
+    // This is when element is fully visible.
+    const elementRectArea = elementRect.getArea();
+    const positionInstances = positions
+        .map(positioningFunction => new PositionObject(positioningFunction, options))
+        // Some positioning functions may return `null` if they don't want to participate.
+        .filter(position => !!position.name);
+    let maxFitFactor = 0;
+    let bestPosition = null;
+    for (const position of positionInstances) {
+        const { limiterIntersectionArea, viewportIntersectionArea } = position;
+        // If a such position is found that element is fully contained by the limiter then, obviously,
+        // there will be no better one, so finishing.
+        if (limiterIntersectionArea === elementRectArea) {
+            return position;
+        }
+        // To maximize both viewport and limiter intersection areas we use distance on _viewportIntersectionArea
+        // and _limiterIntersectionArea plane (without sqrt because we are looking for max value).
+        const fitFactor = viewportIntersectionArea ** 2 + limiterIntersectionArea ** 2;
+        if (fitFactor > maxFitFactor) {
+            maxFitFactor = fitFactor;
+            bestPosition = position;
+        }
+    }
+    return bestPosition;
+}
+// For a given absolute Rect coordinates object and a positioned element ancestor, it updates its
+// coordinates that make up for the position and the scroll of the ancestor.
+//
+// This is necessary because while Rects (and DOMRects) are relative to the browser's viewport, their coordinates
+// are used in real–life to position elements with `position: absolute`, which are scoped by any positioned
+// (and scrollable) ancestors.
+//
+// @private
+//
+// @param {module:utils/dom/rect~Rect} rect A rect with absolute rect coordinates.
+// @param {HTMLElement} positionedElementAncestor An ancestor element that should be considered.
+function shiftRectToCompensatePositionedAncestor(rect, positionedElementAncestor) {
+    const ancestorPosition = getRectForAbsolutePositioning(new Rect(positionedElementAncestor));
+    const ancestorBorderWidths = getBorderWidths(positionedElementAncestor);
+    let moveX = 0;
+    let moveY = 0;
+    // (https://github.com/ckeditor/ckeditor5-ui-default/issues/126)
+    // If there's some positioned ancestor of the panel, then its `Rect` must be taken into
+    // consideration. `Rect` is always relative to the viewport while `position: absolute` works
+    // with respect to that positioned ancestor.
+    moveX -= ancestorPosition.left;
+    moveY -= ancestorPosition.top;
+    // (https://github.com/ckeditor/ckeditor5-utils/issues/139)
+    // If there's some positioned ancestor of the panel, not only its position must be taken into
+    // consideration (see above) but also its internal scrolls. Scroll have an impact here because `Rect`
+    // is relative to the viewport (it doesn't care about scrolling), while `position: absolute`
+    // must compensate that scrolling.
+    moveX += positionedElementAncestor.scrollLeft;
+    moveY += positionedElementAncestor.scrollTop;
+    // (https://github.com/ckeditor/ckeditor5-utils/issues/139)
+    // If there's some positioned ancestor of the panel, then its `Rect` includes its CSS `borderWidth`
+    // while `position: absolute` positioning does not consider it.
+    // E.g. `{ position: absolute, top: 0, left: 0 }` means upper left corner of the element,
+    // not upper-left corner of its border.
+    moveX -= ancestorBorderWidths.left;
+    moveY -= ancestorBorderWidths.top;
+    rect.moveBy(moveX, moveY);
+}
+// DOMRect (also Rect) works in a scroll–independent geometry but `position: absolute` doesn't.
+// This function converts Rect to `position: absolute` coordinates.
+//
+// @private
+// @param {module:utils/dom/rect~Rect} rect A rect to be converted.
+// @returns {module:utils/dom/rect~Rect} Object containing `left` and `top` properties, in absolute coordinates.
+function getRectForAbsolutePositioning(rect) {
+    const { scrollX, scrollY } = global.window;
+    return rect.clone().moveBy(scrollX, scrollY);
+}
+// A position class which instances are created and used by the {@link module:utils/dom/position~getOptimalPosition} helper.
+//
+// {@link module:utils/dom/position~Position#top} and {@link module:utils/dom/position~Position#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.
+// @private
+// @implements {Position}
+class PositionObject {
+    // Creates an instance of the {@link module:utils/dom/position~PositionObject} class.
+    //
+    // @param {module:utils/dom/position~PositioningFunction} positioningFunction function The function that defines the expected
+    // coordinates the positioned element should move to.
+    // @param {Object} [options] options object.
+    // @param {module:utils/dom/rect~Rect} options.elementRect The positioned element rect.
+    // @param {module:utils/dom/rect~Rect} options.targetRect The target element rect.
+    // @param {module:utils/dom/rect~Rect|null} options.viewportRect The viewport rect.
+    // @param {module:utils/dom/rect~Rect} [options.limiterRect] The limiter rect.
+    // @param {HTMLElement|null} [options.positionedElementAncestor] Nearest element ancestor element which CSS position is not "static".
+    constructor(positioningFunction, options) {
+        const positioningFunctionOutput = positioningFunction(options.targetRect, options.elementRect, options.viewportRect);
+        // Nameless position for a function that didn't participate.
+        if (!positioningFunctionOutput) {
+            return;
+        }
+        const { left, top, name, config } = positioningFunctionOutput;
+        this.name = name;
+        this.config = config;
+        this._positioningFunctionCorrdinates = { left, top };
+        this._options = options;
+    }
+    // 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
+    // @type {Number}
+    get left() {
+        return this._absoluteRect.left;
+    }
+    // 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
+    // @type {Number}
+    get top() {
+        return this._absoluteRect.top;
+    }
+    // An intersection area between positioned element and limiter within viewport constraints.
+    //
+    // @readonly
+    // @type {Number}
+    get limiterIntersectionArea() {
+        const limiterRect = this._options.limiterRect;
+        if (limiterRect) {
+            const viewportRect = this._options.viewportRect;
+            if (viewportRect) {
+                // Consider only the part of the limiter which is visible in the viewport. So the limiter is getting limited.
+                const limiterViewportIntersectRect = limiterRect.getIntersection(viewportRect);
+                if (limiterViewportIntersectRect) {
+                    // If the limiter is within the viewport, then check the intersection between that part of the
+                    // limiter and actual position.
+                    return limiterViewportIntersectRect.getIntersectionArea(this._rect);
+                }
+            }
+            else {
+                return limiterRect.getIntersectionArea(this._rect);
+            }
+        }
+        return 0;
+    }
+    // An intersection area between positioned element and viewport.
+    //
+    // @readonly
+    // @type {Number}
+    get viewportIntersectionArea() {
+        const viewportRect = this._options.viewportRect;
+        if (viewportRect) {
+            return viewportRect.getIntersectionArea(this._rect);
+        }
+        return 0;
+    }
+    // An already positioned element rect. A clone of the element rect passed to the constructor
+    // but placed in the viewport according to the positioning function.
+    //
+    // @private
+    // @readonly
+    // @type {module:utils/dom/rect~Rect}
+    get _rect() {
+        if (this._cachedRect) {
+            return this._cachedRect;
+        }
+        this._cachedRect = this._options.elementRect.clone().moveTo(this._positioningFunctionCorrdinates.left, this._positioningFunctionCorrdinates.top);
+        return this._cachedRect;
+    }
+    // An already absolutely positioned element rect. See ({@link #_rect}).
+    //
+    // @private
+    // @readonly
+    // @type {module:utils/dom/rect~Rect}
+    get _absoluteRect() {
+        if (this._cachedAbsoluteRect) {
+            return this._cachedAbsoluteRect;
+        }
+        this._cachedAbsoluteRect = getRectForAbsolutePositioning(this._rect);
+        if (this._options.positionedElementAncestor) {
+            shiftRectToCompensatePositionedAncestor(this._cachedAbsoluteRect, this._options.positionedElementAncestor);
+        }
+        return this._cachedAbsoluteRect;
+    }
+}

package/src/dom/rect.js ADDED Viewed

@@ -0,0 +1,364 @@
+/**
+ * @license Copyright (c) 2003-2022, 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/rect
+ */
+import isRange from './isrange';
+import isWindow from './iswindow';
+import getBorderWidths from './getborderwidths';
+import isText from './istext';
+import { isElement } from 'lodash-es';
+const rectProperties = ['top', 'right', 'bottom', 'left', 'width', 'height'];
+/**
+ * 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 {
+    /**
+     * Creates an instance of rect.
+     *
+     *		// 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 {module:utils/dom/rect~RectSource} source A source object to create the rect.
+     */
+    constructor(source) {
+        const isSourceRange = isRange(source);
+        Object.defineProperty(this, '_source', {
+            // If the source is a Rect instance, copy it's #_source.
+            value: source._source || source,
+            writable: true,
+            enumerable: false
+        });
+        if (isDomElement(source) || isSourceRange) {
+            // The `Rect` class depends on `getBoundingClientRect` and `getClientRects` DOM methods. If the source
+            // of a rect in an HTML element or a DOM range but it does not belong to any rendered DOM tree, these methods
+            // will fail to obtain the geometry and the rect instance makes little sense to the features using it.
+            // To get rid of this warning make sure the source passed to the constructor is a descendant of `window.document.body`.
+            // @if CK_DEBUG // const sourceNode = isSourceRange ? source.startContainer : source;
+            // @if CK_DEBUG // if ( !sourceNode.ownerDocument || !sourceNode.ownerDocument.body.contains( sourceNode ) ) {
+            // @if CK_DEBUG // 	console.warn(
+            // @if CK_DEBUG // 		'rect-source-not-in-dom: The source of this rect does not belong to any rendered DOM tree.',
+            // @if CK_DEBUG // 		{ source } );
+            // @if CK_DEBUG // }
+            if (isSourceRange) {
+                const rangeRects = Rect.getDomRangeRects(source);
+                copyRectProperties(this, Rect.getBoundingRect(rangeRects));
+            }
+            else {
+                copyRectProperties(this, source.getBoundingClientRect());
+            }
+        }
+        else if (isWindow(source)) {
+            const { innerWidth, innerHeight } = source;
+            copyRectProperties(this, {
+                top: 0,
+                right: innerWidth,
+                bottom: innerHeight,
+                left: 0,
+                width: innerWidth,
+                height: innerHeight
+            });
+        }
+        else {
+            copyRectProperties(this, source);
+        }
+    }
+    /**
+     * Returns a clone of the rect.
+     *
+     * @returns {module:utils/dom/rect~Rect} A cloned rect.
+     */
+    clone() {
+        return new Rect(this);
+    }
+    /**
+     * Moves the rect so that its upper–left corner lands in desired `[ x, y ]` location.
+     *
+     * @param {Number} x Desired horizontal location.
+     * @param {Number} y Desired vertical location.
+     * @returns {module:utils/dom/rect~Rect} A rect which has been moved.
+     */
+    moveTo(x, y) {
+        this.top = y;
+        this.right = x + this.width;
+        this.bottom = y + this.height;
+        this.left = x;
+        return this;
+    }
+    /**
+     * Moves the rect in–place by a dedicated offset.
+     *
+     * @param {Number} x A horizontal offset.
+     * @param {Number} y A vertical offset
+     * @returns {module:utils/dom/rect~Rect} A rect which has been moved.
+     */
+    moveBy(x, y) {
+        this.top += y;
+        this.right += x;
+        this.left += x;
+        this.bottom += y;
+        return this;
+    }
+    /**
+     * Returns a new rect a a result of intersection with another rect.
+     *
+     * @param {module:utils/dom/rect~Rect} anotherRect
+     * @returns {module:utils/dom/rect~Rect|null}
+     */
+    getIntersection(anotherRect) {
+        const rect = {
+            top: Math.max(this.top, anotherRect.top),
+            right: Math.min(this.right, anotherRect.right),
+            bottom: Math.min(this.bottom, anotherRect.bottom),
+            left: Math.max(this.left, anotherRect.left),
+            width: 0,
+            height: 0
+        };
+        rect.width = rect.right - rect.left;
+        rect.height = rect.bottom - rect.top;
+        if (rect.width < 0 || rect.height < 0) {
+            return null;
+        }
+        else {
+            return new Rect(rect);
+        }
+    }
+    /**
+     * Returns the area of intersection with another rect.
+     *
+     * @param {module:utils/dom/rect~Rect} anotherRect
+     * @returns {Number} Area of intersection.
+     */
+    getIntersectionArea(anotherRect) {
+        const rect = this.getIntersection(anotherRect);
+        if (rect) {
+            return rect.getArea();
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Returns the area of the rect.
+     *
+     * @returns {Number}
+     */
+    getArea() {
+        return this.width * this.height;
+    }
+    /**
+     * Returns a new rect, a part of the original rect, which is actually visible to the user,
+     * 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.
+     *
+     * @returns {module:utils/dom/rect~Rect|null} A visible rect instance or `null`, if there's none.
+     */
+    getVisible() {
+        const source = this._source;
+        let visibleRect = this.clone();
+        // There's no ancestor to crop <body> with the overflow.
+        if (!isBody(source)) {
+            let parent = source.parentNode || source.commonAncestorContainer;
+            // Check the ancestors all the way up to the <body>.
+            while (parent && !isBody(parent)) {
+                const parentRect = new Rect(parent);
+                const intersectionRect = visibleRect.getIntersection(parentRect);
+                if (intersectionRect) {
+                    if (intersectionRect.getArea() < visibleRect.getArea()) {
+                        // Reduce the visible rect to the intersection.
+                        visibleRect = intersectionRect;
+                    }
+                }
+                else {
+                    // There's no intersection, the rect is completely invisible.
+                    return null;
+                }
+                parent = parent.parentNode;
+            }
+        }
+        return visibleRect;
+    }
+    /**
+     * 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 {module:utils/dom/rect~Rect} anotherRect A rect instance to compare with.
+     * @returns {Boolean} `true` when Rects are equal. `false` otherwise.
+     */
+    isEqual(anotherRect) {
+        for (const prop of rectProperties) {
+            if (this[prop] !== anotherRect[prop]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Checks whether a rect fully contains another rect instance.
+     *
+     * @param {module:utils/dom/rect~Rect} anotherRect
+     * @returns {Boolean} `true` if contains, `false` otherwise.
+     */
+    contains(anotherRect) {
+        const intersectRect = this.getIntersection(anotherRect);
+        return !!(intersectRect && intersectRect.isEqual(anotherRect));
+    }
+    /**
+     * 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 {module:utils/dom/rect~Rect} A rect which has been updated.
+     */
+    excludeScrollbarsAndBorders() {
+        const source = this._source;
+        let scrollBarWidth, scrollBarHeight, direction;
+        if (isWindow(source)) {
+            scrollBarWidth = source.innerWidth - source.document.documentElement.clientWidth;
+            scrollBarHeight = source.innerHeight - source.document.documentElement.clientHeight;
+            direction = source.getComputedStyle(source.document.documentElement).direction;
+        }
+        else {
+            const borderWidths = getBorderWidths(source);
+            scrollBarWidth = source.offsetWidth - source.clientWidth - borderWidths.left - borderWidths.right;
+            scrollBarHeight = source.offsetHeight - source.clientHeight - borderWidths.top - borderWidths.bottom;
+            direction = source.ownerDocument.defaultView.getComputedStyle(source).direction;
+            this.left += borderWidths.left;
+            this.top += borderWidths.top;
+            this.right -= borderWidths.right;
+            this.bottom -= borderWidths.bottom;
+            this.width = this.right - this.left;
+            this.height = this.bottom - this.top;
+        }
+        this.width -= scrollBarWidth;
+        if (direction === 'ltr') {
+            this.right -= scrollBarWidth;
+        }
+        else {
+            this.left += scrollBarWidth;
+        }
+        this.height -= scrollBarHeight;
+        this.bottom -= scrollBarHeight;
+        return this;
+    }
+    /**
+     * Returns an array of rects of the given native DOM Range.
+     *
+     * @param {Range} range A native DOM range.
+     * @returns {Array.<module:utils/dom/rect~Rect>} DOM Range rects.
+     */
+    static getDomRangeRects(range) {
+        const rects = [];
+        // Safari does not iterate over ClientRectList using for...of loop.
+        const clientRects = Array.from(range.getClientRects());
+        if (clientRects.length) {
+            for (const rect of clientRects) {
+                rects.push(new Rect(rect));
+            }
+        }
+        // If there's no client rects for the Range, use parent container's bounding rect
+        // instead and adjust rect's width to simulate the actual geometry of such range.
+        // https://github.com/ckeditor/ckeditor5-utils/issues/153
+        // https://github.com/ckeditor/ckeditor5-ui/issues/317
+        else {
+            let startContainer = range.startContainer;
+            if (isText(startContainer)) {
+                startContainer = startContainer.parentNode;
+            }
+            const rect = new Rect(startContainer.getBoundingClientRect());
+            rect.right = rect.left;
+            rect.width = 0;
+            rects.push(rect);
+        }
+        return rects;
+    }
+    /**
+     * Returns a bounding rectangle that contains all the given `rects`.
+     *
+     * @param {Iterable.<module:utils/dom/rect~Rect>} rects A list of rectangles that should be contained in the result rectangle.
+     * @returns {module:utils/dom/rect~Rect|null} Bounding rectangle or `null` if no `rects` were given.
+     */
+    static getBoundingRect(rects) {
+        const boundingRectData = {
+            left: Number.POSITIVE_INFINITY,
+            top: Number.POSITIVE_INFINITY,
+            right: Number.NEGATIVE_INFINITY,
+            bottom: Number.NEGATIVE_INFINITY,
+            width: 0,
+            height: 0
+        };
+        let rectangleCount = 0;
+        for (const rect of rects) {
+            rectangleCount++;
+            boundingRectData.left = Math.min(boundingRectData.left, rect.left);
+            boundingRectData.top = Math.min(boundingRectData.top, rect.top);
+            boundingRectData.right = Math.max(boundingRectData.right, rect.right);
+            boundingRectData.bottom = Math.max(boundingRectData.bottom, rect.bottom);
+        }
+        if (rectangleCount == 0) {
+            return null;
+        }
+        boundingRectData.width = boundingRectData.right - boundingRectData.left;
+        boundingRectData.height = boundingRectData.bottom - boundingRectData.top;
+        return new Rect(boundingRectData);
+    }
+}
+// Acquires all the rect properties from the passed source.
+//
+// @private
+// @param {module:utils/dom/rect~Rect} rect
+// @param {module:utils/dom/rect~RectLike} source
+function copyRectProperties(rect, source) {
+    for (const p of rectProperties) {
+        rect[p] = source[p];
+    }
+}
+// Checks if provided object is a <body> HTML element.
+//
+// @private
+// @param {*} value
+// @returns {Boolean}
+function isBody(value) {
+    if (!isDomElement(value)) {
+        return false;
+    }
+    return value === value.ownerDocument.body;
+}
+// Checks if provided object is a DOM Element.
+//
+// It's just a wrapper for lodash `isElement` but with type guard.
+//
+// @private
+// @param {*} value
+// @returns {Boolean}
+function isDomElement(value) {
+    return isElement(value);
+}