@tanstack/markdown 0.0.9 → 0.0.10

package/README.md

@@ -2,10 +2,10 @@
 
 A tiny, fast, deterministic Markdown parser and renderer for blogs and documentation.
 
-- 4.6 KB gzip parser
-- 6.4 KB gzip HTML renderer
-- 6.3 KB gzip React adapter
-- 6.3 KB gzip Octane adapter
+- 4.9 KB gzip parser
+- 6.7 KB gzip HTML renderer
+- 6.7 KB gzip React adapter
+- 6.7 KB gzip Octane adapter
 - zero runtime dependencies
 - serializable AST
 - safe defaults for raw HTML and executable URLs
@@ -15,6 +15,8 @@ A tiny, fast, deterministic Markdown parser and renderer for blogs and documenta
 pnpm add @tanstack/markdown
 ```
 
+If you use an AI agent, run `npx @tanstack/intent@latest install` so it can discover the package's task-specific skills.
+
 ```ts
 import { renderHtml } from '@tanstack/markdown/html'
 
@@ -66,8 +68,17 @@ MARKDOWN_CORPUS_DIRS=../tanstack.com/src/blog:../tanstack.com/docs \
   pnpm run test:corpus
 ```
 
+To audit practical compatibility across local TanStack repositories and a pinned external docs/blog sample:
+
+```bash
+pnpm run corpus:audit:tanstack
+pnpm run corpus:audit:external
+```
+
 Generated reports:
 
 - [Bundle sizes](./reports/sizes.md)
 - [Benchmarks](./reports/benchmarks.md)
 - [CommonMark compatibility accounting](./reports/conformance.md)
+- [TanStack repository corpus](./reports/tanstack-corpus.md)
+- [External docs and blogs corpus](./reports/external-corpus.md)

package/dist/inline.js

@@ -32,7 +32,7 @@ function parseInlineRaw(value, options, budget = { scans: Math.max(value.length
                 index += 2;
                 continue;
             }
-            if (next && /[\\`*_[\]{}()#+\-.!|~>]/.test(next)) {
+            if (next && /[\\`*_[\]{}()#+\-.!|~<>]/.test(next)) {
                 text += next;
                 index += 2;
                 continue;
@@ -95,8 +95,20 @@ function parseInlineRaw(value, options, budget = { scans: Math.max(value.length
                 continue;
             }
         }
+        if (char === '*' && next === '*' && value[index + 2] === '*') {
+            const close = findDelimiter(value, index + 3, '***', budget);
+            if (close !== -1) {
+                pushText();
+                nodes.push({
+                    type: 'emphasis',
+                    children: parseInlineRaw(value.slice(index + 1, close + 2), options, budget),
+                });
+                index = close + 3;
+                continue;
+            }
+        }
         if ((char === '*' && next === '*') || (char === '_' && next === '_')) {
-            const close = findDelimiter(value, index + 2, char + char, budget);
+            const close = char === '_' && !canUseUnderscore(value, index, 2, true) ? -1 : findDelimiter(value, index + 2, char + char, budget);
             if (close !== -1) {
                 pushText();
                 nodes.push({
@@ -144,8 +156,8 @@ function parseInlineRaw(value, options, budget = { scans: Math.max(value.length
             }
         }
         if (char === '*' || char === '_') {
-            const close = findDelimiter(value, index + 1, char, budget);
-            if (close !== -1 && !isIntrawordUnderscore(value, index, close, char)) {
+            const close = char === '_' && !canUseUnderscore(value, index, 1, true) ? -1 : findDelimiter(value, index + 1, char, budget);
+            if (close !== -1) {
                 pushText();
                 nodes.push({
                     type: 'emphasis',
@@ -157,7 +169,7 @@ function parseInlineRaw(value, options, budget = { scans: Math.max(value.length
         }
         if (char === '<' && options.allowHtml) {
             const close = findCharacter(value, index + 1, '>', budget);
-            if (close !== -1) {
+            if (close !== -1 && isInlineHtml(value.slice(index, close + 1))) {
                 pushText();
                 nodes.push({ type: 'inlineHtml', value: value.slice(index, close + 1) });
                 index = close + 1;
@@ -224,7 +236,8 @@ function parseLinkish(value, open, options, budget) {
         const closeReference = findBalanced(value, closeBracket + 1, '[', ']', budget);
         if (closeReference === -1)
             return undefined;
-        const definition = options.references?.[normalizeReferenceLabel(value.slice(closeBracket + 2, closeReference))];
+        const referenceLabel = value.slice(closeBracket + 2, closeReference);
+        const definition = options.references?.[normalizeReferenceLabel(referenceLabel || label)];
         if (!definition)
             return undefined;
         return {
@@ -234,8 +247,26 @@ function parseLinkish(value, open, options, budget) {
             end: closeReference + 1,
         };
     }
+    const definition = options.references?.[normalizeReferenceLabel(label)];
+    if (definition) {
+        return {
+            label,
+            href: definition.href,
+            ...(definition.title ? { title: definition.title } : {}),
+            end: closeBracket + 1,
+        };
+    }
     return undefined;
 }
+function isInlineHtml(value) {
+    if (/^<!--(?:[\s\S]*--|-?)>$/.test(value))
+        return true;
+    if (/^<\?[\s\S]*\?>$/.test(value) || /^<![A-Z][\s\S]*>$/.test(value) || /^<!\[CDATA\[[\s\S]*\]\]>$/.test(value))
+        return true;
+    if (/^<\/[A-Za-z][\w:-]*\s*>$/.test(value))
+        return true;
+    return /^<[A-Za-z][\w:-]*(?:\s+[A-Za-z_:][\w:.-]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*\s*\/?>$/.test(value);
+}
 function parseDestination(value) {
     const match = value.match(/^(\S+)(?:\s+["']([^"']*)["'])?$/);
     if (!match)
@@ -290,13 +321,15 @@ function findDelimiter(value, start, delimiter, budget) {
             continue;
         if (delimiter === '~~' && (value[index - 1] === '~' || value[index + 2] === '~'))
             continue;
+        if (delimiter[0] === '_' && !canUseUnderscore(value, index, delimiter.length, false))
+            continue;
         if (value.startsWith(delimiter, index))
             return index;
     }
     return -1;
 }
 function findSingleTildeDelimiter(value, start, budget) {
-    if (isWhitespace(value[start] ?? ''))
+    if (isWhitespace(value[start] ?? '') || /\d/.test(value[start] ?? ''))
         return -1;
     for (let index = start; index < value.length; index++) {
         if (!takeScan(budget))
@@ -330,10 +363,18 @@ function takeScan(budget) {
     budget.scans--;
     return true;
 }
-function isIntrawordUnderscore(value, open, close, delimiter) {
-    if (delimiter !== '_')
-        return false;
-    return /\w/.test(value[open - 1] ?? '') && /\w/.test(value[close + 1] ?? '');
+function canUseUnderscore(value, index, size, opening) {
+    const before = value[index - 1];
+    const after = value[index + size];
+    const leftFlanking = !isDelimiterWhitespace(after) && (!isPunctuation(after) || isDelimiterWhitespace(before) || isPunctuation(before));
+    const rightFlanking = !isDelimiterWhitespace(before) && (!isPunctuation(before) || isDelimiterWhitespace(after) || isPunctuation(after));
+    return opening ? leftFlanking && (!rightFlanking || isPunctuation(before)) : rightFlanking && (!leftFlanking || isPunctuation(after));
+}
+function isDelimiterWhitespace(value) {
+    return value === undefined || /\s/.test(value);
+}
+function isPunctuation(value) {
+    return value !== undefined && /[^\p{L}\p{N}\s]/u.test(value);
 }
 function isWhitespace(value) {
     return /\s/.test(value);

package/dist/parser.js

@@ -127,11 +127,13 @@ class BlockParser {
         };
     }
     parseHeading() {
-        const match = this.current().match(/^ {0,3}(#{1,6})(?:\s+|$)(.*?)\s*#*\s*$/);
+        const match = this.current().match(/^ {0,3}(#{1,6})(?:[ \t]+(.*)|[ \t]*)$/);
         if (!match)
             return undefined;
         const depth = match[1].length;
-        const children = parseInline(match[2].trim(), this.options);
+        const rawValue = match[2] ?? '';
+        const value = (/^#+[ \t]*$/.test(rawValue) ? '' : rawValue.replace(/[ \t]+#+[ \t]*$/, '')).trim();
+        const children = parseInline(value, this.options);
         const id = this.createHeadingId(children);
         this.index++;
         return id ? { type: 'heading', depth, id, children } : { type: 'heading', depth, children };
@@ -264,6 +266,16 @@ class BlockParser {
         if (!this.options.allowHtml || !/^ {0,3}<([A-Za-z][\w:-]*|!--|\/[A-Za-z])/.test(this.current()))
             return undefined;
         const html = [];
+        if (/^ {0,3}<!--/.test(this.current())) {
+            while (this.index < this.lines.length) {
+                const line = this.current();
+                html.push(line);
+                this.index++;
+                if (line.includes('-->'))
+                    break;
+            }
+            return { type: 'html', value: html.join('\n') };
+        }
         while (this.index < this.lines.length && !isBlank(this.current())) {
             html.push(this.current());
             this.index++;
@@ -439,11 +451,12 @@ function leadingSpaces(line) {
     return line.match(/^ */)?.[0].length ?? 0;
 }
 function isBlockStart(line, next) {
+    const marker = listMarker(line);
     return (/^ {0,3}(`{3,}|~{3,})/.test(line) ||
         /^ {0,3}#{1,6}(?:\s+|$)/.test(line) ||
         /^ {0,3}([-*_])(?:\s*\1){2,}\s*$/.test(line) ||
         /^ {0,3}>\s?/.test(line) ||
-        listMarker(line) !== undefined ||
+        (marker !== undefined && (!marker.ordered || marker.number === 1)) ||
         (!!next && looksLikeTableHeader(line, next)));
 }
 function looksLikeTableHeader(header, delimiter) {

package/package.json

@@ -1,13 +1,23 @@
 {
   "name": "@tanstack/markdown",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
   "description": "A tiny, fast, deterministic Markdown renderer for blogs and documentation.",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/markdown.git"
+  },
+  "homepage": "https://github.com/TanStack/markdown#readme",
+  "bugs": {
+    "url": "https://github.com/TanStack/markdown/issues"
+  },
   "sideEffects": false,
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "skills",
+    "!skills/_artifacts"
   ],
   "types": "./dist/index.d.ts",
   "exports": {
@@ -72,6 +82,7 @@
     }
   },
   "devDependencies": {
+    "@tanstack/intent": "^0.3.6",
     "@types/node": "^24.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
@@ -93,16 +104,24 @@
     "unified": "^11.0.5",
     "vitest": "^3.2.0"
   },
+  "keywords": [
+    "tanstack-intent"
+  ],
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:corpus": "vitest run tests/corpus.test.tsx",
+    "corpus:audit": "tsx scripts/audit-corpus.ts",
+    "corpus:audit:tanstack": "tsx scripts/audit-tanstack-corpus.ts",
+    "corpus:audit:external": "tsx scripts/audit-external-corpus.ts",
     "docs:verify": "node scripts/verify-docs.mjs",
+    "test:skills": "intent validate skills --check",
+    "skills:stale": "intent stale",
     "conformance": "tsx scripts/conformance.ts",
     "bench": "tsx scripts/bench.ts",
     "size": "tsx scripts/measure-size.ts",
     "research": "pnpm run conformance && pnpm run size && pnpm run bench",
-    "verify": "pnpm test && pnpm run typecheck && pnpm run build && pnpm run docs:verify && pnpm run research && pnpm pack --dry-run"
+    "verify": "pnpm test && pnpm run typecheck && pnpm run build && pnpm run docs:verify && pnpm run test:skills && pnpm run research && pnpm pack --dry-run"
   }
 }