@ecsplico/editor 0.0.0-stage → 1.0.0

package/dist/core/schema/block-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-ids.js","names":["uuidv4"],"sources":["../../../src/core/schema/block-ids.ts"],"sourcesContent":["import { combineTransactionSteps, findChildrenInRange, getChangedRanges, getExtensionField, splitExtensions } from '@tiptap/core'\nimport type { Extensions } from '@tiptap/core'\nimport { UniqueID } from '@tiptap/extension-unique-id'\nimport type { Node as PMNode } from '@tiptap/pm/model'\nimport { Plugin, PluginKey } from '@tiptap/pm/state'\nimport { Transform } from '@tiptap/pm/transform'\nimport { v4 as uuidv4 } from 'uuid'\n\n/** Node attribute holding a block's stable ID; rendered as `data-id`. */\nexport const BLOCK_ID_ATTR = 'id'\n\n/** The built-in block types: every type that can be a top-level block (paragraphs nested in lists and quotes get one too). Other nodes opt in with `editorBlock: true`. */\nexport const BLOCK_ID_TYPES: readonly string[] = ['paragraph', 'heading', 'bulletList', 'orderedList', 'blockquote', 'codeBlock', 'image', 'audio', 'video', 'file', 'horizontalRule', 'transcriptSegment', 'composite']\n\n/** The node types among `extensions` that carry a block ID: `editorBlock` declared, else built-in (same rule as `NodeFlags`). */\nconst blockTypesOf = (extensions: Extensions): string[] => splitExtensions(extensions).nodeExtensions\n  .filter(ext => getExtensionField<boolean | undefined>(ext, 'editorBlock') ?? BLOCK_ID_TYPES.includes(ext.name))\n  .map(ext => ext.name)\n\n// `NodeFlags` copies `editorBlock` onto the spec; read it there (no import of node-flags: it imports this module).\nconst carriesId = (node: PMNode) => node.type.spec.editorBlock === true\n\n/** A fresh block ID (UUID v4; unlike `crypto.randomUUID()` also available outside secure contexts). */\nexport const newBlockId = (): string => uuidv4()\n\n/** The block ID of `node`; `null` for node types without IDs and for blocks that have none yet. */\nexport function blockIdOf(node: PMNode): string | null {\n  const id: unknown = carriesId(node) ? node.attrs[BLOCK_ID_ATTR] : null\n  return typeof id === 'string' && id ? id : null\n}\n\n/** The block with ID `id` (top-level or nested) and its position in `doc`, or `null`. */\nexport function findBlockById(doc: PMNode, id: string): { node: PMNode, pos: number } | null {\n  let found: { node: PMNode, pos: number } | null = null\n  doc.descendants((node, pos) => {\n    if (found) return false\n    if (blockIdOf(node) === id) found = { node, pos }\n    // Inline content never carries block IDs.\n    return !found && !node.isTextblock\n  })\n  return found\n}\n\n/**\n * `doc` with a fresh ID on every block that has none or repeats an earlier block's ID, or `null` when all IDs are\n * present and unique. For content no editor has touched: JSON seeds, Yjs state from before block IDs, server inserts.\n */\nexport function assignBlockIds(doc: PMNode): PMNode | null {\n  const tr = new Transform(doc)\n  const seen = new Set<string>()\n  doc.descendants((node, pos) => {\n    if (carriesId(node)) {\n      const id = blockIdOf(node)\n      if (id && !seen.has(id)) seen.add(id)\n      else tr.setNodeAttribute(pos, BLOCK_ID_ATTR, newBlockId()) // attribute steps keep all positions valid\n    }\n    return !node.isTextblock\n  })\n  return tr.docChanged ? tr.doc : null\n}\n\n/**\n * UniqueID only compares IDs within the changed ranges, so a block inserted with an ID that exists elsewhere in the\n * document (Alt-drop of a drag-handle drag, `insertContent` of a copied block's JSON) would keep the duplicate. This\n * gives such inserted blocks a fresh ID; the block that was already there keeps its own.\n */\nconst dedupeInserted = () => new Plugin({\n  key: new PluginKey('blockIdDedupe'),\n  appendTransaction(transactions, oldState, newState) {\n    // Remote Yjs changes carry the IDs their author assigned; rewriting them here would make clients diverge.\n    if (!transactions.some(tr => tr.docChanged) || transactions.some(tr => tr.getMeta('y-sync$'))) return\n    const transform = combineTransactionSteps(oldState.doc, [...transactions])\n    const inverse = transform.mapping.invert()\n    // Blocks that did not exist before (their start maps into content these transactions inserted), by position.\n    const inserted = new Map<number, string>()\n    for (const { newRange } of getChangedRanges(transform)) {\n      for (const { node, pos } of findChildrenInRange(newState.doc, newRange, carriesId)) {\n        const id = blockIdOf(node)\n        if (id && inverse.mapResult(pos).deleted) inserted.set(pos, id)\n      }\n    }\n    if (!inserted.size) return // typing and formatting end here, without walking the document\n    const total = new Map<string, number>()\n    const ofInserted = new Map<string, number>()\n    for (const id of inserted.values()) ofInserted.set(id, (ofInserted.get(id) ?? 0) + 1)\n    newState.doc.descendants((node) => {\n      const id = blockIdOf(node)\n      if (id && ofInserted.has(id)) total.set(id, (total.get(id) ?? 0) + 1)\n      return !node.isTextblock\n    })\n    const tr = newState.tr\n    const kept = new Set<string>()\n    for (const [pos, id] of [...inserted].sort(([a], [b]) => a - b)) {\n      if ((total.get(id) ?? 0) < 2) continue\n      // Only inserted copies of this ID (e.g. pasted twice in one go): the first one keeps it.\n      if (total.get(id) === ofInserted.get(id) && !kept.has(id)) {\n        kept.add(id)\n        continue\n      }\n      tr.setNodeAttribute(pos, BLOCK_ID_ATTR, newBlockId())\n    }\n    if (!tr.docChanged) return\n    // Steps reset the stored marks; UniqueID's meta keeps TrailingNode from reacting to this transaction.\n    return tr.setStoredMarks(newState.storedMarks).setMeta('__uniqueIDTransaction', true)\n  },\n})\n\n/**\n * Stable block IDs. `@tiptap/extension-unique-id` assigns IDs only in the local user's transactions: it skips\n * `y-sync$` (remote Yjs) transactions, gives the new half of a split a fresh ID (also the speaker segment's own Enter,\n * whose new half starts without an ID) and strips IDs from pasted and copy-dropped content. Part of\n * `schemaExtensions()`, so the server schema, the JSON mirror and the Yjs state carry the attribute.\n */\nexport const BlockId = UniqueID.extend({\n  // The ID-carrying types are the installed node extensions declaring `editorBlock` (built-ins default true).\n  // Upstream reads `options.types` synchronously in each hook below, so each hook resolves them from its own\n  // editor's extensions right before delegating: the configured options object is shared by every editor on the page.\n  addGlobalAttributes() {\n    this.options.types = blockTypesOf(this.extensions)\n    return this.parent?.() ?? []\n  },\n  onCreate(event) {\n    // Upstream backfills missing IDs on every client once the provider syncs, so two clients would race to give the\n    // same blocks different IDs. The server backfills in `onLoadDocument` instead, before any client syncs.\n    // A standalone editor (no Collaboration, content from JSON) is the only writer: upstream's immediate backfill.\n    const { extensions } = this.editor.extensionManager\n    if (extensions.some(ext => ext.name === 'collaboration')) return\n    this.options.types = blockTypesOf(extensions)\n    this.parent?.(event)\n  },\n  addProseMirrorPlugins() {\n    this.options.types = blockTypesOf(this.editor.extensionManager.extensions)\n    const plugins = this.parent?.() ?? []\n    // Same client-side backfill, for a Collaboration setup without a provider (on the first Yjs sync).\n    this.storage.needsInitialIdGeneration = false\n    return [...plugins, dedupeInserted()]\n  },\n}).configure({ attributeName: BLOCK_ID_ATTR, generateID: newBlockId })\n"],"mappings":"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"}

package/dist/core/schema/hex-color.d.ts

@@ -0,0 +1,5 @@
+//#region src/core/schema/hex-color.d.ts
+/** Plain hex colours only: attribute values come from the shared Y.Doc and may reach an inline style (mentions, author marks). */
+export declare const HEX_COLOR: RegExp;
+//#endregion
+//# sourceMappingURL=hex-color.d.ts.map

package/dist/core/schema/hex-color.js

@@ -0,0 +1,7 @@
+//#region src/core/schema/hex-color.ts
+/** Plain hex colours only: attribute values come from the shared Y.Doc and may reach an inline style (mentions, author marks). */
+const HEX_COLOR = /^#[0-9a-f]{3,8}$/i;
+//#endregion
+export { HEX_COLOR };
+
+//# sourceMappingURL=hex-color.js.map

package/dist/core/schema/hex-color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex-color.js","names":[],"sources":["../../../src/core/schema/hex-color.ts"],"sourcesContent":["/** Plain hex colours only: attribute values come from the shared Y.Doc and may reach an inline style (mentions, author marks). */\nexport const HEX_COLOR = /^#[0-9a-f]{3,8}$/i\n"],"mappings":";;AACA,MAAa,YAAY"}

package/dist/core/schema/index.d.ts

@@ -0,0 +1,21 @@
+import { ABILITY, Ability, AbilityRule, AbilityRuleSource, ROOT_ABILITIES, TEXT_ABILITIES, TYPE_ABILITIES, resolveAbilities } from "./abilities.js";
+import "./mark-flags.js";
+import { BLOCK_ID_ATTR, BLOCK_ID_TYPES, BlockId, assignBlockIds, blockIdOf, findBlockById, newBlockId } from "./block-ids.js";
+import { HEX_COLOR } from "./hex-color.js";
+import { NodeFlags, isBlockContainer, isChromeNode, isEditorBlock } from "./node-flags.js";
+import { OpaqueFence } from "./opaque-fence.js";
+import { StrikeX } from "./strike.js";
+import { AnyExtension, JSONContent } from "@tiptap/core";
+//#region src/core/schema/index.d.ts
+/**
+ * Base Vue-free nodes and marks of every editor: StarterKit (history off: the surface enables it for standalone
+ * editors, collaboration brings its own), StrikeX, the node-flags extension, `OpaqueFence` (Markdown fences of unknown
+ * kinds, kept verbatim) and `BlockId`, which adds the `id` attribute to every block type (its ID-assigning plugins only
+ * run in an editor). The server builds its schema from these as well (`getSchema(...)`).
+ */
+export declare const coreSchemaExtensions: () => AnyExtension[];
+/** Content of a fresh, empty document. */
+export declare const EMPTY_EDITOR_CONTENT: JSONContent;
+//#endregion
+export { ABILITY, Ability, AbilityRule, AbilityRuleSource, BLOCK_ID_ATTR, BLOCK_ID_TYPES, BlockId, HEX_COLOR, NodeFlags, OpaqueFence, ROOT_ABILITIES, StrikeX, TEXT_ABILITIES, TYPE_ABILITIES, assignBlockIds, blockIdOf, findBlockById, isBlockContainer, isChromeNode, isEditorBlock, newBlockId, resolveAbilities };
+//# sourceMappingURL=index.d.ts.map

package/dist/core/schema/index.js

@@ -0,0 +1,33 @@
+import { ABILITY, ROOT_ABILITIES, TEXT_ABILITIES, TYPE_ABILITIES, resolveAbilities } from "./abilities.js";
+import { BLOCK_ID_ATTR, BLOCK_ID_TYPES, BlockId, assignBlockIds, blockIdOf, findBlockById, newBlockId } from "./block-ids.js";
+import { NodeFlags, isBlockContainer, isChromeNode, isEditorBlock } from "./node-flags.js";
+import { OpaqueFence } from "./opaque-fence.js";
+import { StrikeX } from "./strike.js";
+import { HEX_COLOR } from "./hex-color.js";
+import StarterKit from "@tiptap/starter-kit";
+//#region src/core/schema/index.ts
+/**
+* Base Vue-free nodes and marks of every editor: StarterKit (history off: the surface enables it for standalone
+* editors, collaboration brings its own), StrikeX, the node-flags extension, `OpaqueFence` (Markdown fences of unknown
+* kinds, kept verbatim) and `BlockId`, which adds the `id` attribute to every block type (its ID-assigning plugins only
+* run in an editor). The server builds its schema from these as well (`getSchema(...)`).
+*/
+const coreSchemaExtensions = () => [
+	StarterKit.configure({
+		strike: false,
+		undoRedo: false
+	}),
+	StrikeX,
+	NodeFlags,
+	OpaqueFence,
+	BlockId
+];
+/** Content of a fresh, empty document. */
+const EMPTY_EDITOR_CONTENT = {
+	type: "doc",
+	content: [{ type: "paragraph" }]
+};
+//#endregion
+export { ABILITY, BLOCK_ID_ATTR, BLOCK_ID_TYPES, BlockId, EMPTY_EDITOR_CONTENT, HEX_COLOR, NodeFlags, OpaqueFence, ROOT_ABILITIES, StrikeX, TEXT_ABILITIES, TYPE_ABILITIES, assignBlockIds, blockIdOf, coreSchemaExtensions, findBlockById, isBlockContainer, isChromeNode, isEditorBlock, newBlockId, resolveAbilities };
+
+//# sourceMappingURL=index.js.map

package/dist/core/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/core/schema/index.ts"],"sourcesContent":["import type { AnyExtension, JSONContent } from '@tiptap/core'\nimport StarterKit from '@tiptap/starter-kit'\nimport { BlockId } from './block-ids'\nimport { NodeFlags } from './node-flags'\nimport { OpaqueFence } from './opaque-fence'\nimport { StrikeX } from './strike'\n\nexport * from './abilities'\nexport * from './block-ids'\nexport * from './hex-color'\nexport * from './mark-flags'\nexport * from './node-flags'\nexport { OpaqueFence } from './opaque-fence'\nexport { StrikeX } from './strike'\n\n/**\n * Base Vue-free nodes and marks of every editor: StarterKit (history off: the surface enables it for standalone\n * editors, collaboration brings its own), StrikeX, the node-flags extension, `OpaqueFence` (Markdown fences of unknown\n * kinds, kept verbatim) and `BlockId`, which adds the `id` attribute to every block type (its ID-assigning plugins only\n * run in an editor). The server builds its schema from these as well (`getSchema(...)`).\n */\nexport const coreSchemaExtensions = (): AnyExtension[] => [StarterKit.configure({ strike: false, undoRedo: false }), StrikeX, NodeFlags, OpaqueFence, BlockId]\n\n/** Content of a fresh, empty document. */\nexport const EMPTY_EDITOR_CONTENT: JSONContent = { type: 'doc', content: [{ type: 'paragraph' }] }\n"],"mappings":";;;;;;;;;;;;;;AAqBA,MAAa,6BAA6C;CAAC,WAAW,UAAU;EAAE,QAAQ;EAAO,UAAU;CAAM,CAAC;CAAG;CAAS;CAAW;CAAa;AAAO;;AAG7J,MAAa,uBAAoC;CAAE,MAAM;CAAO,SAAS,CAAC,EAAE,MAAM,YAAY,CAAC;AAAE"}

package/dist/core/schema/mark-flags.d.ts

@@ -0,0 +1,12 @@
+//#region src/core/schema/mark-flags.d.ts
+declare module '@tiptap/core' {
+  interface MarkConfig<Options, Storage> {
+    /**
+     * The mark carries editor metadata (who wrote a run, which comment thread anchors it), not formatting: the Markdown
+     * serializer ignores it, so it neither shows up in the Markdown nor splits the formatting runs around it.
+     */
+    markdownInvisible?: boolean;
+  }
+}
+export {};
+//# sourceMappingURL=mark-flags.d.ts.map

package/dist/core/schema/node-flags.d.ts

@@ -0,0 +1,23 @@
+import { Extension } from "@tiptap/core";
+import { Node as Node$1 } from "@tiptap/pm/model";
+//#region src/core/schema/node-flags.d.ts
+declare module '@tiptap/core' {
+  interface NodeConfig<Options, Storage> {
+    /** The node holds blocks that are individually convertible, draggable and addressable (the document, a composite). */
+    editorBlockContainer?: boolean;
+    /** The node is fixed chrome of its parent block (a composite's title/description/tags): it stands for its parent as a target. */
+    editorChrome?: boolean;
+    /** The node is an addressable block: it carries a block ID (`id` attribute) like paragraphs and headings. Built-in block types default to true. */
+    editorBlock?: boolean;
+  }
+}
+/** Copies `editorBlockContainer`, `editorChrome` and `editorBlock` of every node extension onto its `NodeSpec` (`doc` is a container). */
+export declare const NodeFlags: Extension<any, any>;
+/** Whether `node` is a block container (`doc` or a node declaring `editorBlockContainer`). */
+export declare function isBlockContainer(node: Node$1): boolean;
+/** Whether `node` is an addressable block carrying a block ID (declares `editorBlock`, or is a built-in block type). */
+export declare function isEditorBlock(node: Node$1): boolean;
+/** Whether `node` is chrome of its parent block (declares `editorChrome`). */
+export declare function isChromeNode(node: Node$1): boolean;
+//#endregion
+//# sourceMappingURL=node-flags.d.ts.map

package/dist/core/schema/node-flags.js

@@ -0,0 +1,34 @@
+import { BLOCK_ID_TYPES } from "./block-ids.js";
+import { Extension, getExtensionField } from "@tiptap/core";
+//#region src/core/schema/node-flags.ts
+/** The node types of the schema that are structural by name rather than by extension config. */
+const IMPLICIT_CONTAINERS = /* @__PURE__ */ new Set(["doc"]);
+/** Copies `editorBlockContainer`, `editorChrome` and `editorBlock` of every node extension onto its `NodeSpec` (`doc` is a container). */
+const NodeFlags = Extension.create({
+	name: "nodeFlags",
+	extendNodeSchema(extension) {
+		const container = getExtensionField(extension, "editorBlockContainer");
+		const chrome = getExtensionField(extension, "editorChrome");
+		return {
+			editorBlockContainer: container ?? IMPLICIT_CONTAINERS.has(extension.name),
+			editorChrome: chrome ?? false,
+			editorBlock: getExtensionField(extension, "editorBlock") ?? BLOCK_ID_TYPES.includes(extension.name)
+		};
+	}
+});
+/** Whether `node` is a block container (`doc` or a node declaring `editorBlockContainer`). */
+function isBlockContainer(node) {
+	return node.type.spec.editorBlockContainer === true;
+}
+/** Whether `node` is an addressable block carrying a block ID (declares `editorBlock`, or is a built-in block type). */
+function isEditorBlock(node) {
+	return node.type.spec.editorBlock === true;
+}
+/** Whether `node` is chrome of its parent block (declares `editorChrome`). */
+function isChromeNode(node) {
+	return node.type.spec.editorChrome === true;
+}
+//#endregion
+export { NodeFlags, isBlockContainer, isChromeNode, isEditorBlock };
+
+//# sourceMappingURL=node-flags.js.map

package/dist/core/schema/node-flags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-flags.js","names":[],"sources":["../../../src/core/schema/node-flags.ts"],"sourcesContent":["import { Extension, getExtensionField } from '@tiptap/core'\nimport type { Node as PMNode } from '@tiptap/pm/model'\nimport { BLOCK_ID_TYPES } from './block-ids'\n\n// Vue-free and server-importable. Node extensions declare structural roles with plain boolean fields on their\n// `NodeConfig`; this extension copies them onto the `NodeSpec`, so core operations (block conversion, drag targeting)\n// read them from the schema instead of hardcoding feature node names.\n\ndeclare module '@tiptap/core' {\n  interface NodeConfig<Options, Storage> {\n    /** The node holds blocks that are individually convertible, draggable and addressable (the document, a composite). */\n    editorBlockContainer?: boolean\n    /** The node is fixed chrome of its parent block (a composite's title/description/tags): it stands for its parent as a target. */\n    editorChrome?: boolean\n    /** The node is an addressable block: it carries a block ID (`id` attribute) like paragraphs and headings. Built-in block types default to true. */\n    editorBlock?: boolean\n  }\n}\n\n/** The node types of the schema that are structural by name rather than by extension config. */\nconst IMPLICIT_CONTAINERS: ReadonlySet<string> = new Set(['doc'])\n\n/** Copies `editorBlockContainer`, `editorChrome` and `editorBlock` of every node extension onto its `NodeSpec` (`doc` is a container). */\nexport const NodeFlags = Extension.create({\n  name: 'nodeFlags',\n\n  extendNodeSchema(extension) {\n    const container = getExtensionField<boolean | undefined>(extension, 'editorBlockContainer')\n    const chrome = getExtensionField<boolean | undefined>(extension, 'editorChrome')\n    return {\n      editorBlockContainer: container ?? IMPLICIT_CONTAINERS.has(extension.name),\n      editorChrome: chrome ?? false,\n      editorBlock: getExtensionField<boolean | undefined>(extension, 'editorBlock') ?? BLOCK_ID_TYPES.includes(extension.name),\n    }\n  },\n})\n\n/** Whether `node` is a block container (`doc` or a node declaring `editorBlockContainer`). */\nexport function isBlockContainer(node: PMNode): boolean {\n  return node.type.spec.editorBlockContainer === true\n}\n\n/** Whether `node` is an addressable block carrying a block ID (declares `editorBlock`, or is a built-in block type). */\nexport function isEditorBlock(node: PMNode): boolean {\n  return node.type.spec.editorBlock === true\n}\n\n/** Whether `node` is chrome of its parent block (declares `editorChrome`). */\nexport function isChromeNode(node: PMNode): boolean {\n  return node.type.spec.editorChrome === true\n}\n"],"mappings":";;;;AAoBA,MAAM,sCAA2C,IAAI,IAAI,CAAC,KAAK,CAAC;;AAGhE,MAAa,YAAY,UAAU,OAAO;CACxC,MAAM;CAEN,iBAAiB,WAAW;EAC1B,MAAM,YAAY,kBAAuC,WAAW,sBAAsB;EAC1F,MAAM,SAAS,kBAAuC,WAAW,cAAc;EAC/E,OAAO;GACL,sBAAsB,aAAa,oBAAoB,IAAI,UAAU,IAAI;GACzE,cAAc,UAAU;GACxB,aAAa,kBAAuC,WAAW,aAAa,KAAK,eAAe,SAAS,UAAU,IAAI;EACzH;CACF;AACF,CAAC;;AAGD,SAAgB,iBAAiB,MAAuB;CACtD,OAAO,KAAK,KAAK,KAAK,yBAAyB;AACjD;;AAGA,SAAgB,cAAc,MAAuB;CACnD,OAAO,KAAK,KAAK,KAAK,gBAAgB;AACxC;;AAGA,SAAgB,aAAa,MAAuB;CAClD,OAAO,KAAK,KAAK,KAAK,iBAAiB;AACzC"}

package/dist/core/schema/opaque-fence.d.ts

@@ -0,0 +1,11 @@
+import { Node } from "@tiptap/core";
+//#region src/core/schema/opaque-fence.d.ts
+/**
+ * A `::: kind` … `:::` fence of a kind the editor has no node for (kinds a composite feature registers parse into
+ * composites first). The fence's source text is kept in `raw` and written back byte for byte, so documents with fences
+ * of other tools survive a round trip; the editor shows it as read-only text block, and source mode edits it. `kind`
+ * is the word after the opening colons.
+ */
+export declare const OpaqueFence: Node<any, any>;
+//#endregion
+//# sourceMappingURL=opaque-fence.d.ts.map

package/dist/core/schema/opaque-fence.js

@@ -0,0 +1,57 @@
+import { Node } from "@tiptap/core";
+//#region src/core/schema/opaque-fence.ts
+/**
+* A `::: kind` … `:::` fence of a kind the editor has no node for (kinds a composite feature registers parse into
+* composites first). The fence's source text is kept in `raw` and written back byte for byte, so documents with fences
+* of other tools survive a round trip; the editor shows it as read-only text block, and source mode edits it. `kind`
+* is the word after the opening colons.
+*/
+const OpaqueFence = Node.create({
+	name: "opaqueFence",
+	group: "block",
+	atom: true,
+	selectable: true,
+	draggable: true,
+	editorBlock: true,
+	addAttributes() {
+		return {
+			raw: {
+				default: "",
+				rendered: false
+			},
+			kind: {
+				default: null,
+				rendered: false
+			}
+		};
+	},
+	parseHTML() {
+		return [{
+			tag: "pre[data-opaque-fence]",
+			priority: 60,
+			getAttrs: (element) => ({
+				raw: element.textContent ?? "",
+				kind: element.getAttribute("data-opaque-fence") || null
+			})
+		}];
+	},
+	renderHTML({ node }) {
+		return [
+			"pre",
+			{
+				"data-opaque-fence": node.attrs.kind ?? "",
+				class: "sk-opaque-fence"
+			},
+			[
+				"code",
+				{},
+				String(node.attrs.raw ?? "")
+			]
+		];
+	},
+	renderMarkdown: (node) => String(node.attrs?.raw ?? "")
+});
+//#endregion
+export { OpaqueFence };
+
+//# sourceMappingURL=opaque-fence.js.map

package/dist/core/schema/opaque-fence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque-fence.js","names":[],"sources":["../../../src/core/schema/opaque-fence.ts"],"sourcesContent":["import { Node } from '@tiptap/core'\n\n/**\n * A `::: kind` … `:::` fence of a kind the editor has no node for (kinds a composite feature registers parse into\n * composites first). The fence's source text is kept in `raw` and written back byte for byte, so documents with fences\n * of other tools survive a round trip; the editor shows it as read-only text block, and source mode edits it. `kind`\n * is the word after the opening colons.\n */\nexport const OpaqueFence = Node.create({\n  name: 'opaqueFence',\n  group: 'block',\n  atom: true,\n  selectable: true,\n  draggable: true,\n  editorBlock: true,\n\n  addAttributes() {\n    return {\n      raw: { default: '', rendered: false },\n      kind: { default: null, rendered: false },\n    }\n  },\n\n  parseHTML() {\n    return [{\n      tag: 'pre[data-opaque-fence]',\n      priority: 60,\n      getAttrs: element => ({ raw: element.textContent ?? '', kind: element.getAttribute('data-opaque-fence') || null }),\n    }]\n  },\n\n  renderHTML({ node }) {\n    // The text sits in a `code` child: ProseMirror's own sheet sets `white-space: normal` on every non-editable element, which a rule on the `pre` cannot beat.\n    return ['pre', { 'data-opaque-fence': node.attrs.kind ?? '', class: 'sk-opaque-fence' }, ['code', {}, String(node.attrs.raw ?? '')]]\n  },\n\n  renderMarkdown: node => String(node.attrs?.raw ?? ''),\n})\n"],"mappings":";;;;;;;;AAQA,MAAa,cAAc,KAAK,OAAO;CACrC,MAAM;CACN,OAAO;CACP,MAAM;CACN,YAAY;CACZ,WAAW;CACX,aAAa;CAEb,gBAAgB;EACd,OAAO;GACL,KAAK;IAAE,SAAS;IAAI,UAAU;GAAM;GACpC,MAAM;IAAE,SAAS;IAAM,UAAU;GAAM;EACzC;CACF;CAEA,YAAY;EACV,OAAO,CAAC;GACN,KAAK;GACL,UAAU;GACV,WAAU,aAAY;IAAE,KAAK,QAAQ,eAAe;IAAI,MAAM,QAAQ,aAAa,mBAAmB,KAAK;GAAK;EAClH,CAAC;CACH;CAEA,WAAW,EAAE,QAAQ;EAEnB,OAAO;GAAC;GAAO;IAAE,qBAAqB,KAAK,MAAM,QAAQ;IAAI,OAAO;GAAkB;GAAG;IAAC;IAAQ,CAAC;IAAG,OAAO,KAAK,MAAM,OAAO,EAAE;GAAC;EAAC;CACrI;CAEA,iBAAgB,SAAQ,OAAO,KAAK,OAAO,OAAO,EAAE;AACtD,CAAC"}

package/dist/core/schema/strike.d.ts

@@ -0,0 +1,4 @@
+//#region src/core/schema/strike.d.ts
+export declare const StrikeX: import("@tiptap/core").Mark<import("@tiptap/extension-strike").StrikeOptions, any>;
+//#endregion
+//# sourceMappingURL=strike.d.ts.map

package/dist/core/schema/strike.js

@@ -0,0 +1,9 @@
+import { Strike } from "@tiptap/extension-strike";
+//#region src/core/schema/strike.ts
+const StrikeX = Strike.extend({ addKeyboardShortcuts() {
+	return { "Mod-Shift-x": () => this.editor.commands.toggleStrike() };
+} });
+//#endregion
+export { StrikeX };
+
+//# sourceMappingURL=strike.js.map

package/dist/core/schema/strike.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strike.js","names":[],"sources":["../../../src/core/schema/strike.ts"],"sourcesContent":["import { Strike } from '@tiptap/extension-strike'\n\n// Strike's stock shortcut is Mod-Shift-s, which belongs to the speaker segment here; rebind it to Mod-Shift-x.\nexport const StrikeX = Strike.extend({\n  addKeyboardShortcuts() {\n    return { 'Mod-Shift-x': () => this.editor.commands.toggleStrike() }\n  },\n})\n"],"mappings":";;AAGA,MAAa,UAAU,OAAO,OAAO,EACnC,uBAAuB;CACrB,OAAO,EAAE,qBAAqB,KAAK,OAAO,SAAS,aAAa,EAAE;AACpE,EACF,CAAC"}

package/dist/core/selection-range.d.ts

@@ -0,0 +1,13 @@
+import { EditorState } from "@tiptap/pm/state";
+//#region src/core/selection-range.d.ts
+/**
+ * The selection as range for a flow that works on the selected text (AI menu, comments). A boundary that only touches
+ * a block's edge (a triple-click ends at the start of the next block) moves into the selected text, so neither the
+ * excerpt nor its replacement reaches into that block.
+ */
+export declare function selectionRange(state: EditorState): {
+  from: number;
+  to: number;
+};
+//#endregion
+//# sourceMappingURL=selection-range.d.ts.map

package/dist/core/selection-range.js

@@ -0,0 +1,28 @@
+import { Selection } from "@tiptap/pm/state";
+//#region src/core/selection-range.ts
+/**
+* The selection as range for a flow that works on the selected text (AI menu, comments). A boundary that only touches
+* a block's edge (a triple-click ends at the start of the next block) moves into the selected text, so neither the
+* excerpt nor its replacement reaches into that block.
+*/
+function selectionRange(state) {
+	const { from, to, $from, $to } = state.selection;
+	let start = from;
+	let end = to;
+	if (end > start && $to.parent.isTextblock && $to.parentOffset === 0) {
+		const prev = Selection.findFrom(state.doc.resolve($to.before()), -1, true);
+		if (prev && prev.head > start) end = prev.head;
+	}
+	if (end > start && $from.parent.isTextblock && $from.parentOffset === $from.parent.content.size) {
+		const next = Selection.findFrom(state.doc.resolve($from.after()), 1, true);
+		if (next && next.head < end) start = next.head;
+	}
+	return {
+		from: start,
+		to: end
+	};
+}
+//#endregion
+export { selectionRange };
+
+//# sourceMappingURL=selection-range.js.map

package/dist/core/selection-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-range.js","names":[],"sources":["../../src/core/selection-range.ts"],"sourcesContent":["import type { EditorState } from '@tiptap/pm/state'\nimport { Selection } from '@tiptap/pm/state'\n\n/**\n * The selection as range for a flow that works on the selected text (AI menu, comments). A boundary that only touches\n * a block's edge (a triple-click ends at the start of the next block) moves into the selected text, so neither the\n * excerpt nor its replacement reaches into that block.\n */\nexport function selectionRange(state: EditorState): { from: number, to: number } {\n  const { from, to, $from, $to } = state.selection\n  let start = from\n  let end = to\n  if (end > start && $to.parent.isTextblock && $to.parentOffset === 0) {\n    const prev = Selection.findFrom(state.doc.resolve($to.before()), -1, true)\n    if (prev && prev.head > start) end = prev.head\n  }\n  if (end > start && $from.parent.isTextblock && $from.parentOffset === $from.parent.content.size) {\n    const next = Selection.findFrom(state.doc.resolve($from.after()), 1, true)\n    if (next && next.head < end) start = next.head\n  }\n  return { from: start, to: end }\n}\n"],"mappings":";;;;;;;AAQA,SAAgB,eAAe,OAAkD;CAC/E,MAAM,EAAE,MAAM,IAAI,OAAO,QAAQ,MAAM;CACvC,IAAI,QAAQ;CACZ,IAAI,MAAM;CACV,IAAI,MAAM,SAAS,IAAI,OAAO,eAAe,IAAI,iBAAiB,GAAG;EACnE,MAAM,OAAO,UAAU,SAAS,MAAM,IAAI,QAAQ,IAAI,OAAO,CAAC,GAAG,IAAI,IAAI;EACzE,IAAI,QAAQ,KAAK,OAAO,OAAO,MAAM,KAAK;CAC5C;CACA,IAAI,MAAM,SAAS,MAAM,OAAO,eAAe,MAAM,iBAAiB,MAAM,OAAO,QAAQ,MAAM;EAC/F,MAAM,OAAO,UAAU,SAAS,MAAM,IAAI,QAAQ,MAAM,MAAM,CAAC,GAAG,GAAG,IAAI;EACzE,IAAI,QAAQ,KAAK,OAAO,KAAK,QAAQ,KAAK;CAC5C;CACA,OAAO;EAAE,MAAM;EAAO,IAAI;CAAI;AAChC"}

package/dist/core/slash.d.ts

@@ -0,0 +1,24 @@
+import { SlashCommandItem } from "./extension-points.js";
+import { Extension } from "@tiptap/core";
+import { PluginKey } from "@tiptap/pm/state";
+//#region src/core/slash.d.ts
+export interface SlashCommandOptions {
+  /** The final `/` menu: features' commands after the host's `slashCommands` transformer. */
+  items: SlashCommandItem[];
+  /** Popup text while no command matches the typed query (`ctx.t('slash.empty')`). */
+  emptyText: string;
+  /** Popup text while the commands are pending (`ctx.t('common.loading')`). */
+  loadingText: string;
+}
+/** Own key, so the `/` popup runs next to the `@` and `#` popups. */
+export declare const SlashCommandPluginKey: PluginKey<any>;
+/**
+ * `/` menu on an empty line: typing `/` as the only content of a textblock (outside code) opens the shared suggestion
+ * popup with the commands allowed at the caret (`SlashCommandItem.ability`) whose id or label starts with the typed
+ * query; picking one deletes `/query` and runs it. A query no allowed command matches (`/foo`) shows nothing and stays
+ * plain text. The commands come from features and the host; the core feature has none of its own.
+ * Client-only: not part of the Vue-free schema.
+ */
+export declare const SlashCommand: Extension<SlashCommandOptions, any>;
+//#endregion
+//# sourceMappingURL=slash.d.ts.map

package/dist/core/slash.js

@@ -0,0 +1,60 @@
+import { abilitiesAt } from "./abilities.js";
+import { createSuggestionRender } from "./suggestion-popup.js";
+import { Extension } from "@tiptap/core";
+import { PluginKey } from "@tiptap/pm/state";
+import { Suggestion } from "@tiptap/suggestion";
+//#region src/core/slash.ts
+function matching(items, query, abilities) {
+	const q = query.toLowerCase();
+	return items.filter((item) => (!item.ability || abilities.has(item.ability)) && (item.id.startsWith(q) || item.label.toLowerCase().startsWith(q)));
+}
+/** Own key, so the `/` popup runs next to the `@` and `#` popups. */
+const SlashCommandPluginKey = new PluginKey("slashCommand");
+/**
+* `/` menu on an empty line: typing `/` as the only content of a textblock (outside code) opens the shared suggestion
+* popup with the commands allowed at the caret (`SlashCommandItem.ability`) whose id or label starts with the typed
+* query; picking one deletes `/query` and runs it. A query no allowed command matches (`/foo`) shows nothing and stays
+* plain text. The commands come from features and the host; the core feature has none of its own.
+* Client-only: not part of the Vue-free schema.
+*/
+const SlashCommand = Extension.create({
+	name: "slashCommand",
+	addOptions() {
+		return {
+			items: [],
+			emptyText: "",
+			loadingText: ""
+		};
+	},
+	addProseMirrorPlugins() {
+		const { items, emptyText, loadingText } = this.options;
+		return [Suggestion({
+			pluginKey: SlashCommandPluginKey,
+			editor: this.editor,
+			char: "/",
+			startOfLine: true,
+			shouldShow: ({ editor, range, query, transaction }) => {
+				const $from = transaction.doc.resolve(range.from);
+				return $from.parentOffset === 0 && range.to === $from.end() && !$from.parent.type.spec.code && matching(items, query, abilitiesAt(editor, $from)).length > 0;
+			},
+			items: ({ editor, query }) => matching(items, query, abilitiesAt(editor, editor.state.selection.$from)),
+			command: ({ editor, range, props: item }) => {
+				editor.chain().focus().deleteRange(range).run();
+				item.run(editor);
+			},
+			render: createSuggestionRender({
+				display: (item) => ({
+					label: item.label,
+					description: `/${item.id}`,
+					icon: item.icon
+				}),
+				emptyText,
+				loadingText
+			})
+		})];
+	}
+});
+//#endregion
+export { SlashCommand, SlashCommandPluginKey };
+
+//# sourceMappingURL=slash.js.map

package/dist/core/slash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash.js","names":[],"sources":["../../src/core/slash.ts"],"sourcesContent":["import { Extension } from '@tiptap/core'\nimport { PluginKey } from '@tiptap/pm/state'\nimport { Suggestion } from '@tiptap/suggestion'\nimport { abilitiesAt } from './abilities'\nimport type { SlashCommandItem } from './extension-points'\nimport type { Ability } from './schema/abilities'\nimport { createSuggestionRender } from './suggestion-popup'\n\nexport interface SlashCommandOptions {\n  /** The final `/` menu: features' commands after the host's `slashCommands` transformer. */\n  items: SlashCommandItem[]\n  /** Popup text while no command matches the typed query (`ctx.t('slash.empty')`). */\n  emptyText: string\n  /** Popup text while the commands are pending (`ctx.t('common.loading')`). */\n  loadingText: string\n}\n\nfunction matching(items: SlashCommandItem[], query: string, abilities: ReadonlySet<Ability>): SlashCommandItem[] {\n  const q = query.toLowerCase()\n  return items.filter(item => (!item.ability || abilities.has(item.ability))\n    && (item.id.startsWith(q) || item.label.toLowerCase().startsWith(q)))\n}\n\n/** Own key, so the `/` popup runs next to the `@` and `#` popups. */\nexport const SlashCommandPluginKey = new PluginKey('slashCommand')\n\n/**\n * `/` menu on an empty line: typing `/` as the only content of a textblock (outside code) opens the shared suggestion\n * popup with the commands allowed at the caret (`SlashCommandItem.ability`) whose id or label starts with the typed\n * query; picking one deletes `/query` and runs it. A query no allowed command matches (`/foo`) shows nothing and stays\n * plain text. The commands come from features and the host; the core feature has none of its own.\n * Client-only: not part of the Vue-free schema.\n */\nexport const SlashCommand = Extension.create<SlashCommandOptions>({\n  name: 'slashCommand',\n\n  addOptions() {\n    return { items: [], emptyText: '', loadingText: '' }\n  },\n\n  addProseMirrorPlugins() {\n    const { items, emptyText, loadingText } = this.options\n    return [Suggestion<SlashCommandItem>({\n      pluginKey: SlashCommandPluginKey,\n      editor: this.editor,\n      char: '/',\n      startOfLine: true,\n      // `shouldShow` runs inside the plugin's `apply`, before `editor.state` is the new state: resolve in the new doc.\n      shouldShow: ({ editor, range, query, transaction }) => {\n        const $from = transaction.doc.resolve(range.from)\n        return $from.parentOffset === 0 && range.to === $from.end() && !$from.parent.type.spec.code\n          && matching(items, query, abilitiesAt(editor, $from)).length > 0\n      },\n      items: ({ editor, query }) => matching(items, query, abilitiesAt(editor, editor.state.selection.$from)),\n      command: ({ editor, range, props: item }) => {\n        editor.chain().focus().deleteRange(range).run()\n        item.run(editor)\n      },\n      render: createSuggestionRender<SlashCommandItem>({\n        display: item => ({ label: item.label, description: `/${item.id}`, icon: item.icon }),\n        emptyText,\n        loadingText,\n      }),\n    })]\n  },\n})\n"],"mappings":";;;;;;AAiBA,SAAS,SAAS,OAA2B,OAAe,WAAqD;CAC/G,MAAM,IAAI,MAAM,YAAY;CAC5B,OAAO,MAAM,QAAO,UAAS,CAAC,KAAK,WAAW,UAAU,IAAI,KAAK,OAAO,OAClE,KAAK,GAAG,WAAW,CAAC,KAAK,KAAK,MAAM,YAAY,CAAC,CAAC,WAAW,CAAC,EAAE;AACxE;;AAGA,MAAa,wBAAwB,IAAI,UAAU,cAAc;;;;;;;;AASjE,MAAa,eAAe,UAAU,OAA4B;CAChE,MAAM;CAEN,aAAa;EACX,OAAO;GAAE,OAAO,CAAC;GAAG,WAAW;GAAI,aAAa;EAAG;CACrD;CAEA,wBAAwB;EACtB,MAAM,EAAE,OAAO,WAAW,gBAAgB,KAAK;EAC/C,OAAO,CAAC,WAA6B;GACnC,WAAW;GACX,QAAQ,KAAK;GACb,MAAM;GACN,aAAa;GAEb,aAAa,EAAE,QAAQ,OAAO,OAAO,kBAAkB;IACrD,MAAM,QAAQ,YAAY,IAAI,QAAQ,MAAM,IAAI;IAChD,OAAO,MAAM,iBAAiB,KAAK,MAAM,OAAO,MAAM,IAAI,KAAK,CAAC,MAAM,OAAO,KAAK,KAAK,QAClF,SAAS,OAAO,OAAO,YAAY,QAAQ,KAAK,CAAC,CAAC,CAAC,SAAS;GACnE;GACA,QAAQ,EAAE,QAAQ,YAAY,SAAS,OAAO,OAAO,YAAY,QAAQ,OAAO,MAAM,UAAU,KAAK,CAAC;GACtG,UAAU,EAAE,QAAQ,OAAO,OAAO,WAAW;IAC3C,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,YAAY,KAAK,CAAC,CAAC,IAAI;IAC9C,KAAK,IAAI,MAAM;GACjB;GACA,QAAQ,uBAAyC;IAC/C,UAAS,UAAS;KAAE,OAAO,KAAK;KAAO,aAAa,IAAI,KAAK;KAAM,MAAM,KAAK;IAAK;IACnF;IACA;GACF,CAAC;EACH,CAAC,CAAC;CACJ;AACF,CAAC"}

package/dist/core/store.d.ts

@@ -0,0 +1,22 @@
+//#region src/core/store.d.ts
+/** A value that can be observed; the framework-free counterpart of a readonly `Ref`. */
+export interface ReadonlyStore<T> {
+  get(): T;
+  /** Called synchronously after every `set`/`update` with the new value; returns the unsubscribe function. */
+  subscribe(listener: (value: T) => void): () => void;
+}
+export interface Store<T> extends ReadonlyStore<T> {
+  /** Replaces the value; the identical reference is ignored (no notification). */
+  set(value: T): void;
+  /** `recipe` mutates a `structuredClone` of the current value; the clone becomes the value. */
+  update(recipe: (draft: T) => void): void;
+}
+/** A store holding `initial`. Listeners run synchronously, in subscription order. */
+export declare function createStore<T>(initial: T): Store<T>;
+/**
+ * A read-only view of `select(store.get())`. Subscribes to `store` only while it has listeners, and notifies them only
+ * when the selected value changes under `equals` (default `Object.is`).
+ */
+export declare function derived<T, U>(store: ReadonlyStore<T>, select: (value: T) => U, equals?: (a: U, b: U) => boolean): ReadonlyStore<U>;
+//#endregion
+//# sourceMappingURL=store.d.ts.map

package/dist/core/store.js

@@ -0,0 +1,61 @@
+//#region src/core/store.ts
+/** A store holding `initial`. Listeners run synchronously, in subscription order. */
+function createStore(initial) {
+	let value = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	const store = {
+		get: () => value,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		set(next) {
+			if (Object.is(next, value)) return;
+			value = next;
+			for (const listener of [...listeners]) listener(next);
+		},
+		update(recipe) {
+			const draft = structuredClone(value);
+			recipe(draft);
+			store.set(draft);
+		}
+	};
+	return store;
+}
+/**
+* A read-only view of `select(store.get())`. Subscribes to `store` only while it has listeners, and notifies them only
+* when the selected value changes under `equals` (default `Object.is`).
+*/
+function derived(store, select, equals = Object.is) {
+	const listeners = /* @__PURE__ */ new Set();
+	let current;
+	let stop;
+	return {
+		get: () => stop ? current : select(store.get()),
+		subscribe(listener) {
+			if (!stop) {
+				current = select(store.get());
+				stop = store.subscribe((value) => {
+					const next = select(value);
+					if (equals(next, current)) return;
+					current = next;
+					for (const l of [...listeners]) l(next);
+				});
+			}
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+				if (listeners.size === 0 && stop) {
+					stop();
+					stop = void 0;
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { createStore, derived };
+
+//# sourceMappingURL=store.js.map

package/dist/core/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":[],"sources":["../../src/core/store.ts"],"sourcesContent":["/** A value that can be observed; the framework-free counterpart of a readonly `Ref`. */\nexport interface ReadonlyStore<T> {\n  get(): T\n  /** Called synchronously after every `set`/`update` with the new value; returns the unsubscribe function. */\n  subscribe(listener: (value: T) => void): () => void\n}\n\nexport interface Store<T> extends ReadonlyStore<T> {\n  /** Replaces the value; the identical reference is ignored (no notification). */\n  set(value: T): void\n  /** `recipe` mutates a `structuredClone` of the current value; the clone becomes the value. */\n  update(recipe: (draft: T) => void): void\n}\n\n/** A store holding `initial`. Listeners run synchronously, in subscription order. */\nexport function createStore<T>(initial: T): Store<T> {\n  let value = initial\n  const listeners = new Set<(value: T) => void>()\n  const store: Store<T> = {\n    get: () => value,\n    subscribe(listener) {\n      listeners.add(listener)\n      return () => { listeners.delete(listener) }\n    },\n    set(next) {\n      if (Object.is(next, value)) return\n      value = next\n      // A copy: listeners may (un)subscribe while being notified.\n      for (const listener of [...listeners]) listener(next)\n    },\n    update(recipe) {\n      const draft = structuredClone(value)\n      recipe(draft)\n      store.set(draft)\n    },\n  }\n  return store\n}\n\n/**\n * A read-only view of `select(store.get())`. Subscribes to `store` only while it has listeners, and notifies them only\n * when the selected value changes under `equals` (default `Object.is`).\n */\nexport function derived<T, U>(store: ReadonlyStore<T>, select: (value: T) => U, equals: (a: U, b: U) => boolean = Object.is): ReadonlyStore<U> {\n  const listeners = new Set<(value: U) => void>()\n  let current: U\n  let stop: (() => void) | undefined\n  return {\n    get: () => (stop ? current : select(store.get())),\n    subscribe(listener) {\n      if (!stop) {\n        current = select(store.get())\n        stop = store.subscribe((value) => {\n          const next = select(value)\n          if (equals(next, current)) return\n          current = next\n          for (const l of [...listeners]) l(next)\n        })\n      }\n      listeners.add(listener)\n      return () => {\n        listeners.delete(listener)\n        if (listeners.size === 0 && stop) {\n          stop()\n          stop = undefined\n        }\n      }\n    },\n  }\n}\n"],"mappings":";;AAeA,SAAgB,YAAe,SAAsB;CACnD,IAAI,QAAQ;CACZ,MAAM,4BAAY,IAAI,IAAwB;CAC9C,MAAM,QAAkB;EACtB,WAAW;EACX,UAAU,UAAU;GAClB,UAAU,IAAI,QAAQ;GACtB,aAAa;IAAE,UAAU,OAAO,QAAQ;GAAE;EAC5C;EACA,IAAI,MAAM;GACR,IAAI,OAAO,GAAG,MAAM,KAAK,GAAG;GAC5B,QAAQ;GAER,KAAK,MAAM,YAAY,CAAC,GAAG,SAAS,GAAG,SAAS,IAAI;EACtD;EACA,OAAO,QAAQ;GACb,MAAM,QAAQ,gBAAgB,KAAK;GACnC,OAAO,KAAK;GACZ,MAAM,IAAI,KAAK;EACjB;CACF;CACA,OAAO;AACT;;;;;AAMA,SAAgB,QAAc,OAAyB,QAAyB,SAAkC,OAAO,IAAsB;CAC7I,MAAM,4BAAY,IAAI,IAAwB;CAC9C,IAAI;CACJ,IAAI;CACJ,OAAO;EACL,WAAY,OAAO,UAAU,OAAO,MAAM,IAAI,CAAC;EAC/C,UAAU,UAAU;GAClB,IAAI,CAAC,MAAM;IACT,UAAU,OAAO,MAAM,IAAI,CAAC;IAC5B,OAAO,MAAM,WAAW,UAAU;KAChC,MAAM,OAAO,OAAO,KAAK;KACzB,IAAI,OAAO,MAAM,OAAO,GAAG;KAC3B,UAAU;KACV,KAAK,MAAM,KAAK,CAAC,GAAG,SAAS,GAAG,EAAE,IAAI;IACxC,CAAC;GACH;GACA,UAAU,IAAI,QAAQ;GACtB,aAAa;IACX,UAAU,OAAO,QAAQ;IACzB,IAAI,UAAU,SAAS,KAAK,MAAM;KAChC,KAAK;KACL,OAAO,KAAA;IACT;GACF;EACF;CACF;AACF"}

package/dist/core/suggestion-popup.d.ts

@@ -0,0 +1,63 @@
+import { Editor, Extension } from "@tiptap/core";
+import { SuggestionOptions } from "@tiptap/suggestion";
+//#region src/core/suggestion-popup.d.ts
+/** How one suggestion item is shown in the popup. */
+export interface SuggestionDisplay {
+  label: string;
+  description?: string;
+  /** Iconify name, e.g. `i-lucide-user`. */
+  icon?: string;
+  /** CSS colour for label and icon. */
+  color?: string;
+}
+/** Props a framework popup renders: the current items, their row mapping, pick callback and loading state. */
+export interface SuggestionListProps {
+  items: unknown[];
+  display: (item: unknown) => SuggestionDisplay;
+  command: (item: unknown) => void;
+  loading: boolean;
+  /** Shown while `loading` and no item is there. */
+  loadingText: string;
+  emptyText: string;
+}
+/** A mounted popup of one framework layer; `createSuggestionRender` positions `element` and forwards updates and keys. */
+export interface SuggestionPopupHandle {
+  element: HTMLElement;
+  update(props: SuggestionListProps): void;
+  /** Returns `true` when the key was consumed. */
+  onKeyDown(event: KeyboardEvent): boolean;
+  destroy(): void;
+}
+export type SuggestionPopupRenderer = (props: SuggestionListProps, editor: Editor) => SuggestionPopupHandle;
+/** Carries the framework layer's popup renderer; the surface adds `SuggestionPopup.configure({ renderer })`. */
+export declare const SuggestionPopup: Extension<{
+  renderer: SuggestionPopupRenderer | null;
+}, {
+  renderer: SuggestionPopupRenderer | null;
+}>;
+declare module '@tiptap/core' {
+  interface Storage {
+    suggestionPopup: {
+      renderer: SuggestionPopupRenderer | null;
+    };
+  }
+}
+export declare const suggestionPopupOf: (editor: Editor) => SuggestionPopupRenderer;
+export interface SuggestionRenderOptions<T> {
+  display: (item: T) => SuggestionDisplay;
+  /** Shown when `items()` resolved to an empty list. */
+  emptyText: string;
+  /** Shown while `items()` is pending. */
+  loadingText: string;
+}
+/**
+ * Popup renderer for any `@tiptap/suggestion` trigger (`@` mentions, later `#` tags or `/` commands):
+ * pass the result as `suggestion.render`. The trigger's `items()` supplies the entries (sync or async, `loading`
+ * is shown meanwhile), `display` maps an entry to its row, and picking a row calls the suggestion `command`
+ * with the entry itself — so items (`I`) must be assignable to what the command expects (`TSelected`, for Mention: node attrs).
+ * Keys: ArrowUp/ArrowDown move, Enter/Tab pick, Esc closes without inserting (the plugin dismisses the match).
+ * The popup is mounted into `document.body` and kept at the trigger's `clientRect` by the plugin's `mount()`.
+ */
+export declare function createSuggestionRender<I extends TSelected, TSelected = I>(options: SuggestionRenderOptions<I>): NonNullable<SuggestionOptions<I, TSelected>['render']>;
+//#endregion
+//# sourceMappingURL=suggestion-popup.d.ts.map