@effected/markdown 0.7.0 → 0.8.1

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,22 +69,47 @@ 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, mdx) => {
+const escapeText = (value, context, atLineStart, mdx, followingText, nonTextFollows) => {
 	let out = "";
 	let lineStart = atLineStart;
 	for (let index = 0; index < value.length; index += 1) {
 		const char = value[index];
 		if (char === "\n") {
 			const adjacent = value[index - 1] === "\n" || value[index + 1] === "\n";
-			const atBoundary = index === 0 || index === value.length - 1;
 			if (context.singleLine) {
 				out += " ";
 				lineStart = false;
-			} else if (adjacent || atBoundary) {
+			} else if (adjacent || lineStart) {
 				out += "&#10;";
 				lineStart = false;
 			} else {
@@ -129,7 +155,17 @@ const escapeText = (value, context, atLineStart, mdx) => {
 			out += "\\{";
 			continue;
 		}
-		if (context.inHeading && char === "#") {
+		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;
 		}
@@ -218,7 +254,13 @@ const serializeInlines = (children, context, state, startsLine, junctionGuard) =
 		};
 		switch (child.type) {
 			case "text": {
-				const escaped = escapeText(child.value, context, atLineStart, state.mdx);
+				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;
@@ -443,8 +485,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}`;
 };

package/package.json

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