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

package/types/core/logic/dom/html.d.ts

@@ -0,0 +1,290 @@
+import type {} from '../../../typedef';
+export default HTML;
+/**
+ * @description All HTML related classes involved in the editing area
+ */
+declare class HTML {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Filters an HTML string based on allowed and disallowed tags, with optional custom validation.
+	 * - Removes blacklisted tags and keeps only whitelisted tags.
+	 * - Allows custom validation functions to replace, modify, or remove elements.
+	 * @param {string} html - The HTML string to be filtered.
+	 * @param {Object} params - Filtering parameters.
+	 * @param {string} [params.tagWhitelist] - Allowed tags, specified as a string with tags separated by `'|'`. (e.g. `"div|p|span"`).
+	 * @param {string} [params.tagBlacklist] - Disallowed tags, specified as a string with tags separated by `'|'`. (e.g. `"script|iframe"`).
+	 * @param {(node: Node) => Node | string | null} [params.validate] - Function to validate and modify individual nodes.
+	 *   - Return `null` to remove the node.
+	 *   - Return a `Node` to replace the current node.
+	 *   - Return a `string` to replace the node's `outerHTML`.
+	 * @param {boolean} [params.validateAll] - Whether to apply validation to all nodes.
+	 * @returns {string} - The filtered HTML string.
+	 * @example
+	 * // Remove script and iframe tags using blacklist
+	 * const filtered = editor.html.filter('<div>Content<script>alert("xss")</script></div>', {
+	 *   tagBlacklist: 'script|iframe'
+	 * });
+	 *
+	 * // Keep only specific tags using whitelist
+	 * const filtered = editor.html.filter('<div><span>Text</span><img src="x"></div>', {
+	 *   tagWhitelist: 'div|span'
+	 * });
+	 *
+	 * // Custom validation to modify nodes
+	 * const filtered = editor.html.filter('<div class="test"><a href="#">Link</a></div>', {
+	 *   validate: (node) => {
+	 *     if (node.tagName === 'A') {
+	 *       node.setAttribute('target', '_blank');
+	 *       return node;
+	 *     }
+	 *   }
+	 * });
+	 */
+	filter(
+		html: string,
+		{
+			tagWhitelist,
+			tagBlacklist,
+			validate,
+			validateAll,
+		}: {
+			tagWhitelist?: string;
+			tagBlacklist?: string;
+			validate?: (node: Node) => Node | string | null;
+			validateAll?: boolean;
+		},
+	): string;
+	/**
+	 * @description Cleans and compresses HTML code to suit the editor format.
+	 * @param {string} html HTML string to clean and compress
+	 * @param {Object} [options] Cleaning options
+	 * @param {boolean} [options.forceFormat=false] If `true`, wraps text nodes without a format node in the format tag.
+	 * @param {?(string|RegExp)} [options.whitelist] Regular expression of allowed tags.
+	 * Create RegExp object using `helper.converter.createElementWhitelist` method.
+	 * @param {?(string|RegExp)} [options.blacklist] Regular expression of disallowed tags.
+	 * Create RegExp object using `helper.converter.createElementBlacklist` method.
+	 * @param {boolean} [options._freeCodeViewMode=false] If `true`, the free code view mode is enabled.
+	 * @returns {string} Cleaned and compressed HTML string
+	 * @example
+	 * // Basic cleaning
+	 * const cleaned = editor.html.clean('<div>  <p>Hello</p>  </div>');
+	 *
+	 * // Clean with format wrapping
+	 * const cleaned = editor.html.clean('Plain text content', { forceFormat: true });
+	 *
+	 * // Clean with blacklist to remove specific tags
+	 * const cleaned = editor.html.clean('<div><script>alert(1)</script>Content</div>', {
+	 *   blacklist: 'script|style'
+	 * });
+	 */
+	clean(
+		html: string,
+		{
+			forceFormat,
+			whitelist,
+			blacklist,
+			_freeCodeViewMode,
+		}?: {
+			forceFormat?: boolean;
+			whitelist?: (string | RegExp) | null;
+			blacklist?: (string | RegExp) | null;
+			_freeCodeViewMode?: boolean;
+		},
+	): string;
+	/**
+	 * @description Inserts an (HTML element / HTML string / plain string) at the selection range.
+	 * - If `frameOptions.get('charCounter_max')` is exceeded when `html` is added, `null` is returned without addition.
+	 * @param {Node|string} html HTML Element or HTML string or plain string
+	 * @param {Object} [options] Options
+	 * @param {boolean} [options.selectInserted=false] If `true`, selects the range of the inserted node.
+	 * @param {boolean} [options.skipCharCount=false] If `true`, inserts even if `frameOptions.get('charCounter_max')` is exceeded.
+	 * @param {boolean} [options.skipCleaning=false] If `true`, inserts the HTML string without refining it with `html.clean`.
+	 * @returns {HTMLElement|null} The inserted element or `null` if insertion failed
+	 * @example
+	 * // Insert HTML string at cursor
+	 * editor.html.insert('<strong>Bold text</strong>');
+	 *
+	 * // Insert and select the inserted content
+	 * editor.html.insert('<p>New paragraph</p>', { selectInserted: true });
+	 *
+	 * // Insert raw HTML without cleaning
+	 * editor.html.insert('<div class="custom">Content</div>', { skipCleaning: true });
+	 */
+	insert(
+		html: Node | string,
+		{
+			selectInserted,
+			skipCharCount,
+			skipCleaning,
+		}?: {
+			selectInserted?: boolean;
+			skipCharCount?: boolean;
+			skipCleaning?: boolean;
+		},
+	): HTMLElement | null;
+	/**
+	 * @description Delete selected node and insert argument value node and return.
+	 * - If the `afterNode` exists, it is inserted after the `afterNode`
+	 * - Inserting a text node merges with both text nodes on both sides and returns a new `{ container, startOffset, endOffset }`.
+	 * @param {Node} oNode Node to be inserted
+	 * @param {Object} [options] Options
+	 * @param {Node} [options.afterNode=null] If the node exists, it is inserted after the node
+	 * @param {boolean} [options.skipCharCount=null] If `true`, it will be inserted even if `frameOptions.get('charCounter_max')` is exceeded.
+	 * @returns {Object|Node|null}
+	 * @example
+	 * // Insert node at current selection
+	 * const strongNode = document.createElement('strong');
+	 * strongNode.textContent = 'Bold';
+	 * editor.html.insertNode(strongNode);
+	 *
+	 * // Insert node after a specific element
+	 * const paragraph = editor.html.getNode();
+	 * const newSpan = document.createElement('span');
+	 * editor.html.insertNode(newSpan, { afterNode: paragraph });
+	 *
+	 * // Insert bypassing character count limit
+	 * editor.html.insertNode(largeContentNode, { skipCharCount: true });
+	 */
+	insertNode(
+		oNode: Node,
+		{
+			afterNode,
+			skipCharCount,
+		}?: {
+			afterNode?: Node;
+			skipCharCount?: boolean;
+		},
+	): any | Node | null;
+	/**
+	 * @description Delete the selected range.
+	 * @returns {{container: Node, offset: number, commonCon?: ?Node, prevContainer?: ?Node}}
+	 * - `container`: the last element after deletion
+	 * - `offset`: offset
+	 * - `commonCon`: `commonAncestorContainer`
+	 * - `prevContainer`: `previousElementSibling` of the deleted area
+	 */
+	remove(): {
+		container: Node;
+		offset: number;
+		commonCon?: Node | null;
+		prevContainer?: Node | null;
+	};
+	/**
+	 * @description Gets the current content
+	 * @param {Object} [options] Options
+	 * @param {boolean} [options.withFrame=false] Gets the current content with containing parent `div.sun-editor-editable` (`<div class="sun-editor-editable">{content}</div>`).
+	 * Ignored for `targetOptions.get('iframe_fullPage')` is `true`.
+	 * @param {boolean} [options.includeFullPage=false] Return only the content of the body without headers when the `iframe_fullPage` option is `true`
+	 * @param {number|Array<number>} [options.rootKey=null] Root index
+	 * @returns {string|Object<*, string>}
+	 */
+	get({ withFrame, includeFullPage, rootKey }?: { withFrame?: boolean; includeFullPage?: boolean; rootKey?: number | Array<number> }): string | any;
+	/**
+	 * @description Sets the HTML string to the editor content
+	 * @param {string} html HTML string
+	 * @param {Object} [options] Options
+	 * @param {number|Array<number>} [options.rootKey=null] Root index
+	 */
+	set(
+		html: string,
+		{
+			rootKey,
+		}?: {
+			rootKey?: number | Array<number>;
+		},
+	): void;
+	/**
+	 * @description Add content to the end of content.
+	 * @param {string} html Content to Input
+	 * @param {Object} [options] Options
+	 * @param {number|Array<number>} [options.rootKey=null] Root index
+	 */
+	add(
+		html: string,
+		{
+			rootKey,
+		}?: {
+			rootKey?: number | Array<number>;
+		},
+	): void;
+	/**
+	 * @description Gets the current content to JSON data
+	 * @param {Object} [options] Options
+	 * @param {boolean} [options.withFrame=false] Gets the current content with containing parent `div.sun-editor-editable` (`<div class="sun-editor-editable">{content}</div>`).
+	 * @param {number|Array<number>} [options.rootKey=null] Root index
+	 * @returns {Object<string, *>} JSON data
+	 */
+	getJson({ withFrame, rootKey }?: { withFrame?: boolean; rootKey?: number | Array<number> }): {
+		[x: string]: any;
+	};
+	/**
+	 * @description Sets the JSON data to the editor content
+	 * @param {Object<string, *>} jsdonData HTML string
+	 * @param {Object} [options] Options
+	 * @param {number|Array<number>} [options.rootKey=null] Root index
+	 */
+	setJson(
+		jsdonData: {
+			[x: string]: any;
+		},
+		{
+			rootKey,
+		}?: {
+			rootKey?: number | Array<number>;
+		},
+	): void;
+	/**
+	 * @description Call `clipboard.write` to copy the contents and display a success/failure toast message.
+	 * @param {Node|Element|Text|string} content Content to be copied to the clipboard
+	 * @returns {Promise<boolean>} Success or failure
+	 */
+	copy(content: Node | Element | Text | string): Promise<boolean>;
+	/**
+	 * @description Sets the content of the iframe's head tag and body tag when using the `iframe` or `iframe_fullPage` option.
+	 * @param {{head: string, body: string}} ctx { head: HTML string, body: HTML string}
+	 * @param {Object} [options] Options
+	 * @param {number|Array<number>} [options.rootKey=null] Root index
+	 */
+	setFullPage(
+		ctx: {
+			head: string;
+			body: string;
+		},
+		{
+			rootKey,
+		}?: {
+			rootKey?: number | Array<number>;
+		},
+	): boolean;
+	/**
+	 * @description HTML code compression
+	 * @param {string} html HTML string
+	 * @returns {string} HTML string
+	 */
+	compress(html: string): string;
+	/**
+	 * @internal
+	 * @description construct wysiwyg area element to html string
+	 * @param {Node|string} html WYSIWYG element (this.#frameContext.get('wysiwyg')) or HTML string.
+	 * @param {boolean} comp If `true`, does not line break and indentation of tags.
+	 * @returns {string}
+	 */
+	_convertToCode(html: Node | string, comp: boolean): string;
+	/**
+	 * @internal
+	 * @description Reset autoStyleify options.
+	 * @param {Array.<string>} autoStyleify Styles applied automatically on text input.
+	 * - ex `["bold", "underline", "italic", "strike"]`
+	 */
+	__resetAutoStyleify(autoStyleify: Array<string>): void;
+	/**
+	 * @internal
+	 * @description Destroy the HTML instance and release memory
+	 */
+	_destroy(): void;
+	#private;
+}

package/types/core/logic/dom/inline.d.ts

@@ -0,0 +1,93 @@
+import type {} from '../../../typedef';
+export default Inline;
+export type NodeStyleContainerType = {
+	ancestor?: Node | null;
+	offset?: number | null;
+	container?: Node | null;
+	endContainer?: Node | null;
+};
+/**
+ * @typedef {Object} NodeStyleContainerType
+ * @property {?Node} [ancestor]
+ * @property {?number} [offset]
+ * @property {?Node} [container]
+ * @property {?Node} [endContainer]
+ */
+/**
+ * @description Classes related to editor inline formats such as style node like strong, span, etc.
+ */
+declare class Inline {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Adds, updates, or deletes style nodes from selected text (a, span, strong, etc.).
+	 * - 1. If `styleNode` is provided, a node with the same tags and attributes is added to the selected text.
+	 * - 2. If the same tag already exists, only its attributes are updated.
+	 * - 3. If `styleNode` is `null`, existing nodes are updated or removed without adding new ones.
+	 * - 4. Styles matching those in `stylesToModify` are removed. (Use CSS attribute names, e.g., `background-color`)
+	 * - 5. Classes matching those in `stylesToModify` (prefixed with `"."`) are removed.
+	 * - 6. `stylesToModify` is used to avoid duplicate property values from `styleNode`.
+	 * - 7. Nodes with all styles and classes removed are deleted if they match `styleNode`, are in `nodesToRemove`, or if `styleNode` is `null`.
+	 * - 8. Tags matching names in `nodesToRemove` are deleted regardless of their style and class.
+	 * - 9. If `strictRemove` is `true`, nodes in `nodesToRemove` are only removed if all their styles and classes are removed.
+	 * - 10. The function won't modify nodes if the parent has the same class and style values.
+	 * - However, if `nodesToRemove` has values, it will work and separate text nodes even if there's no node to replace.
+	 * @param {?Node} styleNode The element to be added to the selection. If `null`, only existing nodes are modified or removed.
+	 * @param {Object} [options] Options
+	 * @param {Array<string>} [options.stylesToModify=null] Array of style or class names to check and modify.
+	 *        (e.g., ['font-size'], ['.className'], ['font-family', 'color', '.className'])
+	 * @param {Array<string>} [options.nodesToRemove=null] Array of node names to remove.
+	 *        If empty array or `null` when `styleNode` is `null`, all formats are removed.
+	 *        (e.g., ['span'], ['strong', 'em'])
+	 * @param {boolean} [options.strictRemove=false] If `true`, only removes nodes from `nodesToRemove` if all styles and classes are removed.
+	 * @returns {HTMLElement} The element that was added to or modified in the selection.
+	 * @example
+	 * // Apply bold formatting
+	 * const bold = dom.utils.createElement('STRONG');
+	 * editor.inline.apply(bold);
+	 *
+	 * // Remove specific styles
+	 * editor.inline.apply(null, { stylesToModify: ['font-size'] });
+	 *
+	 * // Remove specific tags
+	 * editor.inline.apply(null, { nodesToRemove: ['span'] });
+	 */
+	apply(
+		styleNode: Node | null,
+		{
+			stylesToModify,
+			nodesToRemove,
+			strictRemove,
+		}?: {
+			stylesToModify?: Array<string>;
+			nodesToRemove?: Array<string>;
+			strictRemove?: boolean;
+		},
+	): HTMLElement;
+	/**
+	 * @description Remove all inline formats (styles and tags) from the currently selected text.
+	 * - This is a convenience method that calls `apply()` with `null` parameters to strip all formatting.
+	 * - Removes all inline style nodes (span, strong, em, a, etc.)
+	 * - Preserves only the plain text content
+	 * - Works on the current selection or collapsed cursor position
+	 */
+	remove(): void;
+	/**
+	 * @internal
+	 * @description Nodes that must remain undetached when changing text nodes (A, Label, Code, Span:font-size)
+	 * @param {Node|string} element Element to check
+	 * @returns {boolean}
+	 */
+	_isNonSplitNode(element: Node | string): boolean;
+	/**
+	 * @internal
+	 * @description Nodes that need to be added without modification when changing text nodes
+	 * @param {Node} element Element to check
+	 * @returns {boolean}
+	 */
+	_isIgnoreNodeChange(element: Node): boolean;
+	#private;
+}

package/types/core/logic/dom/listFormat.d.ts

@@ -0,0 +1,101 @@
+import type {} from '../../../typedef';
+export default ListFormat;
+/**
+ * @description Classes related to editor formats such as `list` (ol, ul, li)
+ * - `list` is a special `line`, `block` format.
+ */
+declare class ListFormat {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Append all selected `line` element to the list and insert.
+	 * @param {string} type List type. (ol | ul):[listStyleType]
+	 * @param {Array<Node>} selectedCells `line` elements or list cells.
+	 * @param {boolean} nested If `true`, indenting existing list cells.
+	 * @example
+	 * // Create ordered list from selected lines
+	 * const lines = editor.format.getLines();
+	 * editor.listFormat.apply('ol', lines, false);
+	 *
+	 * // Create unordered list with custom style
+	 * editor.listFormat.apply('ul:circle', selectedElements, false);
+	 *
+	 * // Indent existing list items
+	 * const listItems = [li1, li2, li3];
+	 * editor.listFormat.apply('ul', listItems, true);
+	 */
+	apply(
+		type: string,
+		selectedCells: Array<Node>,
+		nested: boolean,
+	): {
+		sc: Node;
+		so: number;
+		ec: Node;
+		eo: number;
+	};
+	/**
+	 * @description `selectedCells` array are detached from the list element.
+	 * - The return value is applied when the first and last lines of `selectedFormats` are `LI` respectively.
+	 * @param {Array<Node>} selectedCells Array of [`line`, `li`] elements(LI, P...) to remove.
+	 * @param {boolean} shouldDelete If `true`, It does not just remove the list, it deletes the content.
+	 * @returns {{sc: Node, ec: Node}} Node information after deletion
+	 * - sc: Start container node
+	 * - ec: End container node
+	 */
+	remove(
+		selectedCells: Array<Node>,
+		shouldDelete: boolean,
+	): {
+		sc: Node;
+		ec: Node;
+	};
+	/**
+	 * @description Nest list cells or cancel nested cells.
+	 * @param {Array<HTMLElement>} selectedCells List cells.
+	 * @param {boolean} nested Nested or cancel nested.
+	 * @example
+	 * // Indent list items (increase nesting)
+	 * const selectedItems = [liElement1, liElement2];
+	 * editor.listFormat.applyNested(selectedItems, true);
+	 *
+	 * // Outdent list items (decrease nesting)
+	 * editor.listFormat.applyNested(selectedItems, false);
+	 *
+	 * // Get current list cells and nest them
+	 * const cells = editor.format.getLines().filter(el => el.tagName === 'LI');
+	 * editor.listFormat.applyNested(cells, true);
+	 */
+	applyNested(
+		selectedCells: Array<HTMLElement>,
+		nested: boolean,
+	): {
+		sc: Node;
+		so: number;
+		ec: Node;
+		eo: number;
+	};
+	/**
+	 * @description Detach Nested all nested lists under the `baseNode`.
+	 * - Returns a list with nested removed.
+	 * @param {HTMLElement} baseNode Element on which to base.
+	 * @param {boolean} all If `true`, it also detach all nested lists of a returned list.
+	 * @returns {Node} Result element
+	 * @example
+	 * // Remove first level of nesting
+	 * const listItem = document.querySelector('li');
+	 * editor.listFormat.removeNested(listItem, false);
+	 *
+	 * // Flatten all nested lists completely
+	 * editor.listFormat.removeNested(listItem, true);
+	 *
+	 * // Remove nesting and get result
+	 * const result = editor.listFormat.removeNested(nestedLi, false);
+	 * console.log(result); // parent list element
+	 */
+	removeNested(baseNode: HTMLElement, all: boolean): Node;
+	#private;
+}

package/types/core/logic/dom/nodeTransform.d.ts

@@ -0,0 +1,110 @@
+import type {} from '../../../typedef';
+export default NodeTransform;
+/**
+ * @description Node utility class. split, merge, etc.
+ */
+declare class NodeTransform {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @template {HTMLElement} T
+	 * @description Split all tags based on `baseNode`
+	 * @param {Node} baseNode Element or text node on which to base
+	 * @param {?(number|Node)} offset Text offset of `baseNode` (Only valid when `baseNode` is a text node)
+	 * @param {number} [depth=0] The nesting depth of the element being split. (default: 0)
+	 * @returns {T} The last element of the splited tag.
+	 * @example
+	 * // Split at text offset
+	 * const textNode = editor.selection.getNode();
+	 * const newElement = editor.nodeTransform.split(textNode, 5, 0);
+	 *
+	 * // Split at specific depth to preserve parent structure
+	 * const paragraph = editor.selection.getNode().closest('p');
+	 * editor.nodeTransform.split(textNode, 10, 2);
+	 *
+	 * // Split by node reference
+	 * const splitResult = editor.nodeTransform.split(parentNode, childNode, 1);
+	 */
+	split<T extends HTMLElement>(baseNode: Node, offset: (number | Node) | null, depth?: number): T;
+	/**
+	 * @description Use with `npdePath` (dom-query-GetNodePath) to merge the same attributes and tags if they are present and modify the nodepath.
+	 * - If `offset` has been changed, it will return as much `offset` as it has been modified.
+	 * - An array containing change offsets is returned in the order of the `nodePathArray` array.
+	 * @param {Node} element Element
+	 * @param {?number[][]} [nodePathArray] Array of `NodePath` object ([dom-query-GetNodePath(), ..])
+	 * @param {?boolean} [onlyText] If `true`, non-text nodes like `span`, `strong`.. are ignored.
+	 * @returns {Array<number>} [offset, ..]
+	 * @example
+	 * // Merge adjacent tags with same attributes
+	 * const container = editor.selection.getNode().closest('div');
+	 * editor.nodeTransform.mergeSameTags(container, null, false);
+	 *
+	 * // Merge with path tracking
+	 * const startPath = [0, 1, 2];
+	 * const endPath = [0, 2, 1];
+	 * const offsets = editor.nodeTransform.mergeSameTags(element, [startPath, endPath], false);
+	 *
+	 * // Merge only text nodes
+	 * editor.nodeTransform.mergeSameTags(paragraph, null, true);
+	 */
+	mergeSameTags(element: Node, nodePathArray?: number[][] | null, onlyText?: boolean | null): Array<number>;
+	/**
+	 * @description Remove nested tags without other child nodes.
+	 * @param {Node} element Element object
+	 * @param {?(((current: Node) => boolean)|string)} [validation] Validation function / String(`tag1|tag2..`) / If `null`, all tags are applicable.
+	 */
+	mergeNestedTags(element: Node, validation?: (((current: Node) => boolean) | string) | null): void;
+	/**
+	 * @description Delete itself and all parent nodes that match the condition.
+	 * - Returns an {sc: previousSibling, ec: nextSibling}(the deleted node reference) or `null`.
+	 * @param {Node} item Node to be remove
+	 * @param {?(current: Node) => boolean} [validation] Validation function. default(Deleted if it only have `breakLine` and blanks)
+	 * @param {?Node} [stopParent] Stop when the parent node reaches `stopParent`
+	 * @returns {{sc: Node|null, ec: Node|null}|null} {sc: previousSibling, ec: nextSibling} (the deleted node reference) or `null`.
+	 * @example
+	 * // Remove empty parent elements recursively
+	 * const emptySpan = document.querySelector('span:empty');
+	 * const result = editor.nodeTransform.removeAllParents(emptySpan, null, null);
+	 *
+	 * // Remove with custom validation
+	 * editor.nodeTransform.removeAllParents(node, (current) => {
+	 *   return current.textContent.trim().length === 0;
+	 * }, null);
+	 *
+	 * // Remove up to specific parent
+	 * const stopAt = editor.selection.getNode().closest('.container');
+	 * editor.nodeTransform.removeAllParents(childNode, null, stopAt);
+	 */
+	removeAllParents(
+		item: Node,
+		validation?: ((current: Node) => boolean) | null,
+		stopParent?: Node | null,
+	): {
+		sc: Node | null;
+		ec: Node | null;
+	} | null;
+	/**
+	 * @description Delete a empty child node of argument element
+	 * @param {Node} element Element node
+	 * @param {?Node} notRemoveNode Do not remove node
+	 * @param {boolean} forceDelete When all child nodes are deleted, the parent node is also deleted.
+	 */
+	removeEmptyNode(element: Node, notRemoveNode: Node | null, forceDelete: boolean): void;
+	/**
+	 * @description Creates a nested node structure from the given array of nodes.
+	 * @param {SunEditor.NodeCollection} nodeArray An array of nodes to clone. The first node in the array will be the top-level parent.
+	 * @param {?(current: Node) => boolean} [validate] A validate function.
+	 * @returns {{ parent: Node, inner: Node }} An object containing the top-level parent node and the innermost child node.
+	 */
+	createNestedNode(
+		nodeArray: SunEditor.NodeCollection,
+		validate?: ((current: Node) => boolean) | null,
+	): {
+		parent: Node;
+		inner: Node;
+	};
+	#private;
+}