miyuan-editor 0.0.3

package/dist/react/index.esm.js

@@ -0,0 +1,820 @@
+import { fi as __commonJSMin, hi as __require } from "../prompt-B4AOP8f_.js";
+import { A as DOMParser, d as EditorState, m as PluginKey, p as Plugin } from "../dist-5Q_Z9Ell.js";
+import { n as DecorationSet, t as Decoration } from "../dist-CZw77IJK.js";
+import { r as EditorView, t as ExtensionManager } from "../extension-Cl6x5MDR.js";
+import { a as AIMenu$1, c as AIService, d as BubbleMenu$1, f as Toolbar$1, h as ensureStylesInjected, i as AIWriter$1, n as TocPanel$1, o as loadAIConfig, r as WordCountDisplay$1, t as ShortcutPanel$1, u as DragHandle$1 } from "../shortcut-panel-BskGXV8n.js";
+import { n as OPTIONAL_TOOLBAR_ITEMS, r as createToolbarConfig, t as DEFAULT_TOOLBAR_CONFIG } from "../toolbar-config-Cgc9mV2v.js";
+import { i as exportAsPlainText, n as exportAsJSON, r as exportAsMarkdown, t as exportAsHTML } from "../export-utils-DN0Gu8Vu.js";
+import { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, useState } from "react";
+//#region src/react/use-editor.ts
+/**
+* useEditor: React hook that creates and manages an EditorView backed by ProseMirror.
+*/
+function useEditor(options = {}) {
+	const { extensions = [], content, editable = true, onUpdate, onSelectionChange } = options;
+	const viewRef = useRef(null);
+	const managerRef = useRef(null);
+	const [, setVersion] = useState(0);
+	if (!managerRef.current) managerRef.current = new ExtensionManager(extensions);
+	const manager = managerRef.current;
+	const schema = manager.schema;
+	const createState = useCallback(() => {
+		let doc;
+		if (content) try {
+			const container = document.createElement("div");
+			container.innerHTML = content;
+			doc = DOMParser.fromSchema(schema).parse(container);
+		} catch {}
+		return EditorState.create({
+			schema,
+			doc,
+			plugins: manager.plugins
+		});
+	}, [
+		schema,
+		content,
+		manager.plugins
+	]);
+	const stateRef = useRef(null);
+	if (!stateRef.current) stateRef.current = createState();
+	const forceUpdate = useCallback(() => {
+		setVersion((v) => v + 1);
+	}, []);
+	const dispatchTransaction = useCallback((tr) => {
+		const view = viewRef.current;
+		if (!view) return;
+		const newState = view.state.apply(tr);
+		view.updateState(newState);
+		stateRef.current = newState;
+		if (onUpdate) onUpdate(newState);
+		if (onSelectionChange) onSelectionChange(newState);
+		forceUpdate();
+	}, [
+		onUpdate,
+		onSelectionChange,
+		forceUpdate
+	]);
+	const editableRef = useRef(editable);
+	editableRef.current = editable;
+	const createView = useCallback((element) => {
+		if (viewRef.current) return;
+		const view = new EditorView({
+			state: stateRef.current,
+			element,
+			editable: editableRef.current,
+			dispatchTransaction
+		});
+		viewRef.current = view;
+		stateRef.current = view.state;
+		forceUpdate();
+	}, [
+		editable,
+		dispatchTransaction,
+		forceUpdate
+	]);
+	useEffect(() => {
+		return () => {
+			if (viewRef.current) {
+				viewRef.current.destroy();
+				viewRef.current = null;
+			}
+		};
+	}, []);
+	return {
+		view: viewRef.current,
+		state: stateRef.current,
+		schema,
+		commands: manager.commands,
+		forceUpdate,
+		_createView: createView
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/react@19.2.7/node_modules/react/cjs/react-jsx-runtime.production.js
+/**
+* @license React
+* react-jsx-runtime.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_jsx_runtime_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+	function jsxProd(type, config, maybeKey) {
+		var key = null;
+		void 0 !== maybeKey && (key = "" + maybeKey);
+		void 0 !== config.key && (key = "" + config.key);
+		if ("key" in config) {
+			maybeKey = {};
+			for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+		} else maybeKey = config;
+		config = maybeKey.ref;
+		return {
+			$$typeof: REACT_ELEMENT_TYPE,
+			type,
+			key,
+			ref: void 0 !== config ? config : null,
+			props: maybeKey
+		};
+	}
+	exports.Fragment = REACT_FRAGMENT_TYPE;
+	exports.jsx = jsxProd;
+	exports.jsxs = jsxProd;
+}));
+//#endregion
+//#region node_modules/.pnpm/react@19.2.7/node_modules/react/cjs/react-jsx-runtime.development.js
+/**
+* @license React
+* react-jsx-runtime.development.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	"production" !== process.env.NODE_ENV && (function() {
+		function getComponentNameFromType(type) {
+			if (null == type) return null;
+			if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+			if ("string" === typeof type) return type;
+			switch (type) {
+				case REACT_FRAGMENT_TYPE: return "Fragment";
+				case REACT_PROFILER_TYPE: return "Profiler";
+				case REACT_STRICT_MODE_TYPE: return "StrictMode";
+				case REACT_SUSPENSE_TYPE: return "Suspense";
+				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
+				case REACT_ACTIVITY_TYPE: return "Activity";
+			}
+			if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+				case REACT_PORTAL_TYPE: return "Portal";
+				case REACT_CONTEXT_TYPE: return type.displayName || "Context";
+				case REACT_CONSUMER_TYPE: return (type._context.displayName || "Context") + ".Consumer";
+				case REACT_FORWARD_REF_TYPE:
+					var innerType = type.render;
+					type = type.displayName;
+					type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+					return type;
+				case REACT_MEMO_TYPE: return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+				case REACT_LAZY_TYPE:
+					innerType = type._payload;
+					type = type._init;
+					try {
+						return getComponentNameFromType(type(innerType));
+					} catch (x) {}
+			}
+			return null;
+		}
+		function testStringCoercion(value) {
+			return "" + value;
+		}
+		function checkKeyStringCoercion(value) {
+			try {
+				testStringCoercion(value);
+				var JSCompiler_inline_result = !1;
+			} catch (e) {
+				JSCompiler_inline_result = !0;
+			}
+			if (JSCompiler_inline_result) {
+				JSCompiler_inline_result = console;
+				var JSCompiler_temp_const = JSCompiler_inline_result.error;
+				var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+				JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+				return testStringCoercion(value);
+			}
+		}
+		function getTaskName(type) {
+			if (type === REACT_FRAGMENT_TYPE) return "<>";
+			if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+			try {
+				var name = getComponentNameFromType(type);
+				return name ? "<" + name + ">" : "<...>";
+			} catch (x) {
+				return "<...>";
+			}
+		}
+		function getOwner() {
+			var dispatcher = ReactSharedInternals.A;
+			return null === dispatcher ? null : dispatcher.getOwner();
+		}
+		function UnknownOwner() {
+			return Error("react-stack-top-frame");
+		}
+		function hasValidKey(config) {
+			if (hasOwnProperty.call(config, "key")) {
+				var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+				if (getter && getter.isReactWarning) return !1;
+			}
+			return void 0 !== config.key;
+		}
+		function defineKeyPropWarningGetter(props, displayName) {
+			function warnAboutAccessingKey() {
+				specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+			}
+			warnAboutAccessingKey.isReactWarning = !0;
+			Object.defineProperty(props, "key", {
+				get: warnAboutAccessingKey,
+				configurable: !0
+			});
+		}
+		function elementRefGetterWithDeprecationWarning() {
+			var componentName = getComponentNameFromType(this.type);
+			didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+			componentName = this.props.ref;
+			return void 0 !== componentName ? componentName : null;
+		}
+		function ReactElement(type, key, props, owner, debugStack, debugTask) {
+			var refProp = props.ref;
+			type = {
+				$$typeof: REACT_ELEMENT_TYPE,
+				type,
+				key,
+				props,
+				_owner: owner
+			};
+			null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				get: elementRefGetterWithDeprecationWarning
+			}) : Object.defineProperty(type, "ref", {
+				enumerable: !1,
+				value: null
+			});
+			type._store = {};
+			Object.defineProperty(type._store, "validated", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: 0
+			});
+			Object.defineProperty(type, "_debugInfo", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: null
+			});
+			Object.defineProperty(type, "_debugStack", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugStack
+			});
+			Object.defineProperty(type, "_debugTask", {
+				configurable: !1,
+				enumerable: !1,
+				writable: !0,
+				value: debugTask
+			});
+			Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+			return type;
+		}
+		function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+			var children = config.children;
+			if (void 0 !== children) if (isStaticChildren) if (isArrayImpl(children)) {
+				for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++) validateChildKeys(children[isStaticChildren]);
+				Object.freeze && Object.freeze(children);
+			} else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+			else validateChildKeys(children);
+			if (hasOwnProperty.call(config, "key")) {
+				children = getComponentNameFromType(type);
+				var keys = Object.keys(config).filter(function(k) {
+					return "key" !== k;
+				});
+				isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+				didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error("A props object containing a \"key\" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />", isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = !0);
+			}
+			children = null;
+			void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+			hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+			if ("key" in config) {
+				maybeKey = {};
+				for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+			} else maybeKey = config;
+			children && defineKeyPropWarningGetter(maybeKey, "function" === typeof type ? type.displayName || type.name || "Unknown" : type);
+			return ReactElement(type, children, maybeKey, getOwner(), debugStack, debugTask);
+		}
+		function validateChildKeys(node) {
+			isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+		}
+		function isValidElement(object) {
+			return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		var React = __require("react"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+			return null;
+		};
+		React = { react_stack_bottom_frame: function(callStackForError) {
+			return callStackForError();
+		} };
+		var specialPropKeyWarningShown;
+		var didWarnAboutElementRef = {};
+		var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(React, UnknownOwner)();
+		var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+		var didWarnAboutKeySpread = {};
+		exports.Fragment = REACT_FRAGMENT_TYPE;
+		exports.jsx = function(type, config, maybeKey) {
+			var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+			return jsxDEVImpl(type, config, maybeKey, !1, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+		};
+		exports.jsxs = function(type, config, maybeKey) {
+			var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+			return jsxDEVImpl(type, config, maybeKey, !0, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+		};
+	})();
+}));
+//#endregion
+//#region src/react/editor-content.tsx
+var import_jsx_runtime = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_react_jsx_runtime_production();
+	else module.exports = require_react_jsx_runtime_development();
+})))();
+function createEditorAdapter(editor) {
+	return {
+		getView: () => editor.view,
+		getState: () => editor.state,
+		getSchema: () => editor.schema,
+		getCommands: () => editor.commands
+	};
+}
+function EditorContent({ editor, className, style }) {
+	const containerRef = useRef(null);
+	useEffect(() => {
+		const el = containerRef.current;
+		if (!el) return;
+		ensureStylesInjected();
+		editor._createView(el);
+	}, [editor]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className,
+		style
+	});
+}
+//#endregion
+//#region src/react/bubble-menu.tsx
+function BubbleMenu({ editor, className }) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new BubbleMenu$1(createEditorAdapter(editor));
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+}
+//#endregion
+//#region src/react/ai-menu.tsx
+var AIMenu = forwardRef(function AIMenu({ editor, className }, ref) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new AIMenu$1(createEditorAdapter(editor));
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	useImperativeHandle(ref, () => ({ open: () => compRef.current?.open() }), []);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+});
+//#endregion
+//#region src/react/ai-writer.tsx
+var AIWriter = forwardRef(function AIWriter({ editor, className }, ref) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new AIWriter$1(createEditorAdapter(editor));
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	useImperativeHandle(ref, () => ({
+		open: () => compRef.current?.open(),
+		openProductCard: () => compRef.current?.openProductCard()
+	}), []);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+});
+//#endregion
+//#region src/react/toolbar.tsx
+function Toolbar({ editor, className }) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new Toolbar$1(createEditorAdapter(editor));
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	useEffect(() => {
+		compRef.current?.update();
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+}
+//#endregion
+//#region src/react/drag-handle.tsx
+function DragHandle({ editor, className }) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new DragHandle$1(createEditorAdapter(editor));
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+}
+//#endregion
+//#region src/ai/autocomplete.ts
+var autocompleteKey = new PluginKey("aiAutocomplete");
+var DEFAULT_SYSTEM_PROMPT = `你是一个文本补全助手。根据用户提供的上下文，自然地续写接下来的内容。
+规则：
+1. 只输出需要补全的内容，不要重复已有文本
+2. 保持与上下文一致的语言、风格和语气
+3. 补全内容应该简短自然，通常1-2句话即可
+4. 不要输出任何解释、标记或格式符号
+5. 如果上下文不完整，补全当前句子；如果已经完整，可以续写下一句`;
+function getContextBeforeCursor(state, maxChars) {
+	const { from } = state.selection;
+	const startPos = Math.max(0, from - maxChars);
+	return {
+		text: state.doc.textBetween(startPos, from, " ", "").slice(-maxChars),
+		pos: from
+	};
+}
+function shouldTrigger(text, minLen) {
+	if (text.length < minLen) return false;
+	const lastChar = text.slice(-1);
+	if (lastChar === "\n" || lastChar === " ") return false;
+	return true;
+}
+function createGhostTextDecoration(pos, text) {
+	const span = document.createElement("span");
+	span.className = "mi-ai-ghost-text";
+	span.textContent = text;
+	span.style.cssText = "color: #aaa; pointer-events: none; font-style: italic; opacity: 0.7;";
+	return Decoration.widget(pos, span, { key: "ai-ghost" });
+}
+function createAutocompletePlugin(config) {
+	const { getService, debounceMs = 800, minTriggerLength = 4, maxContextChars = 500, systemPrompt = DEFAULT_SYSTEM_PROMPT, enabled: initialEnabled = true } = config;
+	let debounceTimer = null;
+	let abortController = null;
+	let currentSuggestion = "";
+	let isEnabled = initialEnabled;
+	let lastTriggerPos = -1;
+	function clearPending() {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+		if (abortController) {
+			abortController.abort();
+			abortController = null;
+		}
+		currentSuggestion = "";
+	}
+	async function requestCompletion(context, view) {
+		const service = getService();
+		if (!service) return;
+		if (abortController) abortController.abort();
+		abortController = new AbortController();
+		currentSuggestion = "";
+		try {
+			await service.streamChat({
+				messages: [{
+					role: "system",
+					content: systemPrompt
+				}, {
+					role: "user",
+					content: context
+				}],
+				temperature: .3,
+				maxTokens: 150
+			}, (chunk) => {
+				if (abortController?.signal.aborted) return;
+				currentSuggestion += chunk;
+				if (autocompleteKey.getState(view.state)) view.dispatch(view.state.tr.setMeta(autocompleteKey, {
+					type: "update-suggestion",
+					suggestion: currentSuggestion
+				}));
+			});
+		} catch {} finally {
+			abortController = null;
+		}
+	}
+	return new Plugin({
+		key: autocompleteKey,
+		state: {
+			init() {
+				return {
+					decorations: DecorationSet.empty,
+					suggestion: "",
+					loading: false,
+					triggerPos: -1,
+					enabled: isEnabled
+				};
+			},
+			apply(tr, prev) {
+				const meta = tr.getMeta(autocompleteKey);
+				if (meta?.type === "set-enabled") {
+					isEnabled = meta.enabled;
+					clearPending();
+					return {
+						...prev,
+						decorations: DecorationSet.empty,
+						suggestion: "",
+						loading: false,
+						triggerPos: -1,
+						enabled: isEnabled
+					};
+				}
+				if (meta?.type === "clear") {
+					clearPending();
+					return {
+						...prev,
+						decorations: DecorationSet.empty,
+						suggestion: "",
+						loading: false,
+						triggerPos: -1
+					};
+				}
+				if (meta?.type === "update-suggestion") {
+					const suggestion = meta.suggestion;
+					const pos = prev.triggerPos;
+					if (!suggestion || pos < 0) return {
+						...prev,
+						suggestion: "",
+						decorations: DecorationSet.empty,
+						loading: false
+					};
+					const deco = createGhostTextDecoration(pos, suggestion);
+					return {
+						...prev,
+						suggestion,
+						loading: true,
+						decorations: DecorationSet.create(tr.doc, [deco])
+					};
+				}
+				if (meta?.type === "show-suggestion") {
+					const suggestion = meta.suggestion;
+					const pos = meta.pos;
+					if (!suggestion) return {
+						...prev,
+						suggestion: "",
+						decorations: DecorationSet.empty,
+						loading: false
+					};
+					const deco = createGhostTextDecoration(pos, suggestion);
+					return {
+						...prev,
+						suggestion,
+						loading: false,
+						triggerPos: pos,
+						decorations: DecorationSet.create(tr.doc, [deco])
+					};
+				}
+				if (!isEnabled) return prev;
+				if (tr.docChanged) {
+					clearPending();
+					return {
+						...prev,
+						decorations: DecorationSet.empty,
+						suggestion: "",
+						loading: false,
+						triggerPos: -1
+					};
+				}
+				return prev;
+			}
+		},
+		props: {
+			decorations(state) {
+				return autocompleteKey.getState(state)?.decorations ?? DecorationSet.empty;
+			},
+			handleKeyDown(view, event) {
+				const pluginState = autocompleteKey.getState(view.state);
+				if (!pluginState?.suggestion) return false;
+				if (event.key === "Tab") {
+					event.preventDefault();
+					const suggestion = pluginState.suggestion;
+					const triggerPos = pluginState.triggerPos;
+					clearPending();
+					if (suggestion && triggerPos >= 0) {
+						const tr = view.state.tr.insertText(suggestion, triggerPos);
+						view.dispatch(tr);
+					}
+					view.dispatch(view.state.tr.setMeta(autocompleteKey, { type: "clear" }));
+					return true;
+				}
+				if (event.key === "Escape") {
+					event.preventDefault();
+					clearPending();
+					view.dispatch(view.state.tr.setMeta(autocompleteKey, { type: "clear" }));
+					return true;
+				}
+				if (event.key !== "Tab" && event.key !== "Escape") {
+					clearPending();
+					view.dispatch(view.state.tr.setMeta(autocompleteKey, { type: "clear" }));
+				}
+				return false;
+			}
+		},
+		view(_editorView) {
+			return {
+				update(view) {
+					if (!isEnabled) return;
+					if (!getService()) return;
+					if (autocompleteKey.getState(view.state)?.suggestion) return;
+					const { text, pos } = getContextBeforeCursor(view.state, maxContextChars);
+					if (!shouldTrigger(text, minTriggerLength)) return;
+					if (debounceTimer) clearTimeout(debounceTimer);
+					lastTriggerPos = pos;
+					debounceTimer = setTimeout(() => {
+						if (autocompleteKey.getState(view.state)?.suggestion) return;
+						requestCompletion(text, view).then(() => {
+							if (currentSuggestion && !abortController?.signal.aborted) view.dispatch(view.state.tr.setMeta(autocompleteKey, {
+								type: "show-suggestion",
+								suggestion: currentSuggestion,
+								pos: lastTriggerPos
+							}));
+						});
+					}, debounceMs);
+				},
+				destroy() {
+					clearPending();
+				}
+			};
+		}
+	});
+}
+function setAutocompleteEnabled(view, enabled) {
+	view.dispatch(view.state.tr.setMeta(autocompleteKey, {
+		type: "set-enabled",
+		enabled
+	}));
+}
+//#endregion
+//#region src/react/ai-autocomplete.tsx
+var STORAGE_KEY = "mibao-ai-config";
+function createAIAutocompletePlugin(holder, config) {
+	return createAutocompletePlugin({
+		getService: () => holder.service,
+		debounceMs: config?.debounceMs,
+		minTriggerLength: config?.minTriggerLength
+	});
+}
+var AIAutocomplete = forwardRef(function AIAutocomplete({ editor, enabled = false }, ref) {
+	const [active, setActive] = useState(enabled);
+	const viewRef = useRef(editor.view);
+	viewRef.current = editor.view;
+	const holderRef = useRef(null);
+	const serviceRef = useRef(null);
+	const initService = useCallback(() => {
+		const holder = window.__aiAutocompleteHolder;
+		if (!holder) return;
+		const config = loadAIConfig();
+		if (!config) {
+			if (serviceRef.current) {
+				serviceRef.current.close();
+				serviceRef.current = null;
+				holder.service = null;
+			}
+			return;
+		}
+		if (serviceRef.current) serviceRef.current.close();
+		const service = new AIService(config);
+		serviceRef.current = service;
+		holder.service = service;
+		holderRef.current = holder;
+	}, []);
+	useEffect(() => {
+		initService();
+		const handleStorage = (e) => {
+			if (e.key === STORAGE_KEY) initService();
+		};
+		window.addEventListener("storage", handleStorage);
+		return () => {
+			window.removeEventListener("storage", handleStorage);
+			if (serviceRef.current) {
+				serviceRef.current.close();
+				serviceRef.current = null;
+				const holder = window.__aiAutocompleteHolder;
+				if (holder) holder.service = null;
+			}
+		};
+	}, [initService]);
+	useEffect(() => {
+		if (!viewRef.current) return;
+		setAutocompleteEnabled(viewRef.current, active);
+	}, [active]);
+	useImperativeHandle(ref, () => ({
+		setEnabled: (v) => setActive(v),
+		isEnabled: () => active
+	}), [active]);
+	return null;
+});
+//#endregion
+//#region src/react/word-count-display.tsx
+function WordCountDisplay({ editor, className, showDetails = false }) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new WordCountDisplay$1(createEditorAdapter(editor), { showDetails });
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+}
+//#endregion
+//#region src/react/toc-panel.tsx
+function TocPanel({ editor, className, title, onItemClick }) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new TocPanel$1(createEditorAdapter(editor), {
+			title,
+			onItemClick
+		});
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+}
+//#endregion
+//#region src/react/shortcut-panel.tsx
+var ShortcutPanel = forwardRef(function ShortcutPanel({ editor, className, shortcuts }, ref) {
+	const containerRef = useRef(null);
+	const compRef = useRef(null);
+	useEffect(() => {
+		if (!containerRef.current || compRef.current) return;
+		const comp = new ShortcutPanel$1(createEditorAdapter(editor), { shortcuts });
+		comp.mount(containerRef.current);
+		compRef.current = comp;
+		return () => {
+			comp.destroy();
+			compRef.current = null;
+		};
+	}, [editor]);
+	useImperativeHandle(ref, () => ({
+		open: () => compRef.current?.open(),
+		close: () => compRef.current?.close()
+	}), []);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		ref: containerRef,
+		className
+	});
+});
+//#endregion
+export { AIAutocomplete, AIMenu, AIWriter, BubbleMenu, DEFAULT_TOOLBAR_CONFIG, DragHandle, EditorContent, OPTIONAL_TOOLBAR_ITEMS, ShortcutPanel, TocPanel, Toolbar, WordCountDisplay, createAIAutocompletePlugin, createToolbarConfig, exportAsHTML, exportAsJSON, exportAsMarkdown, exportAsPlainText, useEditor };
+
+//# sourceMappingURL=index.esm.js.map