@segnavia/markdown-editor 0.43.0 → 0.45.0

package/dist/editor-css.js

@@ -9,10 +9,12 @@ const EDITOR_CSS = `
 :where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] .ProseMirror){min-block-size:100%;outline:0}
 :where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] table){border-collapse:collapse;inline-size:max-content;min-inline-size:100%}
 :where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] th),:where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] td){min-inline-size:1em}
-:where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] [data-type="taskList"]){list-style:none;padding-inline-start:0}
-:where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] [data-type="taskItem"]){display:grid;grid-template-columns:auto minmax(0,1fr);gap:var(--segnavia-markdown-task-gap,.5em)}
+:where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] ul:has(> li[data-checked])){list-style:none;padding-inline-start:0}
+:where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] li[data-checked]){display:grid;grid-template-columns:auto minmax(0,1fr);gap:var(--segnavia-markdown-task-gap,.5em);align-items:baseline}
+:where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] li[data-checked] > div > p){margin:0}
 :where(:host(segnavia-markdown-editor:not([unstyled])) [part~="locked-block"]){display:block;position:relative;min-block-size:1em}
 :where(:host(segnavia-markdown-editor:not([unstyled])) [part~="locked-block"] segnavia-page){display:block}
+:where(:host(segnavia-markdown-editor:not([unstyled])) [part~="rich"] [part~="raw-inline"]){unicode-bidi:isolate;color:var(--segnavia-markdown-raw-inline-color,inherit);background:var(--segnavia-markdown-raw-inline-background,transparent);border:var(--segnavia-markdown-raw-inline-border,none);border-radius:var(--segnavia-markdown-raw-inline-radius,0);padding-inline:var(--segnavia-markdown-raw-inline-padding,.15em)}
 `;
 //#endregion
 export { EDITOR_CSS };

package/dist/markdown-editor-model.js

@@ -9,17 +9,21 @@ function markdownEditorModel() {
 		retained: ""
 	};
 }
+function normalizeMarkdownLineEndings(markdown) {
+	return markdown.replace(/\r\n?/g, "\n");
+}
 function setModelMarkdown(model, markdown) {
-	if (markdown === model.markdown) return model;
+	const normalized = normalizeMarkdownLineEndings(markdown);
+	if (normalized === model.markdown) return model;
 	if (model.titleSource === "separate") return {
 		...model,
-		markdown,
-		editable: markdown
+		markdown: normalized,
+		editable: normalized
 	};
-	const split = splitLeadingHeading(markdown);
+	const split = splitLeadingHeading(normalized);
 	return {
 		...model,
-		markdown,
+		markdown: normalized,
 		title: split.title ?? "",
 		editable: split.editable,
 		retained: split.retained
@@ -63,7 +67,8 @@ function setModelTitle(model, value) {
 		retained
 	};
 }
-function setModelEditable(model, editable) {
+function setModelEditable(model, edited) {
+	const editable = normalizeMarkdownLineEndings(edited);
 	const markdown = model.titleSource === "leading-heading" ? joinLeadingHeading(editable, model.retained) : editable;
 	if (markdown === model.markdown && editable === model.editable) return model;
 	return {
@@ -73,4 +78,4 @@ function setModelEditable(model, editable) {
 	};
 }
 //#endregion
-export { markdownEditorModel, setModelEditable, setModelMarkdown, setModelTitle, setModelTitleSource };
+export { markdownEditorModel, normalizeMarkdownLineEndings, setModelEditable, setModelMarkdown, setModelTitle, setModelTitleSource };

package/dist/markdown-rich-editor.js

@@ -1,5 +1,6 @@
 import { LockedBlock } from "./markdown-rich-locked.js";
 import { richEditorState, richKeyboard } from "./markdown-rich-commands.js";
+import { RawInline } from "./markdown-rich-raw-inline.js";
 import { richExtensions } from "./markdown-rich-extensions.js";
 import { safeMarkdownUrl } from "@segnavia/html";
 import { HEADLESS_ELEMENTS, SegnaviaPage, createPageElement } from "@segnavia/frame";
@@ -37,8 +38,25 @@ function lockedView(options) {
 		};
 	} });
 }
+const rawInlineView = RawInline.extend({ addNodeView() {
+	return ({ node }) => {
+		const dom = document.createElement("span");
+		dom.part.add("raw-inline");
+		dom.dataset.rawInline = "";
+		dom.dataset.rawSource = String(node.attrs.source ?? "");
+		dom.dataset.rawDisplay = String(node.attrs.display ?? "");
+		dom.dir = "auto";
+		dom.contentEditable = "false";
+		dom.title = String(node.attrs.source ?? "");
+		dom.textContent = String(node.attrs.display ?? "");
+		return { dom };
+	};
+} });
 function extensions(options, keyboard) {
-	return [...richExtensions().map((extension) => extension.name === "lockedBlock" ? lockedView(options) : extension), richKeyboard(keyboard)];
+	return [...richExtensions().map((extension) => {
+		if (extension.name === "lockedBlock") return lockedView(options);
+		return extension.name === "rawInline" ? rawInlineView : extension;
+	}), richKeyboard(keyboard)];
 }
 function pastedHtml(html, linkOrigins) {
 	const parsed = new DOMParser().parseFromString(html, "text/html");

package/dist/markdown-rich-extensions.js

@@ -1,11 +1,159 @@
 import { LockedBlock } from "./markdown-rich-locked.js";
+import { rawInline } from "./markdown-rich-raw-inline.js";
 import { Extension, getSchema } from "@tiptap/core";
 import Image from "@tiptap/extension-image";
-import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { BulletList, OrderedList, TaskItem, TaskList } from "@tiptap/extension-list";
 import { TableKit } from "@tiptap/extension-table";
 import { MarkdownManager } from "@tiptap/markdown";
 import StarterKit from "@tiptap/starter-kit";
+import { Marked } from "marked";
 //#region src/markdown-rich-extensions.ts
+const listAttributes = { loose: {
+	default: false,
+	parseHTML: (element) => element.getAttribute("data-loose") === "true",
+	renderHTML: (attrs) => attrs.loose ? { "data-loose": "true" } : {}
+} };
+const listSeparator = (node) => node.attrs?.loose ? "\n\n" : "\n";
+const listItemPattern = /^(\s*)([-+*]|\d+[.)])(\s+)(?:\[[ xX]\]\s+)?/;
+const indentWidth = (value) => value.replace(/\t/g, "    ").length;
+const lineIndent = (line) => indentWidth(/^\s*/.exec(line)?.[0] ?? "");
+const itemContentIndent = (match) => indentWidth(match[1] ?? "") + (match[2]?.length ?? 0) + indentWidth(match[3] ?? "");
+function updateListContext(match, indent, state) {
+	if (match && indent === state.baseIndent) {
+		state.contentIndent = itemContentIndent(match);
+		state.nestedIndent = void 0;
+	} else if (match && indent >= state.contentIndent && state.nestedIndent === void 0) state.nestedIndent = indent;
+}
+function consumeFence(line, indent, state) {
+	const match = /^(\s*)(`{3,}|~{3,})/.exec(line);
+	if (!match || indent < state.contentIndent || state.nestedIndent !== void 0) return false;
+	const marker = match[2]?.[0] ?? "";
+	const length = match[2]?.length ?? 0;
+	if (!state.fence) state.fence = {
+		marker,
+		length,
+		indent
+	};
+	else if (marker === state.fence.marker && length >= state.fence.length && indent <= state.fence.indent) state.fence = void 0;
+	return true;
+}
+function nextNonblank(lines, index) {
+	return lines.slice(index + 1).find((line) => !/^\s*$/.test(line));
+}
+function blankLineIsLoose(lines, index, state) {
+	const nextLine = nextNonblank(lines, index);
+	if (nextLine === void 0) return false;
+	const nextItem = listItemPattern.exec(nextLine);
+	const nextIndent = lineIndent(nextLine);
+	if (nextItem && nextIndent === state.baseIndent) return true;
+	if (state.nestedIndent !== void 0) {
+		if (nextIndent > state.nestedIndent || nextItem && nextIndent === state.nestedIndent) return false;
+		state.nestedIndent = void 0;
+	}
+	return nextIndent >= state.contentIndent;
+}
+function listLineIsLoose(lines, index, state) {
+	const line = lines[index] ?? "";
+	const match = listItemPattern.exec(line);
+	const indent = lineIndent(line);
+	updateListContext(match, indent, state);
+	if (consumeFence(line, indent, state)) return false;
+	return /^\s*$/.test(line) && state.fence === void 0 && blankLineIsLoose(lines, index, state);
+}
+function listIsLoose(raw) {
+	const lines = raw.split("\n");
+	const firstMatch = listItemPattern.exec(lines.find((line) => listItemPattern.test(line)) ?? "");
+	if (!firstMatch) return false;
+	const state = {
+		baseIndent: indentWidth(firstMatch[1] ?? ""),
+		contentIndent: itemContentIndent(firstMatch)
+	};
+	for (let index = 0; index < lines.length; index++) if (listLineIsLoose(lines, index, state)) return true;
+	return false;
+}
+const LooseBulletList = BulletList.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			...listAttributes
+		};
+	},
+	parseMarkdown(token, helpers) {
+		if (token.type !== "list" || token.ordered) return [];
+		return {
+			type: "bulletList",
+			attrs: { loose: listIsLoose(token.raw ?? "") },
+			content: helpers.parseChildren(token.items ?? [])
+		};
+	},
+	renderMarkdown(node, helpers) {
+		return node.content ? helpers.renderChildren(node.content, listSeparator(node)) : "";
+	}
+});
+const LooseOrderedList = OrderedList.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			...listAttributes
+		};
+	},
+	parseMarkdown(token, helpers) {
+		if (token.type !== "list" || !token.ordered) return [];
+		return {
+			type: "orderedList",
+			attrs: {
+				start: token.start || 1,
+				type: token.typeMarker ?? null,
+				loose: listIsLoose(token.raw ?? "")
+			},
+			content: helpers.parseChildren(token.items ?? [])
+		};
+	},
+	renderMarkdown(node, helpers) {
+		return node.content ? helpers.renderChildren(node.content, listSeparator(node)) : "";
+	}
+});
+const LooseTaskList = TaskList.extend({
+	addAttributes() {
+		return {
+			...this.parent?.(),
+			...listAttributes
+		};
+	},
+	parseMarkdown(token, helpers) {
+		return helpers.createNode("taskList", { loose: listIsLoose(token.raw ?? "") }, helpers.parseChildren(token.items ?? []));
+	},
+	renderMarkdown(node, helpers) {
+		return node.content ? helpers.renderChildren(node.content, listSeparator(node)) : "";
+	},
+	markdownTokenizer: {
+		name: "taskList",
+		level: "block",
+		start: (src) => src.search(/^\s*[-+*]\s+\[[ xX]\]\s+/m),
+		tokenize(src, _tokens, lexer) {
+			const token = new Marked().lexer(src)[0];
+			if (token?.type !== "list" || token.ordered || !token.items?.every((item) => item.task)) return void 0;
+			const items = token.items.map((item) => {
+				const lines = item.text.split("\n");
+				const mainContent = lines.shift() ?? "";
+				const nested = lines.join("\n").trim();
+				return {
+					type: "taskItem",
+					raw: item.raw,
+					checked: item.checked ?? false,
+					text: mainContent,
+					tokens: lexer.inlineTokens(mainContent),
+					nestedTokens: nested ? lexer.blockTokens(`${nested}\n`) : []
+				};
+			});
+			return {
+				type: "taskList",
+				raw: token.raw,
+				items
+			};
+		}
+	}
+});
 const directionalBlocks = Extension.create({
 	name: "directionalBlocks",
 	addGlobalAttributes() {
@@ -30,32 +178,46 @@ const directionalBlocks = Extension.create({
 		}];
 	}
 });
-function richExtensions() {
+function richExtensions(definitionLabels = /* @__PURE__ */ new Set()) {
 	return [
 		StarterKit.configure({
 			trailingNode: false,
-			link: { openOnClick: false }
+			link: { openOnClick: false },
+			bulletList: false,
+			orderedList: false
 		}),
+		LooseBulletList,
+		LooseOrderedList,
 		TableKit,
-		TaskList,
+		LooseTaskList,
 		TaskItem.configure({ nested: true }),
 		Image.configure({ inline: true }),
 		directionalBlocks,
-		LockedBlock
+		LockedBlock,
+		rawInline(definitionLabels)
 	];
 }
 let manager;
+const isolatedMarked = () => new Marked();
 function richMarkdownManager() {
 	manager ??= new MarkdownManager({
+		marked: isolatedMarked(),
 		extensions: richExtensions(),
 		markedOptions: { gfm: true }
 	});
 	return manager;
 }
+function scopedRichMarkdownManager(definitionLabels) {
+	return new MarkdownManager({
+		marked: isolatedMarked(),
+		extensions: richExtensions(definitionLabels),
+		markedOptions: { gfm: true }
+	});
+}
 let schema;
 function richSchema() {
 	schema ??= getSchema(richExtensions());
 	return schema;
 }
 //#endregion
-export { richExtensions, richMarkdownManager, richSchema };
+export { listIsLoose, richExtensions, richMarkdownManager, richSchema, scopedRichMarkdownManager };

package/dist/markdown-rich-locked.js

@@ -2,6 +2,26 @@ import { isDiagramFence, isGithubAlertBlock } from "@segnavia/html";
 import { Node } from "@tiptap/core";
 //#region src/markdown-rich-locked.ts
 const LOCKED_BLOCK_NAME = "lockedBlock";
+const FOOTNOTE_OPENING = /^ {0,3}\[\^/m;
+function matchFootnoteDefinition(src) {
+	const opening = FOOTNOTE_OPENING.exec(src);
+	if (opening?.index !== 0) return void 0;
+	const rest = /^[^\]\n]+\]:[^\n]*(?:\n|$)/.exec(src.slice(opening[0].length))?.[0];
+	const first = rest === void 0 ? void 0 : opening[0] + rest;
+	if (!first) return void 0;
+	let end = first.length;
+	while (end < src.length) {
+		const continuation = /^(?: {4,}|\t)[^\n]*(?:\n|$)/.exec(src.slice(end))?.[0];
+		if (continuation) {
+			end += continuation.length;
+			continue;
+		}
+		const blanks = /^(?:[ \t]*\n)+/.exec(src.slice(end))?.[0];
+		if (!blanks || !/^(?: {4,}|\t)\S/.test(src.slice(end + blanks.length))) break;
+		end += blanks.length;
+	}
+	return src.slice(0, end);
+}
 function lockedFenceLabel(lockedFences, language) {
 	return lockedFences[language?.toLowerCase() ?? ""];
 }
@@ -27,7 +47,7 @@ function isHtmlComment(raw) {
 	return /^<!--[\s\S]*-->$/.test(raw.replace(/\n+$/, ""));
 }
 function isLockedToken(token, lockedFences = {}) {
-	if (token.type === "frontmatter" || token.type === "directive") return true;
+	if (token.type === "frontmatter" || token.type === "directive" || token.type === "footnoteDefinition") return true;
 	if (token.type === "code" && (isDiagramFence(token.lang) || Boolean(lockedFenceLabel(lockedFences, token.lang)))) return true;
 	if (token.type === "blockquote" && isGithubAlertBlock(token.raw)) return true;
 	return token.type === "html" && !isHtmlComment(token.raw);
@@ -75,7 +95,8 @@ const LockedBlock = Node.create({
 		name: "lockedFence",
 		level: "block",
 		start(src) {
-			return src.startsWith("---") || src.startsWith(":::") ? 0 : -1;
+			if (src.startsWith("---") || src.startsWith(":::")) return 0;
+			return FOOTNOTE_OPENING.exec(src)?.index ?? -1;
 		},
 		tokenize(src, tokens) {
 			if (tokens.length === 0) {
@@ -85,6 +106,11 @@ const LockedBlock = Node.create({
 					raw: frontmatter
 				};
 			}
+			const footnote = matchFootnoteDefinition(src);
+			if (footnote) return {
+				type: "footnoteDefinition",
+				raw: footnote
+			};
 			const directive = matchDirectiveContainer(src);
 			return directive ? {
 				type: "directive",

package/dist/markdown-rich-raw-inline.js

@@ -0,0 +1,116 @@
+import { Node } from "@tiptap/core";
+//#region src/markdown-rich-raw-inline.ts
+const RAW_INLINE_NAME = "rawInline";
+const ASCII_PUNCTUATION = String.raw`[!-/:-@\[-` + "{-~]";
+const escapePattern = new RegExp(`^\\\\${ASCII_PUNCTUATION}`);
+const entityPattern = /^&(?:[A-Za-z][A-Za-z0-9]+|#[0-9]+|#[xX][0-9A-Fa-f]+);/;
+const footnotePattern = /^\[\^[^\]\n]+\]/;
+const inlineHtmlPattern = /^(?:<!--[\s\S]*?-->|<\/?[A-Za-z](?:[^<>"']|"[^"]*"|'[^']*')*?>)/;
+const bracketContent = String.raw`(?:\\.|[^\[\]\\]|\[(?:\\.|[^\[\]\\])*\])*`;
+const referencePattern = new RegExp(`^(!?)\\[(${bracketContent})\\](?:\\[(${bracketContent})\\])?`);
+function normalizeReferenceLabel(label) {
+	return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function referenceSource(src, labels) {
+	const match = referencePattern.exec(src);
+	if (!match) return void 0;
+	const raw = match[0];
+	const firstLabel = match[2] ?? "";
+	const secondLabel = match[3];
+	if (secondLabel === void 0 && src[raw.length] === "(") return void 0;
+	const label = secondLabel === void 0 || secondLabel === "" ? firstLabel : secondLabel;
+	return labels.has(normalizeReferenceLabel(label)) ? raw : void 0;
+}
+function rawSource(src, labels) {
+	const escaped = escapePattern.exec(src)?.[0];
+	if (escaped) return {
+		source: escaped,
+		display: escaped.slice(1)
+	};
+	const entity = entityPattern.exec(src)?.[0];
+	if (entity) return {
+		source: entity,
+		display: entity
+	};
+	const footnote = footnotePattern.exec(src)?.[0];
+	if (footnote) return {
+		source: footnote,
+		display: footnote
+	};
+	const reference = referenceSource(src, labels);
+	if (reference) return {
+		source: reference,
+		display: reference
+	};
+	const html = inlineHtmlPattern.exec(src)?.[0];
+	return html && (!html.startsWith("<!") ? !/\n[ \t]*\n/.test(html) : true) ? {
+		source: html,
+		display: html
+	} : void 0;
+}
+function rawInline(labels = /* @__PURE__ */ new Set()) {
+	return Node.create({
+		name: RAW_INLINE_NAME,
+		group: "inline",
+		inline: true,
+		atom: true,
+		selectable: true,
+		draggable: false,
+		addAttributes() {
+			return {
+				source: {
+					default: "",
+					parseHTML: (element) => element.getAttribute("data-raw-source") ?? "",
+					renderHTML: (attrs) => ({ "data-raw-source": attrs.source })
+				},
+				display: {
+					default: "",
+					parseHTML: (element) => element.getAttribute("data-raw-display") ?? "",
+					renderHTML: (attrs) => ({ "data-raw-display": attrs.display })
+				}
+			};
+		},
+		parseHTML() {
+			return [{ tag: "span[data-raw-inline]" }];
+		},
+		renderHTML({ HTMLAttributes }) {
+			return ["span", {
+				...HTMLAttributes,
+				"data-raw-inline": "",
+				dir: "auto"
+			}];
+		},
+		parseMarkdown(token) {
+			return {
+				type: RAW_INLINE_NAME,
+				attrs: {
+					source: token.source,
+					display: token.display
+				}
+			};
+		},
+		renderMarkdown(node) {
+			return typeof node.attrs?.source === "string" ? node.attrs.source : "";
+		},
+		markdownTokenizer: {
+			name: RAW_INLINE_NAME,
+			level: "inline",
+			start(src) {
+				for (let index = 0; index < src.length; index++) if (rawSource(src.slice(index), labels)) return index;
+				return -1;
+			},
+			tokenize(src) {
+				const raw = rawSource(src, labels);
+				return raw ? {
+					type: RAW_INLINE_NAME,
+					raw: raw.source,
+					source: raw.source,
+					display: raw.display
+				} : void 0;
+			}
+		}
+	});
+}
+const RawInline = rawInline();
+//#endregion
+export { RAW_INLINE_NAME, RawInline, normalizeReferenceLabel, rawInline };

package/dist/markdown-rich-save.js

@@ -1,5 +1,6 @@
 import { isLockedToken, isSilentToken, lockedFenceLabel, lockedNode } from "./markdown-rich-locked.js";
-import { richMarkdownManager, richSchema } from "./markdown-rich-extensions.js";
+import { normalizeReferenceLabel } from "./markdown-rich-raw-inline.js";
+import { richMarkdownManager, richSchema, scopedRichMarkdownManager } from "./markdown-rich-extensions.js";
 import { Node } from "@tiptap/pm/model";
 //#region src/markdown-rich-save.ts
 let cachedOriginal;
@@ -39,15 +40,22 @@ const dropTrailingEmptyParagraph = (nodes) => {
 	return last && isEmptyParagraph(last) ? nodes.slice(0, -1) : nodes;
 };
 const restoreAmpersands = (markdown) => markdown.replace(/&(?![a-zA-Z][a-zA-Z0-9]*;)/g, "&");
-function parseBlock(token, raw, lockedFences) {
+function parseBlock(manager, token, raw, lockedFences) {
 	if (isSilentToken(token)) return [];
 	if (isLockedToken(token, lockedFences)) return [lockedNode(raw, lockedFenceLabel(lockedFences, token.lang))];
-	const parsed = richMarkdownManager().parse(raw);
+	const parsed = manager.parse(raw);
 	return Node.fromJSON(richSchema(), parsed).toJSON().content ?? [];
 }
 function blocks(markdown, lockedFences = {}) {
 	const out = [];
-	const tokens = richMarkdownManager().instance.lexer(markdown);
+	const initialTokens = richMarkdownManager().instance.lexer(markdown);
+	const labels = /* @__PURE__ */ new Set();
+	for (const token of initialTokens) {
+		const definition = token.type === "def" ? /^ {0,3}\[([^\]]+)\]:/.exec(token.raw)?.[1] : void 0;
+		if (definition !== void 0) labels.add(normalizeReferenceLabel(definition));
+	}
+	const manager = scopedRichMarkdownManager(labels);
+	const tokens = manager.instance.lexer(markdown);
 	let at = 0;
 	let prevEnd = 0;
 	for (const token of tokens) {
@@ -55,7 +63,7 @@ function blocks(markdown, lockedFences = {}) {
 		at += token.raw.length;
 		if (token.type === "space") continue;
 		const raw = token.raw.replace(/\n+$/, "");
-		const nodes = parseBlock(token, raw, lockedFences);
+		const nodes = parseBlock(manager, token, raw, lockedFences);
 		out.push({
 			raw,
 			sep: markdown.slice(prevEnd, start),
@@ -107,10 +115,22 @@ function firstAtOrAfter(indices, minimum) {
 	return indices[low] ?? -1;
 }
 function serializeNodes(nodes) {
+	const json = nodes.map(asJson);
+	let marker = "raw-inline-amp";
+	const source = JSON.stringify(json);
+	while (source.includes(marker)) marker += "-";
+	const protect = (node) => ({
+		...node,
+		attrs: node.type === "rawInline" && typeof node.attrs?.source === "string" ? {
+			...node.attrs,
+			source: node.attrs.source.replaceAll("&", marker)
+		} : node.attrs,
+		content: node.content?.map(protect)
+	});
 	return restoreAmpersands(richMarkdownManager().serialize({
 		type: "doc",
-		content: nodes.map(asJson)
-	}).trim());
+		content: json.map(protect)
+	}).trim()).replaceAll(marker, "&");
 }
 function matchingBlockIndex(entry, keys, keyIndex, blockIndex) {
 	const currentKey = keys[keyIndex];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/markdown-editor",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -36,9 +36,9 @@
     }
   },
   "dependencies": {
-    "@segnavia/format": "0.43.0",
-    "@segnavia/frame": "0.43.0",
-    "@segnavia/html": "0.43.0"
+    "@segnavia/format": "0.45.0",
+    "@segnavia/frame": "0.45.0",
+    "@segnavia/html": "0.45.0"
   },
   "peerDependencies": {
     "@codemirror/commands": "^6.11.1",
@@ -56,7 +56,8 @@
     "@tiptap/markdown": "^3.32.0",
     "@tiptap/pm": "^3.32.0",
     "@tiptap/starter-kit": "^3.32.0",
-    "codemirror-lang-mermaid": "^0.5.0"
+    "codemirror-lang-mermaid": "^0.5.0",
+    "marked": "^17.0.1"
   },
   "devDependencies": {
     "@codemirror/commands": "6.11.1",
@@ -74,6 +75,7 @@
     "@tiptap/markdown": "3.32.0",
     "@tiptap/pm": "3.32.0",
     "@tiptap/starter-kit": "3.32.0",
-    "codemirror-lang-mermaid": "0.5.0"
+    "codemirror-lang-mermaid": "0.5.0",
+    "marked": "17.0.6"
   }
 }