@owomark/processor 0.1.5 → 0.1.6

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() {
@@ -1343,72 +1343,276 @@ function markdownSandboxHandler(_state, node) {
   };
 }
 
+// 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) {
+  if (typeof line !== "number" || !sourceMap?.segments.length) return line;
+  let delta = 0;
+  for (const segment of sourceMap.segments) {
+    if (line < segment.normalizedStartLine) {
+      break;
+    }
+    if (line <= segment.normalizedEndLine) {
+      if (line === segment.normalizedStartLine) return segment.sourceStartLine;
+      if (line === segment.normalizedEndLine) return segment.sourceEndLine;
+      return segment.sourceStartLine + (line - segment.normalizedStartLine - 1);
+    }
+    delta += segment.normalizedEndLine - segment.normalizedStartLine + 1 - (segment.sourceEndLine - segment.sourceStartLine + 1);
+  }
+  return line - delta;
+}
+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"
+]);
+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.includes("katex-display") || classes.includes("math-display")) {
+        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", rehypeSourceLines]
+]);
+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 resolveDescriptors(descriptors) {
+  return descriptors.map((d) => {
+    const plugin = BUILTIN_PLUGINS.get(d.name) ?? 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/steps.ts
-import { createElement as createElement3, Children } from "react";
-function Steps({ children }) {
+import { createElement as createElement4, 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 createElement4(
     "div",
-    { className: "mdx-steps" },
+    {
+      ...domProps,
+      className: mergeClassName("mdx-steps", className)
+    },
     items.map(
-      (item, i) => createElement3(
+      (item, i) => createElement4(
         "div",
         { className: "mdx-steps-item", key: i },
-        createElement3(
+        createElement4(
           "div",
           { className: "mdx-steps-indicator" },
-          createElement3("span", { className: "mdx-steps-number" }, String(i + 1)),
-          i < items.length - 1 && createElement3("div", { className: "mdx-steps-line" })
+          createElement4("span", { className: "mdx-steps-number" }, String(i + 1)),
+          i < items.length - 1 && createElement4("div", { className: "mdx-steps-line" })
         ),
-        createElement3("div", { className: "mdx-steps-content" }, item)
+        createElement4("div", { className: "mdx-steps-content" }, item)
       )
     )
   );
 }
-function Step({ title, children }) {
-  return createElement3(
+function Step({ title, children, className, ...domProps }) {
+  return createElement4(
     "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 && createElement4("h4", { className: "mdx-step-title" }, title),
+    children && createElement4("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 createElement5, 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,37 +1620,47 @@ function Tabs({ children }) {
     }
   });
   const groupId = `mdx-tabs-${Math.random().toString(36).slice(2, 8)}`;
-  return createElement4(
+  return createElement5(
     "div",
-    { className: "mdx-tabs" },
-    createElement4(
+    {
+      ...domProps,
+      className: mergeClassName("mdx-tabs", className)
+    },
+    createElement5(
       "div",
       { className: "mdx-tabs-list", role: "tablist" },
       tabs.map(
-        (tab, i) => createElement4(
+        (tab, i) => createElement5(
           "label",
           { className: "mdx-tabs-trigger", key: i },
-          createElement4("input", {
+          createElement5("input", {
             type: "radio",
             name: groupId,
             className: "mdx-tabs-radio",
             defaultChecked: i === 0
           }),
-          createElement4("span", null, tab.label)
+          createElement5("span", null, tab.label)
         )
       )
     ),
     tabs.map(
-      (tab, i) => createElement4("div", { className: "mdx-tabs-panel", key: i }, tab.content)
+      (tab, i) => createElement5("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 createElement5(
+    "div",
+    {
+      ...domProps,
+      className
+    },
+    children
+  );
 }
 
 // src/mdx-components/file-tree.ts
-import { createElement as createElement5 } from "react";
+import { createElement as createElement6 } from "react";
 function parseFileTree(text) {
   const entries = [];
   for (const line of text.split("\n")) {
@@ -1460,22 +1674,25 @@ function parseFileTree(text) {
   }
   return entries;
 }
-function FileTree({ children }) {
+function FileTree({ children, className, ...domProps }) {
   const text = extractText(children);
   const entries = parseFileTree(text);
-  return createElement5(
+  return createElement6(
     "div",
-    { className: "mdx-file-tree" },
+    {
+      ...domProps,
+      className: mergeClassName("mdx-file-tree", className)
+    },
     entries.map(
-      (entry, i) => createElement5(
+      (entry, i) => createElement6(
         "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)
+        createElement6("span", { className: "mdx-file-tree-icon" }, entry.isDir ? "\u{1F4C1}" : "\u{1F4C4}"),
+        createElement6("span", { className: "mdx-file-tree-name" }, entry.name)
       )
     )
   );
@@ -1491,14 +1708,22 @@ 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 createElement7 } from "react";
+function Kbd({ children, className, ...domProps }) {
+  return createElement7(
+    "kbd",
+    {
+      ...domProps,
+      className: mergeClassName("mdx-kbd", className)
+    },
+    children
+  );
 }
 
 // src/mdx-components/index.ts
 var DEFAULT_MDX_COMPONENTS = {
   Callout,
+  Note,
   CodeDemo,
   Steps,
   Step,
@@ -1508,6 +1733,324 @@ 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);
+          rewrites.push({
+            startLine,
+            endLine,
+            replacementLines: [
+              `${prefix}${fence}`,
+              ...normalizedLines.map((line) => `${prefix}${line}`),
+              `${prefix}${fence}`
+            ],
+            preservedPrefixColumns,
+            removedIndentColumns: 4
+          });
+        }
+      }
+    }
+    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 buildCompilePlan(source, rewrites) {
+  if (rewrites.length === 0) {
+    return {
+      compileSource: source,
+      sourceMap: { segments: [] }
+    };
+  }
+  const sourceLines = source.split("\n");
+  const outputLines = [];
+  const segments = [];
+  let lineNumber = 1;
+  let rewriteIndex = 0;
+  while (lineNumber <= sourceLines.length) {
+    const rewrite = rewrites[rewriteIndex];
+    if (rewrite && rewrite.startLine === lineNumber) {
+      const normalizedStartLine = outputLines.length + 1;
+      outputLines.push(...rewrite.replacementLines);
+      const normalizedEndLine = outputLines.length;
+      segments.push({
+        kind: "indented-code",
+        normalizedStartLine,
+        normalizedEndLine,
+        sourceStartLine: rewrite.startLine,
+        sourceEndLine: rewrite.endLine,
+        preservedPrefixColumns: rewrite.preservedPrefixColumns,
+        removedIndentColumns: rewrite.removedIndentColumns
+      });
+      lineNumber = rewrite.endLine + 1;
+      rewriteIndex += 1;
+      continue;
+    }
+    outputLines.push(sourceLines[lineNumber - 1]);
+    lineNumber += 1;
+  }
+  const normalizedSource = outputLines.join("\n");
+  return {
+    compileSource: source.endsWith("\n") ? `${normalizedSource}
+` : normalizedSource,
+    sourceMap: { segments }
+  };
+}
+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 markdownTree = parseMarkdownTree(source, options);
+    const rewrites = collectIndentedCodeRewrites(source, markdownTree);
+    const { compileSource, sourceMap } = buildCompilePlan(source, rewrites);
+    const mdxProbeSource = buildMaskedSource(compileSource, parseMarkdownTree(compileSource, options));
+    const mdxTree = createParser("production", options).use(remarkMdx).parse(mdxProbeSource);
+    const { reason, componentNames } = collectMdxSyntaxMetadata(mdxTree);
+    return {
+      hasMdxSyntax: reason !== void 0,
+      reason,
+      componentNames,
+      compileSource,
+      sourceMap
+    };
+  } catch {
+    return {
+      hasMdxSyntax: true,
+      reason: "parse-failed-fallback",
+      componentNames: [],
+      compileSource: source,
+      sourceMap: { segments: [] }
+    };
+  }
+}
+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) {
+  if (typeof line !== "number" || !sourceMap?.segments.length) return line;
+  let delta = 0;
+  for (const segment of sourceMap.segments) {
+    if (line < segment.normalizedStartLine) {
+      break;
+    }
+    if (line <= segment.normalizedEndLine) {
+      if (line === segment.normalizedStartLine) return segment.sourceStartLine;
+      if (line === segment.normalizedEndLine) return segment.sourceEndLine;
+      return segment.sourceStartLine + (line - segment.normalizedStartLine - 1);
+    }
+    delta += segment.normalizedEndLine - segment.normalizedStartLine + 1 - (segment.sourceEndLine - segment.sourceStartLine + 1);
+  }
+  return line - delta;
+}
+function remapMdxColumnNumber(line, column, sourceMap) {
+  if (typeof line !== "number" || typeof column !== "number" || !sourceMap?.segments.length) {
+    return column;
+  }
+  for (const segment of sourceMap.segments) {
+    if (line < segment.normalizedStartLine) break;
+    if (line > segment.normalizedEndLine) continue;
+    if (line === segment.normalizedStartLine || line === segment.normalizedEndLine) {
+      return segment.preservedPrefixColumns + 1;
+    }
+    if (column <= segment.preservedPrefixColumns) {
+      return column;
+    }
+    return column + segment.removedIndentColumns;
+  }
+  return column;
+}
+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
 var DEFAULT_CODE_THEME = "vitesse-light";
 function buildRemarkPlugins(options) {
@@ -1515,19 +2058,19 @@ function buildRemarkPlugins(options) {
   const enableSideAnnotation = options.enableSideAnnotation !== false;
   const enableMarkdownSandbox = options.enableMarkdownSandbox !== false;
   const plugins = [
-    remarkParse,
-    remarkGfm
+    remarkParse2,
+    remarkGfm2
   ];
   if (enableMath) {
-    plugins.push(remarkMath);
+    plugins.push(remarkMath2);
     plugins.push(remarkNormalizeStandaloneMath);
   }
-  plugins.push(remarkDirective);
+  plugins.push(remarkDirective2);
   if (options.mode !== "preview") {
     if (enableSideAnnotation) {
       plugins.push(remarkMicromarkSideAnnotation);
     }
-    plugins.push(remarkMdx);
+    plugins.push(remarkMdx2);
   }
   if (!options.preserveSoftLineBreaks) {
     plugins.push(remarkConvertSoftBreaksToHardBreaks);
@@ -1541,6 +2084,14 @@ 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);
   }
@@ -1554,10 +2105,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);
   }
@@ -1577,9 +2137,9 @@ function createOwoMarkProcessor(options) {
 function createUnifiedProcessor(opts) {
   const remarkPlugins = buildRemarkPlugins(opts);
   const rehypePlugins = buildRehypePlugins(opts);
-  let proc = unified();
+  let proc = unified2();
   for (const plugin of remarkPlugins) {
-    proc = applyPlugin(proc, plugin);
+    proc = applyPlugin2(proc, plugin);
   }
   proc = proc.use(remarkRehype, {
     handlers: {
@@ -1587,7 +2147,7 @@ function createUnifiedProcessor(opts) {
     }
   });
   for (const plugin of rehypePlugins) {
-    proc = applyPlugin(proc, plugin);
+    proc = applyPlugin2(proc, plugin);
   }
   proc = proc.use(rehypeStringify, { allowDangerousHtml: true });
   return {
@@ -1597,21 +2157,40 @@ function createUnifiedProcessor(opts) {
     }
   };
 }
-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 +2212,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 +2246,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",
@@ -1679,15 +2272,24 @@ export {
   DEFAULT_MDX_COMPONENTS,
   FileTree,
   Kbd,
+  Note,
   Step,
   Steps,
   Tab,
   Tabs,
+  allBuiltinDescriptors,
+  analyzeMdxSyntax,
   createOwoMarkProcessor,
+  detectMdxSyntax,
   getOwoMarkPlugins,
+  inspectMdxSource,
+  registerPlugin,
   rehypeMathDisplayFix,
   rehypeSideAnnotation,
+  rehypeSourceLines,
+  remapMdxErrorDetails,
   remarkConvertSoftBreaksToHardBreaks,
   remarkMicromarkSideAnnotation,
-  remarkSideAnnotation
+  remarkSideAnnotation,
+  resolveDescriptors
 };