@effected/markdown 0.6.3 → 0.8.0

package/internal/phrasing.js

@@ -0,0 +1,57 @@
+import { Point, Position } from "../MarkdownNode.js";
+import { preprocessLines } from "./preprocess.js";
+import { LineIndex } from "./lineIndex.js";
+import { parseInlines } from "./inlineParser.js";
+import { trimWithSegments } from "./rawInline.js";
+
+//#region src/internal/phrasing.ts
+const EMPTY_REFMAP = /* @__PURE__ */ new Map();
+const EMPTY_FOOTNOTE_LABELS = /* @__PURE__ */ new Set();
+/**
+* Parse a text fragment as a single paragraph's inline content.
+*/
+const parsePhrasingText = (text, dialect) => {
+	const lines = preprocessLines(text);
+	const segments = [];
+	let content = "";
+	for (const line of lines) {
+		segments.push({
+			textOffset: content.length,
+			sourceOffset: line.start,
+			length: line.text.length
+		});
+		content += `${line.text}\n`;
+	}
+	const trimmed = trimWithSegments(content, segments, /\s/);
+	if (trimmed.text.length === 0) return [];
+	const first = trimmed.segments[0];
+	const startOffset = first === void 0 ? 0 : first.sourceOffset;
+	const lineIndex = LineIndex.fromLineStarts(text, lines.map((line) => line.start));
+	const sourceLength = text.length;
+	const positionOf = (start, end) => {
+		const clampedStart = Math.min(Math.max(start, 0), sourceLength);
+		const clampedEnd = Math.min(Math.max(end, clampedStart), sourceLength);
+		const startPoint = lineIndex.positionAt(clampedStart);
+		const endPoint = lineIndex.positionAt(clampedEnd);
+		return Position.make({
+			start: Point.make({
+				line: startPoint.line,
+				column: startPoint.column,
+				offset: clampedStart
+			}),
+			end: Point.make({
+				line: endPoint.line,
+				column: endPoint.column,
+				offset: clampedEnd
+			})
+		});
+	};
+	return parseInlines({
+		text: trimmed.text,
+		startOffset,
+		segments: trimmed.segments
+	}, EMPTY_REFMAP, positionOf, dialect, EMPTY_FOOTNOTE_LABELS);
+};
+
+//#endregion
+export { parsePhrasingText };

package/internal/rawInline.js

@@ -6,6 +6,8 @@ const reCmarkSpace = /[ \t\n\r]/;
 /**
 * Trim `text` the way commonmark.js does before inline parsing, carrying the
 * segment table along so the surviving characters keep their source offsets.
+* Exported for the phrasing-level parse entry point (`phrasing.ts`), which
+* prepares content the same way a paragraph does.
 */
 const trimWithSegments = (text, segments, whitespace) => {
 	let start = 0;
@@ -54,4 +56,4 @@ const prepareInline = (block, position, refmap, dialect = "commonmark", footnote
 };
 
 //#endregion
-export { prepareInline };
+export { prepareInline, trimWithSegments };

package/internal/stringify.js

@@ -1,3 +1,4 @@
+import { ENTITY } from "./unescape.js";
 import { GuardExceeded } from "./carriers.js";
 
 //#region src/internal/stringify.ts
@@ -21,15 +22,15 @@ const ALWAYS_ESCAPE = /* @__PURE__ */ new Set([
 	"\\",
 	"`",
 	"*",
-	"_",
 	"[",
 	"]",
 	"<",
-	">",
-	"&",
 	"~",
 	"|"
 ]);
+/** A character reference at the head of the string: the engine's own grammar. */
+const reEntityAhead = new RegExp(`^${ENTITY}`, "i");
+const reAlphanumeric = /[\p{L}\p{N}]/u;
 /** Line-start characters that could open a block construct. */
 const LINE_START_ESCAPE = /* @__PURE__ */ new Set([
 	"#",
@@ -68,11 +69,37 @@ const isSchemeColon = (value, index) => {
 	while (start > 0 && /[a-zA-Z]/.test(value[start - 1])) start -= 1;
 	return SCHEME_WORDS.has(value.slice(start, index).toLowerCase());
 };
+/** Whether `value[index]` is a Unicode letter or number (`undefined` is not). */
+const isAlphanumericAt = (value, index) => {
+	const char = value[index];
+	return char !== void 0 && reAlphanumeric.test(char);
+};
+/**
+* Whether the `#` at `value[index]` heads a run that would read as an ATX
+* closing sequence: preceded by whitespace or the value start, and followed
+* by nothing but whitespace to the end of the contiguous text (this value
+* plus `followingText`). A non-text sibling after that may contribute only
+* blank content, so it keeps the escape (conservative).
+*/
+const isClosingHashRun = (value, index, followingText, nonTextFollows) => {
+	const before = value[index - 1];
+	if (before !== void 0 && before !== " " && before !== "	") return false;
+	const rest = value.slice(index) + followingText;
+	let end = 0;
+	while (rest[end] === "#") end += 1;
+	return nonTextFollows || /^[ \t\n]*$/.test(rest.slice(end));
+};
+/** A run that a later sibling could still complete into a character reference. */
+const reEntityPrefix = /^&[#a-z0-9]*$/i;
 /**
 * Escape one text value into `out`, tracking line starts. Returns whether the
-* emission ended at a line start.
+* emission ended at a line start. `followingText` is the concatenated value
+* of the contiguous text siblings after this one (the parser never splits a
+* text run, but a synthesized tree may), and `nonTextFollows` says whether a
+* non-text inline comes after those; together they decide the value-end
+* cases (`&`, and `#` in a heading) against what will actually be emitted.
 */
-const escapeText = (value, context, atLineStart) => {
+const escapeText = (value, context, atLineStart, mdx, followingText, nonTextFollows) => {
 	let out = "";
 	let lineStart = atLineStart;
 	for (let index = 0; index < value.length; index += 1) {
@@ -125,7 +152,21 @@ const escapeText = (value, context, atLineStart) => {
 			out += `\\${char}`;
 			continue;
 		}
-		if (context.inHeading && char === "#") {
+		if (mdx && char === "{") {
+			out += "\\{";
+			continue;
+		}
+		if (char === "_" && !(isAlphanumericAt(value, index - 1) && isAlphanumericAt(value, index + 1))) {
+			out += "\\_";
+			continue;
+		}
+		if (char === "&") {
+			const ahead = value.slice(index) + followingText;
+			const entityShaped = reEntityAhead.test(ahead) || nonTextFollows && reEntityPrefix.test(ahead);
+			out += entityShaped ? "\\&" : "&";
+			continue;
+		}
+		if (context.inHeading && char === "#" && isClosingHashRun(value, index, followingText, nonTextFollows)) {
 			out += "\\#";
 			continue;
 		}
@@ -214,7 +255,13 @@ const serializeInlines = (children, context, state, startsLine, junctionGuard) =
 		};
 		switch (child.type) {
 			case "text": {
-				const escaped = escapeText(child.value, context, atLineStart);
+				let followingText = "";
+				let next = index + 1;
+				while (next < children.length && children[next]?.type === "text") {
+					followingText += children[next].value;
+					next += 1;
+				}
+				const escaped = escapeText(child.value, context, atLineStart, state.mdx, followingText, next < children.length);
 				out += escaped.text;
 				atLineStart = escaped.atLineStart;
 				break;
@@ -291,12 +338,126 @@ const serializeInlines = (children, context, state, startsLine, junctionGuard) =
 			case "footnoteReference":
 				out += `[^${escapeLabel(child.label ?? child.identifier)}]`;
 				atLineStart = false;
+				break;
+			case "mdxJsxTextElement":
+				out += serializeMdxJsxText(child, context, state);
+				atLineStart = false;
+				break;
+			case "mdxTextExpression":
+				out += mdxExpression(child.value);
+				atLineStart = false;
 		}
 		index += 1;
 		unguard(state);
 	}
 	return out;
 };
+/** The tag string of every MDX node type. */
+const MDX_NODE_TYPES = /* @__PURE__ */ new Set([
+	"mdxJsxFlowElement",
+	"mdxJsxTextElement",
+	"mdxFlowExpression",
+	"mdxTextExpression",
+	"mdxjsEsm"
+]);
+/** Whether the tree carries any MDX node — iterative, deliberately unguarded. */
+const treeContainsMdx = (root) => {
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (MDX_NODE_TYPES.has(node.type)) return true;
+		if (node.children !== void 0) for (const child of node.children) stack.push(child);
+	}
+	return false;
+};
+/**
+* The oracle's `indentLines` line model (mdast-util-to-markdown
+* `lib/util/indent-lines.js`): lines split on every terminator spelling
+* (`\r\n`, `\n`, bare `\r`), terminators preserved verbatim between the
+* mapped lines, and `blank` meaning an empty line — so a blank CRLF line
+* stays bare instead of having a retained `\r` treated as content.
+*/
+const mapMdxLines = (value, map) => {
+	const eol = /\r?\n|\r/g;
+	const result = [];
+	let start = 0;
+	let index = 0;
+	for (let match = eol.exec(value); match !== null; match = eol.exec(value)) {
+		const line = value.slice(start, match.index);
+		result.push(map(line, index, line === ""), match[0]);
+		start = match.index + match[0].length;
+		index += 1;
+	}
+	const last = value.slice(start);
+	result.push(map(last, index, last === ""));
+	return result.join("");
+};
+/**
+* Serialize an MDX expression body between braces. Continuation lines take
+* the oracle's two-space indent; the first line and blank lines take none.
+*/
+const mdxExpression = (value) => `{${mapMdxLines(value, (line, index, blank) => index === 0 || blank ? line : `  ${line}`)}}`;
+/**
+* Serialize one JSX attribute. A `null` or absent value is a boolean
+* attribute; a string value is quoted with `"` (the oracle default), the
+* quote itself escaped as `&#x22;` exactly as `stringify-entities` spells
+* it; an expression value goes between braces.
+*/
+const serializeMdxAttribute = (attribute) => {
+	if (attribute.type === "mdxJsxExpressionAttribute") return `{${attribute.value}}`;
+	const value = attribute.value;
+	if (value === void 0 || value === null) return attribute.name;
+	if (typeof value === "string") return `${attribute.name}="${value.replaceAll("\"", "&#x22;")}"`;
+	return `${attribute.name}={${value.value}}`;
+};
+/** Serialize a text (phrasing) JSX element. */
+const serializeMdxJsxText = (node, context, state) => {
+	const attributes = node.attributes.map(serializeMdxAttribute);
+	const selfClosing = node.name !== null && node.children.length === 0;
+	let out = `<${node.name ?? ""}`;
+	if (attributes.length > 0) out += ` ${attributes.join(" ")}`;
+	if (selfClosing) return `${out} />`;
+	out += ">";
+	out += serializeInlines(node.children, context, state, false);
+	out += `</${node.name ?? ""}>`;
+	return out;
+};
+/** Prefix every line of a rendered child block; blank lines stay bare. */
+const indentBlockLines = (content, indent) => mapMdxLines(content, (line, _index, blank) => blank ? line : `${indent}${line}`);
+/**
+* Serialize a flow (block) JSX element: opening tag (attributes on their own
+* lines when one carries a line ending), children as indented block layout,
+* closing tag — the oracle's `mdxElement` flow branch.
+*/
+const serializeMdxJsxFlow = (node, state) => {
+	const currentIndent = "  ".repeat(state.jsxDepth);
+	const attributes = node.attributes.map(serializeMdxAttribute);
+	const selfClosing = node.name !== null && node.children.length === 0;
+	const attributesOnOneLine = attributes.join(" ");
+	const attributesOnTheirOwnLine = /[\r\n]/.test(attributesOnOneLine);
+	let value = `${currentIndent}<${node.name ?? ""}`;
+	if (attributesOnTheirOwnLine) value += `\n${attributes.map((attribute) => `${currentIndent}  ${attribute}`).join("\n")}\n${currentIndent}`;
+	else if (attributesOnOneLine !== "") value += ` ${attributesOnOneLine}`;
+	if (selfClosing) value += `${attributesOnTheirOwnLine ? "" : " "}/`;
+	value += ">";
+	if (node.children.length > 0) {
+		state.jsxDepth += 1;
+		const childIndent = "  ".repeat(state.jsxDepth);
+		const parts = node.children.map((child) => {
+			if (child.type === "mdxJsxFlowElement") {
+				guard(state, child);
+				const rendered = serializeMdxJsxFlow(child, state);
+				unguard(state);
+				return rendered;
+			}
+			return indentBlockLines(serializeBlocks([child], state), childIndent);
+		});
+		state.jsxDepth -= 1;
+		value += `\n${parts.join("\n\n")}\n`;
+	}
+	if (!selfClosing) value += `${currentIndent}</${node.name ?? ""}>`;
+	return value;
+};
 /** Prefix every line of `content`; blank lines take the trimmed prefix. */
 const prefixLines = (content, prefix, blankPrefix) => content.split("\n").map((line) => line === "" ? blankPrefix : `${prefix}${line}`).join("\n");
 /** First line gets `marker`, continuation lines get spaces of its width. */
@@ -325,8 +486,9 @@ const setextUnderline = (heading, content) => {
 	return (heading.depth === 1 ? "=" : "-").repeat(Math.max(1, lastLine.length));
 };
 const serializeHeading = (heading, state) => {
-	const content = serializeInlines(heading.children, HEADING_CONTEXT, state, false);
-	if (heading.headingStyle === "setext" && heading.depth <= 2 && content !== "") return `${content}\n${setextUnderline(heading, content)}`;
+	const setext = heading.headingStyle === "setext" && heading.depth <= 2;
+	const content = serializeInlines(heading.children, HEADING_CONTEXT, state, setext);
+	if (setext && content !== "") return `${content}\n${setextUnderline(heading, content)}`;
 	const hashes = "#".repeat(heading.depth);
 	return content === "" ? hashes : `${hashes} ${content}`;
 };
@@ -381,7 +543,10 @@ const effectiveListMarker = (list, flipped) => {
 };
 const serializeListItem = (item, marker, state, tight) => {
 	guard(state, item);
+	const savedJsxDepth = state.jsxDepth;
+	state.jsxDepth = 0;
 	const inner = serializeBlocks(item.children, state, tight);
+	state.jsxDepth = savedJsxDepth;
 	unguard(state);
 	const content = `${item.checked === void 0 ? "" : item.checked ? "[x] " : "[ ] "}${inner}`;
 	if (content === "") return marker.trimEnd();
@@ -455,7 +620,10 @@ const serializeBlocks = (children, state, tight = false) => {
 				previousListMarker = void 0;
 				break;
 			case "blockquote": {
+				const savedJsxDepth = state.jsxDepth;
+				state.jsxDepth = 0;
 				const inner = serializeBlocks(child.children, state);
+				state.jsxDepth = savedJsxDepth;
 				parts.push(prefixLines(inner, "> ", ">"));
 				previousListMarker = void 0;
 				break;
@@ -485,6 +653,17 @@ const serializeBlocks = (children, state, tight = false) => {
 				previousListMarker = void 0;
 				break;
 			}
+			case "mdxJsxFlowElement":
+				parts.push(serializeMdxJsxFlow(child, state));
+				previousListMarker = void 0;
+				break;
+			case "mdxFlowExpression":
+				parts.push(mdxExpression(child.value));
+				previousListMarker = void 0;
+				break;
+			case "mdxjsEsm":
+				parts.push(child.value);
+				previousListMarker = void 0;
 		}
 		previous = child;
 		nodes.push(child);
@@ -510,7 +689,12 @@ const serializeBlocks = (children, state, tight = false) => {
 * empty for an empty root and ends with exactly one newline otherwise.
 */
 const stringifyTree = (root) => {
-	const body = serializeBlocks(root.children, { depth: 0 });
+	const state = {
+		depth: 0,
+		jsxDepth: 0,
+		mdx: treeContainsMdx(root)
+	};
+	const body = serializeBlocks(root.children, state);
 	return body === "" ? "" : `${body}\n`;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/markdown",
-	"version": "0.6.3",
+	"version": "0.8.0",
 	"private": false,
 	"description": "CommonMark and GFM markdown parse, edit and transform schemas for Effect",
 	"keywords": [
@@ -39,9 +39,9 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/jsonc": "^0.7.0",
+		"@effected/jsonc": "^0.8.1",
 		"@effected/toml": "^0.5.0",
-		"@effected/yaml": "^0.11.0",
+		"@effected/yaml": "^0.12.0",
 		"effect": "4.0.0-rc.109"
 	},
 	"peerDependenciesMeta": {