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

package/types/core/logic/panel/toolbar.d.ts

@@ -0,0 +1,128 @@
+import type {} from '../../../typedef';
+export default Toolbar;
+/**
+ * @description Toolbar class
+ */
+declare class Toolbar {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 * @param {Object} options - Toolbar options
+	 * @param {"toolbar"|"toolbar_sub"} options.keyName - Toolbar key name
+	 * @param {boolean} options.balloon - Balloon toolbar
+	 * @param {boolean} options.inline - Inline toolbar
+	 * @param {boolean} options.balloonAlways - Balloon toolbar always show
+	 * @param {Array<Node>} options.res - Responsive toolbar button list
+	 */
+	constructor(
+		kernel: SunEditor.Kernel,
+		{
+			keyName,
+			balloon,
+			inline,
+			balloonAlways,
+			res,
+		}: {
+			keyName: 'toolbar' | 'toolbar_sub';
+			balloon: boolean;
+			inline: boolean;
+			balloonAlways: boolean;
+			res: Array<Node>;
+		},
+	);
+	isSub: boolean;
+	/**
+	 * @type {Object}
+	 * @description Key names for the toolbar elements.
+	 * @property {"toolbar_sub_main"|"toolbar_main"} main - Main toolbar key name
+	 * @property {"toolbar_sub_buttonTray"|"toolbar_buttonTray"} buttonTray - Button tray key name
+	 * @property {"toolbar_sub_width"|"toolbar_width"} width - Toolbar width key name
+	 */
+	keyName: any;
+	currentMoreLayerActiveButton: HTMLButtonElement;
+	isSticky: boolean;
+	isBalloonMode: boolean;
+	isInlineMode: boolean;
+	isBalloonAlwaysMode: boolean;
+	inlineToolbarAttr: {
+		top: string;
+		width: string;
+		isShow: boolean;
+	};
+	balloonOffset: {
+		top: number;
+		left: number;
+	};
+	/**
+	 * @description Disables all toolbar buttons.
+	 */
+	disable(): void;
+	/**
+	 * @description Enables all toolbar buttons.
+	 */
+	enable(): void;
+	/**
+	 * @description Shows the toolbar.
+	 */
+	show(): void;
+	/**
+	 * @description Hides the toolbar.
+	 */
+	hide(): void;
+	/**
+	 * @description Reset buttons of the responsive toolbar.
+	 */
+	resetResponsiveToolbar(): void;
+	/**
+	 * @description Reset the buttons on the toolbar. (Editor is not reloaded.)
+	 * - You cannot set a new plugin for the button.
+	 * @param {Array} buttonList Button list
+	 */
+	setButtons(buttonList: any[]): void;
+	/**
+	 * @internal
+	 * @description Reset the sticky toolbar position based on the editor state.
+	 */
+	_resetSticky(): void;
+	/**
+	 * @internal
+	 * @description Set up responsive behavior for the toolbar buttons.
+	 */
+	_setResponsive(): void;
+	/**
+	 * @internal
+	 * @description Show the `balloon` toolbar based on the current selection.
+	 * @param {?Range} [rangeObj] - Selection range
+	 */
+	_showBalloon(rangeObj?: Range | null): void;
+	/**
+	 * @internal
+	 * @description Adjust the `balloon` toolbar's position.
+	 * @param {boolean} positionTop - Whether the toolbar should be positioned above the selection
+	 * @param {Range} [range] - Selection range
+	 */
+	_setBalloonOffset(positionTop: boolean, range?: Range): void;
+	/**
+	 * @internal
+	 * @description Show the `inline` toolbar mode.
+	 */
+	_showInline(): void;
+	/**
+	 * @internal
+	 * @description Show a more options layer for toolbar buttons.
+	 * @param {Node} button - Button element
+	 * @param {Node} layer - More options layer element
+	 */
+	_moreLayerOn(button: Node, layer: Node): void;
+	/**
+	 * @internal
+	 * @description Hide the currently active more options layer.
+	 */
+	_moreLayerOff(): void;
+	/**
+	 * @internal
+	 * @description Destroy the Toolbar instance and release memory
+	 */
+	_destroy(): void;
+	#private;
+}

package/types/core/logic/panel/viewer.d.ts

@@ -0,0 +1,89 @@
+import type {} from '../../../typedef';
+export default Viewer;
+/**
+ * @description Viewer (`codeView`, `fullScreen`, `showBlocks`) class
+ */
+declare class Viewer {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Changes to code view or wysiwyg view
+	 * @param {boolean} [value] `true`/`false`, If `undefined` toggle the `codeView` mode.
+	 */
+	codeView(value?: boolean): void;
+	/**
+	 * @description Changes to full screen or default screen
+	 * @param {boolean} [value] `true`/`false`, If `undefined` toggle the `fullScreen` mode.
+	 */
+	fullScreen(value?: boolean): void;
+	/**
+	 * @description Add or remove the class name of `body` so that the code block is visible
+	 * @param {boolean} [value] `true`/`false`, If `undefined` toggle the `showBlocks` mode.
+	 */
+	showBlocks(value?: boolean): void;
+	/**
+	 * @internal
+	 * @description Set the `active` class to the button of the toolbar
+	 */
+	_setButtonsActive(): void;
+	/**
+	 * @description Prints the current content of the editor.
+	 * @throws {Error} Throws error if print operation fails.
+	 */
+	print(): void;
+	/**
+	 * @description Open the preview window.
+	 */
+	preview(): void;
+	/**
+	 * @internal
+	 * @description Resets the full-screen height of the editor.
+	 * - Updates the editor's height dynamically when in full-screen mode.
+	 */
+	_resetFullScreenHeight(): boolean;
+	/**
+	 * @internal
+	 * @description Run `CodeMirror` Editor
+	 * @param {"set"|"get"|"readonly"|"refresh"} key Method key
+	 * @param {*} value `CodeMirror` params
+	 * @param {string} [rootKey] Root key
+	 */
+	_codeMirrorEditor(key: 'set' | 'get' | 'readonly' | 'refresh', value: any, rootKey?: string): any;
+	/**
+	 * @internal
+	 * @description Set method in the code view area
+	 * @param {string} value HTML string
+	 */
+	_setCodeView(value: string): void;
+	/**
+	 * @internal
+	 * @description Get method in the code view area
+	 */
+	_getCodeView(): any;
+	/**
+	 * @internal
+	 * @description Adjusts the height of the code view area.
+	 * - Ensures the code block `auto`-resizes based on its content.
+	 * @param {HTMLElement} code - Code area
+	 * @param {HTMLTextAreaElement} codeNumbers - Code numbers area
+	 * @param {boolean} isAuto - `auto` height option
+	 */
+	_codeViewAutoHeight(code: HTMLElement, codeNumbers: HTMLTextAreaElement, isAuto: boolean): void;
+	/**
+	 * @internal
+	 * @this {HTMLElement} Code numbers area
+	 * @description Synchronizes scrolling of line numbers with the code editor.
+	 * - Keeps the line numbers aligned with the text.
+	 * @param {HTMLTextAreaElement} codeNumbers - Code numbers textarea
+	 */
+	_scrollLineNumbers(this: HTMLElement, codeNumbers: HTMLTextAreaElement): void;
+	/**
+	 * @internal
+	 * @description Destroy the Viewer instance and release memory
+	 */
+	_destroy(): void;
+	#private;
+}

package/types/core/logic/shell/_commandExecutor.d.ts

@@ -0,0 +1,18 @@
+import type {} from '../../../typedef';
+/**
+ * @description Executes built-in editor commands (formatting, undo/redo, save, codeView, etc.)
+ * - and manages copy-format state.
+ */
+export default class CommandExecutor {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Execute default command of command button
+	 */
+	execute(command: any, button: any): Promise<void>;
+	copyFormat(): void;
+	#private;
+}

package/types/core/logic/shell/commandDispatcher.d.ts

@@ -0,0 +1,65 @@
+import type {} from '../../../typedef';
+export const COMMAND_BUTTONS: '.se-menu-list .se-toolbar-btn[data-command]';
+/**
+ * @description Routes toolbar button commands to their handlers and manages active button states.
+ */
+export default class CommandDispatcher {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description All command buttons map
+	 * @type {Map<string, HTMLElement>}
+	 */
+	allCommandButtons: Map<string, HTMLElement>;
+	/**
+	 * @description All command buttons map
+	 * @type {Map<string, HTMLElement>}
+	 */
+	subAllCommandButtons: Map<string, HTMLElement>;
+	get targets(): Map<string, HTMLButtonElement[]>;
+	/**
+	 * @description Returns the active commands array.
+	 * @returns {Array<string>}
+	 */
+	get activeCommands(): Array<string>;
+	/**
+	 * @description Run plugin calls and basic commands.
+	 * @param {string} command Command string
+	 * @param {string} type Display type string (`command`, `dropdown`, `modal`, `container`)
+	 * @param {?Node} [button] The element of command button
+	 */
+	run(command: string, type: string, button?: Node | null): void;
+	/**
+	 * @description Execute `editor.run` with command button.
+	 * @param {Node} target Command target
+	 */
+	runFromTarget(target: Node): void;
+	/**
+	 * @description It is executed by inserting the button of `commandTargets` as the argument value of the `func` function.
+	 * - `func` is called as long as the button array's length.
+	 * @param {string} cmd data-command
+	 * @param {(...args: *) => *} func Function.
+	 */
+	applyTargets(cmd: string, func: (...args: any) => any): void;
+	/**
+	 * @description Sets command target elements.
+	 * @param {string} cmd - The command identifier.
+	 * @param {HTMLButtonElement} target - The associated command button.
+	 */
+	registerTargets(cmd: string, target: HTMLButtonElement): void;
+	resetTargets(): void;
+	/**
+	 * @internal
+	 * @description Caching basic buttons to use
+	 */
+	_initCommandButtons(): void;
+	_copyFormat(): void;
+	/**
+	 * @description Destroy the CommandDispatcher
+	 */
+	_destroy(): void;
+	#private;
+}

package/types/core/logic/shell/component.d.ts

@@ -0,0 +1,182 @@
+import type {} from '../../../typedef';
+export default Component;
+/**
+ * @description Class for managing components such as images and tables that are not in `line` format
+ */
+declare class Component {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description The current component information, used copy, cut, and keydown events
+	 * @type {SunEditor.ComponentInfo}
+	 */
+	info: SunEditor.ComponentInfo;
+	/**
+	 * @description Component is selected
+	 * @type {boolean}
+	 */
+	isSelected: boolean;
+	/**
+	 * @description Currently selected component target
+	 * @type {?Node}
+	 */
+	currentTarget: Node | null;
+	/**
+	 * @description Currently selected component plugin instance
+	 * @type {*}
+	 */
+	currentPlugin: any;
+	/**
+	 * @description Currently selected component plugin name
+	 * @type {*}
+	 */
+	currentPluginName: any;
+	/**
+	 * @description Currently selected component information
+	 * @type {?SunEditor.ComponentInfo}
+	 */
+	currentInfo: SunEditor.ComponentInfo | null;
+	/** @internal */
+	__selectionSelected: boolean;
+	/** @internal */
+	__prevent: boolean;
+	/**
+	 * @description Initialize eventManager reference after EventManager is created.
+	 */
+	_init(): void;
+	/**
+	 * @description Inserts an element and returns it. (Used for elements: table, hr, image, video)
+	 * - If `element` is `HR`, inserts and returns the new line.
+	 * @param {Node} element Element to be inserted
+	 * @param {Object} [options] Options
+	 * @param {boolean} [options.skipCharCount=false] If `true`, it will be inserted even if `frameOptions.get('charCounter_max')` is exceeded.
+	 * @param {boolean} [options.skipHistory=false] If `true`, do not push to history.
+	 * @param {boolean} [options.scrollTo=true] `true` : Scroll to the inserted element, `false` : Do not scroll.
+	 * @param {SunEditor.ComponentInsertType} [options.insertBehavior] If `true`, do not automatically select the inserted component. [default: `options.get('componentInsertBehavior')`]
+	 * - If `null`, no action is performed after insertion.
+	 * @returns {HTMLElement} The inserted element or new line (for HR)
+	 */
+	insert(
+		element: Node,
+		{
+			skipCharCount,
+			skipHistory,
+			scrollTo,
+			insertBehavior,
+		}?: {
+			skipCharCount?: boolean;
+			skipHistory?: boolean;
+			scrollTo?: boolean;
+			insertBehavior?: SunEditor.ComponentInsertType;
+		},
+	): HTMLElement;
+	/**
+	 * @description Handles post-insertion behavior for a newly created component based on the specified mode.
+	 * @param {Node} container The inserted component element.
+	 * @param {?Node} [oNode] Optional node to use for selection if the component cannot be selected.
+	 * @param {SunEditor.ComponentInsertType} [insertBehavior] Behavior mode after component insertion.
+	 */
+	applyInsertBehavior(container: Node, oNode?: Node | null, insertBehavior?: SunEditor.ComponentInsertType): void;
+	/**
+	 * @description Gets the file component and that plugin name
+	 * - return: {target, component, pluginName} | null
+	 * @param {Node} element Target element (figure tag, component div, file tag)
+	 * @returns {SunEditor.ComponentInfo|null}
+	 */
+	get(element: Node): SunEditor.ComponentInfo | null;
+	/**
+	 * @description The component(media, file component, table, etc) is selected and the resizing module is called.
+	 * @param {Node} element Target element
+	 * @param {string} pluginName The plugin name for the selected target.
+	 * @param {Object} [options] Options
+	 * @param {boolean} [options.isInput=false] Whether the target is an input component (table).
+	 */
+	select(
+		element: Node,
+		pluginName: string,
+		{
+			isInput,
+		}?: {
+			isInput?: boolean;
+		},
+	): boolean;
+	/**
+	 * @description Deselects the selected component.
+	 */
+	deselect(): void;
+	/**
+	 * @description Determines if the specified node is a block component (e.g., img, iframe, video, audio, table) with the class `se-component`
+	 * - or a direct `FIGURE` node. This function checks if the node itself is a component
+	 * - or if it belongs to any components identified by the component manager.
+	 * @param {Node} element The DOM node to check.
+	 * @returns {boolean} True if the node is a block component or part of it, otherwise false.
+	 */
+	is(element: Node): boolean;
+	/**
+	 * @description Checks if the given node is an inline component (class `se-inline-component`).
+	 * - If the node is a `FIGURE`, it checks the parent element instead.
+	 * - It also verifies whether the node is part of an inline component recognized by the component manager.
+	 * @param {Node} element The DOM node to check.
+	 * @returns {boolean} True if the node is an inline component or part of it, otherwise false.
+	 */
+	isInline(element: Node): boolean;
+	/**
+	 * @description Checks if the specified node qualifies as a basic component within the editor.
+	 * - This function verifies whether the node is recognized as a component by the `is` function, while also ensuring that it is not an inline component as determined by the `isInline` function.
+	 * - This is used to identify block-level elements or standalone components that are not part of the inline component classification.
+	 * @param {Node} element The DOM node to check.
+	 * @returns {boolean} True if the node is a basic (non-inline) component, otherwise false.
+	 */
+	isBasic(element: Node): boolean;
+	/**
+	 * @description Copies the specified component node to the clipboard.
+	 * - This function is different from the one called when the user presses the `Ctrl + C` key combination.
+	 * @param {Node} container The DOM node to check.
+	 */
+	copy(container: Node): Promise<void>;
+	/**
+	 * @description Temporarily selects a component without showing its controller.
+	 * This is a lightweight selection mode used for:
+	 * - Mouse hover: Shows visual selection while hovering, auto-deselects on mouse out
+	 * - Table column/row resize: Maintains selection after resize without showing controller
+	 *
+	 * Key differences from `select()`:
+	 * - Does NOT show the component's controller (resize handles, toolbar, etc.)
+	 * - Sets `__overInfo` flag so selection is automatically cleared on mouse out
+	 * - Calling `select()` afterward will upgrade to full selection with controller
+	 *
+	 * @param {Element} target The element to hover-select
+	 */
+	hoverSelect(target: Element): void;
+	/**
+	 * @internal
+	 * @description Deselects the currently selected component, removing any selection effects and associated event listeners.
+	 * - This method resets the selection state and hides UI elements related to the component selection.
+	 */
+	__deselect(): void;
+	/**
+	 * @internal
+	 * @description Set line breaker of component
+	 * @param {HTMLElement} element Element tag
+	 */
+	_setComponentLineBreaker(element: HTMLElement): void;
+	/**
+	 * @internal
+	 * @description Removes global event listeners that were previously added for component interactions.
+	 */
+	__removeGlobalEvent(): void;
+	/**
+	 * @internal
+	 * @description Removes drag-related events and resets drag-related states.
+	 */
+	__removeDragEvent(): void;
+	/**
+	 * @internal
+	 * @description Destroy the Component instance and release memory
+	 */
+	_destroy(): void;
+	#private;
+}

package/types/core/logic/shell/focusManager.d.ts

@@ -0,0 +1,31 @@
+import type {} from '../../../typedef';
+/**
+ * @description Manages editor focus and blur behavior across frames and controllers.
+ */
+export default class FocusManager {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 */
+	constructor(kernel: SunEditor.Kernel);
+	/**
+	 * @description Focus to wysiwyg area
+	 * @param {*} [rootKey] Root frame key.
+	 */
+	focus(rootKey?: any): void;
+	/**
+	 * @description If `focusEl` is a component, then that component is selected; if it is a format element, the last text is selected
+	 * - If `focusEl` is `null`, then selected last element
+	 * @param {?Node} [focusEl] Focus element
+	 */
+	focusEdge(focusEl?: Node | null): void;
+	/**
+	 * @description Focus to wysiwyg area using native focus function
+	 */
+	nativeFocus(): void;
+	/**
+	 * @description Focusout to wysiwyg area (.blur())
+	 */
+	blur(): void;
+	#private;
+}

package/types/core/{base → logic/shell}/history.d.ts

@@ -1,17 +1,18 @@
+import type {} from '../../../typedef';
 /**
  * @description History stack closure
- * @param {__se__EditorCore} editor - The root editor instance
+ * @param {SunEditor.Kernel} kernel
  */
-export default function History(editor: __se__EditorCore): {
+export default function History(kernel: SunEditor.Kernel): {
 	/**
 	 * @description Saving the current status to the history object stack
-	 * - If "delay" is true, it will be saved after (options.get('historyStackDelayTime') || 400) milliseconds.
-	 * - If the function is called again with the "delay" argument true before it is saved, the delay time is renewed.
+	 * - If `delay` is `true`, it will be saved after (`options.get('historyStackDelayTime')` || 400) milliseconds.
+	 * - If the function is called again with the `delay` argument `true` before it is saved, the delay time is renewed.
 	 * - You can specify the delay time by sending a number.
-	 * @param {boolean|number} delay If true, add stack without delay time.
-	 * @param {*=} [rootKey] The key of the root frame to save history for.
+	 * @param {boolean|number} delay If `true`, add stack without delay time.
+	 * @param {*} [rootKey] The key of the root frame to save history for.
 	 */
-	push(delay: boolean | number, rootKey?: any | undefined): void;
+	push(delay: boolean | number, rootKey?: any): void;
 	/**
 	 * @description Immediately saves the current state to the history stack if a delayed save is pending.
 	 * @param {*} rootKey The key of the root frame.
@@ -28,9 +29,9 @@ export default function History(editor: __se__EditorCore): {
 	redo(): void;
 	/**
 	 * @description Overwrites the current state in the history stack with the latest content.
-	 * @param {string=} [rootKey] The key of the root frame to overwrite.
+	 * @param {string} [rootKey] The key of the root frame to overwrite.
 	 */
-	overwrite(rootKey?: string | undefined): void;
+	overwrite(rootKey?: string): void;
 	/**
 	 * @description Pauses the history stack, preventing new entries from being added for up to 5 seconds.
 	 */
@@ -53,8 +54,8 @@ export default function History(editor: __se__EditorCore): {
 	 * @description Returns the root stack containing the history of each frame.
 	 * @returns {{content: string, s: {path: number|number[], offset: number|number[]}, e: {path: number|number[], offset: number|number[]}, frame: HTMLElement}} The root stack object.
 	 * - content: content html string
-	 * - s: depth info of the "start" range
-	 * - e: depth info of the "end" range
+	 * - s: depth info of the `start` range
+	 * - e: depth info of the `end` range
 	 * - frame: wysiwyg editable element.
 	 */
 	getRootStack(): {
@@ -77,5 +78,5 @@ export default function History(editor: __se__EditorCore): {
 	/**
 	 * @description Clears the entire history stack and cancels any pending save operations.
 	 */
-	destroy(): void;
+	_destroy(): void;
 };

package/types/core/logic/shell/pluginManager.d.ts

@@ -0,0 +1,115 @@
+import type {} from '../../../typedef';
+export default PluginManager;
+export type PluginEventParam = {
+	frameContext: SunEditor.FrameContext;
+	event: Event;
+	data?: string;
+	line?: Node;
+	range?: Range;
+	file?: File;
+	doc?: Document;
+};
+export type ComponentChecker = (element: Node | null) => any;
+/**
+ * @typedef {Object} PluginEventParam
+ * @property {SunEditor.FrameContext} frameContext
+ * @property {Event} event
+ * @property {string} [data]
+ * @property {Node} [line]
+ * @property {Range} [range]
+ * @property {File} [file]
+ * @property {Document} [doc]
+ */
+/**
+ * @typedef {(element: Node | null) => * } ComponentChecker
+ */
+/**
+ * @description Manages plugin registration and state.
+ * Extracts `plugin` related responsibilities from the monolithic `Editor` class.
+ */
+declare class PluginManager {
+	/**
+	 * @constructor
+	 * @param {SunEditor.Kernel} kernel
+	 * @param {import('../../section/constructor').ConstructorReturnType} [product] - Initial editor context
+	 */
+	constructor(kernel: SunEditor.Kernel, product?: import('../../section/constructor').ConstructorReturnType);
+	/**
+	 * @description Returns the plugins object.
+	 * @returns {Object<string, *>}
+	 */
+	get plugins(): {
+		[x: string]: any;
+	};
+	/**
+	 * @description Returns the file component management object.
+	 * @returns {Object<string, *>}
+	 */
+	get fileInfo(): {
+		[x: string]: any;
+	};
+	/**
+	 * @description Finds component information for the given element.
+	 * @param {Node} element The DOM element to check.
+	 * @returns {SunEditor.ComponentInfo|null}
+	 */
+	findComponentInfo(element: Node): SunEditor.ComponentInfo | null;
+	/**
+	 * @description Apply retain format rules from plugins to the parsed DOM
+	 * @param {DocumentFragment|Document} domParser
+	 */
+	applyRetainFormat(domParser: DocumentFragment | Document): void;
+	/**
+	 * @description Dispatches an event to all registered plugin handlers synchronously.
+	 * @param {string} name The event name (e.g., 'onMouseMove', 'onFocus')
+	 * @param {PluginEventParam} e The event payload
+	 * @returns {boolean|undefined} Returns false if any handler cancels the event
+	 */
+	emitEvent(name: string, e: PluginEventParam): boolean | undefined;
+	/**
+	 * @description Dispatches an event to all registered plugin handlers asynchronously.
+	 * @param {string} name The event name (e.g., 'onKeyDown', 'onPaste')
+	 * @param {PluginEventParam} e The event payload
+	 * @returns {Promise<boolean|undefined>} Returns false if any handler cancels the event
+	 */
+	emitEventAsync(name: string, e: PluginEventParam): Promise<boolean | undefined>;
+	/**
+	 * @description Check the components such as image and video and modify them according to the format.
+	 * @param {boolean} loaded If `true`, the component is loaded.
+	 */
+	checkFileInfo(loaded: boolean): void;
+	/**
+	 * @description Initialize the information of the components.
+	 */
+	resetFileInfo(): void;
+	/**
+	 * @description If the plugin is not added, add the plugin and call the `add` function.
+	 * - If the plugin is added call `callBack` function.
+	 * @param {string} pluginName The name of the plugin to call
+	 * @param {?Array<HTMLElement>} targets Plugin target button
+	 * @param {?Object<string, *>} pluginOptions Plugin's options
+	 */
+	register(
+		pluginName: string,
+		targets: Array<HTMLElement> | null,
+		pluginOptions: {
+			[x: string]: any;
+		} | null,
+	): void;
+	/**
+	 * @description Initialize the plugin manager and register plugins.
+	 * @param {SunEditor.InitOptions} options
+	 */
+	init(options: SunEditor.InitOptions): void;
+	/**
+	 * @description Get a specific plugin instance
+	 * @param {string} name
+	 * @returns {*}
+	 */
+	get(name: string): any;
+	/**
+	 * @description Destroy the plugin manager
+	 */
+	_destroy(): void;
+	#private;
+}