@localess/richtext 4.0.0-dev.20260905085556 → 4.0.0-dev.20260906124410

package/dist/markdown-parser/index.mjs

@@ -0,0 +1,440 @@
+import { n as UnsupportedTracker, o as sanitizeUrl, r as emptyDocument, t as RichTextParseError } from "../parse-common-C-dAtFji.mjs";
+//#region src/markdown-parser/inline.ts
+/**
+* Parses Markdown inline content into text nodes with marks.
+*
+* Supported: `**strong**`/`__strong__`, `*em*`/`_em_`, `~~strike~~`,
+* `` `code` ``, `[text](href)`, and `\` escapes. Everything else — images,
+* reference links, autolinks, HTML — is left as literal text, since the model
+* has nowhere to put it.
+*
+* Code spans win over every other marker, matching CommonMark: the contents of
+* `` `**x**` `` are literal.
+*/
+function parseInline(source, marks = []) {
+	const nodes = [];
+	let text = "";
+	let index = 0;
+	const flush = () => {
+		if (text === "") return;
+		nodes.push({
+			type: "text",
+			text,
+			...marks.length ? { marks: [...marks] } : {}
+		});
+		text = "";
+	};
+	const push = (children) => {
+		flush();
+		nodes.push(...children);
+	};
+	while (index < source.length) {
+		const char = source[index];
+		if (char === "\\" && index + 1 < source.length && /[\\`*_~[\]()#+\-.!>]/.test(source[index + 1])) {
+			text += source[index + 1];
+			index += 2;
+			continue;
+		}
+		if (char === "`") {
+			const fence = /^`+/.exec(source.slice(index))[0];
+			const close = source.indexOf(fence, index + fence.length);
+			if (close !== -1) {
+				const code = source.slice(index + fence.length, close);
+				flush();
+				nodes.push({
+					type: "text",
+					text: code,
+					marks: [...marks, { type: "code" }]
+				});
+				index = close + fence.length;
+				continue;
+			}
+		}
+		if (char === "[") {
+			const link = matchLink(source, index);
+			if (link) {
+				push(parseInline(link.label, [...marks, link.mark]));
+				index = link.end;
+				continue;
+			}
+		}
+		const emphasis = matchEmphasis(source, index);
+		if (emphasis) {
+			push(parseInline(emphasis.inner, [...marks, emphasis.mark]));
+			index = emphasis.end;
+			continue;
+		}
+		text += char;
+		index++;
+	}
+	flush();
+	return nodes;
+}
+var DELIMITERS = [
+	{
+		token: "~~",
+		type: "strike"
+	},
+	{
+		token: "**",
+		type: "bold"
+	},
+	{
+		token: "__",
+		type: "bold"
+	},
+	{
+		token: "*",
+		type: "italic"
+	},
+	{
+		token: "_",
+		type: "italic"
+	}
+];
+function matchEmphasis(source, index) {
+	for (const { token, type } of DELIMITERS) {
+		if (!source.startsWith(token, index)) continue;
+		const contentStart = index + token.length;
+		const close = findClosing(source, token, contentStart);
+		if (close === -1) continue;
+		const inner = source.slice(contentStart, close);
+		if (inner === "") continue;
+		return {
+			inner,
+			mark: { type },
+			end: close + token.length
+		};
+	}
+	return null;
+}
+/**
+* Finds the closing delimiter for an emphasis run.
+*
+* When the closing run is longer than the delimiter — `***` closing a `**` —
+* the delimiter is taken from the **end** of the run, leaving the leading
+* characters to close any inner emphasis. That is what makes
+* `**bold *and italic***` nest correctly instead of ending the strong early.
+*/
+function findClosing(source, token, from) {
+	const char = token[0];
+	let index = from;
+	while (index < source.length) {
+		if (source[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (source[index] === char) {
+			let runEnd = index;
+			while (runEnd < source.length && source[runEnd] === char) runEnd++;
+			if (runEnd - index >= token.length) return runEnd - token.length;
+			index = runEnd;
+			continue;
+		}
+		index++;
+	}
+	return -1;
+}
+function matchLink(source, index) {
+	let depth = 0;
+	let labelEnd = -1;
+	for (let i = index; i < source.length; i++) {
+		const char = source[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "[") depth++;
+		else if (char === "]") {
+			depth--;
+			if (depth === 0) {
+				labelEnd = i;
+				break;
+			}
+		}
+	}
+	if (labelEnd === -1 || source[labelEnd + 1] !== "(") return null;
+	let parens = 0;
+	let targetEnd = -1;
+	for (let i = labelEnd + 1; i < source.length; i++) {
+		const char = source[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "(") parens++;
+		else if (char === ")") {
+			parens--;
+			if (parens === 0) {
+				targetEnd = i;
+				break;
+			}
+		}
+	}
+	if (targetEnd === -1) return null;
+	const target = source.slice(labelEnd + 2, targetEnd).trim();
+	let href;
+	if (target.startsWith("<")) {
+		const close = target.indexOf(">");
+		href = close === -1 ? target.slice(1) : target.slice(1, close);
+	} else href = target.split(/\s+/)[0] ?? "";
+	return {
+		label: source.slice(index + 1, labelEnd),
+		mark: {
+			type: "link",
+			attrs: {
+				href: sanitizeUrl(href),
+				target: null,
+				rel: null,
+				class: null
+			}
+		},
+		end: targetEnd + 1
+	};
+}
+//#endregion
+//#region src/markdown-parser/block.ts
+var ATX_HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+var SETEXT_UNDERLINE = /^ {0,3}(=+|-+)\s*$/;
+var FENCE = /^ {0,3}(`{3,}|~{3,})\s*([^\s`]*)/;
+var BULLET_ITEM = /^(\s*)[-*+]\s+(.*)$/;
+var ORDERED_ITEM = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+var THEMATIC_BREAK = /^ {0,3}(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/;
+var BLOCKQUOTE = /^ {0,3}> ?(.*)$/;
+/** Constructs the model cannot represent, reported through the unsupported policy. */
+var UNSUPPORTED_BLOCKS = [{
+	pattern: THEMATIC_BREAK,
+	name: "thematic break"
+}, {
+	pattern: BLOCKQUOTE,
+	name: "blockquote"
+}];
+/**
+* Parses Markdown block structure into model nodes.
+*
+* A documented **subset**, not CommonMark: ATX and setext headings,
+* paragraphs, bullet and ordered lists, fenced and indented code blocks. Tables,
+* images, blockquotes, thematic breaks, footnotes, and reference links have no
+* representation in the model and go through the unsupported policy.
+*/
+function parseBlocks(markdown, tracker) {
+	return parseLines(markdown.replace(/\r\n?/g, "\n").split("\n"), tracker);
+}
+function parseLines(lines, tracker) {
+	const nodes = [];
+	let index = 0;
+	while (index < lines.length) {
+		const line = lines[index];
+		if (line.trim() === "") {
+			index++;
+			continue;
+		}
+		const fence = FENCE.exec(line);
+		if (fence) {
+			const marker = fence[1][0];
+			const language = fence[2] || null;
+			const body = [];
+			index++;
+			while (index < lines.length && !new RegExp(`^ {0,3}${marker}{${fence[1].length},}\\s*$`).test(lines[index])) {
+				body.push(lines[index]);
+				index++;
+			}
+			index++;
+			nodes.push(codeBlock(body.join("\n"), language));
+			continue;
+		}
+		if (/^ {4}/.test(line) && line.trim() !== "") {
+			const body = [];
+			while (index < lines.length && (/^ {4}/.test(lines[index]) || lines[index].trim() === "")) {
+				if (lines[index].trim() === "" && !hasMoreIndented(lines, index)) break;
+				body.push(lines[index].replace(/^ {4}/, ""));
+				index++;
+			}
+			nodes.push(codeBlock(body.join("\n"), null));
+			continue;
+		}
+		const atx = ATX_HEADING.exec(line);
+		if (atx) {
+			const level = atx[1].length;
+			nodes.push({
+				type: "heading",
+				attrs: { level },
+				content: parseInline(atx[2])
+			});
+			index++;
+			continue;
+		}
+		if (BULLET_ITEM.exec(line) ?? ORDERED_ITEM.exec(line)) {
+			const [list, consumed] = parseList(lines, index, tracker);
+			nodes.push(list);
+			index = consumed;
+			continue;
+		}
+		const unsupportedBlock = UNSUPPORTED_BLOCKS.find((entry) => entry.pattern.test(line));
+		if (unsupportedBlock) {
+			if (tracker.record(unsupportedBlock.name) === "skip") {
+				index++;
+				continue;
+			}
+			const inner = BLOCKQUOTE.exec(line)?.[1] ?? "";
+			if (inner.trim() !== "") nodes.push({
+				type: "paragraph",
+				content: parseInline(inner)
+			});
+			index++;
+			continue;
+		}
+		const paragraph = [];
+		while (index < lines.length && lines[index].trim() !== "") {
+			const current = lines[index];
+			if (paragraph.length > 0 && SETEXT_UNDERLINE.test(current)) {
+				const level = current.trim().startsWith("=") ? 1 : 2;
+				nodes.push({
+					type: "heading",
+					attrs: { level },
+					content: parseInline(paragraph.join(" "))
+				});
+				index++;
+				break;
+			}
+			if (paragraph.length > 0 && (ATX_HEADING.test(current) || FENCE.test(current) || BULLET_ITEM.test(current) || ORDERED_ITEM.test(current))) break;
+			paragraph.push(current.trim());
+			index++;
+			if (index <= lines.length && paragraph.length > 0 && index < lines.length && SETEXT_UNDERLINE.test(lines[index])) continue;
+		}
+		if (paragraph.length > 0 && nodes[nodes.length - 1]?.type !== "heading") nodes.push({
+			type: "paragraph",
+			content: parseInline(paragraph.join(" "))
+		});
+		else if (paragraph.length > 0 && !wasConsumedAsHeading(nodes, paragraph)) nodes.push({
+			type: "paragraph",
+			content: parseInline(paragraph.join(" "))
+		});
+	}
+	return nodes;
+}
+/** A blank line inside an indented code block only continues it if more indented content follows. */
+function hasMoreIndented(lines, index) {
+	for (let i = index + 1; i < lines.length; i++) {
+		if (lines[i].trim() === "") continue;
+		return /^ {4}/.test(lines[i]);
+	}
+	return false;
+}
+function wasConsumedAsHeading(nodes, paragraph) {
+	const last = nodes[nodes.length - 1];
+	if (!last || last.type !== "heading") return false;
+	return (last.content ?? []).map((node) => node.type === "text" ? node.text : "").join("") === paragraph.join(" ");
+}
+function codeBlock(text, language) {
+	const node = { type: "codeBlock" };
+	if (language) node.attrs = { language };
+	if (text !== "") node.content = [{
+		type: "text",
+		text
+	}];
+	return node;
+}
+/** Parses one list and its nested lists, returning the node and the next line index. */
+function parseList(lines, start, tracker) {
+	const first = BULLET_ITEM.exec(lines[start]) ?? ORDERED_ITEM.exec(lines[start]);
+	const ordered = ORDERED_ITEM.test(lines[start]);
+	const baseIndent = first[1].length;
+	const items = [];
+	let index = start;
+	let startNumber;
+	while (index < lines.length) {
+		const line = lines[index];
+		if (line.trim() === "") {
+			const next = lines[index + 1];
+			if (next === void 0 || next.trim() !== "" && indentOf(next) < baseIndent + 1 && !isItem(next)) break;
+			index++;
+			continue;
+		}
+		const match = BULLET_ITEM.exec(line) ?? ORDERED_ITEM.exec(line);
+		if (!match || indentOf(line) < baseIndent) break;
+		if (indentOf(line) > baseIndent) break;
+		if (ORDERED_ITEM.test(line) !== ordered) break;
+		if (ordered && startNumber === void 0) startNumber = Number.parseInt(match[2], 10);
+		const childLines = [ordered ? match[3] : match[2]];
+		index++;
+		while (index < lines.length) {
+			const candidate = lines[index];
+			if (candidate.trim() === "") {
+				const next = lines[index + 1];
+				if (next !== void 0 && indentOf(next) > baseIndent) {
+					childLines.push("");
+					index++;
+					continue;
+				}
+				break;
+			}
+			if (indentOf(candidate) > baseIndent) {
+				childLines.push(candidate.slice(baseIndent + 2));
+				index++;
+				continue;
+			}
+			break;
+		}
+		items.push({
+			type: "listItem",
+			content: parseLines(childLines, tracker)
+		});
+	}
+	const node = ordered ? { type: "orderedList" } : { type: "bulletList" };
+	if (ordered && startNumber !== void 0 && startNumber !== 1) node.attrs = { start: startNumber };
+	node.content = items;
+	return [node, index];
+}
+function indentOf(line) {
+	return /^\s*/.exec(line)[0].length;
+}
+function isItem(line) {
+	return BULLET_ITEM.test(line) || ORDERED_ITEM.test(line);
+}
+//#endregion
+//#region src/markdown-parser/index.ts
+/**
+* Parses a Markdown string into a Localess rich text document.
+*
+* A documented **subset**, not CommonMark — the model is closed, so most of the
+* spec maps to nodes that do not exist.
+*
+* | Supported | Not supported |
+* |---|---|
+* | ATX (`# x`) and setext headings | tables |
+* | paragraphs | images |
+* | bullet and ordered lists (incl. nesting and `start`) | blockquotes |
+* | fenced and indented code blocks | thematic breaks |
+* | `**bold**`, `*italic*`, `~~strike~~`, `` `code` `` | footnotes |
+* | `[text](href)` | reference links, autolinks |
+*
+* Unrepresentable constructs go through {@link RichTextParseOptions.unsupported}
+* and are listed in the result. Inline syntax with no model equivalent (images,
+* raw HTML) is kept as literal text rather than dropped.
+*
+* Link hrefs pass through the same allowlist the renderer applies.
+*
+* Never throws — except under `unsupported: 'throw'`.
+*
+* @example
+* ```ts
+* const { doc, unsupported } = parseMarkdownToRichText('# Title\n\nSome **bold** text.');
+* ```
+*/
+function parseMarkdownToRichText(markdown, options = {}) {
+	const tracker = new UnsupportedTracker(options);
+	if (typeof markdown !== "string" || markdown.trim() === "") return {
+		doc: emptyDocument(),
+		unsupported: []
+	};
+	return {
+		doc: {
+			type: "doc",
+			content: parseBlocks(markdown, tracker)
+		},
+		unsupported: tracker.report()
+	};
+}
+//#endregion
+export { RichTextParseError, parseMarkdownToRichText };

package/dist/markdown-parser/inline.d.ts

@@ -0,0 +1,13 @@
+import { LocalessRichTextMark, LocalessRichTextNode } from '../model';
+/**
+ * Parses Markdown inline content into text nodes with marks.
+ *
+ * Supported: `**strong**`/`__strong__`, `*em*`/`_em_`, `~~strike~~`,
+ * `` `code` ``, `[text](href)`, and `\` escapes. Everything else — images,
+ * reference links, autolinks, HTML — is left as literal text, since the model
+ * has nowhere to put it.
+ *
+ * Code spans win over every other marker, matching CommonMark: the contents of
+ * `` `**x**` `` are literal.
+ */
+export declare function parseInline(source: string, marks?: LocalessRichTextMark[]): LocalessRichTextNode[];

package/dist/parse-common-C-dAtFji.mjs

@@ -0,0 +1,100 @@
+//#region src/escape.ts
+var TEXT_ESCAPES = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;"
+};
+var ATTR_ESCAPES = {
+	...TEXT_ESCAPES,
+	"\"": "&quot;"
+};
+/**
+* Escapes text content for safe HTML output. The escape set (`& < >`) matches
+* TipTap's `generateHTML` DOM serialization — parity-tested; do not widen it
+* without updating the parity fixtures.
+*/
+function escapeHtml(text) {
+	return text.replace(/[&<>]/g, (ch) => TEXT_ESCAPES[ch]);
+}
+/** Escapes an attribute value for safe double-quoted HTML output (`& " < >`). */
+function escapeAttr(value) {
+	return value.replace(/[&"<>]/g, (ch) => ATTR_ESCAPES[ch]);
+}
+var SAFE_SCHEME = /^(?:https?:|mailto:|tel:)/i;
+var HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/**
+* Allowlist URL sanitizer for link hrefs: `http:`, `https:`, `mailto:`, `tel:`
+* and scheme-less (relative/protocol-relative/fragment/query) URLs pass;
+* everything else (e.g. `javascript:`, `data:`) becomes `''`.
+*/
+function sanitizeUrl(url) {
+	const trimmed = url.trim();
+	if (trimmed === "") return "";
+	if (SAFE_SCHEME.test(trimmed)) return trimmed;
+	if (!HAS_SCHEME.test(trimmed)) return trimmed;
+	return "";
+}
+//#endregion
+//#region src/parse-common.ts
+/** Thrown by both parsers when `unsupported: 'throw'` meets an unrepresentable element. */
+var RichTextParseError = class extends Error {
+	/** The element that could not be represented. */
+	element;
+	constructor(element) {
+		super(`[@localess/richtext] "${element}" has no representation in the Localess rich text model. Use { unsupported: 'unwrap' } to keep its text, or { unsupported: 'skip' } to drop it.`);
+		this.name = "RichTextParseError";
+		this.element = element;
+	}
+};
+/**
+* Records unsupported elements for the result report, warns once per element
+* type per parse, and applies the configured policy.
+*
+* Mirrors the renderer's forward-compat behaviour, which warns once per unknown
+* type per render and stays silent in production.
+*/
+var UnsupportedTracker = class {
+	policy;
+	counts = /* @__PURE__ */ new Map();
+	warned = /* @__PURE__ */ new Set();
+	constructor(options = {}) {
+		this.policy = options.unsupported ?? "unwrap";
+	}
+	/**
+	* Records one occurrence and returns whether the caller should keep the
+	* element's children.
+	*
+	* @throws {RichTextParseError} When the policy is `throw`.
+	*/
+	record(element) {
+		if (this.policy === "throw") throw new RichTextParseError(element);
+		this.counts.set(element, (this.counts.get(element) ?? 0) + 1);
+		this.warn(element);
+		return this.policy;
+	}
+	/** The report, in first-seen order. */
+	report() {
+		const action = this.policy === "skip" ? "skipped" : "unwrapped";
+		return [...this.counts.entries()].map(([element, count]) => ({
+			element,
+			action,
+			count
+		}));
+	}
+	warn(element) {
+		if (typeof process !== "undefined" && process.env && process.env.NODE_ENV === "production") return;
+		if (this.warned.has(element)) return;
+		this.warned.add(element);
+		const verb = this.policy === "skip" ? "skipped" : "unwrapped";
+		console.warn(`[@localess/richtext] "${element}" has no representation in the Localess rich text model and was ${verb}.`);
+	}
+};
+/** An empty document — what both parsers return for empty, `null`, or `undefined` input. */
+function emptyDocument() {
+	return {
+		type: "doc",
+		content: []
+	};
+}
+//#endregion
+export { escapeHtml as a, escapeAttr as i, UnsupportedTracker as n, sanitizeUrl as o, emptyDocument as r, RichTextParseError as t };

package/dist/parse-common-DEYhfKnK.js

@@ -0,0 +1,135 @@
+//#region src/escape.ts
+var TEXT_ESCAPES = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;"
+};
+var ATTR_ESCAPES = {
+	...TEXT_ESCAPES,
+	"\"": "&quot;"
+};
+/**
+* Escapes text content for safe HTML output. The escape set (`& < >`) matches
+* TipTap's `generateHTML` DOM serialization — parity-tested; do not widen it
+* without updating the parity fixtures.
+*/
+function escapeHtml(text) {
+	return text.replace(/[&<>]/g, (ch) => TEXT_ESCAPES[ch]);
+}
+/** Escapes an attribute value for safe double-quoted HTML output (`& " < >`). */
+function escapeAttr(value) {
+	return value.replace(/[&"<>]/g, (ch) => ATTR_ESCAPES[ch]);
+}
+var SAFE_SCHEME = /^(?:https?:|mailto:|tel:)/i;
+var HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/**
+* Allowlist URL sanitizer for link hrefs: `http:`, `https:`, `mailto:`, `tel:`
+* and scheme-less (relative/protocol-relative/fragment/query) URLs pass;
+* everything else (e.g. `javascript:`, `data:`) becomes `''`.
+*/
+function sanitizeUrl(url) {
+	const trimmed = url.trim();
+	if (trimmed === "") return "";
+	if (SAFE_SCHEME.test(trimmed)) return trimmed;
+	if (!HAS_SCHEME.test(trimmed)) return trimmed;
+	return "";
+}
+//#endregion
+//#region src/parse-common.ts
+/** Thrown by both parsers when `unsupported: 'throw'` meets an unrepresentable element. */
+var RichTextParseError = class extends Error {
+	/** The element that could not be represented. */
+	element;
+	constructor(element) {
+		super(`[@localess/richtext] "${element}" has no representation in the Localess rich text model. Use { unsupported: 'unwrap' } to keep its text, or { unsupported: 'skip' } to drop it.`);
+		this.name = "RichTextParseError";
+		this.element = element;
+	}
+};
+/**
+* Records unsupported elements for the result report, warns once per element
+* type per parse, and applies the configured policy.
+*
+* Mirrors the renderer's forward-compat behaviour, which warns once per unknown
+* type per render and stays silent in production.
+*/
+var UnsupportedTracker = class {
+	policy;
+	counts = /* @__PURE__ */ new Map();
+	warned = /* @__PURE__ */ new Set();
+	constructor(options = {}) {
+		this.policy = options.unsupported ?? "unwrap";
+	}
+	/**
+	* Records one occurrence and returns whether the caller should keep the
+	* element's children.
+	*
+	* @throws {RichTextParseError} When the policy is `throw`.
+	*/
+	record(element) {
+		if (this.policy === "throw") throw new RichTextParseError(element);
+		this.counts.set(element, (this.counts.get(element) ?? 0) + 1);
+		this.warn(element);
+		return this.policy;
+	}
+	/** The report, in first-seen order. */
+	report() {
+		const action = this.policy === "skip" ? "skipped" : "unwrapped";
+		return [...this.counts.entries()].map(([element, count]) => ({
+			element,
+			action,
+			count
+		}));
+	}
+	warn(element) {
+		if (typeof process !== "undefined" && process.env && process.env.NODE_ENV === "production") return;
+		if (this.warned.has(element)) return;
+		this.warned.add(element);
+		const verb = this.policy === "skip" ? "skipped" : "unwrapped";
+		console.warn(`[@localess/richtext] "${element}" has no representation in the Localess rich text model and was ${verb}.`);
+	}
+};
+/** An empty document — what both parsers return for empty, `null`, or `undefined` input. */
+function emptyDocument() {
+	return {
+		type: "doc",
+		content: []
+	};
+}
+//#endregion
+Object.defineProperty(exports, "RichTextParseError", {
+	enumerable: true,
+	get: function() {
+		return RichTextParseError;
+	}
+});
+Object.defineProperty(exports, "UnsupportedTracker", {
+	enumerable: true,
+	get: function() {
+		return UnsupportedTracker;
+	}
+});
+Object.defineProperty(exports, "emptyDocument", {
+	enumerable: true,
+	get: function() {
+		return emptyDocument;
+	}
+});
+Object.defineProperty(exports, "escapeAttr", {
+	enumerable: true,
+	get: function() {
+		return escapeAttr;
+	}
+});
+Object.defineProperty(exports, "escapeHtml", {
+	enumerable: true,
+	get: function() {
+		return escapeHtml;
+	}
+});
+Object.defineProperty(exports, "sanitizeUrl", {
+	enumerable: true,
+	get: function() {
+		return sanitizeUrl;
+	}
+});