@wordpress/dom 4.56.0 → 5.0.0

package/build-types/types.d.ts

@@ -0,0 +1,29 @@
+export interface SemanticElementDefinition {
+    /**
+     * Content attributes
+     */
+    attributes?: string[];
+    /**
+     * Allowed child elements, or `'*'` for any
+     */
+    children?: ContentSchema | '*';
+}
+export type ContentSchema = Record<string, SemanticElementDefinition>;
+export interface FindFocusableOptions {
+    /**
+     * If set, only return elements that are sequentially focusable.
+     * Non-interactive elements with a negative `tabindex` are focusable but
+     * not sequentially focusable.
+     */
+    sequential?: boolean;
+}
+export type MaybeHTMLInputElement = HTMLElement & {
+    type?: string;
+    checked?: boolean;
+    name?: string;
+};
+export interface ObjectTabbable {
+    element: HTMLElement;
+    index: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/build-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACzC;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;OAEG;IACH,QAAQ,CAAC,EAAE,aAAa,GAAG,GAAG,CAAC;CAC/B;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAE,MAAM,EAAE,yBAAyB,CAAE,CAAC;AAExE,MAAM,WAAW,oBAAoB;IACpC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACd"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wordpress/dom",
-	"version": "4.56.0",
+	"version": "5.0.0",
 	"description": "DOM utilities module for WordPress.",
 	"author": "The WordPress Contributors",
 	"license": "GPL-2.0-or-later",
@@ -20,14 +20,13 @@
 		"url": "https://github.com/WordPress/gutenberg/issues"
 	},
 	"engines": {
-		"node": ">=18.12.0"
+		"node": ">=22.13.0"
 	},
 	"files": [
 		"src",
 		"build",
 		"build-module",
-		"build-types",
-		"*.md"
+		"build-types"
 	],
 	"main": "build/index.cjs",
 	"module": "build-module/index.mjs",
@@ -43,13 +42,13 @@
 	"types": "build-types",
 	"sideEffects": false,
 	"dependencies": {
-		"@wordpress/deprecated": "^4.56.0"
+		"@wordpress/deprecated": "^5.0.0"
 	},
 	"devDependencies": {
-		"vitest": "^5.0.0"
+		"vitest": "^5.0.3"
 	},
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "56d8058eda6e30c4cc8bfc37818fa6ed972f7dc2"
+	"gitHead": "8d30f92cbbde3ddf781c8799443c649befbbcb88"
 }

package/src/{data-transfer.js → data-transfer.ts}

@@ -1,11 +1,11 @@
 /**
  * Gets all files from a DataTransfer object.
  *
- * @param {DataTransfer} dataTransfer DataTransfer object to inspect.
+ * @param dataTransfer DataTransfer object to inspect.
  *
- * @return {File[]} An array containing all files.
+ * @return An array containing all files.
  */
-export function getFilesFromDataTransfer( dataTransfer ) {
+export function getFilesFromDataTransfer( dataTransfer: DataTransfer ): File[] {
 	const files = Array.from( dataTransfer.files );
 
 	Array.from( dataTransfer.items ).forEach( ( item ) => {

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

@@ -6,13 +6,17 @@
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/caretPositionFromPoint
  *
- * @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 doc The document of the range.
+ * @param x   Horizontal position within the current viewport.
+ * @param y   Vertical position within the current viewport.
  *
- * @return {Range | null} The best range for the given point.
+ * @return The best range for the given point.
  */
-export default function caretRangeFromPoint( doc, x, y ) {
+export default function caretRangeFromPoint(
+	doc: Document,
+	x: number,
+	y: number
+): Range | null {
 	if ( doc.caretPositionFromPoint ) {
 		const point = doc.caretPositionFromPoint( x, y );
 

package/src/dom/{clean-node-list.js → clean-node-list.ts}

@@ -4,33 +4,27 @@ import unwrap from './unwrap';
 import { isPhrasingContent } from '../phrasing-content';
 import insertAfter from './insert-after';
 import isElement from './is-element';
+import type { Schema } from './types';
 
 const noop = () => {};
 
-/**
- * @typedef SchemaItem
- * @property {string[]}                            [attributes] Attributes.
- * @property {(string | RegExp)[]}                 [classes]    Classnames or RegExp to test against. Use '*' to keep all classes.
- * @property {'*' | { [tag: string]: SchemaItem }} [children]   Child schemas.
- * @property {string[]}                            [require]    Selectors to test required children against. Leave empty or undefined if there are no requirements.
- * @property {boolean}                             allowEmpty   Whether to allow nodes without children.
- * @property {(node: Node) => boolean}             [isMatch]    Function to test whether a node is a match. If left undefined any node will be assumed to match.
- */
-
-/** @typedef {{ [tag: string]: SchemaItem }} Schema */
-
 /**
  * Given a schema, unwraps or removes nodes, attributes and classes on a node
  * list.
  *
- * @param {NodeList} nodeList The nodeList to filter.
- * @param {Document} doc      The document of the nodeList.
- * @param {Schema}   schema   An array of functions that can mutate with the provided node.
- * @param {boolean}  inline   Whether to clean for inline mode.
+ * @param nodeList The nodeList to filter.
+ * @param doc      The document of the nodeList.
+ * @param schema   Schema for the HTML.
+ * @param inline   Whether to clean for inline mode.
  */
-export default function cleanNodeList( nodeList, doc, schema, inline ) {
+export default function cleanNodeList(
+	nodeList: NodeList,
+	doc: Document,
+	schema: Schema,
+	inline: boolean
+) {
 	Array.from( nodeList ).forEach(
-		( /** @type {Node & { nextElementSibling?: unknown }} */ node ) => {
+		( node: Node & { nextElementSibling?: unknown } ) => {
 			const tag = node.nodeName.toLowerCase();
 
 			// It's a valid child, if the tag exists in the schema without an isMatch
@@ -84,13 +78,11 @@ export default function cleanNodeList( nodeList, doc, schema, inline ) {
 									// Keep all classes.
 									return () => true;
 								} else if ( typeof item === 'string' ) {
-									return (
-										/** @type {string} */ className
-									) => className === item;
+									return ( className: string ) =>
+										className === item;
 								} else if ( item instanceof RegExp ) {
-									return (
-										/** @type {string} */ className
-									) => item.test( className );
+									return ( className: string ) =>
+										item.test( className );
 								}
 
 								return noop;

package/src/dom/{compute-caret-rect.js → compute-caret-rect.ts}

@@ -4,11 +4,11 @@ import { assertIsDefined } from '../utils/assert-is-defined';
 /**
  * Get the rectangle for the selection in a container.
  *
- * @param {Window} win The window of the selection.
+ * @param win The window of the selection.
  *
- * @return {DOMRect | null} The rectangle.
+ * @return The rectangle.
  */
-export default function computeCaretRect( win ) {
+export default function computeCaretRect( win: Window ): DOMRect | null {
 	const selection = win.getSelection();
 	assertIsDefined( selection, 'selection' );
 	const range = selection.rangeCount ? selection.getRangeAt( 0 ) : null;

package/src/dom/{document-has-selection.js → document-has-selection.ts}

@@ -6,11 +6,11 @@ import documentHasTextSelection from './document-has-text-selection';
  * Check whether the current document has a selection. This includes focus in
  * input fields, textareas, and general rich-text selection.
  *
- * @param {Document} doc The document to check.
+ * @param doc The document to check.
  *
- * @return {boolean} True if there is selection, false if not.
+ * @return True if there is selection, false if not.
  */
-export default function documentHasSelection( doc ) {
+export default function documentHasSelection( doc: Document ): boolean {
 	return (
 		!! doc.activeElement &&
 		( isHTMLInputElement( doc.activeElement ) ||

package/src/dom/{document-has-text-selection.js → document-has-text-selection.ts}

@@ -7,11 +7,11 @@ import { assertIsDefined } from '../utils/assert-is-defined';
  *
  * See: https://developer.mozilla.org/en-US/docs/Web/API/Window/getSelection#Related_objects.
  *
- * @param {Document} doc The document to check.
+ * @param doc The document to check.
  *
- * @return {boolean} True if there is selection, false if not.
+ * @return True if there is selection, false if not.
  */
-export default function documentHasTextSelection( doc ) {
+export default function documentHasTextSelection( doc: Document ): boolean {
 	assertIsDefined( doc.defaultView, 'doc.defaultView' );
 	const selection = doc.defaultView.getSelection();
 	assertIsDefined( selection, 'selection' );

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

@@ -6,11 +6,13 @@ import inputFieldHasUncollapsedSelection from './input-field-has-uncollapsed-sel
  * This includes ranges of text across elements and any selection inside
  * textual `<input>` and `<textarea>` elements.
  *
- * @param {Document} doc The document to check.
+ * @param doc The document to check.
  *
- * @return {boolean} Whether there is any recognizable text selection in the document.
+ * @return Whether there is any recognizable text selection in the document.
  */
-export default function documentHasUncollapsedSelection( doc ) {
+export default function documentHasUncollapsedSelection(
+	doc: Document
+): boolean {
 	return (
 		documentHasTextSelection( doc ) ||
 		( !! doc.activeElement &&

package/src/dom/{get-computed-style.js → get-computed-style.ts}

@@ -1,10 +1,12 @@
 import { assertIsDefined } from '../utils/assert-is-defined';
 
 /**
- * @param {Element} element
- * @return {ReturnType<Window['getComputedStyle']>} The computed style for the element.
+ * @param element
+ * @return The computed style for the element.
  */
-export default function getComputedStyle( element ) {
+export default function getComputedStyle(
+	element: Element
+): CSSStyleDeclaration {
 	assertIsDefined(
 		element.ownerDocument.defaultView,
 		'element.ownerDocument.defaultView'

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}

@@ -12,13 +12,17 @@ import { scrollIfNoRange } from './scroll-if-no-range';
  * 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'

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';
 }