@wordpress/dom 4.57.0 → 5.1.0

package/src/dom/{get-offset-parent.js → get-offset-parent.ts}

@@ -1,4 +1,5 @@
 import getComputedStyle from './get-computed-style';
+import isElement from './is-element';
 
 /**
  * Returns the closest positioned element, or null under any of the conditions
@@ -7,18 +8,16 @@ import getComputedStyle from './get-computed-style';
  *
  * @see https://drafts.csswg.org/cssom-view/#dom-htmlelement-offsetparent
  *
- * @param {Node} node Node from which to find offset parent.
+ * @param node Node from which to find offset parent.
  *
- * @return {Node | null} Offset parent.
+ * @return Offset parent.
  */
-export default function getOffsetParent( node ) {
+export default function getOffsetParent( node: Node ): Node | null {
 	// Cannot retrieve computed style or offset parent only anything other than
 	// an element node, so find the closest element node.
-	let closestElement;
-	while ( ( closestElement = /** @type {Node} */ ( node.parentNode ) ) ) {
-		if ( closestElement.nodeType === closestElement.ELEMENT_NODE ) {
-			break;
-		}
+	let closestElement = node.parentNode;
+	while ( closestElement && ! isElement( closestElement ) ) {
+		closestElement = closestElement.parentNode;
 	}
 
 	if ( ! closestElement ) {
@@ -27,14 +26,10 @@ export default function getOffsetParent( node ) {
 
 	// If the closest element is already positioned, return it, as offsetParent
 	// does not otherwise consider the node itself.
-	if (
-		getComputedStyle( /** @type {Element} */ ( closestElement ) )
-			.position !== 'static'
-	) {
+	if ( getComputedStyle( closestElement ).position !== 'static' ) {
 		return closestElement;
 	}
 
 	// offsetParent is undocumented/draft.
-	return /** @type {Node & { offsetParent: Node }} */ ( closestElement )
-		.offsetParent;
+	return ( closestElement as HTMLElement ).offsetParent;
 }

package/src/dom/{get-range-height.js → get-range-height.ts}

@@ -2,10 +2,10 @@
  * Gets the height of the range without ignoring zero width rectangles, which
  * some browsers ignore when creating a union.
  *
- * @param {Range} range The range to check.
- * @return {number | undefined} Height of the range or undefined if the range has no client rectangles.
+ * @param range The range to check.
+ * @return Height of the range or undefined if the range has no client rectangles.
  */
-export default function getRangeHeight( range ) {
+export default function getRangeHeight( range: Range ): number | undefined {
 	const rects = Array.from( range.getClientRects() );
 
 	if ( ! rects.length ) {

package/src/dom/{get-rectangle-from-range.js → get-rectangle-from-range.ts}

@@ -5,11 +5,11 @@ import { assertIsDefined } from '../utils/assert-is-defined';
  * can be found. Use instead of `Range.getBoundingClientRect()`, which is often
  * broken, especially for collapsed ranges.
  *
- * @param {Range} range The range.
+ * @param range The range.
  *
- * @return {DOMRect?} The rectangle.
+ * @return The rectangle.
  */
-export default function getRectangleFromRange( range ) {
+export default function getRectangleFromRange( range: Range ): DOMRect | null {
 	// For uncollapsed ranges, get the rectangle that bounds the contents of the
 	// range; this a rectangle enclosing the union of the bounding rectangles
 	// for all the elements in the range.
@@ -97,10 +97,7 @@ export default function getRectangleFromRange( range ) {
 		let beforeRange;
 		if ( before && before.nodeType === before.TEXT_NODE ) {
 			beforeRange = ownerDocument.createRange();
-			beforeRange.setStart(
-				before,
-				/** @type {Text} */ ( before ).length
-			);
+			beforeRange.setStart( before, ( before as Text ).length );
 			beforeRange.collapse( true );
 		}
 		let afterRange;
@@ -149,13 +146,10 @@ export default function getRectangleFromRange( range ) {
 		rects.length === 1 &&
 		startContainer.nodeType === startContainer.TEXT_NODE &&
 		range.startOffset > 0 &&
-		range.startOffset < /** @type {Text} */ ( startContainer ).length
+		range.startOffset < ( startContainer as Text ).length
 	) {
 		assertIsDefined( ownerDocument, 'ownerDocument' );
-		const measure = (
-			/** @type {number} */ start,
-			/** @type {number} */ end
-		) => {
+		const measure = ( start: number, end: number ) => {
 			const charRange = ownerDocument.createRange();
 			charRange.setStart( startContainer, start );
 			charRange.setEnd( startContainer, end );

package/src/dom/{get-scroll-container.js → get-scroll-container.ts}

@@ -4,12 +4,15 @@ import getComputedStyle from './get-computed-style';
  * Given a DOM node, finds the closest scrollable container node or the node
  * itself, if scrollable.
  *
- * @param {Element | null} node      Node from which to start.
- * @param {?string}        direction Direction of scrollable container to search for ('vertical', 'horizontal', 'all').
- *                                   Defaults to 'vertical'.
- * @return {Element | undefined} Scrollable container node, if found.
+ * @param node      Node from which to start.
+ * @param direction Direction of scrollable container to search for ('vertical', 'horizontal', 'all').
+ *                  Defaults to 'vertical'.
+ * @return Scrollable container node, if found.
  */
-export default function getScrollContainer( node, direction = 'vertical' ) {
+export default function getScrollContainer(
+	node: Element | null,
+	direction: 'vertical' | 'horizontal' | 'all' = 'vertical'
+): Element | undefined {
 	if ( ! node ) {
 		return undefined;
 	}
@@ -43,8 +46,5 @@ export default function getScrollContainer( node, direction = 'vertical' ) {
 	}
 
 	// Continue traversing.
-	return getScrollContainer(
-		/** @type {Element} */ ( node.parentNode ),
-		direction
-	);
+	return getScrollContainer( node.parentNode as Element, direction );
 }

package/src/dom/{hidden-caret-range-from-point.js → hidden-caret-range-from-point.ts}

@@ -6,14 +6,19 @@ import getComputedStyle from './get-computed-style';
  * Gives the container a temporary high z-index (above any UI).
  * This is preferred over getting the UI nodes and set styles there.
  *
- * @param {Document}    doc       The document of the range.
- * @param {number}      x         Horizontal position within the current viewport.
- * @param {number}      y         Vertical position within the current viewport.
- * @param {HTMLElement} container Container in which the range is expected to be found.
+ * @param doc       The document of the range.
+ * @param x         Horizontal position within the current viewport.
+ * @param y         Vertical position within the current viewport.
+ * @param container Container in which the range is expected to be found.
  *
- * @return {?Range} The best range for the given point.
+ * @return The best range for the given point.
  */
-export default function hiddenCaretRangeFromPoint( doc, x, y, container ) {
+export default function hiddenCaretRangeFromPoint(
+	doc: Document,
+	x: number,
+	y: number,
+	container: HTMLElement
+): Range | null {
 	const originalZIndex = container.style.zIndex;
 	const originalPosition = container.style.position;
 	const originalBorderRadius = container.style.borderRadius;

package/src/dom/{input-field-has-uncollapsed-selection.js → input-field-has-uncollapsed-selection.ts}

@@ -14,11 +14,13 @@ import isHTMLInputElement from './is-html-input-element';
  *
  * See: https://html.spec.whatwg.org/multipage/input.html#do-not-apply
  *
- * @param {Element} element The HTML element.
+ * @param element The HTML element.
  *
- * @return {boolean} Whether the input/textarea element has some "selection".
+ * @return Whether the input/textarea element has some "selection".
  */
-export default function inputFieldHasUncollapsedSelection( element ) {
+export default function inputFieldHasUncollapsedSelection(
+	element: Element
+): boolean {
 	if ( ! isHTMLInputElement( element ) && ! isTextField( element ) ) {
 		return false;
 	}
@@ -27,8 +29,8 @@ export default function inputFieldHasUncollapsedSelection( element ) {
 	// `selectionEnd` on non-text <input> elements, so a try/catch construct is
 	// necessary.
 	try {
-		const { selectionStart, selectionEnd } =
-			/** @type {HTMLInputElement | HTMLTextAreaElement} */ ( element );
+		const { selectionStart, selectionEnd } = element as
+			HTMLInputElement | HTMLTextAreaElement;
 		return (
 			// `null` means the input type doesn't implement selection, thus we
 			// cannot determine whether the selection is collapsed, so we

package/src/dom/{insert-after.js → insert-after.ts}

@@ -4,11 +4,13 @@ import { assertIsDefined } from '../utils/assert-is-defined';
  * Given two DOM nodes, inserts the former in the DOM as the next sibling of
  * the latter.
  *
- * @param {Node} newNode       Node to be inserted.
- * @param {Node} referenceNode Node after which to perform the insertion.
- * @return {void}
+ * @param newNode       Node to be inserted.
+ * @param referenceNode Node after which to perform the insertion.
  */
-export default function insertAfter( newNode, referenceNode ) {
+export default function insertAfter(
+	newNode: Node,
+	referenceNode: Node
+): void {
 	assertIsDefined( referenceNode.parentNode, 'referenceNode.parentNode' );
 	referenceNode.parentNode.insertBefore( newNode, referenceNode.nextSibling );
 }

package/src/dom/{is-edge.js → is-edge.ts}

@@ -5,20 +5,23 @@ import isSelectionForward from './is-selection-forward';
 import hiddenCaretRangeFromPoint from './hidden-caret-range-from-point';
 import { assertIsDefined } from '../utils/assert-is-defined';
 import isInputOrTextArea from './is-input-or-text-area';
-import { scrollIfNoRange } from './scroll-if-no-range';
 
 /**
  * Check whether the selection is at the edge of the container. Checks for
  * horizontal position by default. Set `onlyVertical` to true to check only
  * vertically.
  *
- * @param {HTMLElement} container            Focusable element.
- * @param {boolean}     isReverse            Set to true to check left, false to check right.
- * @param {boolean}     [onlyVertical=false] Set to true to check only vertical position.
+ * @param container    Focusable element.
+ * @param isReverse    Set to true to check left, false to check right.
+ * @param onlyVertical Set to true to check only vertical position.
  *
- * @return {boolean} True if at the edge, false if not.
+ * @return True if at the edge, false if not.
  */
-export default function isEdge( container, isReverse, onlyVertical = false ) {
+export default function isEdge(
+	container: HTMLElement,
+	isReverse: boolean,
+	onlyVertical: boolean = false
+): boolean {
 	if (
 		isInputOrTextArea( container ) &&
 		typeof container.selectionStart === 'number'
@@ -78,53 +81,48 @@ export default function isEdge( container, isReverse, onlyVertical = false ) {
 		return false;
 	}
 
+	// A line above the selection (or below, when going down) means it is not
+	// at the vertical edge. Unlike hit-testing a point, a range measures
+	// lines outside the viewport too.
+	const contentRange = ownerDocument.createRange();
+	contentRange.selectNodeContents( container );
+	const hasLineBeyond = Array.from( contentRange.getClientRects() ).some(
+		( rect ) =>
+			rect.height > 0 &&
+			( isReverse
+				? rect.bottom <= rangeRect.top + 1
+				: rect.top >= rangeRect.bottom - 1 )
+	);
+
+	if ( hasLineBeyond ) {
+		return false;
+	}
+
+	if ( onlyVertical ) {
+		return true;
+	}
+
 	// In the case of RTL scripts, the horizontal edge is at the opposite side.
 	const isReverseDir = isRTL( container ) ? ! isReverse : isReverse;
 	const containerRect = container.getBoundingClientRect();
 
-	// To check if a selection is at the edge, we insert a test selection at the
-	// edge of the container and check if the selections have the same vertical
-	// or horizontal position. If they do, the selection is at the edge.
-	// This method proves to be better than a DOM-based calculation for the
-	// horizontal edge, since it ignores empty textnodes and a trailing line
-	// break element. In other words, we need to check visual positioning, not
-	// DOM positioning.
-	// It also proves better than using the computed style for the vertical
-	// edge, because we cannot know the padding and line height reliably in
-	// pixels. `getComputedStyle` may return a value with different units.
+	// The selection is on the edge line. To check if it is at the horizontal
+	// edge of that line, we hit-test a point at the container's edge on that
+	// line and check if the caret there has the same position. This proves
+	// better than a DOM-based calculation, since it ignores empty text nodes
+	// and a trailing line break element. The line is within the viewport when
+	// the selection is; otherwise the browser handles the key.
 	const x = isReverseDir ? containerRect.left + 1 : containerRect.right - 1;
-	const y = isReverse ? containerRect.top + 1 : containerRect.bottom - 1;
-
-	// The test point can only be hit-tested when it is within the viewport
-	// (`caretRangeFromPoint` returns nothing for a point outside it, upon
-	// which `scrollIfNoRange` scrolls the container's edge into view to
-	// measure, e.g. on every arrow press within a container taller than the
-	// viewport). When the edge is outside the viewport and the selection is
-	// within it, they are at least a viewport boundary apart along that
-	// axis, so the selection cannot be at the edge. Check each axis
-	// separately: the vertical check must not be short-circuited by a
-	// horizontally overflowing container, and vice versa.
-	const isFarFromVerticalEdge =
-		( y < 0 || y > defaultView.innerHeight ) &&
-		rangeRect.top >= 0 &&
-		rangeRect.bottom <= defaultView.innerHeight;
-	const isFarFromHorizontalEdge =
-		( x < 0 || x > defaultView.innerWidth ) &&
-		rangeRect.left >= 0 &&
-		rangeRect.right <= defaultView.innerWidth;
-
-	if (
-		isFarFromVerticalEdge ||
-		( ! onlyVertical && isFarFromHorizontalEdge )
-	) {
-		return false;
-	}
+	const y = isReverse ? rangeRect.top + 1 : rangeRect.bottom - 1;
 
-	const testRange = scrollIfNoRange( container, isReverse, () =>
-		hiddenCaretRangeFromPoint( ownerDocument, x, y, container )
+	const testRange = hiddenCaretRangeFromPoint(
+		ownerDocument,
+		x,
+		y,
+		container
 	);
 
-	if ( ! testRange ) {
+	if ( ! testRange || ! container.contains( testRange.startContainer ) ) {
 		return false;
 	}
 
@@ -144,7 +142,5 @@ export default function isEdge( container, isReverse, onlyVertical = false ) {
 	const hasVerticalDiff = Math.abs( verticalDiff ) <= 1;
 	const hasHorizontalDiff = Math.abs( horizontalDiff ) <= 1;
 
-	return onlyVertical
-		? hasVerticalDiff
-		: hasVerticalDiff && hasHorizontalDiff;
+	return hasVerticalDiff && hasHorizontalDiff;
 }

package/src/dom/{is-element.js → is-element.ts}

@@ -2,6 +2,8 @@
  * @param {Node | null | undefined} node
  * @return {node is Element} True if node is an Element node
  */
-export default function isElement( node ) {
+export default function isElement(
+	node: Node | null | undefined
+): node is Element {
 	return !! node && node.nodeType === node.ELEMENT_NODE;
 }

package/src/dom/{is-empty.js → is-empty.ts}

@@ -2,26 +2,24 @@
  * Recursively checks if an element is empty. An element is not empty if it
  * contains text or contains elements with attributes such as images.
  *
- * @param {Element} element The element to check.
+ * @param element The element to check.
  *
- * @return {boolean} Whether or not the element is empty.
+ * @return Whether or not the element is empty.
  */
-export default function isEmpty( element ) {
+export default function isEmpty( element: Node ): boolean {
 	switch ( element.nodeType ) {
 		case element.TEXT_NODE:
 			// We cannot use \s since it includes special spaces which we want
 			// to preserve.
 			return /^[ \f\n\r\t\v\u00a0]*$/.test( element.nodeValue || '' );
 		case element.ELEMENT_NODE:
-			if ( element.hasAttributes() ) {
+			if ( ( element as Element ).hasAttributes() ) {
 				return false;
 			} else if ( ! element.hasChildNodes() ) {
 				return true;
 			}
 
-			return /** @type {Element[]} */ (
-				Array.from( element.childNodes )
-			).every( isEmpty );
+			return Array.from( element.childNodes ).every( isEmpty );
 		default:
 			return true;
 	}

package/src/dom/{is-entirely-selected.js → is-entirely-selected.ts}

@@ -11,11 +11,11 @@ const ZWNBSP = '\ufeff';
  * Check whether the contents of the element have been entirely selected.
  * Returns true if there is no possibility of selection.
  *
- * @param {HTMLElement} element The element to check.
+ * @param element The element to check.
  *
- * @return {boolean} True if entirely selected, false if not.
+ * @return True if entirely selected, false if not.
  */
-export default function isEntirelySelected( element ) {
+export default function isEntirelySelected( element: HTMLElement ): boolean {
 	if ( isInputOrTextArea( element ) ) {
 		return (
 			element.selectionStart === 0 &&
@@ -61,7 +61,7 @@ export default function isEntirelySelected( element ) {
 	assertIsDefined( lastChild, 'lastChild' );
 	const endContainerContentLength =
 		endContainer.nodeType === endContainer.TEXT_NODE
-			? /** @type {Text} */ ( endContainer ).data.length
+			? ( endContainer as Text ).data.length
 			: endContainer.childNodes.length;
 
 	return (
@@ -76,15 +76,18 @@ export default function isEntirelySelected( element ) {
  * Check whether the contents of the element have been entirely selected.
  * Returns true if there is no possibility of selection.
  *
- * @param {HTMLElement|Node}         query     The element to check.
- * @param {HTMLElement}              container The container that we suspect "query" may be a first or last child of.
- * @param {"firstChild"|"lastChild"} propName  "firstChild" or "lastChild"
+ * @param query     The element to check.
+ * @param container The container that we suspect "query" may be a first or last child of.
+ * @param propName  "firstChild" or "lastChild"
  *
- * @return {boolean} True if query is a deep first/last child of container, false otherwise.
+ * @return True if query is a deep first/last child of container, false otherwise.
  */
-function isDeepChild( query, container, propName ) {
-	/** @type {HTMLElement | ChildNode | null} */
-	let candidate = container;
+function isDeepChild(
+	query: HTMLElement | Node,
+	container: HTMLElement,
+	propName: 'firstChild' | 'lastChild'
+): boolean {
+	let candidate: HTMLElement | ChildNode | null = container;
 	do {
 		if ( query === candidate ) {
 			return true;

package/src/dom/{is-form-element.js → is-form-element.ts}

@@ -4,11 +4,13 @@ import isInputOrTextArea from './is-input-or-text-area';
  *
  * Detects if element is a form element.
  *
- * @param {Element} element The element to check.
+ * @param element The element to check.
  *
- * @return {boolean} True if form element and false otherwise.
+ * @return True if form element and false otherwise.
  */
-export default function isFormElement( element ) {
+export default function isFormElement(
+	element: Element | null | undefined
+): boolean {
 	if ( ! element ) {
 		return false;
 	}

package/src/dom/{is-horizontal-edge.js → is-horizontal-edge.ts}

@@ -8,6 +8,9 @@ import isEdge from './is-edge';
  *
  * @return {boolean} True if at the horizontal edge, false if not.
  */
-export default function isHorizontalEdge( container, isReverse ) {
+export default function isHorizontalEdge(
+	container: HTMLElement,
+	isReverse: boolean
+): boolean {
 	return isEdge( container, isReverse );
 }

package/src/dom/{is-html-input-element.js → is-html-input-element.ts}

@@ -2,6 +2,8 @@
  * @param {Node} node
  * @return {node is HTMLInputElement} Whether the node is an HTMLInputElement.
  */
-export default function isHTMLInputElement( node ) {
+export default function isHTMLInputElement(
+	node: Node | null | undefined
+): node is HTMLInputElement {
 	return node?.nodeName === 'INPUT';
 }

package/src/dom/{is-input-or-text-area.js → is-input-or-text-area.ts}

@@ -2,6 +2,8 @@
  * @param {Element} element
  * @return {element is HTMLInputElement | HTMLTextAreaElement} Whether the element is an input or textarea
  */
-export default function isInputOrTextArea( element ) {
+export default function isInputOrTextArea(
+	element: Element
+): element is HTMLInputElement | HTMLTextAreaElement {
 	return element.tagName === 'INPUT' || element.tagName === 'TEXTAREA';
 }

package/src/dom/{is-number-input.js → is-number-input.ts}

@@ -4,11 +4,11 @@ import isHTMLInputElement from './is-html-input-element';
 /**
  * Check whether the given element is an input field of type number.
  *
- * @param {Node} node The HTML node.
+ * @param node The HTML node.
  *
- * @return {node is HTMLInputElement} True if the node is number input.
+ * @return True if the node is number input.
  */
-export default function isNumberInput( node ) {
+export default function isNumberInput( node: Node ): node is HTMLInputElement {
 	deprecated( 'wp.dom.isNumberInput', {
 		since: '6.1',
 		version: '6.5',

package/src/dom/{is-rtl.js → is-rtl.ts}

@@ -3,10 +3,10 @@ import getComputedStyle from './get-computed-style';
 /**
  * Whether the element's text direction is right-to-left.
  *
- * @param {Element} element The element to check.
+ * @param element The element to check.
  *
- * @return {boolean} True if rtl, false if ltr.
+ * @return True if rtl, false if ltr.
  */
-export default function isRTL( element ) {
+export default function isRTL( element: Element ): boolean {
 	return getComputedStyle( element ).direction === 'rtl';
 }

package/src/dom/{is-selection-forward.js → is-selection-forward.ts}

@@ -6,11 +6,11 @@ import { assertIsDefined } from '../utils/assert-is-defined';
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
  *
- * @param {Selection} selection Selection object to check.
+ * @param selection Selection object to check.
  *
- * @return {boolean} Whether the selection is forward.
+ * @return Whether the selection is forward.
  */
-export default function isSelectionForward( selection ) {
+export default function isSelectionForward( selection: Selection ): boolean {
 	const { anchorNode, focusNode, anchorOffset, focusOffset } = selection;
 
 	assertIsDefined( anchorNode, 'anchorNode' );

package/src/dom/{is-text-field.js → is-text-field.ts}

@@ -6,10 +6,10 @@ import isHTMLInputElement from './is-html-input-element';
  *
  * See: https://html.spec.whatwg.org/#textFieldSelection
  *
- * @param {Node} node The HTML element.
- * @return {node is HTMLElement} True if the element is an text field, false if not.
+ * @param node The HTML element.
+ * @return True if the element is an text field, false if not.
  */
-export default function isTextField( node ) {
+export default function isTextField( node: Node ): node is HTMLElement {
 	const nonTextInputs = [
 		'button',
 		'checkbox',
@@ -29,6 +29,6 @@ export default function isTextField( node ) {
 			node.type &&
 			! nonTextInputs.includes( node.type ) ) ||
 		node.nodeName === 'TEXTAREA' ||
-		/** @type {HTMLElement} */ ( node ).contentEditable === 'true'
+		( node as HTMLElement ).contentEditable === 'true'
 	);
 }

package/src/dom/{is-vertical-edge.js → is-vertical-edge.ts}

@@ -8,6 +8,9 @@ import isEdge from './is-edge';
  *
  * @return {boolean} True if at the vertical edge, false if not.
  */
-export default function isVerticalEdge( container, isReverse ) {
+export default function isVerticalEdge(
+	container: HTMLElement,
+	isReverse: boolean
+): boolean {
 	return isEdge( container, isReverse, true );
 }

package/src/dom/{place-caret-at-edge.js → place-caret-at-edge.ts}

@@ -7,13 +7,17 @@ import { scrollIfNoRange } from './scroll-if-no-range';
 /**
  * Gets the range to place.
  *
- * @param {HTMLElement}      container Focusable element.
- * @param {boolean}          isReverse True for end, false for start.
- * @param {number|undefined} x         X coordinate to vertically position.
+ * @param container Focusable element.
+ * @param isReverse True for end, false for start.
+ * @param x         X coordinate to vertically position.
  *
- * @return {Range|null} The range to place.
+ * @return The range to place.
  */
-function getRange( container, isReverse, x ) {
+function getRange(
+	container: HTMLElement,
+	isReverse: boolean,
+	x: number | undefined
+): Range | null {
 	const { ownerDocument } = container;
 	// In the case of RTL scripts, the horizontal edge is at the opposite side.
 	const isReverseDir = isRTL( container ) ? ! isReverse : isReverse;
@@ -36,11 +40,15 @@ function getRange( container, isReverse, x ) {
 /**
  * Places the caret at start or end of a given element.
  *
- * @param {HTMLElement}      container Focusable element.
- * @param {boolean}          isReverse True for end, false for start.
- * @param {number|undefined} x         X coordinate to vertically position.
+ * @param container Focusable element.
+ * @param isReverse True for end, false for start.
+ * @param x         X coordinate to vertically position.
  */
-export default function placeCaretAtEdge( container, isReverse, x ) {
+export default function placeCaretAtEdge(
+	container: HTMLElement,
+	isReverse: boolean,
+	x: number | undefined
+) {
 	if ( ! container ) {
 		return;
 	}

package/src/dom/{place-caret-at-horizontal-edge.js → place-caret-at-horizontal-edge.ts}

@@ -6,6 +6,9 @@ import placeCaretAtEdge from './place-caret-at-edge';
  * @param {HTMLElement} container Focusable element.
  * @param {boolean}     isReverse True for end, false for start.
  */
-export default function placeCaretAtHorizontalEdge( container, isReverse ) {
+export default function placeCaretAtHorizontalEdge(
+	container: HTMLElement,
+	isReverse: boolean
+) {
 	return placeCaretAtEdge( container, isReverse, undefined );
 }

package/src/dom/{place-caret-at-vertical-edge.js → place-caret-at-vertical-edge.ts}

@@ -7,6 +7,10 @@ import placeCaretAtEdge from './place-caret-at-edge';
  * @param {boolean}     isReverse True for bottom, false for top.
  * @param {DOMRect}     [rect]    The rectangle to position the caret with.
  */
-export default function placeCaretAtVerticalEdge( container, isReverse, rect ) {
+export default function placeCaretAtVerticalEdge(
+	container: HTMLElement,
+	isReverse: boolean,
+	rect?: DOMRect
+) {
 	return placeCaretAtEdge( container, isReverse, rect?.left );
 }