@markii/core 0.8.0 → 0.9.0

package/dist/parse.js

@@ -3,6 +3,7 @@ import remarkParse from 'remark-parse';
 import remarkDirective from 'remark-directive';
 import remarkFrontmatter from 'remark-frontmatter';
 import remarkGfm from 'remark-gfm';
+import { visit } from 'unist-util-visit';
 /**
  * Parses Mark text into an mdast AST. CommonMark plus GitHub-Flavored
  * Markdown (`remark-gfm`: tables, task lists, strikethrough, autolinks) plus
@@ -36,5 +37,100 @@ export function parse(text) {
         .use(remarkFrontmatter)
         .use(remarkDirective)
         .use(remarkGfm);
-    return processor.parse(text);
+    const tree = processor.parse(text);
+    demoteInvalidTextDirectives(tree, text);
+    return tree;
+}
+/**
+ * `remark-directive` treats every single colon as a potential text
+ * directive, with no notion of ordinary prose. That misreads a clock time
+ * (`12:34`), a Bible verse (`John 3:16`), a ratio (`a:b`), or a `key:value`
+ * pair as a directive, and every renderer then shows an "unknown component"
+ * fallback box in the middle of an otherwise plain sentence — something a
+ * casual user hits constantly and has no way to escape short of learning
+ * directive syntax.
+ *
+ * This pass narrows recognition to directives that actually look
+ * intentional: a text directive is kept only when its name starts with an
+ * ASCII letter (`kbd`, not `34`) AND the colon sits at a word start — either
+ * the very first character of the document, or immediately preceded by
+ * something other than an ASCII letter/digit. Whitespace and punctuation
+ * (`(`, `*`, `_`, `"`, `>`, a newline) all count as a word start; a letter
+ * or digit does not. This is checked against the raw source text via the
+ * node's own start offset (not sibling nodes), so it works across emphasis
+ * boundaries too — `**:badge[x]**` keeps the directive (`*` precedes the
+ * colon) while `word:kbd[x]` demotes (`d` precedes it).
+ *
+ * A textDirective that fails the rule is replaced with a plain `text` node
+ * holding the exact original source slice, so the sentence reads exactly as
+ * written. Leaf (`::`) and container (`:::`) directives are untouched: they
+ * only ever occur at the start of a line, so they can't collide with prose
+ * colons in the first place.
+ */
+function demoteInvalidTextDirectives(tree, source) {
+    visit(tree, 'textDirective', (node, index, parent) => {
+        if (parent === undefined || index === undefined)
+            return;
+        const directive = node;
+        const position = directive.position;
+        if (position === undefined ||
+            position.start.offset === undefined ||
+            position.end.offset === undefined) {
+            return;
+        }
+        if (isRecognizedTextDirective(directive.name, position.start.offset, source)) {
+            return;
+        }
+        const replacement = {
+            type: 'text',
+            value: source.slice(position.start.offset, position.end.offset),
+            position,
+        };
+        parent.children[index] = replacement;
+    });
+    mergeAdjacentText(tree);
+}
+/** ASCII letter check for the directive-name start (`kbd`, not `34` or `1st`). */
+const STARTS_WITH_LETTER = /^[A-Za-z]/;
+/** ASCII letter-or-digit check for the character immediately before the colon. */
+const IS_WORD_CHARACTER = /[A-Za-z0-9]/;
+function isRecognizedTextDirective(name, colonOffset, source) {
+    if (!STARTS_WITH_LETTER.test(name))
+        return false;
+    if (colonOffset === 0)
+        return true;
+    const charBefore = source[colonOffset - 1];
+    return charBefore === undefined || !IS_WORD_CHARACTER.test(charBefore);
+}
+/**
+ * Merges runs of adjacent `text` sibling nodes back into one, in place,
+ * recursively over the whole tree. Needed after `demoteInvalidTextDirectives`
+ * replaces a textDirective with a text node: the paragraph
+ * `"Meet at 12:34 pm sharp."` must come back as ONE contiguous text node
+ * (matching what a plain-prose paragraph looks like everywhere else in the
+ * corpus), not three fragments split around where a directive used to be.
+ */
+function mergeAdjacentText(node) {
+    if (!hasChildren(node))
+        return;
+    const children = node.children;
+    const merged = [];
+    for (const child of children) {
+        const last = merged[merged.length - 1];
+        if (last !== undefined && last.type === 'text' && child.type === 'text') {
+            last.value += child.value;
+            if (last.position !== undefined && child.position !== undefined) {
+                last.position = { start: last.position.start, end: child.position.end };
+            }
+        }
+        else {
+            merged.push(child);
+        }
+    }
+    node.children = merged;
+    for (const child of merged)
+        mergeAdjacentText(child);
+}
+function hasChildren(node) {
+    return Array.isArray(node.children);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markii/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Framework-agnostic reference parser for Mark (.mk.md): CommonMark + directives to mdast, and mdast to a sanitized hast tree. Zero React dependency.",
   "keywords": [
     "markdown",