suneditor 3.0.0-alpha.2 → 3.0.0-alpha.20

package/types/helper/dom/domCheck.d.ts

@@ -0,0 +1,182 @@
+/**
+ * @description A method that checks If the text is blank or to see if it contains 'ZERO WIDTH SPACE' or empty (unicode.zeroWidthSpace)
+ * @param {string|Node} text String value or Node
+ * @returns {boolean}
+ */
+export function isZeroWidth(text: string | Node): boolean;
+/**
+ * @description Determine if this offset is the edge offset of container
+ * @param {Node} container The node of the selection object. (range.startContainer..)
+ * @param {number} offset The offset of the selection object. (core.getRange().startOffset...)
+ * @param {?"front"|"end"=} dir Select check point - Both edge, Front edge or End edge. ("front": Front edge, "end": End edge, undefined: Both edge)
+ * @returns {boolean}
+ */
+export function isEdgePoint(container: Node, offset: number, dir?: (('front' | 'end') | null) | undefined): boolean;
+/**
+ * @description Check the node is a text node.
+ * @param {?Node} node The node to check
+ * @returns {node is Text}
+ */
+export function isText(node: Node | null): node is Text;
+/**
+ * @description Check the node is an HTMLElement node.
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isElement(node: Node | null): node is HTMLElement;
+/**
+ * @description It is judged whether it is the input element (INPUT, TEXTAREA)
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLInputElement}
+ */
+export function isInputElement(node: Node | null): node is HTMLInputElement;
+/**
+ * @description It is judged whether it is the button element
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLButtonElement}
+ */
+export function isButtonElement(node: Node | null): node is HTMLButtonElement;
+/**
+ * @description Check the node is a list (ol, ul)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLOListElement|HTMLUListElement}
+ */
+export function isList(node: (Node | string) | null): node is HTMLOListElement | HTMLUListElement;
+/**
+ * @description Check the node is a list cell (li)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLLIElement}
+ */
+export function isListCell(node: (Node | string) | null): node is HTMLLIElement;
+/**
+ * @description Check the node is a table
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableElement}
+ */
+export function isTable(node: (Node | string) | null): node is HTMLTableElement;
+/**
+ * @description Check the node is a table elements. (table, thead, tbody, tr, th, td)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableElement|HTMLTableSectionElement|HTMLTableRowElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableColElement}
+ */
+export function isTableElements(node: (Node | string) | null): node is HTMLTableElement | HTMLTableSectionElement | HTMLTableRowElement | HTMLTableCellElement | HTMLTableColElement | HTMLTableColElement;
+/**
+ * @description Check the node is a table cell (td, th)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableCellElement|HTMLTableColElement}
+ */
+export function isTableCell(node: (Node | string) | null): node is HTMLTableCellElement | HTMLTableColElement;
+/**
+ * @description Check the node is a table row (tr)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLTableRowElement}
+ */
+export function isTableRow(node: (Node | string) | null): node is HTMLTableRowElement;
+/**
+ * @description Check the node is a break node (BR)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLBRElement}
+ */
+export function isBreak(node: (Node | string) | null): node is HTMLBRElement;
+/**
+ * @description Check the node is a anchor node (A)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLAnchorElement}
+ */
+export function isAnchor(node: (Node | string) | null): node is HTMLAnchorElement;
+/**
+ * @description Check the node is a media node (img, iframe, audio, video, canvas)
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLImageElement|HTMLIFrameElement|HTMLAudioElement|HTMLVideoElement|HTMLCanvasElement}
+ */
+export function isMedia(node: (Node | string) | null): node is HTMLImageElement | HTMLIFrameElement | HTMLAudioElement | HTMLVideoElement | HTMLCanvasElement;
+/**
+ * @description Check the node is a iframe tag
+ * @param {?Node|string} node The element or element name to check
+ * @returns {node is HTMLIFrameElement}
+ */
+export function isIFrame(node: (Node | string) | null): node is HTMLIFrameElement;
+/**
+ * @description Check the node is a figure tag
+ * @param {?Node|string} node The element or element name to check
+ * @returns {boolean}
+ */
+export function isFigure(node: (Node | string) | null): boolean;
+/**
+ * @description Check the line element is empty.
+ * @param {Node} node "line" element node
+ * @returns {boolean}
+ */
+export function isEmptyLine(node: Node): boolean;
+/**
+ * @description It is judged whether it is the edit region top div element or iframe's body tag.
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isWysiwygFrame(node: Node | null): node is HTMLElement;
+/**
+ * @description It is judged whether it is the contenteditable property is false.
+ * @param {?Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isNonEditable(node: Node | null): node is HTMLElement;
+/**
+ * @description Check the span's attributes are empty.
+ * @param {?Node} node Element node
+ * @returns {boolean}
+ */
+export function isSpanWithoutAttr(node: Node | null): boolean;
+/**
+ * @description Compares the style and class for equal values.
+ * @param {Node} a Node to compare
+ * @param {Node} b Node to compare
+ * @returns {boolean} Returns true if both are text nodes.
+ */
+export function isSameAttributes(a: Node, b: Node): boolean;
+/**
+ * @description It is judged whether it is the not checking node. (class="katex", "MathJax", "se-exclude-format")
+ * @param {Node} node The node to check
+ * @returns {node is HTMLElement}
+ */
+export function isExcludeFormat(node: Node): node is HTMLElement;
+/**
+ * @description Checks for "__se__uneditable" in the class list.
+ * - Components with class "__se__uneditable" cannot be modified.
+ * @param {Node} node The element to check
+ * @returns {boolean}
+ */
+export function isUneditable(node: Node): boolean;
+/**
+ * @description Checks if element can't be easily enabled
+ * @param {Node} node Element to check for
+ * @returns {boolean}
+ */
+export function isImportantDisabled(node: Node): boolean;
+export default check;
+declare namespace check {
+	export { isZeroWidth };
+	export { isEdgePoint };
+	export { isText };
+	export { isElement };
+	export { isInputElement };
+	export { isButtonElement };
+	export { isList };
+	export { isListCell };
+	export { isTable };
+	export { isTableElements };
+	export { isTableCell };
+	export { isTableRow };
+	export { isBreak };
+	export { isAnchor };
+	export { isMedia };
+	export { isIFrame };
+	export { isFigure };
+	export { isEmptyLine };
+	export { isWysiwygFrame };
+	export { isNonEditable };
+	export { isSpanWithoutAttr };
+	export { isSameAttributes };
+	export { isExcludeFormat };
+	export { isUneditable };
+	export { isImportantDisabled };
+}

package/types/helper/dom/domQuery.d.ts

@@ -0,0 +1,214 @@
+/**
+ * @description Returns the index compared to other sibling nodes.
+ * @param {Node} node The Node to find index
+ * @returns {number}
+ */
+export function getPositionIndex(node: Node): number;
+/**
+ * @description Returns the position of the "node" in the "parentNode" in a numerical array.
+ * - e.g.) <p><span>aa</span><span>bb</span></p> : getNodePath(node: "bb", parentNode: "<P>") -> [1, 0]
+ * @param {Node} node The Node to find position path
+ * @param {?Node} parentNode Parent node. If null, wysiwyg div area
+ * @param {?{s: number, e: number}=} _newOffsets If you send an object of the form "{s: 0, e: 0}", the text nodes that are attached together are merged into one, centered on the "node" argument.
+ * "_newOffsets.s" stores the length of the combined characters after "node" and "_newOffsets.e" stores the length of the combined characters before "node".
+ * Do not use unless absolutely necessary.
+ * @returns {Array<number>}
+ */
+export function getNodePath(
+	node: Node,
+	parentNode: Node | null,
+	_newOffsets?:
+		| ({
+				s: number;
+				e: number;
+		  } | null)
+		| undefined
+): Array<number>;
+/**
+ * @template {Node} T
+ * @description Returns the node in the location of the path array obtained from "helper.dom.getNodePath".
+ * @param {Array<number>} offsets Position array, array obtained from "helper.dom.getNodePath"
+ * @param {Node} parentNode Base parent element
+ * @returns {T}
+ */
+export function getNodeFromPath<T extends Node>(offsets: Array<number>, parentNode: Node): T;
+/**
+ * @template {HTMLElement} T
+ * @description Get all "children" of the argument value element (Without text nodes)
+ * @param {Node} element element to get child node
+ * @param {?(current: *) => boolean} validation Conditional function
+ * @returns {Array<T>}
+ */
+export function getListChildren<T extends HTMLElement>(element: Node, validation: ((current: any) => boolean) | null): Array<T>;
+/**
+ * @template {Node} T
+ * @description Get all "childNodes" of the argument value element (Include text nodes)
+ * @param {Node} element element to get child node
+ * @param {?(current: *) => boolean} validation Conditional function
+ * @returns {Array<T>}
+ */
+export function getListChildNodes<T extends Node>(element: Node, validation: ((current: any) => boolean) | null): Array<T>;
+/**
+ * @description Returns the number of parents nodes.
+ * - "0" when the parent node is the WYSIWYG area.
+ * - '-1' when the element argument is the WYSIWYG area.
+ * @param {Node} node The element to check
+ * @returns {number}
+ */
+export function getNodeDepth(node: Node): number;
+/**
+ * @description Sort a node array by depth of element.
+ * @param {Array<Node>} array Node array
+ * @param {boolean} des true: descending order / false: ascending order
+ */
+export function sortNodeByDepth(array: Array<Node>, des: boolean): void;
+/**
+ * @description Compares two elements to find a common ancestor, and returns the order of the two elements.
+ * @param {Node} a Node to compare.
+ * @param {Node} b Node to compare.
+ * @returns {{ancestor: HTMLElement|null, a: Node, b: Node, result: number}} { ancesstor, a, b, result: (a > b ? 1 : a < b ? -1 : 0) };
+ */
+export function compareElements(
+	a: Node,
+	b: Node
+): {
+	ancestor: HTMLElement | null;
+	a: Node;
+	b: Node;
+	result: number;
+};
+/**
+ * @template {HTMLElement} T
+ * @description Get the parent element of the argument value.
+ * - A tag that satisfies the query condition is imported.
+ * @param {Node} element Reference element
+ * @param {string|((current: *) => boolean)|Node} query Query String (nodeName, .className, #ID, :name) or validation function.
+ * - Not use it like jquery.
+ * - Only one condition can be entered at a time.
+ * @param {?number=} depth Number of parent levels to depth.
+ * @returns {T|null} Not found: null
+ */
+export function getParentElement<T extends HTMLElement>(element: Node, query: string | ((current: any) => boolean) | Node, depth?: (number | null) | undefined): T | null;
+/**
+ * @template {HTMLElement} T
+ * @description Gets all ancestors of the argument value.
+ * - Get all tags that satisfy the query condition.
+ * @param {Node} element Reference element
+ * @param {string|((current: *) => boolean)|Node} query Query String (nodeName, .className, #ID, :name) or validation function.
+ * Not use it like jquery.
+ * Only one condition can be entered at a time.
+ * @param {?number=} depth Number of parent levels to depth.
+ * @returns {Array<T>} Returned in an array in order.
+ */
+export function getParentElements<T extends HTMLElement>(element: Node, query: string | ((current: any) => boolean) | Node, depth?: (number | null) | undefined): Array<T>;
+/**
+ * @template {HTMLElement} T
+ * @description Gets the element with "data-command" attribute among the parent elements.
+ * @param {Node} target Target element
+ * @returns {T|null}
+ */
+export function getCommandTarget<T extends HTMLElement>(target: Node): T | null;
+/**
+ * @template {HTMLElement} T
+ * @description Get the event.target element.
+ * @param {Event} event Event object
+ * @returns {T|null}
+ */
+export function getEventTarget<T extends HTMLElement>(event: Event): T | null;
+/**
+ * @template {Node} T
+ * @description Get the child element of the argument value.
+ * - A tag that satisfies the query condition is imported.
+ * @param {Node} node Reference element
+ * @param {string|((current: *) => boolean)|Node} query Query String (nodeName, .className, #ID, :name) or validation function.
+ * @param {boolean} last If true returns the last node among the found child nodes. (default: first node)
+ * Not use it like jquery.
+ * Only one condition can be entered at a time.
+ * @returns {T|null} Not found: null
+ */
+export function getEdgeChild<T extends Node>(node: Node, query: string | ((current: any) => boolean) | Node, last: boolean): T | null;
+/**
+ * @description Get edge child nodes of the argument value.
+ * - 1. The first node of all the child nodes of the "first" element is returned.
+ * - 2. The last node of all the child nodes of the "last" element is returned.
+ * - 3. When there is no "last" element, the first and last nodes of all the children of the "first" element are returned.
+ * @param {Node} first First element
+ * @param {Node|null} last Last element
+ * @returns {{sc: Node, ec: Node}} { sc: "first", ec: "last" }
+ */
+export function getEdgeChildNodes(
+	first: Node,
+	last: Node | null
+): {
+	sc: Node;
+	ec: Node;
+};
+/**
+ * @template {Node} T
+ * @description Gets the previous sibling last child. If there is no sibling, then it'll take it from the closest ancestor with child
+ * @param {Node} node Reference element
+ * @param {?Node=} ceiling Highest boundary allowed
+ * @returns {T|null} Not found: null
+ */
+export function getPreviousDeepestNode<T extends Node>(node: Node, ceiling?: (Node | null) | undefined): T | null;
+/**
+ * @template {Node} T
+ * @description Gets the next sibling first child. If there is no sibling, then it'll take it from the closest ancestor with child
+ * @param {Node} node Reference element
+ * @param {?Node=} ceiling Highest boundary allowed
+ * @returns {T|null} Not found: null
+ */
+export function getNextDeepestNode<T extends Node>(node: Node, ceiling?: (Node | null) | undefined): T | null;
+/**
+ * @description Find the index of the text node in the line element.
+ * @param {Node} line Line element (p, div, etc.)
+ * @param {Node} offsetContainer Base node to start searching
+ * @param {number} offset Base offset to start searching
+ * @param {?(current: *) => boolean=} validate Validation function
+ * @returns {number}
+ */
+export function findTextIndexOnLine(line: Node, offsetContainer: Node, offset: number, validate?: (((current: any) => boolean) | null) | undefined): number;
+/**
+ * @description Find the end index of a sequence of at least minTabSize consecutive non-breaking spaces or spaces
+ * - which are interpreted as a tab key, occurring after a given base index in a text string.
+ * @param {Node} line Line element (p, div, etc.)
+ * @param {number} baseIndex Base index to start searching
+ * @param {number} minTabSize Minimum number of consecutive spaces to consider as a tab
+ * @returns {number} The adjusted index within the line element accounting for non-space characters
+ */
+export function findTabEndIndex(line: Node, baseIndex: number, minTabSize: number): number;
+/**
+ * @description Get nearest scrollable parent
+ * @param {Node} element Element
+ * @returns {HTMLElement|null}
+ */
+export function getScrollParent(element: Node): HTMLElement | null;
+/**
+ * @description Get the argument iframe's document object if use the "iframe" or "fullPage" options
+ * @param {HTMLIFrameElement} iframe Iframe element (this.editor.frameContext.get('wysiwygFrame'))
+ * @returns {Document}
+ */
+export function getIframeDocument(iframe: HTMLIFrameElement): Document;
+export default query;
+declare namespace query {
+	export { getPositionIndex };
+	export { getNodePath };
+	export { getNodeFromPath };
+	export { getListChildren };
+	export { getListChildNodes };
+	export { getNodeDepth };
+	export { sortNodeByDepth };
+	export { compareElements };
+	export { getParentElement };
+	export { getParentElements };
+	export { getCommandTarget };
+	export { getEventTarget };
+	export { getEdgeChild };
+	export { getEdgeChildNodes };
+	export { getPreviousDeepestNode };
+	export { getNextDeepestNode };
+	export { findTextIndexOnLine };
+	export { findTabEndIndex };
+	export { getScrollParent };
+	export { getIframeDocument };
+}

package/types/helper/dom/domUtils.d.ts

@@ -0,0 +1,211 @@
+/**
+ * @template {HTMLElement} T
+ * @description Create Element node
+ * @param {string} elementName Element name
+ * @param {?Object<string, string>=} attributes The attributes of the tag. {style: 'font-size:12px;..', class: 'el_class',..}
+ * @param {?string|Node=} inner A innerHTML string or inner node.
+ * @returns {T}
+ */
+export function createElement<T extends HTMLElement>(
+	elementName: string,
+	attributes?:
+		| ({
+				[x: string]: string;
+		  } | null)
+		| undefined,
+	inner?: ((string | Node) | null) | undefined
+): T;
+/**
+ * @description Create text node
+ * @param {string} text text content
+ * @returns {Text}
+ */
+export function createTextNode(text: string): Text;
+/**
+ * @description Get attributes of argument element to string ('class="---" name="---" ')
+ * @param {Node} element Element object
+ * @param {Array<string>|null} exceptAttrs Array of attribute names to exclude from the result
+ * @returns {string}
+ */
+export function getAttributesToString(element: Node, exceptAttrs: Array<string> | null): string;
+/**
+ * @description Get the items array from the array that matches the condition.
+ * @param {__se__NodeCollection} array Array to get item
+ * @param {?(current: *) => boolean} validation Conditional function
+ * @returns {Array<Node>|null}
+ */
+export function arrayFilter(array: __se__NodeCollection, validation: ((current: any) => boolean) | null): Array<Node> | null;
+/**
+ * @description Get the item from the array that matches the condition.
+ * @param {__se__NodeCollection} array Array to get item
+ * @param {?(current: *) => boolean} validation Conditional function
+ * @returns {Node|null}
+ */
+export function arrayFind(array: __se__NodeCollection, validation: ((current: any) => boolean) | null): Node | null;
+/**
+ * @description Check if an array contains an element
+ * @param {__se__NodeCollection} array element array
+ * @param {Node} node The node to check for
+ * @returns {boolean}
+ */
+export function arrayIncludes(array: __se__NodeCollection, node: Node): boolean;
+/**
+ * @description Get the index of the argument value in the element array
+ * @param {__se__NodeCollection} array element array
+ * @param {Node} node The element to find index
+ * @returns {number}
+ */
+export function getArrayIndex(array: __se__NodeCollection, node: Node): number;
+/**
+ * @description Get the next index of the argument value in the element array
+ * @param {__se__NodeCollection} array element array
+ * @param {Node} item The element to find index
+ * @returns {number}
+ */
+export function nextIndex(array: __se__NodeCollection, item: Node): number;
+/**
+ * @description Get the previous index of the argument value in the element array
+ * @param {__se__NodeCollection} array Element array
+ * @param {Node} item The element to find index
+ * @returns {number}
+ */
+export function prevIndex(array: __se__NodeCollection, item: Node): number;
+/**
+ * @description Add style and className of copyEl to originEl
+ * @param {Node} originEl Origin element
+ * @param {Node} copyEl Element to copy
+ * @param {?Array<string>=} blacklist Blacklist array(LowerCase)
+ */
+export function copyTagAttributes(originEl: Node, copyEl: Node, blacklist?: (Array<string> | null) | undefined): void;
+/**
+ * @description Copy and apply attributes of format tag that should be maintained. (style, class) Ignore "__se__format__" class
+ * @param {Node} originEl Origin element
+ * @param {Node} copyEl Element to copy
+ */
+export function copyFormatAttributes(originEl: Node, copyEl: Node): void;
+/**
+ * @description Delete argumenu value element
+ * @param {Node} item Node to be remove
+ */
+export function removeItem(item: Node): void;
+/**
+ * @description Replace element
+ * @param {Node} element Target element
+ * @param {string|Node} newElement String or element of the new element to apply
+ */
+export function changeElement(element: Node, newElement: string | Node): void;
+/**
+ * @description Set the text content value of the argument value element
+ * @param {Node} node Element to replace text content
+ * @param {string} txt Text to be applied
+ */
+export function changeTxt(node: Node, txt: string): void;
+/**
+ * @description Set style, if all styles are deleted, the style properties are deleted.
+ * @param {Node|Node[]} elements Element to set style
+ * @param {string} styleName Style attribute name (marginLeft, textAlign...)
+ * @param {string|number} value Style value
+ */
+export function setStyle(elements: Node | Node[], styleName: string, value: string | number): void;
+/**
+ * @description In the predefined code view mode, the buttons except the executable button are changed to the 'disabled' state.
+ * @param {Array<HTMLButtonElement|HTMLInputElement>} buttonList (Button | Input) Element array
+ * @param {boolean} disabled Disabled value
+ * @param {boolean} [important=false] If priveleged mode should be used (Necessary to switch importantDisabled buttons)
+ */
+export function setDisabled(buttonList: Array<HTMLButtonElement | HTMLInputElement>, disabled: boolean, important?: boolean): void;
+/**
+ * @description Determine whether any of the matched elements are assigned the given class
+ * @param {?Node} element Elements to search class name
+ * @param {string} className Class name to search for
+ * @returns {boolean}
+ */
+export function hasClass(element: Node | null, className: string): boolean;
+/**
+ * @description Append the className value of the argument value element
+ * @param {Node|__se__NodeCollection} element Elements to add class name
+ * @param {string} className Class name to be add
+ */
+export function addClass(element: Node | __se__NodeCollection, className: string): void;
+/**
+ * @description Delete the className value of the argument value element
+ * @param {Node|__se__NodeCollection} element Elements to remove class name
+ * @param {string} className Class name to be remove
+ */
+export function removeClass(element: Node | __se__NodeCollection, className: string): void;
+/**
+ * @description Argument value If there is no class name, insert it and delete the class name if it exists
+ * @param {Node} element Element to replace class name
+ * @param {string} className Class name to be change
+ * @returns {boolean|undefined}
+ */
+export function toggleClass(element: Node, className: string): boolean | undefined;
+/**
+ * @description Gets the size of the documentElement client size.
+ * @param {Document} doc Document object
+ * @returns {{w: number, h: number}} documentElement.clientWidth, documentElement.clientHeight
+ */
+export function getClientSize(doc?: Document): {
+	w: number;
+	h: number;
+};
+/**
+ * @description Gets the size of the window visualViewport size
+ * @returns {{top: number, left: number, scale: number}}
+ */
+export function getViewportSize(): {
+	top: number;
+	left: number;
+	scale: number;
+};
+/**
+ * @description Copies the "wwTarget" element and returns it with inline all styles applied.
+ * @param {Node} wwTarget Target element to copy(.sun-editor.sun-editor-editable)
+ * @param {boolean} includeWW Include the "wwTarget" element in the copy
+ * @param {Array<string>} styles Style list - kamel case
+ * @returns
+ */
+export function applyInlineStylesAll(wwTarget: Node, includeWW: boolean, styles: Array<string>): HTMLElement;
+export default utils;
+declare namespace utils {
+	export { clone };
+	export { createElement };
+	export { createTextNode };
+	export { getAttributesToString };
+	export { arrayFilter };
+	export { arrayFind };
+	export { arrayIncludes };
+	export { getArrayIndex };
+	export { nextIndex };
+	export { prevIndex };
+	export { copyTagAttributes };
+	export { copyFormatAttributes };
+	export { removeItem };
+	export { changeElement };
+	export { changeTxt };
+	export { setStyle };
+	export { setDisabled };
+	export { hasClass };
+	export { addClass };
+	export { removeClass };
+	export { toggleClass };
+	export { getClientSize };
+	export { getViewportSize };
+	export { applyInlineStylesAll };
+	export { waitForMediaLoad };
+}
+/**
+ * @template {Node} T
+ * @description Clones a node while preserving its type.
+ * @param {T} node - The node to clone.
+ * @param {boolean} [deep=false] - Whether to perform a deep clone.
+ * @returns {T} - The cloned node.
+ */
+declare function clone<T extends Node>(node: T, deep?: boolean): T;
+/**
+ * @description Wait for media elements to load
+ * @param {Node} target Target element
+ * @param {number} timeout Timeout milliseconds
+ * @returns {Promise<void>}
+ */
+declare function waitForMediaLoad(target: Node, timeout?: number): Promise<void>;

package/types/helper/dom/index.d.ts

@@ -0,0 +1,9 @@
+export default dom;
+declare namespace dom {
+	export { query };
+	export { check };
+	export { utils };
+}
+import query from './domQuery';
+import check from './domCheck';
+import utils from './domUtils';