fromsrc 0.0.0 → 0.0.1

package/dist/rehypetoc.js

@@ -0,0 +1,61 @@
+import { visit } from 'unist-util-visit';
+
+function extractText(node) {
+  let text = "";
+  for (const child of node.children) {
+    if (child.type === "text") {
+      text += child.value;
+    } else if (child.type === "element") {
+      text += extractText(child);
+    }
+  }
+  return text;
+}
+const levelMap = {
+  h1: 1,
+  h2: 2,
+  h3: 3,
+  h4: 4,
+  h5: 5,
+  h6: 6
+};
+function buildTree(headings) {
+  const root = [];
+  const stack = [];
+  for (const heading of headings) {
+    const node = { ...heading, children: [] };
+    while (stack.length > 0) {
+      const last = stack[stack.length - 1];
+      if (!last || last.level < heading.level) break;
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      root.push(node);
+    } else {
+      const parent = stack[stack.length - 1];
+      if (parent) parent.children.push(node);
+    }
+    stack.push(node);
+  }
+  return root;
+}
+const rehypeToc = (options) => {
+  const min = options?.minLevel ?? 2;
+  const max = options?.maxLevel ?? 4;
+  return (tree, file) => {
+    const headings = [];
+    visit(tree, "element", (node) => {
+      const level = levelMap[node.tagName];
+      if (!level || level < min || level > max) return;
+      const raw = node.properties?.id;
+      const id = typeof raw === "string" ? raw : "";
+      const text = extractText(node);
+      if (!id || !text) return;
+      headings.push({ id, text, level });
+    });
+    file.data["headings"] = headings;
+    file.data["toc"] = buildTree(headings);
+  };
+};
+
+export { rehypeToc };

package/dist/remark.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkAlerts: Plugin<[], Root>;
+
+export { remarkAlerts as default, remarkAlerts };

package/dist/remark.js

@@ -0,0 +1,48 @@
+import { visit } from 'unist-util-visit';
+
+const types = {
+  NOTE: "info",
+  TIP: "tip",
+  WARNING: "warning",
+  CAUTION: "error",
+  IMPORTANT: "info"
+};
+const pattern = /^\[!(NOTE|TIP|WARNING|CAUTION|IMPORTANT)\]\s*/;
+function transformer(tree) {
+  visit(tree, "blockquote", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const first = node.children[0];
+    if (first?.type !== "paragraph") return;
+    const text = first.children[0];
+    if (text?.type !== "text") return;
+    const match = text.value.match(pattern);
+    if (!match) return;
+    const key = match[1];
+    if (!key) return;
+    const calloutType = types[key];
+    text.value = text.value.replace(pattern, "");
+    if (!text.value && first.children.length === 1) {
+      node.children.shift();
+    } else if (!text.value) {
+      first.children.shift();
+    }
+    const children = node.children.length ? node.children : [{ type: "paragraph", children: [{ type: "text", value: "" }] }];
+    parent.children[index] = {
+      type: "mdxJsxFlowElement",
+      name: "Callout",
+      attributes: [
+        {
+          type: "mdxJsxAttribute",
+          name: "type",
+          value: calloutType
+        }
+      ],
+      children,
+      data: { _mdxExplicitJsx: true }
+    };
+  });
+}
+const remarkAlerts = () => transformer;
+var remark_default = remarkAlerts;
+
+export { remark_default as default, remarkAlerts };

package/dist/remarkadmonition.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkAdmonition: Plugin<[], Root>;
+
+export { remarkAdmonition };

package/dist/remarkadmonition.js

@@ -0,0 +1,78 @@
+const types = /* @__PURE__ */ new Set(["note", "tip", "info", "warning", "danger", "caution", "important"]);
+const openPattern = /^:::(\w+)(?:\s+(.+))?$/;
+const closePattern = /^:::$/;
+function extractText(node) {
+  if (node.value) return node.value;
+  if (node.children) return node.children.map(extractText).join("");
+  return "";
+}
+function isOpen(node) {
+  if (node.type !== "paragraph") return null;
+  const text = extractText(node).trim();
+  const match = text.match(openPattern);
+  if (!match) return null;
+  const raw = match[1];
+  if (!raw) return null;
+  const kind = raw.toLowerCase();
+  if (!types.has(kind)) return null;
+  return { kind, title: match[2]?.trim() || void 0 };
+}
+function isClose(node) {
+  if (node.type !== "paragraph") return false;
+  return closePattern.test(extractText(node).trim());
+}
+function buildElement(kind, title, children) {
+  const attrs = [{ type: "mdxJsxAttribute", name: "type", value: kind }];
+  if (title) {
+    attrs.push({ type: "mdxJsxAttribute", name: "title", value: title });
+  }
+  return {
+    type: "mdxJsxFlowElement",
+    name: "Callout",
+    attributes: attrs,
+    children,
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function processChildren(nodes) {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    if (!node) {
+      i++;
+      continue;
+    }
+    const open = isOpen(node);
+    if (!open) {
+      if (node.children) {
+        node.children = processChildren(node.children);
+      }
+      result.push(node);
+      i++;
+      continue;
+    }
+    const inner = [];
+    i++;
+    while (i < nodes.length) {
+      const child = nodes[i];
+      if (!child || isClose(child)) break;
+      inner.push(child);
+      i++;
+    }
+    if (i < nodes.length) {
+      i++;
+    }
+    result.push(buildElement(open.kind, open.title, processChildren(inner)));
+  }
+  return result;
+}
+function transformer(tree) {
+  const root = tree;
+  if (root.children) {
+    root.children = processChildren(root.children);
+  }
+}
+const remarkAdmonition = () => transformer;
+
+export { remarkAdmonition };

package/dist/remarkannotation.d.ts

@@ -0,0 +1,10 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+type Annotation = {
+    line: number;
+    type: string;
+};
+declare const remarkAnnotation: Plugin<[], Root>;
+
+export { type Annotation, remarkAnnotation };

package/dist/remarkannotation.js

@@ -0,0 +1,65 @@
+import { visit } from 'unist-util-visit';
+
+const patterns = [
+  /\/\/\s*\[!code\s+(\w+[+-]*)\]\s*$/,
+  /#\s*\[!code\s+(\w+[+-]*)\]\s*$/,
+  /<!--\s*\[!code\s+(\w+[+-]*)\]\s*-->\s*$/
+];
+const validTypes = /* @__PURE__ */ new Set(["highlight", "focus", "warning", "error"]);
+function parseType(raw) {
+  if (raw === "++") return "added";
+  if (raw === "--") return "removed";
+  const lower = raw.toLowerCase();
+  if (validTypes.has(lower)) return lower;
+  return null;
+}
+function matchAnnotation(line) {
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match) {
+      const raw = match[1];
+      if (!raw) continue;
+      const parsed = parseType(raw);
+      if (!parsed) continue;
+      return {
+        type: parsed,
+        cleaned: line.replace(pattern, "").trimEnd()
+      };
+    }
+  }
+  return null;
+}
+function transformer(tree) {
+  visit(tree, "code", (node) => {
+    if (!node.value) return;
+    const lines = node.value.split("\n");
+    const annotations = [];
+    const cleaned = [];
+    const types = /* @__PURE__ */ new Set();
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line === void 0) continue;
+      const result = matchAnnotation(line);
+      if (result) {
+        annotations.push({ line: i + 1, type: result.type });
+        types.add(result.type);
+        cleaned.push(result.cleaned);
+      } else {
+        cleaned.push(line);
+      }
+    }
+    if (annotations.length === 0) return;
+    node.value = cleaned.join("\n");
+    const data = node.data ?? {};
+    data.annotations = annotations;
+    const hProperties = data.hProperties ?? {};
+    for (const t of types) {
+      hProperties[`data-line-${t}`] = true;
+    }
+    data.hProperties = hProperties;
+    node.data = data;
+  });
+}
+const remarkAnnotation = () => transformer;
+
+export { remarkAnnotation };

package/dist/remarkbadge.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkBadge: Plugin<[], Root>;
+
+export { remarkBadge };

package/dist/remarkbadge.js

@@ -0,0 +1,40 @@
+import { visit } from 'unist-util-visit';
+
+const pattern = /\[\[badge:([^\]:]+)(?::([^\]]+))?\]\]/g;
+const remarkBadge = () => (tree) => {
+  visit(tree, "text", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const value = node.value;
+    pattern.lastIndex = 0;
+    if (!pattern.test(value)) return;
+    pattern.lastIndex = 0;
+    const parts = [];
+    let last = 0;
+    for (const match of value.matchAll(pattern)) {
+      const before = value.slice(last, match.index);
+      if (before) {
+        parts.push({ type: "text", value: before });
+      }
+      const text = match[1];
+      if (!text) continue;
+      const variant = match[2] || "default";
+      parts.push({
+        type: "mdxJsxTextElement",
+        name: "Badge",
+        attributes: [{ type: "mdxJsxAttribute", name: "variant", value: variant }],
+        children: [{ type: "text", value: text }],
+        data: { _mdxExplicitJsx: true }
+      });
+      last = match.index + match[0].length;
+    }
+    const after = value.slice(last);
+    if (after) {
+      parts.push({ type: "text", value: after });
+    }
+    if (parts.length > 0) {
+      parent.children.splice(index, 1, ...parts);
+    }
+  });
+};
+
+export { remarkBadge };

package/dist/remarkblockmath.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkBlockMath: Plugin<[], Root>;
+
+export { remarkBlockMath };

package/dist/remarkblockmath.js

@@ -0,0 +1,57 @@
+import { visit } from 'unist-util-visit';
+
+const langs = /* @__PURE__ */ new Set(["math", "latex", "katex"]);
+const inlinePattern = /(?<!\$)\$(?!\$)(.+?)(?<!\$)\$(?!\$)/;
+function blockElement(value) {
+  return {
+    type: "mdxJsxFlowElement",
+    name: "BlockMath",
+    attributes: [{ type: "mdxJsxAttribute", name: "math", value }],
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function inlineElement(value) {
+  return {
+    type: "mdxJsxTextElement",
+    name: "InlineMath",
+    attributes: [{ type: "mdxJsxAttribute", name: "math", value }],
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function splitInline(text) {
+  const nodes = [];
+  let remaining = text;
+  while (remaining) {
+    const match = remaining.match(inlinePattern);
+    if (!match || match.index === void 0) {
+      if (remaining) nodes.push({ type: "text", value: remaining });
+      break;
+    }
+    if (match.index > 0) {
+      nodes.push({ type: "text", value: remaining.slice(0, match.index) });
+    }
+    const inline = match[1];
+    if (inline) nodes.push(inlineElement(inline));
+    remaining = remaining.slice(match.index + match[0].length);
+  }
+  return nodes;
+}
+function transformer(tree) {
+  visit(tree, "code", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    if (!node.lang || !langs.has(node.lang)) return;
+    parent.children[index] = blockElement(node.value);
+  });
+  visit(tree, "text", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    if (!inlinePattern.test(node.value)) return;
+    const nodes = splitInline(node.value);
+    if (nodes.length <= 1) return;
+    parent.children.splice(index, 1, ...nodes);
+  });
+}
+const remarkBlockMath = () => transformer;
+
+export { remarkBlockMath };

package/dist/remarkcallout.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkCallout: Plugin<[], Root>;
+
+export { remarkCallout };

package/dist/remarkcallout.js

@@ -0,0 +1,65 @@
+import { visit } from 'unist-util-visit';
+
+const pattern = /^\[!(\w+)\]\s*/;
+const typeMap = {
+  note: { name: "Note" },
+  tip: { name: "Callout", type: "tip" },
+  warning: { name: "Callout", type: "warning" },
+  important: { name: "Note", type: "important" },
+  caution: { name: "Callout", type: "danger" }
+};
+function extractType(node) {
+  const first = node.children[0];
+  if (first?.type !== "paragraph") return null;
+  const text = first.children?.[0];
+  if (text?.type !== "text" || !text.value) return null;
+  const match = text.value.match(pattern);
+  if (!match) return null;
+  const raw = match[1];
+  return raw ? raw.toLowerCase() : null;
+}
+function stripPrefix(node) {
+  const children = [...node.children];
+  const first = children[0];
+  if (first?.type !== "paragraph") return children;
+  const para = { ...first, children: [...first.children] };
+  const text = para.children[0];
+  if (text?.type === "text" && text.value) {
+    const stripped = text.value.replace(pattern, "");
+    if (stripped) {
+      para.children[0] = { ...text, value: stripped };
+    } else {
+      para.children.shift();
+    }
+  }
+  if (para.children.length === 0) {
+    children.shift();
+  } else {
+    children[0] = para;
+  }
+  return children;
+}
+function transformer(tree) {
+  visit(tree, "blockquote", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const calloutType = extractType(node);
+    if (!calloutType) return;
+    const mapping = typeMap[calloutType];
+    if (!mapping) return;
+    const attrs = [];
+    if (mapping.type) {
+      attrs.push({ type: "mdxJsxAttribute", name: "type", value: mapping.type });
+    }
+    const element = {
+      type: "mdxJsxFlowElement",
+      name: mapping.name,
+      attributes: attrs,
+      children: stripPrefix(node),
+      data: { _mdxExplicitJsx: true }
+    };
+    parent.children[index] = element;
+  });
+}
+const remarkCallout = () => transformer;
+
+export { remarkCallout };

package/dist/remarkcaption.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkCaption: Plugin<[], Root>;
+
+export { remarkCaption };

package/dist/remarkcaption.js

@@ -0,0 +1,48 @@
+import { visit } from 'unist-util-visit';
+
+function standalone(parent) {
+  if (parent.children.length !== 1) return null;
+  const child = parent.children[0];
+  if (child?.type !== "image") return null;
+  return child;
+}
+function figure(image) {
+  const attributes = [
+    { type: "mdxJsxAttribute", name: "src", value: image.url },
+    { type: "mdxJsxAttribute", name: "alt", value: image.alt || "" }
+  ];
+  if (image.title) {
+    attributes.push({ type: "mdxJsxAttribute", name: "title", value: image.title });
+  }
+  return {
+    type: "mdxJsxFlowElement",
+    name: "figure",
+    attributes: [],
+    children: [
+      {
+        type: "mdxJsxFlowElement",
+        name: "img",
+        attributes,
+        children: []
+      },
+      {
+        type: "mdxJsxFlowElement",
+        name: "figcaption",
+        attributes: [],
+        children: [{ type: "text", value: image.alt || "" }]
+      }
+    ],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function transformer(tree) {
+  visit(tree, "paragraph", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const image = standalone(node);
+    if (!image?.alt) return;
+    parent.children[index] = figure(image);
+  });
+}
+const remarkCaption = () => transformer;
+
+export { remarkCaption };

package/dist/remarkcodetitle.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkCodeTitle: Plugin<[], Root>;
+
+export { remarkCodeTitle };

package/dist/remarkcodetitle.js

@@ -0,0 +1,39 @@
+import { visit } from 'unist-util-visit';
+
+const pattern = /title=(?:"([^"]+)"|(\S+))/;
+function parse(meta) {
+  const match = meta.match(pattern);
+  if (!match) return null;
+  const title = match[1] || match[2];
+  if (!title) return null;
+  const cleaned = meta.replace(pattern, "").trim();
+  return { title, cleaned };
+}
+function transformer(tree) {
+  visit(tree, "code", (node, index, parent) => {
+    if (!parent || index === void 0 || !node.meta) return;
+    const result = parse(node.meta);
+    if (!result) return;
+    const element = {
+      type: "mdxJsxFlowElement",
+      name: "CodeBlock",
+      attributes: [
+        { type: "mdxJsxAttribute", name: "title", value: result.title },
+        { type: "mdxJsxAttribute", name: "lang", value: node.lang || "" }
+      ],
+      children: [
+        {
+          type: "code",
+          value: node.value,
+          lang: node.lang ?? null,
+          meta: result.cleaned || null
+        }
+      ],
+      data: { _mdxExplicitJsx: true }
+    };
+    parent.children[index] = element;
+  });
+}
+const remarkCodeTitle = () => transformer;
+
+export { remarkCodeTitle };

package/dist/remarkcolumns.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkColumns: Plugin<[], Root>;
+
+export { remarkColumns };

package/dist/remarkcolumns.js

@@ -0,0 +1,67 @@
+function text(n) {
+  return n.value ?? n.children?.map(text).join("") ?? "";
+}
+function para(node, re) {
+  return node.type === "paragraph" ? text(node).trim().match(re) : null;
+}
+const isColumnsOpen = (n) => {
+  const m = para(n, /^:::\s*columns(?:\s+(\d+))?$/);
+  return m ? { count: m[1] } : null;
+};
+const isColumnOpen = (n) => !!para(n, /^:::\s*column$/);
+const isClose = (n) => !!para(n, /^:::$/);
+function mdx(name, attrs, children) {
+  return {
+    type: "mdxJsxFlowElement",
+    name,
+    attributes: attrs,
+    children,
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function processChildren(nodes) {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    if (!node) {
+      i++;
+      continue;
+    }
+    const open = isColumnsOpen(node);
+    if (!open) {
+      if (node.children) node.children = processChildren(node.children);
+      result.push(node);
+      i++;
+      continue;
+    }
+    const attrs = [];
+    if (open.count) {
+      attrs.push({ type: "mdxJsxAttribute", name: "count", value: open.count });
+    }
+    const columns = [];
+    let current = null;
+    i++;
+    while (i < nodes.length) {
+      const child = nodes[i];
+      if (!child || isClose(child)) break;
+      if (isColumnOpen(child)) {
+        if (current) columns.push(mdx("Column", [], current));
+        current = [];
+      } else if (current) {
+        current.push(child);
+      }
+      i++;
+    }
+    if (current) columns.push(mdx("Column", [], current));
+    if (i < nodes.length) i++;
+    result.push(mdx("Columns", attrs, columns));
+  }
+  return result;
+}
+const remarkColumns = () => (tree) => {
+  const root = tree;
+  if (root.children) root.children = processChildren(root.children);
+};
+
+export { remarkColumns };

package/dist/remarkdetails.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+declare const remarkDetails: Plugin<[], Root>;
+
+export { remarkDetails };