@ecsplico/editor 0.0.0-stage → 1.0.0

package/dist/core/suggestion-popup.js

@@ -0,0 +1,57 @@
+import { Extension } from "@tiptap/core";
+//#region src/core/suggestion-popup.ts
+/** Carries the framework layer's popup renderer; the surface adds `SuggestionPopup.configure({ renderer })`. */
+const SuggestionPopup = Extension.create({
+	name: "suggestionPopup",
+	addOptions() {
+		return { renderer: null };
+	},
+	addStorage() {
+		return { renderer: this.options.renderer };
+	}
+});
+const suggestionPopupOf = (editor) => {
+	const renderer = editor.storage.suggestionPopup?.renderer;
+	if (!renderer) throw new Error("@ecsplico/editor: no suggestion popup renderer; the surface adds SuggestionPopup.configure({ renderer })");
+	return renderer;
+};
+/**
+* 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()`.
+*/
+function createSuggestionRender(options) {
+	return () => {
+		let handle;
+		let unmount;
+		const listProps = (props) => ({
+			items: props.items,
+			display: options.display,
+			command: props.command,
+			loading: props.loading,
+			loadingText: options.loadingText,
+			emptyText: options.emptyText
+		});
+		return {
+			onStart(props) {
+				handle = suggestionPopupOf(props.editor)(listProps(props), props.editor);
+				handle.element.style.zIndex = "50";
+				unmount = props.mount(handle.element);
+			},
+			onUpdate: (props) => handle?.update(listProps(props)),
+			onKeyDown: ({ event }) => handle?.onKeyDown(event) ?? false,
+			onExit() {
+				unmount?.();
+				handle?.destroy();
+				unmount = handle = void 0;
+			}
+		};
+	};
+}
+//#endregion
+export { SuggestionPopup, createSuggestionRender, suggestionPopupOf };
+
+//# sourceMappingURL=suggestion-popup.js.map

package/dist/core/suggestion-popup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggestion-popup.js","names":[],"sources":["../../src/core/suggestion-popup.ts"],"sourcesContent":["import { type Editor, Extension } from '@tiptap/core'\nimport type { SuggestionOptions, SuggestionProps } from '@tiptap/suggestion'\n\n/** How one suggestion item is shown in the popup. */\nexport interface SuggestionDisplay {\n  label: string\n  description?: string\n  /** Iconify name, e.g. `i-lucide-user`. */\n  icon?: string\n  /** CSS colour for label and icon. */\n  color?: string\n}\n\n/** Props a framework popup renders: the current items, their row mapping, pick callback and loading state. */\nexport interface SuggestionListProps {\n  items: unknown[]\n  display: (item: unknown) => SuggestionDisplay\n  command: (item: unknown) => void\n  loading: boolean\n  /** Shown while `loading` and no item is there. */\n  loadingText: string\n  emptyText: string\n}\n\n/** A mounted popup of one framework layer; `createSuggestionRender` positions `element` and forwards updates and keys. */\nexport interface SuggestionPopupHandle {\n  element: HTMLElement\n  update(props: SuggestionListProps): void\n  /** Returns `true` when the key was consumed. */\n  onKeyDown(event: KeyboardEvent): boolean\n  destroy(): void\n}\n\nexport type SuggestionPopupRenderer = (props: SuggestionListProps, editor: Editor) => SuggestionPopupHandle\n\n/** Carries the framework layer's popup renderer; the surface adds `SuggestionPopup.configure({ renderer })`. */\nexport const SuggestionPopup = Extension.create<{ renderer: SuggestionPopupRenderer | null }, { renderer: SuggestionPopupRenderer | null }>({\n  name: 'suggestionPopup',\n\n  addOptions() {\n    return { renderer: null }\n  },\n\n  addStorage() {\n    return { renderer: this.options.renderer }\n  },\n})\n\ndeclare module '@tiptap/core' {\n  interface Storage {\n    suggestionPopup: { renderer: SuggestionPopupRenderer | null }\n  }\n}\n\nexport const suggestionPopupOf = (editor: Editor): SuggestionPopupRenderer => {\n  const renderer = editor.storage.suggestionPopup?.renderer\n  if (!renderer) throw new Error('@ecsplico/editor: no suggestion popup renderer; the surface adds SuggestionPopup.configure({ renderer })')\n  return renderer\n}\n\nexport interface SuggestionRenderOptions<T> {\n  display: (item: T) => SuggestionDisplay\n  /** Shown when `items()` resolved to an empty list. */\n  emptyText: string\n  /** Shown while `items()` is pending. */\n  loadingText: string\n}\n\n/**\n * Popup renderer for any `@tiptap/suggestion` trigger (`@` mentions, later `#` tags or `/` commands):\n * pass the result as `suggestion.render`. The trigger's `items()` supplies the entries (sync or async, `loading`\n * is shown meanwhile), `display` maps an entry to its row, and picking a row calls the suggestion `command`\n * with the entry itself — so items (`I`) must be assignable to what the command expects (`TSelected`, for Mention: node attrs).\n * Keys: ArrowUp/ArrowDown move, Enter/Tab pick, Esc closes without inserting (the plugin dismisses the match).\n * The popup is mounted into `document.body` and kept at the trigger's `clientRect` by the plugin's `mount()`.\n */\nexport function createSuggestionRender<I extends TSelected, TSelected = I>(options: SuggestionRenderOptions<I>): NonNullable<SuggestionOptions<I, TSelected>['render']> {\n  return () => {\n    let handle: SuggestionPopupHandle | undefined\n    let unmount: (() => void) | undefined\n    const listProps = (props: SuggestionProps<I, TSelected>): SuggestionListProps => ({\n      items: props.items,\n      display: options.display as (item: unknown) => SuggestionDisplay,\n      command: props.command as (item: unknown) => void,\n      loading: props.loading,\n      loadingText: options.loadingText,\n      emptyText: options.emptyText,\n    })\n\n    return {\n      onStart(props) {\n        handle = suggestionPopupOf(props.editor)(listProps(props), props.editor)\n        handle.element.style.zIndex = '50'\n        unmount = props.mount(handle.element)\n      },\n      onUpdate: props => handle?.update(listProps(props)),\n      onKeyDown: ({ event }) => handle?.onKeyDown(event) ?? false,\n      onExit() {\n        unmount?.()\n        handle?.destroy()\n        unmount = handle = undefined\n      },\n    }\n  }\n}\n"],"mappings":";;;AAoCA,MAAa,kBAAkB,UAAU,OAAmG;CAC1I,MAAM;CAEN,aAAa;EACX,OAAO,EAAE,UAAU,KAAK;CAC1B;CAEA,aAAa;EACX,OAAO,EAAE,UAAU,KAAK,QAAQ,SAAS;CAC3C;AACF,CAAC;AAQD,MAAa,qBAAqB,WAA4C;CAC5E,MAAM,WAAW,OAAO,QAAQ,iBAAiB;CACjD,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,0GAA0G;CACzI,OAAO;AACT;;;;;;;;;AAkBA,SAAgB,uBAA2D,SAA6F;CACtK,aAAa;EACX,IAAI;EACJ,IAAI;EACJ,MAAM,aAAa,WAA+D;GAChF,OAAO,MAAM;GACb,SAAS,QAAQ;GACjB,SAAS,MAAM;GACf,SAAS,MAAM;GACf,aAAa,QAAQ;GACrB,WAAW,QAAQ;EACrB;EAEA,OAAO;GACL,QAAQ,OAAO;IACb,SAAS,kBAAkB,MAAM,MAAM,CAAC,CAAC,UAAU,KAAK,GAAG,MAAM,MAAM;IACvE,OAAO,QAAQ,MAAM,SAAS;IAC9B,UAAU,MAAM,MAAM,OAAO,OAAO;GACtC;GACA,WAAU,UAAS,QAAQ,OAAO,UAAU,KAAK,CAAC;GAClD,YAAY,EAAE,YAAY,QAAQ,UAAU,KAAK,KAAK;GACtD,SAAS;IACP,UAAU;IACV,QAAQ,QAAQ;IAChB,UAAU,SAAS,KAAA;GACrB;EACF;CACF;AACF"}

package/dist/core/tag-name.js

@@ -0,0 +1,11 @@
+/**
+* Canonical tag name: lowercase, trimmed, whitespace runs → `-`, only letters (incl. umlauts/ß), digits, `-` and `_`,
+* repeated/edge dashes collapsed. `'  Neu Tag! '` → `'neu-tag'`; `''` means "no usable name".
+*/
+function normalizeTagName(raw) {
+	return raw.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^\p{L}\p{N}_-]/gu, "").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+//#endregion
+export { normalizeTagName };
+
+//# sourceMappingURL=tag-name.js.map

package/dist/core/tag-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-name.js","names":[],"sources":["../../src/core/tag-name.ts"],"sourcesContent":["/** Longest tag name; longer input is cut. */\nexport const MAX_TAG_NAME_LENGTH = 64\n\n/**\n * Canonical tag name: lowercase, trimmed, whitespace runs → `-`, only letters (incl. umlauts/ß), digits, `-` and `_`,\n * repeated/edge dashes collapsed. `'  Neu Tag! '` → `'neu-tag'`; `''` means \"no usable name\".\n */\nexport function normalizeTagName(raw: string): string {\n  return raw.trim().toLowerCase()\n    .replace(/\\s+/g, '-')\n    .replace(/[^\\p{L}\\p{N}_-]/gu, '')\n    .replace(/-{2,}/g, '-')\n    .replace(/^-+|-+$/g, '')\n    .slice(0, MAX_TAG_NAME_LENGTH)\n}\n"],"mappings":";;;;AAOA,SAAgB,iBAAiB,KAAqB;CACpD,OAAO,IAAI,KAAK,CAAC,CAAC,YAAY,CAAC,CAC5B,QAAQ,QAAQ,GAAG,CAAC,CACpB,QAAQ,qBAAqB,EAAE,CAAC,CAChC,QAAQ,UAAU,GAAG,CAAC,CACtB,QAAQ,YAAY,EAAE,CAAC,CACvB,MAAM,GAAA,EAAsB;AACjC"}

package/dist/core/toolbar-items.d.ts

@@ -0,0 +1,10 @@
+import { ToolbarGroup } from "./toolbar.js";
+import { FeatureContext } from "./feature.js";
+//#region src/core/toolbar-items.d.ts
+/**
+ * The core toolbar: undo/redo, paragraph and headings, text marks, lists, quote, code block
+ * and rule. Orders leave room for the groups features contribute.
+ */
+export declare function coreToolbarGroups(ctx: FeatureContext): ToolbarGroup<never>[];
+//#endregion
+//# sourceMappingURL=toolbar-items.d.ts.map

package/dist/core/toolbar-items.js

@@ -0,0 +1,206 @@
+import { ABILITY } from "./schema/abilities.js";
+import { commandItem } from "./toolbar.js";
+//#region src/core/toolbar-items.ts
+/**
+* The core toolbar: undo/redo, paragraph and headings, text marks, lists, quote, code block
+* and rule. Orders leave room for the groups features contribute.
+*/
+function coreToolbarGroups(ctx) {
+	const headingsShown = (editor) => ctx.settings.get().blocks.structure === "flat" || !editor.schema.nodes.composite;
+	return [
+		{
+			id: "history",
+			order: 10,
+			items: [commandItem({
+				id: "undo",
+				order: 10,
+				icon: "i-lucide-undo-2",
+				label: ctx.t("toolbar.undo"),
+				kbds: ["meta", "z"],
+				command: (c) => c.undo()
+			}), commandItem({
+				id: "redo",
+				order: 20,
+				icon: "i-lucide-redo-2",
+				label: ctx.t("toolbar.redo"),
+				kbds: [
+					"meta",
+					"shift",
+					"z"
+				],
+				command: (c) => c.redo()
+			})]
+		},
+		{
+			id: "block-type",
+			order: 20,
+			items: [commandItem({
+				id: "paragraph",
+				order: 10,
+				icon: "i-lucide-pilcrow",
+				label: ctx.t("toolbar.paragraph"),
+				kbds: [
+					"meta",
+					"alt",
+					"0"
+				],
+				command: (c) => c.setParagraph(),
+				isActive: (e) => e.isActive("paragraph")
+			}), ...[
+				1,
+				2,
+				3
+			].map((level) => ({
+				...commandItem({
+					id: `heading${level}`,
+					order: 20 + level,
+					icon: `i-lucide-heading-${level}`,
+					label: ctx.t("toolbar.heading", { level }),
+					kbds: [
+						"meta",
+						"alt",
+						String(level)
+					],
+					ability: ABILITY.headings,
+					command: (c) => c.toggleHeading({ level }),
+					isActive: (e) => e.isActive("heading", { level })
+				}),
+				visible: headingsShown
+			}))]
+		},
+		{
+			id: "marks",
+			order: 30,
+			items: [
+				commandItem({
+					id: "bold",
+					order: 10,
+					icon: "i-lucide-bold",
+					label: ctx.t("toolbar.bold"),
+					kbds: ["meta", "b"],
+					ability: ABILITY.marks,
+					command: (c) => c.toggleBold(),
+					isActive: (e) => e.isActive("bold")
+				}),
+				commandItem({
+					id: "italic",
+					order: 20,
+					icon: "i-lucide-italic",
+					label: ctx.t("toolbar.italic"),
+					kbds: ["meta", "i"],
+					ability: ABILITY.marks,
+					command: (c) => c.toggleItalic(),
+					isActive: (e) => e.isActive("italic")
+				}),
+				commandItem({
+					id: "underline",
+					order: 30,
+					icon: "i-lucide-underline",
+					label: ctx.t("toolbar.underline"),
+					kbds: ["meta", "u"],
+					ability: ABILITY.marks,
+					command: (c) => c.toggleUnderline(),
+					isActive: (e) => e.isActive("underline")
+				}),
+				commandItem({
+					id: "strike",
+					order: 40,
+					icon: "i-lucide-strikethrough",
+					label: ctx.t("toolbar.strike"),
+					kbds: [
+						"meta",
+						"shift",
+						"x"
+					],
+					ability: ABILITY.marks,
+					command: (c) => c.toggleStrike(),
+					isActive: (e) => e.isActive("strike")
+				}),
+				commandItem({
+					id: "code",
+					order: 50,
+					icon: "i-lucide-code",
+					label: ctx.t("toolbar.code"),
+					kbds: ["meta", "e"],
+					ability: ABILITY.marks,
+					command: (c) => c.toggleCode(),
+					isActive: (e) => e.isActive("code")
+				})
+			]
+		},
+		{
+			id: "blocks",
+			order: 40,
+			items: [
+				commandItem({
+					id: "bulletList",
+					order: 10,
+					icon: "i-lucide-list",
+					label: ctx.t("toolbar.bulletList"),
+					kbds: [
+						"meta",
+						"shift",
+						"8"
+					],
+					ability: ABILITY.lists,
+					command: (c) => c.toggleBulletList(),
+					isActive: (e) => e.isActive("bulletList")
+				}),
+				commandItem({
+					id: "orderedList",
+					order: 20,
+					icon: "i-lucide-list-ordered",
+					label: ctx.t("toolbar.orderedList"),
+					kbds: [
+						"meta",
+						"shift",
+						"7"
+					],
+					ability: ABILITY.lists,
+					command: (c) => c.toggleOrderedList(),
+					isActive: (e) => e.isActive("orderedList")
+				}),
+				commandItem({
+					id: "blockquote",
+					order: 30,
+					icon: "i-lucide-text-quote",
+					label: ctx.t("toolbar.blockquote"),
+					kbds: [
+						"meta",
+						"shift",
+						"b"
+					],
+					ability: ABILITY.blockquote,
+					command: (c) => c.toggleBlockquote(),
+					isActive: (e) => e.isActive("blockquote")
+				}),
+				commandItem({
+					id: "codeBlock",
+					order: 40,
+					icon: "i-lucide-square-code",
+					label: ctx.t("toolbar.codeBlock"),
+					kbds: [
+						"meta",
+						"alt",
+						"c"
+					],
+					ability: ABILITY.codeBlock,
+					command: (c) => c.toggleCodeBlock(),
+					isActive: (e) => e.isActive("codeBlock")
+				}),
+				commandItem({
+					id: "rule",
+					order: 50,
+					icon: "i-lucide-minus",
+					label: ctx.t("toolbar.rule"),
+					ability: ABILITY.rule,
+					command: (c) => c.setHorizontalRule()
+				})
+			]
+		}
+	];
+}
+//#endregion
+export { coreToolbarGroups };
+
+//# sourceMappingURL=toolbar-items.js.map

package/dist/core/toolbar-items.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-items.js","names":[],"sources":["../../src/core/toolbar-items.ts"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { FeatureContext } from './feature'\nimport { ABILITY } from './schema/abilities'\nimport { commandItem, type ToolbarGroup } from './toolbar'\n\n/**\n * The core toolbar: undo/redo, paragraph and headings, text marks, lists, quote, code block\n * and rule. Orders leave room for the groups features contribute.\n */\nexport function coreToolbarGroups(ctx: FeatureContext): ToolbarGroup<never>[] {\n  // Headings are the document structure in the flat setting, and always where the schema has no composites to structure with.\n  const headingsShown = (editor: Editor) => ctx.settings.get().blocks.structure === 'flat' || !editor.schema.nodes.composite\n  return [\n    {\n      id: 'history',\n      order: 10,\n      items: [\n        commandItem({ id: 'undo', order: 10, icon: 'i-lucide-undo-2', label: ctx.t('toolbar.undo'), kbds: ['meta', 'z'], command: c => c.undo() }),\n        commandItem({ id: 'redo', order: 20, icon: 'i-lucide-redo-2', label: ctx.t('toolbar.redo'), kbds: ['meta', 'shift', 'z'], command: c => c.redo() }),\n      ],\n    },\n    {\n      id: 'block-type',\n      order: 20,\n      items: [\n        commandItem({ id: 'paragraph', order: 10, icon: 'i-lucide-pilcrow', label: ctx.t('toolbar.paragraph'), kbds: ['meta', 'alt', '0'], command: c => c.setParagraph(), isActive: e => e.isActive('paragraph') }),\n        // With composites in the schema, the 'composite' structure shows Bausteine instead of H1–H3.\n        ...([1, 2, 3] as const).map(level => ({\n          ...commandItem({\n            id: `heading${level}`,\n            order: 20 + level,\n            icon: `i-lucide-heading-${level}`,\n            label: ctx.t('toolbar.heading', { level }),\n            kbds: ['meta', 'alt', String(level)],\n            ability: ABILITY.headings,\n            command: c => c.toggleHeading({ level }),\n            isActive: e => e.isActive('heading', { level }),\n          }),\n          visible: headingsShown,\n        })),\n      ],\n    },\n    {\n      id: 'marks',\n      order: 30,\n      items: [\n        commandItem({ id: 'bold', order: 10, icon: 'i-lucide-bold', label: ctx.t('toolbar.bold'), kbds: ['meta', 'b'], ability: ABILITY.marks, command: c => c.toggleBold(), isActive: e => e.isActive('bold') }),\n        commandItem({ id: 'italic', order: 20, icon: 'i-lucide-italic', label: ctx.t('toolbar.italic'), kbds: ['meta', 'i'], ability: ABILITY.marks, command: c => c.toggleItalic(), isActive: e => e.isActive('italic') }),\n        commandItem({ id: 'underline', order: 30, icon: 'i-lucide-underline', label: ctx.t('toolbar.underline'), kbds: ['meta', 'u'], ability: ABILITY.marks, command: c => c.toggleUnderline(), isActive: e => e.isActive('underline') }),\n        // Mod-Shift-s is the speaker segment, so strike is rebound to Mod-Shift-x (StrikeX).\n        commandItem({ id: 'strike', order: 40, icon: 'i-lucide-strikethrough', label: ctx.t('toolbar.strike'), kbds: ['meta', 'shift', 'x'], ability: ABILITY.marks, command: c => c.toggleStrike(), isActive: e => e.isActive('strike') }),\n        commandItem({ id: 'code', order: 50, icon: 'i-lucide-code', label: ctx.t('toolbar.code'), kbds: ['meta', 'e'], ability: ABILITY.marks, command: c => c.toggleCode(), isActive: e => e.isActive('code') }),\n      ],\n    },\n    {\n      id: 'blocks',\n      order: 40,\n      items: [\n        commandItem({ id: 'bulletList', order: 10, icon: 'i-lucide-list', label: ctx.t('toolbar.bulletList'), kbds: ['meta', 'shift', '8'], ability: ABILITY.lists, command: c => c.toggleBulletList(), isActive: e => e.isActive('bulletList') }),\n        commandItem({ id: 'orderedList', order: 20, icon: 'i-lucide-list-ordered', label: ctx.t('toolbar.orderedList'), kbds: ['meta', 'shift', '7'], ability: ABILITY.lists, command: c => c.toggleOrderedList(), isActive: e => e.isActive('orderedList') }),\n        commandItem({ id: 'blockquote', order: 30, icon: 'i-lucide-text-quote', label: ctx.t('toolbar.blockquote'), kbds: ['meta', 'shift', 'b'], ability: ABILITY.blockquote, command: c => c.toggleBlockquote(), isActive: e => e.isActive('blockquote') }),\n        commandItem({ id: 'codeBlock', order: 40, icon: 'i-lucide-square-code', label: ctx.t('toolbar.codeBlock'), kbds: ['meta', 'alt', 'c'], ability: ABILITY.codeBlock, command: c => c.toggleCodeBlock(), isActive: e => e.isActive('codeBlock') }),\n        commandItem({ id: 'rule', order: 50, icon: 'i-lucide-minus', label: ctx.t('toolbar.rule'), ability: ABILITY.rule, command: c => c.setHorizontalRule() }),\n      ],\n    },\n  ]\n}\n"],"mappings":";;;;;;;AASA,SAAgB,kBAAkB,KAA4C;CAE5E,MAAM,iBAAiB,WAAmB,IAAI,SAAS,IAAI,CAAC,CAAC,OAAO,cAAc,UAAU,CAAC,OAAO,OAAO,MAAM;CACjH,OAAO;EACL;GACE,IAAI;GACJ,OAAO;GACP,OAAO,CACL,YAAY;IAAE,IAAI;IAAQ,OAAO;IAAI,MAAM;IAAmB,OAAO,IAAI,EAAE,cAAc;IAAG,MAAM,CAAC,QAAQ,GAAG;IAAG,UAAS,MAAK,EAAE,KAAK;GAAE,CAAC,GACzI,YAAY;IAAE,IAAI;IAAQ,OAAO;IAAI,MAAM;IAAmB,OAAO,IAAI,EAAE,cAAc;IAAG,MAAM;KAAC;KAAQ;KAAS;IAAG;IAAG,UAAS,MAAK,EAAE,KAAK;GAAE,CAAC,CACpJ;EACF;EACA;GACE,IAAI;GACJ,OAAO;GACP,OAAO,CACL,YAAY;IAAE,IAAI;IAAa,OAAO;IAAI,MAAM;IAAoB,OAAO,IAAI,EAAE,mBAAmB;IAAG,MAAM;KAAC;KAAQ;KAAO;IAAG;IAAG,UAAS,MAAK,EAAE,aAAa;IAAG,WAAU,MAAK,EAAE,SAAS,WAAW;GAAE,CAAC,GAE3M,GAAI;IAAC;IAAG;IAAG;GAAC,CAAC,CAAW,KAAI,WAAU;IACpC,GAAG,YAAY;KACb,IAAI,UAAU;KACd,OAAO,KAAK;KACZ,MAAM,oBAAoB;KAC1B,OAAO,IAAI,EAAE,mBAAmB,EAAE,MAAM,CAAC;KACzC,MAAM;MAAC;MAAQ;MAAO,OAAO,KAAK;KAAC;KACnC,SAAS,QAAQ;KACjB,UAAS,MAAK,EAAE,cAAc,EAAE,MAAM,CAAC;KACvC,WAAU,MAAK,EAAE,SAAS,WAAW,EAAE,MAAM,CAAC;IAChD,CAAC;IACD,SAAS;GACX,EAAE,CACJ;EACF;EACA;GACE,IAAI;GACJ,OAAO;GACP,OAAO;IACL,YAAY;KAAE,IAAI;KAAQ,OAAO;KAAI,MAAM;KAAiB,OAAO,IAAI,EAAE,cAAc;KAAG,MAAM,CAAC,QAAQ,GAAG;KAAG,SAAS,QAAQ;KAAO,UAAS,MAAK,EAAE,WAAW;KAAG,WAAU,MAAK,EAAE,SAAS,MAAM;IAAE,CAAC;IACxM,YAAY;KAAE,IAAI;KAAU,OAAO;KAAI,MAAM;KAAmB,OAAO,IAAI,EAAE,gBAAgB;KAAG,MAAM,CAAC,QAAQ,GAAG;KAAG,SAAS,QAAQ;KAAO,UAAS,MAAK,EAAE,aAAa;KAAG,WAAU,MAAK,EAAE,SAAS,QAAQ;IAAE,CAAC;IAClN,YAAY;KAAE,IAAI;KAAa,OAAO;KAAI,MAAM;KAAsB,OAAO,IAAI,EAAE,mBAAmB;KAAG,MAAM,CAAC,QAAQ,GAAG;KAAG,SAAS,QAAQ;KAAO,UAAS,MAAK,EAAE,gBAAgB;KAAG,WAAU,MAAK,EAAE,SAAS,WAAW;IAAE,CAAC;IAEjO,YAAY;KAAE,IAAI;KAAU,OAAO;KAAI,MAAM;KAA0B,OAAO,IAAI,EAAE,gBAAgB;KAAG,MAAM;MAAC;MAAQ;MAAS;KAAG;KAAG,SAAS,QAAQ;KAAO,UAAS,MAAK,EAAE,aAAa;KAAG,WAAU,MAAK,EAAE,SAAS,QAAQ;IAAE,CAAC;IAClO,YAAY;KAAE,IAAI;KAAQ,OAAO;KAAI,MAAM;KAAiB,OAAO,IAAI,EAAE,cAAc;KAAG,MAAM,CAAC,QAAQ,GAAG;KAAG,SAAS,QAAQ;KAAO,UAAS,MAAK,EAAE,WAAW;KAAG,WAAU,MAAK,EAAE,SAAS,MAAM;IAAE,CAAC;GAC1M;EACF;EACA;GACE,IAAI;GACJ,OAAO;GACP,OAAO;IACL,YAAY;KAAE,IAAI;KAAc,OAAO;KAAI,MAAM;KAAiB,OAAO,IAAI,EAAE,oBAAoB;KAAG,MAAM;MAAC;MAAQ;MAAS;KAAG;KAAG,SAAS,QAAQ;KAAO,UAAS,MAAK,EAAE,iBAAiB;KAAG,WAAU,MAAK,EAAE,SAAS,YAAY;IAAE,CAAC;IACzO,YAAY;KAAE,IAAI;KAAe,OAAO;KAAI,MAAM;KAAyB,OAAO,IAAI,EAAE,qBAAqB;KAAG,MAAM;MAAC;MAAQ;MAAS;KAAG;KAAG,SAAS,QAAQ;KAAO,UAAS,MAAK,EAAE,kBAAkB;KAAG,WAAU,MAAK,EAAE,SAAS,aAAa;IAAE,CAAC;IACrP,YAAY;KAAE,IAAI;KAAc,OAAO;KAAI,MAAM;KAAuB,OAAO,IAAI,EAAE,oBAAoB;KAAG,MAAM;MAAC;MAAQ;MAAS;KAAG;KAAG,SAAS,QAAQ;KAAY,UAAS,MAAK,EAAE,iBAAiB;KAAG,WAAU,MAAK,EAAE,SAAS,YAAY;IAAE,CAAC;IACpP,YAAY;KAAE,IAAI;KAAa,OAAO;KAAI,MAAM;KAAwB,OAAO,IAAI,EAAE,mBAAmB;KAAG,MAAM;MAAC;MAAQ;MAAO;KAAG;KAAG,SAAS,QAAQ;KAAW,UAAS,MAAK,EAAE,gBAAgB;KAAG,WAAU,MAAK,EAAE,SAAS,WAAW;IAAE,CAAC;IAC9O,YAAY;KAAE,IAAI;KAAQ,OAAO;KAAI,MAAM;KAAkB,OAAO,IAAI,EAAE,cAAc;KAAG,SAAS,QAAQ;KAAM,UAAS,MAAK,EAAE,kBAAkB;IAAE,CAAC;GACzJ;EACF;CACF;AACF"}

package/dist/core/toolbar.d.ts

@@ -0,0 +1,74 @@
+import { Ability } from "./schema/abilities.js";
+import { ChainedCommands, Editor } from "@tiptap/core";
+//#region src/core/toolbar.d.ts
+/** One row of a dropdown a toolbar item or block action opens; the framework layer renders it. */
+export interface MenuItem {
+  type?: 'label' | 'separator';
+  label?: string;
+  description?: string;
+  /** Iconify name, e.g. `i-lucide-heading-1`. */
+  icon?: string;
+  disabled?: boolean;
+  onSelect?: () => void;
+}
+interface ToolbarItemBase {
+  /** Unique within its group. */
+  id: string;
+  /** Tooltip and aria-label. */
+  label: string;
+  /** Iconify name, e.g. `i-lucide-bold`. */
+  icon: string;
+  /** Shortcut keys shown in the tooltip, e.g. `['meta', 'b']`. */
+  kbds?: string[];
+  /** Ability the item needs at the caret; turning an active toggle off never does. Unset: ungated. */
+  ability?: Ability;
+  /** Position within the group (ascending, stable); built-ins use their visual sequence. */
+  order?: number;
+  /** Whether the item is on at the caret (toggle style). */
+  active?: (editor: Editor) => boolean;
+  /** Extra condition for disabling the item. */
+  disabled?: (editor: Editor) => boolean;
+  /** Hides the item; evaluated only with a live editor. */
+  visible?: (editor: Editor) => boolean;
+}
+/**
+ * One button: `run` on click, `menu` (a dropdown of the items it returns), or `component`: a component that renders
+ * the whole button itself (with its own popover, badge or state) and receives `{ editor }`. A component item is placed
+ * in its group like any other and honors `visible`; `label` and `icon` only describe it (the component draws its own
+ * tooltip), and `ability`, `active`, `disabled` are not applied.
+ */
+export type ToolbarItem<C = unknown> = ToolbarItemBase & ({
+  run: (editor: Editor) => void;
+  menu?: never;
+  component?: never;
+} | {
+  menu: (editor: Editor) => MenuItem[];
+  run?: never;
+  component?: never;
+} | {
+  component: C;
+  run?: never;
+  menu?: never;
+});
+/** A visually joined set of buttons; groups of the same `id` from different features merge into one. */
+export interface ToolbarGroup<C = unknown> {
+  id: string;
+  /** Position among the groups (ascending, stable). */
+  order?: number;
+  /** Hides the group; evaluated only with a live editor. */
+  visible?: (editor: Editor) => boolean;
+  items: ToolbarItem<C>[];
+}
+/**
+ * A toolbar item over a command chain: `run` focuses the editor and executes `command`; the item is disabled while
+ * `can()` says the command is structurally impossible (also an empty undo history).
+ */
+export declare function commandItem(def: Omit<ToolbarItemBase, 'active' | 'disabled'> & {
+  command: (chain: ChainedCommands) => ChainedCommands;
+  isActive?: (editor: Editor) => boolean;
+}): ToolbarItem<never>;
+/** Merges groups of the same id and sorts groups and items by `order` (stable); the first group of an id keeps its position. */
+export declare function mergeToolbarGroups<C>(groups: readonly ToolbarGroup<C>[]): ToolbarGroup<C>[];
+//#endregion
+export {};
+//# sourceMappingURL=toolbar.d.ts.map

package/dist/core/toolbar.js

@@ -0,0 +1,45 @@
+//#region src/core/toolbar.ts
+/**
+* A toolbar item over a command chain: `run` focuses the editor and executes `command`; the item is disabled while
+* `can()` says the command is structurally impossible (also an empty undo history).
+*/
+function commandItem(def) {
+	const { command, isActive, ...item } = def;
+	return {
+		...item,
+		...isActive && { active: isActive },
+		disabled: (editor) => !command(editor.can().chain()).run(),
+		run: (editor) => {
+			command(editor.chain().focus()).run();
+		}
+	};
+}
+const byOrder = (a, b) => (a.order ?? 0) - (b.order ?? 0);
+/** Merges groups of the same id and sorts groups and items by `order` (stable); the first group of an id keeps its position. */
+function mergeToolbarGroups(groups) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const group of groups) {
+		const existing = merged.get(group.id);
+		if (!existing) {
+			merged.set(group.id, {
+				...group,
+				items: [...group.items]
+			});
+			continue;
+		}
+		existing.items.push(...group.items);
+		existing.order ??= group.order;
+		if (group.visible) {
+			const previous = existing.visible;
+			existing.visible = previous ? (editor) => previous(editor) && group.visible(editor) : group.visible;
+		}
+	}
+	return [...merged.values()].sort(byOrder).map((group) => ({
+		...group,
+		items: [...group.items].sort(byOrder)
+	}));
+}
+//#endregion
+export { commandItem, mergeToolbarGroups };
+
+//# sourceMappingURL=toolbar.js.map

package/dist/core/toolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar.js","names":[],"sources":["../../src/core/toolbar.ts"],"sourcesContent":["import type { ChainedCommands, Editor } from '@tiptap/core'\nimport type { Ability } from './schema/abilities'\n\n// Toolbar descriptors: features contribute groups, the framework layer's toolbar renders them. `C` is that layer's component type.\n\n/** One row of a dropdown a toolbar item or block action opens; the framework layer renders it. */\nexport interface MenuItem {\n  type?: 'label' | 'separator'\n  label?: string\n  description?: string\n  /** Iconify name, e.g. `i-lucide-heading-1`. */\n  icon?: string\n  disabled?: boolean\n  onSelect?: () => void\n}\n\ninterface ToolbarItemBase {\n  /** Unique within its group. */\n  id: string\n  /** Tooltip and aria-label. */\n  label: string\n  /** Iconify name, e.g. `i-lucide-bold`. */\n  icon: string\n  /** Shortcut keys shown in the tooltip, e.g. `['meta', 'b']`. */\n  kbds?: string[]\n  /** Ability the item needs at the caret; turning an active toggle off never does. Unset: ungated. */\n  ability?: Ability\n  /** Position within the group (ascending, stable); built-ins use their visual sequence. */\n  order?: number\n  /** Whether the item is on at the caret (toggle style). */\n  active?: (editor: Editor) => boolean\n  /** Extra condition for disabling the item. */\n  disabled?: (editor: Editor) => boolean\n  /** Hides the item; evaluated only with a live editor. */\n  visible?: (editor: Editor) => boolean\n}\n\n/**\n * One button: `run` on click, `menu` (a dropdown of the items it returns), or `component`: a component that renders\n * the whole button itself (with its own popover, badge or state) and receives `{ editor }`. A component item is placed\n * in its group like any other and honors `visible`; `label` and `icon` only describe it (the component draws its own\n * tooltip), and `ability`, `active`, `disabled` are not applied.\n */\nexport type ToolbarItem<C = unknown> = ToolbarItemBase & (\n  | { run: (editor: Editor) => void, menu?: never, component?: never }\n  | { menu: (editor: Editor) => MenuItem[], run?: never, component?: never }\n  | { component: C, run?: never, menu?: never }\n)\n\n/** A visually joined set of buttons; groups of the same `id` from different features merge into one. */\nexport interface ToolbarGroup<C = unknown> {\n  id: string\n  /** Position among the groups (ascending, stable). */\n  order?: number\n  /** Hides the group; evaluated only with a live editor. */\n  visible?: (editor: Editor) => boolean\n  items: ToolbarItem<C>[]\n}\n\n/**\n * A toolbar item over a command chain: `run` focuses the editor and executes `command`; the item is disabled while\n * `can()` says the command is structurally impossible (also an empty undo history).\n */\nexport function commandItem(def: Omit<ToolbarItemBase, 'active' | 'disabled'> & {\n  command: (chain: ChainedCommands) => ChainedCommands\n  isActive?: (editor: Editor) => boolean\n}): ToolbarItem<never> {\n  const { command, isActive, ...item } = def\n  return {\n    ...item,\n    ...(isActive && { active: isActive }),\n    disabled: editor => !command(editor.can().chain()).run(),\n    run: (editor) => { command(editor.chain().focus()).run() },\n  }\n}\n\nconst byOrder = <T extends { order?: number }>(a: T, b: T) => (a.order ?? 0) - (b.order ?? 0)\n\n/** Merges groups of the same id and sorts groups and items by `order` (stable); the first group of an id keeps its position. */\nexport function mergeToolbarGroups<C>(groups: readonly ToolbarGroup<C>[]): ToolbarGroup<C>[] {\n  const merged = new Map<string, ToolbarGroup<C>>()\n  for (const group of groups) {\n    const existing = merged.get(group.id)\n    if (!existing) {\n      merged.set(group.id, { ...group, items: [...group.items] })\n      continue\n    }\n    existing.items.push(...group.items)\n    existing.order ??= group.order\n    if (group.visible) {\n      const previous = existing.visible\n      existing.visible = previous ? editor => previous(editor) && group.visible!(editor) : group.visible\n    }\n  }\n  return [...merged.values()].sort(byOrder).map(group => ({ ...group, items: [...group.items].sort(byOrder) }))\n}\n"],"mappings":";;;;;AA+DA,SAAgB,YAAY,KAGL;CACrB,MAAM,EAAE,SAAS,UAAU,GAAG,SAAS;CACvC,OAAO;EACL,GAAG;EACH,GAAI,YAAY,EAAE,QAAQ,SAAS;EACnC,WAAU,WAAU,CAAC,QAAQ,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;EACvD,MAAM,WAAW;GAAE,QAAQ,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;EAAE;CAC3D;AACF;AAEA,MAAM,WAAyC,GAAM,OAAU,EAAE,SAAS,MAAM,EAAE,SAAS;;AAG3F,SAAgB,mBAAsB,QAAuD;CAC3F,MAAM,yBAAS,IAAI,IAA6B;CAChD,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,OAAO,IAAI,MAAM,EAAE;EACpC,IAAI,CAAC,UAAU;GACb,OAAO,IAAI,MAAM,IAAI;IAAE,GAAG;IAAO,OAAO,CAAC,GAAG,MAAM,KAAK;GAAE,CAAC;GAC1D;EACF;EACA,SAAS,MAAM,KAAK,GAAG,MAAM,KAAK;EAClC,SAAS,UAAU,MAAM;EACzB,IAAI,MAAM,SAAS;GACjB,MAAM,WAAW,SAAS;GAC1B,SAAS,UAAU,YAAW,WAAU,SAAS,MAAM,KAAK,MAAM,QAAS,MAAM,IAAI,MAAM;EAC7F;CACF;CACA,OAAO,CAAC,GAAG,OAAO,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,KAAI,WAAU;EAAE,GAAG;EAAO,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC,CAAC,KAAK,OAAO;CAAE,EAAE;AAC9G"}

package/dist/document/DocumentSurface.d.ts

@@ -0,0 +1,38 @@
+import { MarkdownSurfaceProps } from "../markdown/MarkdownSurface.js";
+import { EditorView } from "@codemirror/view";
+import { ReactNode } from "react";
+import { Editor } from "@tiptap/core";
+//#region src/document/DocumentSurface.d.ts
+/** Which surface was mounted and its editor, for `onReady`. */
+export type DocumentSurfaceTarget = {
+  kind: 'markdown';
+  editor: Editor;
+} | {
+  kind: 'code';
+  view: EditorView;
+};
+export interface DocumentSurfaceProps {
+  /** The document's path; its extension (and `mime`) decides the surface (`kindOf`) and the code language (`languageOf`). */
+  path: string;
+  /** The document text. */
+  value?: string;
+  mime?: string;
+  onChange?: (text: string) => void;
+  /** Mod-S in the code surface, with the current text. */
+  onSave?: (text: string) => void;
+  onReady?: (target: DocumentSurfaceTarget) => void;
+  editable?: boolean;
+  /** Code surface only: the language id, overriding the one the path implies. */
+  language?: string;
+  /** Code surface only. */
+  wordWrap?: boolean;
+  /** The Markdown surface's own props (`preset` at least), used when `path` is a Markdown file. */
+  markdown: Omit<MarkdownSurfaceProps, 'value' | 'editable' | 'onChange' | 'onReady'>;
+  /** Shown for a file that is neither Markdown nor text. */
+  binary?: (path: string) => ReactNode;
+  className?: string;
+}
+/** The Markdown surface or the code surface, by `kindOf(path, mime)`. Remount (`key={path}`) when the path changes. */
+export declare function DocumentSurface(props: DocumentSurfaceProps): import("react").JSX.Element;
+//#endregion
+//# sourceMappingURL=DocumentSurface.d.ts.map

package/dist/document/DocumentSurface.js

@@ -0,0 +1,44 @@
+import { kindOf, languageOf } from "../code/kind.js";
+import { CodeSurface } from "../code/CodeSurface.js";
+import { MarkdownSurface } from "../markdown/MarkdownSurface.js";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region src/document/DocumentSurface.tsx
+/** The Markdown surface or the code surface, by `kindOf(path, mime)`. Remount (`key={path}`) when the path changes. */
+function DocumentSurface(props) {
+	const { path, value = "", mime, editable = true, language, wordWrap = true, markdown, binary, className, onChange, onSave, onReady } = props;
+	const kind = kindOf(path, mime);
+	if (kind === "markdown") return /* @__PURE__ */ jsx("div", {
+		className,
+		children: /* @__PURE__ */ jsx(MarkdownSurface, {
+			...markdown,
+			value,
+			editable,
+			...onChange && { onChange },
+			onReady: (editor) => onReady?.({
+				kind: "markdown",
+				editor
+			})
+		})
+	});
+	if (kind === "code") {
+		const lang = language ?? languageOf(path);
+		return /* @__PURE__ */ jsx(CodeSurface, {
+			value,
+			editable,
+			wordWrap,
+			...lang !== void 0 && { language: lang },
+			...className && { className },
+			...onChange && { onChange },
+			...onSave && { onSave },
+			onReady: (view) => onReady?.({
+				kind: "code",
+				view
+			})
+		});
+	}
+	return /* @__PURE__ */ jsx(Fragment, { children: binary?.(path) });
+}
+//#endregion
+export { DocumentSurface };
+
+//# sourceMappingURL=DocumentSurface.js.map

package/dist/document/DocumentSurface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentSurface.js","names":[],"sources":["../../src/document/DocumentSurface.tsx"],"sourcesContent":["import type { Editor } from '@tiptap/core'\nimport type { EditorView } from '@codemirror/view'\nimport type { ReactNode } from 'react'\nimport { CodeSurface } from '../code/CodeSurface'\nimport { kindOf, languageOf } from '../code/kind'\nimport { MarkdownSurface, type MarkdownSurfaceProps } from '../markdown/MarkdownSurface'\n\n/** Which surface was mounted and its editor, for `onReady`. */\nexport type DocumentSurfaceTarget = { kind: 'markdown', editor: Editor } | { kind: 'code', view: EditorView }\n\nexport interface DocumentSurfaceProps {\n  /** The document's path; its extension (and `mime`) decides the surface (`kindOf`) and the code language (`languageOf`). */\n  path: string\n  /** The document text. */\n  value?: string\n  mime?: string\n  onChange?: (text: string) => void\n  /** Mod-S in the code surface, with the current text. */\n  onSave?: (text: string) => void\n  onReady?: (target: DocumentSurfaceTarget) => void\n  editable?: boolean\n  /** Code surface only: the language id, overriding the one the path implies. */\n  language?: string\n  /** Code surface only. */\n  wordWrap?: boolean\n  /** The Markdown surface's own props (`preset` at least), used when `path` is a Markdown file. */\n  markdown: Omit<MarkdownSurfaceProps, 'value' | 'editable' | 'onChange' | 'onReady'>\n  /** Shown for a file that is neither Markdown nor text. */\n  binary?: (path: string) => ReactNode\n  className?: string\n}\n\n/** The Markdown surface or the code surface, by `kindOf(path, mime)`. Remount (`key={path}`) when the path changes. */\nexport function DocumentSurface(props: DocumentSurfaceProps) {\n  const { path, value = '', mime, editable = true, language, wordWrap = true, markdown, binary, className, onChange, onSave, onReady } = props\n  const kind = kindOf(path, mime)\n  if (kind === 'markdown') {\n    return (\n      <div className={className}>\n        <MarkdownSurface\n          {...markdown}\n          value={value}\n          editable={editable}\n          {...(onChange && { onChange })}\n          onReady={editor => onReady?.({ kind: 'markdown', editor })}\n        />\n      </div>\n    )\n  }\n  if (kind === 'code') {\n    const lang = language ?? languageOf(path)\n    return (\n      <CodeSurface\n        value={value}\n        editable={editable}\n        wordWrap={wordWrap}\n        {...(lang !== undefined && { language: lang })}\n        {...(className && { className })}\n        {...(onChange && { onChange })}\n        {...(onSave && { onSave })}\n        onReady={view => onReady?.({ kind: 'code', view })}\n      />\n    )\n  }\n  return <>{binary?.(path)}</>\n}\n"],"mappings":";;;;;;AAiCA,SAAgB,gBAAgB,OAA6B;CAC3D,MAAM,EAAE,MAAM,QAAQ,IAAI,MAAM,WAAW,MAAM,UAAU,WAAW,MAAM,UAAU,QAAQ,WAAW,UAAU,QAAQ,YAAY;CACvI,MAAM,OAAO,OAAO,MAAM,IAAI;CAC9B,IAAI,SAAS,YACX,OACE,oBAAC,OAAD;EAAgB;EACd,UAAA,oBAAC,iBAAD;GACE,GAAI;GACG;GACG;GACV,GAAK,YAAY,EAAE,SAAS;GAC5B,UAAS,WAAU,UAAU;IAAE,MAAM;IAAY;GAAO,CAAC;EAC1D,CAAA;CACE,CAAA;CAGT,IAAI,SAAS,QAAQ;EACnB,MAAM,OAAO,YAAY,WAAW,IAAI;EACxC,OACE,oBAAC,aAAD;GACS;GACG;GACA;GACV,GAAK,SAAS,KAAA,KAAa,EAAE,UAAU,KAAK;GAC5C,GAAK,aAAa,EAAE,UAAU;GAC9B,GAAK,YAAY,EAAE,SAAS;GAC5B,GAAK,UAAU,EAAE,OAAO;GACxB,UAAS,SAAQ,UAAU;IAAE,MAAM;IAAQ;GAAK,CAAC;EAClD,CAAA;CAEL;CACA,OAAO,oBAAA,UAAA,EAAA,UAAG,SAAS,IAAI,EAAI,CAAA;AAC7B"}

package/dist/document/DocumentSurface.vue.d.ts

@@ -0,0 +1,56 @@
+import _default$1 from "../markdown/MarkdownSurface.vue.js";
+import { EditorView } from "@codemirror/view";
+import { Editor } from "@tiptap/vue-3";
+//#region src/document/DocumentSurface.vue.d.ts
+type MarkdownProps = Omit<InstanceType<typeof _default$1>['$props'], 'modelValue' | 'editable' | 'onReady' | 'onUpdate:modelValue'>;
+/** Which surface was mounted and its editor, for the `ready` event. */
+export type DocumentSurfaceTarget = {
+  kind: 'markdown';
+  editor: Editor;
+} | {
+  kind: 'code';
+  view: EditorView;
+};
+type __VLS_Props = {
+  /** The document's path; its extension (and `mime`) decides the surface (`kindOf`) and the code language (`languageOf`). */
+  path: string;
+  /** The document text. */
+  modelValue?: string;
+  mime?: string;
+  editable?: boolean;
+  /** Code surface only: the language id, overriding the one the path implies. */
+  language?: string;
+  /** Code surface only. */
+  wordWrap?: boolean;
+  /** The Markdown surface's own props (`preset` at least), used when `path` is a Markdown file. */
+  markdown: MarkdownProps;
+};
+declare var __VLS_13: string, __VLS_14: any, __VLS_26: {
+  path: string;
+};
+type __VLS_Slots = {} & { [K in NonNullable<typeof __VLS_13>]?: (props: typeof __VLS_14) => any; } & {
+  binary?: (props: typeof __VLS_26) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  ready: (target: DocumentSurfaceTarget) => any;
+  "update:modelValue": (text: string) => any;
+  save: (text: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+  onReady?: ((target: DocumentSurfaceTarget) => any) | undefined;
+  "onUpdate:modelValue"?: ((text: string) => any) | undefined;
+  onSave?: ((text: string) => any) | undefined;
+}>, {
+  modelValue: string;
+  editable: boolean;
+  wordWrap: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { _default as default };
+//# sourceMappingURL=DocumentSurface.vue.d.ts.map