@owomark/processor 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,15 +1,15 @@
 // src/processor/index.ts
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import remarkGfm from "remark-gfm";
-import remarkMath from "remark-math";
-import remarkMdx from "remark-mdx";
+import { unified as unified2 } from "unified";
+import remarkParse2 from "remark-parse";
+import remarkGfm2 from "remark-gfm";
+import remarkMath2 from "remark-math";
+import remarkMdx2 from "remark-mdx";
 import remarkRehype from "remark-rehype";
 import rehypeKatex from "rehype-katex";
 import rehypeSlug from "rehype-slug";
 import rehypePrettyCode from "rehype-pretty-code";
 import rehypeStringify from "rehype-stringify";
-import remarkDirective from "remark-directive";
+import remarkDirective2 from "remark-directive";
 
 // src/processor/rehype-math-display-fix.ts
 function rehypeMathDisplayFix() {
@@ -30,7 +30,8 @@ function walk(node) {
             type: "element",
             tagName: "div",
             properties: { className: ["math-display-block"] },
-            children: codeEl.children
+            children: codeEl.children,
+            position: child.position ?? codeEl.position
           };
         }
       }
@@ -140,43 +141,15 @@ function pushSplitTextNodes(target, textNode) {
 }
 
 // src/processor/remark-side-annotation.ts
-var STRUCTURAL_TYPES = {
-  ":": "plain",
-  "}": "brace",
-  "{": "left-brace",
-  "]": "bracket",
-  "[": "left-bracket",
-  "|": "line",
-  "-": "dash",
-  "->": "arrow",
-  "=>": "fat-arrow",
-  "~>": "wave-arrow"
-};
-var SEMANTIC_TYPES = {
-  "!": "warning",
-  "?": "question"
-};
-var COMPOUND_TYPES = {
-  "}->": "brace-arrow",
-  "}=>": "brace-fat-arrow",
-  "]->": "bracket-arrow",
-  "]=>": "bracket-fat-arrow",
-  "|->": "line-arrow",
-  "|=>": "line-fat-arrow",
-  "}!": "brace-warning",
-  "}?": "brace-question"
-};
-var TYPE_TABLE = {
-  ...STRUCTURAL_TYPES,
-  ...SEMANTIC_TYPES,
-  ...COMPOUND_TYPES
-};
-var TYPE_SYMBOLS_SORTED = Object.keys(TYPE_TABLE).sort(
-  (a, b) => b.length - a.length
-);
-var TYPE_BY_KEYWORD = Object.fromEntries(
-  Object.entries(TYPE_TABLE).map(([symbol, keyword]) => [keyword, symbol])
-);
+import {
+  SIDE_ANNOTATION_SYMBOL_BY_KEYWORD,
+  SIDE_ANNOTATION_TYPE_SYMBOLS_SORTED as TYPE_SYMBOLS_SORTED,
+  SIDE_ANNOTATION_TYPE_TABLE as TYPE_TABLE,
+  SIDE_NOTE_DEFINITION_RE as NOTE_DEF_RE,
+  SIDE_NOTE_REF_RE as NOTE_REF_RE
+} from "@owomark/core/semantic/syntax";
+var TYPE_BY_KEYWORD = SIDE_ANNOTATION_SYMBOL_BY_KEYWORD;
+var TYPE_TABLE_LOOKUP = TYPE_TABLE;
 function makeSideAnnotationNode(opts) {
   const classNames = ["side-annotation", `side-type-${opts.sideType}`];
   if (opts.orphan) classNames.push("side-orphan");
@@ -205,8 +178,6 @@ var INLINE_ANNOTATION_RE = /(?:^|(?<=\s))\(>((?:[^ ()\\]|\\.)+?) ((?:[^)\\]|\\.)
 var CONTINUATION_RE = /(?:^|(?<=\s))\(>\+\)\s*$/m;
 var CONTINUATION_RE_GLOBAL = /(?:^|(?<=\s))\(>\+\)\s*$/gm;
 var ESCAPE_RE = /\(\\>/;
-var NOTE_DEF_RE = /^\[>([\w-]+)\]:\s*(?:\{type=([^}"]+|"[^"]*")\}\s*)?/;
-var NOTE_REF_RE = /^\[>([\w-]+)\]$/;
 function remarkSideAnnotation() {
   return (tree) => {
     const noteDefinitions = collectNoteDefinitions(tree);
@@ -228,7 +199,7 @@ function collectNoteDefinitions(tree) {
     let typeSymbol = ":";
     if (match[2]) {
       const raw = match[2].replace(/^"|"$/g, "");
-      if (TYPE_TABLE[raw]) {
+      if (TYPE_TABLE_LOOKUP[raw]) {
         typeSymbol = raw;
       } else if (TYPE_BY_KEYWORD[raw]) {
         typeSymbol = TYPE_BY_KEYWORD[raw];
@@ -263,7 +234,7 @@ function collectNoteDefinitions(tree) {
       type: "sideNoteDefinition",
       identifier: id,
       sideTypeSymbol: typeSymbol,
-      sideType: TYPE_TABLE[typeSymbol] || "plain",
+      sideType: TYPE_TABLE_LOOKUP[typeSymbol] || "plain",
       children: contentChildren
     });
     toRemove.push(i);
@@ -287,7 +258,7 @@ function processDirectiveContainers(tree, noteDefinitions) {
       const refMatch = NOTE_REF_RE.exec(label.trim());
       if (refMatch) {
         noteRef = refMatch[1];
-        const def = noteDefinitions.get(noteRef);
+        const def = noteDefinitions.get(refMatch[1]);
         if (def) {
           sideType = def.sideType;
           sideTypeSymbol = def.sideTypeSymbol;
@@ -567,7 +538,7 @@ function parseInlineAnnotationText(inner) {
   if (spaceIdx < 0) return null;
   const typeCandidate = inner.slice(0, spaceIdx);
   if (!typeCandidate) return null;
-  const sideType = TYPE_TABLE[typeCandidate];
+  const sideType = TYPE_TABLE_LOOKUP[typeCandidate];
   if (sideType) {
     const content2 = inner.slice(spaceIdx + 1).replace(/\\([)])/g, "$1").trim();
     if (!content2) return null;
@@ -699,6 +670,7 @@ function splitDirectiveLabelParagraph(paragraph) {
 }
 
 // src/processor/rehype-side-annotation.ts
+import { SIDE_ANNOTATION_RENDERER_KEY_BY_TYPE } from "@owomark/core/semantic/syntax";
 var STROKE_WIDTH = "1.5";
 function el(tagName, properties, children = []) {
   return { type: "element", tagName, properties, children };
@@ -952,6 +924,7 @@ function visit(node) {
 function transform(node) {
   const properties = node.properties ?? {};
   const sideType = String(properties["data-side-type"] || "plain");
+  const rendererKey = SIDE_ANNOTATION_RENDERER_KEY_BY_TYPE[sideType] ?? sideType;
   const sideText = properties["data-side-text"] ? String(properties["data-side-text"]) : null;
   const isOrphan = properties["data-side-orphan"] != null;
   const mainContent = el("div", { class: "side-annotation-main" }, node.children);
@@ -959,7 +932,7 @@ function transform(node) {
   if (isOrphan) {
     asideChildren.push(SVG_GENERATORS["line"]());
   } else {
-    const svgGen = SVG_GENERATORS[sideType];
+    const svgGen = SVG_GENERATORS[rendererKey];
     if (svgGen) {
       asideChildren.push(svgGen());
     }
@@ -997,7 +970,7 @@ function sideAnnotationSyntax() {
     }
   };
 }
-function tokenizeSideAnnotation(effects, ok, nok) {
+function tokenizeSideAnnotation(effects, ok2, nok) {
   return start;
   function start(code) {
     if (code !== CODE_OPEN_PAREN) return nok(code);
@@ -1021,7 +994,7 @@ function tokenizeSideAnnotation(effects, ok, nok) {
     if (code === CODE_CLOSE_PAREN) {
       effects.consume(code);
       effects.exit("sideAnnotationMarker");
-      return ok;
+      return ok2;
     }
     effects.consume(code);
     return content;
@@ -1060,6 +1033,37 @@ function remarkMicromarkSideAnnotation() {
   fromMarkdownExtensions.push(sideAnnotationFromMarkdown());
 }
 
+// src/processor/remark-code-block-metadata.ts
+function visit2(node, visitor) {
+  visitor(node);
+  if (!Array.isArray(node.children)) {
+    return;
+  }
+  for (const child of node.children) {
+    visit2(child, visitor);
+  }
+}
+function remarkCodeBlockMetadata() {
+  return (tree) => {
+    visit2(tree, (node) => {
+      if (node.type !== "code") {
+        return;
+      }
+      const hProperties = node.data?.hProperties ?? {};
+      const language = typeof node.lang === "string" && node.lang.trim() ? node.lang.trim() : null;
+      const meta = typeof node.meta === "string" && node.meta.trim() ? node.meta.trim() : null;
+      node.data = {
+        ...node.data,
+        hProperties: {
+          ...hProperties,
+          ...language ? { "data-language": language } : {},
+          ...meta ? { "data-meta": meta } : {}
+        }
+      };
+    });
+  };
+}
+
 // src/processor/remark-markdown-sandbox.ts
 var DEFAULT_OUTER_FENCE_TICKS = 4;
 var SANDBOX_ROOT_CLASS = "owo-markdown-sandbox";
@@ -1295,6 +1299,7 @@ async function transformChildren(node, sourceLines, options, sandboxCount) {
         const sandboxId = createSandboxId(codeNode.position?.start?.line, sandboxCount.value - 1);
         const nestedProcessor = options.createProcessor({
           ...options.processorOptions,
+          canonicalDocument: void 0,
           enableMarkdownSandbox: false,
           enableSideAnnotation: meta.options.sideAnnotation ?? options.processorOptions.enableSideAnnotation,
           enableMath: meta.options.math ?? options.processorOptions.enableMath,
@@ -1343,72 +1348,1107 @@ function markdownSandboxHandler(_state, node) {
   };
 }
 
+// ../../node_modules/unist-util-visit/node_modules/unist-util-is/lib/index.js
+var convert = (
+  /**
+   * @type {(
+   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &
+   *   ((test?: Test) => AssertAnything)
+   * )}
+   */
+  /**
+   * @param {Test} [test]
+   * @returns {AssertAnything}
+   */
+  (function(test) {
+    if (test === void 0 || test === null) {
+      return ok;
+    }
+    if (typeof test === "string") {
+      return typeFactory(test);
+    }
+    if (typeof test === "object") {
+      return Array.isArray(test) ? anyFactory(test) : propsFactory(test);
+    }
+    if (typeof test === "function") {
+      return castFactory(test);
+    }
+    throw new Error("Expected function, string, or object as test");
+  })
+);
+function anyFactory(tests) {
+  const checks = [];
+  let index = -1;
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index]);
+  }
+  return castFactory(any);
+  function any(...parameters) {
+    let index2 = -1;
+    while (++index2 < checks.length) {
+      if (checks[index2].call(this, ...parameters)) return true;
+    }
+    return false;
+  }
+}
+function propsFactory(check) {
+  return castFactory(all);
+  function all(node) {
+    let key;
+    for (key in check) {
+      if (node[key] !== check[key]) return false;
+    }
+    return true;
+  }
+}
+function typeFactory(check) {
+  return castFactory(type);
+  function type(node) {
+    return node && node.type === check;
+  }
+}
+function castFactory(check) {
+  return assertion;
+  function assertion(node, ...parameters) {
+    return Boolean(
+      node && typeof node === "object" && "type" in node && // @ts-expect-error: fine.
+      Boolean(check.call(this, node, ...parameters))
+    );
+  }
+}
+function ok() {
+  return true;
+}
+
+// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.js
+function color(d) {
+  return "\x1B[33m" + d + "\x1B[39m";
+}
+
+// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/index.js
+var CONTINUE = true;
+var EXIT = false;
+var SKIP = "skip";
+var visitParents = (
+  /**
+   * @type {(
+   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &
+   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)
+   * )}
+   */
+  /**
+   * @param {Node} tree
+   * @param {Test} test
+   * @param {Visitor<Node>} visitor
+   * @param {boolean | null | undefined} [reverse]
+   * @returns {void}
+   */
+  (function(tree, test, visitor, reverse) {
+    if (typeof test === "function" && typeof visitor !== "function") {
+      reverse = visitor;
+      visitor = test;
+      test = null;
+    }
+    const is2 = convert(test);
+    const step = reverse ? -1 : 1;
+    factory(tree, void 0, [])();
+    function factory(node, index, parents) {
+      const value = node && typeof node === "object" ? node : {};
+      if (typeof value.type === "string") {
+        const name = (
+          // `hast`
+          typeof value.tagName === "string" ? value.tagName : (
+            // `xast`
+            typeof value.name === "string" ? value.name : void 0
+          )
+        );
+        Object.defineProperty(visit4, "name", {
+          value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
+        });
+      }
+      return visit4;
+      function visit4() {
+        let result = [];
+        let subresult;
+        let offset;
+        let grandparents;
+        if (!test || is2(node, index, parents[parents.length - 1] || null)) {
+          result = toResult(visitor(node, parents));
+          if (result[0] === EXIT) {
+            return result;
+          }
+        }
+        if (node.children && result[0] !== SKIP) {
+          offset = (reverse ? node.children.length : -1) + step;
+          grandparents = parents.concat(node);
+          while (offset > -1 && offset < node.children.length) {
+            subresult = factory(node.children[offset], offset, grandparents)();
+            if (subresult[0] === EXIT) {
+              return subresult;
+            }
+            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
+          }
+        }
+        return result;
+      }
+    }
+  })
+);
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "number") {
+    return [CONTINUE, value];
+  }
+  return [value];
+}
+
+// ../../node_modules/unist-util-visit/lib/index.js
+var visit3 = (
+  /**
+   * @type {(
+   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &
+   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)
+   * )}
+   */
+  /**
+   * @param {Node} tree
+   * @param {Test} test
+   * @param {Visitor} visitor
+   * @param {boolean | null | undefined} [reverse]
+   * @returns {void}
+   */
+  (function(tree, test, visitor, reverse) {
+    if (typeof test === "function" && typeof visitor !== "function") {
+      reverse = visitor;
+      visitor = test;
+      test = null;
+    }
+    visitParents(tree, test, overload, reverse);
+    function overload(node, parents) {
+      const parent = parents[parents.length - 1];
+      return visitor(
+        node,
+        parent ? parent.children.indexOf(node) : null,
+        parent
+      );
+    }
+  })
+);
+
+// src/processor/owo-component-registry.ts
+import {
+  componentRegistry,
+  getComponentDescriptorByDirective
+} from "@owomark/core/semantic/components";
+function toComponentRegistryEntry(descriptor) {
+  return {
+    directiveName: descriptor.directiveName,
+    componentName: descriptor.componentName,
+    kind: descriptor.componentKind,
+    allowedAttrs: descriptor.allowedAttrs,
+    requiredAttrs: descriptor.requiredAttrs,
+    requiredParent: descriptor.requiredParent,
+    allowedChildDirective: descriptor.allowedChildDirectives[0] ?? null,
+    payloadStrategy: descriptor.payloadStrategy
+  };
+}
+var entries = componentRegistry.list().map(toComponentRegistryEntry);
+var COMPONENT_REGISTRY = new Map(
+  entries.map((e) => [e.directiveName, e])
+);
+function isKnownDirective(name) {
+  return COMPONENT_REGISTRY.has(name);
+}
+function getComponentEntry(name) {
+  const entry = COMPONENT_REGISTRY.get(name);
+  if (entry) return entry;
+  const descriptor = getComponentDescriptorByDirective(name);
+  return descriptor ? toComponentRegistryEntry(descriptor) : void 0;
+}
+
+// src/processor/owo-components-diagnostics.ts
+var SOURCE = "owo-components";
+function reportDisabledFlag(file, name, position) {
+  file.message(
+    `Component directive ":::${name}" requires enableComponents to be enabled`,
+    { place: position, source: SOURCE }
+  );
+}
+function reportUnknownComponent(file, name, position) {
+  file.message(
+    `Unknown component directive ":::${name}"`,
+    { place: position, source: SOURCE }
+  );
+}
+function reportInvalidAttr(file, name, attr, position) {
+  file.message(
+    `Attribute "${attr}" is not allowed on ":::${name}"`,
+    { place: position, source: SOURCE }
+  );
+}
+function reportMissingAttr(file, name, attr, position) {
+  file.message(
+    `":::${name}" requires attribute "${attr}"`,
+    { place: position, source: SOURCE }
+  );
+}
+function reportInvalidNesting(file, name, expectedParent, position) {
+  file.message(
+    `":::${name}" must be inside ":::${expectedParent}"`,
+    { place: position, source: SOURCE }
+  );
+}
+function reportInvalidChildren(file, parentName, expectedChild, position) {
+  file.message(
+    `":::${parentName}" children must all be ":::${expectedChild}"`,
+    { place: position, source: SOURCE }
+  );
+}
+function reportMissingPayload(file, name, what, position) {
+  file.message(
+    `":::${name}" requires ${what}`,
+    { place: position, source: SOURCE }
+  );
+}
+function reportConflictingPayload(file, name, what, position) {
+  file.message(
+    `":::${name}" ${what}`,
+    { place: position, source: SOURCE }
+  );
+}
+
+// src/processor/remark-owo-components.ts
+function escapeHtml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function findCodeBlock(children) {
+  for (const child of children) {
+    if (child.type === "code") return child;
+  }
+  return null;
+}
+function countCodeBlocks(children) {
+  return children.filter((c) => c.type === "code").length;
+}
+function hasContainerDirectiveChildren(children, name) {
+  return children.some(
+    (c) => c.type === "containerDirective" && c.name === name
+  );
+}
+function allChildrenAreDirective(children, name) {
+  const meaningful = children.filter(
+    (c) => c.type !== "paragraph" || !isBlankParagraph(c)
+  );
+  return meaningful.length > 0 && meaningful.every(
+    (c) => c.type === "containerDirective" && c.name === name
+  );
+}
+function isBlankParagraph(node) {
+  if (node.type !== "paragraph") return false;
+  const children = node.children;
+  if (!children || children.length === 0) return true;
+  return children.every((c) => c.type === "text" && !c.value?.trim());
+}
+function getDirectiveChildren(children, name) {
+  return children.filter(
+    (c) => c.type === "containerDirective" && c.name === name
+  );
+}
+function extractTextContent(children) {
+  let text = "";
+  for (const child of children) {
+    if (child.type === "text") {
+      text += child.value ?? "";
+    } else if (child.children) {
+      text += extractTextContent(child.children);
+    }
+  }
+  return text;
+}
+function getPosition(node) {
+  return node.position?.start;
+}
+function validateAttrs(file, node, entry) {
+  const attrs = node.attributes ?? {};
+  let valid = true;
+  for (const key of Object.keys(attrs)) {
+    if (!entry.allowedAttrs.includes(key)) {
+      reportInvalidAttr(file, entry.directiveName, key, getPosition(node));
+    }
+  }
+  for (const key of entry.requiredAttrs) {
+    if (!attrs[key]?.trim()) {
+      reportMissingAttr(file, entry.directiveName, key, getPosition(node));
+      valid = false;
+    }
+  }
+  return valid;
+}
+function mdastHtmlNode(html) {
+  return { type: "html", value: html };
+}
+function mdastWrapper(hName, className, children) {
+  const cls = Array.isArray(className) ? className : [className];
+  return {
+    type: "paragraph",
+    data: { hName, hProperties: { className: cls } },
+    children
+  };
+}
+function transformNote(node) {
+  const title = node.attributes?.title;
+  node.data = {
+    hName: "aside",
+    hProperties: { className: ["mdx-note"] }
+  };
+  if (title && node.children) {
+    node.children.unshift(mdastHtmlNode(
+      `<div class="mdx-note-title">${escapeHtml2(title)}</div>`
+    ));
+  }
+  if (node.children) {
+    const wrapper = mdastWrapper(
+      "div",
+      "mdx-note-body",
+      title ? node.children.slice(1) : [...node.children]
+    );
+    node.children = title ? [node.children[0], wrapper] : [wrapper];
+  }
+}
+function transformCallout(node) {
+  const type = node.attributes?.type ?? "info";
+  const ICONS2 = { info: "i", warn: "!", error: "\xD7", success: "\u2713" };
+  const icon = ICONS2[type] ?? ICONS2.info;
+  node.data = {
+    hName: "div",
+    hProperties: {
+      className: ["mdx-callout", `mdx-callout-${type}`],
+      "data-callout-type": type
+    }
+  };
+  if (node.children) {
+    node.children.unshift(mdastHtmlNode(
+      `<span class="mdx-callout-icon">${escapeHtml2(icon)}</span>`
+    ));
+    const contentChildren = node.children.slice(1);
+    const wrapper = mdastWrapper("div", "mdx-callout-content", contentChildren);
+    node.children = [node.children[0], wrapper];
+  }
+}
+function transformDetails(node) {
+  const summary = node.attributes?.summary ?? "";
+  const open = node.attributes?.open;
+  node.data = {
+    hName: "details",
+    hProperties: {
+      className: ["mdx-details"],
+      ...open === "true" ? { open: true } : {}
+    }
+  };
+  if (node.children) {
+    node.children.unshift(mdastHtmlNode(
+      `<summary class="mdx-details-summary">${escapeHtml2(summary)}</summary>`
+    ));
+    const bodyChildren = node.children.slice(1);
+    const wrapper = mdastWrapper("div", "mdx-details-body", bodyChildren);
+    node.children = [node.children[0], wrapper];
+  }
+}
+function transformKbd(node) {
+  node.data = {
+    hName: "kbd",
+    hProperties: { className: ["mdx-kbd"] }
+  };
+}
+function makeRenderedNode(node, html) {
+  node.type = "owoComponentRendered";
+  node.children = [];
+  node.data = { html };
+}
+function renderCodeDemoSingle(attrs, code, fenceLang) {
+  const title = attrs.title ?? "";
+  const language = attrs.language ?? (fenceLang || "text");
+  const titleHtml = title ? `<figcaption>${escapeHtml2(title)}</figcaption>` : "";
+  return `<figure class="mdx-code-demo" data-code-demo>${titleHtml}<pre data-language="${escapeHtml2(language)}"><code>${escapeHtml2(code)}</code></pre></figure>`;
+}
+function renderCodeDemoMultiTab(attrs, tabs) {
+  const title = attrs.title ?? "";
+  const titleHtml = title ? `<figcaption>${escapeHtml2(title)}</figcaption>` : "";
+  const groupId = `mdx-code-tabs-${Math.random().toString(36).slice(2, 8)}`;
+  const tabListItems = tabs.map(
+    (tab, i) => `<label class="mdx-tabs-trigger"><input type="radio" name="${groupId}" class="mdx-tabs-radio"${i === 0 ? " checked" : ""}><span>${escapeHtml2(tab.label)}</span></label>`
+  ).join("");
+  const panels = tabs.map(
+    (tab) => `<div class="mdx-tabs-panel"><pre data-language="${escapeHtml2(tab.language)}"><code>${escapeHtml2(tab.code)}</code></pre></div>`
+  ).join("");
+  return `<figure class="mdx-code-demo" data-code-demo>${titleHtml}<div class="mdx-tabs"><div class="mdx-tabs-list" role="tablist">${tabListItems}</div>${panels}</div></figure>`;
+}
+function renderFileTree(text) {
+  const entries2 = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.replace(/^[\s\-*]*/, "");
+    if (!trimmed) continue;
+    const leadingSpaces = line.match(/^(\s*)/)?.[1].length ?? 0;
+    const depth = Math.floor(leadingSpaces / 2);
+    const isDir = trimmed.endsWith("/");
+    const name = isDir ? trimmed.slice(0, -1) : trimmed;
+    entries2.push({ name, isDir, depth });
+  }
+  const items = entries2.map((entry) => {
+    const icon = entry.isDir ? "\u{1F4C1}" : "\u{1F4C4}";
+    const cls = entry.isDir ? "mdx-file-tree-dir" : "mdx-file-tree-file";
+    return `<div class="mdx-file-tree-entry ${cls}" style="padding-left: ${entry.depth * 1.25 + 0.5}rem"><span class="mdx-file-tree-icon">${icon}</span><span class="mdx-file-tree-name">${escapeHtml2(entry.name)}</span></div>`;
+  }).join("");
+  return `<div class="mdx-file-tree">${items}</div>`;
+}
+function renderLinkCard(attrs, summaryText) {
+  const href = attrs.href ?? "";
+  const title = attrs.title ?? "";
+  const description = attrs.description ?? summaryText;
+  const domain = attrs.domain;
+  const titleHtml = `<div class="mdx-link-card-title">${escapeHtml2(title)}</div>`;
+  const descHtml = description ? `<div class="mdx-link-card-desc">${escapeHtml2(description)}</div>` : "";
+  const domainHtml = domain ? `<div class="mdx-link-card-domain">${escapeHtml2(domain)}</div>` : "";
+  return `<a class="mdx-link-card" href="${escapeHtml2(href)}">${titleHtml}${descHtml}${domainHtml}</a>`;
+}
+function transformSteps(node) {
+  const stepNodes = getDirectiveChildren(node.children ?? [], "step");
+  node.data = {
+    hName: "div",
+    hProperties: { className: ["mdx-steps"] }
+  };
+  const items = [];
+  for (let i = 0; i < stepNodes.length; i++) {
+    const step = stepNodes[i];
+    const title = step.attributes?.title;
+    const titleNode = title ? mdastHtmlNode(`<h4 class="mdx-step-title">${escapeHtml2(title)}</h4>`) : null;
+    const bodyChildren = step.children ?? [];
+    const bodyNode = bodyChildren.length > 0 ? mdastWrapper("div", "mdx-step-body", bodyChildren) : null;
+    const line = i < stepNodes.length - 1 ? mdastHtmlNode('<div class="mdx-steps-line"></div>') : null;
+    const indicatorChildren = [
+      mdastHtmlNode(`<span class="mdx-steps-number">${i + 1}</span>`)
+    ];
+    if (line) indicatorChildren.push(line);
+    const stepContentChildren = [];
+    if (titleNode) stepContentChildren.push(titleNode);
+    if (bodyNode) stepContentChildren.push(bodyNode);
+    const stepInner = mdastWrapper("div", "mdx-step", stepContentChildren);
+    const indicatorWrapper = mdastWrapper("div", "mdx-steps-indicator", indicatorChildren);
+    const contentWrapper = mdastWrapper("div", "mdx-steps-content", [stepInner]);
+    items.push(mdastWrapper("div", "mdx-steps-item", [indicatorWrapper, contentWrapper]));
+  }
+  node.children = items;
+}
+function transformTabs(node) {
+  const tabNodes = getDirectiveChildren(node.children ?? [], "tab");
+  const groupId = `mdx-tabs-${Math.random().toString(36).slice(2, 8)}`;
+  node.data = {
+    hName: "div",
+    hProperties: { className: ["mdx-tabs"] }
+  };
+  const triggers = [];
+  const panels = [];
+  for (let i = 0; i < tabNodes.length; i++) {
+    const tab = tabNodes[i];
+    const label = tab.attributes?.label ?? `Tab ${i + 1}`;
+    triggers.push(mdastHtmlNode(
+      `<label class="mdx-tabs-trigger"><input type="radio" name="${groupId}" class="mdx-tabs-radio"${i === 0 ? " checked" : ""}><span>${escapeHtml2(label)}</span></label>`
+    ));
+    panels.push(mdastWrapper("div", "mdx-tabs-panel", tab.children ?? []));
+  }
+  const tabList = mdastWrapper("div", "mdx-tabs-list", triggers);
+  tabList.data.hProperties.role = "tablist";
+  node.children = [tabList, ...panels];
+}
+function remarkOwoComponents(options) {
+  const { enabled } = options;
+  return function transform2(tree, file) {
+    visit3(tree, (node, _index, parent) => {
+      const directive = node;
+      if (directive.type === "textDirective") {
+        return handleTextDirective(directive, parent ?? void 0, file, enabled);
+      }
+      if (directive.type !== "containerDirective") return;
+      const { name } = directive;
+      if (name === "side") return;
+      const entry = COMPONENT_REGISTRY.get(name);
+      if (!entry) {
+        reportUnknownComponent(file, name, getPosition(directive));
+        return;
+      }
+      if (!enabled) {
+        reportDisabledFlag(file, name, getPosition(directive));
+        return;
+      }
+      validateAttrs(file, directive, entry);
+      if (entry.requiredParent) {
+        const parentDirective = parent;
+        if (!parentDirective || parentDirective.type !== "containerDirective" || parentDirective.name !== entry.requiredParent) {
+          reportInvalidNesting(file, name, entry.requiredParent, getPosition(directive));
+          return;
+        }
+      }
+      if (entry.allowedChildDirective && directive.children) {
+        const childName = entry.allowedChildDirective;
+        const hasChildDirectives = hasContainerDirectiveChildren(directive.children, childName);
+        if (entry.kind === "block-parent") {
+          if (!allChildrenAreDirective(directive.children, childName)) {
+            if (directive.children.some((c) => !isBlankParagraph(c))) {
+              reportInvalidChildren(file, name, childName, getPosition(directive));
+            }
+          }
+        }
+        if (name === "code-demo" && hasChildDirectives) {
+          const hasTopLevelCode = countCodeBlocks(directive.children) > 0;
+          if (hasTopLevelCode) {
+            reportConflictingPayload(file, name, "cannot mix top-level code blocks with :::code-tab children", getPosition(directive));
+            return;
+          }
+          if (!allChildrenAreDirective(directive.children, "code-tab")) {
+            reportInvalidChildren(file, name, "code-tab", getPosition(directive));
+          }
+          const codeTabNodes = getDirectiveChildren(directive.children, "code-tab");
+          for (const ct of codeTabNodes) {
+            validateAttrs(file, ct, COMPONENT_REGISTRY.get("code-tab"));
+            const codeCount = countCodeBlocks(ct.children ?? []);
+            if (codeCount === 0) {
+              reportMissingPayload(file, "code-tab", "a fenced code block", getPosition(ct));
+            } else if (codeCount > 1) {
+              reportConflictingPayload(file, "code-tab", "must contain exactly one fenced code block", getPosition(ct));
+            }
+          }
+          const tabs = codeTabNodes.map((ct) => {
+            const code = findCodeBlock(ct.children ?? []);
+            return {
+              label: ct.attributes?.label ?? "",
+              language: ct.attributes?.language ?? code?.lang ?? "text",
+              code: code?.value ?? ""
+            };
+          });
+          makeRenderedNode(directive, renderCodeDemoMultiTab(directive.attributes ?? {}, tabs));
+          return SKIP;
+        }
+      }
+      switch (name) {
+        case "note":
+          transformNote(directive);
+          return SKIP;
+        case "callout":
+          transformCallout(directive);
+          return SKIP;
+        case "details":
+          transformDetails(directive);
+          return SKIP;
+        case "kbd":
+          transformKbd(directive);
+          return SKIP;
+        case "code-demo": {
+          const codeBlock = findCodeBlock(directive.children ?? []);
+          if (!codeBlock) {
+            reportMissingPayload(file, name, "a fenced code block", getPosition(directive));
+            return;
+          }
+          if (countCodeBlocks(directive.children ?? []) > 1) {
+            reportConflictingPayload(file, name, "must contain exactly one fenced code block (or use :::code-tab)", getPosition(directive));
+            return;
+          }
+          makeRenderedNode(
+            directive,
+            renderCodeDemoSingle(directive.attributes ?? {}, codeBlock.value, codeBlock.lang ?? "")
+          );
+          return SKIP;
+        }
+        case "file-tree": {
+          const codeBlock = findCodeBlock(directive.children ?? []);
+          if (!codeBlock) {
+            reportMissingPayload(file, name, "a fenced code block", getPosition(directive));
+            return;
+          }
+          makeRenderedNode(directive, renderFileTree(codeBlock.value));
+          return SKIP;
+        }
+        case "link-card": {
+          const attrs = directive.attributes ?? {};
+          const hasDesc = Boolean(attrs.description);
+          const bodyText = extractTextContent(directive.children ?? []).trim();
+          if (hasDesc && bodyText) {
+            reportConflictingPayload(file, name, 'cannot have both "description" attribute and body text', getPosition(directive));
+          }
+          makeRenderedNode(directive, renderLinkCard(attrs, bodyText));
+          return SKIP;
+        }
+        case "steps":
+          transformSteps(directive);
+          return SKIP;
+        case "tabs":
+          transformTabs(directive);
+          return SKIP;
+        case "step":
+        case "tab":
+        case "code-tab":
+          break;
+      }
+    });
+  };
+}
+function handleTextDirective(node, _parent, file, enabled) {
+  if (node.name === "kbd") {
+    if (!enabled) {
+      reportDisabledFlag(file, node.name, getPosition(node));
+      return;
+    }
+    transformKbd(node);
+    return SKIP;
+  }
+  const entry = COMPONENT_REGISTRY.get(node.name);
+  if (entry && entry.kind !== "inline-text") {
+    reportInvalidNesting(file, node.name, "block context (use ::: syntax)", getPosition(node));
+  }
+}
+function owoComponentRenderedHandler(_state, node) {
+  return {
+    type: "raw",
+    value: node.data?.html ?? ""
+  };
+}
+
+// src/processor/source-normalization.ts
+import {
+  collectMathFenceNormalizationRewrites
+} from "@owomark/core/semantic/syntax";
+function splitLogicalLines(source) {
+  const lines = source.split("\n");
+  if (source.endsWith("\n")) {
+    lines.pop();
+  }
+  return lines;
+}
+function createIdentitySourceMap(source) {
+  const lineCount = splitLogicalLines(source).length;
+  return {
+    normalizedToSourceLine: Array.from({ length: lineCount }, (_, index) => index + 1),
+    normalizedToSourceColumn: Array.from({ length: lineCount }, () => 1),
+    segments: []
+  };
+}
+function applySourceRewrites(source, sourceMap, rewrites) {
+  if (rewrites.length === 0) {
+    return { source, sourceMap };
+  }
+  const inputLines = splitLogicalLines(source);
+  const outputLines = [];
+  const normalizedToSourceLine = [];
+  const normalizedToSourceColumn = [];
+  const segments = [...sourceMap.segments];
+  let lineNumber = 1;
+  let rewriteIndex = 0;
+  while (lineNumber <= inputLines.length) {
+    const rewrite = rewrites[rewriteIndex];
+    if (rewrite && rewrite.startLine === lineNumber) {
+      const normalizedStartLine = outputLines.length + 1;
+      outputLines.push(...rewrite.replacementLines);
+      for (const mapping of rewrite.lineMappings) {
+        const sourceLine = sourceMap.normalizedToSourceLine[mapping.sourceLine - 1] ?? mapping.sourceLine;
+        const sourceColumnBase = sourceMap.normalizedToSourceColumn[mapping.sourceLine - 1] ?? 1;
+        normalizedToSourceLine.push(sourceLine);
+        normalizedToSourceColumn.push(sourceColumnBase + mapping.sourceColumn - 1);
+      }
+      segments.push({
+        kind: rewrite.kind,
+        normalizedStartLine,
+        normalizedEndLine: outputLines.length,
+        sourceStartLine: sourceMap.normalizedToSourceLine[rewrite.startLine - 1] ?? rewrite.startLine,
+        sourceEndLine: sourceMap.normalizedToSourceLine[rewrite.endLine - 1] ?? rewrite.endLine
+      });
+      lineNumber = rewrite.endLine + 1;
+      rewriteIndex += 1;
+      continue;
+    }
+    outputLines.push(inputLines[lineNumber - 1]);
+    normalizedToSourceLine.push(sourceMap.normalizedToSourceLine[lineNumber - 1] ?? lineNumber);
+    normalizedToSourceColumn.push(sourceMap.normalizedToSourceColumn[lineNumber - 1] ?? 1);
+    lineNumber += 1;
+  }
+  const normalizedSource = outputLines.join("\n");
+  return {
+    source: source.endsWith("\n") ? `${normalizedSource}
+` : normalizedSource,
+    sourceMap: {
+      normalizedToSourceLine,
+      normalizedToSourceColumn,
+      segments
+    }
+  };
+}
+function normalizeOwoMarkSource(source, options) {
+  const baseMap = createIdentitySourceMap(source);
+  if (options?.enableMath === false) {
+    return { source, sourceMap: baseMap };
+  }
+  const rewrites = collectMathFenceNormalizationRewrites(source).map((rewrite) => ({
+    kind: rewrite.kind,
+    startLine: rewrite.startLine,
+    endLine: rewrite.endLine,
+    replacementLines: rewrite.replacementLines,
+    lineMappings: rewrite.lineMappings
+  }));
+  return applySourceRewrites(source, baseMap, rewrites);
+}
+function remapNormalizedLine(line, sourceMap) {
+  if (typeof line !== "number" || line < 1) return line;
+  return sourceMap?.normalizedToSourceLine[line - 1] ?? line;
+}
+function remapNormalizedColumn(line, column, sourceMap) {
+  if (typeof line !== "number" || typeof column !== "number" || line < 1 || column < 1) {
+    return column;
+  }
+  const baseColumn = sourceMap?.normalizedToSourceColumn[line - 1];
+  if (typeof baseColumn !== "number") {
+    return column;
+  }
+  return baseColumn + column - 1;
+}
+
+// src/processor/remark-mdx-source-lines.ts
+function setMdxAttribute(node, name, value) {
+  const attributes = Array.isArray(node.attributes) ? node.attributes : [];
+  const existing = attributes.findIndex(
+    (attribute) => attribute?.type === "mdxJsxAttribute" && attribute.name === name
+  );
+  const nextAttribute = {
+    type: "mdxJsxAttribute",
+    name,
+    value
+  };
+  if (existing >= 0) {
+    attributes[existing] = nextAttribute;
+  } else {
+    attributes.push(nextAttribute);
+  }
+  node.attributes = attributes;
+}
+function remapLine(line, sourceMap) {
+  return remapNormalizedLine(line, sourceMap);
+}
+function stampMdxJsxNode(node, sourceMap) {
+  const startLine = remapLine(node.position?.start?.line, sourceMap);
+  if (!startLine) return;
+  const endLine = remapLine(node.position?.end?.line, sourceMap) ?? startLine;
+  setMdxAttribute(node, "data-source-line-start", String(startLine));
+  setMdxAttribute(node, "data-source-line-end", String(endLine));
+  setMdxAttribute(node, "data-block-id", `L${startLine}-${endLine}`);
+}
+function walk3(node, sourceMap) {
+  if (!node || typeof node !== "object") return;
+  if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") {
+    stampMdxJsxNode(node, sourceMap);
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walk3(child, sourceMap);
+  }
+}
+function remarkMdxSourceLines(options) {
+  return (tree) => {
+    walk3(tree, options?.sourceMap);
+  };
+}
+
+// src/processor/rehype-source-lines.ts
+var LEAF_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "pre",
+  "table",
+  "hr",
+  "img"
+]);
+var CONTAINER_TAGS = /* @__PURE__ */ new Set([
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "div",
+  "section",
+  "details",
+  "summary"
+]);
+var MATH_LEAF_CLASSES = /* @__PURE__ */ new Set([
+  "katex-display",
+  "math-display",
+  "math-display-block"
+]);
+function liHasAnchorDescendant(node) {
+  if (!Array.isArray(node.children)) return false;
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (LEAF_TAGS.has(child.tagName)) return true;
+    if (child.tagName === "ul" || child.tagName === "ol") return true;
+    if (CONTAINER_TAGS.has(child.tagName) && liHasAnchorDescendant(child)) return true;
+  }
+  return false;
+}
+function stampAnchorAttributes(node) {
+  const sl = node.position.start.line;
+  const el2 = node.position.end?.line ?? sl;
+  node.properties = node.properties || {};
+  node.properties["data-source-line-start"] = sl;
+  node.properties["data-source-line-end"] = el2;
+  node.properties["data-block-id"] = `L${sl}-${el2}`;
+}
+function walk4(node) {
+  if (!node) return;
+  if (node.type === "element" && node.position?.start?.line) {
+    const tag = node.tagName;
+    if (LEAF_TAGS.has(tag)) {
+      stampAnchorAttributes(node);
+    } else if (tag === "li" && !liHasAnchorDescendant(node)) {
+      stampAnchorAttributes(node);
+    } else if (tag === "div") {
+      const classes = node.properties?.className || [];
+      if (classes.some((className) => MATH_LEAF_CLASSES.has(className))) {
+        stampAnchorAttributes(node);
+        return;
+      }
+    }
+  }
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walk4(child);
+  }
+}
+function rehypeSourceLines() {
+  return (tree) => {
+    walk4(tree);
+  };
+}
+
+// src/processor/plugin-registry.ts
+var BUILTIN_PLUGINS = /* @__PURE__ */ new Map([
+  ["rehype-source-lines", {
+    plugin: rehypeSourceLines,
+    workerSafe: true
+  }]
+]);
+var GLOBAL_KEY = "__owomark_custom_plugins__";
+function getCustomPlugins() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) g[GLOBAL_KEY] = /* @__PURE__ */ new Map();
+  return g[GLOBAL_KEY];
+}
+function registerPlugin(name, plugin) {
+  getCustomPlugins().set(name, plugin);
+}
+function allBuiltinDescriptors(descriptors) {
+  return descriptors.every((d) => BUILTIN_PLUGINS.has(d.name));
+}
+function isWorkerSafeBuiltinDescriptor(descriptor) {
+  return BUILTIN_PLUGINS.get(descriptor.name)?.workerSafe === true;
+}
+function allWorkerSafeBuiltinDescriptors(descriptors) {
+  return descriptors.every((d) => BUILTIN_PLUGINS.get(d.name)?.workerSafe === true);
+}
+function resolveDescriptors(descriptors) {
+  return descriptors.map((d) => {
+    const plugin = BUILTIN_PLUGINS.get(d.name)?.plugin ?? getCustomPlugins().get(d.name);
+    if (!plugin) {
+      throw new Error(`[owomark] Unknown plugin descriptor: "${d.name}". Register it first via registerPlugin().`);
+    }
+    if (d.options) return [plugin, d.options];
+    return plugin;
+  });
+}
+
 // src/mdx-components/callout.ts
 import { createElement } from "react";
+
+// src/mdx-components/dom-props.ts
+function mergeClassName(...values) {
+  const merged = values.filter(Boolean).join(" ").trim();
+  return merged || void 0;
+}
+
+// src/mdx-components/callout.ts
 var ICONS = { info: "i", warn: "!", error: "\xD7" };
-function Callout({ type = "info", children }) {
+function Callout({
+  type = "info",
+  children,
+  className,
+  ...domProps
+}) {
   return createElement(
     "div",
-    { className: `mdx-callout mdx-callout-${type}`, "data-callout-type": type },
+    {
+      ...domProps,
+      className: mergeClassName("mdx-callout", `mdx-callout-${type}`, className),
+      "data-callout-type": type
+    },
     createElement("span", { className: "mdx-callout-icon" }, ICONS[type] || ICONS.info),
     createElement("div", { className: "mdx-callout-content" }, children)
   );
 }
 
-// src/mdx-components/code-demo.ts
+// src/mdx-components/note.ts
 import { createElement as createElement2 } from "react";
-function CodeDemo({ title, language = "text", code }) {
+function Note({
+  title,
+  children,
+  className,
+  ...domProps
+}) {
   return createElement2(
+    "aside",
+    {
+      ...domProps,
+      className: mergeClassName("mdx-note", className)
+    },
+    title ? createElement2("div", { className: "mdx-note-title" }, title) : null,
+    createElement2("div", { className: "mdx-note-body" }, children)
+  );
+}
+
+// src/mdx-components/code-demo.ts
+import { createElement as createElement3 } from "react";
+function CodeDemo({
+  title,
+  language = "text",
+  code,
+  className,
+  ...domProps
+}) {
+  return createElement3(
     "figure",
-    { className: "mdx-code-demo", "data-code-demo": "" },
-    title && createElement2("figcaption", null, title),
-    createElement2(
+    {
+      ...domProps,
+      className: mergeClassName("mdx-code-demo", className),
+      "data-code-demo": ""
+    },
+    title && createElement3("figcaption", null, title),
+    createElement3(
       "pre",
       { "data-language": language },
-      createElement2("code", null, code)
+      createElement3("code", null, code)
     )
   );
 }
 
+// src/mdx-components/code-tab.ts
+import { createElement as createElement4 } from "react";
+function CodeTab({
+  label,
+  language,
+  children,
+  className,
+  ...domProps
+}) {
+  return createElement4(
+    "div",
+    {
+      ...domProps,
+      className: mergeClassName("mdx-code-tab", className),
+      "data-label": label,
+      "data-language": language
+    },
+    children
+  );
+}
+
+// src/mdx-components/details.ts
+import { createElement as createElement5 } from "react";
+function Details({
+  summary,
+  open,
+  children,
+  className,
+  ...domProps
+}) {
+  return createElement5(
+    "details",
+    {
+      ...domProps,
+      className: mergeClassName("mdx-details", className),
+      open: open === "true" || void 0
+    },
+    createElement5("summary", { className: "mdx-details-summary" }, summary),
+    createElement5("div", { className: "mdx-details-body" }, children)
+  );
+}
+
+// src/mdx-components/link-card.ts
+import { createElement as createElement6 } from "react";
+function LinkCard({
+  href,
+  title,
+  description,
+  domain,
+  children,
+  className,
+  ...domProps
+}) {
+  const desc = description || (children ? children : null);
+  return createElement6(
+    "a",
+    {
+      ...domProps,
+      className: mergeClassName("mdx-link-card", className),
+      href
+    },
+    createElement6("div", { className: "mdx-link-card-title" }, title),
+    desc ? createElement6("div", { className: "mdx-link-card-desc" }, desc) : null,
+    domain ? createElement6("div", { className: "mdx-link-card-domain" }, domain) : null
+  );
+}
+
 // src/mdx-components/steps.ts
-import { createElement as createElement3, Children } from "react";
-function Steps({ children }) {
+import { createElement as createElement7, Children } from "react";
+function Steps({ children, className, ...domProps }) {
   const items = [];
   Children.forEach(children, (child) => {
     if (child && typeof child === "object" && "props" in child) {
       items.push(child);
     }
   });
-  return createElement3(
+  return createElement7(
     "div",
-    { className: "mdx-steps" },
+    {
+      ...domProps,
+      className: mergeClassName("mdx-steps", className)
+    },
     items.map(
-      (item, i) => createElement3(
+      (item, i) => createElement7(
         "div",
         { className: "mdx-steps-item", key: i },
-        createElement3(
+        createElement7(
           "div",
           { className: "mdx-steps-indicator" },
-          createElement3("span", { className: "mdx-steps-number" }, String(i + 1)),
-          i < items.length - 1 && createElement3("div", { className: "mdx-steps-line" })
+          createElement7("span", { className: "mdx-steps-number" }, String(i + 1)),
+          i < items.length - 1 && createElement7("div", { className: "mdx-steps-line" })
         ),
-        createElement3("div", { className: "mdx-steps-content" }, item)
+        createElement7("div", { className: "mdx-steps-content" }, item)
       )
     )
   );
 }
-function Step({ title, children }) {
-  return createElement3(
+function Step({ title, children, className, ...domProps }) {
+  return createElement7(
     "div",
-    { className: "mdx-step" },
-    title && createElement3("h4", { className: "mdx-step-title" }, title),
-    children && createElement3("div", { className: "mdx-step-body" }, children)
+    {
+      ...domProps,
+      className: mergeClassName("mdx-step", className)
+    },
+    title && createElement7("h4", { className: "mdx-step-title" }, title),
+    children && createElement7("div", { className: "mdx-step-body" }, children)
   );
 }
 
 // src/mdx-components/tabs.ts
-import { createElement as createElement4, Children as Children2 } from "react";
-function Tabs({ children }) {
+import { createElement as createElement8, Children as Children2 } from "react";
+function Tabs({ children, className, ...domProps }) {
   const tabs = [];
   Children2.forEach(children, (child) => {
     if (child && typeof child === "object" && "props" in child) {
@@ -1416,39 +2456,49 @@ function Tabs({ children }) {
     }
   });
   const groupId = `mdx-tabs-${Math.random().toString(36).slice(2, 8)}`;
-  return createElement4(
+  return createElement8(
     "div",
-    { className: "mdx-tabs" },
-    createElement4(
+    {
+      ...domProps,
+      className: mergeClassName("mdx-tabs", className)
+    },
+    createElement8(
       "div",
       { className: "mdx-tabs-list", role: "tablist" },
       tabs.map(
-        (tab, i) => createElement4(
+        (tab, i) => createElement8(
           "label",
           { className: "mdx-tabs-trigger", key: i },
-          createElement4("input", {
+          createElement8("input", {
             type: "radio",
             name: groupId,
             className: "mdx-tabs-radio",
             defaultChecked: i === 0
           }),
-          createElement4("span", null, tab.label)
+          createElement8("span", null, tab.label)
         )
       )
     ),
     tabs.map(
-      (tab, i) => createElement4("div", { className: "mdx-tabs-panel", key: i }, tab.content)
+      (tab, i) => createElement8("div", { className: "mdx-tabs-panel", key: i }, tab.content)
     )
   );
 }
-function Tab({ label: _label, children }) {
-  return createElement4("div", null, children);
+function Tab({ label: _label, children, className, ...domProps }) {
+  return createElement8(
+    "div",
+    {
+      ...domProps,
+      className
+    },
+    children
+  );
 }
 
 // src/mdx-components/file-tree.ts
-import { createElement as createElement5 } from "react";
+import { createElement as createElement9 } from "react";
 function parseFileTree(text) {
-  const entries = [];
+  const entries2 = [];
   for (const line of text.split("\n")) {
     const trimmed = line.replace(/^[\s\-\*]*/, "");
     if (!trimmed) continue;
@@ -1456,26 +2506,29 @@ function parseFileTree(text) {
     const depth = Math.floor(leadingSpaces / 2);
     const isDir = trimmed.endsWith("/");
     const name = isDir ? trimmed.slice(0, -1) : trimmed;
-    entries.push({ name, isDir, depth });
+    entries2.push({ name, isDir, depth });
   }
-  return entries;
+  return entries2;
 }
-function FileTree({ children }) {
+function FileTree({ children, className, ...domProps }) {
   const text = extractText(children);
-  const entries = parseFileTree(text);
-  return createElement5(
+  const entries2 = parseFileTree(text);
+  return createElement9(
     "div",
-    { className: "mdx-file-tree" },
-    entries.map(
-      (entry, i) => createElement5(
+    {
+      ...domProps,
+      className: mergeClassName("mdx-file-tree", className)
+    },
+    entries2.map(
+      (entry, i) => createElement9(
         "div",
         {
           className: `mdx-file-tree-entry ${entry.isDir ? "mdx-file-tree-dir" : "mdx-file-tree-file"}`,
           style: { paddingLeft: `${entry.depth * 1.25 + 0.5}rem` },
           key: i
         },
-        createElement5("span", { className: "mdx-file-tree-icon" }, entry.isDir ? "\u{1F4C1}" : "\u{1F4C4}"),
-        createElement5("span", { className: "mdx-file-tree-name" }, entry.name)
+        createElement9("span", { className: "mdx-file-tree-icon" }, entry.isDir ? "\u{1F4C1}" : "\u{1F4C4}"),
+        createElement9("span", { className: "mdx-file-tree-name" }, entry.name)
       )
     )
   );
@@ -1491,15 +2544,26 @@ function extractText(node) {
 }
 
 // src/mdx-components/kbd.ts
-import { createElement as createElement6 } from "react";
-function Kbd({ children }) {
-  return createElement6("kbd", { className: "mdx-kbd" }, children);
+import { createElement as createElement10 } from "react";
+function Kbd({ children, className, ...domProps }) {
+  return createElement10(
+    "kbd",
+    {
+      ...domProps,
+      className: mergeClassName("mdx-kbd", className)
+    },
+    children
+  );
 }
 
 // src/mdx-components/index.ts
 var DEFAULT_MDX_COMPONENTS = {
   Callout,
+  Note,
   CodeDemo,
+  CodeTab,
+  Details,
+  LinkCard,
   Steps,
   Step,
   Tabs,
@@ -1508,6 +2572,810 @@ var DEFAULT_MDX_COMPONENTS = {
   Kbd
 };
 
+// src/processor/mdx-syntax-analysis.ts
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkMdx from "remark-mdx";
+import remarkDirective from "remark-directive";
+var MDX_NODE_REASONS = /* @__PURE__ */ new Map([
+  ["mdxjsEsm", "mdxjs-esm"],
+  ["mdxJsxFlowElement", "mdx-jsx-flow"],
+  ["mdxJsxTextElement", "mdx-jsx-text"],
+  ["mdxFlowExpression", "mdx-flow-expression"],
+  ["mdxTextExpression", "mdx-text-expression"]
+]);
+var MASKED_LITERAL_NODE_TYPES = /* @__PURE__ */ new Set([
+  "code",
+  "inlineCode",
+  "math",
+  "inlineMath"
+]);
+function applyPlugin(proc, entry) {
+  if (Array.isArray(entry)) {
+    const [plugin, ...args] = entry;
+    return proc.use(plugin, ...args);
+  }
+  return proc.use(entry);
+}
+function createParser(mode, options) {
+  const enableMath = options?.enableMath !== false;
+  const enableSideAnnotation = options?.enableSideAnnotation !== false;
+  const remarkPlugins = [remarkGfm];
+  if (enableMath) {
+    remarkPlugins.push(remarkMath, remarkNormalizeStandaloneMath);
+  }
+  remarkPlugins.push(remarkDirective);
+  if (mode === "production") {
+    if (enableSideAnnotation) {
+      remarkPlugins.push(remarkMicromarkSideAnnotation);
+    }
+    remarkPlugins.push(remarkMdx);
+  }
+  if (enableSideAnnotation) {
+    remarkPlugins.push(remarkSideAnnotation);
+  }
+  if (options?.extraRemarkDescriptors?.length) {
+    remarkPlugins.push(...resolveDescriptors(options.extraRemarkDescriptors));
+  }
+  if (options?.extraRemarkPlugins) {
+    remarkPlugins.push(...options.extraRemarkPlugins);
+  }
+  let parser = unified().use(remarkParse);
+  for (const plugin of remarkPlugins) {
+    parser = applyPlugin(parser, plugin);
+  }
+  return parser;
+}
+function collectRangesByNodeTypes(root, nodeTypes) {
+  const stack = [root];
+  const ranges = [];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    const nodeType = typeof node.type === "string" ? node.type : null;
+    if (nodeType && nodeTypes.has(nodeType)) {
+      const start = node.position?.start?.offset;
+      const end = node.position?.end?.offset;
+      if (typeof start === "number" && typeof end === "number" && start >= 0 && end >= start) {
+        ranges.push({ start, end });
+      }
+    }
+    const children = Array.isArray(node.children) ? node.children : [];
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      stack.push(children[index]);
+    }
+  }
+  ranges.sort((left, right) => left.start - right.start);
+  return ranges;
+}
+function buildMaskedSource(source, root) {
+  const ranges = collectRangesByNodeTypes(root, MASKED_LITERAL_NODE_TYPES);
+  let cursor = 0;
+  let result = "";
+  for (const range of ranges) {
+    if (range.start < cursor) continue;
+    result += source.slice(cursor, range.start);
+    result += source.slice(range.start, range.end).replace(/[^\s]/g, "x");
+    cursor = range.end;
+  }
+  result += source.slice(cursor);
+  return result;
+}
+function hasIndentedCodeIndent(line) {
+  return line.startsWith("    ") || line.startsWith("	");
+}
+function stripIndentedCodeIndent(line) {
+  if (line.startsWith("    ")) return line.slice(4);
+  if (line.startsWith("	")) return line.slice(1);
+  return line;
+}
+function parseMarkdownTree(source, options) {
+  return createParser("preview", options).parse(source);
+}
+function getFence(lines) {
+  const tildeRuns = lines.flatMap((line) => line.match(/~+/g) ?? []);
+  let longestRun = 2;
+  for (const run of tildeRuns) {
+    if (run.length > longestRun) {
+      longestRun = run.length;
+    }
+  }
+  return "~".repeat(longestRun + 1);
+}
+function collectIndentedCodeRewrites(source, root) {
+  const sourceLines = source.split("\n");
+  const stack = [root];
+  const rewrites = [];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    if (node.type === "code") {
+      const startLine = node.position?.start?.line;
+      const endLine = node.position?.end?.line;
+      const startColumn = node.position?.start?.column;
+      if (typeof startLine === "number" && typeof endLine === "number" && typeof startColumn === "number" && startLine >= 1 && endLine >= startLine) {
+        const firstLine = sourceLines[startLine - 1] ?? "";
+        const preservedPrefixColumns = Math.max(0, startColumn - 1);
+        const prefix = firstLine.slice(0, preservedPrefixColumns);
+        const firstContentLine = firstLine.slice(prefix.length);
+        if (hasIndentedCodeIndent(firstContentLine)) {
+          const originalLines = sourceLines.slice(startLine - 1, endLine);
+          const normalizedLines = originalLines.map((line) => {
+            const withoutPrefix = line.startsWith(prefix) ? line.slice(prefix.length) : line;
+            return stripIndentedCodeIndent(withoutPrefix);
+          });
+          const fence = getFence(normalizedLines);
+          const lineMappings = [
+            { sourceLine: startLine, sourceColumn: preservedPrefixColumns + 1 },
+            ...normalizedLines.map((_, offset) => ({
+              sourceLine: startLine + offset,
+              sourceColumn: preservedPrefixColumns + 5
+            })),
+            { sourceLine: endLine, sourceColumn: preservedPrefixColumns + 1 }
+          ];
+          rewrites.push({
+            kind: "indented-code",
+            startLine,
+            endLine,
+            replacementLines: [
+              `${prefix}${fence}`,
+              ...normalizedLines.map((line) => `${prefix}${line}`),
+              `${prefix}${fence}`
+            ],
+            lineMappings
+          });
+        }
+      }
+    }
+    const children = Array.isArray(node.children) ? node.children : [];
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      stack.push(children[index]);
+    }
+  }
+  rewrites.sort((left, right) => left.startLine - right.startLine);
+  return rewrites;
+}
+function collectMdxSyntaxMetadata(root) {
+  const componentNames = /* @__PURE__ */ new Set();
+  const stack = [root];
+  let reason;
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    const nodeType = typeof node.type === "string" ? node.type : null;
+    if (!reason && nodeType) {
+      reason = MDX_NODE_REASONS.get(nodeType);
+    }
+    if ((nodeType === "mdxJsxFlowElement" || nodeType === "mdxJsxTextElement") && typeof node.name === "string" && /^[A-Z]/.test(node.name)) {
+      componentNames.add(node.name);
+    }
+    const children = Array.isArray(node.children) ? node.children : [];
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      stack.push(children[index]);
+    }
+  }
+  return {
+    reason,
+    componentNames: Array.from(componentNames)
+  };
+}
+function inspectMdxSource(source, options) {
+  try {
+    const normalized = normalizeOwoMarkSource(source, { enableMath: options?.enableMath });
+    const markdownTree = parseMarkdownTree(normalized.source, options);
+    const rewrites = collectIndentedCodeRewrites(normalized.source, markdownTree);
+    const compilePlan = applySourceRewrites(normalized.source, normalized.sourceMap, rewrites);
+    const mdxProbeSource = buildMaskedSource(
+      compilePlan.source,
+      parseMarkdownTree(compilePlan.source, options)
+    );
+    const mdxTree = createParser("production", options).use(remarkMdx).parse(mdxProbeSource);
+    const { reason, componentNames } = collectMdxSyntaxMetadata(mdxTree);
+    return {
+      hasMdxSyntax: reason !== void 0,
+      reason,
+      componentNames,
+      compileSource: compilePlan.source,
+      sourceMap: compilePlan.sourceMap
+    };
+  } catch {
+    const fallback = normalizeOwoMarkSource(source, { enableMath: options?.enableMath });
+    return {
+      hasMdxSyntax: true,
+      reason: "parse-failed-fallback",
+      componentNames: [],
+      compileSource: fallback.source,
+      sourceMap: fallback.sourceMap
+    };
+  }
+}
+function analyzeMdxSyntax(source, options) {
+  const inspection = inspectMdxSource(source, options);
+  return {
+    hasMdxSyntax: inspection.hasMdxSyntax,
+    reason: inspection.reason,
+    componentNames: inspection.componentNames
+  };
+}
+function detectMdxSyntax(source, options) {
+  const { hasMdxSyntax, reason } = analyzeMdxSyntax(source, options);
+  return { hasMdxSyntax, reason };
+}
+function remapMdxLineNumber(line, sourceMap) {
+  return remapNormalizedLine(line, sourceMap);
+}
+function remapMdxColumnNumber(line, column, sourceMap) {
+  return remapNormalizedColumn(line, column, sourceMap);
+}
+function remapMdxErrorDetails(error, sourceMap) {
+  if (error && typeof error === "object") {
+    const value = error;
+    if (typeof value.line === "number") {
+      return {
+        message: value.message ?? String(error),
+        line: remapMdxLineNumber(value.line, sourceMap),
+        column: remapMdxColumnNumber(value.line, value.column, sourceMap)
+      };
+    }
+    const text = value.message ?? String(error);
+    const match = text.match(/\((\d+):(\d+)/);
+    if (match) {
+      const line = Number(match[1]);
+      const column = Number(match[2]);
+      return {
+        message: text,
+        line: remapMdxLineNumber(line, sourceMap),
+        column: remapMdxColumnNumber(line, column, sourceMap)
+      };
+    }
+    return { message: text };
+  }
+  return { message: String(error) };
+}
+
+// src/processor/index.ts
+import { parseMarkdownToDocument as parseMarkdownToDocument2 } from "@owomark/core";
+
+// src/processor/canonical-mdast.ts
+import {
+  CARDS_FAMILY_CUSTOM_BLOCK_KEY,
+  isCardsFamilyAttributes,
+  parseInlineSideAnnotationFromText,
+  parseMarkdownToDocument,
+  stripInlineSideAnnotationTail,
+  stripSideContinuationTail
+} from "@owomark/core";
+function createInlineMathNode(value) {
+  return {
+    type: "inlineMath",
+    value,
+    data: {
+      hName: "code",
+      hProperties: { className: ["language-math", "math-inline"] },
+      hChildren: [{ type: "text", value }]
+    }
+  };
+}
+function splitMixedDoubleDollarText(value) {
+  const nodes = [];
+  let cursor = 0;
+  const re = /\$\$([^$\n]+)\$\$/g;
+  let match;
+  while ((match = re.exec(value)) != null) {
+    if (match.index > cursor) {
+      nodes.push({ type: "text", value: value.slice(cursor, match.index) });
+    }
+    nodes.push(createInlineMathNode(match[1]));
+    cursor = match.index + match[0].length;
+  }
+  if (cursor < value.length) {
+    nodes.push({ type: "text", value: value.slice(cursor) });
+  }
+  return nodes.length > 0 ? nodes : [{ type: "text", value }];
+}
+function countLines(raw) {
+  return raw === "" ? 1 : raw.split("\n").length;
+}
+function createPosition(startLine, endLine, offset, raw, sourceMap) {
+  const normalizedEndColumn = raw.length === 0 ? 1 : (raw.split("\n").at(-1)?.length ?? 0) + 1;
+  const remappedStartLine = remapNormalizedLine(startLine, sourceMap) ?? startLine;
+  const remappedEndLine = remapNormalizedLine(endLine, sourceMap) ?? endLine;
+  const remappedStartColumn = remapNormalizedColumn(startLine, 1, sourceMap) ?? 1;
+  const remappedEndColumn = remapNormalizedColumn(endLine, normalizedEndColumn, sourceMap) ?? normalizedEndColumn;
+  return {
+    start: {
+      line: remappedStartLine,
+      column: remappedStartColumn,
+      offset
+    },
+    end: {
+      line: remappedEndLine,
+      column: remappedEndColumn,
+      offset: offset + raw.length
+    }
+  };
+}
+function advanceState(state, raw, sourceMap) {
+  const startLine = state.line;
+  const endLine = startLine + countLines(raw) - 1;
+  const position = createPosition(startLine, endLine, state.offset, raw, sourceMap);
+  state.line = endLine + 1;
+  state.offset += raw.length + 1;
+  return position;
+}
+function updateContainerPosition(node, child) {
+  if (!child.position) {
+    return;
+  }
+  if (!node.position) {
+    node.position = {
+      start: { ...child.position.start },
+      end: { ...child.position.end }
+    };
+    return;
+  }
+  node.position.end = { ...child.position.end };
+}
+function appendChild(parent, child) {
+  parent.children ??= [];
+  parent.children.push(child);
+  updateContainerPosition(parent, child);
+}
+function frameKey(frame) {
+  return `${frame.kind}:${frame.depth}`;
+}
+function ancestryKey(frames) {
+  return frames.map(frameKey).join("/");
+}
+function parseDirectiveAttributes(raw) {
+  const attributes = {};
+  const match = raw.match(/\{([^}]*)\}\s*$/);
+  if (!match) {
+    return attributes;
+  }
+  const content = match[1].trim();
+  if (!content) {
+    return attributes;
+  }
+  const attrRe = /([A-Za-z0-9_-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s]+))/g;
+  let attrMatch;
+  while ((attrMatch = attrRe.exec(content)) != null) {
+    attributes[attrMatch[1]] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+  }
+  return attributes;
+}
+function parseFenceMeta(block) {
+  const opener = block.syntaxRaw.split("\n")[0] ?? "";
+  const match = opener.match(/^[`~]{3,}([^\s]*)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const meta = match[2]?.trim() ?? "";
+  return meta.length > 0 ? meta : null;
+}
+function inlineToMdast(nodes, options) {
+  return nodes.flatMap((node) => {
+    switch (node.kind) {
+      case "text":
+        return options.enableMath === false ? [{ type: "text", value: node.text }] : splitMixedDoubleDollarText(node.text);
+      case "strong":
+        return [{ type: "strong", children: inlineToMdast(node.children, options) }];
+      case "emphasis":
+        return [{ type: "emphasis", children: inlineToMdast(node.children, options) }];
+      case "delete":
+        return [{ type: "delete", children: inlineToMdast(node.children, options) }];
+      case "inlineCode":
+        return [{ type: "inlineCode", value: node.text }];
+      case "inlineMath":
+        return options.enableMath === false ? [{ type: "text", value: `$${node.text}$` }] : [createInlineMathNode(node.text)];
+      case "html":
+        return [{ type: "html", value: node.text }];
+      case "link":
+        return [{ type: "link", url: node.url, children: inlineToMdast(node.children, options) }];
+      case "image":
+        return [{
+          type: "image",
+          url: node.url,
+          alt: node.alt.map((child) => child.kind === "text" ? child.text : "").join("")
+        }];
+    }
+  });
+}
+function inlineFromParagraphSource(source, options) {
+  const document = parseMarkdownToDocument(source);
+  const paragraph = document.conformance.blocks.find((block) => block.kind === "paragraph");
+  return paragraph?.kind === "paragraph" ? inlineToMdast(paragraph.inline, options) : [{ type: "text", value: source }];
+}
+function attachBlockToParent(parent, blockNode) {
+  appendChild(parent, blockNode);
+}
+function createSideAnnotationNode(block, position, options) {
+  const strippedInlineMarkdown = block.raw.split("\n").map((line) => {
+    if (parseInlineSideAnnotationFromText(line)) {
+      return stripInlineSideAnnotationTail(line);
+    }
+    if (line.includes("(>+)")) {
+      return stripSideContinuationTail(line);
+    }
+    return line;
+  }).join("\n");
+  const memberMarkdown = block.sideAnnotationKind === "inline" || block.sideAnnotationKind === "continuation-chain" ? strippedInlineMarkdown : block.members.map((member) => member.syntaxRaw).join("\n\n");
+  const children = block.sideAnnotationKind === "continuation-chain" ? [{
+    type: "paragraph",
+    children: strippedInlineMarkdown.split("\n").flatMap((line, index, lines) => {
+      const lineChildren = inlineFromParagraphSource(line, options);
+      if (index === lines.length - 1) {
+        return lineChildren;
+      }
+      return [...lineChildren, { type: "break" }];
+    })
+  }] : block.sideAnnotationKind !== "container" && block.sideAnnotationKind !== "reference-container" && !strippedInlineMarkdown.includes("\n\n") ? [{
+    type: "paragraph",
+    children: strippedInlineMarkdown.split("\n").flatMap((line, index, lines) => {
+      const lineChildren = inlineFromParagraphSource(line, options);
+      if (index === lines.length - 1) {
+        return lineChildren;
+      }
+      return [...lineChildren, { type: "break" }];
+    })
+  }] : buildRootFromDocument(parseMarkdownToDocument(memberMarkdown), options).children ?? [];
+  return {
+    type: "sideAnnotation",
+    data: {
+      hName: "div",
+      hProperties: {
+        className: [
+          "side-annotation",
+          `side-type-${block.sideType}`,
+          ...block.orphan ? ["side-orphan"] : []
+        ],
+        "data-side-type": block.sideType,
+        ...block.annotationText ? { "data-side-text": block.annotationText } : {},
+        ...block.orphan ? { "data-side-orphan": "true" } : {}
+      }
+    },
+    sideType: block.sideType,
+    sideTypeSymbol: block.sideTypeSymbol,
+    noteRef: block.noteRef ?? null,
+    inlineText: block.annotationText ?? null,
+    orphan: block.orphan ?? false,
+    position,
+    children
+  };
+}
+function createDirectiveContainerNode(block, position, options) {
+  const lines = block.syntaxRaw.split("\n");
+  const opener = lines[0] ?? "";
+  const innerMarkdown = lines.slice(1, -1).join("\n");
+  return {
+    type: "containerDirective",
+    name: block.directiveName,
+    attributes: parseDirectiveAttributes(opener),
+    position,
+    children: buildRootFromDocument(parseMarkdownToDocument(innerMarkdown), options).children ?? []
+  };
+}
+function createCustomBlockNodes(block, position, options) {
+  const cardsAttributes = isCardsFamilyAttributes(block.customBlockAttributes) ? block.customBlockAttributes : null;
+  if (block.customBlockKey === CARDS_FAMILY_CUSTOM_BLOCK_KEY && cardsAttributes) {
+    return [{
+      type: "cardsContainer",
+      position,
+      data: {
+        hName: "section",
+        hProperties: {
+          className: ["owo-cards"],
+          "data-owo-cards": "",
+          "data-owo-cards-cols": String(cardsAttributes.layout.cols)
+        }
+      },
+      children: cardsAttributes.cards.map((card) => {
+        const bodyRoot = buildRootFromDocument(parseMarkdownToDocument(card.bodyMarkdown), options);
+        const children = [];
+        if (card.title) {
+          children.push({
+            type: "cardsTitle",
+            position,
+            data: {
+              hName: "header",
+              hProperties: {
+                className: ["owo-card-title"]
+              }
+            },
+            children: [{ type: "text", value: card.title }]
+          });
+        }
+        children.push({
+          type: "cardsBody",
+          position,
+          data: {
+            hName: "div",
+            hProperties: {
+              className: ["owo-card-body"]
+            }
+          },
+          children: bodyRoot.children ?? []
+        });
+        return {
+          type: "cardsItem",
+          position,
+          data: {
+            hName: "article",
+            hProperties: {
+              className: ["owo-card", ...card.tone ? [`owo-card-tone-${card.tone}`] : []],
+              "data-owo-card": "",
+              ...card.tone ? { "data-owo-card-tone": card.tone } : {}
+            }
+          },
+          children
+        };
+      })
+    }];
+  }
+  switch (block.customBlockRuntime.processorFallback) {
+    case "skip-block":
+      return [];
+    case "unwrap-children": {
+      const innerMarkdown = block.syntaxRaw.split("\n").slice(1, -1).join("\n");
+      if (!innerMarkdown.trim()) {
+        return [];
+      }
+      return (buildRootFromDocument(parseMarkdownToDocument(innerMarkdown), options).children ?? []).map((child) => ({
+        ...child,
+        position: child.position ?? position
+      }));
+    }
+    case "render-raw":
+    default:
+      return [{
+        type: "paragraph",
+        position,
+        children: [{ type: "text", value: block.raw }]
+      }];
+  }
+}
+function buildLeafNode(block, position, options) {
+  switch (block.type) {
+    case "paragraph":
+      return [{
+        type: "paragraph",
+        children: inlineToMdast(block.conformanceInline ?? [], options),
+        position
+      }];
+    case "heading":
+      return [{
+        type: "heading",
+        depth: block.headingLevel,
+        children: inlineToMdast(block.conformanceInline ?? [], options),
+        position
+      }];
+    case "code-fence":
+      return [{
+        type: "code",
+        lang: block.language || null,
+        meta: parseFenceMeta(block),
+        value: block.syntaxRaw.split("\n").slice(1, -1).join("\n"),
+        position
+      }];
+    case "math-block":
+      if (options.enableMath === false) {
+        return [{
+          type: "paragraph",
+          children: [{ type: "text", value: block.raw }],
+          position
+        }];
+      }
+      return [{
+        type: "math",
+        meta: null,
+        value: block.syntaxRaw.includes("\n") ? block.syntaxRaw.split("\n").slice(1, -1).join("\n") : block.syntaxRaw.slice(2, -2),
+        data: {
+          hName: "pre",
+          hChildren: [{
+            type: "element",
+            tagName: "code",
+            properties: { className: ["language-math", "math-display"] },
+            children: [{
+              type: "text",
+              value: block.syntaxRaw.includes("\n") ? block.syntaxRaw.split("\n").slice(1, -1).join("\n") : block.syntaxRaw.slice(2, -2)
+            }]
+          }]
+        },
+        position
+      }];
+    case "table":
+      return block.conformanceTableNode != null ? [block.conformanceTableNode(position)] : [];
+    case "html-block":
+      return [{ type: "html", value: block.syntaxRaw, position }];
+    case "thematic-break":
+      return [{ type: "thematicBreak", position }];
+    case "side-annotation":
+      if (options.enableSideAnnotation === false) {
+        return [{
+          type: "paragraph",
+          children: [{ type: "text", value: block.raw }],
+          position
+        }];
+      }
+      return [createSideAnnotationNode(block, position, options)];
+    case "directive-container":
+      if (options.enableComponents === false && block.directiveName !== "side") {
+        return [{
+          type: "paragraph",
+          children: [{ type: "text", value: block.raw }],
+          position
+        }];
+      }
+      return [createDirectiveContainerNode(block, position, options)];
+    case "custom-block":
+      return createCustomBlockNodes(block, position, options);
+    case "blockquote":
+      return [{
+        type: "paragraph",
+        children: inlineToMdast(block.conformanceInline ?? [], options),
+        position
+      }];
+    default:
+      return [];
+  }
+}
+function ensureListContext(stack, parent, kind, depth, ancestry) {
+  const key = ancestryKey(ancestry);
+  const existing = stack.find((entry) => entry.kind === kind && entry.depth === depth && entry.ancestryKey === key);
+  if (existing) {
+    return existing;
+  }
+  const node = {
+    type: "list",
+    ordered: kind === "ordered-list",
+    children: []
+  };
+  appendChild(parent, node);
+  const created = {
+    kind,
+    depth,
+    ancestryKey: key,
+    node,
+    currentListItem: null
+  };
+  stack.push(created);
+  return created;
+}
+function buildRootFromBlocks(blocks, options) {
+  const root = { type: "root", children: [] };
+  const state = { line: 1, offset: 0 };
+  const listStack = [];
+  const containerMap = /* @__PURE__ */ new Map([["", root]]);
+  for (const rawBlock of blocks) {
+    const position = advanceState(state, rawBlock.raw, options.sourceMap);
+    const block = rawBlock;
+    if (rawBlock.type === "paragraph" && rawBlock.raw.trim() === "") {
+      continue;
+    }
+    const effectiveAncestry = rawBlock.type === "blockquote" ? [
+      ...rawBlock.ancestry,
+      ...Array.from({ length: rawBlock.depth }, (_, index) => ({
+        kind: "blockquote",
+        depth: index + 1
+      }))
+    ] : rawBlock.ancestry;
+    let parent = root;
+    let ancestryFrames = [];
+    for (const frame of effectiveAncestry) {
+      ancestryFrames = [...ancestryFrames, { kind: frame.kind, depth: frame.depth }];
+      const key = ancestryKey(ancestryFrames);
+      const cached = containerMap.get(key);
+      if (cached) {
+        parent = cached;
+        continue;
+      }
+      let node;
+      if (frame.kind === "blockquote") {
+        node = { type: "blockquote", children: [] };
+      } else if (frame.kind === "unordered-list" || frame.kind === "ordered-list") {
+        node = { type: "list", ordered: frame.kind === "ordered-list", children: [] };
+      } else {
+        node = { type: "listItem", children: [] };
+      }
+      appendChild(parent, node);
+      containerMap.set(key, node);
+      parent = node;
+    }
+    if (rawBlock.type === "unordered-list" || rawBlock.type === "ordered-list") {
+      const listContext = ensureListContext(listStack, parent, rawBlock.type, rawBlock.depth, rawBlock.ancestry);
+      const listItem = { type: "listItem", children: [], position };
+      appendChild(listContext.node, listItem);
+      listContext.currentListItem = listItem;
+      const paragraph = {
+        type: "paragraph",
+        children: inlineToMdast(block.conformanceInline ?? [], options),
+        position
+      };
+      appendChild(listItem, paragraph);
+      const syntheticFrames = [
+        ...rawBlock.ancestry.map((frame) => ({ kind: frame.kind, depth: frame.depth })),
+        { kind: rawBlock.type, depth: rawBlock.depth },
+        { kind: "list-item", depth: rawBlock.depth }
+      ];
+      containerMap.set(ancestryKey(syntheticFrames), listItem);
+      updateContainerPosition(listContext.node, listItem);
+      continue;
+    }
+    for (const node of buildLeafNode(block, position, options)) {
+      attachBlockToParent(parent, node);
+    }
+  }
+  return root;
+}
+function buildRootFromDocument(document, options = {}) {
+  const conformanceBlocks = [...document.conformance.blocks];
+  function shiftConformanceForBlock(block) {
+    if (block.type === "side-annotation" || block.type === "side-note-definition" || block.type === "directive-container" || block.type === "custom-block" || block.type === "reference-definition") {
+      return null;
+    }
+    return conformanceBlocks.shift() ?? null;
+  }
+  const enrichedBlocks = document.blocks.map((block) => {
+    const conformance = shiftConformanceForBlock(block);
+    return {
+      ...block,
+      conformanceInline: conformance?.kind === "paragraph" || conformance?.kind === "heading" || conformance?.kind === "blockquote" || conformance?.kind === "listItem" ? conformance.inline : null,
+      conformanceTableNode: conformance?.kind === "table" ? (position) => ({
+        type: "table",
+        children: conformance.rows.map((row) => ({
+          type: "tableRow",
+          children: row.cells.map((cell) => ({
+            type: "tableCell",
+            children: [{ type: "paragraph", children: inlineToMdast(cell.inline, options) }]
+          }))
+        })),
+        position
+      }) : null
+    };
+  });
+  return buildRootFromBlocks(enrichedBlocks, options);
+}
+
+// src/processor/mdx-execution-plan.ts
+function planMdxCompileExecution(options) {
+  if (options.enableCodeHighlight !== false) {
+    return {
+      target: "main-thread",
+      reason: "code-highlighting-not-worker-safe"
+    };
+  }
+  if (options.extraRemarkPlugins?.length) {
+    return {
+      target: "main-thread",
+      reason: "extra-remark-plugins-not-worker-safe"
+    };
+  }
+  if (options.extraRehypePlugins?.length) {
+    return {
+      target: "main-thread",
+      reason: "extra-rehype-plugins-not-worker-safe"
+    };
+  }
+  if (options.extraRemarkDescriptors?.length && !allWorkerSafeBuiltinDescriptors(options.extraRemarkDescriptors)) {
+    return {
+      target: "main-thread",
+      reason: "extra-remark-descriptors-not-worker-safe"
+    };
+  }
+  if (options.extraRehypeDescriptors?.length && !allWorkerSafeBuiltinDescriptors(options.extraRehypeDescriptors)) {
+    return {
+      target: "main-thread",
+      reason: "extra-rehype-descriptors-not-worker-safe"
+    };
+  }
+  return {
+    target: "worker",
+    reason: "worker-safe"
+  };
+}
+
 // src/processor/index.ts
 var DEFAULT_CODE_THEME = "vitesse-light";
 function buildRemarkPlugins(options) {
@@ -1515,23 +3383,27 @@ function buildRemarkPlugins(options) {
   const enableSideAnnotation = options.enableSideAnnotation !== false;
   const enableMarkdownSandbox = options.enableMarkdownSandbox !== false;
   const plugins = [
-    remarkParse,
-    remarkGfm
+    options.canonicalDocument == null ? remarkParse2 : createCanonicalDocumentParser(options.canonicalDocument, options),
+    remarkGfm2
   ];
   if (enableMath) {
-    plugins.push(remarkMath);
+    plugins.push(remarkMath2);
     plugins.push(remarkNormalizeStandaloneMath);
   }
-  plugins.push(remarkDirective);
+  plugins.push(remarkDirective2);
+  plugins.push([remarkOwoComponents, {
+    enabled: options.enableComponents !== false
+  }]);
   if (options.mode !== "preview") {
     if (enableSideAnnotation) {
       plugins.push(remarkMicromarkSideAnnotation);
     }
-    plugins.push(remarkMdx);
+    plugins.push(remarkMdx2);
   }
   if (!options.preserveSoftLineBreaks) {
     plugins.push(remarkConvertSoftBreaksToHardBreaks);
   }
+  plugins.push(remarkCodeBlockMetadata);
   if (enableSideAnnotation) {
     plugins.push(remarkSideAnnotation);
   }
@@ -1541,11 +3413,29 @@ function buildRemarkPlugins(options) {
       createProcessor: createOwoMarkProcessor
     }]);
   }
+  if (options.sourceAnchors) {
+    plugins.push([remarkMdxSourceLines, {
+      sourceMap: options.mdxSourceMap
+    }]);
+  }
+  if (options.extraRemarkDescriptors?.length) {
+    plugins.push(...resolveDescriptors(options.extraRemarkDescriptors));
+  }
   if (options.extraRemarkPlugins) {
     plugins.push(...options.extraRemarkPlugins);
   }
   return plugins;
 }
+function createCanonicalDocumentParser(document, options) {
+  return function canonicalDocumentParser() {
+    this.parser = () => buildRootFromDocument(document, {
+      enableSideAnnotation: options.enableSideAnnotation,
+      enableMath: options.enableMath,
+      enableComponents: options.enableComponents,
+      sourceMap: options.sourceMap
+    });
+  };
+}
 function buildRehypePlugins(options) {
   const enableMath = options.enableMath !== false;
   const enableSideAnnotation = options.enableSideAnnotation !== false;
@@ -1554,10 +3444,19 @@ function buildRehypePlugins(options) {
   if (enableMath) {
     plugins.push(rehypeKatex, rehypeMathDisplayFix);
   }
-  plugins.push(rehypeSlug, [rehypePrettyCode, { theme }]);
+  plugins.push(rehypeSlug);
+  if (options.enableCodeHighlight !== false) {
+    plugins.push([rehypePrettyCode, { theme }]);
+  }
   if (enableSideAnnotation) {
     plugins.push(rehypeSideAnnotation);
   }
+  if (options.sourceAnchors) {
+    plugins.push(rehypeSourceLines);
+  }
+  if (options.extraRehypeDescriptors?.length) {
+    plugins.push(...resolveDescriptors(options.extraRehypeDescriptors));
+  }
   if (options.extraRehypePlugins) {
     plugins.push(...options.extraRehypePlugins);
   }
@@ -1575,43 +3474,69 @@ function createOwoMarkProcessor(options) {
   return createUnifiedProcessor(opts);
 }
 function createUnifiedProcessor(opts) {
-  const remarkPlugins = buildRemarkPlugins(opts);
   const rehypePlugins = buildRehypePlugins(opts);
-  let proc = unified();
-  for (const plugin of remarkPlugins) {
-    proc = applyPlugin(proc, plugin);
-  }
-  proc = proc.use(remarkRehype, {
-    handlers: {
-      markdownSandbox: markdownSandboxHandler
-    }
-  });
-  for (const plugin of rehypePlugins) {
-    proc = applyPlugin(proc, plugin);
-  }
-  proc = proc.use(rehypeStringify, { allowDangerousHtml: true });
   return {
     async process(source) {
-      const result = await proc.process(source);
+      const normalized = normalizeOwoMarkSource(source, { enableMath: opts.enableMath });
+      const canonicalDocument = opts.canonicalDocument ?? parseMarkdownToDocument2(normalized.source);
+      const remarkPlugins = buildRemarkPlugins({
+        ...opts,
+        canonicalDocument,
+        sourceMap: normalized.sourceMap
+      });
+      let runtimeProc = unified2();
+      for (const plugin of remarkPlugins) {
+        runtimeProc = applyPlugin2(runtimeProc, plugin);
+      }
+      runtimeProc = runtimeProc.use(remarkRehype, {
+        handlers: {
+          markdownSandbox: markdownSandboxHandler,
+          owoComponentRendered: owoComponentRenderedHandler
+        }
+      });
+      for (const plugin of rehypePlugins) {
+        runtimeProc = applyPlugin2(runtimeProc, plugin);
+      }
+      runtimeProc = runtimeProc.use(rehypeStringify, { allowDangerousHtml: true });
+      const result = await runtimeProc.process(normalized.source);
       return { value: String(result), toString: () => String(result) };
     }
   };
 }
-var FENCED_CODE_RE = /^```[\s\S]*?^```/gm;
-var INLINE_CODE_RE = /`[^`]+`/g;
-var JSX_TAG_RE = /<([A-Z][A-Za-z0-9]*)/g;
-function extractComponentNames(source) {
-  const stripped = source.replace(FENCED_CODE_RE, "").replace(INLINE_CODE_RE, "");
-  const names = /* @__PURE__ */ new Set();
-  let match;
-  while ((match = JSX_TAG_RE.exec(stripped)) !== null) {
-    names.add(match[1]);
-  }
-  return names;
-}
 function createMdxProcessor(opts) {
-  const { remarkPlugins, rehypePlugins } = getOwoMarkPlugins({ ...opts, mode: "production" });
   const registeredComponents = { ...DEFAULT_MDX_COMPONENTS, ...opts.mdxComponents };
+  const createMissingComponent = (componentName) => (props) => {
+    const { children, ...restProps } = props;
+    return _react.createElement("div", { "data-mdx-missing": componentName, ...restProps }, children);
+  };
+  function registerMissingComponentPath(componentMap, componentName) {
+    const parts = componentName.split(".");
+    let cursor = componentMap;
+    let inserted = false;
+    for (let index = 0; index < parts.length; index += 1) {
+      const part = parts[index];
+      const isLeaf = index === parts.length - 1;
+      const existing = cursor[part];
+      if (isLeaf) {
+        if (existing === void 0) {
+          cursor[part] = createMissingComponent(componentName);
+          inserted = true;
+        }
+        return inserted;
+      }
+      if (existing == null) {
+        cursor[part] = {};
+        inserted = true;
+        cursor = cursor[part];
+        continue;
+      }
+      if (typeof existing === "function") {
+        return inserted;
+      }
+      cursor = existing;
+    }
+    return inserted;
+  }
   let _evaluate;
   let _renderToStaticMarkup;
   let _jsxRuntime;
@@ -1633,19 +3558,33 @@ function createMdxProcessor(opts) {
   return {
     async process(source) {
       await ensureImports();
-      const usedNames = extractComponentNames(source);
+      const inspection = inspectMdxSource(source, {
+        enableMath: opts.enableMath,
+        enableSideAnnotation: opts.enableSideAnnotation,
+        extraRemarkDescriptors: opts.extraRemarkDescriptors,
+        extraRemarkPlugins: opts.extraRemarkPlugins
+      });
+      const { remarkPlugins, rehypePlugins } = getOwoMarkPlugins({
+        ...opts,
+        mode: "production",
+        mdxSourceMap: inspection.sourceMap
+      });
       const componentMap = { ...registeredComponents };
-      for (const name of usedNames) {
-        if (!(name in componentMap)) {
+      for (const name of inspection.componentNames) {
+        if (registerMissingComponentPath(componentMap, name)) {
           console.warn(`[owomark-mdx] Unregistered MDX component: <${name}>`);
-          componentMap[name] = (props) => _react.createElement("div", { "data-mdx-missing": name }, props.children);
         }
       }
-      const { default: Content } = await _evaluate(source, {
-        ..._jsxRuntime,
-        remarkPlugins,
-        rehypePlugins
-      });
+      let Content;
+      try {
+        ({ default: Content } = await _evaluate(inspection.compileSource, {
+          ..._jsxRuntime,
+          remarkPlugins,
+          rehypePlugins
+        }));
+      } catch (error) {
+        throw remapMdxErrorDetails(error, inspection.sourceMap);
+      }
       const html = _renderToStaticMarkup(
         _react.createElement(Content, { components: componentMap })
       );
@@ -1653,14 +3592,14 @@ function createMdxProcessor(opts) {
     }
   };
 }
-function applyPlugin(proc, entry) {
+function applyPlugin2(proc, entry) {
   if (Array.isArray(entry)) {
     const [plugin, ...args] = entry;
     return proc.use(plugin, ...args);
   }
   return proc.use(entry);
 }
-var MDX_MANAGED_REMARK_PLUGINS = /* @__PURE__ */ new Set([remarkParse, remarkMdx]);
+var MDX_MANAGED_REMARK_PLUGINS = /* @__PURE__ */ new Set([remarkParse2, remarkMdx2]);
 function getOwoMarkPlugins(options) {
   const opts = {
     mode: "production",
@@ -1674,20 +3613,41 @@ function getOwoMarkPlugins(options) {
   return { remarkPlugins, rehypePlugins };
 }
 export {
+  COMPONENT_REGISTRY,
   Callout,
   CodeDemo,
+  CodeTab,
   DEFAULT_MDX_COMPONENTS,
+  Details,
   FileTree,
   Kbd,
+  LinkCard,
+  Note,
   Step,
   Steps,
   Tab,
   Tabs,
+  allBuiltinDescriptors,
+  allWorkerSafeBuiltinDescriptors,
+  analyzeMdxSyntax,
   createOwoMarkProcessor,
+  detectMdxSyntax,
+  getComponentEntry,
   getOwoMarkPlugins,
+  inspectMdxSource,
+  isKnownDirective,
+  isWorkerSafeBuiltinDescriptor,
+  owoComponentRenderedHandler,
+  planMdxCompileExecution,
+  registerPlugin,
   rehypeMathDisplayFix,
   rehypeSideAnnotation,
+  rehypeSourceLines,
+  remapMdxErrorDetails,
+  remarkCodeBlockMetadata,
   remarkConvertSoftBreaksToHardBreaks,
   remarkMicromarkSideAnnotation,
-  remarkSideAnnotation
+  remarkOwoComponents,
+  remarkSideAnnotation,
+  resolveDescriptors
 };