@ecsplico/editor 0.0.0-stage → 2.0.0

package/dist/markdown/MarkdownSurface2.js

@@ -0,0 +1,237 @@
+import { contentToMarkdown, markdownToContent } from "./document.js";
+import { MarkdownClipboard } from "./clipboard.js";
+import { joinFrontmatter, splitFrontmatter } from "./frontmatter.js";
+import { useUiKit } from "../vue/kit/use-ui-kit.js";
+import { useEditorI18n } from "../vue/use-editor-i18n.js";
+import _sfc_main$1 from "../vue/components/EditorSurface.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createVNode, defineComponent, guardReactiveProps, mergeModels, normalizeProps, onBeforeUnmount, openBlock, ref, renderList, renderSlot, shallowRef, unref, useModel, vShow, watch, withCtx, withDirectives } from "vue";
+//#region src/markdown/MarkdownSurface.vue
+const _hoisted_1 = { class: "contents" };
+const _hoisted_2 = {
+	key: 0,
+	class: "flex flex-col gap-3",
+	"data-testid": "markdown-source"
+};
+const _hoisted_3 = { class: "flex justify-end gap-2" };
+const _sfc_main = /*@__PURE__*/ defineComponent({
+	inheritAttrs: false,
+	__name: "MarkdownSurface",
+	props: /*@__PURE__*/ mergeModels({
+		modelValue: { default: "" },
+		preset: {},
+		collaboration: {},
+		metadata: {},
+		abilities: {},
+		extensions: {},
+		blockActions: {},
+		slashCommands: {},
+		documentId: {},
+		upload: {},
+		editable: {
+			type: Boolean,
+			default: true
+		},
+		settingsUi: { default: "internal" },
+		policy: {},
+		sourceMode: {}
+	}, {
+		"sidebarOpen": {
+			type: Boolean,
+			default: false
+		},
+		"sidebarOpenModifiers": {},
+		"commentsOpen": {
+			type: Boolean,
+			default: false
+		},
+		"commentsOpenModifiers": {}
+	}),
+	emits: /*@__PURE__*/ mergeModels([
+		"update:modelValue",
+		"frontmatter",
+		"ready",
+		"metadataCreate",
+		"contentError",
+		"diagnostics",
+		"settingsOpen"
+	], ["update:sidebarOpen", "update:commentsOpen"]),
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const { Button: UButton, Textarea: UTextarea, Alert: UAlert } = useUiKit();
+		const { t } = useEditorI18n();
+		const emit = __emit;
+		const sidebarOpen = useModel(__props, "sidebarOpen");
+		const commentsOpen = useModel(__props, "commentsOpen");
+		const surface = ref(null);
+		const editor = shallowRef();
+		const sourceState = shallowRef();
+		watch(() => props.sourceMode, (mode, _previous, onCleanup) => {
+			sourceState.value = mode?.state.get();
+			if (mode) onCleanup(mode.state.subscribe((state) => {
+				sourceState.value = state;
+			}));
+		}, { immediate: true });
+		const inSource = computed(() => sourceState.value?.mode === "source");
+		const extensionsWithClipboard = computed(() => props.extensions?.some((extension) => extension.name === "markdownClipboard") ? props.extensions : [...props.extensions ?? [], MarkdownClipboard.configure({ policy: props.policy ?? {} })]);
+		/** The frontmatter block of the text last handed in (or emitted): it is written back unchanged. */
+		let frontmatter = null;
+		/** Whether the text ended with a line break: the emitted text then does too, so saving a file does not flip it. */
+		let finalBreak = false;
+		/** The body (text after the frontmatter) the editor's document stands for; an incoming text with this body only changes the frontmatter. */
+		let loadedBody = null;
+		/** The text last sent through `update:modelValue`; the host handing it back is not an external change. */
+		let lastEmitted;
+		/** `body` as document JSON, migrated by the preset and checked against the editor's schema; an error is reported through `contentError`, not thrown. */
+		function parsed(instance, body) {
+			try {
+				const { content, diagnostics } = markdownToContent(instance, body, {
+					policy: props.policy,
+					t
+				});
+				instance.schema.nodeFromJSON(content).check();
+				emit("diagnostics", diagnostics);
+				return content;
+			} catch (error) {
+				emit("contentError", error instanceof Error ? error : new Error(String(error)));
+				return;
+			}
+		}
+		/** Replaces the document without an update event and outside the undo history: loading a text is not an edit. */
+		function load(instance, body) {
+			const json = parsed(instance, body);
+			if (!json) return false;
+			const { state } = instance;
+			const doc = instance.schema.nodeFromJSON(json);
+			instance.view.dispatch(state.tr.replaceWith(0, state.doc.content.size, doc.content).setMeta("addToHistory", false).setMeta("preventUpdate", true));
+			return true;
+		}
+		/** Takes in a text from the host: the frontmatter always, the body into the document unless this is a collaborative editor (its document is the shared one). */
+		function adopt(instance, text) {
+			const split = splitFrontmatter(text);
+			if (split.frontmatter !== frontmatter) {
+				frontmatter = split.frontmatter;
+				emit("frontmatter", frontmatter);
+			}
+			finalBreak = split.body.endsWith("\n");
+			if (props.collaboration || split.body === loadedBody) return;
+			if (load(instance, split.body)) loadedBody = split.body;
+		}
+		function emitCurrent(instance) {
+			const markdown = contentToMarkdown(instance);
+			const body = markdown && finalBreak ? `${markdown}\n` : markdown;
+			loadedBody = body;
+			lastEmitted = joinFrontmatter(frontmatter, body);
+			emit("update:modelValue", lastEmitted);
+		}
+		function onUpdate({ editor: instance }) {
+			emitCurrent(instance);
+		}
+		function onReady(instance) {
+			editor.value = instance;
+			frontmatter = splitFrontmatter(props.modelValue).frontmatter;
+			adopt(instance, props.modelValue);
+			instance.on("update", onUpdate);
+			emit("ready", instance);
+		}
+		watch(() => props.modelValue, (text) => {
+			const instance = editor.value;
+			if (!instance || instance.isDestroyed || text === lastEmitted) return;
+			lastEmitted = void 0;
+			adopt(instance, text);
+		});
+		onBeforeUnmount(() => editor.value?.off("update", onUpdate));
+		__expose({
+			editor,
+			settingsOpen: computed({
+				get: () => surface.value?.settingsOpen ?? false,
+				set: (open) => {
+					if (surface.value) surface.value.settingsOpen = open;
+				}
+			}),
+			settingsTab: computed({
+				get: () => surface.value?.settingsTab,
+				set: (tab) => {
+					if (surface.value) surface.value.settingsTab = tab;
+				}
+			})
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [withDirectives(createElementVNode("div", _hoisted_1, [createVNode(_sfc_main$1, {
+				ref_key: "surface",
+				ref: surface,
+				"sidebar-open": sidebarOpen.value,
+				"onUpdate:sidebarOpen": _cache[0] || (_cache[0] = ($event) => sidebarOpen.value = $event),
+				"comments-open": commentsOpen.value,
+				"onUpdate:commentsOpen": _cache[1] || (_cache[1] = ($event) => commentsOpen.value = $event),
+				preset: __props.preset,
+				collaboration: __props.collaboration,
+				metadata: __props.metadata,
+				abilities: __props.abilities,
+				extensions: extensionsWithClipboard.value,
+				"block-actions": __props.blockActions,
+				"slash-commands": __props.slashCommands,
+				"document-id": __props.documentId,
+				upload: __props.upload,
+				editable: __props.editable,
+				"settings-ui": __props.settingsUi,
+				onReady,
+				onMetadataCreate: _cache[2] || (_cache[2] = (list, item) => emit("metadataCreate", list, item)),
+				onSettingsOpen: _cache[3] || (_cache[3] = (tab) => emit("settingsOpen", tab))
+			}, createSlots({ _: 2 }, [renderList(_ctx.$slots, (_, name) => {
+				return {
+					name,
+					fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps ?? {})))])
+				};
+			})]), 1032, [
+				"sidebar-open",
+				"comments-open",
+				"preset",
+				"collaboration",
+				"metadata",
+				"abilities",
+				"extensions",
+				"block-actions",
+				"slash-commands",
+				"document-id",
+				"upload",
+				"editable",
+				"settings-ui"
+			])], 512), [[vShow, !inSource.value]]), __props.sourceMode && sourceState.value && inSource.value ? (openBlock(), createElementBlock("section", _hoisted_2, [
+				createVNode(unref(UTextarea), {
+					"model-value": sourceState.value.source,
+					"aria-label": unref(t)("markdown.source.label"),
+					class: "w-full font-mono",
+					rows: 16,
+					autoresize: "",
+					autofocus: "",
+					"data-testid": "markdown-source-input",
+					"onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => __props.sourceMode.edit($event ?? ""))
+				}, null, 8, ["model-value", "aria-label"]),
+				(openBlock(true), createElementBlock(Fragment, null, renderList(sourceState.value.diagnostics, (diagnostic, index) => {
+					return openBlock(), createBlock(unref(UAlert), {
+						key: index,
+						color: diagnostic.severity === "error" ? "error" : diagnostic.severity === "warning" ? "warning" : "info",
+						variant: "subtle",
+						title: diagnostic.line ? `${diagnostic.line}: ${diagnostic.message}` : diagnostic.message,
+						"data-testid": "markdown-source-diagnostic"
+					}, null, 8, ["color", "title"]);
+				}), 128)),
+				createElementVNode("div", _hoisted_3, [createVNode(unref(UButton), {
+					label: unref(t)("markdown.source.cancel"),
+					color: "neutral",
+					variant: "ghost",
+					"data-testid": "markdown-source-cancel",
+					onClick: _cache[5] || (_cache[5] = ($event) => __props.sourceMode.cancel())
+				}, null, 8, ["label"]), createVNode(unref(UButton), {
+					label: unref(t)("markdown.source.apply"),
+					"data-testid": "markdown-source-apply",
+					onClick: _cache[6] || (_cache[6] = ($event) => __props.sourceMode.commit())
+				}, null, 8, ["label"])])
+			])) : createCommentVNode("v-if", true)], 64);
+		};
+	}
+});
+//#endregion
+export { _sfc_main as default };
+
+//# sourceMappingURL=MarkdownSurface2.js.map

package/dist/markdown/MarkdownSurface2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownSurface2.js","names":["$slots","_useModel","_openBlock","_createElementBlock","_Fragment","_withDirectives","_createElementVNode","_createVNode","EditorSurface","_createSlots","_renderList","_withCtx","_renderSlot","_normalizeProps","_guardReactiveProps","_vShow","_unref","_createBlock","_createCommentVNode"],"sources":["../../src/markdown/MarkdownSurface.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport type { Editor as CoreEditor } from '@tiptap/core'\nimport type { AnyExtension, Editor, JSONContent } from '@tiptap/vue-3'\nimport { computed, onBeforeUnmount, ref, shallowRef, watch } from 'vue'\nimport { useUiKit } from '../vue/kit/use-ui-kit'\nimport { useEditorI18n } from '../vue/use-editor-i18n'\nimport type { AbilitiesOptions, BlockAction, SlashCommandItem } from '../core/extension-points'\nimport type { CollaborationSession, EditorPreset, UploadFn } from '../core/feature'\nimport type { EditorMetadata, MetadataItem } from '../core/metadata-types'\nimport EditorSurface from '../vue/components/EditorSurface.vue'\nimport { MarkdownClipboard } from './clipboard'\nimport { contentToMarkdown, markdownToContent } from './document'\nimport { joinFrontmatter, splitFrontmatter } from './frontmatter'\nimport type { MarkdownDiagnostic, MarkdownPolicy } from './policy'\nimport type { SourceMode, SourceModeState } from './source-mode'\n\ndefineOptions({ inheritAttrs: false })\n\n// The props, emits and slots of `EditorSurface` are forwarded as they are (see there for their meaning); the\n// document is not its JSON `modelValue` but a Markdown string.\nconst props = withDefaults(defineProps<{\n  /** The document as Markdown text, YAML frontmatter included (kept verbatim and never shown in the editor). */\n  modelValue?: string\n  preset: EditorPreset\n  collaboration?: CollaborationSession\n  metadata?: EditorMetadata\n  abilities?: Partial<AbilitiesOptions>\n  extensions?: AnyExtension[]\n  blockActions?: BlockAction[]\n  slashCommands?: (defaults: SlashCommandItem[]) => SlashCommandItem[]\n  documentId?: string\n  upload?: UploadFn\n  editable?: boolean\n  settingsUi?: 'internal' | 'external'\n  /** What Markdown text may carry in, for loaded text and pasted text alike (see `MarkdownPolicy`). Default: no raw HTML, no data-URL images, safe link schemes only. */\n  policy?: MarkdownPolicy\n  /**\n   * Source mode (`createSourceMode`): while its state is `source`, the surface shows the draft in a plain text area\n   * instead of the editor, with the diagnostics of a rejected commit and Apply / Cancel buttons; the editor is kept\n   * alive underneath. The mode is entered by the host (`sourceMode.enter()`).\n   */\n  sourceMode?: SourceMode\n}>(), { modelValue: '', editable: true, settingsUi: 'internal' })\n\nconst { Button: UButton, Textarea: UTextarea, Alert: UAlert } = useUiKit()\nconst { t } = useEditorI18n()\n\nconst emit = defineEmits<{\n  /** The whole text (frontmatter and Markdown body) after every edit, in collaborative mode after every update of the shared document, remote ones included. */\n  'update:modelValue': [markdown: string]\n  /** The frontmatter block the incoming `modelValue` carries changed (null: it has none); the verbatim block, fences included. */\n  'frontmatter': [frontmatter: string | null]\n  'ready': [editor: Editor]\n  'metadataCreate': [list: string, item: MetadataItem]\n  /** The Markdown handed in does not fit this editor's schema; the last valid document stays. */\n  'contentError': [error: Error]\n  /** What parsing the text handed in dropped or could not understand (raw HTML, unsafe URLs, unknown fences, broken fences); emitted after each load. */\n  'diagnostics': [diagnostics: MarkdownDiagnostic[]]\n  'settingsOpen': [tab?: string]\n}>()\n\nconst sidebarOpen = defineModel<boolean>('sidebarOpen', { default: false })\nconst commentsOpen = defineModel<boolean>('commentsOpen', { default: false })\n\nconst surface = ref<{ settingsOpen: boolean, settingsTab: string | undefined } | null>(null)\nconst editor = shallowRef<Editor>()\n\nconst sourceState = shallowRef<SourceModeState>()\nwatch(() => props.sourceMode, (mode, _previous, onCleanup) => {\n  sourceState.value = mode?.state.get()\n  if (mode) onCleanup(mode.state.subscribe((state) => { sourceState.value = state }))\n}, { immediate: true })\nconst inSource = computed(() => sourceState.value?.mode === 'source')\n// A policy change takes effect with the next editor: the clipboard extension is built with the editor.\nconst extensionsWithClipboard = computed(() => props.extensions?.some(extension => extension.name === 'markdownClipboard')\n  ? props.extensions\n  : [...(props.extensions ?? []), MarkdownClipboard.configure({ policy: props.policy ?? {} })])\n\n/** The frontmatter block of the text last handed in (or emitted): it is written back unchanged. */\nlet frontmatter: string | null = null\n/** Whether the text ended with a line break: the emitted text then does too, so saving a file does not flip it. */\nlet finalBreak = false\n/** The body (text after the frontmatter) the editor's document stands for; an incoming text with this body only changes the frontmatter. */\nlet loadedBody: string | null = null\n/** The text last sent through `update:modelValue`; the host handing it back is not an external change. */\nlet lastEmitted: string | undefined\n\n/** `body` as document JSON, migrated by the preset and checked against the editor's schema; an error is reported through `contentError`, not thrown. */\nfunction parsed(instance: Editor, body: string): JSONContent | undefined {\n  try {\n    const { content, diagnostics } = markdownToContent(instance, body, { policy: props.policy, t })\n    instance.schema.nodeFromJSON(content).check()\n    emit('diagnostics', diagnostics)\n    return content\n  }\n  catch (error) {\n    emit('contentError', error instanceof Error ? error : new Error(String(error)))\n    return undefined\n  }\n}\n\n/** Replaces the document without an update event and outside the undo history: loading a text is not an edit. */\nfunction load(instance: Editor, body: string): boolean {\n  const json = parsed(instance, body)\n  if (!json) return false\n  const { state } = instance\n  const doc = instance.schema.nodeFromJSON(json)\n  instance.view.dispatch(state.tr.replaceWith(0, state.doc.content.size, doc.content).setMeta('addToHistory', false).setMeta('preventUpdate', true))\n  return true\n}\n\n/** Takes in a text from the host: the frontmatter always, the body into the document unless this is a collaborative editor (its document is the shared one). */\nfunction adopt(instance: Editor, text: string) {\n  const split = splitFrontmatter(text)\n  if (split.frontmatter !== frontmatter) {\n    frontmatter = split.frontmatter\n    emit('frontmatter', frontmatter)\n  }\n  finalBreak = split.body.endsWith('\\n')\n  if (props.collaboration || split.body === loadedBody) return\n  if (load(instance, split.body)) loadedBody = split.body\n}\n\nfunction emitCurrent(instance: CoreEditor) {\n  const markdown = contentToMarkdown(instance)\n  const body = markdown && finalBreak ? `${markdown}\\n` : markdown\n  loadedBody = body\n  lastEmitted = joinFrontmatter(frontmatter, body)\n  emit('update:modelValue', lastEmitted)\n}\n\nfunction onUpdate({ editor: instance }: { editor: CoreEditor }) {\n  emitCurrent(instance)\n}\n\nfunction onReady(instance: Editor) {\n  editor.value = instance\n  // The editor and its pipeline exist only now, so the text is parsed now (first load: no `frontmatter` event for a block that was always there).\n  frontmatter = splitFrontmatter(props.modelValue).frontmatter\n  adopt(instance, props.modelValue)\n  instance.on('update', onUpdate)\n  emit('ready', instance)\n}\n\nwatch(() => props.modelValue, (text) => {\n  const instance = editor.value\n  if (!instance || instance.isDestroyed || text === lastEmitted) return\n  lastEmitted = undefined\n  adopt(instance, text)\n})\n\nonBeforeUnmount(() => editor.value?.off('update', onUpdate))\n\ndefineExpose({\n  editor,\n  settingsOpen: computed({ get: () => surface.value?.settingsOpen ?? false, set: (open: boolean) => { if (surface.value) surface.value.settingsOpen = open } }),\n  settingsTab: computed({ get: () => surface.value?.settingsTab, set: (tab: string | undefined) => { if (surface.value) surface.value.settingsTab = tab } }),\n})\n</script>\n\n<template>\n  <div v-show=\"!inSource\" class=\"contents\">\n    <EditorSurface\n      ref=\"surface\"\n      v-model:sidebar-open=\"sidebarOpen\"\n      v-model:comments-open=\"commentsOpen\"\n      :preset=\"preset\"\n      :collaboration=\"collaboration\"\n      :metadata=\"metadata\"\n      :abilities=\"abilities\"\n      :extensions=\"extensionsWithClipboard\"\n      :block-actions=\"blockActions\"\n      :slash-commands=\"slashCommands\"\n      :document-id=\"documentId\"\n      :upload=\"upload\"\n      :editable=\"editable\"\n      :settings-ui=\"settingsUi\"\n      @ready=\"onReady\"\n      @metadata-create=\"(list, item) => emit('metadataCreate', list, item)\"\n      @settings-open=\"tab => emit('settingsOpen', tab)\"\n    >\n      <template v-for=\"(_, name) in $slots\" :key=\"name\" #[name]=\"slotProps\">\n        <slot :name=\"name\" v-bind=\"slotProps ?? {}\" />\n      </template>\n    </EditorSurface>\n  </div>\n  <section v-if=\"sourceMode && sourceState && inSource\" class=\"flex flex-col gap-3\" data-testid=\"markdown-source\">\n    <UTextarea\n      :model-value=\"sourceState.source\"\n      :aria-label=\"t('markdown.source.label')\"\n      class=\"w-full font-mono\"\n      :rows=\"16\"\n      autoresize\n      autofocus\n      data-testid=\"markdown-source-input\"\n      @update:model-value=\"sourceMode.edit($event ?? '')\"\n    />\n    <UAlert\n      v-for=\"(diagnostic, index) in sourceState.diagnostics\"\n      :key=\"index\"\n      :color=\"diagnostic.severity === 'error' ? 'error' : diagnostic.severity === 'warning' ? 'warning' : 'info'\"\n      variant=\"subtle\"\n      :title=\"diagnostic.line ? `${diagnostic.line}: ${diagnostic.message}` : diagnostic.message\"\n      data-testid=\"markdown-source-diagnostic\"\n    />\n    <div class=\"flex justify-end gap-2\">\n      <UButton :label=\"t('markdown.source.cancel')\" color=\"neutral\" variant=\"ghost\" data-testid=\"markdown-source-cancel\" @click=\"sourceMode.cancel()\" />\n      <UButton :label=\"t('markdown.source.apply')\" data-testid=\"markdown-source-apply\" @click=\"sourceMode.commit()\" />\n    </div>\n  </section>\n</template>\n"],"mappings":"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"}

package/dist/markdown/clipboard.d.ts

@@ -0,0 +1,17 @@
+import { MarkdownPolicy } from "./policy.js";
+import { Extension } from "@tiptap/core";
+//#region src/markdown/clipboard.d.ts
+export interface MarkdownClipboardOptions {
+  /** What pasted Markdown and HTML may carry in (see `MarkdownPolicy`); data-URL images only with `allowDataUrls`. */
+  policy?: MarkdownPolicy;
+}
+/**
+ * Markdown on the clipboard, both ways. Pasting: `text/markdown` is parsed as Markdown; plain text that contains block
+ * syntax (headings, lists, quotes, code fences, tables, `:::` fences, …) becomes blocks, while plain text without it
+ * (including inline syntax like `**x**`) stays literal; HTML is sanitized before ProseMirror parses it with the schema's
+ * rules. Copying and cutting set `text/markdown` (what `editor.markdown` makes of the selection) next to ProseMirror's
+ * `text/html` and `text/plain`. Pasting is the editor's own: not editable, no paste.
+ */
+export declare const MarkdownClipboard: Extension<MarkdownClipboardOptions, any>;
+//#endregion
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/markdown/clipboard.js

@@ -0,0 +1,125 @@
+import { isSafeMediaUrl, isSafeUrl } from "./policy.js";
+import { markdownToContent } from "./document.js";
+import { Extension } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { DOMParser as DOMParser$1, Slice } from "@tiptap/pm/model";
+//#region src/markdown/clipboard.ts
+/** Elements dropped, with everything inside them, from pasted HTML. */
+const DISCARDED = "script, style, iframe, object, embed, svg, math, template, noscript, input, button, link, meta, base";
+/**
+* `html` as ProseMirror will parse it: without scripts, styles, embeds and form controls, event-handler attributes,
+* links with unsafe URLs (the text stays) and media with unsafe URLs (images are dropped; data URLs only with
+* `policy.allowDataUrls`).
+*/
+function sanitizeHtml(html, policy) {
+	const { body } = new DOMParser().parseFromString(html, "text/html");
+	for (const element of body.querySelectorAll(DISCARDED)) element.remove();
+	for (const element of body.querySelectorAll("*")) {
+		for (const { name } of [...element.attributes]) if (/^on/i.test(name)) element.removeAttribute(name);
+		const href = element.getAttribute("href");
+		if (href !== null && !isSafeUrl(href)) element.removeAttribute("href");
+		const src = element.getAttribute("src");
+		if (src === null || isSafeMediaUrl(src, policy)) continue;
+		if (element.tagName === "IMG") element.remove();
+		else element.removeAttribute("src");
+	}
+	return body.innerHTML;
+}
+/** ProseMirror's `someProp` falls through to the default behaviour on a falsy result; its types do not say so. */
+const DEFAULT_PARSING = null;
+/**
+* Markdown as a ProseMirror slice of the editor's schema, or null when it does not fit. A single paragraph is open on
+* both sides, so it merges into the paragraph around the caret like text pasted natively; anything else is inserted as
+* blocks.
+*/
+function markdownSlice(editor, markdown, policy) {
+	try {
+		const doc = editor.schema.nodeFromJSON(markdownToContent(editor, markdown, { policy }).content);
+		doc.check();
+		const blocks = doc.content;
+		return blocks.childCount === 1 && blocks.firstChild.type.name === "paragraph" ? new Slice(blocks, 1, 1) : new Slice(blocks, 0, 0);
+	} catch {
+		return null;
+	}
+}
+/**
+* The parser of pasted HTML. The image node's own rule skips `data:` sources (Tiptap's `allowBase64` is off unless the
+* host turns it on), so a policy that allows data URLs adds a rule for the raster ones `sanitizeHtml` let through.
+*/
+function htmlParser(editor, policy) {
+	const { schema } = editor;
+	if (!policy.allowDataUrls || !schema.nodes.image) return void 0;
+	return new DOMParser$1(schema, [{
+		tag: "img[src^=\"data:\"]",
+		node: "image",
+		getAttrs: (element) => ({
+			src: element.getAttribute("src"),
+			alt: element.getAttribute("alt"),
+			title: element.getAttribute("title")
+		})
+	}, ...DOMParser$1.fromSchema(schema).rules]);
+}
+/**
+* Markdown on the clipboard, both ways. Pasting: `text/markdown` is parsed as Markdown; plain text that contains block
+* syntax (headings, lists, quotes, code fences, tables, `:::` fences, …) becomes blocks, while plain text without it
+* (including inline syntax like `**x**`) stays literal; HTML is sanitized before ProseMirror parses it with the schema's
+* rules. Copying and cutting set `text/markdown` (what `editor.markdown` makes of the selection) next to ProseMirror's
+* `text/html` and `text/plain`. Pasting is the editor's own: not editable, no paste.
+*/
+const MarkdownClipboard = Extension.create({
+	name: "markdownClipboard",
+	addOptions: () => ({ policy: {} }),
+	addProseMirrorPlugins() {
+		const { editor } = this;
+		const policy = this.options.policy ?? {};
+		const clipboardParser = htmlParser(editor, policy);
+		const markdownOf = (view) => {
+			const json = view.state.selection.content().content.toJSON();
+			return editor.markdown.serialize({
+				type: "doc",
+				content: json
+			}).replace(/\n+$/, "");
+		};
+		const copy = (view, event) => {
+			const data = event.clipboardData;
+			const cut = event.type === "cut";
+			if (!data || view.state.selection.empty || cut && !view.editable) return false;
+			const { dom, text } = view.serializeForClipboard(view.state.selection.content());
+			const markdown = markdownOf(view);
+			event.preventDefault();
+			data.clearData();
+			data.setData("text/html", dom.innerHTML);
+			data.setData("text/plain", text);
+			data.setData("text/markdown", markdown);
+			if (cut) view.dispatch(view.state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent", "cut"));
+			return true;
+		};
+		return [new Plugin({
+			key: new PluginKey("markdownClipboard"),
+			props: {
+				handleDOMEvents: {
+					copy,
+					cut: copy
+				},
+				transformPastedHTML: (html) => sanitizeHtml(html, policy),
+				...clipboardParser && { clipboardParser },
+				handlePaste(view, event) {
+					const markdown = event.clipboardData?.getData("text/markdown");
+					const slice = markdown?.trim() ? markdownSlice(editor, markdown, policy) : null;
+					if (!slice) return false;
+					view.dispatch(view.state.tr.replaceSelection(slice).scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste"));
+					return true;
+				},
+				clipboardTextParser(text, $context, plain) {
+					if (plain || $context.parent.type.spec.code) return DEFAULT_PARSING;
+					const slice = markdownSlice(editor, text, policy);
+					return slice?.content.content.some((block) => block.type.name !== "paragraph") ? slice : DEFAULT_PARSING;
+				}
+			}
+		})];
+	}
+});
+//#endregion
+export { MarkdownClipboard };
+
+//# sourceMappingURL=clipboard.js.map

package/dist/markdown/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.js","names":["ProseMirrorParser"],"sources":["../../src/markdown/clipboard.ts"],"sourcesContent":["import { type Editor, Extension } from '@tiptap/core'\nimport { DOMParser as ProseMirrorParser, Slice } from '@tiptap/pm/model'\nimport { Plugin, PluginKey } from '@tiptap/pm/state'\nimport type { EditorView } from '@tiptap/pm/view'\nimport { markdownToContent } from './document'\nimport { isSafeMediaUrl, isSafeUrl, type MarkdownPolicy } from './policy'\n\nexport interface MarkdownClipboardOptions {\n  /** What pasted Markdown and HTML may carry in (see `MarkdownPolicy`); data-URL images only with `allowDataUrls`. */\n  policy?: MarkdownPolicy\n}\n\n/** Elements dropped, with everything inside them, from pasted HTML. */\nconst DISCARDED = 'script, style, iframe, object, embed, svg, math, template, noscript, input, button, link, meta, base'\n\n/**\n * `html` as ProseMirror will parse it: without scripts, styles, embeds and form controls, event-handler attributes,\n * links with unsafe URLs (the text stays) and media with unsafe URLs (images are dropped; data URLs only with\n * `policy.allowDataUrls`).\n */\nfunction sanitizeHtml(html: string, policy: MarkdownPolicy): string {\n  const { body } = new DOMParser().parseFromString(html, 'text/html')\n  for (const element of body.querySelectorAll(DISCARDED)) element.remove()\n  for (const element of body.querySelectorAll('*')) {\n    for (const { name } of [...element.attributes]) if (/^on/i.test(name)) element.removeAttribute(name)\n    const href = element.getAttribute('href')\n    if (href !== null && !isSafeUrl(href)) element.removeAttribute('href')\n    const src = element.getAttribute('src')\n    if (src === null || isSafeMediaUrl(src, policy)) continue\n    if (element.tagName === 'IMG') element.remove()\n    else element.removeAttribute('src')\n  }\n  return body.innerHTML\n}\n\n/** ProseMirror's `someProp` falls through to the default behaviour on a falsy result; its types do not say so. */\nconst DEFAULT_PARSING = null as unknown as Slice\n\n/**\n * Markdown as a ProseMirror slice of the editor's schema, or null when it does not fit. A single paragraph is open on\n * both sides, so it merges into the paragraph around the caret like text pasted natively; anything else is inserted as\n * blocks.\n */\nfunction markdownSlice(editor: Editor, markdown: string, policy: MarkdownPolicy): Slice | null {\n  try {\n    const doc = editor.schema.nodeFromJSON(markdownToContent(editor, markdown, { policy }).content)\n    doc.check()\n    const blocks = doc.content\n    return blocks.childCount === 1 && blocks.firstChild!.type.name === 'paragraph' ? new Slice(blocks, 1, 1) : new Slice(blocks, 0, 0)\n  }\n  catch {\n    return null\n  }\n}\n\n/**\n * The parser of pasted HTML. The image node's own rule skips `data:` sources (Tiptap's `allowBase64` is off unless the\n * host turns it on), so a policy that allows data URLs adds a rule for the raster ones `sanitizeHtml` let through.\n */\nfunction htmlParser(editor: Editor, policy: MarkdownPolicy): ProseMirrorParser | undefined {\n  const { schema } = editor\n  if (!policy.allowDataUrls || !schema.nodes.image) return undefined\n  const rule = {\n    tag: 'img[src^=\"data:\"]',\n    node: 'image',\n    getAttrs: (element: HTMLElement) => ({ src: element.getAttribute('src'), alt: element.getAttribute('alt'), title: element.getAttribute('title') }),\n  }\n  return new ProseMirrorParser(schema, [rule, ...ProseMirrorParser.fromSchema(schema).rules])\n}\n\n/**\n * Markdown on the clipboard, both ways. Pasting: `text/markdown` is parsed as Markdown; plain text that contains block\n * syntax (headings, lists, quotes, code fences, tables, `:::` fences, …) becomes blocks, while plain text without it\n * (including inline syntax like `**x**`) stays literal; HTML is sanitized before ProseMirror parses it with the schema's\n * rules. Copying and cutting set `text/markdown` (what `editor.markdown` makes of the selection) next to ProseMirror's\n * `text/html` and `text/plain`. Pasting is the editor's own: not editable, no paste.\n */\nexport const MarkdownClipboard = Extension.create<MarkdownClipboardOptions>({\n  name: 'markdownClipboard',\n\n  addOptions: () => ({ policy: {} }),\n\n  addProseMirrorPlugins() {\n    const { editor } = this\n    const policy = this.options.policy ?? {}\n    const clipboardParser = htmlParser(editor, policy)\n    const markdownOf = (view: EditorView): string => {\n      const json = view.state.selection.content().content.toJSON() as unknown[]\n      return editor.markdown!.serialize({ type: 'doc', content: json as never }).replace(/\\n+$/, '')\n    }\n    const copy = (view: EditorView, event: Event): boolean => {\n      const data = (event as ClipboardEvent).clipboardData\n      const cut = event.type === 'cut'\n      if (!data || view.state.selection.empty || (cut && !view.editable)) return false\n      const { dom, text } = view.serializeForClipboard(view.state.selection.content())\n      const markdown = markdownOf(view)\n      event.preventDefault()\n      data.clearData()\n      data.setData('text/html', dom.innerHTML)\n      data.setData('text/plain', text)\n      data.setData('text/markdown', markdown)\n      if (cut) view.dispatch(view.state.tr.deleteSelection().scrollIntoView().setMeta('uiEvent', 'cut'))\n      return true\n    }\n\n    return [new Plugin({\n      key: new PluginKey('markdownClipboard'),\n      props: {\n        handleDOMEvents: { copy, cut: copy },\n        transformPastedHTML: html => sanitizeHtml(html, policy),\n        ...(clipboardParser && { clipboardParser }),\n        handlePaste(view, event) {\n          const markdown = event.clipboardData?.getData('text/markdown')\n          const slice = markdown?.trim() ? markdownSlice(editor, markdown, policy) : null\n          if (!slice) return false\n          view.dispatch(view.state.tr.replaceSelection(slice).scrollIntoView().setMeta('paste', true).setMeta('uiEvent', 'paste'))\n          return true\n        },\n        clipboardTextParser(text, $context, plain) {\n          if (plain || $context.parent.type.spec.code) return DEFAULT_PARSING\n          const slice = markdownSlice(editor, text, policy)\n          // Only text the Markdown parser reads as something other than paragraphs has block syntax; the rest pastes as the text it is.\n          return slice?.content.content.some(block => block.type.name !== 'paragraph') ? slice : DEFAULT_PARSING\n        },\n      },\n    })]\n  },\n})\n"],"mappings":"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"}

package/dist/markdown/document.d.ts

@@ -0,0 +1,36 @@
+import { Translate } from "../i18n/index.js";
+import { MarkdownDiagnostic, MarkdownPolicy } from "./policy.js";
+import { Editor, JSONContent } from "@tiptap/core";
+//#region src/markdown/document.d.ts
+/** A Markdown body as document JSON, with what the parse dropped or could not understand. */
+export interface MarkdownContent {
+  content: JSONContent;
+  diagnostics: MarkdownDiagnostic[];
+}
+/**
+ * `body` (Markdown without frontmatter) as the document JSON of `editor`, plus `diagnostics`: the preset's block
+ * pipeline parses it (`parseBlocks`: Markdown tokens, then the features' normalize and segment stages), the blocks
+ * become the children of a `doc`, `policy` is enforced and the preset's `migrateContent` stage runs. An empty body is
+ * the empty document (one empty paragraph). Nothing is applied to the editor.
+ *
+ * The diagnostics' `message` is in the language of `options.t`, by default that of the editor's registered surface, else
+ * the default locale.
+ *
+ * Diagnostics: `raw-html` (dropped unless `policy.allowHtml`), `unsafe-url` (links and media with a scheme other than
+ * http(s), mailto and tel are dropped; base64 `data:image` URLs are kept only with `policy.allowDataUrls`),
+ * `unknown-fence` (a `:::` fence of a kind no feature registered, kept verbatim as an `opaqueFence`), and the fatal
+ * `unclosed-fence` and `invalid-fence-meta` (a fence opener that stayed plain text).
+ */
+export declare function markdownToContent(editor: Editor, body: string, options?: {
+  policy?: MarkdownPolicy;
+  t?: Translate;
+}): MarkdownContent;
+/**
+ * The document of `editor` as Markdown (`editor.getMarkdown()`: the registered Markdown handlers render every node,
+ * tables as pipe tables and task items as `- [ ]`/`- [x]`), without trailing line breaks: Tiptap keeps an empty
+ * paragraph after a last block that is not a paragraph, and it is not content. Callers that write files add their own
+ * final line break.
+ */
+export declare function contentToMarkdown(editor: Editor): string;
+//#endregion
+//# sourceMappingURL=document.d.ts.map

package/dist/markdown/document.js

@@ -0,0 +1,100 @@
+import { splitFences } from "../core/fences.js";
+import { parseBlocks, pipelineOf } from "../core/pipeline.js";
+import { createTranslator } from "../i18n/index.js";
+import { editorEntryOf } from "../core/editor-ui.js";
+import { EMPTY_EDITOR_CONTENT } from "../core/schema/index.js";
+import { enforceUrlPolicy, locate } from "./policy.js";
+//#region src/markdown/document.ts
+/**
+* Runs `parse` with raw HTML tokens (block and inline, tags and comments) dropped instead of handed to the schema's
+* `parseHTML` rules, and reports each in `diagnostics`.
+*/
+function withoutRawHtml(editor, source, diagnostics, t, parse) {
+	const manager = editor.markdown;
+	if (!manager) return parse();
+	const own = Object.hasOwn(manager, "parseHTMLToken");
+	const original = manager.parseHTMLToken;
+	let from = 0;
+	manager.parseHTMLToken = (token) => {
+		const html = (token.raw ?? token.text ?? "").trim();
+		if (html) {
+			const { line, next } = locate(source, html, from);
+			from = next;
+			diagnostics.push({
+				code: "raw-html",
+				severity: "warning",
+				message: t("markdown.diagnostic.rawHtml", { html: JSON.stringify(html.length > 60 ? `${html.slice(0, 57)}…` : html) }),
+				...line && { line }
+			});
+		}
+		return null;
+	};
+	try {
+		return parse();
+	} finally {
+		if (own) manager.parseHTMLToken = original;
+		else delete manager.parseHTMLToken;
+	}
+}
+const opaqueFences = (node) => [...node.type === "opaqueFence" ? [node] : [], ...(node.content ?? []).flatMap(opaqueFences)];
+/**
+* `body` (Markdown without frontmatter) as the document JSON of `editor`, plus `diagnostics`: the preset's block
+* pipeline parses it (`parseBlocks`: Markdown tokens, then the features' normalize and segment stages), the blocks
+* become the children of a `doc`, `policy` is enforced and the preset's `migrateContent` stage runs. An empty body is
+* the empty document (one empty paragraph). Nothing is applied to the editor.
+*
+* The diagnostics' `message` is in the language of `options.t`, by default that of the editor's registered surface, else
+* the default locale.
+*
+* Diagnostics: `raw-html` (dropped unless `policy.allowHtml`), `unsafe-url` (links and media with a scheme other than
+* http(s), mailto and tel are dropped; base64 `data:image` URLs are kept only with `policy.allowDataUrls`),
+* `unknown-fence` (a `:::` fence of a kind no feature registered, kept verbatim as an `opaqueFence`), and the fatal
+* `unclosed-fence` and `invalid-fence-meta` (a fence opener that stayed plain text).
+*/
+function markdownToContent(editor, body, options = {}) {
+	const policy = options.policy ?? {};
+	const t = options.t ?? editorEntryOf(editor)?.ctx.t ?? createTranslator();
+	const diagnostics = [];
+	const { blocks } = policy.allowHtml ? parseBlocks(editor, body) : withoutRawHtml(editor, body, diagnostics, t, () => parseBlocks(editor, body));
+	let content = blocks.length ? {
+		type: "doc",
+		content: blocks
+	} : EMPTY_EDITOR_CONTENT;
+	content = enforceUrlPolicy(content, policy, body, diagnostics, t);
+	if (!content.content?.length) content = EMPTY_EDITOR_CONTENT;
+	for (const problem of splitFences(body).problems) diagnostics.push({
+		code: problem.code,
+		severity: "error",
+		line: problem.line,
+		message: t(problem.code === "unclosed-fence" ? "markdown.diagnostic.unclosedFence" : "markdown.diagnostic.invalidFenceMeta", { kind: problem.kind })
+	});
+	let from = 0;
+	for (const fence of opaqueFences(content)) {
+		const raw = String(fence.attrs?.raw ?? "");
+		const { line, next } = locate(body, raw, from);
+		from = next;
+		diagnostics.push({
+			code: "unknown-fence",
+			severity: "info",
+			message: t("markdown.diagnostic.unknownFence", { kind: String(fence.attrs?.kind) }),
+			...line && { line }
+		});
+	}
+	return {
+		content: pipelineOf(editor).migrateContent(content),
+		diagnostics
+	};
+}
+/**
+* The document of `editor` as Markdown (`editor.getMarkdown()`: the registered Markdown handlers render every node,
+* tables as pipe tables and task items as `- [ ]`/`- [x]`), without trailing line breaks: Tiptap keeps an empty
+* paragraph after a last block that is not a paragraph, and it is not content. Callers that write files add their own
+* final line break.
+*/
+function contentToMarkdown(editor) {
+	return editor.getMarkdown().replace(/\n+$/, "");
+}
+//#endregion
+export { contentToMarkdown, markdownToContent };
+
+//# sourceMappingURL=document.js.map

package/dist/markdown/document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.js","names":[],"sources":["../../src/markdown/document.ts"],"sourcesContent":["import type { Editor, JSONContent } from '@tiptap/core'\nimport { splitFences } from '../core/fences'\nimport { parseBlocks, pipelineOf } from '../core/pipeline'\nimport { EMPTY_EDITOR_CONTENT } from '../core/schema'\nimport { editorEntryOf } from '../core/editor-ui'\nimport { createTranslator, type Translate } from '../i18n'\nimport { enforceUrlPolicy, locate, type MarkdownDiagnostic, type MarkdownPolicy } from './policy'\n\n/** A Markdown body as document JSON, with what the parse dropped or could not understand. */\nexport interface MarkdownContent {\n  content: JSONContent\n  diagnostics: MarkdownDiagnostic[]\n}\n\n/** The part of `@tiptap/markdown`'s manager the HTML policy swaps out for the duration of one parse. */\ninterface HtmlParsing {\n  parseHTMLToken: (token: { raw?: string, text?: string }) => unknown\n}\n\n/**\n * Runs `parse` with raw HTML tokens (block and inline, tags and comments) dropped instead of handed to the schema's\n * `parseHTML` rules, and reports each in `diagnostics`.\n */\nfunction withoutRawHtml<T>(editor: Editor, source: string, diagnostics: MarkdownDiagnostic[], t: Translate, parse: () => T): T {\n  const manager = editor.markdown as unknown as HtmlParsing | undefined\n  if (!manager) return parse()\n  const own = Object.hasOwn(manager, 'parseHTMLToken')\n  const original = manager.parseHTMLToken\n  let from = 0\n  manager.parseHTMLToken = (token) => {\n    const html = (token.raw ?? token.text ?? '').trim()\n    if (html) {\n      const { line, next } = locate(source, html, from)\n      from = next\n      diagnostics.push({ code: 'raw-html', severity: 'warning', message: t('markdown.diagnostic.rawHtml', { html: JSON.stringify(html.length > 60 ? `${html.slice(0, 57)}…` : html) }), ...(line && { line }) })\n    }\n    return null\n  }\n  try {\n    return parse()\n  }\n  finally {\n    if (own) manager.parseHTMLToken = original\n    else delete (manager as Partial<HtmlParsing>).parseHTMLToken\n  }\n}\n\nconst opaqueFences = (node: JSONContent): JSONContent[] => [...(node.type === 'opaqueFence' ? [node] : []), ...(node.content ?? []).flatMap(opaqueFences)]\n\n/**\n * `body` (Markdown without frontmatter) as the document JSON of `editor`, plus `diagnostics`: the preset's block\n * pipeline parses it (`parseBlocks`: Markdown tokens, then the features' normalize and segment stages), the blocks\n * become the children of a `doc`, `policy` is enforced and the preset's `migrateContent` stage runs. An empty body is\n * the empty document (one empty paragraph). Nothing is applied to the editor.\n *\n * The diagnostics' `message` is in the language of `options.t`, by default that of the editor's registered surface, else\n * the default locale.\n *\n * Diagnostics: `raw-html` (dropped unless `policy.allowHtml`), `unsafe-url` (links and media with a scheme other than\n * http(s), mailto and tel are dropped; base64 `data:image` URLs are kept only with `policy.allowDataUrls`),\n * `unknown-fence` (a `:::` fence of a kind no feature registered, kept verbatim as an `opaqueFence`), and the fatal\n * `unclosed-fence` and `invalid-fence-meta` (a fence opener that stayed plain text).\n */\nexport function markdownToContent(editor: Editor, body: string, options: { policy?: MarkdownPolicy, t?: Translate } = {}): MarkdownContent {\n  const policy = options.policy ?? {}\n  const t = options.t ?? editorEntryOf(editor)?.ctx.t ?? createTranslator()\n  const diagnostics: MarkdownDiagnostic[] = []\n\n  const { blocks } = policy.allowHtml ? parseBlocks(editor, body) : withoutRawHtml(editor, body, diagnostics, t, () => parseBlocks(editor, body))\n  let content: JSONContent = blocks.length ? { type: 'doc', content: blocks } : EMPTY_EDITOR_CONTENT\n  content = enforceUrlPolicy(content, policy, body, diagnostics, t)\n  if (!content.content?.length) content = EMPTY_EDITOR_CONTENT\n\n  for (const problem of splitFences(body).problems) {\n    diagnostics.push({\n      code: problem.code,\n      severity: 'error',\n      line: problem.line,\n      message: t(problem.code === 'unclosed-fence' ? 'markdown.diagnostic.unclosedFence' : 'markdown.diagnostic.invalidFenceMeta', { kind: problem.kind }),\n    })\n  }\n  let from = 0\n  for (const fence of opaqueFences(content)) {\n    const raw = String(fence.attrs?.raw ?? '')\n    const { line, next } = locate(body, raw, from)\n    from = next\n    diagnostics.push({ code: 'unknown-fence', severity: 'info', message: t('markdown.diagnostic.unknownFence', { kind: String(fence.attrs?.kind) }), ...(line && { line }) })\n  }\n\n  return { content: pipelineOf(editor).migrateContent(content), diagnostics }\n}\n\n/**\n * The document of `editor` as Markdown (`editor.getMarkdown()`: the registered Markdown handlers render every node,\n * tables as pipe tables and task items as `- [ ]`/`- [x]`), without trailing line breaks: Tiptap keeps an empty\n * paragraph after a last block that is not a paragraph, and it is not content. Callers that write files add their own\n * final line break.\n */\nexport function contentToMarkdown(editor: Editor): string {\n  return editor.getMarkdown().replace(/\\n+$/, '')\n}\n"],"mappings":";;;;;;;;;;;AAuBA,SAAS,eAAkB,QAAgB,QAAgB,aAAmC,GAAc,OAAmB;CAC7H,MAAM,UAAU,OAAO;CACvB,IAAI,CAAC,SAAS,OAAO,MAAM;CAC3B,MAAM,MAAM,OAAO,OAAO,SAAS,gBAAgB;CACnD,MAAM,WAAW,QAAQ;CACzB,IAAI,OAAO;CACX,QAAQ,kBAAkB,UAAU;EAClC,MAAM,QAAQ,MAAM,OAAO,MAAM,QAAQ,GAAA,CAAI,KAAK;EAClD,IAAI,MAAM;GACR,MAAM,EAAE,MAAM,SAAS,OAAO,QAAQ,MAAM,IAAI;GAChD,OAAO;GACP,YAAY,KAAK;IAAE,MAAM;IAAY,UAAU;IAAW,SAAS,EAAE,+BAA+B,EAAE,MAAM,KAAK,UAAU,KAAK,SAAS,KAAK,GAAG,KAAK,MAAM,GAAG,EAAE,EAAE,KAAK,IAAI,EAAE,CAAC;IAAG,GAAI,QAAQ,EAAE,KAAK;GAAG,CAAC;EAC3M;EACA,OAAO;CACT;CACA,IAAI;EACF,OAAO,MAAM;CACf,UACQ;EACN,IAAI,KAAK,QAAQ,iBAAiB;OAC7B,OAAQ,QAAiC;CAChD;AACF;AAEA,MAAM,gBAAgB,SAAqC,CAAC,GAAI,KAAK,SAAS,gBAAgB,CAAC,IAAI,IAAI,CAAC,GAAI,IAAI,KAAK,WAAW,CAAC,EAAA,CAAG,QAAQ,YAAY,CAAC;;;;;;;;;;;;;;;AAgBzJ,SAAgB,kBAAkB,QAAgB,MAAc,UAAsD,CAAC,GAAoB;CACzI,MAAM,SAAS,QAAQ,UAAU,CAAC;CAClC,MAAM,IAAI,QAAQ,KAAK,cAAc,MAAM,CAAC,EAAE,IAAI,KAAK,iBAAiB;CACxE,MAAM,cAAoC,CAAC;CAE3C,MAAM,EAAE,WAAW,OAAO,YAAY,YAAY,QAAQ,IAAI,IAAI,eAAe,QAAQ,MAAM,aAAa,SAAS,YAAY,QAAQ,IAAI,CAAC;CAC9I,IAAI,UAAuB,OAAO,SAAS;EAAE,MAAM;EAAO,SAAS;CAAO,IAAI;CAC9E,UAAU,iBAAiB,SAAS,QAAQ,MAAM,aAAa,CAAC;CAChE,IAAI,CAAC,QAAQ,SAAS,QAAQ,UAAU;CAExC,KAAK,MAAM,WAAW,YAAY,IAAI,CAAC,CAAC,UACtC,YAAY,KAAK;EACf,MAAM,QAAQ;EACd,UAAU;EACV,MAAM,QAAQ;EACd,SAAS,EAAE,QAAQ,SAAS,mBAAmB,sCAAsC,wCAAwC,EAAE,MAAM,QAAQ,KAAK,CAAC;CACrJ,CAAC;CAEH,IAAI,OAAO;CACX,KAAK,MAAM,SAAS,aAAa,OAAO,GAAG;EACzC,MAAM,MAAM,OAAO,MAAM,OAAO,OAAO,EAAE;EACzC,MAAM,EAAE,MAAM,SAAS,OAAO,MAAM,KAAK,IAAI;EAC7C,OAAO;EACP,YAAY,KAAK;GAAE,MAAM;GAAiB,UAAU;GAAQ,SAAS,EAAE,oCAAoC,EAAE,MAAM,OAAO,MAAM,OAAO,IAAI,EAAE,CAAC;GAAG,GAAI,QAAQ,EAAE,KAAK;EAAG,CAAC;CAC1K;CAEA,OAAO;EAAE,SAAS,WAAW,MAAM,CAAC,CAAC,eAAe,OAAO;EAAG;CAAY;AAC5E;;;;;;;AAQA,SAAgB,kBAAkB,QAAwB;CACxD,OAAO,OAAO,YAAY,CAAC,CAAC,QAAQ,QAAQ,EAAE;AAChD"}

package/dist/markdown/frontmatter.d.ts

@@ -0,0 +1,18 @@
+//#region src/markdown/frontmatter.d.ts
+/** A Markdown text split into its YAML frontmatter block and the body after it. */
+export interface SplitMarkdown {
+  /** The frontmatter block verbatim, both `---` fence lines, the line break after the closing one and the blank lines separating it from the body included; null when the text has none. */
+  frontmatter: string | null;
+  /** Everything after the frontmatter block (the whole text without one). */
+  body: string;
+}
+/**
+ * Splits YAML frontmatter off `text`. The block is only recognised at offset 0 (a `---` line further down is a thematic
+ * break or a table border, never frontmatter) and is returned verbatim, so `joinFrontmatter(...splitFrontmatter(text))`
+ * gives `text` back byte for byte. The YAML itself is not parsed.
+ */
+export declare function splitFrontmatter(text: string): SplitMarkdown;
+/** `body` behind `frontmatter` (as `splitFrontmatter` returns it); without frontmatter, `body` itself. */
+export declare function joinFrontmatter(frontmatter: string | null, body: string): string;
+//#endregion
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/markdown/frontmatter.js

@@ -0,0 +1,32 @@
+//#region src/markdown/frontmatter.ts
+/**
+* `---`, any lines, `---`: each fence on a line of its own, the closing one ended by a line break or the end of the text.
+* Blank lines after the closing fence belong to the block: the body serializer never writes leading blank lines, so a
+* separator kept in the body would vanish on the first edit.
+*/
+const FRONTMATTER = /^---[ \t]*\r?\n(?:[\s\S]*?\r?\n)?---[ \t]*(?:\r?\n(?:[ \t]*\r?\n)*|$)/;
+/**
+* Splits YAML frontmatter off `text`. The block is only recognised at offset 0 (a `---` line further down is a thematic
+* break or a table border, never frontmatter) and is returned verbatim, so `joinFrontmatter(...splitFrontmatter(text))`
+* gives `text` back byte for byte. The YAML itself is not parsed.
+*/
+function splitFrontmatter(text) {
+	const match = FRONTMATTER.exec(text);
+	if (!match) return {
+		frontmatter: null,
+		body: text
+	};
+	return {
+		frontmatter: match[0],
+		body: text.slice(match[0].length)
+	};
+}
+/** `body` behind `frontmatter` (as `splitFrontmatter` returns it); without frontmatter, `body` itself. */
+function joinFrontmatter(frontmatter, body) {
+	if (frontmatter === null) return body;
+	return frontmatter.endsWith("\n") || !body ? frontmatter + body : `${frontmatter}\n${body}`;
+}
+//#endregion
+export { joinFrontmatter, splitFrontmatter };
+
+//# sourceMappingURL=frontmatter.js.map