@luckyfishes/markdown-core 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# `@luckyfishes/markdown-core`
+
+Reusable Markdown/MDX parsing and AST transformation utilities extracted from `noname_blog`.
+
+This package only handles syntax parsing and AST transforms. It does not ship React components, styles, or framework-specific rendering glue.
+
+## Included
+
+- Custom block syntax like `::tabs`, `::details`, and `::ComponentName`
+- Inline component syntax like `:badge[...]()` and `:tip[...]()`
+- Superscript and subscript transforms
+- Code fence to MDX component transforms
+- Footnotes heading normalization
+- Heading extraction helpers
+
+## Not Included
+
+- React component implementations
+- MDX runtime rendering
+- Next.js integration
+- CSS styles

package/dist/index.d.ts

@@ -0,0 +1,140 @@
+import { PluggableList } from 'unified';
+import { RootContent, Text, Root } from 'mdast';
+
+declare const FOOTNOTES_HEADING_TEXT = "Footnotes";
+declare const FOOTNOTES_HEADING_ID = "footnote-label";
+type FootnotesOptions = {
+    headingId?: string;
+    headingText?: string;
+};
+
+type HastNode$1 = {
+    type: string;
+    tagName?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode$1[];
+    value?: string;
+};
+type CodeFenceComponentMapping = {
+    componentName: string;
+    propName: string;
+};
+type CodeFenceComponentMappings = Record<string, CodeFenceComponentMapping>;
+declare const DEFAULT_CODE_FENCE_COMPONENT_MAPPINGS: CodeFenceComponentMappings;
+declare function createCodeFenceComponentPlugin(mappings?: CodeFenceComponentMappings): (tree: HastNode$1) => void;
+
+type NodeWithPosition = {
+    position?: {
+        start?: {
+            line?: number;
+            offset?: number;
+        };
+        end?: {
+            line?: number;
+            offset?: number;
+        };
+    };
+};
+type FlowNode = RootContent & NodeWithPosition;
+type CustomSyntaxComponentNames = {
+    badge: string;
+    tip: string;
+    tabs: string;
+    tabsList: string;
+    tabsTrigger: string;
+    tabsContent: string;
+};
+type CustomSyntaxOptions = {
+    componentNames?: Partial<CustomSyntaxComponentNames>;
+};
+declare const DEFAULT_CUSTOM_SYNTAX_COMPONENT_NAMES: CustomSyntaxComponentNames;
+declare function resolveCustomSyntaxComponentNames(options?: CustomSyntaxOptions): CustomSyntaxComponentNames;
+type BlockHandlerKind = "block" | "container";
+type BlockHandlerMatchContext = {
+    children: FlowNode[];
+    componentNames: CustomSyntaxComponentNames;
+    getNodeSource: (node: NodeWithPosition) => string;
+    index: number;
+    source: string;
+    lines: string[];
+};
+type BlockHandlerTransformContext = BlockHandlerMatchContext & {
+    consumeThroughLine: (endLine: number) => number;
+    createFlowElement: (name: string, props?: Record<string, unknown>, children?: RootContent[]) => RootContent;
+    createInlineTextElement: (name: string, props?: Record<string, unknown>, text?: string) => RootContent;
+    createText: (value: string) => Text;
+    getLine: (lineNumber: number) => string;
+    getNodeSource: (node: NodeWithPosition) => string;
+    parseYamlProps: (yamlSource: string) => Record<string, unknown>;
+    transformFragment: (markdown: string) => RootContent[];
+};
+type BlockHandlerResult = {
+    consumed: number;
+    nodes: RootContent[];
+};
+type CustomSyntaxBlockHandler = {
+    kind: BlockHandlerKind;
+    match: (context: BlockHandlerMatchContext) => boolean;
+    name: string;
+    priority?: number;
+    transform: (context: BlockHandlerTransformContext) => BlockHandlerResult;
+};
+type InlineHandlerContext = {
+    componentNames: CustomSyntaxComponentNames;
+    createInlineTextElement: (name: string, props?: Record<string, unknown>, text?: string) => RootContent;
+    createText: (value: string) => Text;
+    getNodeSource: (node: NodeWithPosition) => string;
+    source: string;
+};
+type CustomSyntaxInlineHandler = {
+    kind: "inline";
+    match: (nodes: RootContent[], index: number, context: InlineHandlerContext) => boolean;
+    name: string;
+    priority?: number;
+    transform: (nodes: RootContent[], index: number, context: InlineHandlerContext) => {
+        consumed: number;
+        nodes: RootContent[];
+    };
+};
+
+type MarkdownPresetOptions = {
+    codeFenceMappings?: CodeFenceComponentMappings;
+    customSyntax?: CustomSyntaxOptions;
+    footnotes?: FootnotesOptions;
+};
+type MarkdownPreset = {
+    remarkPlugins: PluggableList;
+    rehypePlugins: PluggableList;
+};
+declare function createMarkdownPreset(options?: MarkdownPresetOptions): MarkdownPreset;
+
+type HastNode = {
+    type: string;
+    tagName?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+    value?: string;
+};
+declare function rehypeFootnotesHeading(options?: FootnotesOptions): (tree: HastNode) => void;
+
+declare function createCustomSyntaxRemarkPlugin(options?: CustomSyntaxOptions): (tree: Root, file?: {
+    value?: unknown;
+}) => void;
+
+declare const YAML_PROP_PREFIX = "__YAML__";
+
+type MdastNode = {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+};
+declare function remarkSuperSub(): (tree: MdastNode) => void;
+
+type MarkdownHeading = {
+    depth: 1 | 2 | 3;
+    text: string;
+    id: string;
+};
+declare function extractHeadings(markdown: string, options?: FootnotesOptions): MarkdownHeading[];
+
+export { type CodeFenceComponentMapping, type CodeFenceComponentMappings, type CustomSyntaxBlockHandler, type CustomSyntaxComponentNames, type CustomSyntaxInlineHandler, type CustomSyntaxOptions, DEFAULT_CODE_FENCE_COMPONENT_MAPPINGS, DEFAULT_CUSTOM_SYNTAX_COMPONENT_NAMES, FOOTNOTES_HEADING_ID, FOOTNOTES_HEADING_TEXT, type FlowNode, type FootnotesOptions, type MarkdownHeading, type MarkdownPreset, type MarkdownPresetOptions, type NodeWithPosition, YAML_PROP_PREFIX, createCodeFenceComponentPlugin, createCustomSyntaxRemarkPlugin, createMarkdownPreset, extractHeadings, rehypeFootnotesHeading, remarkSuperSub, resolveCustomSyntaxComponentNames };

package/dist/index.js

@@ -0,0 +1,1148 @@
+// src/footnotes.ts
+var FOOTNOTES_HEADING_TEXT = "Footnotes";
+var FOOTNOTES_HEADING_ID = "footnote-label";
+function resolveFootnotesHeadingDepth(depths) {
+  return depths.includes(1) ? 1 : 2;
+}
+
+// src/preset.ts
+import remarkGfm2 from "remark-gfm";
+
+// src/rehype/code-fence-components.ts
+import { visit } from "unist-util-visit";
+var DEFAULT_CODE_FENCE_COMPONENT_MAPPINGS = {
+  chart: { componentName: "ChartBlock", propName: "spec" },
+  mermaid: { componentName: "MermaidDiagram", propName: "chart" },
+  music: { componentName: "MusicScore", propName: "score" }
+};
+function hasLanguage(node, language) {
+  const className = node.properties?.className;
+  const targetClass = `language-${language}`;
+  if (typeof className === "string") {
+    return className.split(/\s+/).includes(targetClass);
+  }
+  if (Array.isArray(className)) {
+    return className.some((name) => `${name}` === targetClass);
+  }
+  return false;
+}
+function extractText(node) {
+  if (node.type === "text") {
+    return node.value ?? "";
+  }
+  if (!node.children || node.children.length === 0) {
+    return "";
+  }
+  return node.children.map((child) => extractText(child)).join("");
+}
+function createCodeFenceComponentPlugin(mappings = DEFAULT_CODE_FENCE_COMPONENT_MAPPINGS) {
+  const resolvedMappings = {
+    ...DEFAULT_CODE_FENCE_COMPONENT_MAPPINGS,
+    ...mappings
+  };
+  return (tree) => {
+    visit(
+      tree,
+      "element",
+      (node, index, parent) => {
+        if (!parent || typeof index !== "number") {
+          return;
+        }
+        if (node.tagName !== "pre") {
+          return;
+        }
+        const [codeNode] = node.children ?? [];
+        if (!codeNode || codeNode.type !== "element" || codeNode.tagName !== "code") {
+          return;
+        }
+        const match = Object.entries(resolvedMappings).find(
+          ([language2]) => hasLanguage(codeNode, language2)
+        );
+        if (!match) {
+          return;
+        }
+        const [language, mapping] = match;
+        const value = extractText(codeNode).trim();
+        parent.children = parent.children ?? [];
+        parent.children[index] = {
+          type: "element",
+          tagName: mapping.componentName,
+          properties: {
+            [mapping.propName]: value,
+            "data-language": language
+          },
+          children: []
+        };
+      }
+    );
+  };
+}
+
+// src/rehype/footnotes-heading.ts
+import { visit as visit2 } from "unist-util-visit";
+function hasFootnotesSection(node) {
+  return node.tagName === "section" && Object.prototype.hasOwnProperty.call(node.properties ?? {}, "dataFootnotes");
+}
+function removeSrOnlyClass(className) {
+  if (typeof className === "string") {
+    return className.split(/\s+/).filter((name) => name && name !== "sr-only");
+  }
+  if (Array.isArray(className)) {
+    return className.filter((name) => `${name}` !== "sr-only");
+  }
+  return className;
+}
+function isHeadingTag(tagName) {
+  return tagName === "h1" || tagName === "h2" || tagName === "h3";
+}
+function resolveHeadingTagName(tree) {
+  const depths = [];
+  visit2(tree, "element", (node) => {
+    if (!isHeadingTag(node.tagName)) {
+      return;
+    }
+    const depth = Number(node.tagName.slice(1));
+    if (!Number.isNaN(depth)) {
+      depths.push(depth);
+    }
+  });
+  return `h${resolveFootnotesHeadingDepth(depths)}`;
+}
+function createHeadingNode(tagName, headingId, headingText) {
+  return {
+    type: "element",
+    tagName,
+    properties: {
+      id: headingId
+    },
+    children: [
+      {
+        type: "text",
+        value: headingText
+      }
+    ]
+  };
+}
+function rehypeFootnotesHeading(options) {
+  const headingId = options?.headingId ?? FOOTNOTES_HEADING_ID;
+  const headingText = options?.headingText ?? FOOTNOTES_HEADING_TEXT;
+  return (tree) => {
+    const headingTagName = resolveHeadingTagName(tree);
+    visit2(tree, "element", (node) => {
+      if (!hasFootnotesSection(node)) {
+        return;
+      }
+      node.children = node.children ?? [];
+      const existingHeading = node.children.find(
+        (child) => child.type === "element" && (child.tagName === "h1" || child.tagName === "h2") && child.properties?.id === headingId
+      );
+      if (existingHeading) {
+        existingHeading.tagName = headingTagName;
+        existingHeading.properties = {
+          ...existingHeading.properties,
+          className: removeSrOnlyClass(existingHeading.properties?.className),
+          id: headingId
+        };
+        existingHeading.children = [
+          {
+            type: "text",
+            value: headingText
+          }
+        ];
+        return;
+      }
+      node.children.unshift(
+        createHeadingNode(headingTagName, headingId, headingText)
+      );
+    });
+  };
+}
+
+// src/remark/custom-syntax/utils.ts
+import matter from "gray-matter";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+var YAML_PROP_PREFIX = "__YAML__";
+var YAML_BODY_SPLIT_RE = /^---\s*$/;
+var COMPONENT_START_RE = /^::([A-Za-z][A-Za-z0-9_]*)\s*$/;
+var DETAILS_START_RE = /^::\s*details(?:\s+(\[open\]))?(?:\s+(.*\S))?\s*$/i;
+var DOUBLE_BLOCK_START_RE = /^::(?:[A-Za-z][A-Za-z0-9_]*|\s+details(?:\s+.*)?)\s*$/i;
+var BLOCK_END_RE = /^::\s*$/;
+var LEGACY_COMPONENT_RE = /<(AreaChart|ChartTooltip|XAxis|GitHubCalendarCard|MermaidDiagram|Card)\b/;
+var LEGACY_CHART_BLOCK_COMPONENTS = /* @__PURE__ */ new Set([
+  "AreaChart",
+  "Area",
+  "Grid",
+  "ChartTooltip",
+  "XAxis"
+]);
+function createSourceLineResult(source) {
+  return {
+    lines: source.split(/\r?\n/)
+  };
+}
+function getLine(lines, lineNumber) {
+  return lines[lineNumber - 1] ?? "";
+}
+function getNodeSource(source, node) {
+  const start = node.position?.start?.offset;
+  const end = node.position?.end?.offset;
+  if (typeof start !== "number" || typeof end !== "number") {
+    return "";
+  }
+  return source.slice(start, end);
+}
+function parseYamlProps(yamlSource) {
+  const trimmed = yamlSource.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const { data } = matter(`---
+${yamlSource}
+---
+`);
+  return data ?? {};
+}
+function escapeHtmlAttr(raw) {
+  return raw.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function serializeAttrValue(value) {
+  if (typeof value === "string") {
+    return escapeHtmlAttr(value);
+  }
+  return `${YAML_PROP_PREFIX}${encodeURIComponent(JSON.stringify(value))}`;
+}
+function createAttribute(name, value) {
+  return {
+    type: "mdxJsxAttribute",
+    name,
+    value: value == null ? null : serializeAttrValue(value)
+  };
+}
+function createText(value) {
+  return {
+    type: "text",
+    value
+  };
+}
+function createFlowElement(name, props = {}, children = []) {
+  const node = {
+    type: "mdxJsxFlowElement",
+    name,
+    attributes: Object.entries(props).map(
+      ([key, value]) => createAttribute(key, value)
+    ),
+    children
+  };
+  return node;
+}
+function createInlineTextElement(name, props = {}, text = "") {
+  const node = {
+    type: "mdxJsxTextElement",
+    name,
+    attributes: Object.entries(props).map(
+      ([key, value]) => createAttribute(key, value)
+    ),
+    children: text ? [createText(text)] : []
+  };
+  return node;
+}
+function parseMarkdownFragment(markdown) {
+  return unified().use(remarkParse).use(remarkGfm).parse(markdown);
+}
+
+// src/remark/custom-syntax/handlers/component-block.ts
+function findBlockEnd(lines, startLine, isNestedStart) {
+  let cursor = startLine + 1;
+  let nestedDepth = 0;
+  let innerFenceMarker = null;
+  while (cursor <= lines.length) {
+    const current = lines[cursor - 1] ?? "";
+    if (innerFenceMarker) {
+      if (current.trimStart().startsWith(innerFenceMarker)) {
+        innerFenceMarker = null;
+      }
+      cursor += 1;
+      continue;
+    }
+    const trimmedCurrent = current.trimStart();
+    if (trimmedCurrent.startsWith("```")) {
+      innerFenceMarker = "```";
+      cursor += 1;
+      continue;
+    }
+    if (trimmedCurrent.startsWith("~~~")) {
+      innerFenceMarker = "~~~";
+      cursor += 1;
+      continue;
+    }
+    if (isNestedStart(current) && !BLOCK_END_RE.test(current)) {
+      nestedDepth += 1;
+      cursor += 1;
+      continue;
+    }
+    if (BLOCK_END_RE.test(current)) {
+      if (nestedDepth === 0) {
+        return cursor;
+      }
+      nestedDepth -= 1;
+    }
+    cursor += 1;
+  }
+  return -1;
+}
+var componentBlockHandler = {
+  kind: "block",
+  match: ({ children, index, getNodeSource: getNodeSource2 }) => {
+    const node = children[index];
+    if (!node) {
+      return false;
+    }
+    const snippet = getNodeSource2(node);
+    const firstLine = snippet.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    return COMPONENT_START_RE.test(firstLine);
+  },
+  name: "component-block",
+  transform: (context) => {
+    const node = context.children[context.index];
+    const startLine = node.position?.start?.line;
+    if (!startLine) {
+      return { consumed: 1, nodes: [node] };
+    }
+    const openingLine = context.getLine(startLine).trim();
+    const componentMatch = openingLine.match(COMPONENT_START_RE);
+    if (!componentMatch) {
+      return { consumed: 1, nodes: [node] };
+    }
+    const componentName = componentMatch[1];
+    if (LEGACY_CHART_BLOCK_COMPONENTS.has(componentName)) {
+      throw new Error(
+        `Legacy chart block syntax "::${componentName}" is not supported. Use \`\`\`chart JSON code blocks instead. (line ${startLine})`
+      );
+    }
+    const endLine = findBlockEnd(
+      context.lines,
+      startLine,
+      (line) => COMPONENT_START_RE.test(line)
+    );
+    if (endLine === -1) {
+      throw new Error(
+        `Unclosed "::${componentName}" block at line ${startLine}`
+      );
+    }
+    const blockLines = context.lines.slice(startLine, endLine - 1);
+    const splitAt = blockLines.findIndex(
+      (line) => YAML_BODY_SPLIT_RE.test(line)
+    );
+    const yamlLines = splitAt === -1 ? blockLines : blockLines.slice(0, splitAt);
+    const bodyLines = splitAt === -1 ? [] : blockLines.slice(splitAt + 1);
+    const props = context.parseYamlProps(yamlLines.join("\n"));
+    const bodyMarkdown = bodyLines.join("\n");
+    const children = bodyMarkdown ? context.transformFragment(bodyMarkdown) : [];
+    return {
+      consumed: context.consumeThroughLine(endLine),
+      nodes: [context.createFlowElement(componentName, props, children)]
+    };
+  }
+};
+
+// src/remark/custom-syntax/handlers/details-block.ts
+function findDetailsEnd(lines, startLine) {
+  let cursor = startLine + 1;
+  let nestedDepth = 0;
+  let innerFenceMarker = null;
+  while (cursor <= lines.length) {
+    const current = lines[cursor - 1] ?? "";
+    if (innerFenceMarker) {
+      if (current.trimStart().startsWith(innerFenceMarker)) {
+        innerFenceMarker = null;
+      }
+      cursor += 1;
+      continue;
+    }
+    const trimmedCurrent = current.trimStart();
+    if (trimmedCurrent.startsWith("```")) {
+      innerFenceMarker = "```";
+      cursor += 1;
+      continue;
+    }
+    if (trimmedCurrent.startsWith("~~~")) {
+      innerFenceMarker = "~~~";
+      cursor += 1;
+      continue;
+    }
+    if (DOUBLE_BLOCK_START_RE.test(current) && !BLOCK_END_RE.test(current)) {
+      nestedDepth += 1;
+      cursor += 1;
+      continue;
+    }
+    if (BLOCK_END_RE.test(current)) {
+      if (nestedDepth === 0) {
+        return cursor;
+      }
+      nestedDepth -= 1;
+    }
+    cursor += 1;
+  }
+  return -1;
+}
+var detailsBlockHandler = {
+  kind: "container",
+  match: ({ children, index, getNodeSource: getNodeSource2 }) => {
+    const node = children[index];
+    if (!node) {
+      return false;
+    }
+    const snippet = getNodeSource2(node);
+    const firstLine = snippet.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    return DETAILS_START_RE.test(firstLine);
+  },
+  name: "details-block",
+  priority: 10,
+  transform: (context) => {
+    const node = context.children[context.index];
+    const startLine = node.position?.start?.line;
+    if (!startLine) {
+      return { consumed: 1, nodes: [node] };
+    }
+    const openingLine = context.getLine(startLine).trim();
+    const detailsMatch = openingLine.match(DETAILS_START_RE);
+    if (!detailsMatch) {
+      return { consumed: 1, nodes: [node] };
+    }
+    const endLine = findDetailsEnd(context.lines, startLine);
+    if (endLine === -1) {
+      throw new Error(`Unclosed ":: details" block at line ${startLine}`);
+    }
+    const bodyMarkdown = context.lines.slice(startLine, endLine - 1).join("\n");
+    const summaryText = detailsMatch[2]?.trim() ?? "";
+    const children = [
+      context.createFlowElement("summary", {}, [
+        context.createText(summaryText || "Details")
+      ]),
+      ...context.transformFragment(bodyMarkdown)
+    ];
+    const props = detailsMatch[1] ? { open: true } : {};
+    return {
+      consumed: context.consumeThroughLine(endLine),
+      nodes: [context.createFlowElement("details", props, children)]
+    };
+  }
+};
+
+// src/remark/custom-syntax/handlers/inline-component.ts
+var INLINE_COMPONENT_DEFINITIONS = {
+  badge: {
+    buildProps: ({ option, params }) => {
+      const shape = params.shape || params.variant || option || "default";
+      return { shape };
+    },
+    resolveComponentName: (context) => context.componentNames.badge
+  },
+  tip: {
+    buildProps: ({ body, option, params }) => ({
+      text: body,
+      tip: params.tip || params.tooltip || params.message || option || "",
+      copy: params.copy === "false" ? false : params.copy ? true : option === "copy" ? true : params.value ? true : false,
+      value: params.value || ""
+    }),
+    resolveComponentName: (context) => context.componentNames.tip
+  }
+};
+function parseInlineComponentParams(option) {
+  const trimmed = option.trim();
+  if (!trimmed) {
+    return {
+      option: trimmed,
+      params: {}
+    };
+  }
+  if (!trimmed.includes("=") && !trimmed.includes(",")) {
+    return {
+      option: trimmed,
+      params: {}
+    };
+  }
+  const params = {};
+  let hasInvalidSegment = false;
+  for (const segment of trimmed.split(",")) {
+    const entry = segment.trim();
+    if (!entry) {
+      continue;
+    }
+    const separatorIndex = entry.indexOf("=");
+    if (separatorIndex === -1) {
+      params[entry] = "true";
+      continue;
+    }
+    const key = entry.slice(0, separatorIndex).trim();
+    const value = entry.slice(separatorIndex + 1).trim();
+    if (!key) {
+      hasInvalidSegment = true;
+      break;
+    }
+    params[key] = value;
+  }
+  if (hasInvalidSegment) {
+    return {
+      option: trimmed,
+      params: {}
+    };
+  }
+  return {
+    option: "",
+    params
+  };
+}
+var INLINE_COMPONENT_RE = /(^|[^\\]):([A-Za-z][A-Za-z0-9_-]*)\[([^\]]*)\]\(([^)]*)\)/g;
+function extractInlineText(children) {
+  return children.map(
+    (child) => child.type === "text" ? typeof child.value === "string" ? child.value : "" : "children" in child ? extractInlineText(child.children) : ""
+  ).join("");
+}
+function buildInlineComponentNode(context, name, body, rawOption) {
+  const definition = INLINE_COMPONENT_DEFINITIONS[name];
+  if (!definition) {
+    return null;
+  }
+  const parsedOption = parseInlineComponentParams(rawOption);
+  return context.createInlineTextElement(
+    definition.resolveComponentName(context),
+    definition.buildProps({
+      body,
+      name,
+      option: parsedOption.option,
+      params: parsedOption.params
+    }),
+    body
+  );
+}
+function isInlineLinkCandidate(node) {
+  return node?.type === "link";
+}
+var inlineComponentHandler = {
+  kind: "inline",
+  match: (nodes, index) => {
+    const current = nodes[index];
+    const next = nodes[index + 1];
+    if (current?.type === "text" && typeof current.value === "string" && /(^|[^\\]):([A-Za-z][A-Za-z0-9_-]*)$/.test(current.value) && isInlineLinkCandidate(next)) {
+      return true;
+    }
+    if (current?.type !== "text" || typeof current.value !== "string") {
+      return false;
+    }
+    INLINE_COMPONENT_RE.lastIndex = 0;
+    return INLINE_COMPONENT_RE.test(current.value);
+  },
+  name: "inline-component",
+  transform: (nodes, index, context) => {
+    const current = nodes[index];
+    const next = nodes[index + 1];
+    if (current?.type !== "text" || typeof current.value !== "string") {
+      return { consumed: 1, nodes: current ? [current] : [] };
+    }
+    const markerMatch = current.value.match(
+      /^(.*?)(?<!\\):([A-Za-z][A-Za-z0-9_-]*)$/
+    );
+    if (markerMatch && isInlineLinkCandidate(next)) {
+      const leadingText = markerMatch[1] ?? "";
+      const name = markerMatch[2];
+      const body = extractInlineText(next.children);
+      const componentNode = buildInlineComponentNode(
+        context,
+        name,
+        body,
+        next.url
+      );
+      if (!componentNode) {
+        return { consumed: 1, nodes: [current] };
+      }
+      return {
+        consumed: 2,
+        nodes: [
+          ...leadingText ? [context.createText(leadingText)] : [],
+          componentNode
+        ]
+      };
+    }
+    const output = [];
+    const source = current.value;
+    let lastIndex = 0;
+    INLINE_COMPONENT_RE.lastIndex = 0;
+    for (const match of source.matchAll(INLINE_COMPONENT_RE)) {
+      const fullMatch = match[0];
+      const prefix = match[1] ?? "";
+      const name = match[2];
+      const body = match[3] ?? "";
+      const rawOption = match[4] ?? "";
+      const start = match.index ?? 0;
+      const matchStart = start + prefix.length;
+      const before = source.slice(lastIndex, matchStart);
+      if (before) {
+        output.push(context.createText(before));
+      }
+      const componentNode = buildInlineComponentNode(
+        context,
+        name,
+        body,
+        rawOption
+      );
+      if (componentNode) {
+        output.push(componentNode);
+      } else {
+        output.push(context.createText(fullMatch.slice(prefix.length)));
+      }
+      lastIndex = start + fullMatch.length;
+    }
+    if (lastIndex < source.length) {
+      output.push(context.createText(source.slice(lastIndex)));
+    }
+    return {
+      consumed: 1,
+      nodes: output.length > 0 ? output : [current]
+    };
+  }
+};
+
+// src/remark/custom-syntax/handlers/legacy-guard.ts
+var legacyGuardBlockHandler = {
+  kind: "block",
+  match: ({ children, index, getNodeSource: getNodeSource2 }) => {
+    const node = children[index];
+    if (!node) {
+      return false;
+    }
+    if (node.type === "html" && typeof node.value === "string" && LEGACY_COMPONENT_RE.test(node.value)) {
+      return true;
+    }
+    const snippet = getNodeSource2(node);
+    const firstLine = snippet.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    const match = firstLine.match(COMPONENT_START_RE);
+    return Boolean(match && LEGACY_CHART_BLOCK_COMPONENTS.has(match[1]));
+  },
+  name: "legacy-guard-block",
+  priority: 100,
+  transform: (context) => {
+    const node = context.children[context.index];
+    const startLine = node?.position?.start?.line ?? context.index + 1;
+    if (node?.type === "html" && typeof node.value === "string" && LEGACY_COMPONENT_RE.test(node.value)) {
+      throw new Error(
+        `Legacy MDX component syntax is not supported. Use "::ComponentName" with YAML props instead. (line ${startLine})`
+      );
+    }
+    const openingLine = context.getLine(startLine).trim();
+    const match = openingLine.match(COMPONENT_START_RE);
+    if (match && LEGACY_CHART_BLOCK_COMPONENTS.has(match[1])) {
+      throw new Error(
+        `Legacy chart block syntax "::${match[1]}" is not supported. Use \`\`\`chart JSON code blocks instead. (line ${startLine})`
+      );
+    }
+    return { consumed: 1, nodes: node ? [node] : [] };
+  }
+};
+
+// src/remark/custom-syntax/handlers/tabs-block.ts
+var TABS_START_RE = /^::tabs\s*$/i;
+function findTabsEnd(lines, startLine) {
+  let cursor = startLine + 1;
+  let nestedDepth = 0;
+  let innerFenceMarker = null;
+  while (cursor <= lines.length) {
+    const current = lines[cursor - 1] ?? "";
+    if (innerFenceMarker) {
+      if (current.trimStart().startsWith(innerFenceMarker)) {
+        innerFenceMarker = null;
+      }
+      cursor += 1;
+      continue;
+    }
+    const trimmedCurrent = current.trimStart();
+    if (trimmedCurrent.startsWith("```")) {
+      innerFenceMarker = "```";
+      cursor += 1;
+      continue;
+    }
+    if (trimmedCurrent.startsWith("~~~")) {
+      innerFenceMarker = "~~~";
+      cursor += 1;
+      continue;
+    }
+    if (TABS_START_RE.test(current)) {
+      nestedDepth += 1;
+      cursor += 1;
+      continue;
+    }
+    if (BLOCK_END_RE.test(current)) {
+      if (nestedDepth === 0) {
+        return cursor;
+      }
+      nestedDepth -= 1;
+    }
+    cursor += 1;
+  }
+  return -1;
+}
+function splitTabSections(value) {
+  const lines = value.split(/\r?\n/);
+  const sections = [];
+  let currentSection = [];
+  let yamlSource = "";
+  let yamlCaptured = false;
+  let inInnerFence = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (inInnerFence) {
+      if (trimmed.startsWith(inInnerFence)) {
+        inInnerFence = null;
+      }
+      currentSection.push(line);
+      continue;
+    }
+    if (trimmed.startsWith("```")) {
+      inInnerFence = "```";
+      currentSection.push(line);
+      continue;
+    }
+    if (trimmed.startsWith("~~~")) {
+      inInnerFence = "~~~";
+      currentSection.push(line);
+      continue;
+    }
+    if (YAML_BODY_SPLIT_RE.test(line)) {
+      if (!yamlCaptured) {
+        yamlSource = currentSection.join("\n");
+        yamlCaptured = true;
+      } else {
+        sections.push(currentSection.join("\n"));
+      }
+      currentSection = [];
+      continue;
+    }
+    currentSection.push(line);
+  }
+  sections.push(currentSection.join("\n"));
+  return {
+    sections,
+    yamlSource
+  };
+}
+var tabsBlockHandler = {
+  kind: "container",
+  match: ({ children, index, getNodeSource: getNodeSource2 }) => {
+    const node = children[index];
+    if (!node) {
+      return false;
+    }
+    const snippet = getNodeSource2(node);
+    const firstLine = snippet.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    return TABS_START_RE.test(firstLine);
+  },
+  name: "tabs-block",
+  priority: 20,
+  transform: (context) => {
+    const node = context.children[context.index];
+    const startLine = node.position?.start?.line;
+    if (!startLine) {
+      return { consumed: 1, nodes: [node] };
+    }
+    const openingLine = context.getLine(startLine).trim();
+    if (!TABS_START_RE.test(openingLine)) {
+      return { consumed: 1, nodes: [node] };
+    }
+    const endLine = findTabsEnd(context.lines, startLine);
+    if (endLine === -1) {
+      throw new Error(`Unclosed "::tabs" block at line ${startLine}`);
+    }
+    const blockLines = context.lines.slice(startLine, endLine - 1);
+    const { sections, yamlSource } = splitTabSections(blockLines.join("\n"));
+    const props = context.parseYamlProps(yamlSource);
+    const labels = Array.isArray(props.tabs) ? props.tabs : [];
+    delete props.tabs;
+    const tabsData = sections.map((section) => section.trim()).filter((section, index) => section.length > 0 || index < labels.length).map((section, index) => ({
+      content: section,
+      label: typeof labels[index] === "string" ? labels[index] : `Tab ${index + 1}`,
+      value: `tab-${index}`
+    }));
+    if (tabsData.length === 0) {
+      return {
+        consumed: context.consumeThroughLine(endLine),
+        nodes: []
+      };
+    }
+    const defaultValue = typeof props.defaultValue === "string" ? props.defaultValue : tabsData[0]?.value ?? "";
+    const tabsProps = { ...props, defaultValue };
+    const tabsListChildren = tabsData.map(
+      (tab) => context.createFlowElement(
+        context.componentNames.tabsTrigger,
+        { value: tab.value },
+        [context.createText(tab.label)]
+      )
+    );
+    const tabsContentChildren = tabsData.map(
+      (tab) => context.createFlowElement(
+        context.componentNames.tabsContent,
+        { value: tab.value },
+        [...context.transformFragment(tab.content)]
+      )
+    );
+    return {
+      consumed: context.consumeThroughLine(endLine),
+      nodes: [
+        context.createFlowElement(context.componentNames.tabs, tabsProps, [
+          context.createFlowElement(
+            context.componentNames.tabsList,
+            {},
+            tabsListChildren
+          ),
+          ...tabsContentChildren
+        ])
+      ]
+    };
+  }
+};
+
+// src/remark/custom-syntax/types.ts
+var DEFAULT_CUSTOM_SYNTAX_COMPONENT_NAMES = {
+  badge: "Badge",
+  tip: "Tip",
+  tabs: "Tabs",
+  tabsList: "TabsList",
+  tabsTrigger: "TabsTrigger",
+  tabsContent: "TabsContent"
+};
+function resolveCustomSyntaxComponentNames(options) {
+  return {
+    ...DEFAULT_CUSTOM_SYNTAX_COMPONENT_NAMES,
+    ...options?.componentNames
+  };
+}
+
+// src/remark/custom-syntax/plugin.ts
+var BLOCK_HANDLERS = [
+  legacyGuardBlockHandler,
+  detailsBlockHandler,
+  tabsBlockHandler,
+  componentBlockHandler
+].sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0));
+var INLINE_HANDLERS = [
+  inlineComponentHandler
+].sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0));
+function isParent(value) {
+  return Boolean(value && typeof value === "object" && "children" in value);
+}
+function isGeneratedMdxNode(value) {
+  const nodeType = value.type;
+  return nodeType === "mdxJsxFlowElement" || nodeType === "mdxJsxTextElement";
+}
+function transformInlineChildren(parent, source, options) {
+  const nextChildren = [];
+  let index = 0;
+  const componentNames = resolveCustomSyntaxComponentNames(options);
+  while (index < parent.children.length) {
+    const handler = INLINE_HANDLERS.find(
+      (candidate) => candidate.match(parent.children, index, {
+        componentNames,
+        createInlineTextElement,
+        createText,
+        getNodeSource: (node) => getNodeSource(source, node),
+        source
+      })
+    );
+    if (!handler) {
+      nextChildren.push(parent.children[index]);
+      index += 1;
+      continue;
+    }
+    const result = handler.transform(parent.children, index, {
+      componentNames,
+      createInlineTextElement,
+      createText,
+      getNodeSource: (node) => getNodeSource(source, node),
+      source
+    });
+    nextChildren.push(...result.nodes);
+    index += result.consumed;
+  }
+  parent.children = nextChildren;
+}
+function transformBlockChildren(parent, source, transformTree2, options) {
+  const { lines } = createSourceLineResult(source);
+  const originalChildren = parent.children;
+  const nextChildren = [];
+  let index = 0;
+  const componentNames = resolveCustomSyntaxComponentNames(options);
+  while (index < originalChildren.length) {
+    const handler = BLOCK_HANDLERS.find(
+      (candidate) => candidate.match({
+        children: originalChildren,
+        componentNames,
+        getNodeSource: (node) => getNodeSource(source, node),
+        index,
+        lines,
+        source
+      })
+    );
+    if (!handler) {
+      nextChildren.push(originalChildren[index]);
+      index += 1;
+      continue;
+    }
+    const result = handler.transform({
+      children: originalChildren,
+      componentNames,
+      index,
+      lines,
+      source,
+      consumeThroughLine: (endLine) => {
+        let cursor = index;
+        while (cursor < originalChildren.length) {
+          const childEndLine = originalChildren[cursor]?.position?.end?.line;
+          if (typeof childEndLine === "number" && childEndLine >= endLine) {
+            return cursor - index + 1;
+          }
+          cursor += 1;
+        }
+        return originalChildren.length - index;
+      },
+      createFlowElement,
+      createInlineTextElement,
+      createText,
+      getLine: (lineNumber) => getLine(lines, lineNumber),
+      getNodeSource: (node) => getNodeSource(source, node),
+      parseYamlProps,
+      transformFragment: (markdown) => {
+        const fragmentTree = parseMarkdownFragment(markdown);
+        return transformTree2(fragmentTree, markdown, options).children;
+      }
+    });
+    nextChildren.push(...result.nodes);
+    index += result.consumed;
+  }
+  parent.children = nextChildren;
+}
+function transformTree(tree, sourceOverride = "", options) {
+  const source = sourceOverride;
+  const walk = (node) => {
+    if (!isParent(node)) {
+      return;
+    }
+    transformBlockChildren(node, source, transformTree, options);
+    transformInlineChildren(node, source, options);
+    for (const child of node.children) {
+      if (isGeneratedMdxNode(child)) {
+        continue;
+      }
+      walk(child);
+    }
+  };
+  walk(tree);
+  return tree;
+}
+function createCustomSyntaxRemarkPlugin(options) {
+  return (tree, file) => {
+    const source = typeof file?.value === "string" ? file.value : "";
+    transformTree(tree, source, options);
+  };
+}
+
+// src/remark/supersub.ts
+function isParent2(node) {
+  return Array.isArray(node.children);
+}
+function isWhitespace(char) {
+  return char !== void 0 && /\s/.test(char);
+}
+function canOpenMarker(value, index, marker) {
+  const previousChar = value[index - 1];
+  const nextChar = value[index + 1];
+  if (!nextChar || isWhitespace(nextChar)) {
+    return false;
+  }
+  if (marker === "~") {
+    return previousChar !== "~" && nextChar !== "~";
+  }
+  return true;
+}
+function isValidWrappedContent(content) {
+  return Boolean(content.trim()) && content.trim() === content;
+}
+function findClosingMarker(value, startIndex, marker) {
+  for (let index = startIndex; index < value.length; index += 1) {
+    if (value[index] !== marker) {
+      continue;
+    }
+    const previousChar = value[index - 1];
+    const nextChar = value[index + 1];
+    if (previousChar === "\\") {
+      continue;
+    }
+    if (marker === "~" && (previousChar === "~" || nextChar === "~")) {
+      continue;
+    }
+    const content = value.slice(startIndex, index);
+    if (isValidWrappedContent(content)) {
+      return index;
+    }
+  }
+  return -1;
+}
+function createTextNode(value) {
+  return { type: "text", value };
+}
+function createWrappedNode(marker, value) {
+  return {
+    type: "mdxJsxTextElement",
+    name: marker === "^" ? "sup" : "sub",
+    attributes: [],
+    children: [{ type: "text", value }]
+  };
+}
+function transformTextNode(value) {
+  const output = [];
+  let buffer = "";
+  let changed = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if ((char === "^" || char === "~") && canOpenMarker(value, index, char)) {
+      const closingIndex = findClosingMarker(value, index + 1, char);
+      if (closingIndex !== -1) {
+        if (buffer) {
+          output.push(createTextNode(buffer));
+          buffer = "";
+        }
+        output.push(
+          createWrappedNode(char, value.slice(index + 1, closingIndex))
+        );
+        index = closingIndex;
+        changed = true;
+        continue;
+      }
+    }
+    buffer += char;
+  }
+  if (!changed) {
+    return null;
+  }
+  if (buffer) {
+    output.push(createTextNode(buffer));
+  }
+  return output;
+}
+function transformNode(node) {
+  if (!isParent2(node)) {
+    return;
+  }
+  const nextChildren = [];
+  for (const child of node.children) {
+    if (child.type === "text" && typeof child.value === "string") {
+      const transformed = transformTextNode(child.value);
+      if (transformed) {
+        nextChildren.push(...transformed);
+        continue;
+      }
+    }
+    transformNode(child);
+    nextChildren.push(child);
+  }
+  node.children = nextChildren;
+}
+function remarkSuperSub() {
+  return (tree) => {
+    transformNode(tree);
+  };
+}
+
+// src/preset.ts
+function createMarkdownPreset(options) {
+  const customSyntaxPlugin = options?.customSyntax ? function customSyntaxPresetPlugin() {
+    return createCustomSyntaxRemarkPlugin(options.customSyntax);
+  } : createCustomSyntaxRemarkPlugin;
+  const codeFencePlugin = options?.codeFenceMappings ? function codeFencePresetPlugin() {
+    return createCodeFenceComponentPlugin(options.codeFenceMappings);
+  } : createCodeFenceComponentPlugin;
+  const footnotesPlugin = options?.footnotes ? function footnotesPresetPlugin() {
+    return rehypeFootnotesHeading(options.footnotes);
+  } : rehypeFootnotesHeading;
+  return {
+    remarkPlugins: [
+      customSyntaxPlugin,
+      [remarkGfm2, { singleTilde: false }],
+      remarkSuperSub
+    ],
+    rehypePlugins: [
+      codeFencePlugin,
+      footnotesPlugin
+    ]
+  };
+}
+
+// src/toc/extract-headings.ts
+import GithubSlugger from "github-slugger";
+import remarkGfm3 from "remark-gfm";
+import remarkParse2 from "remark-parse";
+import { unified as unified2 } from "unified";
+import { visit as visit3 } from "unist-util-visit";
+function extractText2(children) {
+  return children.map((child) => {
+    if ("value" in child && typeof child.value === "string") {
+      return child.value;
+    }
+    if ("alt" in child && typeof child.alt === "string") {
+      return child.alt;
+    }
+    if ("children" in child && Array.isArray(child.children)) {
+      return extractText2(child.children);
+    }
+    return "";
+  }).join("");
+}
+function extractHeadings(markdown, options) {
+  const tree = unified2().use(remarkParse2).use(remarkGfm3).parse(markdown);
+  const slugger = new GithubSlugger();
+  const headings = [];
+  const headingId = options?.headingId ?? FOOTNOTES_HEADING_ID;
+  const headingText = options?.headingText ?? FOOTNOTES_HEADING_TEXT;
+  let hasFootnotes = false;
+  visit3(tree, "heading", (node) => {
+    if (node.depth !== 1 && node.depth !== 2 && node.depth !== 3) {
+      return;
+    }
+    const text = extractText2(node.children).trim();
+    if (!text) {
+      return;
+    }
+    headings.push({
+      depth: node.depth,
+      text,
+      id: slugger.slug(text)
+    });
+  });
+  visit3(tree, "footnoteDefinition", () => {
+    hasFootnotes = true;
+  });
+  if (hasFootnotes) {
+    headings.push({
+      depth: resolveFootnotesHeadingDepth(
+        headings.map((heading) => heading.depth)
+      ),
+      text: headingText,
+      id: headingId
+    });
+  }
+  return headings;
+}
+export {
+  DEFAULT_CODE_FENCE_COMPONENT_MAPPINGS,
+  DEFAULT_CUSTOM_SYNTAX_COMPONENT_NAMES,
+  FOOTNOTES_HEADING_ID,
+  FOOTNOTES_HEADING_TEXT,
+  YAML_PROP_PREFIX,
+  createCodeFenceComponentPlugin,
+  createCustomSyntaxRemarkPlugin,
+  createMarkdownPreset,
+  extractHeadings,
+  rehypeFootnotesHeading,
+  remarkSuperSub,
+  resolveCustomSyntaxComponentNames
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@luckyfishes/markdown-core",
+  "version": "0.1.0",
+  "description": "Core Markdown/MDX parsing and AST transformation utilities extracted from noname_blog.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "homepage": "https://github.com/lijiajunply/nonameblog-markdown-core#readme",
+  "bugs": {
+    "url": "https://github.com/lijiajunply/nonameblog-markdown-core/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lijiajunply/nonameblog-markdown-core.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "prepare": "npm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "github-slugger": "^2.0.0",
+    "gray-matter": "^4.0.3",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0"
+  },
+  "devDependencies": {
+    "@types/mdast": "^4.0.4",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}