@lobehub/editor 4.15.1 → 4.15.2

package/es/editor-kernel/kernel.js

@@ -0,0 +1,661 @@
+import { __esmMin, __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { createDebugLogger, init_debug } from "../utils/debug.js";
+import locale_default, { init_locale } from "../locale/index.js";
+import { $isRootTextContentEmpty, init_utils } from "../plugins/common/utils/index.js";
+import { getHotkeyById, init_registerHotkey, registerHotkey } from "../utils/hotkey/registerHotkey.js";
+import { init_event, registerEvent } from "./event.js";
+import { KernelPlugin, init_plugin } from "./plugin.js";
+import { $closest, EDITOR_THEME_KEY, createEmptyEditorState, generateEditorId, init_utils as init_utils$1, noop, registerEditorKernel, unregisterEditorKernel } from "./utils.js";
+import { createHeadlessEditor } from "@lexical/headless";
+import { createEmptyHistoryState } from "@lexical/history";
+import { $createTableSelection, $isTableNode, $isTableSelection } from "@lexical/table";
+import { get, merge, template, templateSettings } from "es-toolkit/compat";
+import EventEmitter from "eventemitter3";
+import { $createNodeSelection, $createRangeSelection, $getNodeByKey, $getSelection, $isElementNode, $isNodeSelection, $isRangeSelection, $setSelection, COMMAND_PRIORITY_CRITICAL, KEY_DOWN_COMMAND, createEditor } from "lexical";
+//#region src/editor-kernel/kernel.ts
+var kernel_exports = /* @__PURE__ */ __exportAll({ Kernel: () => Kernel });
+var Kernel;
+var init_kernel = __esmMin((() => {
+	init_locale();
+	init_utils();
+	init_debug();
+	init_registerHotkey();
+	init_event();
+	init_plugin();
+	init_utils$1();
+	templateSettings.interpolate = /{{([\S\s]+?)}}/g;
+	Kernel = class Kernel extends EventEmitter {
+		static {
+			this.globalHotReloadMode = void 0;
+		}
+		constructor() {
+			super();
+			this.plugins = [];
+			this.pluginsConfig = /* @__PURE__ */ new Map();
+			this.pluginsInstances = [];
+			this.beforeEditorInitHooks = [];
+			this.nodeTransforms = [];
+			this.rootClassNames = /* @__PURE__ */ new Set();
+			this.nodes = [];
+			this.themes = { [EDITOR_THEME_KEY]: generateEditorId() };
+			this.decorators = {};
+			this.serviceMap = /* @__PURE__ */ new Map();
+			this.localeMap = locale_default;
+			this.hotReloadMode = false;
+			this.logger = createDebugLogger("kernel");
+			this.historyState = createEmptyHistoryState();
+			this.headlessEditor = false;
+			this._commands = /* @__PURE__ */ new Map();
+			this._commandsClean = /* @__PURE__ */ new Map();
+			this.dataTypeMap = /* @__PURE__ */ new Map();
+			this.hotReloadMode = this.detectDevelopmentMode();
+			this.logger.info(`🚀 Kernel initialized (hot reload: ${this.hotReloadMode})`);
+		}
+		cloneNodeEditor() {
+			const newKernel = new Kernel();
+			newKernel.registerPlugins(this.plugins);
+			newKernel.initNodeEditor();
+			newKernel.setDocument("json", this.getDocument("json") || "{}", { keepId: true });
+			return newKernel;
+		}
+		getHistoryState() {
+			return this.historyState;
+		}
+		isEditable() {
+			return this.editor?.isEditable() || false;
+		}
+		detectDevelopmentMode() {
+			if (Kernel.globalHotReloadMode !== void 0) return Kernel.globalHotReloadMode;
+			if (typeof process !== "undefined" && true) return true;
+			if (typeof window !== "undefined") {
+				if (window.webpackHotUpdate) return true;
+				if (window.__vite_plugin_react_preamble_installed__) return true;
+				if (window.__NEXT_DATA__?.buildId === "development") return true;
+			}
+			if (typeof window !== "undefined" && window.location) {
+				const hostname = window.location.hostname;
+				if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".local")) return true;
+			}
+			return true;
+		}
+		/**
+		* Globally enable or disable hot reload mode for all kernel instances
+		* @param enabled Whether to enable hot reload mode globally
+		*/
+		static setGlobalHotReloadMode(enabled) {
+			Kernel.globalHotReloadMode = enabled;
+		}
+		/**
+		* Reset global hot reload mode to automatic detection
+		*/
+		static resetGlobalHotReloadMode() {
+			Kernel.globalHotReloadMode = void 0;
+		}
+		getLexicalEditor() {
+			return this.editor || null;
+		}
+		destroy() {
+			unregisterEditorKernel(this.themes[EDITOR_THEME_KEY]);
+			this.logger.info(`🗑️ Destroying editor with ${this.pluginsInstances.length} plugins`);
+			try {
+				this.editor?.setEditorState(createEmptyEditorState());
+			} catch (error) {
+				this.logger.warn("Failed to reset editor state during destroy:", error);
+			}
+			this.dataTypeMap.clear();
+			this.pluginsInstances.forEach((plugin) => {
+				if (plugin.destroy) plugin.destroy();
+			});
+			this.pluginsInstances = [];
+			this.beforeEditorInitHooks = [];
+			this.nodeTransforms = [];
+			this.rootClassNames.clear();
+			this.serviceMap.clear();
+			this.decorators = {};
+			this.themes = {};
+			this.headlessEditor = false;
+			this.logger.info("✅ Editor destroyed");
+		}
+		getRootElement() {
+			if (this.headlessEditor) return null;
+			return this.editor?.getRootElement() || null;
+		}
+		setRootElement(dom, editable = true) {
+			if (this.editor) {
+				if (this.headlessEditor) throw new Error("Headless editor cannot be attached to a root element.");
+				this.logger.warn("[Editor] Editor is already initialized, updating root element only");
+				this.editor.setRootElement(dom);
+				this.applyRootClassNames(dom);
+				return this.editor;
+			}
+			if (this.pluginsInstances.length === 0) {
+				this.logger.info(`🔌 Initializing ${this.plugins.length} plugins`);
+				for (const plugin of this.plugins) {
+					const instance = new plugin(this, this.pluginsConfig.get(plugin));
+					this.pluginsInstances.push(instance);
+				}
+			}
+			this.runBeforeEditorInitLifecycle();
+			const resolvedNodes = this.resolveNodesForInitialization();
+			this.logger.info(`📝 Creating editor with ${resolvedNodes.length} nodes`);
+			registerEditorKernel(this.themes[EDITOR_THEME_KEY], this);
+			const editor = this.editor = createEditor({
+				__kernel: this,
+				editable,
+				namespace: "lobehub",
+				nodes: resolvedNodes,
+				onError: (error) => {
+					this.logger.error("❌ Lexical editor error:", error);
+					this.emit("error", error);
+				},
+				theme: this.themes
+			});
+			this.headlessEditor = false;
+			this.editor.setRootElement(dom);
+			this.applyRootClassNames(dom);
+			registerEvent(editor, dom);
+			this.pluginsInstances.forEach((plugin) => {
+				plugin.onInit?.(editor);
+			});
+			this.logger.info(`✅ Editor ready with ${this.pluginsInstances.length} plugins`);
+			this.emit("initialized", editor);
+			return this.editor;
+		}
+		setEditable(editable) {
+			if (!this.editor) {
+				this.logger.error("❌ Editor not initialized");
+				throw new Error(`Editor is not initialized.`);
+			}
+			this.editor.setEditable(editable);
+			this.emit("editableChange", editable);
+			this.logger.debug(`✏️ Editor editable set to ${editable}`);
+		}
+		initNodeEditor() {
+			if (this.editor) return this.editor;
+			if (this.pluginsInstances.length === 0) {
+				this.logger.info(`🔌 Initializing ${this.plugins.length} plugins`);
+				for (const plugin of this.plugins) {
+					const instance = new plugin(this, this.pluginsConfig.get(plugin));
+					this.pluginsInstances.push(instance);
+				}
+			}
+			this.runBeforeEditorInitLifecycle();
+			const resolvedNodes = this.resolveNodesForInitialization();
+			this.logger.info(`📝 Creating editor with ${resolvedNodes.length} nodes`);
+			const editor = this.editor = createEditor({
+				__kernel: this,
+				namespace: "lobehub",
+				nodes: resolvedNodes,
+				onError: (error) => {
+					this.logger.error("❌ Lexical editor error:", error);
+					this.emit("error", error);
+				},
+				theme: this.themes
+			});
+			this.headlessEditor = false;
+			this.pluginsInstances.forEach((plugin) => {
+				plugin.onInit?.(editor);
+			});
+			this.logger.info(`✅ Editor ready with ${this.pluginsInstances.length} plugins`);
+			this.emit("initialized", editor);
+			return editor || null;
+		}
+		initHeadlessEditor() {
+			if (this.editor) return this.editor;
+			if (this.pluginsInstances.length === 0) {
+				this.logger.info(`🔌 Initializing ${this.plugins.length} plugins`);
+				for (const plugin of this.plugins) {
+					const instance = new plugin(this, this.pluginsConfig.get(plugin));
+					this.pluginsInstances.push(instance);
+				}
+			}
+			this.runBeforeEditorInitLifecycle();
+			const resolvedNodes = this.resolveNodesForInitialization();
+			this.logger.info(`📝 Creating headless editor with ${resolvedNodes.length} nodes`);
+			const editor = this.editor = createHeadlessEditor({
+				__kernel: this,
+				namespace: "lobehub-headless",
+				nodes: resolvedNodes,
+				onError: (error) => {
+					this.logger.error("❌ Lexical headless editor error:", error);
+					this.emit("error", error);
+				},
+				theme: this.themes
+			});
+			this.headlessEditor = true;
+			this.pluginsInstances.forEach((plugin) => {
+				plugin.onInit?.(editor);
+			});
+			this.logger.info(`✅ Headless editor ready with ${this.pluginsInstances.length} plugins`);
+			this.emit("initialized", editor);
+			return editor || null;
+		}
+		setDocument(type, content, options) {
+			const datasource = this.dataTypeMap.get(type);
+			if (!datasource) {
+				this.logger.error(`❌ DataSource for type "${type}" not found`);
+				throw new Error(`DataSource for type "${type}" is not registered.`);
+			}
+			if (!this.editor) {
+				this.logger.error("❌ Editor not initialized");
+				throw new Error(`Editor is not initialized.`);
+			}
+			if (!options?.keepHistory) {
+				this.historyState.redoStack = [];
+				this.historyState.undoStack = [];
+				this.historyState.current = null;
+			}
+			datasource.read(this.editor, content, options);
+			this.emit("documentChange", type, content);
+			this.logger.debug(`📥 Set ${type} document`);
+		}
+		setSelection(selection, opt) {
+			if (!this.editor) {
+				this.logger.error("❌ Editor not initialized");
+				throw new Error(`Editor is not initialized.`);
+			}
+			const editor = this.editor;
+			return new Promise((resolve) => {
+				editor.update(() => {
+					try {
+						if (selection.type === "range") {
+							const startNodeId = opt?.collapseToEnd ? selection.endNodeId : selection.startNodeId;
+							const endNodeId = opt?.collapseToStart ? selection.startNodeId : selection.endNodeId;
+							const startOffset = opt?.collapseToEnd ? selection.endOffset : selection.startOffset;
+							const endOffset = opt?.collapseToStart ? selection.startOffset : selection.endOffset;
+							const anchorNode = $getNodeByKey(startNodeId);
+							const focusNode = $getNodeByKey(endNodeId);
+							if (!anchorNode || !focusNode) {
+								this.logger.error("❌ Nodes for selection not found");
+								resolve(false);
+								return;
+							}
+							const rng = $createRangeSelection();
+							rng.anchor.set(anchorNode.getKey(), startOffset, $isElementNode(anchorNode) ? "element" : "text");
+							rng.focus.set(focusNode.getKey(), endOffset, $isElementNode(focusNode) ? "element" : "text");
+							$setSelection(rng);
+							resolve(true);
+							return;
+						}
+						if (selection.type === "node") {
+							if (!$getNodeByKey(selection.startNodeId)) {
+								this.logger.error("❌ Node for selection not found");
+								resolve(false);
+								return;
+							}
+							const nodeSel = $createNodeSelection();
+							nodeSel.add(selection.startNodeId);
+							$setSelection(nodeSel);
+							resolve(true);
+							return;
+						}
+						if (selection.type === "table") {
+							const startNode = $getNodeByKey(selection.startNodeId);
+							if (!startNode) {
+								this.logger.error("❌ Node for selection not found");
+								resolve(false);
+								return;
+							}
+							const endNode = $getNodeByKey(selection.endNodeId);
+							if (!endNode) {
+								this.logger.error("❌ Node for selection not found");
+								resolve(false);
+								return;
+							}
+							const table1 = $closest(startNode, (n) => $isTableNode(n));
+							const table2 = $closest(endNode, (n) => $isTableNode(n));
+							if (!table1 || !table2 || table1 !== table2) {
+								this.logger.error("❌ Table nodes for selection not found or do not match");
+								resolve(false);
+								return;
+							}
+							const rng = $createTableSelection();
+							rng.set(table1.getKey(), selection.startNodeId, selection.endNodeId);
+							$setSelection(rng);
+							resolve(true);
+							return;
+						}
+						resolve(false);
+					} catch (error) {
+						this.logger.error("❌ Error setting selection:", error);
+						resolve(false);
+					}
+				});
+			});
+		}
+		getSelection() {
+			if (!this.editor) {
+				this.logger.error("❌ Editor not initialized");
+				throw new Error(`Editor is not initialized.`);
+			}
+			return this.editor.read(() => {
+				const selection = $getSelection();
+				if ($isRangeSelection(selection)) return {
+					endNodeId: selection.focus.getNode().getKey(),
+					endOffset: selection.focus.offset,
+					startNodeId: selection.anchor.getNode().getKey(),
+					startOffset: selection.anchor.offset,
+					type: "range"
+				};
+				if ($isNodeSelection(selection)) return {
+					endNodeId: selection.getNodes()[0].getKey(),
+					endOffset: 0,
+					startNodeId: selection.getNodes()[0].getKey(),
+					startOffset: 0,
+					type: "node"
+				};
+				if ($isTableSelection(selection)) {
+					const [start, end] = selection.getStartEndPoints();
+					return {
+						endNodeId: end.getNode().getKey(),
+						endOffset: end.offset,
+						startNodeId: start.getNode().getKey(),
+						startOffset: start.offset,
+						type: "table"
+					};
+				}
+				return null;
+			});
+		}
+		focus() {
+			if (this.headlessEditor) return;
+			this.editor?.focus();
+		}
+		blur() {
+			if (this.headlessEditor) return;
+			this.editor?.blur();
+		}
+		getDocument(type) {
+			const datasource = this.dataTypeMap.get(type);
+			if (!datasource) {
+				this.logger.error(`❌ DataSource for type "${type}" not found`);
+				throw new Error(`DataSource for type "${type}" is not registered.`);
+			}
+			if (!this.editor) {
+				this.logger.error("❌ Editor not initialized");
+				throw new Error(`Editor is not initialized.`);
+			}
+			return datasource.write(this.editor);
+		}
+		getSelectionDocument(type) {
+			const datasource = this.dataTypeMap.get(type);
+			if (!datasource) throw new Error(`DataSource for type "${type}" is not registered.`);
+			if (!this.editor) throw new Error(`Editor is not initialized.`);
+			return datasource.write(this.editor, { selection: true });
+		}
+		registerDecorator(name, decorator) {
+			if (this.decorators[name]) if (this.hotReloadMode) {
+				this.logger.warn(`🔄 Hot reload: decorator "${name}"`);
+				this.decorators[name] = decorator;
+				return this;
+			} else {
+				if (this.decorators[name] === decorator) {
+					this.logger.warn(`[Editor] Decorator "${name}" is already registered with the same function`);
+					return this;
+				}
+				this.logger.error(`[Editor] Attempting to register duplicate decorator "${name}". Enable hot reload mode if this is intended.`);
+				throw new Error(`Decorator with name "${name}" is already registered.`);
+			}
+			this.decorators[name] = decorator;
+			this.logger.debug(`🎭 Decorator: ${name}`);
+			return this;
+		}
+		getDecorator(name) {
+			return this.decorators[name];
+		}
+		/**
+		* Unregister a decorator
+		* @param name Decorator name
+		*/
+		unregisterDecorator(name) {
+			if (this.decorators[name]) {
+				delete this.decorators[name];
+				this.logger.debug(`🗑️ Removed decorator: ${name}`);
+				return true;
+			}
+			this.logger.warn(`⚠️ Decorator "${name}" not found`);
+			return false;
+		}
+		/**
+		* Get all registered decorator names
+		*/
+		getRegisteredDecorators() {
+			return Object.keys(this.decorators);
+		}
+		/**
+		* Support registering target data source
+		* @param dataSource Data source
+		*/
+		registerDataSource(dataSource) {
+			this.dataTypeMap.set(dataSource.type, dataSource);
+			this.logger.debug(`📄 Data source: ${dataSource.type}`);
+		}
+		registerThemes(themes) {
+			this.themes = merge(this.themes, themes);
+		}
+		registerPlugin(plugin, config) {
+			const findPlugin = this.plugins.find((p) => p.pluginName === plugin.pluginName);
+			if (findPlugin) if (findPlugin !== plugin) if (this.hotReloadMode) {
+				this.logger.warn(`🔄 Hot reload: plugin "${plugin.pluginName}"`);
+				const index = this.plugins.findIndex((p) => p.pluginName === plugin.pluginName);
+				if (index !== -1) {
+					this.plugins.splice(index, 1);
+					const instanceIndex = this.pluginsInstances.findIndex((instance) => {
+						return instance.constructor.pluginName === plugin.pluginName;
+					});
+					if (instanceIndex !== -1) {
+						const oldInstance = this.pluginsInstances[instanceIndex];
+						if (oldInstance instanceof KernelPlugin) {
+							const decoratorNames = oldInstance.getRegisteredDecorators();
+							for (const decoratorName of decoratorNames) {
+								this.unregisterDecorator(decoratorName);
+								this.logger.debug(`🧨 Cleanup: decorator "${decoratorName}"`);
+							}
+						}
+						if (oldInstance.destroy) oldInstance.destroy();
+						this.pluginsInstances.splice(instanceIndex, 1);
+					}
+				}
+			} else throw new Error(`Plugin with name "${plugin.pluginName}" is already registered with a different implementation.`);
+			else {
+				if (config !== void 0) this.pluginsConfig.set(plugin, config);
+				return this;
+			}
+			this.pluginsConfig.set(plugin, config || {});
+			this.plugins.push(plugin);
+			this.logger.debug(`🔌 Plugin: ${plugin.pluginName}`);
+			return this;
+		}
+		registerPlugins(plugins) {
+			for (const plugin of plugins) if (Array.isArray(plugin)) this.registerPlugin(plugin[0], plugin[1]);
+			else this.registerPlugin(plugin);
+			this.logger.debug(`🔌 Registered ${plugins.length} plugins`);
+			return this;
+		}
+		registerNodes(nodes) {
+			const nodeTypes = nodes.map((node) => {
+				if (typeof node === "function" && node.getType) return node.getType();
+				else if (typeof node === "object" && node.replace && typeof node.replace === "function" && node.replace.getType) return node.replace.getType();
+				return "unknown";
+			}).filter((type) => type !== "unknown");
+			this.nodes.push(...nodes);
+			if (nodeTypes.length > 3) this.logger.debug(`🧩 Nodes: ${nodeTypes.length} types`);
+			else this.logger.debug(`🧩 Nodes: ${nodeTypes.join(", ")}`);
+		}
+		registerNodeTransform(transform) {
+			this.nodeTransforms.push(transform);
+			return () => {
+				this.nodeTransforms = this.nodeTransforms.filter((item) => item !== transform);
+			};
+		}
+		registerBeforeEditorInit(hook) {
+			this.beforeEditorInitHooks.push(hook);
+			return () => {
+				this.beforeEditorInitHooks = this.beforeEditorInitHooks.filter((item) => item !== hook);
+			};
+		}
+		registerRootClassName(className) {
+			const classNames = className.split(/\s+/).filter(Boolean);
+			for (const item of classNames) this.rootClassNames.add(item);
+			const rootElement = this.editor?.getRootElement();
+			if (rootElement) rootElement.classList.add(...classNames);
+			return () => {
+				for (const item of classNames) this.rootClassNames.delete(item);
+				const currentRootElement = this.editor?.getRootElement();
+				if (currentRootElement) currentRootElement.classList.remove(...classNames);
+			};
+		}
+		runBeforeEditorInitLifecycle() {
+			for (const hook of this.beforeEditorInitHooks) hook();
+		}
+		applyRootClassNames(dom) {
+			if (this.rootClassNames.size === 0) return;
+			dom.classList.add(...Array.from(this.rootClassNames));
+		}
+		resolveNodesForInitialization() {
+			const resolvedNodes = this.nodes.flatMap((node, index) => {
+				let transformedNode = node;
+				for (const transform of this.nodeTransforms) {
+					transformedNode = transform(transformedNode, index);
+					if (!transformedNode) return [];
+				}
+				return [transformedNode];
+			});
+			if (resolvedNodes.length !== this.nodes.length) this.logger.debug(`🧩 Node transform filtered ${this.nodes.length - resolvedNodes.length} nodes before editor initialization`);
+			return resolvedNodes;
+		}
+		registerService(serviceId, service) {
+			const serviceIdString = serviceId.__serviceId;
+			if (this.serviceMap.has(serviceIdString)) if (this.hotReloadMode) {
+				this.logger.warn(`🔄 Hot reload: service "${serviceIdString}"`);
+				this.serviceMap.set(serviceIdString, service);
+				return;
+			} else {
+				if (this.serviceMap.get(serviceIdString) === service) {
+					this.logger.warn(`[Editor] Service "${serviceIdString}" is already registered with the same instance`);
+					return;
+				}
+				this.logger.error(`[Editor] Attempting to register duplicate service "${serviceIdString}". Enable hot reload mode if this is intended.`);
+				throw new Error(`Service with ID "${serviceIdString}" is already registered.`);
+			}
+			this.serviceMap.set(serviceIdString, service);
+			this.logger.debug(`🔧 Service: ${serviceIdString}`);
+		}
+		/**
+		* Register service with hot reload support - allows overriding existing services
+		* @param serviceId Service identifier
+		* @param service Service instance
+		*/
+		registerServiceHotReload(serviceId, service) {
+			this.serviceMap.set(serviceId.__serviceId, service);
+			this.logger.debug(`🔄 Hot-reload service: ${serviceId.__serviceId}`);
+		}
+		/**
+		* Enable or disable hot reload mode
+		* @param enabled Whether to enable hot reload mode
+		*/
+		setHotReloadMode(enabled) {
+			this.hotReloadMode = enabled;
+		}
+		/**
+		* Check if hot reload mode is enabled
+		*/
+		isHotReloadMode() {
+			return this.hotReloadMode;
+		}
+		/**
+		* Get service
+		* @param serviceId Service ID
+		*/
+		requireService(serviceId) {
+			const service = this.serviceMap.get(serviceId.__serviceId);
+			if (!service) return null;
+			return service;
+		}
+		dispatchCommand(type, payload) {
+			if (!this.editor) throw new Error("Editor is not initialized.");
+			return this.editor.dispatchCommand(type, payload);
+		}
+		getTheme() {
+			return this.themes;
+		}
+		updateTheme(key, value) {
+			this.themes[key] = value;
+		}
+		registerLocale(locale) {
+			const localeKeys = Object.keys(locale);
+			this.localeMap = merge(this.localeMap, locale);
+			this.logger.debug(`🌐 Locale: ${localeKeys.length} keys`);
+		}
+		t(key, params) {
+			let translation = get(this.localeMap, key) || key;
+			if (params) translation = template(translation)(params);
+			return translation;
+		}
+		get isEmpty() {
+			if (!this.editor) return true;
+			return this.editor.getEditorState().read(() => {
+				return $isRootTextContentEmpty(this.editor.isComposing(), true);
+			});
+		}
+		get isSelected() {
+			if (!this.editor) return false;
+			return this.editor.getEditorState().read(() => {
+				const selection = $getSelection();
+				if ($isRangeSelection(selection)) return !!selection._cachedNodes;
+				return false;
+			});
+		}
+		cleanDocument() {
+			this.setDocument("text", "");
+		}
+		registerHotkey(hotkeyId, callback, options = {}) {
+			const lexicalEditor = this.editor;
+			if (!lexicalEditor) throw new Error("Editor is not initialized.");
+			const hotkey = getHotkeyById(hotkeyId);
+			if (!hotkey) return () => false;
+			if (options.enabled === false) return () => false;
+			this.logger.debug(`⌨️ Hotkey: ${hotkey.id}`);
+			return lexicalEditor.registerCommand(KEY_DOWN_COMMAND, registerHotkey(hotkey, callback, options), hotkey.priority);
+		}
+		registerHighCommand(command, listener, priority) {
+			const lexicalEditor = this.editor;
+			if (!lexicalEditor) throw new Error("Editor is not initialized.");
+			const commandsMap = this._commands;
+			if (!commandsMap.has(command)) {
+				commandsMap.set(command, [
+					/* @__PURE__ */ new Set(),
+					/* @__PURE__ */ new Set(),
+					/* @__PURE__ */ new Set(),
+					/* @__PURE__ */ new Set(),
+					/* @__PURE__ */ new Set()
+				]);
+				this._commandsClean.set(command, lexicalEditor.registerCommand(command, (payload) => {
+					for (let i = 4; i >= 0; i--) {
+						const listenerInPriorityOrder = this._commands.get(command);
+						if (listenerInPriorityOrder !== void 0) {
+							const listenersSet = listenerInPriorityOrder[i];
+							for (const listener of listenersSet) if (listener(payload, lexicalEditor)) return true;
+						}
+					}
+					return false;
+				}, COMMAND_PRIORITY_CRITICAL));
+				if (!command.type?.includes("KEY")) this.logger.debug(`⚡ Command: ${command.type || "unknown"}`);
+			}
+			const listenersInPriorityOrder = commandsMap.get(command);
+			if (listenersInPriorityOrder === void 0) return noop;
+			const listeners = listenersInPriorityOrder[priority];
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+				if (listenersInPriorityOrder.every((listenersSet) => listenersSet.size === 0)) {
+					commandsMap.delete(command);
+					this._commandsClean.get(command)?.();
+				}
+			};
+		}
+	};
+}));
+//#endregion
+init_kernel();
+export { Kernel, init_kernel, kernel_exports };