@mce/collaboration 0.24.4

package/dist/AbstractProvider.d.ts

@@ -0,0 +1,61 @@
+import type { YDoc } from 'mce';
+import type { ObservableEvents } from 'modern-idoc';
+import { Observable } from 'modern-idoc';
+import * as awarenessProtocol from 'y-protocols/awareness';
+/**
+ * 顶层消息类型。一个消息 = [messageType: varUint, payload...]，房间名由传输层在 URL 等处携带。
+ */
+export declare const MESSAGE_SYNC = 0;
+export declare const MESSAGE_AWARENESS = 1;
+export declare const MESSAGE_QUERY_AWARENESS = 3;
+export interface AbstractProviderEvents extends ObservableEvents {
+    /** 连接状态变化。 */
+    status: [{
+        connected: boolean;
+    }];
+    /** 首次与对端完成 sync step2，本端已拿到全量状态。 */
+    synced: [boolean];
+}
+/**
+ * 可插拔传输层基类。负责 Yjs 同步协议（state vector 握手 + 增量）与 Awareness（在场感知）的
+ * 编解码与路由；具体字节怎么收发由子类实现（WebSocket / WebRTC / BroadcastChannel / 自定义）。
+ *
+ * 关注点分离：
+ * - 本类只懂「协议」：何时发 syncStep1、如何把 update / awareness 编成消息、收到消息如何分发。
+ * - 子类只懂「传输」：实现 {@link send}，在连接打开时调用 {@link onOpen}，收到字节时调用 {@link receive}。
+ *
+ * 回环防护：远端增量一律以 `this`（provider 实例）为 origin apply 到文档——既不进入本端
+ * UndoManager，又能刷新视图，且本端 'update' 监听据 `origin === this` 跳过再广播。
+ */
+export declare abstract class AbstractProvider<Events extends AbstractProviderEvents = AbstractProviderEvents> extends Observable<Events> {
+    readonly awareness: awarenessProtocol.Awareness;
+    synced: boolean;
+    /** 传输层连接状态。随 onOpen / onClose 翻转，供晚挂监听的上层补读初值。 */
+    connected: boolean;
+    protected _ydoc: YDoc;
+    protected _doc: YDoc['_yDoc'];
+    private _onUpdate;
+    private _onAwarenessUpdate;
+    constructor(ydoc: YDoc);
+    /** 子类实现：把字节发往对端。连接未就绪时应自行缓冲或丢弃（同步协议可在重连后重放）。 */
+    protected abstract send(data: Uint8Array): void;
+    /**
+     * 把本端全量状态作为一条 sync update 主动推给对端。
+     *
+     * 用于**无中心服务端的 P2P 传输**（如 BroadcastChannel / WebRTC）：step1/step2 握手只能让
+     * 「发起方」拉到对端缺失的内容，无法让已在场的对端获得本端新内容。当本端在会话中途换上一份
+     * 新内容（如 setDoc 后 provider 重建）时，调用此方法把内容推过去，对端 applyUpdate 即合并。
+     * 有服务端的传输（WebSocket）由服务端持久化 + 转发，通常不需要。
+     */
+    protected broadcastState(): void;
+    /** 连接（重新）建立后由子类调用：发起 sync step1 并广播本端 awareness。 */
+    protected onOpen(): void;
+    /** 连接断开后由子类调用。 */
+    protected onClose(): void;
+    /** 子类收到一帧消息字节后调用，路由到 sync / awareness 处理。 */
+    protected receive(data: Uint8Array): void;
+    private _encodeAwareness;
+    private _removeAwareness;
+    protected _setSynced(value: boolean): void;
+    destroy(): void;
+}

package/dist/AbstractProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/CollaborationStatus.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Presence.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/WebsocketProvider.d.ts

@@ -0,0 +1,36 @@
+import type { YDoc } from 'mce';
+import { AbstractProvider } from './AbstractProvider';
+export interface WebsocketProviderOptions {
+    /** 是否构造后立即连接，默认 true。 */
+    connect?: boolean;
+    /** 断线重连基础间隔（ms），按指数退避，默认 1000。 */
+    reconnectInterval?: number;
+    /** 最大重连间隔（ms），默认 30000。 */
+    maxReconnectInterval?: number;
+    /** WebSocket 子协议。 */
+    protocols?: string | string[];
+}
+/**
+ * 基于 WebSocket 的传输实现，协议与 y-websocket 服务端兼容：
+ * 连接地址为 `${url}/${room}`，二进制帧承载 {@link AbstractProvider} 定义的 sync / awareness 消息。
+ *
+ * 特性：指数退避重连、连接未就绪时缓冲消息、`onOpen` 自动发起 state vector 握手。
+ */
+export declare class WebsocketProvider extends AbstractProvider {
+    readonly url: string;
+    ws: WebSocket | null;
+    shouldConnect: boolean;
+    private readonly _reconnectInterval;
+    private readonly _maxReconnectInterval;
+    private readonly _protocols?;
+    private _reconnectAttempts;
+    private _reconnectTimer;
+    /** 连接未 OPEN 时缓冲待发字节，OPEN 后冲刷。 */
+    private _pending;
+    constructor(url: string, room: string, ydoc: YDoc, options?: WebsocketProviderOptions);
+    connect(): void;
+    disconnect(): void;
+    protected send(data: Uint8Array): void;
+    private _scheduleReconnect;
+    destroy(): void;
+}

package/dist/WebsocketProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/collaborationPlugin.d.ts

@@ -0,0 +1,61 @@
+import type { YDoc } from 'mce';
+import type { Ref, ShallowRef } from 'vue';
+import type { AbstractProvider } from './AbstractProvider';
+import type { WebsocketProviderOptions } from './WebsocketProvider';
+declare global {
+    namespace Mce {
+        /**
+         * 传输层工厂：拿到当前文档的底层 YDoc，返回一个 Provider 实例。
+         * 文档切换时框架会以新文档的 YDoc 重新调用，以重建会话。
+         */
+        type ProviderFactory = (doc: YDoc) => AbstractProvider;
+        interface CollaborationConnectOptions {
+            /** WebSocket 服务端地址（与 y-websocket 兼容）。与 provider 二选一。 */
+            url?: string;
+            /** 房间名，默认取当前文档 id。 */
+            room?: string;
+            /** 透传给 WebsocketProvider 的可选项（重连间隔、子协议等）。 */
+            websocket?: WebsocketProviderOptions;
+            /** 自定义传输层工厂（WebRTC / BroadcastChannel / 自定义）。提供时忽略 url / room。 */
+            provider?: ProviderFactory;
+        }
+        interface Collaboration {
+            /** 当前 Provider 实例；未连接时为 undefined。 */
+            provider: ShallowRef<AbstractProvider | undefined>;
+            /** 传输层连接状态。 */
+            connected: Ref<boolean>;
+            /** 是否已与对端完成首次全量同步。 */
+            synced: Ref<boolean>;
+            /** 是否存在活跃的协同会话（connect 后、disconnect 前恒为 true，跨文档切换保持）。 */
+            active: Ref<boolean>;
+            /** 建立协同会话。重复调用会先断开旧会话。返回新建的 Provider（参数非法时返回 undefined）。 */
+            connect: (options: CollaborationConnectOptions) => AbstractProvider | undefined;
+            /** 断开并销毁当前 Provider，结束协同会话。 */
+            disconnect: () => void;
+        }
+        interface Options {
+            /** 启动时自动建立协同会话。 */
+            collaboration?: CollaborationConnectOptions;
+        }
+        interface Editor {
+            collaboration: Collaboration;
+        }
+        interface Events {
+            /** 传输层连接状态变化。 */
+            collaborationStatus: [connected: boolean];
+            /** 首次全量同步完成 / 失效。 */
+            collaborationSynced: [synced: boolean];
+        }
+    }
+}
+/**
+ * 协同会话接入：把可插拔的传输层（{@link AbstractProvider} 子类）接到编辑器的文档生命周期上。
+ *
+ * 职责边界：本插件只管「会话生命周期」——建立 / 销毁 Provider、跨文档切换重建、暴露连接 /
+ * 同步状态。协议编解码（sync / awareness）在 {@link AbstractProvider}，字节收发在具体 Provider。
+ *
+ * 关键不变量：Provider 绑定在某个具体的底层 YDoc 上（`Doc._yDoc`）。`setDoc` 切换文档时旧
+ * YDoc 会被 destroy，故必须以新文档的 YDoc 重建 Provider —— 这里订阅 `docSet` 事件完成重建。
+ */
+declare const _default: import("mce").Plugin;
+export default _default;

package/dist/index.css

@@ -0,0 +1,97 @@
+.m-collab-status[data-v-d870b105] {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+.m-collab-status__dot[data-v-d870b105] {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.m-collab-status__dot--synced[data-v-d870b105] {
+  background-color: #0CA678;
+}
+.m-collab-status__dot--connecting[data-v-d870b105] {
+  background-color: #F59F00;
+}
+.m-collab-status__dot--offline[data-v-d870b105] {
+  background-color: rgba(var(--m-theme-on-surface), 0.3);
+}
+.m-collab-status__label[data-v-d870b105] {
+  opacity: 0.7;
+}
+.m-collab-status__avatars[data-v-d870b105] {
+  display: flex;
+  align-items: center;
+  margin-left: 4px;
+}
+.m-collab-status__avatar[data-v-d870b105] {
+  width: 18px;
+  height: 18px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: #fff;
+  font-size: 0.625rem;
+  font-weight: bold;
+  overflow: hidden;
+  border: 1.5px solid rgba(var(--m-theme-surface), 1);
+  margin-left: -6px;
+}
+.m-collab-status__avatar[data-v-d870b105]:first-child {
+  margin-left: 0;
+}
+.m-collab-status__avatar img[data-v-d870b105] {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+.m-collab-status__avatar--more[data-v-d870b105] {
+  background-color: rgba(var(--m-theme-on-surface), 0.3);
+}.m-presence {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  overflow: hidden;
+  z-index: 10;
+}
+.m-presence-selection {
+  position: absolute;
+  border: 1.5px solid;
+  pointer-events: none;
+}
+.m-presence-tag {
+  position: absolute;
+  top: 0;
+  left: -1.5px;
+  transform: translateY(-100%);
+  padding: 1px 6px;
+  border-radius: 4px 4px 4px 0;
+  color: #fff;
+  font-size: 12px;
+  line-height: 16px;
+  white-space: nowrap;
+}
+.m-presence-cursor {
+  position: absolute;
+  top: 0;
+  left: 0;
+  will-change: transform;
+  transition: transform 80ms linear;
+}
+.m-presence-cursor svg {
+  display: block;
+}
+.m-presence-label {
+  position: absolute;
+  top: 16px;
+  left: 12px;
+  padding: 1px 6px;
+  border-radius: 4px;
+  color: #fff;
+  font-size: 12px;
+  line-height: 18px;
+  white-space: nowrap;
+}/*$vite$:1*/

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './AbstractProvider';
+export { default as collaborationPlugin } from './collaborationPlugin';
+export { default as presencePlugin } from './presencePlugin';
+export * from './WebsocketProvider';
+/** 注册「协同会话」+「在场感知」两个插件（presence 依赖 collaboration 的 provider，顺序固定）。 */
+export declare function plugin(): import("mce").Plugin[];
+export default plugin;

package/dist/index.js

@@ -0,0 +1,909 @@
+import { INTERNAL_ORIGIN, definePlugin, useEditor } from "mce";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, defineComponent, normalizeClass, normalizeStyle, onScopeDispose, openBlock, ref, renderList, shallowRef, toDisplayString, unref, watch } from "vue";
+import { Observable } from "modern-idoc";
+import * as awarenessProtocol from "y-protocols/awareness";
+import * as syncProtocol from "y-protocols/sync";
+//#region src/CollaborationStatus.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$1 = {
+	key: 0,
+	class: "m-collab-status"
+};
+var _hoisted_2$1 = { class: "m-collab-status__label" };
+var _hoisted_3$1 = {
+	key: 0,
+	class: "m-collab-status__avatars"
+};
+var _hoisted_4 = ["title"];
+var _hoisted_5 = ["src", "alt"];
+var _hoisted_6 = {
+	key: 0,
+	class: "m-collab-status__avatar m-collab-status__avatar--more"
+};
+var MAX_AVATARS = 5;
+var CollaborationStatus_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "CollaborationStatus",
+	setup(__props) {
+		const { collaboration, presence, t } = useEditor();
+		/** 连接 / 同步状态：offline → connecting → synced。 */
+		const status = computed(() => {
+			if (!collaboration.connected.value) return "offline";
+			return collaboration.synced.value ? "synced" : "connecting";
+		});
+		const avatars = computed(() => {
+			return presence.peers.value.slice(0, MAX_AVATARS).map((peer) => ({
+				clientId: peer.clientId,
+				name: peer.user?.name ?? "",
+				color: peer.user?.color ?? "#868E96",
+				avatar: peer.user?.avatar,
+				initial: (peer.user?.name ?? "?").trim().charAt(0).toUpperCase() || "?"
+			}));
+		});
+		const overflow = computed(() => Math.max(0, presence.peers.value.length - MAX_AVATARS));
+		return (_ctx, _cache) => {
+			return unref(collaboration).active.value ? (openBlock(), createElementBlock("div", _hoisted_1$1, [
+				createElementVNode("span", { class: normalizeClass(["m-collab-status__dot", `m-collab-status__dot--${status.value}`]) }, null, 2),
+				createElementVNode("span", _hoisted_2$1, toDisplayString(unref(t)(`collaboration:${status.value}`)), 1),
+				avatars.value.length ? (openBlock(), createElementBlock("div", _hoisted_3$1, [(openBlock(true), createElementBlock(Fragment, null, renderList(avatars.value, (peer) => {
+					return openBlock(), createElementBlock("span", {
+						key: peer.clientId,
+						class: "m-collab-status__avatar",
+						style: normalizeStyle({ backgroundColor: peer.color }),
+						title: peer.name
+					}, [peer.avatar ? (openBlock(), createElementBlock("img", {
+						key: 0,
+						src: peer.avatar,
+						alt: peer.name
+					}, null, 8, _hoisted_5)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createTextVNode(toDisplayString(peer.initial), 1)], 64))], 12, _hoisted_4);
+				}), 128)), overflow.value ? (openBlock(), createElementBlock("span", _hoisted_6, " +" + toDisplayString(overflow.value), 1)) : createCommentVNode("", true)])) : createCommentVNode("", true)
+			])) : createCommentVNode("", true);
+		};
+	}
+});
+//#endregion
+//#region \0plugin-vue:export-helper
+var _plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+//#endregion
+//#region src/CollaborationStatus.vue
+var CollaborationStatus_default = /*#__PURE__*/ _plugin_vue_export_helper_default(CollaborationStatus_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-d870b105"]]);
+//#endregion
+//#region ../../node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/math.js
+/**
+* Common Math expressions.
+*
+* @module math
+*/
+var floor = Math.floor;
+/**
+* @function
+* @param {number} a
+* @param {number} b
+* @return {number} The smaller element of a and b
+*/
+var min = (a, b) => a < b ? a : b;
+/**
+* @function
+* @param {number} a
+* @param {number} b
+* @return {number} The bigger element of a and b
+*/
+var max = (a, b) => a > b ? a : b;
+Number.isNaN;
+//#endregion
+//#region ../../node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/number.js
+/**
+* Utility helpers for working with numbers.
+*
+* @module number
+*/
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+Number.MIN_SAFE_INTEGER;
+Number.isInteger;
+Number.isNaN;
+Number.parseInt;
+//#endregion
+//#region ../../node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/string.js
+/**
+* Utility module to work with strings.
+*
+* @module string
+*/
+var fromCharCode = String.fromCharCode;
+String.fromCodePoint;
+fromCharCode(65535);
+/* c8 ignore next */
+var utf8TextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+/* c8 ignore next */
+var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+/* c8 ignore start */
+if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1)
+ /* c8 ignore next */
+utf8TextDecoder = null;
+//#endregion
+//#region ../../node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/error.js
+/**
+* Error helpers.
+*
+* @module error
+*/
+/**
+* @param {string} s
+* @return {Error}
+*/
+/* c8 ignore next */
+var create = (s) => new Error(s);
+//#endregion
+//#region ../../node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/encoding.js
+/**
+* Efficient schema-less binary encoding with support for variable length encoding.
+*
+* Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
+*
+* Encodes numbers in little-endian order (least to most significant byte order)
+* and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+* which is also used in Protocol Buffers.
+*
+* ```js
+* // encoding step
+* const encoder = encoding.createEncoder()
+* encoding.writeVarUint(encoder, 256)
+* encoding.writeVarString(encoder, 'Hello world!')
+* const buf = encoding.toUint8Array(encoder)
+* ```
+*
+* ```js
+* // decoding step
+* const decoder = decoding.createDecoder(buf)
+* decoding.readVarUint(decoder) // => 256
+* decoding.readVarString(decoder) // => 'Hello world!'
+* decoding.hasContent(decoder) // => false - all data is read
+* ```
+*
+* @module encoding
+*/
+/**
+* A BinaryEncoder handles the encoding to an Uint8Array.
+*/
+var Encoder = class {
+	constructor() {
+		this.cpos = 0;
+		this.cbuf = new Uint8Array(100);
+		/**
+		* @type {Array<Uint8Array>}
+		*/
+		this.bufs = [];
+	}
+};
+/**
+* @function
+* @return {Encoder}
+*/
+var createEncoder = () => new Encoder();
+/**
+* The current length of the encoded data.
+*
+* @function
+* @param {Encoder} encoder
+* @return {number}
+*/
+var length = (encoder) => {
+	let len = encoder.cpos;
+	for (let i = 0; i < encoder.bufs.length; i++) len += encoder.bufs[i].length;
+	return len;
+};
+/**
+* Transform to Uint8Array.
+*
+* @function
+* @param {Encoder} encoder
+* @return {Uint8Array<ArrayBuffer>} The created ArrayBuffer.
+*/
+var toUint8Array = (encoder) => {
+	const uint8arr = new Uint8Array(length(encoder));
+	let curPos = 0;
+	for (let i = 0; i < encoder.bufs.length; i++) {
+		const d = encoder.bufs[i];
+		uint8arr.set(d, curPos);
+		curPos += d.length;
+	}
+	uint8arr.set(new Uint8Array(encoder.cbuf.buffer, 0, encoder.cpos), curPos);
+	return uint8arr;
+};
+/**
+* Write one byte to the encoder.
+*
+* @function
+* @param {Encoder} encoder
+* @param {number} num The byte that is to be encoded.
+*/
+var write = (encoder, num) => {
+	const bufferLen = encoder.cbuf.length;
+	if (encoder.cpos === bufferLen) {
+		encoder.bufs.push(encoder.cbuf);
+		encoder.cbuf = new Uint8Array(bufferLen * 2);
+		encoder.cpos = 0;
+	}
+	encoder.cbuf[encoder.cpos++] = num;
+};
+/**
+* Write a variable length unsigned integer. Max encodable integer is 2^53.
+*
+* @function
+* @param {Encoder} encoder
+* @param {number} num The number that is to be encoded.
+*/
+var writeVarUint = (encoder, num) => {
+	while (num > 127) {
+		write(encoder, 128 | 127 & num);
+		num = floor(num / 128);
+	}
+	write(encoder, 127 & num);
+};
+new Uint8Array(3e4).length / 3;
+utf8TextEncoder && utf8TextEncoder.encodeInto;
+/**
+* Append fixed-length Uint8Array to the encoder.
+*
+* @function
+* @param {Encoder} encoder
+* @param {Uint8Array} uint8Array
+*/
+var writeUint8Array = (encoder, uint8Array) => {
+	const bufferLen = encoder.cbuf.length;
+	const cpos = encoder.cpos;
+	const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+	const rightCopyLen = uint8Array.length - leftCopyLen;
+	encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+	encoder.cpos += leftCopyLen;
+	if (rightCopyLen > 0) {
+		encoder.bufs.push(encoder.cbuf);
+		encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+		encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+		encoder.cpos = rightCopyLen;
+	}
+};
+/**
+* Append an Uint8Array to Encoder.
+*
+* @function
+* @param {Encoder} encoder
+* @param {Uint8Array} uint8Array
+*/
+var writeVarUint8Array = (encoder, uint8Array) => {
+	writeVarUint(encoder, uint8Array.byteLength);
+	writeUint8Array(encoder, uint8Array);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/lib0@0.2.117/node_modules/lib0/decoding.js
+/**
+* Efficient schema-less binary decoding with support for variable length encoding.
+*
+* Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
+*
+* Encodes numbers in little-endian order (least to most significant byte order)
+* and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+* which is also used in Protocol Buffers.
+*
+* ```js
+* // encoding step
+* const encoder = encoding.createEncoder()
+* encoding.writeVarUint(encoder, 256)
+* encoding.writeVarString(encoder, 'Hello world!')
+* const buf = encoding.toUint8Array(encoder)
+* ```
+*
+* ```js
+* // decoding step
+* const decoder = decoding.createDecoder(buf)
+* decoding.readVarUint(decoder) // => 256
+* decoding.readVarString(decoder) // => 'Hello world!'
+* decoding.hasContent(decoder) // => false - all data is read
+* ```
+*
+* @module decoding
+*/
+var errorUnexpectedEndOfArray = create("Unexpected end of array");
+var errorIntegerOutOfRange = create("Integer out of Range");
+/**
+* A Decoder handles the decoding of an Uint8Array.
+* @template {ArrayBufferLike} [Buf=ArrayBufferLike]
+*/
+var Decoder = class {
+	/**
+	* @param {Uint8Array<Buf>} uint8Array Binary data to decode
+	*/
+	constructor(uint8Array) {
+		/**
+		* Decoding target.
+		*
+		* @type {Uint8Array<Buf>}
+		*/
+		this.arr = uint8Array;
+		/**
+		* Current decoding position.
+		*
+		* @type {number}
+		*/
+		this.pos = 0;
+	}
+};
+/**
+* @function
+* @template {ArrayBufferLike} Buf
+* @param {Uint8Array<Buf>} uint8Array
+* @return {Decoder<Buf>}
+*/
+var createDecoder = (uint8Array) => new Decoder(uint8Array);
+/**
+* Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+*
+* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+*
+* @function
+* @template {ArrayBufferLike} Buf
+* @param {Decoder<Buf>} decoder The decoder instance
+* @param {number} len The length of bytes to read
+* @return {Uint8Array<Buf>}
+*/
+var readUint8Array = (decoder, len) => {
+	const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+	decoder.pos += len;
+	return view;
+};
+/**
+* Read variable length Uint8Array.
+*
+* Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+*            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+*
+* @function
+* @template {ArrayBufferLike} Buf
+* @param {Decoder<Buf>} decoder
+* @return {Uint8Array<Buf>}
+*/
+var readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
+/**
+* Read unsigned integer (32bit) with variable length.
+* 1/8th of the storage is used as encoding overhead.
+*  * numbers < 2^7 is stored in one bytlength
+*  * numbers < 2^14 is stored in two bylength
+*
+* @function
+* @param {Decoder} decoder
+* @return {number} An unsigned integer.length
+*/
+var readVarUint = (decoder) => {
+	let num = 0;
+	let mult = 1;
+	const len = decoder.arr.length;
+	while (decoder.pos < len) {
+		const r = decoder.arr[decoder.pos++];
+		num = num + (r & 127) * mult;
+		mult *= 128;
+		if (r < 128) return num;
+		/* c8 ignore start */
+		if (num > MAX_SAFE_INTEGER) throw errorIntegerOutOfRange;
+	}
+	throw errorUnexpectedEndOfArray;
+};
+//#endregion
+//#region src/AbstractProvider.ts
+/**
+* 顶层消息类型。一个消息 = [messageType: varUint, payload...]，房间名由传输层在 URL 等处携带。
+*/
+var MESSAGE_SYNC = 0;
+var MESSAGE_AWARENESS = 1;
+var MESSAGE_QUERY_AWARENESS = 3;
+/**
+* 可插拔传输层基类。负责 Yjs 同步协议（state vector 握手 + 增量）与 Awareness（在场感知）的
+* 编解码与路由；具体字节怎么收发由子类实现（WebSocket / WebRTC / BroadcastChannel / 自定义）。
+*
+* 关注点分离：
+* - 本类只懂「协议」：何时发 syncStep1、如何把 update / awareness 编成消息、收到消息如何分发。
+* - 子类只懂「传输」：实现 {@link send}，在连接打开时调用 {@link onOpen}，收到字节时调用 {@link receive}。
+*
+* 回环防护：远端增量一律以 `this`（provider 实例）为 origin apply 到文档——既不进入本端
+* UndoManager，又能刷新视图，且本端 'update' 监听据 `origin === this` 跳过再广播。
+*/
+var AbstractProvider = class extends Observable {
+	awareness;
+	synced = false;
+	/** 传输层连接状态。随 onOpen / onClose 翻转，供晚挂监听的上层补读初值。 */
+	connected = false;
+	_ydoc;
+	_doc;
+	_onUpdate;
+	_onAwarenessUpdate;
+	constructor(ydoc) {
+		super();
+		this._ydoc = ydoc;
+		this._doc = ydoc._yDoc;
+		this.awareness = new awarenessProtocol.Awareness(this._doc);
+		this._onUpdate = (update, origin) => {
+			if (origin === this || origin === INTERNAL_ORIGIN) return;
+			const encoder = createEncoder();
+			writeVarUint(encoder, 0);
+			syncProtocol.writeUpdate(encoder, update);
+			this.send(toUint8Array(encoder));
+		};
+		this._onAwarenessUpdate = ({ added, updated, removed }, origin) => {
+			if (origin === this) return;
+			const changed = added.concat(updated, removed);
+			this.send(this._encodeAwareness(changed));
+		};
+		ydoc.on("update", this._onUpdate);
+		this.awareness.on("update", this._onAwarenessUpdate);
+		if (typeof addEventListener !== "undefined") addEventListener("beforeunload", this._removeAwareness);
+	}
+	/**
+	* 把本端全量状态作为一条 sync update 主动推给对端。
+	*
+	* 用于**无中心服务端的 P2P 传输**（如 BroadcastChannel / WebRTC）：step1/step2 握手只能让
+	* 「发起方」拉到对端缺失的内容，无法让已在场的对端获得本端新内容。当本端在会话中途换上一份
+	* 新内容（如 setDoc 后 provider 重建）时，调用此方法把内容推过去，对端 applyUpdate 即合并。
+	* 有服务端的传输（WebSocket）由服务端持久化 + 转发，通常不需要。
+	*/
+	broadcastState() {
+		const encoder = createEncoder();
+		writeVarUint(encoder, 0);
+		syncProtocol.writeUpdate(encoder, this._ydoc.encodeStateAsUpdate());
+		this.send(toUint8Array(encoder));
+	}
+	/** 连接（重新）建立后由子类调用：发起 sync step1 并广播本端 awareness。 */
+	onOpen() {
+		const encoder = createEncoder();
+		writeVarUint(encoder, 0);
+		syncProtocol.writeSyncStep1(encoder, this._doc);
+		this.send(toUint8Array(encoder));
+		if (this.awareness.getLocalState() !== null) this.send(this._encodeAwareness([this._doc.clientID]));
+		this.connected = true;
+		this.emit("status", { connected: true });
+	}
+	/** 连接断开后由子类调用。 */
+	onClose() {
+		awarenessProtocol.removeAwarenessStates(this.awareness, Array.from(this.awareness.getStates().keys()).filter((id) => id !== this._doc.clientID), this);
+		this.connected = false;
+		this.emit("status", { connected: false });
+	}
+	/** 子类收到一帧消息字节后调用，路由到 sync / awareness 处理。 */
+	receive(data) {
+		const decoder = createDecoder(data);
+		const encoder = createEncoder();
+		switch (readVarUint(decoder)) {
+			case 0: {
+				writeVarUint(encoder, 0);
+				const syncType = syncProtocol.readSyncMessage(decoder, encoder, this._doc, this);
+				if (!this.synced && syncType === syncProtocol.messageYjsSyncStep2) this._setSynced(true);
+				if (length(encoder) > 1) this.send(toUint8Array(encoder));
+				break;
+			}
+			case 1:
+				awarenessProtocol.applyAwarenessUpdate(this.awareness, readVarUint8Array(decoder), this);
+				break;
+			case 3:
+				this.send(this._encodeAwareness(Array.from(this.awareness.getStates().keys())));
+				break;
+		}
+	}
+	_encodeAwareness(clients) {
+		const encoder = createEncoder();
+		writeVarUint(encoder, 1);
+		writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, clients));
+		return toUint8Array(encoder);
+	}
+	_removeAwareness = () => {
+		awarenessProtocol.removeAwarenessStates(this.awareness, [this._doc.clientID], "unload");
+	};
+	_setSynced(value) {
+		if (this.synced !== value) {
+			this.synced = value;
+			this.emit("synced", value);
+		}
+	}
+	destroy() {
+		this._removeAwareness();
+		this._ydoc.off("update", this._onUpdate);
+		this.awareness.off("update", this._onAwarenessUpdate);
+		this.awareness.destroy();
+		if (typeof removeEventListener !== "undefined") removeEventListener("beforeunload", this._removeAwareness);
+		super.destroy?.();
+	}
+};
+//#endregion
+//#region src/WebsocketProvider.ts
+/**
+* 基于 WebSocket 的传输实现，协议与 y-websocket 服务端兼容：
+* 连接地址为 `${url}/${room}`，二进制帧承载 {@link AbstractProvider} 定义的 sync / awareness 消息。
+*
+* 特性：指数退避重连、连接未就绪时缓冲消息、`onOpen` 自动发起 state vector 握手。
+*/
+var WebsocketProvider = class extends AbstractProvider {
+	url;
+	ws = null;
+	shouldConnect;
+	_reconnectInterval;
+	_maxReconnectInterval;
+	_protocols;
+	_reconnectAttempts = 0;
+	_reconnectTimer = null;
+	/** 连接未 OPEN 时缓冲待发字节，OPEN 后冲刷。 */
+	_pending = [];
+	constructor(url, room, ydoc, options = {}) {
+		super(ydoc);
+		this.url = `${url.replace(/\/$/, "")}/${room}`;
+		this._reconnectInterval = options.reconnectInterval ?? 1e3;
+		this._maxReconnectInterval = options.maxReconnectInterval ?? 3e4;
+		this._protocols = options.protocols;
+		this.shouldConnect = options.connect ?? true;
+		if (this.shouldConnect) this.connect();
+	}
+	connect() {
+		this.shouldConnect = true;
+		if (this.ws) return;
+		const ws = new WebSocket(this.url, this._protocols);
+		ws.binaryType = "arraybuffer";
+		this.ws = ws;
+		ws.onopen = () => {
+			this._reconnectAttempts = 0;
+			const pending = this._pending;
+			this._pending = [];
+			pending.forEach((data) => ws.send(data));
+			this.onOpen();
+		};
+		ws.onmessage = (event) => {
+			this.receive(new Uint8Array(event.data));
+		};
+		ws.onclose = () => {
+			this.ws = null;
+			this.onClose();
+			this._setSynced(false);
+			if (this.shouldConnect) this._scheduleReconnect();
+		};
+		ws.onerror = () => {
+			ws.close();
+		};
+	}
+	disconnect() {
+		this.shouldConnect = false;
+		if (this._reconnectTimer) {
+			clearTimeout(this._reconnectTimer);
+			this._reconnectTimer = null;
+		}
+		this.ws?.close();
+	}
+	send(data) {
+		const ws = this.ws;
+		if (ws && ws.readyState === WebSocket.OPEN) ws.send(data);
+		else this._pending.push(data);
+	}
+	_scheduleReconnect() {
+		if (this._reconnectTimer) return;
+		const delay = Math.min(this._reconnectInterval * 2 ** this._reconnectAttempts, this._maxReconnectInterval);
+		this._reconnectAttempts++;
+		this._reconnectTimer = setTimeout(() => {
+			this._reconnectTimer = null;
+			if (this.shouldConnect) this.connect();
+		}, delay);
+	}
+	destroy() {
+		this.disconnect();
+		super.destroy();
+	}
+};
+//#endregion
+//#region src/collaborationPlugin.ts
+/**
+* 协同会话接入：把可插拔的传输层（{@link AbstractProvider} 子类）接到编辑器的文档生命周期上。
+*
+* 职责边界：本插件只管「会话生命周期」——建立 / 销毁 Provider、跨文档切换重建、暴露连接 /
+* 同步状态。协议编解码（sync / awareness）在 {@link AbstractProvider}，字节收发在具体 Provider。
+*
+* 关键不变量：Provider 绑定在某个具体的底层 YDoc 上（`Doc._yDoc`）。`setDoc` 切换文档时旧
+* YDoc 会被 destroy，故必须以新文档的 YDoc 重建 Provider —— 这里订阅 `docSet` 事件完成重建。
+*/
+var collaborationPlugin_default = definePlugin((editor, options) => {
+	const provider = shallowRef();
+	const connected = ref(false);
+	const synced = ref(false);
+	const active = ref(false);
+	let factory;
+	/** 销毁当前 Provider 并复位状态（保留 factory / active，供文档切换后重建）。 */
+	function teardown() {
+		const p = provider.value;
+		if (p) {
+			p.destroy();
+			provider.value = void 0;
+		}
+		connected.value = false;
+		synced.value = false;
+	}
+	/** 用当前 factory 针对当前文档的 YDoc 建立 Provider 并接线状态。 */
+	function spawn() {
+		if (!factory) return;
+		const ydoc = editor.root.value._yDoc;
+		const p = factory(ydoc);
+		p.on("status", ({ connected: value }) => {
+			connected.value = value;
+			editor.emit("collaborationStatus", value);
+		});
+		p.on("synced", (value) => {
+			synced.value = value;
+			editor.emit("collaborationSynced", value);
+		});
+		connected.value = p.connected;
+		synced.value = p.synced;
+		provider.value = p;
+		return p;
+	}
+	const connect = (options) => {
+		teardown();
+		if (options.provider) factory = options.provider;
+		else if (options.url) {
+			const { url, room, websocket } = options;
+			factory = (doc) => new WebsocketProvider(url, room ?? editor.root.value.id, doc, websocket);
+		} else {
+			console.warn("[collaboration] connect 需要提供 url 或 provider");
+			return;
+		}
+		active.value = true;
+		return spawn();
+	};
+	const disconnect = () => {
+		active.value = false;
+		factory = void 0;
+		teardown();
+	};
+	function onDocSet() {
+		if (!active.value) return;
+		try {
+			teardown();
+		} finally {
+			spawn();
+		}
+	}
+	editor.collaboration = {
+		provider,
+		connected,
+		synced,
+		active,
+		connect,
+		disconnect
+	};
+	editor.registerStatusbarItem(CollaborationStatus_default);
+	return {
+		name: "mce:collaboration",
+		messages: {
+			en: {
+				"collaboration:synced": "Synced",
+				"collaboration:connecting": "Connecting…",
+				"collaboration:offline": "Offline"
+			},
+			zhHans: {
+				"collaboration:synced": "已同步",
+				"collaboration:connecting": "连接中…",
+				"collaboration:offline": "离线"
+			}
+		},
+		setup: () => {
+			editor.on("docSet", onDocSet);
+			if (options.collaboration) connect(options.collaboration);
+			onScopeDispose(() => {
+				editor.off("docSet", onDocSet);
+				factory = void 0;
+				active.value = false;
+				teardown();
+			});
+		}
+	};
+});
+//#endregion
+//#region src/Presence.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "m-presence" };
+var _hoisted_2 = {
+	width: "20",
+	height: "20",
+	viewBox: "0 0 20 20",
+	fill: "none"
+};
+var _hoisted_3 = ["fill"];
+//#endregion
+//#region src/Presence.vue
+var Presence_default = /* @__PURE__ */ defineComponent({
+	__name: "Presence",
+	setup(__props) {
+		const { presence, camera, getNodeById, getObb } = useEditor();
+		/** 全局画布坐标 → 画板（屏幕）像素，与 box mixin 的 obbToDrawboardObb 同公式。 */
+		function toDrawboard(p) {
+			const { zoom, position } = camera.value;
+			return {
+				x: p.x * zoom.x - position.x,
+				y: p.y * zoom.y - position.y
+			};
+		}
+		const cursors = computed(() => {
+			return presence.peers.value.filter((peer) => peer.cursor).map((peer) => {
+				const { x, y } = toDrawboard(peer.cursor);
+				return {
+					clientId: peer.clientId,
+					color: peer.user?.color ?? "#1C7ED6",
+					name: peer.user?.name ?? "",
+					x,
+					y
+				};
+			});
+		});
+		const selections = computed(() => {
+			const boxes = [];
+			presence.peers.value.forEach((peer) => {
+				const color = peer.user?.color ?? "#1C7ED6";
+				const name = peer.user?.name ?? "";
+				let labeled = false;
+				peer.selection?.forEach((id) => {
+					const node = getNodeById(id);
+					if (!node) return;
+					boxes.push({
+						key: `${peer.clientId}:${id}`,
+						color,
+						name: labeled ? "" : name,
+						style: getObb(node, "drawboard").toCssStyle()
+					});
+					labeled = true;
+				});
+			});
+			return boxes;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [(openBlock(true), createElementBlock(Fragment, null, renderList(selections.value, (box) => {
+				return openBlock(), createElementBlock("div", {
+					key: box.key,
+					class: "m-presence-selection",
+					style: normalizeStyle({
+						...box.style,
+						borderColor: box.color
+					})
+				}, [box.name ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					class: "m-presence-tag",
+					style: normalizeStyle({ backgroundColor: box.color })
+				}, toDisplayString(box.name), 5)) : createCommentVNode("", true)], 4);
+			}), 128)), (openBlock(true), createElementBlock(Fragment, null, renderList(cursors.value, (cursor) => {
+				return openBlock(), createElementBlock("div", {
+					key: cursor.clientId,
+					class: "m-presence-cursor",
+					style: normalizeStyle({ transform: `translate(${cursor.x}px, ${cursor.y}px)` })
+				}, [(openBlock(), createElementBlock("svg", _hoisted_2, [createElementVNode("path", {
+					d: "M3 3L10 17L11.5 11.5L17 10L3 3Z",
+					fill: cursor.color,
+					stroke: "#fff",
+					"stroke-width": "1",
+					"stroke-linejoin": "round"
+				}, null, 8, _hoisted_3)])), cursor.name ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					class: "m-presence-label",
+					style: normalizeStyle({ backgroundColor: cursor.color })
+				}, toDisplayString(cursor.name), 5)) : createCommentVNode("", true)], 4);
+			}), 128))]);
+		};
+	}
+});
+//#endregion
+//#region src/presencePlugin.ts
+/** 默认调色板：按 clientId 取色，保证同一会话内每端颜色稳定。 */
+var COLORS = [
+	"#F76707",
+	"#0CA678",
+	"#1C7ED6",
+	"#AE3EC9",
+	"#E64980",
+	"#F59F00",
+	"#15AABF",
+	"#7048E8"
+];
+function colorFromId(id) {
+	return COLORS[Math.abs(id) % COLORS.length];
+}
+/**
+* 在场感知（Awareness）：把本端的用户信息 / 光标 / 选区广播给协同对端，并把对端状态收敛为
+* 响应式 `peers` 供 UI 渲染（远端光标、选框）。
+*
+* 职责边界：本插件只管「在场状态」。传输与会话生命周期在 {@link file://./collaboration.ts}，
+* Awareness 协议编解码在 `AbstractProvider`。Awareness 实例随 Provider 走 —— Provider 重建
+* （连接 / 文档切换）后这里会重新接线并补发本端状态。
+*/
+var presencePlugin_default = definePlugin((editor) => {
+	const peers = ref([]);
+	const localUser = ref({});
+	function getAwareness() {
+		return editor.collaboration.provider.value?.awareness;
+	}
+	/** 把对端 awareness 状态收敛为 peers（剔除本端）。 */
+	function syncPeers() {
+		const awareness = getAwareness();
+		if (!awareness) {
+			peers.value = [];
+			return;
+		}
+		const local = awareness.clientID;
+		const list = [];
+		awareness.getStates().forEach((state, clientId) => {
+			if (clientId === local) return;
+			list.push({
+				clientId,
+				...state
+			});
+		});
+		peers.value = list;
+	}
+	/** 广播本端 user 字段（补齐默认色 / 名）。 */
+	function applyLocalUser() {
+		const awareness = getAwareness();
+		if (!awareness) return;
+		const clientId = awareness.clientID;
+		const u = localUser.value;
+		awareness.setLocalStateField("user", {
+			...u,
+			color: u.color ?? colorFromId(clientId),
+			name: u.name ?? `Guest-${clientId % 1e3}`
+		});
+	}
+	const setUser = (user) => {
+		localUser.value = {
+			...localUser.value,
+			...user
+		};
+		applyLocalUser();
+	};
+	editor.presence = {
+		peers,
+		localUser,
+		setUser
+	};
+	return {
+		name: "mce:presence",
+		components: [{
+			type: "overlay",
+			component: Presence_default,
+			order: "before"
+		}],
+		setup: () => {
+			const { collaboration, drawboardPointer, selection, getGlobalPointer } = editor;
+			watch(collaboration.provider, (provider, _old, onCleanup) => {
+				if (!provider) {
+					peers.value = [];
+					return;
+				}
+				const { awareness } = provider;
+				applyLocalUser();
+				awareness.setLocalStateField("selection", selection.value.map((n) => n.id));
+				awareness.on("change", syncPeers);
+				syncPeers();
+				onCleanup(() => awareness.off("change", syncPeers));
+			}, { immediate: true });
+			watch(drawboardPointer, () => {
+				const awareness = getAwareness();
+				if (!awareness) return;
+				awareness.setLocalStateField("cursor", drawboardPointer.value ? { ...getGlobalPointer() } : null);
+			});
+			watch(selection, () => {
+				const awareness = getAwareness();
+				if (!awareness) return;
+				awareness.setLocalStateField("selection", selection.value.map((n) => n.id));
+			});
+		}
+	};
+});
+//#endregion
+//#region src/index.ts
+/** 注册「协同会话」+「在场感知」两个插件（presence 依赖 collaboration 的 provider，顺序固定）。 */
+function plugin() {
+	return [collaborationPlugin_default, presencePlugin_default];
+}
+//#endregion
+export { AbstractProvider, MESSAGE_AWARENESS, MESSAGE_QUERY_AWARENESS, MESSAGE_SYNC, WebsocketProvider, collaborationPlugin_default as collaborationPlugin, plugin as default, plugin, presencePlugin_default as presencePlugin };

package/dist/presencePlugin.d.ts

@@ -0,0 +1,51 @@
+import type { Ref } from 'vue';
+declare global {
+    namespace Mce {
+        interface PresenceUser {
+            /** 业务侧用户 id（可选，用于去重 / 头像）。 */
+            id?: string;
+            /** 展示名。缺省时按 clientId 生成访客名。 */
+            name?: string;
+            /** 主题色（光标 / 选框 / 头像描边）。缺省时按 clientId 从调色板取色。 */
+            color?: string;
+            /** 头像 URL。 */
+            avatar?: string;
+        }
+        /** 本端广播 / 远端接收的在场状态。坐标统一用全局画布坐标，与缩放 / 平移无关。 */
+        interface PresenceState {
+            user?: PresenceUser;
+            /** 光标位置（全局画布坐标）；离开画布时为 null。 */
+            cursor?: {
+                x: number;
+                y: number;
+            } | null;
+            /** 选中的节点 id 列表。 */
+            selection?: string[];
+        }
+        interface Peer extends PresenceState {
+            /** yjs clientID，远端唯一标识。 */
+            clientId: number;
+        }
+        interface Presence {
+            /** 远端在场用户列表（不含本端），随 awareness 变化响应式更新。 */
+            peers: Ref<Peer[]>;
+            /** 本端用户信息。 */
+            localUser: Ref<PresenceUser>;
+            /** 设置本端用户信息并立即广播（连接前调用会在连接后自动应用）。 */
+            setUser: (user: Partial<PresenceUser>) => void;
+        }
+        interface Editor {
+            presence: Presence;
+        }
+    }
+}
+/**
+ * 在场感知（Awareness）：把本端的用户信息 / 光标 / 选区广播给协同对端，并把对端状态收敛为
+ * 响应式 `peers` 供 UI 渲染（远端光标、选框）。
+ *
+ * 职责边界：本插件只管「在场状态」。传输与会话生命周期在 {@link file://./collaboration.ts}，
+ * Awareness 协议编解码在 `AbstractProvider`。Awareness 实例随 Provider 走 —— Provider 重建
+ * （连接 / 文档切换）后这里会重新接线并补发本端状态。
+ */
+declare const _default: import("mce").Plugin;
+export default _default;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@mce/collaboration",
+  "type": "module",
+  "version": "0.24.4",
+  "description": "Collaboration plugin for mce",
+  "author": "wxm",
+  "license": "MIT",
+  "homepage": "https://github.com/qq15725/mce",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qq15725/mce.git"
+  },
+  "bugs": {
+    "url": "https://github.com/qq15725/mce/issues"
+  },
+  "keywords": [
+    "mce",
+    "collaboration",
+    "plugin"
+  ],
+  "sideEffects": true,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./*.mjs": "./*.js",
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "browser": "./dist/index.js",
+  "typings": "dist/index.d.ts",
+  "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "*",
+        "dist/*",
+        "dist/*.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.7",
+    "mce": "0.24.4"
+  },
+  "peerDependencies": {
+    "mce": "^0",
+    "vue": "^3.5.0"
+  },
+  "scripts": {
+    "build:code": "vite build",
+    "build:tsc": "NODE_ENV=production vue-tsc --emitDeclarationOnly --project tsconfig.json",
+    "build": "pnpm build:code && pnpm build:tsc",
+    "lint": "eslint src",
+    "typecheck": "vue-tsc --noEmit --project tsconfig.json",
+    "test": "vitest --run"
+  }
+}