@markmap/parse 1.1.0 → 1.1.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './parse';
 export * from './to-tree';
+export * from './mark';
 export * from './plugins';
 export * from './html-image';

package/dist/index.js

@@ -3,6 +3,9 @@ import remarkGfm from "remark-gfm";
 import remarkParse from "remark-parse";
 import { unified } from "unified";
 import { parse as parse$1 } from "yaml";
+import { splice } from "micromark-util-chunked";
+import { classifyCharacter } from "micromark-util-classify-character";
+import { resolveAll } from "micromark-util-resolve-all";
 import { assignIds } from "@markmap/core";
 // src/html-image.ts
 var TAG = /^<img((?:\s+[a-z][a-z0-9-]*(?:\s*=\s*(?:"[^"<>]*"|'[^'<>]*'|[^\s"'=<>`]+))?)*)\s*\/?>$/i;
@@ -91,95 +94,155 @@ function remarkHtmlImages() {
 	};
 	return (tree) => visit(tree);
 }
-// src/plugins.ts
-function visitParents(node, fn) {
-	if (!("children" in node)) return;
-	for (const child of node.children) visitParents(child, fn);
-	fn(node);
-}
+// src/mark.ts
+var EQUALS = 61;
+var PUNCTUATION = 2;
+/** Whether each `==` sequence can open or close a mark, from its flanking characters. */
+var sides = /* @__PURE__ */ new WeakMap();
 /**
-* Turn `==text==` into `mark` nodes. Like `**`, the opening `==` must be followed by
-* a non-space and the closing one preceded by a non-space. Delimiters can wrap other
-* inline nodes (`==a **b**==`) but not cross block boundaries.
+* micromark syntax for `==text==`, modeled on GFM strikethrough: a sequence of exactly two
+* `=` with the same flanking rules as `**`. Because it runs in the tokenizer, escapes
+* (`\=`), character references (`&#61;`) and code spans are never delimiters.
 */
-function remarkMark() {
-	return (tree) => visitParents(tree, (parent) => {
-		if (parent.children.some((child) => child.type === "text" && child.value.includes("=="))) parent.children = markChildren(parent.children);
-	});
+function markSyntax() {
+	const construct = {
+		name: "mark",
+		tokenize: tokenizeMark,
+		resolveAll: resolveAllMark
+	};
+	return {
+		text: { [EQUALS]: construct },
+		insideSpan: { null: [construct] },
+		attentionMarkers: { null: [EQUALS] }
+	};
 }
-function markChildren(children) {
-	const tokens = [];
-	for (const child of children) {
-		if (child.type !== "text") {
-			tokens.push({
-				delim: false,
-				node: child
-			});
-			continue;
+var resolveAllMark = (events, context) => {
+	for (let index = 0; index < events.length; index += 1) {
+		const closer = events[index][1];
+		if (events[index][0] !== "enter" || closer.type !== "markSequenceTemporary" || !sides.get(closer)?.close) continue;
+		for (let open = index - 1; open >= 0; open -= 1) {
+			const opener = events[open][1];
+			if (events[open][0] !== "exit" || opener.type !== "markSequenceTemporary" || !sides.get(opener)?.open) continue;
+			opener.type = "markSequence";
+			closer.type = "markSequence";
+			const mark = {
+				type: "mark",
+				start: { ...opener.start },
+				end: { ...closer.end }
+			};
+			const text = {
+				type: "markText",
+				start: { ...opener.end },
+				end: { ...closer.start }
+			};
+			const next = [
+				[
+					"enter",
+					mark,
+					context
+				],
+				[
+					"enter",
+					opener,
+					context
+				],
+				[
+					"exit",
+					opener,
+					context
+				],
+				[
+					"enter",
+					text,
+					context
+				]
+			];
+			const insideSpan = context.parser.constructs.insideSpan.null;
+			if (insideSpan) splice(next, next.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));
+			splice(next, next.length, 0, [
+				[
+					"exit",
+					text,
+					context
+				],
+				[
+					"enter",
+					closer,
+					context
+				],
+				[
+					"exit",
+					closer,
+					context
+				],
+				[
+					"exit",
+					mark,
+					context
+				]
+			]);
+			splice(events, open - 1, index - open + 3, next);
+			index = open + next.length - 2;
+			break;
 		}
-		child.value.split(/(==)/).forEach((part) => {
-			if (part === "==") tokens.push({
-				delim: true,
-				canOpen: false,
-				canClose: false
-			});
-			else if (part) tokens.push({
-				delim: false,
-				node: {
-					type: "text",
-					value: part
-				}
-			});
-		});
 	}
-	const edgeChar = (token, end) => {
-		if (!token) return "";
-		if (token.delim) return "=";
-		if (token.node.type === "text") return end ? token.node.value.at(-1) : token.node.value[0];
-		return "x";
-	};
-	tokens.forEach((token, i) => {
-		if (!token.delim) return;
-		const next = edgeChar(tokens[i + 1], false);
-		const prev = edgeChar(tokens[i - 1], true);
-		token.canOpen = !!next && !/\s/.test(next);
-		token.canClose = !!prev && !/\s/.test(prev);
-	});
-	const pairs = /* @__PURE__ */ new Map();
-	let open = -1;
-	tokens.forEach((token, i) => {
-		if (!token.delim) return;
-		if (open >= 0 && token.canClose && i > open + 1) {
-			pairs.set(open, i);
-			open = -1;
-		} else if (open < 0 && token.canOpen) open = i;
-	});
-	const build = (from, to) => {
-		const result = [];
-		const pushText = (value) => {
-			const last = result.at(-1);
-			if (last?.type === "text") last.value += value;
-			else result.push({
-				type: "text",
-				value
-			});
-		};
-		for (let i = from; i < to; i += 1) {
-			const token = tokens[i];
-			const close = pairs.get(i);
-			if (close != null) {
-				result.push({
-					type: "mark",
-					children: build(i + 1, close)
-				});
-				i = close;
-			} else if (token.delim) pushText("==");
-			else if (token.node.type === "text") pushText(token.node.value);
-			else result.push(token.node);
+	for (const [, token] of events) if (token.type === "markSequenceTemporary") token.type = "data";
+	return events;
+};
+var tokenizeMark = function(effects, ok, nok) {
+	const { previous, events } = this;
+	let size = 0;
+	const more = (code) => {
+		if (code === EQUALS) {
+			if (size > 1) return nok(code);
+			effects.consume(code);
+			size += 1;
+			return more;
 		}
-		return result;
+		if (size < 2) return nok(code);
+		const token = effects.exit("markSequenceTemporary");
+		const before = classifyCharacter(previous);
+		const after = classifyCharacter(code);
+		sides.set(token, {
+			open: !after || after === PUNCTUATION && Boolean(before),
+			close: !before || before === PUNCTUATION && Boolean(after)
+		});
+		return ok(code);
+	};
+	return (code) => {
+		if (previous === EQUALS && events.at(-1)?.[1].type !== "characterEscape") return nok(code);
+		effects.enter("markSequenceTemporary");
+		return more(code);
+	};
+};
+function markFromMarkdown() {
+	return {
+		canContainEols: ["mark"],
+		enter: { mark(token) {
+			this.enter({
+				type: "mark",
+				children: []
+			}, token);
+		} },
+		exit: { mark(token) {
+			this.exit(token);
+		} }
 	};
-	return build(0, tokens.length);
+}
+/**
+* Turn `==text==` into `mark` nodes. Like `**`, delimiters can wrap other inline nodes
+* (`==a **b**==`) but not cross block boundaries.
+*/
+var remarkMark = function() {
+	const data = this.data();
+	(data.micromarkExtensions ??= []).push(markSyntax());
+	(data.fromMarkdownExtensions ??= []).push(markFromMarkdown());
+};
+// src/plugins.ts
+function visitParents(node, fn) {
+	if (!("children" in node)) return;
+	for (const child of node.children) visitParents(child, fn);
+	fn(node);
 }
 /** Replace `[text][ref]` and `![alt][ref]` with plain links and images, and drop definitions. */
 function remarkResolveReferences() {
@@ -382,4 +445,4 @@ function readFrontmatter(mdast) {
 		return {};
 	}
 }
-export { parse, parseHtmlImage, remarkHtmlImages, remarkMark, remarkResolveReferences, toTree };
+export { markFromMarkdown, markSyntax, parse, parseHtmlImage, remarkHtmlImages, remarkMark, remarkResolveReferences, toTree };

package/dist/mark.d.ts

@@ -0,0 +1,24 @@
+import type { Extension as FromMarkdownExtension } from 'mdast-util-from-markdown';
+import type { Extension } from 'micromark-util-types';
+import type { Root } from 'mdast';
+import type { Plugin } from 'unified';
+declare module 'micromark-util-types' {
+    interface TokenTypeMap {
+        mark: 'mark';
+        markSequence: 'markSequence';
+        markSequenceTemporary: 'markSequenceTemporary';
+        markText: 'markText';
+    }
+}
+/**
+ * micromark syntax for `==text==`, modeled on GFM strikethrough: a sequence of exactly two
+ * `=` with the same flanking rules as `**`. Because it runs in the tokenizer, escapes
+ * (`\=`), character references (`=`) and code spans are never delimiters.
+ */
+export declare function markSyntax(): Extension;
+export declare function markFromMarkdown(): FromMarkdownExtension;
+/**
+ * Turn `==text==` into `mark` nodes. Like `**`, delimiters can wrap other inline nodes
+ * (`==a **b**==`) but not cross block boundaries.
+ */
+export declare const remarkMark: Plugin<[], Root>;

package/dist/plugins.d.ts

@@ -1,9 +1,3 @@
 import type { Root } from 'mdast';
-/**
- * Turn `==text==` into `mark` nodes. Like `**`, the opening `==` must be followed by
- * a non-space and the closing one preceded by a non-space. Delimiters can wrap other
- * inline nodes (`==a **b**==`) but not cross block boundaries.
- */
-export declare function remarkMark(): (tree: Root) => void;
 /** Replace `[text][ref]` and `![alt][ref]` with plain links and images, and drop definitions. */
 export declare function remarkResolveReferences(): (tree: Root) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markmap/parse",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Parse Markdown into a Markmap tree",
   "homepage": "https://github.com/markmap/markmap#readme",
   "license": "MIT",
@@ -24,7 +24,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@markmap/core": "1.1.0",
+    "@markmap/core": "1.1.1",
+    "micromark-util-chunked": "^2.0.1",
+    "micromark-util-classify-character": "^2.0.1",
+    "micromark-util-resolve-all": "^2.0.1",
     "remark-frontmatter": "^5.0.0",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
@@ -32,7 +35,9 @@
     "yaml": "^2.9.1"
   },
   "devDependencies": {
-    "@types/mdast": "^4.0.4"
+    "@types/mdast": "^4.0.4",
+    "mdast-util-from-markdown": "^2.1.0",
+    "micromark-util-types": "^2.0.3"
   },
   "scripts": {
     "clean": "rm -rf dist tsconfig.tsbuildinfo",