@prosekit/extensions 0.16.0-beta.0 → 0.16.0

package/dist/{prosekit-extensions-loro.js → loro.js}

@@ -1,6 +1,5 @@
 import { defineCommands, defineKeymap, definePlugin, isApple, union, withPriority } from "@prosekit/core";
 import { LoroCursorPlugin, LoroEphemeralCursorPlugin, LoroSyncPlugin, LoroUndoPlugin, redo, undo } from "loro-prosemirror";
-//#region src/loro/loro-commands.ts
 const commands = {
 	undo: () => undo,
 	redo: () => redo
@@ -8,8 +7,6 @@ const commands = {
 function defineLoroCommands() {
 	return defineCommands(commands);
 }
-//#endregion
-//#region src/loro/loro-cursor-plugin.ts
 function defineLoroCursorPlugin(options) {
 	return definePlugin(createLoroCursorPlugin(options));
 }
@@ -20,8 +17,6 @@ function createLoroCursorPlugin(options) {
 	else if (presence) return LoroEphemeralCursorPlugin(presence, rest);
 	else throw new Error("Either awareness or presence must be provided");
 }
-//#endregion
-//#region src/loro/loro-keymap.ts
 const keymap = {
 	"Mod-z": undo,
 	"Mod-Z": redo
@@ -30,18 +25,12 @@ if (!isApple) keymap["Mod-y"] = redo;
 function defineLoroKeymap() {
 	return defineKeymap(keymap);
 }
-//#endregion
-//#region src/loro/loro-sync-plugin.ts
 function defineLoroSyncPlugin(options) {
 	return definePlugin(LoroSyncPlugin(options));
 }
-//#endregion
-//#region src/loro/loro-undo-plugin.ts
 function defineLoroUndoPlugin(options) {
 	return definePlugin(LoroUndoPlugin(options));
 }
-//#endregion
-//#region src/loro/loro.ts
 /**
 * @public
 */
@@ -65,7 +54,6 @@ function defineLoro(options) {
 		})
 	]), 3);
 }
-//#endregion
 export { defineLoro, defineLoroCommands, defineLoroCursorPlugin, defineLoroKeymap, defineLoroSyncPlugin, defineLoroUndoPlugin };
 
-//# sourceMappingURL=prosekit-extensions-loro.js.map
+//# sourceMappingURL=loro.js.map

package/dist/loro.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loro.js","names":[],"sources":["../src/loro/loro-commands.ts","../src/loro/loro-cursor-plugin.ts","../src/loro/loro-keymap.ts","../src/loro/loro-sync-plugin.ts","../src/loro/loro-undo-plugin.ts","../src/loro/loro.ts"],"sourcesContent":["import { defineCommands, type Extension } from '@prosekit/core'\nimport { redo, undo } from 'loro-prosemirror'\n\nconst commands = {\n  undo: () => undo,\n  redo: () => redo,\n} as const\n\n/**\n * @internal\n */\nexport type LoroCommandsExtension = Extension<{\n  Commands: {\n    undo: []\n    redo: []\n  }\n}>\n\nexport function defineLoroCommands(): LoroCommandsExtension {\n  return defineCommands(commands)\n}\n","import { definePlugin, type PlainExtension } from '@prosekit/core'\nimport type { Plugin } from '@prosekit/pm/state'\nimport type { CursorAwareness, CursorEphemeralStore, CursorPluginOptions } from 'loro-prosemirror'\nimport { LoroCursorPlugin, LoroEphemeralCursorPlugin } from 'loro-prosemirror'\n\nexport interface LoroCursorOptions extends CursorPluginOptions {\n  awareness?: CursorAwareness\n  presence?: CursorEphemeralStore\n}\n\nexport function defineLoroCursorPlugin(\n  options: LoroCursorOptions,\n): PlainExtension {\n  return definePlugin(createLoroCursorPlugin(options))\n}\n\nfunction createLoroCursorPlugin(options: LoroCursorOptions): Plugin {\n  const { awareness, presence, ...rest } = options\n  if (awareness && presence) {\n    throw new Error('Only one of awareness and presence can be provided')\n  } else if (awareness) {\n    return LoroCursorPlugin(awareness, rest)\n  } else if (presence) {\n    return LoroEphemeralCursorPlugin(presence, rest)\n  } else {\n    throw new Error('Either awareness or presence must be provided')\n  }\n}\n","import { defineKeymap, isApple, type Keymap, type PlainExtension } from '@prosekit/core'\nimport { redo, undo } from 'loro-prosemirror'\n\nconst keymap: Keymap = {\n  'Mod-z': undo,\n  'Mod-Z': redo,\n}\n\nif (!isApple) {\n  keymap['Mod-y'] = redo\n}\n\nexport function defineLoroKeymap(): PlainExtension {\n  return defineKeymap(keymap)\n}\n","import { definePlugin, type PlainExtension } from '@prosekit/core'\nimport { LoroSyncPlugin, type LoroSyncPluginProps } from 'loro-prosemirror'\n\nexport function defineLoroSyncPlugin(\n  options: LoroSyncPluginProps,\n): PlainExtension {\n  return definePlugin(LoroSyncPlugin(options))\n}\n","import { definePlugin, type PlainExtension } from '@prosekit/core'\nimport { LoroUndoPlugin, type LoroUndoPluginProps } from 'loro-prosemirror'\n\nexport function defineLoroUndoPlugin(options: LoroUndoPluginProps): PlainExtension {\n  return definePlugin(LoroUndoPlugin(options))\n}\n","import type { Priority } from '@prosekit/core'\nimport { union, withPriority, type PlainExtension, type Union } from '@prosekit/core'\nimport type {\n  CursorAwareness,\n  CursorEphemeralStore,\n  CursorPluginOptions,\n  LoroDocType,\n  LoroSyncPluginProps,\n  LoroUndoPluginProps,\n} from 'loro-prosemirror'\n\nimport { defineLoroCommands, type LoroCommandsExtension } from './loro-commands.ts'\nimport { defineLoroCursorPlugin } from './loro-cursor-plugin.ts'\nimport { defineLoroKeymap } from './loro-keymap.ts'\nimport { defineLoroSyncPlugin } from './loro-sync-plugin.ts'\nimport { defineLoroUndoPlugin } from './loro-undo-plugin.ts'\n\nexport interface LoroOptions {\n  /**\n   * The Loro instance handles the state of shared data.\n   */\n  doc: LoroDocType\n\n  /**\n   * The (legacy) Awareness instance. One of `awareness` or `presence` must be provided.\n   */\n  awareness?: CursorAwareness\n\n  /**\n   * The CursorEphemeralStore instance. One of `awareness` or `presence` must be provided.\n   */\n  presence?: CursorEphemeralStore\n\n  /**\n   * Extra options for `LoroSyncPlugin`.\n   */\n  sync?: Omit<LoroSyncPluginProps, 'doc'>\n\n  /**\n   * Extra options for the `LoroUndoPlugin`.\n   */\n  undo?: Omit<LoroUndoPluginProps, 'doc'>\n\n  /**\n   * Extra options for `LoroCursorPlugin` or `LoroEphemeralCursorPlugin`.\n   */\n  cursor?: CursorPluginOptions\n}\n\n/**\n * @internal\n */\nexport type LoroExtension = Union<[LoroCommandsExtension, PlainExtension]>\n\n/**\n * @public\n */\nexport function defineLoro(options: LoroOptions): LoroExtension {\n  const { doc, awareness, presence, sync, undo, cursor } = options\n\n  return withPriority(\n    union([\n      defineLoroKeymap(),\n      defineLoroCommands(),\n      defineLoroCursorPlugin({ ...cursor, awareness, presence }),\n      defineLoroUndoPlugin({ ...undo, doc }),\n      defineLoroSyncPlugin({ ...sync, doc }),\n    ]),\n    3 satisfies typeof Priority.high,\n  )\n}\n"],"mappings":";;AAGA,MAAM,WAAW;CACf,YAAY;CACZ,YAAY;CACb;AAYD,SAAgB,qBAA4C;AAC1D,QAAO,eAAe,SAAS;;ACTjC,SAAgB,uBACd,SACgB;AAChB,QAAO,aAAa,uBAAuB,QAAQ,CAAC;;AAGtD,SAAS,uBAAuB,SAAoC;CAClE,MAAM,EAAE,WAAW,UAAU,GAAG,SAAS;AACzC,KAAI,aAAa,SACf,OAAM,IAAI,MAAM,qDAAqD;UAC5D,UACT,QAAO,iBAAiB,WAAW,KAAK;UAC/B,SACT,QAAO,0BAA0B,UAAU,KAAK;KAEhD,OAAM,IAAI,MAAM,gDAAgD;;ACtBpE,MAAM,SAAiB;CACrB,SAAS;CACT,SAAS;CACV;AAED,IAAI,CAAC,QACH,QAAO,WAAW;AAGpB,SAAgB,mBAAmC;AACjD,QAAO,aAAa,OAAO;;ACV7B,SAAgB,qBACd,SACgB;AAChB,QAAO,aAAa,eAAe,QAAQ,CAAC;;ACH9C,SAAgB,qBAAqB,SAA8C;AACjF,QAAO,aAAa,eAAe,QAAQ,CAAC;;;;;ACqD9C,SAAgB,WAAW,SAAqC;CAC9D,MAAM,EAAE,KAAK,WAAW,UAAU,MAAM,MAAM,WAAW;AAEzD,QAAO,aACL,MAAM;EACJ,kBAAkB;EAClB,oBAAoB;EACpB,uBAAuB;GAAE,GAAG;GAAQ;GAAW;GAAU,CAAC;EAC1D,qBAAqB;GAAE,GAAG;GAAM;GAAK,CAAC;EACtC,qBAAqB;GAAE,GAAG;GAAM;GAAK,CAAC;EACvC,CAAC,EACF,EACD"}

package/dist/{prosekit-extensions-mark-rule.d.ts → mark-rule.d.ts}

@@ -1,7 +1,5 @@
 import { PlainExtension } from "@prosekit/core";
 import { Attrs, MarkType } from "@prosekit/pm/model";
-
-//#region src/mark-rule/types.d.ts
 /**
  * The options for {@link defineMarkRule}.
  *
@@ -25,13 +23,10 @@ interface MarkRuleOptions {
    */
   attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
 }
-//#endregion
-//#region src/mark-rule/mark-rule.d.ts
 /**
  * A mark rule is something that can automatically apply marks to text if it
  * matches a certain pattern, and remove them if it doesn't match anymore.
  */
 declare function defineMarkRule(options: MarkRuleOptions): PlainExtension;
-//#endregion
 export { type MarkRuleOptions, defineMarkRule };
-//# sourceMappingURL=prosekit-extensions-mark-rule.d.ts.map
+//# sourceMappingURL=mark-rule.d.ts.map

package/dist/mark-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-rule.d.ts","names":[],"sources":["../src/mark-rule/types.ts","../src/mark-rule/mark-rule.ts"],"mappings":";;;;AAOA;;;UAAiB,eAAA;EAUA;;;;EALf,KAAA,EAAO,MAAA;EAamD;;;EAR1D,IAAA,WAAe,QAAA;EAAA;;;;;;EAQf,KAAA,GAAQ,KAAA,YAAiB,KAAA,EAAO,gBAAA,KAAqB,KAAA;AAAA;;AAlBvD;;;iBCGgB,cAAA,CAAe,OAAA,EAAS,eAAA,GAAkB,cAAA"}

package/dist/mark-rule.js

@@ -1,157 +1,2 @@
-import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
-import { OBJECT_REPLACEMENT_CHARACTER, defineFacet, defineFacetPayload, getMarkType, maybeRun, pluginFacet } from "@prosekit/core";
-//#region src/mark-rule/range.ts
-function getSpanTextRanges($from, $to) {
-	const nodeRange = $from.blockRange($to);
-	if (!nodeRange) return [];
-	const stack = [];
-	let start = nodeRange.start;
-	for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {
-		const child = nodeRange.parent.child(i);
-		stack.push([start, child]);
-		start += child.nodeSize;
-	}
-	const ranges = [];
-	while (stack.length > 0) {
-		const [start, node] = stack.pop();
-		if (node.type.spec.code) continue;
-		if (node.type.isTextblock) {
-			ranges.push([start + 1, start + 1 + node.content.size]);
-			continue;
-		}
-		node.forEach((child, offset) => {
-			stack.push([start + offset + 1, child]);
-		});
-	}
-	return ranges;
-}
-function getInlineTextRange($from, $to) {
-	return [$from.start(), $to.end()];
-}
-function getTextRanges(doc, from, to) {
-	const $from = doc.resolve(from);
-	const $to = doc.resolve(to);
-	if ($from.sameParent($to) && $from.parent.isTextblock) return [getInlineTextRange($from, $to)];
-	else {
-		if (!$from.blockRange($to)) return [];
-		return getSpanTextRanges($from, $to);
-	}
-}
-function getMapRange(transactions, oldState, newState) {
-	let lo = oldState.selection.from;
-	let hi = oldState.selection.to;
-	for (const tr of transactions) for (const map of tr.mapping.maps) {
-		lo = map.map(lo);
-		hi = map.map(hi);
-		map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
-			lo = Math.min(lo, hi, newStart);
-			hi = Math.max(lo, hi, newEnd);
-		});
-	}
-	lo = Math.min(lo, hi, newState.selection.from);
-	hi = Math.min(lo, hi, newState.selection.to);
-	return [lo, hi];
-}
-function getCheckRanges(transactions, oldState, newState) {
-	const [from, to] = getMapRange(transactions, oldState, newState);
-	return getTextRanges(newState.doc, from, to);
-}
-//#endregion
-//#region src/mark-rule/apply.ts
-function getExpectedMarkings(rules, doc, from, to) {
-	const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER);
-	const ranges = [];
-	for (const rule of rules) {
-		rule.regex.lastIndex = 0;
-		const matches = text.matchAll(rule.regex);
-		const markType = getMarkType(doc.type.schema, rule.type);
-		for (const match of matches) {
-			const index = match.index;
-			if (index == null) continue;
-			const attrs = maybeRun(rule.attrs, match);
-			const mark = markType.create(attrs);
-			ranges.push([
-				from + index,
-				from + index + match[0].length,
-				mark
-			]);
-		}
-	}
-	ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
-	const result = [];
-	let freeIndex = 0;
-	for (const range of ranges) if (range[0] >= freeIndex) {
-		result.push(range);
-		freeIndex = range[1];
-	}
-	return result;
-}
-function getReceivedMarkings(rules, doc, from, to) {
-	const result = [];
-	const schema = doc.type.schema;
-	const markTypes = rules.map((rule) => getMarkType(schema, rule.type));
-	doc.nodesBetween(from, to, (node, pos) => {
-		if (!node.isInline) return;
-		for (const markType of markTypes) {
-			const mark = node.marks.find((mark) => mark.type === markType);
-			if (mark) result.push([
-				pos,
-				pos + node.nodeSize,
-				mark
-			]);
-		}
-	});
-	return result;
-}
-function markRangeEquals(a, b) {
-	return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2]);
-}
-function markRangeDiffs(a, b) {
-	return a.filter((x) => !b.some((y) => markRangeEquals(x, y)));
-}
-function applyMarkRules(rules, transactions, oldState, newState) {
-	if (transactions.length === 0 || transactions.every((tr) => !tr.docChanged)) return null;
-	const ranges = getCheckRanges(transactions, oldState, newState);
-	const toRemove = [];
-	const toCreate = [];
-	for (const [from, to] of ranges) {
-		const expected = getExpectedMarkings(rules, newState.doc, from, to);
-		const received = getReceivedMarkings(rules, newState.doc, from, to);
-		toRemove.push(...markRangeDiffs(received, expected));
-		toCreate.push(...markRangeDiffs(expected, received));
-	}
-	if (toCreate.length === 0 && toRemove.length === 0) return null;
-	const tr = newState.tr;
-	for (const [from, to, mark] of toRemove) tr.removeMark(from, to, mark);
-	for (const [from, to, mark] of toCreate) tr.addMark(from, to, mark);
-	return tr;
-}
-//#endregion
-//#region src/mark-rule/mark-rule.ts
-/**
-* A mark rule is something that can automatically apply marks to text if it
-* matches a certain pattern, and remove them if it doesn't match anymore.
-*/
-function defineMarkRule(options) {
-	return defineFacetPayload(markRuleFacet, [options]);
-}
-const markRuleFacet = defineFacet({
-	reduce: () => {
-		let rules = [];
-		const plugin = new ProseMirrorPlugin({
-			key: new PluginKey("prosekit-mark-rule"),
-			appendTransaction: (transactions, oldState, newState) => {
-				return applyMarkRules(rules, transactions, oldState, newState);
-			}
-		});
-		return function reducer(input) {
-			rules = input;
-			return plugin;
-		};
-	},
-	parent: pluginFacet
-});
-//#endregion
-export { defineMarkRule as t };
-
-//# sourceMappingURL=mark-rule.js.map
+import { t as defineMarkRule } from "./mark-rule2.js";
+export { defineMarkRule };

package/dist/mark-rule2.js

@@ -0,0 +1,151 @@
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+import { OBJECT_REPLACEMENT_CHARACTER, defineFacet, defineFacetPayload, getMarkType, maybeRun, pluginFacet } from "@prosekit/core";
+function getSpanTextRanges($from, $to) {
+	const nodeRange = $from.blockRange($to);
+	if (!nodeRange) return [];
+	const stack = [];
+	let start = nodeRange.start;
+	for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {
+		const child = nodeRange.parent.child(i);
+		stack.push([start, child]);
+		start += child.nodeSize;
+	}
+	const ranges = [];
+	while (stack.length > 0) {
+		const [start, node] = stack.pop();
+		if (node.type.spec.code) continue;
+		if (node.type.isTextblock) {
+			ranges.push([start + 1, start + 1 + node.content.size]);
+			continue;
+		}
+		node.forEach((child, offset) => {
+			stack.push([start + offset + 1, child]);
+		});
+	}
+	return ranges;
+}
+function getInlineTextRange($from, $to) {
+	return [$from.start(), $to.end()];
+}
+function getTextRanges(doc, from, to) {
+	const $from = doc.resolve(from);
+	const $to = doc.resolve(to);
+	if ($from.sameParent($to) && $from.parent.isTextblock) return [getInlineTextRange($from, $to)];
+	else {
+		if (!$from.blockRange($to)) return [];
+		return getSpanTextRanges($from, $to);
+	}
+}
+function getMapRange(transactions, oldState, newState) {
+	let lo = oldState.selection.from;
+	let hi = oldState.selection.to;
+	for (const tr of transactions) for (const map of tr.mapping.maps) {
+		lo = map.map(lo);
+		hi = map.map(hi);
+		map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+			lo = Math.min(lo, hi, newStart);
+			hi = Math.max(lo, hi, newEnd);
+		});
+	}
+	lo = Math.min(lo, hi, newState.selection.from);
+	hi = Math.min(lo, hi, newState.selection.to);
+	return [lo, hi];
+}
+function getCheckRanges(transactions, oldState, newState) {
+	const [from, to] = getMapRange(transactions, oldState, newState);
+	return getTextRanges(newState.doc, from, to);
+}
+function getExpectedMarkings(rules, doc, from, to) {
+	const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER);
+	const ranges = [];
+	for (const rule of rules) {
+		rule.regex.lastIndex = 0;
+		const matches = text.matchAll(rule.regex);
+		const markType = getMarkType(doc.type.schema, rule.type);
+		for (const match of matches) {
+			const index = match.index;
+			if (index == null) continue;
+			const attrs = maybeRun(rule.attrs, match);
+			const mark = markType.create(attrs);
+			ranges.push([
+				from + index,
+				from + index + match[0].length,
+				mark
+			]);
+		}
+	}
+	ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+	const result = [];
+	let freeIndex = 0;
+	for (const range of ranges) if (range[0] >= freeIndex) {
+		result.push(range);
+		freeIndex = range[1];
+	}
+	return result;
+}
+function getReceivedMarkings(rules, doc, from, to) {
+	const result = [];
+	const schema = doc.type.schema;
+	const markTypes = rules.map((rule) => getMarkType(schema, rule.type));
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isInline) return;
+		for (const markType of markTypes) {
+			const mark = node.marks.find((mark) => mark.type === markType);
+			if (mark) result.push([
+				pos,
+				pos + node.nodeSize,
+				mark
+			]);
+		}
+	});
+	return result;
+}
+function markRangeEquals(a, b) {
+	return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2]);
+}
+function markRangeDiffs(a, b) {
+	return a.filter((x) => !b.some((y) => markRangeEquals(x, y)));
+}
+function applyMarkRules(rules, transactions, oldState, newState) {
+	if (transactions.length === 0 || transactions.every((tr) => !tr.docChanged)) return null;
+	const ranges = getCheckRanges(transactions, oldState, newState);
+	const toRemove = [];
+	const toCreate = [];
+	for (const [from, to] of ranges) {
+		const expected = getExpectedMarkings(rules, newState.doc, from, to);
+		const received = getReceivedMarkings(rules, newState.doc, from, to);
+		toRemove.push(...markRangeDiffs(received, expected));
+		toCreate.push(...markRangeDiffs(expected, received));
+	}
+	if (toCreate.length === 0 && toRemove.length === 0) return null;
+	const tr = newState.tr;
+	for (const [from, to, mark] of toRemove) tr.removeMark(from, to, mark);
+	for (const [from, to, mark] of toCreate) tr.addMark(from, to, mark);
+	return tr;
+}
+/**
+* A mark rule is something that can automatically apply marks to text if it
+* matches a certain pattern, and remove them if it doesn't match anymore.
+*/
+function defineMarkRule(options) {
+	return defineFacetPayload(markRuleFacet, [options]);
+}
+const markRuleFacet = defineFacet({
+	reduce: () => {
+		let rules = [];
+		const plugin = new ProseMirrorPlugin({
+			key: new PluginKey("prosekit-mark-rule"),
+			appendTransaction: (transactions, oldState, newState) => {
+				return applyMarkRules(rules, transactions, oldState, newState);
+			}
+		});
+		return function reducer(input) {
+			rules = input;
+			return plugin;
+		};
+	},
+	parent: pluginFacet
+});
+export { defineMarkRule as t };
+
+//# sourceMappingURL=mark-rule2.js.map

package/dist/mark-rule2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-rule2.js","names":[],"sources":["../src/mark-rule/range.ts","../src/mark-rule/apply.ts","../src/mark-rule/mark-rule.ts"],"sourcesContent":["import type { ProseMirrorNode, ResolvedPos } from '@prosekit/pm/model'\nimport type { EditorState, Transaction } from '@prosekit/pm/state'\nimport type { ProsemirrorNode } from 'prosemirror-flat-list'\n\nfunction getSpanTextRanges($from: ResolvedPos, $to: ResolvedPos) {\n  const nodeRange = $from.blockRange($to)\n  if (!nodeRange) {\n    return []\n  }\n\n  const stack: Array<[start: number, node: ProseMirrorNode]> = []\n  let start = nodeRange.start\n\n  for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {\n    const child = nodeRange.parent.child(i)\n    stack.push([start, child])\n    start += child.nodeSize\n  }\n\n  const ranges: Array<[number, number]> = []\n\n  while (stack.length > 0) {\n    const [start, node] = stack.pop()!\n    if (node.type.spec.code) {\n      continue\n    }\n\n    if (node.type.isTextblock) {\n      ranges.push([start + 1, start + 1 + node.content.size])\n      continue\n    }\n\n    node.forEach((child, offset) => {\n      stack.push([start + offset + 1, child])\n    })\n  }\n\n  return ranges\n}\n\nfunction getInlineTextRange(\n  $from: ResolvedPos,\n  $to: ResolvedPos,\n): [number, number] {\n  return [$from.start(), $to.end()]\n}\n\nfunction getTextRanges(\n  doc: ProsemirrorNode,\n  from: number,\n  to: number,\n): Array<[number, number]> {\n  const $from = doc.resolve(from)\n  const $to = doc.resolve(to)\n\n  if ($from.sameParent($to) && $from.parent.isTextblock) {\n    return [getInlineTextRange($from, $to)]\n  } else {\n    const nodeRange = $from.blockRange($to)\n    if (!nodeRange) {\n      return []\n    }\n\n    return getSpanTextRanges($from, $to)\n  }\n}\n\nfunction getMapRange(\n  transactions: readonly Transaction[],\n  oldState: EditorState,\n  newState: EditorState,\n) {\n  let lo = oldState.selection.from\n  let hi = oldState.selection.to\n\n  for (const tr of transactions) {\n    for (const map of tr.mapping.maps) {\n      lo = map.map(lo)\n      hi = map.map(hi)\n\n      map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {\n        lo = Math.min(lo, hi, newStart)\n        hi = Math.max(lo, hi, newEnd)\n      })\n    }\n  }\n\n  lo = Math.min(lo, hi, newState.selection.from)\n  hi = Math.min(lo, hi, newState.selection.to)\n\n  return [lo, hi] as const\n}\n\nexport function getCheckRanges(\n  transactions: readonly Transaction[],\n  oldState: EditorState,\n  newState: EditorState,\n): Array<[number, number]> {\n  const [from, to] = getMapRange(transactions, oldState, newState)\n  return getTextRanges(newState.doc, from, to)\n}\n","import { getMarkType, maybeRun, OBJECT_REPLACEMENT_CHARACTER } from '@prosekit/core'\nimport type { Mark, ProseMirrorNode } from '@prosekit/pm/model'\nimport type { EditorState, Transaction } from '@prosekit/pm/state'\n\nimport { getCheckRanges } from './range.ts'\nimport type { MarkRuleOptions } from './types.ts'\n\ntype MarkRange = [from: number, to: number, mark: Mark]\n\nfunction getExpectedMarkings(\n  rules: MarkRuleOptions[],\n  doc: ProseMirrorNode,\n  from: number,\n  to: number,\n): MarkRange[] {\n  const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER)\n  const ranges: MarkRange[] = []\n\n  for (const rule of rules) {\n    rule.regex.lastIndex = 0\n    const matches = text.matchAll(rule.regex)\n    const markType = getMarkType(doc.type.schema, rule.type)\n\n    for (const match of matches) {\n      const index = match.index\n      if (index == null) continue\n      const attrs = maybeRun(rule.attrs, match)\n      const mark = markType.create(attrs)\n      ranges.push([from + index, from + index + match[0].length, mark])\n    }\n  }\n\n  // Sort by start position. If start positions are equal, the longer match\n  // should be prioritized.\n  ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1])\n\n  // Remove overlapped marks.\n  const result: MarkRange[] = []\n  let freeIndex = 0\n\n  for (const range of ranges) {\n    if (range[0] >= freeIndex) {\n      result.push(range)\n      freeIndex = range[1]\n    }\n  }\n\n  return result\n}\n\nfunction getReceivedMarkings(\n  rules: MarkRuleOptions[],\n  doc: ProseMirrorNode,\n  from: number,\n  to: number,\n): MarkRange[] {\n  const result: MarkRange[] = []\n  const schema = doc.type.schema\n  const markTypes = rules.map((rule) => getMarkType(schema, rule.type))\n\n  doc.nodesBetween(from, to, (node, pos) => {\n    if (!node.isInline) {\n      return\n    }\n\n    for (const markType of markTypes) {\n      const mark = node.marks.find((mark) => mark.type === markType)\n      if (mark) {\n        result.push([pos, pos + node.nodeSize, mark])\n      }\n    }\n  })\n  return result\n}\n\nfunction markRangeEquals(a: MarkRange, b: MarkRange): boolean {\n  return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2])\n}\n\nfunction markRangeDiffs(a: MarkRange[], b: MarkRange[]): MarkRange[] {\n  return a.filter((x) => !b.some((y) => markRangeEquals(x, y)))\n}\n\nexport function applyMarkRules(\n  rules: MarkRuleOptions[],\n  transactions: readonly Transaction[],\n  oldState: EditorState,\n  newState: EditorState,\n): Transaction | null {\n  if (transactions.length === 0 || transactions.every((tr) => !tr.docChanged)) {\n    return null\n  }\n\n  const ranges = getCheckRanges(transactions, oldState, newState)\n\n  const toRemove: MarkRange[] = []\n  const toCreate: MarkRange[] = []\n\n  for (const [from, to] of ranges) {\n    const expected = getExpectedMarkings(rules, newState.doc, from, to)\n    const received = getReceivedMarkings(rules, newState.doc, from, to)\n\n    toRemove.push(...markRangeDiffs(received, expected))\n    toCreate.push(...markRangeDiffs(expected, received))\n  }\n\n  if (toCreate.length === 0 && toRemove.length === 0) {\n    return null\n  }\n\n  const tr = newState.tr\n  for (const [from, to, mark] of toRemove) {\n    tr.removeMark(from, to, mark)\n  }\n  for (const [from, to, mark] of toCreate) {\n    tr.addMark(from, to, mark)\n  }\n  return tr\n}\n","import { defineFacet, defineFacetPayload, pluginFacet, type PlainExtension, type PluginPayload } from '@prosekit/core'\nimport { PluginKey, ProseMirrorPlugin, type EditorState, type Transaction } from '@prosekit/pm/state'\n\nimport { applyMarkRules } from './apply.ts'\nimport type { MarkRuleOptions } from './types.ts'\n\n/**\n * A mark rule is something that can automatically apply marks to text if it\n * matches a certain pattern, and remove them if it doesn't match anymore.\n */\nexport function defineMarkRule(options: MarkRuleOptions): PlainExtension {\n  return defineFacetPayload(markRuleFacet, [options]) as PlainExtension\n}\n\nconst markRuleFacet = defineFacet<MarkRuleOptions, PluginPayload>({\n  reduce: () => {\n    let rules: MarkRuleOptions[] = []\n\n    const plugin = new ProseMirrorPlugin({\n      key: new PluginKey('prosekit-mark-rule'),\n      appendTransaction: (\n        transactions: readonly Transaction[],\n        oldState: EditorState,\n        newState: EditorState,\n      ) => {\n        return applyMarkRules(rules, transactions, oldState, newState)\n      },\n    })\n\n    return function reducer(input) {\n      rules = input\n      return plugin\n    }\n  },\n\n  parent: pluginFacet,\n})\n"],"mappings":"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"}

package/dist/{prosekit-extensions-math.d.ts → math.d.ts}

@@ -1,8 +1,6 @@
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 import { Attrs } from "@prosekit/pm/model";
 import { RenderMathBlock, RenderMathInline } from "prosemirror-math";
-
-//#region src/math/math-block.d.ts
 /**
  * @internal
  */
@@ -61,8 +59,6 @@ type MathBlockExtension = Union<[MathBlockSpecExtension]>;
  * @public
  */
 declare function defineMathBlock(options: MathBlockOptions): MathBlockExtension;
-//#endregion
-//#region src/math/math-inline.d.ts
 /**
  * @internal
  */
@@ -121,11 +117,7 @@ type MathInlineExtension = Union<[MathInlineSpecExtension]>;
  * @public
  */
 declare function defineMathInline(options: MathInlineOptions): MathInlineExtension;
-//#endregion
-//#region src/math/math-plugin.d.ts
 declare function defineMathPlugin(): PlainExtension;
-//#endregion
-//#region src/math/math.d.ts
 /**
  * @public
  */
@@ -149,6 +141,5 @@ interface MathOptions {
  * @public
  */
 declare function defineMath(options: MathOptions): MathExtension;
-//#endregion
 export { type MathBlockExtension, type MathBlockOptions, type MathBlockSpecExtension, type MathBlockViewOptions, type MathExtension, type MathInlineExtension, type MathInlineOptions, type MathInlineSpecExtension, type MathInlineViewOptions, type MathOptions, defineMath, defineMathBlock, defineMathBlockEnterRule, defineMathBlockSpec, defineMathBlockView, defineMathInline, defineMathInlineInputRule, defineMathInlineSpec, defineMathInlineView, defineMathPlugin };
-//# sourceMappingURL=prosekit-extensions-math.d.ts.map
+//# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math/math-block.ts","../src/math/math-inline.ts","../src/math/math-plugin.ts","../src/math/math.ts"],"mappings":";;;;AASA;;KAAY,sBAAA,GAAyB,SAAA;EACnC,KAAA;IACE,SAAA,EAAW,KAAA;EAAA;AAAA;;;;iBAOC,mBAAA,CAAA,GAAuB,sBAAA;;;;;AAmBvC;UAAiB,oBAAA;;;;EAIf,MAAA,EAAQ,eAAA;AAAA;;;;;;;iBASM,mBAAA,CAAA;EAAsB;AAAA,GAAU,oBAAA,GAAuB,SAAA;;;;iBAYvD,wBAAA,CAAA,GAA4B,cAAA;;AAA5C;;;;UASiB,gBAAA;EAAA;;;EAIf,MAAA,EAAQ,eAAA;AAAA;AAMV;;;AAAA,KAAY,kBAAA,GAAqB,KAAA,EAAO,sBAAA;;AAQxC;;;;;iBAAgB,eAAA,CAAgB,OAAA,EAAS,gBAAA,GAAmB,kBAAA;;AAhF5D;;KCAY,uBAAA,GAA0B,SAAA;EACpC,KAAA;IACE,UAAA,EAAY,KAAA;EAAA;AAAA;;;;iBAOA,oBAAA,CAAA,GAAwB,uBAAA;;;;;ADmBxC;UCPiB,qBAAA;;;;EAIf,MAAA,EAAQ,gBAAA;AAAA;;;;;;;iBASM,oBAAA,CAAA;EAAuB;AAAA,GAAU,qBAAA,GAAwB,SAAA;;;;iBAYzD,yBAAA,CAAA,GAA6B,cAAA;;ADO7C;;;;UCEiB,iBAAA;EDOA;;;ECHf,MAAA,EAAQ,gBAAA;AAAA;ADaV;;;AAAA,KCPY,mBAAA,GAAsB,KAAA,EAAO,uBAAA;;ADezC;;;;;iBCPgB,gBAAA,CAAiB,OAAA,EAAS,iBAAA,GAAoB,mBAAA;AAAA,iBC/E9C,gBAAA,CAAA,GAAoB,cAAA;AFMpC;;;AAAA,KGCY,aAAA,GAAgB,KAAA,EAAO,mBAAA,EAAqB,kBAAA;;;;;;UAOvC,WAAA;EHCD;;;EGGd,eAAA,EAAiB,eAAA;EHH0C;AAmB7D;;EGXE,gBAAA,EAAkB,gBAAA;AAAA;;AHwBpB;;iBGlBgB,UAAA,CAAW,OAAA,EAAS,WAAA,GAAc,aAAA"}

package/dist/{prosekit-extensions-math.js → math.js}

@@ -1,8 +1,7 @@
-import { defineInputRule } from "./prosekit-extensions-input-rule.js";
-import { defineEnterRule } from "./prosekit-extensions-enter-rule.js";
+import { defineInputRule } from "./input-rule.js";
+import { defineEnterRule } from "./enter-rule.js";
 import { defineNodeSpec, defineNodeView, definePlugin, union } from "@prosekit/core";
 import { createCursorInsidePlugin, createMathBlockView, createMathInlineInputRule, createMathInlineView, mathBlockEnterRule, mathBlockSpec, mathInlineSpec } from "prosemirror-math";
-//#region src/math/math-block.ts
 /**
 * @internal
 */
@@ -45,8 +44,6 @@ function defineMathBlockEnterRule() {
 function defineMathBlock(options) {
 	return union(defineMathBlockSpec(), defineMathBlockView(options), defineMathBlockEnterRule());
 }
-//#endregion
-//#region src/math/math-inline.ts
 /**
 * @internal
 */
@@ -85,20 +82,15 @@ function defineMathInlineInputRule() {
 function defineMathInline(options) {
 	return union(defineMathInlineSpec(), defineMathInlineView(options), defineMathInlineInputRule());
 }
-//#endregion
-//#region src/math/math-plugin.ts
 function defineMathPlugin() {
 	return definePlugin(createCursorInsidePlugin());
 }
-//#endregion
-//#region src/math/math.ts
 /**
 * @public
 */
 function defineMath(options) {
 	return union(defineMathBlock({ render: options.renderMathBlock }), defineMathInline({ render: options.renderMathInline }), defineMathPlugin());
 }
-//#endregion
 export { defineMath, defineMathBlock, defineMathBlockEnterRule, defineMathBlockSpec, defineMathBlockView, defineMathInline, defineMathInlineInputRule, defineMathInlineSpec, defineMathInlineView, defineMathPlugin };
 
-//# sourceMappingURL=prosekit-extensions-math.js.map
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","names":[],"sources":["../src/math/math-block.ts","../src/math/math-inline.ts","../src/math/math-plugin.ts","../src/math/math.ts"],"sourcesContent":["import { defineNodeSpec, defineNodeView, union, type Extension, type PlainExtension, type Union } from '@prosekit/core'\nimport type { Attrs } from '@prosekit/pm/model'\nimport { createMathBlockView, mathBlockEnterRule, mathBlockSpec, type RenderMathBlock } from 'prosemirror-math'\n\nimport { defineEnterRule } from '../enter-rule/index.ts'\n\n/**\n * @internal\n */\nexport type MathBlockSpecExtension = Extension<{\n  Nodes: {\n    mathBlock: Attrs\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineMathBlockSpec(): MathBlockSpecExtension {\n  return defineNodeSpec<'mathBlock', Attrs>({\n    ...mathBlockSpec,\n    attrs: {\n      // The language in the `mathBlock` node, useful for syntax highlighting.\n      // This library doesn't focus on using the TeX language in a `mathBlock` node,\n      // but this is the most common language used for math blocks in rich text\n      // editors, so 'tex' is set as the default value.\n      language: { default: 'tex', validate: 'string' },\n    },\n    name: 'mathBlock',\n  })\n}\n\n/**\n * Options for {@link defineMathBlockView}.\n *\n * @internal\n */\nexport interface MathBlockViewOptions {\n  /**\n   * The function to render the math block.\n   */\n  render: RenderMathBlock\n}\n\n/**\n * Defines an extension that renders a math block using a custom node view.\n *\n * @param options\n * @internal\n */\nexport function defineMathBlockView({ render }: MathBlockViewOptions): Extension {\n  return defineNodeView({\n    name: 'mathBlock',\n    constructor: (node, view, getPos, decorations) => {\n      return createMathBlockView(render, node, decorations)\n    },\n  })\n}\n\n/**\n * @internal\n */\nexport function defineMathBlockEnterRule(): PlainExtension {\n  return defineEnterRule(mathBlockEnterRule)\n}\n\n/**\n * Options for {@link defineMathBlock}.\n *\n * @internal\n */\nexport interface MathBlockOptions {\n  /**\n   * The function to render the math block.\n   */\n  render: RenderMathBlock\n}\n\n/**\n * @internal\n */\nexport type MathBlockExtension = Union<[MathBlockSpecExtension]>\n\n/**\n * Defines node `mathBlock` and related functionalities.\n *\n * @param options\n * @public\n */\nexport function defineMathBlock(options: MathBlockOptions): MathBlockExtension {\n  return union(\n    defineMathBlockSpec(),\n    defineMathBlockView(options),\n    defineMathBlockEnterRule(),\n  )\n}\n","import { defineNodeSpec, defineNodeView, union, type Extension, type PlainExtension, type Union } from '@prosekit/core'\nimport type { Attrs } from '@prosekit/pm/model'\nimport { createMathInlineInputRule, createMathInlineView, mathInlineSpec, type RenderMathInline } from 'prosemirror-math'\n\nimport { defineInputRule } from '../input-rule/index.ts'\n\n/**\n * @internal\n */\nexport type MathInlineSpecExtension = Extension<{\n  Nodes: {\n    mathInline: Attrs\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineMathInlineSpec(): MathInlineSpecExtension {\n  return defineNodeSpec<'mathInline', Attrs>({\n    ...mathInlineSpec,\n    name: 'mathInline',\n  })\n}\n\n/**\n * Options for {@link defineMathInlineView}.\n *\n * @internal\n */\nexport interface MathInlineViewOptions {\n  /**\n   * The function to render the math inline.\n   */\n  render: RenderMathInline\n}\n\n/**\n * Defines an extension that renders a math inline using a custom node view.\n *\n * @param options\n * @internal\n */\nexport function defineMathInlineView({ render }: MathInlineViewOptions): Extension {\n  return defineNodeView({\n    name: 'mathInline',\n    constructor: (node, view, getPos, decorations) => {\n      return createMathInlineView(render, node, decorations)\n    },\n  })\n}\n\n/**\n * @internal\n */\nexport function defineMathInlineInputRule(): PlainExtension {\n  return defineInputRule(createMathInlineInputRule('mathInline'))\n}\n\n/**\n * Options for {@link defineMathInline}.\n *\n * @internal\n */\nexport interface MathInlineOptions {\n  /**\n   * The function to render the math inline.\n   */\n  render: RenderMathInline\n}\n\n/**\n * @internal\n */\nexport type MathInlineExtension = Union<[MathInlineSpecExtension]>\n\n/**\n * Defines node `mathInline` and related functionalities.\n *\n * @param options\n * @public\n */\nexport function defineMathInline(options: MathInlineOptions): MathInlineExtension {\n  return union(\n    defineMathInlineSpec(),\n    defineMathInlineView(options),\n    defineMathInlineInputRule(),\n  )\n}\n","import { definePlugin, type PlainExtension } from '@prosekit/core'\nimport { createCursorInsidePlugin } from 'prosemirror-math'\n\nexport function defineMathPlugin(): PlainExtension {\n  return definePlugin(\n    createCursorInsidePlugin(),\n  )\n}\n","import { union, type Union } from '@prosekit/core'\nimport type { RenderMathBlock, RenderMathInline } from 'prosemirror-math'\n\nimport { defineMathBlock, type MathBlockExtension } from './math-block.ts'\nimport { defineMathInline, type MathInlineExtension } from './math-inline.ts'\nimport { defineMathPlugin } from './math-plugin.ts'\n\n/**\n * @public\n */\nexport type MathExtension = Union<[MathInlineExtension, MathBlockExtension]>\n\n/**\n * Options for {@link defineMath}.\n *\n * @public\n */\nexport interface MathOptions {\n  /**\n   * The function to render the math block.\n   */\n  renderMathBlock: RenderMathBlock\n\n  /**\n   * The function to render the math inline.\n   */\n  renderMathInline: RenderMathInline\n}\n\n/**\n * @public\n */\nexport function defineMath(options: MathOptions): MathExtension {\n  return union(\n    defineMathBlock({ render: options.renderMathBlock }),\n    defineMathInline({ render: options.renderMathInline }),\n    defineMathPlugin(),\n  )\n}\n"],"mappings":";;;;;;;AAkBA,SAAgB,sBAA8C;AAC5D,QAAO,eAAmC;EACxC,GAAG;EACH,OAAO,EAKL,UAAU;GAAE,SAAS;GAAO,UAAU;GAAU,EACjD;EACD,MAAM;EACP,CAAC;;;;;;;;AAqBJ,SAAgB,oBAAoB,EAAE,UAA2C;AAC/E,QAAO,eAAe;EACpB,MAAM;EACN,cAAc,MAAM,MAAM,QAAQ,gBAAgB;AAChD,UAAO,oBAAoB,QAAQ,MAAM,YAAY;;EAExD,CAAC;;;;;AAMJ,SAAgB,2BAA2C;AACzD,QAAO,gBAAgB,mBAAmB;;;;;;;;AA0B5C,SAAgB,gBAAgB,SAA+C;AAC7E,QAAO,MACL,qBAAqB,EACrB,oBAAoB,QAAQ,EAC5B,0BAA0B,CAC3B;;;;;AC5EH,SAAgB,uBAAgD;AAC9D,QAAO,eAAoC;EACzC,GAAG;EACH,MAAM;EACP,CAAC;;;;;;;;AAqBJ,SAAgB,qBAAqB,EAAE,UAA4C;AACjF,QAAO,eAAe;EACpB,MAAM;EACN,cAAc,MAAM,MAAM,QAAQ,gBAAgB;AAChD,UAAO,qBAAqB,QAAQ,MAAM,YAAY;;EAEzD,CAAC;;;;;AAMJ,SAAgB,4BAA4C;AAC1D,QAAO,gBAAgB,0BAA0B,aAAa,CAAC;;;;;;;;AA0BjE,SAAgB,iBAAiB,SAAiD;AAChF,QAAO,MACL,sBAAsB,EACtB,qBAAqB,QAAQ,EAC7B,2BAA2B,CAC5B;;ACpFH,SAAgB,mBAAmC;AACjD,QAAO,aACL,0BAA0B,CAC3B;;;;;AC0BH,SAAgB,WAAW,SAAqC;AAC9D,QAAO,MACL,gBAAgB,EAAE,QAAQ,QAAQ,iBAAiB,CAAC,EACpD,iBAAiB,EAAE,QAAQ,QAAQ,kBAAkB,CAAC,EACtD,kBAAkB,CACnB"}

package/dist/{prosekit-extensions-mention.d.ts → mention.d.ts}

@@ -1,6 +1,4 @@
 import { Extension, Union } from "@prosekit/core";
-
-//#region src/mention/index.d.ts
 interface MentionAttrs {
   id: string;
   value: string;
@@ -35,6 +33,5 @@ type MentionExtension = Union<[MentionSpecExtension, MentionCommandsExtension]>;
  * @public
  */
 declare function defineMention(): MentionExtension;
-//#endregion
 export { MentionAttrs, MentionCommandsExtension, MentionExtension, MentionSpecExtension, defineMention, defineMentionCommands, defineMentionSpec };
-//# sourceMappingURL=prosekit-extensions-mention.d.ts.map
+//# sourceMappingURL=mention.d.ts.map

package/dist/mention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mention.d.ts","names":[],"sources":["../src/mention/index.ts"],"mappings":";UAEiB,YAAA;EACf,EAAA;EACA,KAAA;EACA,IAAA;AAAA;;;;KAMU,oBAAA,GAAuB,SAAA;EACjC,KAAA;IACE,OAAA,EAAS,YAAA;EAAA;AAAA;;;;iBAOG,iBAAA,CAAA,GAAqB,oBAAA;;;;KAsCzB,wBAAA,GAA2B,SAAA;EACrC,QAAA;IACE,aAAA,GAAgB,KAAA,EAAO,YAAA;EAAA;AAAA;AAAA,iBAIX,qBAAA,CAAA,GAAyB,wBAAA;;;;KAW7B,gBAAA,GAAmB,KAAA,EAAO,oBAAA,EAAsB,wBAAA;;;;iBAK5C,aAAA,CAAA,GAAiB,gBAAA"}

package/dist/{prosekit-extensions-mention.js → mention.js}

@@ -1,5 +1,4 @@
 import { defineCommands, defineNodeSpec, insertNode, union } from "@prosekit/core";
-//#region src/mention/index.ts
 /**
 * @public
 */
@@ -52,7 +51,6 @@ function defineMentionCommands() {
 function defineMention() {
 	return union(defineMentionSpec(), defineMentionCommands());
 }
-//#endregion
 export { defineMention, defineMentionCommands, defineMentionSpec };
 
-//# sourceMappingURL=prosekit-extensions-mention.js.map
+//# sourceMappingURL=mention.js.map

package/dist/mention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mention.js","names":[],"sources":["../src/mention/index.ts"],"sourcesContent":["import { defineCommands, defineNodeSpec, insertNode, union, type Extension, type Union } from '@prosekit/core'\n\nexport interface MentionAttrs {\n  id: string\n  value: string\n  kind: string\n}\n\n/**\n * @internal\n */\nexport type MentionSpecExtension = Extension<{\n  Nodes: {\n    mention: MentionAttrs\n  }\n}>\n\n/**\n * @public\n */\nexport function defineMentionSpec(): MentionSpecExtension {\n  return defineNodeSpec<'mention', MentionAttrs>({\n    name: 'mention',\n    atom: true,\n    group: 'inline',\n    attrs: {\n      id: { validate: 'string' },\n      value: { validate: 'string' },\n      kind: { default: '', validate: 'string' },\n    },\n    inline: true,\n    leafText: (node) => (node.attrs as MentionAttrs).value.toString(),\n    parseDOM: [\n      {\n        tag: `span[data-mention]`,\n        getAttrs: (dom: HTMLElement): MentionAttrs => ({\n          id: dom.getAttribute('data-id') || '',\n          kind: dom.getAttribute('data-mention') || '',\n          value: dom.textContent || '',\n        }),\n      },\n    ],\n    toDOM(node) {\n      return [\n        'span',\n        {\n          'data-id': (node.attrs as MentionAttrs).id.toString(),\n          'data-mention': (node.attrs as MentionAttrs).kind.toString(),\n        },\n        (node.attrs as MentionAttrs).value.toString(),\n      ]\n    },\n  })\n}\n\n/**\n * @internal\n */\nexport type MentionCommandsExtension = Extension<{\n  Commands: {\n    insertMention: [attrs: MentionAttrs]\n  }\n}>\n\nexport function defineMentionCommands(): MentionCommandsExtension {\n  return defineCommands({\n    insertMention: (attrs: MentionAttrs) => {\n      return insertNode({ type: 'mention', attrs })\n    },\n  })\n}\n\n/**\n * @internal\n */\nexport type MentionExtension = Union<[MentionSpecExtension, MentionCommandsExtension]>\n\n/**\n * @public\n */\nexport function defineMention(): MentionExtension {\n  return union(defineMentionSpec(), defineMentionCommands())\n}\n"],"mappings":";;;;AAoBA,SAAgB,oBAA0C;AACxD,QAAO,eAAwC;EAC7C,MAAM;EACN,MAAM;EACN,OAAO;EACP,OAAO;GACL,IAAI,EAAE,UAAU,UAAU;GAC1B,OAAO,EAAE,UAAU,UAAU;GAC7B,MAAM;IAAE,SAAS;IAAI,UAAU;IAAU;GAC1C;EACD,QAAQ;EACR,WAAW,SAAU,KAAK,MAAuB,MAAM,UAAU;EACjE,UAAU,CACR;GACE,KAAK;GACL,WAAW,SAAoC;IAC7C,IAAI,IAAI,aAAa,UAAU,IAAI;IACnC,MAAM,IAAI,aAAa,eAAe,IAAI;IAC1C,OAAO,IAAI,eAAe;IAC3B;GACF,CACF;EACD,MAAM,MAAM;AACV,UAAO;IACL;IACA;KACE,WAAY,KAAK,MAAuB,GAAG,UAAU;KACrD,gBAAiB,KAAK,MAAuB,KAAK,UAAU;KAC7D;IACA,KAAK,MAAuB,MAAM,UAAU;IAC9C;;EAEJ,CAAC;;AAYJ,SAAgB,wBAAkD;AAChE,QAAO,eAAe,EACpB,gBAAgB,UAAwB;AACtC,SAAO,WAAW;GAAE,MAAM;GAAW;GAAO,CAAC;IAEhD,CAAC;;;;;AAWJ,SAAgB,gBAAkC;AAChD,QAAO,MAAM,mBAAmB,EAAE,uBAAuB,CAAC"}

package/dist/{prosekit-extensions-mod-click-prevention.d.ts → mod-click-prevention.d.ts}

@@ -1,6 +1,4 @@
 import { PlainExtension } from "@prosekit/core";
-
-//#region src/mod-click-prevention/index.d.ts
 /**
  * @internal
  */
@@ -12,6 +10,5 @@ type ModClickPreventionExtension = PlainExtension;
  * @public
  */
 declare function defineModClickPrevention(): ModClickPreventionExtension;
-//#endregion
 export { ModClickPreventionExtension, defineModClickPrevention };
-//# sourceMappingURL=prosekit-extensions-mod-click-prevention.d.ts.map
+//# sourceMappingURL=mod-click-prevention.d.ts.map

package/dist/mod-click-prevention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod-click-prevention.d.ts","names":[],"sources":["../src/mod-click-prevention/index.ts"],"mappings":";;AAOA;;KAAY,2BAAA,GAA8B,cAAA;;;AAQ1C;;;;iBAAgB,wBAAA,CAAA,GAA4B,2BAAA"}

package/dist/{prosekit-extensions-mod-click-prevention.js → mod-click-prevention.js}

@@ -1,6 +1,5 @@
 import { Plugin, PluginKey } from "@prosekit/pm/state";
 import { definePlugin, isApple } from "@prosekit/core";
-//#region src/mod-click-prevention/index.ts
 /**
 * By default, clicking a node while holding the mod key will select the node. This
 * extension disables that behavior.
@@ -18,7 +17,6 @@ function handleClick(_view, _pos, event) {
 	return !!event[selectNodeModifier];
 }
 const selectNodeModifier = isApple ? "metaKey" : "ctrlKey";
-//#endregion
 export { defineModClickPrevention };
 
-//# sourceMappingURL=prosekit-extensions-mod-click-prevention.js.map
+//# sourceMappingURL=mod-click-prevention.js.map

package/dist/mod-click-prevention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod-click-prevention.js","names":[],"sources":["../src/mod-click-prevention/index.ts"],"sourcesContent":["import { definePlugin, isApple, type PlainExtension } from '@prosekit/core'\nimport { Plugin, PluginKey } from '@prosekit/pm/state'\nimport type { EditorView } from '@prosekit/pm/view'\n\n/**\n * @internal\n */\nexport type ModClickPreventionExtension = PlainExtension\n\n/**\n * By default, clicking a node while holding the mod key will select the node. This\n * extension disables that behavior.\n *\n * @public\n */\nexport function defineModClickPrevention(): ModClickPreventionExtension {\n  return definePlugin(new Plugin({ key, props: { handleClick } }))\n}\n\nconst key = new PluginKey('prosekit-mod-click-prevention')\n\nfunction handleClick(_view: EditorView, _pos: number, event: MouseEvent) {\n  return !!event[selectNodeModifier]\n}\n\nconst selectNodeModifier: 'metaKey' | 'ctrlKey' = isApple\n  ? 'metaKey'\n  : 'ctrlKey'\n"],"mappings":";;;;;;;;AAeA,SAAgB,2BAAwD;AACtE,QAAO,aAAa,IAAI,OAAO;EAAE;EAAK,OAAO,EAAE,aAAa;EAAE,CAAC,CAAC;;AAGlE,MAAM,MAAM,IAAI,UAAU,gCAAgC;AAE1D,SAAS,YAAY,OAAmB,MAAc,OAAmB;AACvE,QAAO,CAAC,CAAC,MAAM;;AAGjB,MAAM,qBAA4C,UAC9C,YACA"}