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

package/types/core/kernel/coreKernel.d.ts

@@ -0,0 +1,219 @@
+import type {} from '../../typedef';
+export default CoreKernel;
+export type ProductType = import('../section/constructor').ConstructorReturnType;
+export type Deps = {
+	/**
+	 * - Editor facade (public API)
+	 */
+	facade: SunEditor.Instance;
+	/**
+	 * - L1: Central state store
+	 */
+	store: SunEditor.Store;
+	/**
+	 * - L2: Context provider
+	 */
+	contextProvider: import('../config/contextProvider').default;
+	/**
+	 * - L2: Option provider
+	 */
+	optionProvider: import('../config/optionProvider').default;
+	/**
+	 * - L2: Instance type checker
+	 */
+	instanceCheck: import('../config/instanceCheck').default;
+	/**
+	 * - L2: Event manager (public API)
+	 */
+	eventManager: import('../config/eventManager').default;
+	/**
+	 * - Frame root elements map
+	 */
+	frameRoots: Map<string, SunEditor.FrameContext>;
+	/**
+	 * - Editor context
+	 */
+	context: SunEditor.Context;
+	/**
+	 * - Editor options
+	 */
+	options: SunEditor.Options;
+	/**
+	 * - Icon set
+	 */
+	icons: any;
+	/**
+	 * - Language strings
+	 */
+	lang: any;
+	/**
+	 * - Current frame context
+	 */
+	frameContext: SunEditor.FrameContext;
+	/**
+	 * - Current frame options
+	 */
+	frameOptions: SunEditor.FrameOptions;
+	/**
+	 * - L3: Offset calculator
+	 */
+	offset: import('../logic/dom/offset').default;
+	/**
+	 * - L3: Selection handler
+	 */
+	selection: import('../logic/dom/selection').default;
+	/**
+	 * - L3: Block formatting
+	 */
+	format: import('../logic/dom/format').default;
+	/**
+	 * - L3: Inline styling
+	 */
+	inline: import('../logic/dom/inline').default;
+	/**
+	 * - L3: List operations
+	 */
+	listFormat: import('../logic/dom/listFormat').default;
+	/**
+	 * - L3: HTML processing
+	 */
+	html: import('../logic/dom/html').default;
+	/**
+	 * - L3: Node transformation
+	 */
+	nodeTransform: import('../logic/dom/nodeTransform').default;
+	/**
+	 * - L3: Character counting
+	 */
+	char: import('../logic/dom/char').default;
+	/**
+	 * - L3: Component lifecycle
+	 */
+	component: import('../logic/shell/component').default;
+	/**
+	 * - L3: Focus management
+	 */
+	focusManager: import('../logic/shell/focusManager').default;
+	/**
+	 * - L3: Plugin registry
+	 */
+	pluginManager: import('../logic/shell/pluginManager').default;
+	/**
+	 * - Plugin instances map
+	 */
+	plugins: {
+		[x: string]: any;
+	};
+	/**
+	 * - L3: UI state management
+	 */
+	ui: import('../logic/shell/ui').default;
+	/**
+	 * - L3: Command routing
+	 */
+	commandDispatcher: import('../logic/shell/commandDispatcher').default;
+	/**
+	 * - L3: Undo/Redo stack
+	 */
+	history: ReturnType<typeof History>;
+	/**
+	 * - L3: Shortcut mapping
+	 */
+	shortcuts: import('../logic/shell/shortcuts').default;
+	/**
+	 * - L3: Toolbar renderer
+	 */
+	toolbar: import('../logic/panel/toolbar').default;
+	/**
+	 * - L3: Sub-toolbar renderer
+	 */
+	subToolbar: import('../logic/panel/toolbar').default;
+	/**
+	 * - L3: Menu renderer
+	 */
+	menu: import('../logic/panel/menu').default;
+	/**
+	 * - L3: View mode handler
+	 */
+	viewer: import('../logic/panel/viewer').default;
+};
+/**
+ * @typedef {import('../section/constructor').ConstructorReturnType} ProductType
+ */
+/**
+ * @typedef {Object} Deps
+ * @property {SunEditor.Instance} facade - Editor facade (public API)
+ * @property {SunEditor.Store} store - L1: Central state store
+ *
+ * @property {import('../config/contextProvider').default} contextProvider - L2: Context provider
+ * @property {import('../config/optionProvider').default} optionProvider - L2: Option provider
+ * @property {import('../config/instanceCheck').default} instanceCheck - L2: Instance type checker
+ * @property {import('../config/eventManager').default} eventManager - L2: Event manager (public API)
+ *
+ * @property {Map<string, SunEditor.FrameContext>} frameRoots - Frame root elements map
+ * @property {SunEditor.Context} context - Editor context
+ * @property {SunEditor.Options} options - Editor options
+ * @property {Object} icons - Icon set
+ * @property {Object} lang - Language strings
+ * @property {SunEditor.FrameContext} frameContext - Current frame context
+ * @property {SunEditor.FrameOptions} frameOptions - Current frame options
+ *
+ * @property {import('../logic/dom/offset').default} offset - L3: Offset calculator
+ * @property {import('../logic/dom/selection').default} selection - L3: Selection handler
+ * @property {import('../logic/dom/format').default} format - L3: Block formatting
+ * @property {import('../logic/dom/inline').default} inline - L3: Inline styling
+ * @property {import('../logic/dom/listFormat').default} listFormat - L3: List operations
+ * @property {import('../logic/dom/html').default} html - L3: HTML processing
+ * @property {import('../logic/dom/nodeTransform').default} nodeTransform - L3: Node transformation
+ * @property {import('../logic/dom/char').default} char - L3: Character counting
+ *
+ * @property {import('../logic/shell/component').default} component - L3: Component lifecycle
+ * @property {import('../logic/shell/focusManager').default} focusManager - L3: Focus management
+ * @property {import('../logic/shell/pluginManager').default} pluginManager - L3: Plugin registry
+ * @property {Object<string, Object>} plugins - Plugin instances map
+ * @property {import('../logic/shell/ui').default} ui - L3: UI state management
+ * @property {import('../logic/shell/commandDispatcher').default} commandDispatcher - L3: Command routing
+ * @property {ReturnType<import('../logic/shell/history').default>} history - L3: Undo/Redo stack
+ * @property {import('../logic/shell/shortcuts').default} shortcuts - L3: Shortcut mapping
+ *
+ * @property {import('../logic/panel/toolbar').default} toolbar - L3: Toolbar renderer
+ * @property {import('../logic/panel/toolbar').default} subToolbar - L3: Sub-toolbar renderer
+ * @property {import('../logic/panel/menu').default} menu - L3: Menu renderer
+ * @property {import('../logic/panel/viewer').default} viewer - L3: View mode handler
+ */
+/**
+ * @description Core dependency container for the editor.
+ * - Stores and retrieves config/logic/plugin instances.
+ * - Orchestrates dependency injection across layers.
+ * - Initialization order: L1 Store -> L2 Config (`$` Phase 1) -> L3 Logic (`$` Phase 2) -> L4 Event.
+ */
+declare class CoreKernel {
+	/**
+	 * @param {SunEditor.Instance} facade - Editor instance (Public API)
+	 * @param {Object} config - Initial configuration
+	 * @param {ProductType} config.product  - The initial product object.
+	 * @param {SunEditor.InitOptions} config.options  - The initial options.
+	 */
+	constructor(
+		facade: SunEditor.Instance,
+		config: {
+			product: ProductType;
+			options: SunEditor.InitOptions;
+		},
+	);
+	/** @type {Deps} */
+	$: Deps;
+	store: Store;
+	_eventOrchestrator: EventOrchestrator;
+	/**
+	 * @description Destroy the kernel and release all resources.
+	 * Teardown order (reverse of init): plugins -> logic -> event -> config -> store
+	 * Uses error aggregation to ensure all modules are cleaned up even if some fail.
+	 */
+	_destroy(): void;
+	facade: any;
+	#private;
+}
+import EventOrchestrator from '../event/eventOrchestrator';
+import History from '../logic/shell/history';
+import Store from './store';

package/types/core/kernel/kernelInjector.d.ts

@@ -0,0 +1,16 @@
+import type {} from '../../typedef';
+export default KernelInjector;
+/**
+ * @description Base class for kernel consumers (plugins, modules).
+ * - Provides cached access to kernel dependencies via `$` object.
+ * - Dependencies are built once in `CoreKernel` and shared across all consumers.
+ * - Eliminates circular references by routing through the kernel.
+ */
+declare class KernelInjector {
+	/**
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/** @type {SunEditor.Deps} */
+	$: SunEditor.Deps;
+}

package/types/core/kernel/store.d.ts

@@ -0,0 +1,170 @@
+import type {} from '../../typedef';
+export default Store;
+export type StoreState = {
+	/**
+	 * - Current root frame key.
+	 */
+	rootKey: any;
+	/**
+	 * - Whether the editor has focus.
+	 */
+	hasFocus: boolean;
+	/**
+	 * - Tab character space count.
+	 */
+	tabSize: number;
+	/**
+	 * - `block` indent margin size (px).
+	 */
+	indentSize: number;
+	/**
+	 * - Code view indent space count.
+	 */
+	codeIndentSize: number;
+	/**
+	 * - Selection path tag names (for navigation bar).
+	 */
+	currentNodes: Array<string>;
+	/**
+	 * - Active command/style names from selection path.
+	 */
+	currentNodesMap: Array<string>;
+	/**
+	 * - Viewport height at initialization.
+	 */
+	initViewportHeight: number;
+	/**
+	 * - Current visual viewport height.
+	 */
+	currentViewportHeight: number;
+	/**
+	 * - Whether a controller or component is currently active, used to manage `blur`/`focus` behavior.
+	 */
+	controlActive: boolean;
+	/**
+	 * - Whether the frame content is scrollable (derived from `height`/`maxHeight` options).
+	 */
+	isScrollable: (fc: SunEditor.FrameContext) => boolean;
+	/**
+	 * - Last selection node processed by `selectionState.update()` (cache for dedup).
+	 */
+	_lastSelectionNode: Node | null;
+	/**
+	 * - Cached selection range.
+	 */
+	_range: Range | null;
+	/**
+	 * - Whether `mousedown` is pressed.
+	 */
+	_mousedown: boolean;
+	/**
+	 * - Suppress `blur` event handling.
+	 */
+	_preventBlur: boolean;
+	/**
+	 * - Suppress `focus` event handling.
+	 */
+	_preventFocus: boolean;
+};
+/**
+ * - Toolbar display mode flags (immutable after init).
+ */
+export type StoreMode = {
+	/**
+	 * - Whether the toolbar is in classic (top-fixed) mode.
+	 */
+	isClassic: boolean;
+	/**
+	 * - Whether the toolbar is in `inline` mode (appears above the editor on focus).
+	 */
+	isInline: boolean;
+	/**
+	 * - Whether the toolbar is in `balloon` mode (appears on text selection).
+	 */
+	isBalloon: boolean;
+	/**
+	 * - Whether the toolbar is in `balloon-always` mode (always visible as floating).
+	 */
+	isBalloonAlways: boolean;
+	/**
+	 * - Whether the sub-toolbar is in `balloon` mode.
+	 */
+	isSubBalloon: boolean;
+	/**
+	 * - Whether the sub-toolbar is in `balloon-always` mode.
+	 */
+	isSubBalloonAlways: boolean;
+};
+/**
+ * @typedef {Object} StoreState
+ * @property {*} rootKey - Current root frame key.
+ * @property {boolean} hasFocus - Whether the editor has focus.
+ * @property {number} tabSize - Tab character space count.
+ * @property {number} indentSize - `block` indent margin size (px).
+ * @property {number} codeIndentSize - Code view indent space count.
+ * @property {Array<string>} currentNodes - Selection path tag names (for navigation bar).
+ * @property {Array<string>} currentNodesMap - Active command/style names from selection path.
+ * @property {number} initViewportHeight - Viewport height at initialization.
+ * @property {number} currentViewportHeight - Current visual viewport height.
+ * @property {boolean} controlActive - Whether a controller or component is currently active, used to manage `blur`/`focus` behavior.
+ * @property {(fc: SunEditor.FrameContext) => boolean} isScrollable - Whether the frame content is scrollable (derived from `height`/`maxHeight` options).
+ * @property {?Node} _lastSelectionNode - Last selection node processed by `selectionState.update()` (cache for dedup).
+ * @property {?Range} _range - Cached selection range.
+ * @property {boolean} _mousedown - Whether `mousedown` is pressed.
+ * @property {boolean} _preventBlur - Suppress `blur` event handling.
+ * @property {boolean} _preventFocus - Suppress `focus` event handling.
+ */
+/**
+ * @typedef {Object} StoreMode - Toolbar display mode flags (immutable after init).
+ * @property {boolean} isClassic - Whether the toolbar is in classic (top-fixed) mode.
+ * @property {boolean} isInline - Whether the toolbar is in `inline` mode (appears above the editor on focus).
+ * @property {boolean} isBalloon - Whether the toolbar is in `balloon` mode (appears on text selection).
+ * @property {boolean} isBalloonAlways - Whether the toolbar is in `balloon-always` mode (always visible as floating).
+ * @property {boolean} isSubBalloon - Whether the sub-toolbar is in `balloon` mode.
+ * @property {boolean} isSubBalloonAlways - Whether the sub-toolbar is in `balloon-always` mode.
+ */
+/**
+ * @description Central runtime state management for the editor.
+ * - Does not store DOM references (kept in `frameContext`).
+ * - Does not store configuration values (kept in `options`).
+ * - Only manages runtime state.
+ */
+declare class Store {
+	/**
+	 * @param {import('../section/constructor').ConstructorReturnType} product - Constructor product
+	 */
+	constructor(product: import('../section/constructor').ConstructorReturnType);
+	/**
+	 * @internal
+	 * @description If `true`, initialize all indexes of image, video information
+	 * @type {boolean}
+	 */
+	_editorInitFinished: boolean;
+	/** @type {StoreMode} */
+	mode: StoreMode;
+	/**
+	 * @description Get state value (supports underscore notation)
+	 * @template {keyof StoreState} K
+	 * @param {K} key
+	 * @returns {StoreState[K]}
+	 */
+	get<K extends keyof StoreState>(key: K): StoreState[K];
+	/**
+	 * @description Set state value and notify subscribers
+	 * @template {keyof StoreState} K
+	 * @param {K} key
+	 * @param {StoreState[K]} value - Value to set
+	 */
+	set<K extends keyof StoreState>(key: K, value: StoreState[K]): void;
+	/**
+	 * @description Subscribe to state changes
+	 * @template {keyof StoreState} K
+	 * @param {K} path - Path to subscribe
+	 * @param {(newValue: StoreState[K], oldValue: StoreState[K]) => void} callback
+	 * @returns {() => void} Unsubscribe function
+	 */
+	subscribe<K extends keyof StoreState>(path: K, callback: (newValue: StoreState[K], oldValue: StoreState[K]) => void): () => void;
+	_reset(): void;
+	_destroy(): void;
+	#private;
+}

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

@@ -0,0 +1,46 @@
+import type {} from '../../../typedef';
+export default Char;
+/**
+ * @description character count, character limit, etc. management class
+ */
+declare class Char {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Returns false if char count is greater than "frameOptions.get('charCounter_max')" when "html" is added to the current editor.
+	 * @param {Node|string} html Element node or String.
+	 * @returns {boolean}
+	 */
+	check(html: Node | string): boolean;
+	/**
+	 * @description Get the [content]'s number of characters or binary data size. (frameOptions.get('charCounter_type'))
+	 * - If [content] is undefined, get the current editor's number of characters or binary data size.
+	 * @param {string} [content] Content to count. (defalut: this.#frameContext.get('wysiwyg'))
+	 * @returns {number}
+	 */
+	getLength(content?: string): number;
+	/**
+	 * @descriptionGets Get the length in bytes of a string.
+	 * @param {string} text String text
+	 * @returns {number}
+	 */
+	getByteLength(text: string): number;
+	/**
+	 * @description Set the char count to charCounter element textContent.
+	 * @param {?SunEditor.FrameContext} [fc] Frame context
+	 */
+	display(fc?: SunEditor.FrameContext | null): void;
+	/**
+	 * @description Returns false if char count is greater than "frameOptions.get('charCounter_max')" when "inputText" is added to the current editor.
+	 * - If the current number of characters is greater than "charCounter_max", the excess characters are removed.
+	 * And call the char.display()
+	 * @param {string} inputText Text added.
+	 * @param {boolean} _fromInputEvent Whether the test is triggered from an input event.
+	 * @returns {boolean}
+	 */
+	test(inputText: string, _fromInputEvent: boolean): boolean;
+	#private;
+}

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

@@ -0,0 +1,234 @@
+import type {} from '../../../typedef';
+export default Format;
+/**
+ * @description Classes related to editor formats such as `line` and `block`.
+ */
+declare class Format {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Replace the line tag of the current selection.
+	 * @param {Node} element Line element (P, DIV..)
+	 * @example
+	 * // Replace the format tag of selected lines with H1
+	 * const h1 = document.createElement('h1');
+	 * editor.format.setLine(h1);
+	 *
+	 * // Replace the format tag of selected lines with DIV
+	 * const div = document.createElement('div');
+	 * editor.format.setLine(div);
+	 */
+	setLine(element: Node): void;
+	/**
+	 * @description If a parent node that contains an argument node finds a format node (`format.isLine`), it returns that node.
+	 * @param {Node} node Reference node.
+	 * @param {?(current: Node) => boolean} [validation] Additional validation function.
+	 * @returns {HTMLElement|null}
+	 */
+	getLine(node: Node, validation?: ((current: Node) => boolean) | null): HTMLElement | null;
+	/**
+	 * @description Replace the br-line tag of the current selection.
+	 * @param {Node} element BR-Line element (PRE..)
+	 */
+	setBrLine(element: Node): void;
+	/**
+	 * @description If a parent node that contains an argument node finds a `brLine` (`format.isBrLine`), it returns that node.
+	 * @param {Node} element Reference node.
+	 * @param {?(current: Node) => boolean} [validation] Additional validation function.
+	 * @returns {HTMLBRElement|null}
+	 */
+	getBrLine(element: Node, validation?: ((current: Node) => boolean) | null): HTMLBRElement | null;
+	/**
+	 * @description Append `line` element to sibling node of argument element.
+	 * - If the `lineNode` argument value is present, the tag of that argument value is inserted,
+	 * - If not, the currently selected format tag is inserted.
+	 * @param {Node} element Insert as siblings of that element
+	 * @param {?(string|Node)} [lineNode] Node name or node obejct to be inserted
+	 * @returns {HTMLElement}
+	 */
+	addLine(element: Node, lineNode?: (string | Node) | null): HTMLElement;
+	/**
+	 * @description If a parent node that contains an argument node finds a format node (`format.isBlock`), it returns that node.
+	 * @param {Node} element Reference node.
+	 * @param {?(current: Node) => boolean} [validation] Additional validation function.
+	 * @returns {HTMLElement|null}
+	 */
+	getBlock(element: Node, validation?: ((current: Node) => boolean) | null): HTMLElement | null;
+	/**
+	 * @description Appended all selected `line` element to the argument element(`block`) and insert
+	 * @param {Node} blockElement Element of wrap the arguments (BLOCKQUOTE...)
+	 * @example
+	 * // Wrap selected lines in a blockquote
+	 * const blockquote = document.createElement('blockquote');
+	 * editor.format.applyBlock(blockquote);
+	 */
+	applyBlock(blockElement: Node): void;
+	/**
+	 * @description The elements of the `selectedFormats` array are detached from the `blockElement` element. (`LI` tags are converted to `P` tags)
+	 * - When `selectedFormats` is `null`, all elements are detached and return {cc: parentNode, sc: nextSibling, ec: previousSibling, removeArray: [Array of removed elements]}.
+	 * @param {Node} blockElement `block` element (PRE, BLOCKQUOTE, OL, UL...)
+	 * @param {Object} [options] Options
+	 * @param {Array<Node>} [options.selectedFormats=null] Array of `line` elements (P, DIV, LI...) to remove.
+	 * - If `null`, Applies to all elements and return {cc: parentNode, sc: nextSibling, ec: previousSibling}
+	 * @param {Node} [options.newBlockElement=null] The node(`blockElement`) to replace the currently wrapped node.
+	 * @param {boolean} [options.shouldDelete=false] If `true`, deleted without detached.
+	 * @param {boolean} [options.skipHistory=false] When `true`, it does not update the history stack and the selection object and return `EdgeNodes` (dom-query-GetEdgeChildNodes)
+	 * @returns {{cc: Node, sc: Node, so: number, ec: Node, eo: number, removeArray: ?Array<Node>}} Node information after deletion
+	 * - cc: Common parent container node
+	 * - sc: Start container node
+	 * - so: Start offset
+	 * - ec: End container node
+	 * - eo: End offset
+	 * - removeArray: Array of removed elements
+	 * @example
+	 * // Remove all list items from a list
+	 * const listElement = editor.selection.getNode().closest('ul');
+	 * editor.format.removeBlock(listElement);
+	 *
+	 * // Remove specific list items only
+	 * const selectedItems = [liElement1, liElement2];
+	 * editor.format.removeBlock(listElement, { selectedFormats: selectedItems });
+	 *
+	 * // Replace blockquote with div
+	 * const blockquote = editor.selection.getNode().closest('blockquote');
+	 * const newDiv = document.createElement('div');
+	 * editor.format.removeBlock(blockquote, { newBlockElement: newDiv });
+	 */
+	removeBlock(
+		blockElement: Node,
+		{
+			selectedFormats,
+			newBlockElement,
+			shouldDelete,
+			skipHistory,
+		}?: {
+			selectedFormats?: Array<Node>;
+			newBlockElement?: Node;
+			shouldDelete?: boolean;
+			skipHistory?: boolean;
+		},
+	): {
+		cc: Node;
+		sc: Node;
+		so: number;
+		ec: Node;
+		eo: number;
+		removeArray: Array<Node> | null;
+	};
+	/**
+	 * @description Indent more the selected lines.
+	 * - margin size : `store.get('indentSize')`
+	 */
+	indent(): void;
+	/**
+	 * @description Indent less the selected lines.
+	 * - margin size - `store.get('indentSize')`
+	 */
+	outdent(): void;
+	/**
+	 * @description Check if the container and offset values are the edges of the `line`
+	 * @param {Node} node The node of the selection object. (range.startContainer..)
+	 * @param {number} offset The offset of the selection object. (selection.getRange().startOffset...)
+	 * @param {"front"|"end"} dir Select check point - `front`: Front edge, `end`: End edge, `undefined`: Both edge.
+	 * @returns {node is HTMLElement}
+	 */
+	isEdgeLine(node: Node, offset: number, dir: 'front' | 'end'): node is HTMLElement;
+	/**
+	 * @description It is judged whether it is a node related to the text style.
+	 * @param {Node|string} element The node to check
+	 * @returns {element is HTMLElement}
+	 */
+	isTextStyleNode(element: Node | string): element is HTMLElement;
+	/**
+	 * @description It is judged whether it is the `line` element.
+	 * - (P, DIV, H[1-6], PRE, LI | class=`__se__format__line_xxx`)
+	 * - `line` element also contain `brLine` element
+	 * @param {Node|string} element The node to check
+	 * @returns {element is HTMLElement}
+	 */
+	isLine(element: Node | string): element is HTMLElement;
+	/**
+	 * @description It is judged whether it is the only `line` element.
+	 * @param {Node|string} element The node to check
+	 * @returns {element is HTMLElement}
+	 */
+	isNormalLine(element: Node | string): element is HTMLElement;
+	/**
+	 * @description It is judged whether it is the `brLine` element.
+	 * - (PRE | class=`__se__format__br_line_xxx`)
+	 * - `brLine` elements is included in the `line` element.
+	 * - `brLine` elements's line break is `BR` tag.
+	 * ※ Entering the Enter key in the space on the last line ends `brLine` and appends `line`.
+	 * @param {Node|string} element The node to check
+	 * @returns {element is HTMLElement}
+	 */
+	isBrLine(element: Node | string): element is HTMLElement;
+	/**
+	 * @description It is judged whether it is the `block` element.
+	 * - (BLOCKQUOTE, OL, UL, FIGCAPTION, TABLE, THEAD, TBODY, TR, TH, TD | class=`__se__format__block_xxx`)
+	 * - `block` is wrap the `line` and `component`
+	 * @param {Node|string} element The node to check
+	 * @returns {element is HTMLElement}
+	 */
+	isBlock(element: Node | string): element is HTMLElement;
+	/**
+	 * @description It is judged whether it is the `closureBlock` element.
+	 * - (TH, TD | class=`__se__format__block_closure_xxx`)
+	 * - `closureBlock` elements is included in the `block`.
+	 * - `closureBlock` element is wrap the `line` and `component`
+	 * - ※ You cannot exit this format with the Enter key or Backspace key.
+	 * - ※ Use it only in special cases. ([ex] format of table cells)
+	 * @param {Node|string} element The node to check
+	 * @returns {element is HTMLElement}
+	 */
+	isClosureBlock(element: Node | string): element is HTMLElement;
+	/**
+	 * @description It is judged whether it is the `closureBrLine` element.
+	 * - (class=`__se__format__br_line__closure_xxx`)
+	 * - `closureBrLine` elements is included in the `brLine`.
+	 * - `closureBrLine` elements's line break is `BR` tag.
+	 * - ※ You cannot exit this format with the Enter key or Backspace key.
+	 * - ※ Use it only in special cases. ([ex] format of table cells)
+	 * @param {Node|string} element The node to check
+	 * @returns {element is HTMLElement}
+	 */
+	isClosureBrLine(element: Node | string): element is HTMLElement;
+	/**
+	 * @description Returns a `line` array from selected range.
+	 * @param {?(current: Node) => boolean} [validation] The validation function. (Replaces the default validation `format.isLine(current)`)
+	 * @returns {Array<HTMLElement>}
+	 */
+	getLines(validation?: ((current: Node) => boolean) | null): Array<HTMLElement>;
+	/**
+	 * @description Get lines and components from the selected range. (P, DIV, H[1-6], OL, UL, TABLE..)
+	 * - If some of the component are included in the selection, get the entire that component.
+	 * @param {boolean} removeDuplicate If `true`, if there is a parent and child tag among the selected elements, the child tag is excluded.
+	 * @returns {Array<HTMLElement>}
+	 */
+	getLinesAndComponents(removeDuplicate: boolean): Array<HTMLElement>;
+	/**
+	 * @internal
+	 * @description Nodes without text
+	 * @param {Node|string} element Element to check
+	 * @returns {boolean}
+	 */
+	_isNotTextNode(element: Node | string): boolean;
+	/**
+	 * @internal
+	 * @description A function that distinguishes areas where `selection` should not be placed
+	 * @param {Node} element Element
+	 * @returns {boolean}
+	 */
+	_isExcludeSelectionElement(element: Node): boolean;
+	/**
+	 * @internal
+	 * @description Reset the line break format.
+	 * @param {"line"|"br"} breakFormat `options.get('defaultLineBreakFormat')`
+	 * @returns {boolean}
+	 */
+	__resetBrLineBreak(breakFormat: 'line' | 'br'): boolean;
+	#private;
+}