@jvs-milkdown/core 1.0.0

package/lib/index.js

@@ -0,0 +1,676 @@
+import { Clock, Container, Ctx, createSlice, createTimer } from "@jvs-milkdown/ctx";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+import { callCommandBeforeEditorView, ctxCallOutOfScope, docTypeError } from "@jvs-milkdown/exception";
+import { baseKeymap, chainCommands, deleteSelection, joinTextblockBackward, selectNodeBackward } from "@jvs-milkdown/prose/commands";
+import { DOMParser, Node, Schema } from "@jvs-milkdown/prose/model";
+import { customInputRules } from "@jvs-milkdown/prose";
+import { keymap as keymap$1 } from "@jvs-milkdown/prose/keymap";
+import { EditorState, Plugin, PluginKey } from "@jvs-milkdown/prose/state";
+import { undoInputRule } from "@jvs-milkdown/prose/inputrules";
+import { ParserState, SerializerState } from "@jvs-milkdown/transformer";
+import { EditorView } from "@jvs-milkdown/prose/view";
+//#region src/__internal__/utils.ts
+function withMeta(plugin, meta) {
+	plugin.meta = {
+		package: "@jvs-milkdown/core",
+		group: "System",
+		...meta
+	};
+	return plugin;
+}
+//#endregion
+//#region src/__internal__/remark-handlers.ts
+var remarkHandlers = {
+	text: (node, _, state, info) => {
+		const value = node.value;
+		if (/^[^*_\\]*\s+$/.test(value)) return value;
+		return state.safe(value, {
+			...info,
+			encode: []
+		});
+	},
+	strong: (node, _, state, info) => {
+		const marker = node.marker || state.options.strong || "*";
+		const exit = state.enter("strong");
+		const tracker = state.createTracker(info);
+		let value = tracker.move(marker + marker);
+		value += tracker.move(state.containerPhrasing(node, {
+			before: value,
+			after: marker,
+			...tracker.current()
+		}));
+		value += tracker.move(marker + marker);
+		exit();
+		return value;
+	},
+	emphasis: (node, _, state, info) => {
+		const marker = node.marker || state.options.emphasis || "*";
+		const exit = state.enter("emphasis");
+		const tracker = state.createTracker(info);
+		let value = tracker.move(marker);
+		value += tracker.move(state.containerPhrasing(node, {
+			before: value,
+			after: marker,
+			...tracker.current()
+		}));
+		value += tracker.move(marker);
+		exit();
+		return value;
+	}
+};
+//#endregion
+//#region src/internal-plugin/atoms.ts
+var editorViewCtx = createSlice({}, "editorView");
+var editorStateCtx = createSlice({}, "editorState");
+var initTimerCtx = createSlice([], "initTimer");
+var editorCtx = createSlice({}, "editor");
+var inputRulesCtx = createSlice([], "inputRules");
+var prosePluginsCtx = createSlice([], "prosePlugins");
+var remarkPluginsCtx = createSlice([], "remarkPlugins");
+var nodeViewCtx = createSlice([], "nodeView");
+var markViewCtx = createSlice([], "markView");
+var remarkCtx = createSlice(unified().use(remarkParse).use(remarkStringify), "remark");
+var remarkStringifyOptionsCtx = createSlice({
+	handlers: remarkHandlers,
+	encode: []
+}, "remarkStringifyOptions");
+//#endregion
+//#region src/internal-plugin/config.ts
+var ConfigReady = createTimer("ConfigReady");
+function config(configure) {
+	const plugin = (ctx) => {
+		ctx.record(ConfigReady);
+		return async () => {
+			await configure(ctx);
+			ctx.done(ConfigReady);
+			return () => {
+				ctx.clearTimer(ConfigReady);
+			};
+		};
+	};
+	withMeta(plugin, { displayName: "Config" });
+	return plugin;
+}
+//#endregion
+//#region src/internal-plugin/init.ts
+var InitReady = createTimer("InitReady");
+function init(editor) {
+	const plugin = (ctx) => {
+		ctx.inject(editorCtx, editor).inject(prosePluginsCtx, []).inject(remarkPluginsCtx, []).inject(inputRulesCtx, []).inject(nodeViewCtx, []).inject(markViewCtx, []).inject(remarkStringifyOptionsCtx, {
+			handlers: remarkHandlers,
+			encode: []
+		}).inject(remarkCtx, unified().use(remarkParse).use(remarkStringify)).inject(initTimerCtx, [ConfigReady]).record(InitReady);
+		return async () => {
+			await ctx.waitTimers(initTimerCtx);
+			const options = ctx.get(remarkStringifyOptionsCtx);
+			ctx.set(remarkCtx, unified().use(remarkParse).use(remarkStringify, options));
+			ctx.done(InitReady);
+			return () => {
+				ctx.remove(editorCtx).remove(prosePluginsCtx).remove(remarkPluginsCtx).remove(inputRulesCtx).remove(nodeViewCtx).remove(markViewCtx).remove(remarkStringifyOptionsCtx).remove(remarkCtx).remove(initTimerCtx).clearTimer(InitReady);
+			};
+		};
+	};
+	withMeta(plugin, { displayName: "Init" });
+	return plugin;
+}
+//#endregion
+//#region src/internal-plugin/schema.ts
+var SchemaReady = createTimer("SchemaReady");
+var schemaTimerCtx = createSlice([], "schemaTimer");
+var schemaCtx = createSlice({}, "schema");
+var nodesCtx = createSlice([], "nodes");
+var marksCtx = createSlice([], "marks");
+function extendPriority(x) {
+	return {
+		...x,
+		parseDOM: x.parseDOM?.map((rule) => ({
+			priority: x.priority,
+			...rule
+		}))
+	};
+}
+var schema = (ctx) => {
+	ctx.inject(schemaCtx, {}).inject(nodesCtx, []).inject(marksCtx, []).inject(schemaTimerCtx, [InitReady]).record(SchemaReady);
+	return async () => {
+		await ctx.waitTimers(schemaTimerCtx);
+		const remark = ctx.get(remarkCtx);
+		const processor = ctx.get(remarkPluginsCtx).reduce((acc, plug) => acc.use(plug.plugin, plug.options), remark);
+		ctx.set(remarkCtx, processor);
+		const schema = new Schema({
+			nodes: Object.fromEntries(ctx.get(nodesCtx).map(([key, x]) => [key, extendPriority(x)])),
+			marks: Object.fromEntries(ctx.get(marksCtx).map(([key, x]) => [key, extendPriority(x)]))
+		});
+		ctx.set(schemaCtx, schema);
+		ctx.done(SchemaReady);
+		return () => {
+			ctx.remove(schemaCtx).remove(nodesCtx).remove(marksCtx).remove(schemaTimerCtx).clearTimer(SchemaReady);
+		};
+	};
+};
+withMeta(schema, { displayName: "Schema" });
+//#endregion
+//#region src/internal-plugin/commands.ts
+var CommandManager = class {
+	constructor() {
+		this.setCtx = (ctx) => {
+			this.#ctx = ctx;
+		};
+		this.chain = () => {
+			if (this.#ctx == null) throw callCommandBeforeEditorView();
+			const ctx = this.#ctx;
+			const commands = [];
+			const get = this.get.bind(this);
+			const chains = {
+				run: () => {
+					const chained = chainCommands(...commands);
+					const view = ctx.get(editorViewCtx);
+					return chained(view.state, view.dispatch, view);
+				},
+				inline: (command) => {
+					commands.push(command);
+					return chains;
+				},
+				pipe: pipe.bind(this)
+			};
+			function pipe(slice, payload) {
+				const cmd = get(slice);
+				commands.push(cmd(payload));
+				return chains;
+			}
+			return chains;
+		};
+	}
+	#container = new Container();
+	#ctx = null;
+	get ctx() {
+		return this.#ctx;
+	}
+	create(meta, value) {
+		const slice = meta.create(this.#container.sliceMap);
+		slice.set(value);
+		return slice;
+	}
+	get(slice) {
+		return this.#container.get(slice).get();
+	}
+	remove(slice) {
+		return this.#container.remove(slice);
+	}
+	call(slice, payload) {
+		if (this.#ctx == null) throw callCommandBeforeEditorView();
+		const command = this.get(slice)(payload);
+		const view = this.#ctx.get(editorViewCtx);
+		return command(view.state, view.dispatch, view);
+	}
+	inline(command) {
+		if (this.#ctx == null) throw callCommandBeforeEditorView();
+		const view = this.#ctx.get(editorViewCtx);
+		return command(view.state, view.dispatch, view);
+	}
+};
+function createCmdKey(key = "cmdKey") {
+	return createSlice((() => () => false), key);
+}
+var commandsCtx = createSlice(new CommandManager(), "commands");
+var commandsTimerCtx = createSlice([SchemaReady], "commandsTimer");
+var CommandsReady = createTimer("CommandsReady");
+var commands = (ctx) => {
+	const cmd = new CommandManager();
+	cmd.setCtx(ctx);
+	ctx.inject(commandsCtx, cmd).inject(commandsTimerCtx, [SchemaReady]).record(CommandsReady);
+	return async () => {
+		await ctx.waitTimers(commandsTimerCtx);
+		ctx.done(CommandsReady);
+		return () => {
+			ctx.remove(commandsCtx).remove(commandsTimerCtx).clearTimer(CommandsReady);
+		};
+	};
+};
+withMeta(commands, { displayName: "Commands" });
+//#endregion
+//#region src/internal-plugin/keymap.ts
+function overrideBaseKeymap(keymap) {
+	keymap.Backspace = chainCommands(undoInputRule, deleteSelection, joinTextblockBackward, selectNodeBackward);
+	return keymap;
+}
+var KeymapManager = class {
+	constructor() {
+		this.setCtx = (ctx) => {
+			this.#ctx = ctx;
+		};
+		this.add = (keymap) => {
+			this.#keymap.push(keymap);
+			return () => {
+				this.#keymap = this.#keymap.filter((item) => item !== keymap);
+			};
+		};
+		this.addObjectKeymap = (keymaps) => {
+			const remove = [];
+			Object.entries(keymaps).forEach(([key, command]) => {
+				if (typeof command === "function") {
+					const keymapItem = {
+						key,
+						onRun: () => command
+					};
+					this.#keymap.push(keymapItem);
+					remove.push(() => {
+						this.#keymap = this.#keymap.filter((item) => item !== keymapItem);
+					});
+				} else {
+					this.#keymap.push(command);
+					remove.push(() => {
+						this.#keymap = this.#keymap.filter((item) => item !== command);
+					});
+				}
+			});
+			return () => {
+				remove.forEach((fn) => fn());
+			};
+		};
+		this.addBaseKeymap = () => {
+			const base = overrideBaseKeymap(baseKeymap);
+			return this.addObjectKeymap(base);
+		};
+		this.build = () => {
+			const keymap = {};
+			this.#keymap.forEach((item) => {
+				keymap[item.key] = [...keymap[item.key] || [], item];
+			});
+			return Object.fromEntries(Object.entries(keymap).map(([key, items]) => {
+				const sortedItems = items.sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));
+				const command = (state, dispatch, view) => {
+					const ctx = this.#ctx;
+					if (ctx == null) throw ctxCallOutOfScope();
+					return chainCommands(...sortedItems.map((item) => item.onRun(ctx)))(state, dispatch, view);
+				};
+				return [key, command];
+			}));
+		};
+	}
+	#ctx = null;
+	#keymap = [];
+	get ctx() {
+		return this.#ctx;
+	}
+};
+var keymapCtx = createSlice(new KeymapManager(), "keymap");
+var keymapTimerCtx = createSlice([SchemaReady], "keymapTimer");
+var KeymapReady = createTimer("KeymapReady");
+var keymap = (ctx) => {
+	const km = new KeymapManager();
+	km.setCtx(ctx);
+	ctx.inject(keymapCtx, km).inject(keymapTimerCtx, [SchemaReady]).record(KeymapReady);
+	return async () => {
+		await ctx.waitTimers(keymapTimerCtx);
+		ctx.done(KeymapReady);
+		return () => {
+			ctx.remove(keymapCtx).remove(keymapTimerCtx).clearTimer(KeymapReady);
+		};
+	};
+};
+//#endregion
+//#region src/internal-plugin/parser.ts
+var ParserReady = createTimer("ParserReady");
+var outOfScope$1 = (() => {
+	throw ctxCallOutOfScope();
+});
+var parserCtx = createSlice(outOfScope$1, "parser");
+var parserTimerCtx = createSlice([], "parserTimer");
+var parser = (ctx) => {
+	ctx.inject(parserCtx, outOfScope$1).inject(parserTimerCtx, [SchemaReady]).record(ParserReady);
+	return async () => {
+		await ctx.waitTimers(parserTimerCtx);
+		const remark = ctx.get(remarkCtx);
+		const schema = ctx.get(schemaCtx);
+		ctx.set(parserCtx, ParserState.create(schema, remark));
+		ctx.done(ParserReady);
+		return () => {
+			ctx.remove(parserCtx).remove(parserTimerCtx).clearTimer(ParserReady);
+		};
+	};
+};
+withMeta(parser, { displayName: "Parser" });
+//#endregion
+//#region src/internal-plugin/serializer.ts
+var SerializerReady = createTimer("SerializerReady");
+var serializerTimerCtx = createSlice([], "serializerTimer");
+var outOfScope = (() => {
+	throw ctxCallOutOfScope();
+});
+var serializerCtx = createSlice(outOfScope, "serializer");
+var serializer = (ctx) => {
+	ctx.inject(serializerCtx, outOfScope).inject(serializerTimerCtx, [SchemaReady]).record(SerializerReady);
+	return async () => {
+		await ctx.waitTimers(serializerTimerCtx);
+		const remark = ctx.get(remarkCtx);
+		const schema = ctx.get(schemaCtx);
+		ctx.set(serializerCtx, SerializerState.create(schema, remark));
+		ctx.done(SerializerReady);
+		return () => {
+			ctx.remove(serializerCtx).remove(serializerTimerCtx).clearTimer(SerializerReady);
+		};
+	};
+};
+withMeta(serializer, { displayName: "Serializer" });
+//#endregion
+//#region src/internal-plugin/editor-state.ts
+var defaultValueCtx = createSlice("", "defaultValue");
+var editorStateOptionsCtx = createSlice((x) => x, "stateOptions");
+var editorStateTimerCtx = createSlice([], "editorStateTimer");
+var EditorStateReady = createTimer("EditorStateReady");
+function getDoc(defaultValue, parser, schema) {
+	if (typeof defaultValue === "string") return parser(defaultValue);
+	if (defaultValue.type === "html") return DOMParser.fromSchema(schema).parse(defaultValue.dom);
+	if (defaultValue.type === "json") return Node.fromJSON(schema, defaultValue.value);
+	throw docTypeError(defaultValue);
+}
+var key$1 = new PluginKey("MILKDOWN_STATE_TRACKER");
+var editorState = (ctx) => {
+	ctx.inject(defaultValueCtx, "").inject(editorStateCtx, {}).inject(editorStateOptionsCtx, (x) => x).inject(editorStateTimerCtx, [
+		ParserReady,
+		SerializerReady,
+		CommandsReady,
+		KeymapReady
+	]).record(EditorStateReady);
+	return async () => {
+		await ctx.waitTimers(editorStateTimerCtx);
+		const schema = ctx.get(schemaCtx);
+		const parser = ctx.get(parserCtx);
+		const rules = ctx.get(inputRulesCtx);
+		const optionsOverride = ctx.get(editorStateOptionsCtx);
+		const prosePlugins = ctx.get(prosePluginsCtx);
+		const doc = getDoc(ctx.get(defaultValueCtx), parser, schema);
+		const km = ctx.get(keymapCtx);
+		const disposeBaseKeymap = km.addBaseKeymap();
+		const plugins = [
+			...prosePlugins,
+			new Plugin({
+				key: key$1,
+				state: {
+					init: () => {},
+					apply: (_tr, _value, _oldState, newState) => {
+						ctx.set(editorStateCtx, newState);
+					}
+				}
+			}),
+			customInputRules({ rules }),
+			keymap$1(km.build())
+		];
+		ctx.set(prosePluginsCtx, plugins);
+		const options = optionsOverride({
+			schema,
+			doc,
+			plugins
+		});
+		const state = EditorState.create(options);
+		ctx.set(editorStateCtx, state);
+		ctx.done(EditorStateReady);
+		return () => {
+			disposeBaseKeymap();
+			ctx.remove(defaultValueCtx).remove(editorStateCtx).remove(editorStateOptionsCtx).remove(editorStateTimerCtx).clearTimer(EditorStateReady);
+		};
+	};
+};
+withMeta(editorState, { displayName: "EditorState" });
+//#endregion
+//#region src/internal-plugin/paste-rule.ts
+var pasteRulesCtx = createSlice([], "pasteRule");
+var pasteRulesTimerCtx = createSlice([SchemaReady], "pasteRuleTimer");
+var PasteRulesReady = createTimer("PasteRuleReady");
+var pasteRule = (ctx) => {
+	ctx.inject(pasteRulesCtx, []).inject(pasteRulesTimerCtx, [SchemaReady]).record(PasteRulesReady);
+	return async () => {
+		await ctx.waitTimers(pasteRulesTimerCtx);
+		ctx.done(PasteRulesReady);
+		return () => {
+			ctx.remove(pasteRulesCtx).remove(pasteRulesTimerCtx).clearTimer(PasteRulesReady);
+		};
+	};
+};
+withMeta(pasteRule, { displayName: "PasteRule" });
+//#endregion
+//#region src/internal-plugin/editor-view.ts
+var EditorViewReady = createTimer("EditorViewReady");
+var editorViewTimerCtx = createSlice([], "editorViewTimer");
+var editorViewOptionsCtx = createSlice({}, "editorViewOptions");
+var rootCtx = createSlice(null, "root");
+var rootDOMCtx = createSlice(null, "rootDOM");
+var rootAttrsCtx = createSlice({}, "rootAttrs");
+function createViewContainer(root, ctx) {
+	const container = document.createElement("div");
+	container.className = "milkdown";
+	root.appendChild(container);
+	ctx.set(rootDOMCtx, container);
+	const attrs = ctx.get(rootAttrsCtx);
+	Object.entries(attrs).forEach(([key, value]) => container.setAttribute(key, value));
+	return container;
+}
+function prepareViewDom(dom) {
+	dom.classList.add("editor");
+	dom.setAttribute("role", "textbox");
+}
+var key = new PluginKey("MILKDOWN_VIEW_CLEAR");
+var editorView = (ctx) => {
+	ctx.inject(rootCtx, document.body).inject(editorViewCtx, {}).inject(editorViewOptionsCtx, {}).inject(rootDOMCtx, null).inject(rootAttrsCtx, {}).inject(editorViewTimerCtx, [EditorStateReady, PasteRulesReady]).record(EditorViewReady);
+	return async () => {
+		await ctx.wait(InitReady);
+		const root = ctx.get(rootCtx) || document.body;
+		const el = typeof root === "string" ? document.querySelector(root) : root;
+		ctx.update(prosePluginsCtx, (xs) => [new Plugin({
+			key,
+			view: (editorView) => {
+				const container = el ? createViewContainer(el, ctx) : void 0;
+				const handleDOM = () => {
+					if (container && el) {
+						const editor = editorView.dom;
+						el.replaceChild(container, editor);
+						container.appendChild(editor);
+					}
+				};
+				handleDOM();
+				return { destroy: () => {
+					if (container?.parentNode) container?.parentNode.replaceChild(editorView.dom, container);
+					container?.remove();
+				} };
+			}
+		}), ...xs]);
+		await ctx.waitTimers(editorViewTimerCtx);
+		const state = ctx.get(editorStateCtx);
+		const options = ctx.get(editorViewOptionsCtx);
+		const view = new EditorView(el, {
+			state,
+			nodeViews: Object.fromEntries(ctx.get(nodeViewCtx)),
+			markViews: Object.fromEntries(ctx.get(markViewCtx)),
+			transformPasted: (slice, view, isPlainText) => {
+				ctx.get(pasteRulesCtx).sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50)).map((rule) => rule.run).forEach((runner) => {
+					slice = runner(slice, view, isPlainText);
+				});
+				return slice;
+			},
+			...options
+		});
+		prepareViewDom(view.dom);
+		ctx.set(editorViewCtx, view);
+		ctx.done(EditorViewReady);
+		return () => {
+			view?.destroy();
+			ctx.remove(rootCtx).remove(editorViewCtx).remove(editorViewOptionsCtx).remove(rootDOMCtx).remove(rootAttrsCtx).remove(editorViewTimerCtx).clearTimer(EditorViewReady);
+		};
+	};
+};
+withMeta(editorView, { displayName: "EditorView" });
+//#endregion
+//#region src/editor/editor.ts
+var EditorStatus = /* @__PURE__ */ function(EditorStatus) {
+	EditorStatus["Idle"] = "Idle";
+	EditorStatus["OnCreate"] = "OnCreate";
+	EditorStatus["Created"] = "Created";
+	EditorStatus["OnDestroy"] = "OnDestroy";
+	EditorStatus["Destroyed"] = "Destroyed";
+	return EditorStatus;
+}({});
+var Editor = class Editor {
+	constructor() {
+		this.enableInspector = (enable = true) => {
+			this.#enableInspector = enable;
+			return this;
+		};
+		this.onStatusChange = (onChange) => {
+			this.#onStatusChange = onChange;
+			return this;
+		};
+		this.config = (configure) => {
+			this.#configureList.push(configure);
+			return this;
+		};
+		this.removeConfig = (configure) => {
+			this.#configureList = this.#configureList.filter((x) => x !== configure);
+			return this;
+		};
+		this.use = (plugins) => {
+			const _plugins = [plugins].flat();
+			_plugins.flat().forEach((plugin) => {
+				this.#usrPluginStore.set(plugin, {
+					ctx: void 0,
+					handler: void 0,
+					cleanup: void 0
+				});
+			});
+			if (this.#status === EditorStatus.Created) this.#prepare(_plugins, this.#usrPluginStore);
+			return this;
+		};
+		this.remove = async (plugins) => {
+			if (this.#status === EditorStatus.OnCreate) {
+				console.warn("[Milkdown]: You are trying to remove plugins when the editor is creating, this is not recommended, please check your code.");
+				return new Promise((resolve) => {
+					setTimeout(() => {
+						resolve(this.remove(plugins));
+					}, 50);
+				});
+			}
+			await this.#cleanup([plugins].flat(), true);
+			return this;
+		};
+		this.create = async () => {
+			if (this.#status === EditorStatus.OnCreate) return this;
+			if (this.#status === EditorStatus.Created) await this.destroy();
+			this.#setStatus(EditorStatus.OnCreate);
+			this.#loadInternal();
+			this.#prepare([...this.#usrPluginStore.keys()], this.#usrPluginStore);
+			await Promise.all([this.#loadPluginInStore(this.#sysPluginStore), this.#loadPluginInStore(this.#usrPluginStore)].flat());
+			this.#setStatus(EditorStatus.Created);
+			return this;
+		};
+		this.destroy = async (clearPlugins = false) => {
+			if (this.#status === EditorStatus.Destroyed || this.#status === EditorStatus.OnDestroy) return this;
+			if (this.#status === EditorStatus.OnCreate) return new Promise((resolve) => {
+				setTimeout(() => {
+					resolve(this.destroy(clearPlugins));
+				}, 50);
+			});
+			if (clearPlugins) this.#configureList = [];
+			this.#setStatus(EditorStatus.OnDestroy);
+			await this.#cleanup([...this.#usrPluginStore.keys()], clearPlugins);
+			await this.#cleanupInternal();
+			this.#setStatus(EditorStatus.Destroyed);
+			return this;
+		};
+		this.action = (action) => action(this.#ctx);
+		this.inspect = () => {
+			if (!this.#enableInspector) {
+				console.warn("[Milkdown]: You are trying to collect inspection when inspector is disabled, please enable inspector by `editor.enableInspector()` first.");
+				return [];
+			}
+			return [...this.#sysPluginStore.values(), ...this.#usrPluginStore.values()].map(({ ctx }) => ctx?.inspector?.read()).filter((x) => Boolean(x));
+		};
+	}
+	static make() {
+		return new Editor();
+	}
+	#enableInspector = false;
+	#status = EditorStatus.Idle;
+	#configureList = [];
+	#onStatusChange = () => void 0;
+	#container = new Container();
+	#clock = new Clock();
+	#usrPluginStore = /* @__PURE__ */ new Map();
+	#sysPluginStore = /* @__PURE__ */ new Map();
+	#ctx = new Ctx(this.#container, this.#clock);
+	#loadInternal = () => {
+		const configPlugin = config(async (ctx) => {
+			await Promise.all(this.#configureList.map((fn) => Promise.resolve(fn(ctx))));
+		});
+		const internalPlugins = [
+			schema,
+			parser,
+			serializer,
+			commands,
+			keymap,
+			pasteRule,
+			editorState,
+			editorView,
+			init(this),
+			configPlugin
+		];
+		this.#prepare(internalPlugins, this.#sysPluginStore);
+	};
+	#prepare = (plugins, store) => {
+		plugins.forEach((plugin) => {
+			const ctx = this.#ctx.produce(this.#enableInspector ? plugin.meta : void 0);
+			const handler = plugin(ctx);
+			store.set(plugin, {
+				ctx,
+				handler,
+				cleanup: void 0
+			});
+		});
+	};
+	#cleanup = (plugins, remove = false) => {
+		return Promise.all([plugins].flat().map(async (plugin) => {
+			const cleanup = this.#usrPluginStore.get(plugin)?.cleanup;
+			if (remove) this.#usrPluginStore.delete(plugin);
+			else this.#usrPluginStore.set(plugin, {
+				ctx: void 0,
+				handler: void 0,
+				cleanup: void 0
+			});
+			if (typeof cleanup === "function") return cleanup();
+			return cleanup;
+		}));
+	};
+	#cleanupInternal = async () => {
+		await Promise.all([...this.#sysPluginStore.entries()].map(async ([_, { cleanup }]) => {
+			if (typeof cleanup === "function") return cleanup();
+			return cleanup;
+		}));
+		this.#sysPluginStore.clear();
+	};
+	#setStatus = (status) => {
+		this.#status = status;
+		this.#onStatusChange(status);
+	};
+	#loadPluginInStore = (store) => {
+		return [...store.entries()].map(async ([key, loader]) => {
+			const { ctx, handler } = loader;
+			if (!handler) return;
+			const cleanup = await handler();
+			store.set(key, {
+				ctx,
+				handler,
+				cleanup
+			});
+		});
+	};
+	get ctx() {
+		return this.#ctx;
+	}
+	get status() {
+		return this.#status;
+	}
+};
+//#endregion
+export { CommandManager, CommandsReady, ConfigReady, Editor, EditorStateReady, EditorStatus, EditorViewReady, InitReady, KeymapManager, KeymapReady, ParserReady, PasteRulesReady, SchemaReady, SerializerReady, commands, commandsCtx, commandsTimerCtx, config, createCmdKey, defaultValueCtx, editorCtx, editorState, editorStateCtx, editorStateOptionsCtx, editorStateTimerCtx, editorView, editorViewCtx, editorViewOptionsCtx, editorViewTimerCtx, getDoc, init, initTimerCtx, inputRulesCtx, keymap, keymapCtx, keymapTimerCtx, markViewCtx, marksCtx, nodeViewCtx, nodesCtx, parser, parserCtx, parserTimerCtx, pasteRule, pasteRulesCtx, pasteRulesTimerCtx, prosePluginsCtx, remarkCtx, remarkPluginsCtx, remarkStringifyOptionsCtx, rootAttrsCtx, rootCtx, rootDOMCtx, schema, schemaCtx, schemaTimerCtx, serializer, serializerCtx, serializerTimerCtx };
+
+//# sourceMappingURL=index.js.map