suneditor 3.0.0-alpha.9 → 3.0.0-beta.2

package/types/helper/clipboard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description Write the content to the clipboard
+ * - Iframe is replaced with a placeholder : <div data-se-iframe-holder-src="iframe.src">[iframe: iframe.src]</div>
+ * - "iframe placeholder" is re-rendered in html.clean when pasted into the editor.
+ * @param {Element|Text|string} content Content to be copied to the clipboard
+ * @returns {Promise<void>}
+ */
+export function write(content: Element | Text | string): Promise<void>;
+declare namespace _default {
+	export { write };
+}
+export default _default;

package/types/helper/converter.d.ts

@@ -0,0 +1,197 @@
+/**
+ * @description Parses an HTML string into a DOM tree, then recursively traverses the nodes to convert them into a structured JSON representation.
+ * -Each element includes its tag name, attributes, and children.
+ * -Text nodes are represented as { type: 'text', content: '...' }.
+ * @param {string} content HTML string
+ * @returns {Object<string, *>} JSON data
+ */
+export function htmlToJson(content: string): {
+	[x: string]: any;
+};
+/**
+ * @description Takes a JSON structure representing HTML elements and recursively serializes it into a valid HTML string.
+ * -It rebuilds each tag with attributes and inner content.
+ * Text content and attributes are safely escaped to prevent parsing issues or XSS.
+ * Useful for restoring dynamic HTML from a data format.
+ * @param {Object<string, *>} jsonData
+ * @returns {string} HTML string
+ */
+export function jsonToHtml(jsonData: { [x: string]: any }): string;
+/**
+ * @description Convert HTML string to HTML Entity
+ * @param {string} content
+ * @returns {string} Content string
+ * @private
+ */
+export function htmlToEntity(content: string): string;
+/**
+ * @description Convert HTML Entity to HTML string
+ * @param {string} content Content string
+ * @returns {string}
+ */
+export function entityToHTML(content: string): string;
+/**
+ * @description Debounce function
+ * @param {(...args: *) => void} func function
+ * @param {number} wait delay ms
+ * @returns {*} executedFunction
+ */
+export function debounce(func: (...args: any) => void, wait: number): any;
+/**
+ * @description Synchronizes two Map objects by updating the first Map with the values from the second,
+ * - and deleting any keys in the first Map that are not present in the second.
+ * @param {Map<*, *>} targetMap The Map to update (target).
+ * @param {Map<*, *>} referenceMap The Map providing the reference values (source).
+ */
+export function syncMaps(targetMap: Map<any, any>, referenceMap: Map<any, any>): void;
+/**
+ * @description Object.values
+ * @param {Object<*, *>} obj Object parameter.
+ * @returns {Array<*>}
+ */
+export function getValues(obj: any): Array<any>;
+/**
+ * @description Convert the CamelCase To the KebabCase.
+ * @param {string|Array<string>} param [Camel string]
+ */
+export function camelToKebabCase(param: string | Array<string>): any;
+/**
+ * @overload
+ * @param {string} param - Kebab-case string.
+ * @returns {string} CamelCase string.
+ */
+export function kebabToCamelCase(param: string): string;
+/**
+ * @overload
+ * @param {Array<string>} param - Array of Kebab-case strings.
+ * @returns {Array<string>} Array of CamelCase strings.
+ */
+export function kebabToCamelCase(param: Array<string>): Array<string>;
+/**
+ *
+ * @param {"em"|"rem"|"%"|"pt"|"px"} to Size units to be converted
+ * @param {string} size siSize to convert with units (ex: "15rem")
+ * @returns {string}
+ */
+export function toFontUnit(to: 'em' | 'rem' | '%' | 'pt' | 'px', size: string): string;
+/**
+ * @description Convert the node list to an array. If not, returns an empty array.
+ * @param {?__se__NodeCollection} nodeList
+ * @returns Array
+ */
+export function nodeListToArray(nodeList: __se__NodeCollection | null): any;
+/**
+ * @description Returns a new object with keys and values swapped.
+ * @param {Object<*, *>} obj object
+ * @returns {Object<*, *>}
+ */
+export function swapKeyValue(obj: any): any;
+/**
+ * @description Create whitelist RegExp object.
+ * @param {string} list Tags list ("br|p|div|pre...")
+ * @returns {RegExp} Return RegExp format: new RegExp("<\\/?\\b(?!" + list + ")\\b[^>^<]*+>", "gi")
+ */
+export function createElementWhitelist(list: string): RegExp;
+/**
+ * @description Create blacklist RegExp object.
+ * @param {string} list Tags list ("br|p|div|pre...")
+ * @returns {RegExp} Return RegExp format: new RegExp("<\\/?\\b(?:" + list + ")\\b[^>^<]*+>", "gi")
+ */
+export function createElementBlacklist(list: string): RegExp;
+/**
+ * @description Function to check hex format color
+ * @param {string} str Color value
+ */
+export function isHexColor(str: string): boolean;
+/**
+ * @description Function to convert hex format to a rgb color
+ * @param {string} rgba RGBA color format
+ * @returns {string}
+ */
+export function rgb2hex(rgba: string): string;
+/**
+ * @description Computes the width as a percentage of the parent's width, and returns this value rounded to two decimal places.
+ * @param {HTMLElement} target The target element for which to calculate the width percentage.
+ * @param {?HTMLElement=} parentTarget The parent element to use as the reference for the width calculation. If not provided, the target's parent element is used.
+ * @returns {number}
+ */
+export function getWidthInPercentage(target: HTMLElement, parentTarget?: (HTMLElement | null) | undefined): number;
+/**
+ * @description Convert url pattern text node to anchor node
+ * @param {Node} node Text node
+ * @returns {boolean} Return true if the text node is converted to an anchor node
+ */
+export function textToAnchor(node: Node): boolean;
+/**
+ * Converts styles within a <span> tag to corresponding HTML tags (e.g., <strong>, <em>, <u>, <s>).
+ * Maintains the original <span> tag and wraps its content with the new tags.
+ * @param {{ regex: RegExp, tag: string }} styleToTag An object mapping style properties to HTML tags. ex) {bold: { regex: /font-weight\s*:\s*bold/i, tag: 'strong' },}
+ * @param {Node} node Node
+ */
+export function spanToStyleNode(
+	styleToTag: {
+		regex: RegExp;
+		tag: string;
+	},
+	node: Node
+): void;
+/**
+ * Adds a query string to a URL. If the URL already contains a query string, the new query is appended to the existing one.
+ * @param {string} url The original URL to which the query string will be added.
+ * @param {string} query The query string to be added to the URL.
+ * @returns {string} The updated URL with the query string appended.
+ */
+export function addUrlQuery(url: string, query: string): string;
+/**
+ * @description Converts options-related styles and returns them for each frame.
+ * @param {Map<string, *>} fo editor.frameOptions
+ * @param {string} cssText Style string
+ * @returns {{top: string, frame: string, editor: string}}
+ * @private
+ */
+export function _setDefaultOptionStyle(
+	fo: Map<string, any>,
+	cssText: string
+): {
+	top: string;
+	frame: string;
+	editor: string;
+};
+/**
+ * @description Set default style tag of the iframe
+ * @param {Array<string>} linkNames link names array of CSS files
+ * @returns {string} "<link rel="stylesheet" href=".." />.."
+ */
+export function _setIframeStyleLinks(linkNames: Array<string>): string;
+/**
+ * @description When iframe height options is "auto" return "<style>" tag that required.
+ * @param {string} frameHeight height
+ * @returns {string} "<style>...</style>"
+ */
+export function _setAutoHeightStyle(frameHeight: string): string;
+export default converter;
+declare namespace converter {
+	export { htmlToJson };
+	export { jsonToHtml };
+	export { htmlToEntity };
+	export { entityToHTML };
+	export { debounce };
+	export { syncMaps };
+	export { getValues };
+	export { camelToKebabCase };
+	export { kebabToCamelCase };
+	export { toFontUnit };
+	export { nodeListToArray };
+	export { swapKeyValue };
+	export { createElementWhitelist };
+	export { createElementBlacklist };
+	export { isHexColor };
+	export { rgb2hex };
+	export { getWidthInPercentage };
+	export { textToAnchor };
+	export { spanToStyleNode };
+	export { addUrlQuery };
+	export { _setDefaultOptionStyle };
+	export { _setIframeStyleLinks };
+	export { _setAutoHeightStyle };
+}

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

@@ -0,0 +1,189 @@
+/**
+ * @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 Checks whether the given node is a content-less (void) HTML tag
+ * @param {?Node|string} node The element or element name to check
+ * @returns {boolean}
+ */
+export function isContentLess(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 { isContentLess };
+	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,223 @@
+/**
+ * @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 Finds the table cell that appears visually at the bottom-right position,
+ * considering both rowSpan and colSpan, even if smaller cells are placed after large merged cells.
+ *
+ * @param {HTMLTableCellElement[]} cells
+ * @returns {HTMLTableCellElement|null}
+ */
+export function findVisualLastCell(cells: HTMLTableCellElement[]): HTMLTableCellElement | null;
+/**
+ * @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 { findVisualLastCell };
+	export { getScrollParent };
+	export { getIframeDocument };
+}