fromsrc 0.0.0 → 0.0.1

package/dist/remarkinstall.js

@@ -0,0 +1,52 @@
+import { visit } from 'unist-util-visit';
+
+function attribute(name, value) {
+  return { type: "mdxJsxAttribute", name, value };
+}
+function commands(pkg, dev) {
+  if (dev) {
+    return {
+      npm: `npm install -D ${pkg}`,
+      yarn: `yarn add -D ${pkg}`,
+      pnpm: `pnpm add -D ${pkg}`,
+      bun: `bun add -d ${pkg}`
+    };
+  }
+  return {
+    npm: `npm install ${pkg}`,
+    yarn: `yarn add ${pkg}`,
+    pnpm: `pnpm add ${pkg}`,
+    bun: `bun add ${pkg}`
+  };
+}
+function transformer(tree) {
+  visit(tree, "code", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const isInstall = node.lang === "install" || node.meta && node.meta.includes("install");
+    if (!isInstall) return;
+    const raw = node.value.trim();
+    if (!raw) return;
+    const dev = raw.includes("--dev") || raw.includes("-D") || (node.meta?.includes("dev") ?? false);
+    const pkg = raw.split(/\s+/).filter((w) => w !== "--dev" && w !== "-D").join(" ");
+    if (!pkg) return;
+    const cmds = commands(pkg, dev);
+    const attrs = [
+      attribute("packages", pkg),
+      attribute("npm", cmds.npm),
+      attribute("yarn", cmds.yarn),
+      attribute("pnpm", cmds.pnpm),
+      attribute("bun", cmds.bun)
+    ];
+    const element = {
+      type: "mdxJsxFlowElement",
+      name: "Install",
+      attributes: attrs,
+      children: [],
+      data: { _mdxExplicitJsx: true }
+    };
+    parent.children[index] = element;
+  });
+}
+const remarkInstall = () => transformer;
+
+export { remarkInstall };

package/dist/remarklinkcard.d.ts

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

package/dist/remarklinkcard.js

@@ -0,0 +1,38 @@
+import { visit } from 'unist-util-visit';
+
+function extract(node) {
+  if (node.children.length !== 1) return null;
+  const child = node.children[0];
+  if (!child) return null;
+  if (child.type !== "link") return null;
+  const link = child;
+  if (!link.url.startsWith("https://")) return null;
+  const text = link.children[0];
+  if (!text || text.type !== "text") return null;
+  const raw = text.value;
+  if (!raw.startsWith("card")) return null;
+  const title = raw.startsWith("card:") ? raw.slice(5).trim() : new URL(link.url).hostname.replace(/^www\./, "");
+  return { href: link.url, title };
+}
+function makeNode(href, title) {
+  return {
+    type: "mdxJsxFlowElement",
+    name: "LinkCard",
+    attributes: [
+      { type: "mdxJsxAttribute", name: "href", value: href },
+      { type: "mdxJsxAttribute", name: "title", value: title }
+    ],
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+const remarkLinkCard = () => (tree) => {
+  visit(tree, "paragraph", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const result = extract(node);
+    if (!result) return;
+    parent.children[index] = makeNode(result.href, result.title);
+  });
+};
+
+export { remarkLinkCard };

package/dist/remarkmath.d.ts

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

package/dist/remarkmath.js

@@ -0,0 +1,69 @@
+import { visit } from 'unist-util-visit';
+
+const blockPattern = /^\$\$([\s\S]*)\$\$$/;
+const inlinePattern = /\$([^$]+)\$/g;
+function makeInline(math) {
+  return {
+    type: "mdxJsxTextElement",
+    name: "InlineMath",
+    attributes: [{ type: "mdxJsxAttribute", name: "math", value: math }],
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function makeBlock(math) {
+  return {
+    type: "mdxJsxFlowElement",
+    name: "BlockMath",
+    attributes: [{ type: "mdxJsxAttribute", name: "math", value: math }],
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function transformer(tree) {
+  visit(tree, "paragraph", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    if (node.children.length !== 1) return;
+    const child = node.children[0];
+    if (child?.type !== "text") return;
+    const match = child.value.trim().match(blockPattern);
+    if (!match) return;
+    const block = match[1];
+    if (block === void 0) return;
+    parent.children[index] = makeBlock(block.trim());
+  });
+  visit(tree, "paragraph", (node) => {
+    const next = [];
+    let changed = false;
+    for (const child of node.children) {
+      if (child.type !== "text" || !inlinePattern.test(child.value)) {
+        next.push(child);
+        continue;
+      }
+      changed = true;
+      inlinePattern.lastIndex = 0;
+      let cursor = 0;
+      let match;
+      while ((match = inlinePattern.exec(child.value)) !== null) {
+        if (match.index > cursor) {
+          next.push({
+            type: "text",
+            value: child.value.slice(cursor, match.index)
+          });
+        }
+        const inline = match[1];
+        if (inline !== void 0) next.push(makeInline(inline));
+        cursor = match.index + match[0].length;
+      }
+      if (cursor < child.value.length) {
+        next.push({ type: "text", value: child.value.slice(cursor) });
+      }
+    }
+    if (changed) {
+      node.children = next;
+    }
+  });
+}
+const remarkMath = () => transformer;
+
+export { remarkMath };

package/dist/remarkmermaid.d.ts

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

package/dist/remarkmermaid.js

@@ -0,0 +1,21 @@
+import { visit } from 'unist-util-visit';
+
+function transformer(tree) {
+  visit(tree, "code", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    if (node.lang !== "mermaid") return;
+    const element = {
+      type: "mdxJsxFlowElement",
+      name: "Mermaid",
+      attributes: [
+        { type: "mdxJsxAttribute", name: "chart", value: node.value }
+      ],
+      children: [],
+      data: { _mdxExplicitJsx: true }
+    };
+    parent.children[index] = element;
+  });
+}
+const remarkMermaid = () => transformer;
+
+export { remarkMermaid };

package/dist/remarkmeta.d.ts

@@ -0,0 +1,15 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+type CodeMeta = {
+    title?: string;
+    filename?: string;
+    highlight?: number[];
+    showLineNumbers?: boolean;
+    copy?: boolean;
+    [key: string]: unknown;
+};
+declare function parseMeta(meta: string): CodeMeta;
+declare const remarkMeta: Plugin<[], Root>;
+
+export { type CodeMeta, parseMeta, remarkMeta };

package/dist/remarkmeta.js

@@ -0,0 +1,63 @@
+import { visit } from 'unist-util-visit';
+
+function parseRange(raw) {
+  const result = [];
+  for (const part of raw.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed.includes("-")) {
+      const [start, end] = trimmed.split("-");
+      const a = Number.parseInt(start ?? "", 10);
+      const b = Number.parseInt(end ?? "", 10);
+      if (!Number.isNaN(a) && !Number.isNaN(b)) {
+        for (let i = a; i <= b; i++) result.push(i);
+      }
+    } else {
+      const n = Number.parseInt(trimmed, 10);
+      if (!Number.isNaN(n)) result.push(n);
+    }
+  }
+  return result;
+}
+function parseBrace(raw) {
+  const inner = raw.slice(1, -1);
+  if (/^[\d,\s-]+$/.test(inner)) return parseRange(inner);
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return inner;
+  }
+}
+function parseMeta(meta) {
+  const result = {};
+  const pattern = /(\w+)=("[^"]*"|'[^']*'|\{[^}]*\})|(\{[^}]*\})|(\w+)/g;
+  let match;
+  while ((match = pattern.exec(meta)) !== null) {
+    if (match[1] && match[2]) {
+      const key = match[1];
+      const val = match[2];
+      if (!key || !val) continue;
+      if (val.startsWith('"') || val.startsWith("'")) {
+        result[key] = val.slice(1, -1);
+      } else {
+        result[key] = parseBrace(val);
+      }
+    } else if (match[3]) {
+      result.highlight = parseRange(match[3].slice(1, -1));
+    } else if (match[4]) {
+      result[match[4]] = true;
+    }
+  }
+  return result;
+}
+function transformer(tree) {
+  visit(tree, "code", (node) => {
+    if (!node.meta) return;
+    const meta = parseMeta(node.meta);
+    const data = node.data ?? {};
+    data.meta = meta;
+    node.data = data;
+  });
+}
+const remarkMeta = () => transformer;
+
+export { parseMeta, remarkMeta };

package/dist/remarkreadingtime.d.ts

@@ -0,0 +1,11 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+type ReadingTimeOptions = {
+    wordsPerMinute?: number;
+    codeWordsPerMinute?: number;
+};
+declare function countWords(text: string): number;
+declare const remarkReadingTime: Plugin<[ReadingTimeOptions?], Root>;
+
+export { type ReadingTimeOptions, countWords, remarkReadingTime };

package/dist/remarkreadingtime.js

@@ -0,0 +1,44 @@
+import { visit } from 'unist-util-visit';
+
+function countWords(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return 0;
+  return trimmed.split(/\s+/).length;
+}
+function collectText(node) {
+  let result = "";
+  for (const child of node.children) {
+    if (child.type === "text" || child.type === "inlineCode") {
+      result += child.value + " ";
+    }
+  }
+  return result;
+}
+const remarkReadingTime = (options) => {
+  const wpm = options?.wordsPerMinute ?? 200;
+  const codeWpm = options?.codeWordsPerMinute ?? 100;
+  return (tree, file) => {
+    let text = "";
+    let code = "";
+    visit(tree, (node) => {
+      if (node.type === "heading" || node.type === "paragraph") {
+        text += collectText(node);
+        return "skip";
+      }
+      if (node.type === "text") {
+        text += node.value + " ";
+      }
+      if (node.type === "code") {
+        code += node.value + " ";
+        return "skip";
+      }
+    });
+    const textWords = countWords(text);
+    const codeWords = countWords(code);
+    const minutes = Math.ceil(textWords / wpm + codeWords / codeWpm);
+    file.data.readingTime = minutes;
+    file.data.wordCount = textWords + codeWords;
+  };
+};
+
+export { countWords, remarkReadingTime };

package/dist/remarksteps.d.ts

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

package/dist/remarksteps.js

@@ -0,0 +1,56 @@
+import { visit } from 'unist-util-visit';
+
+function isStepsList(node) {
+  if (!node.ordered) return false;
+  return node.children.every((item) => {
+    const first = item.children[0];
+    if (!first || first.type !== "paragraph") return false;
+    return first.children[0]?.type === "strong";
+  });
+}
+function extractTitle(strong) {
+  if (!strong || !("children" in strong) || !Array.isArray(strong.children)) return "";
+  return strong.children.map((child) => "value" in child ? child.value ?? "" : "").join("");
+}
+function makeStep(item) {
+  const paragraph = item.children[0];
+  const strong = paragraph.children[0];
+  const title = extractTitle(strong);
+  const remaining = paragraph.children.slice(1);
+  const first = remaining[0];
+  const trimmed = first && first.type === "text" && first.value.startsWith(" ") ? [{ ...first, value: first.value.slice(1) }, ...remaining.slice(1)] : remaining;
+  const children = [];
+  if (trimmed.length > 0) {
+    children.push({
+      type: "paragraph",
+      children: trimmed
+    });
+  }
+  for (const child of item.children.slice(1)) {
+    children.push(child);
+  }
+  return {
+    type: "mdxJsxFlowElement",
+    name: "Step",
+    attributes: [{ type: "mdxJsxAttribute", name: "title", value: title }],
+    children,
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function transformer(tree) {
+  visit(tree, "list", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    if (!isStepsList(node)) return;
+    const steps = node.children.map(makeStep);
+    parent.children[index] = {
+      type: "mdxJsxFlowElement",
+      name: "Steps",
+      attributes: [],
+      children: steps,
+      data: { _mdxExplicitJsx: true }
+    };
+  });
+}
+const remarkSteps = () => transformer;
+
+export { remarkSteps };

package/dist/remarkstructure.d.ts

@@ -0,0 +1,18 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+interface TocHeading {
+    id: string;
+    text: string;
+    level: number;
+}
+interface TocNode {
+    id: string;
+    text: string;
+    level: number;
+    children: TocNode[];
+}
+declare function buildTocTree(headings: TocHeading[]): TocNode[];
+declare const remarkStructure: Plugin<[], Root>;
+
+export { type TocHeading, type TocNode, buildTocTree, remarkStructure };

package/dist/remarkstructure.js

@@ -0,0 +1,53 @@
+import { visit } from 'unist-util-visit';
+
+function extractText(node) {
+  if ("value" in node && typeof node.value === "string") return node.value;
+  if ("children" in node && Array.isArray(node.children)) {
+    return node.children.map(extractText).join("");
+  }
+  return "";
+}
+function generateId(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function buildTocTree(headings) {
+  const root = [];
+  const stack = [];
+  for (const heading of headings) {
+    const node = {
+      id: heading.id,
+      text: heading.text,
+      level: heading.level,
+      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;
+}
+function transformer(tree, file) {
+  const headings = [];
+  visit(tree, "heading", (node) => {
+    const text = extractText(node);
+    headings.push({
+      id: generateId(text),
+      text,
+      level: node.depth
+    });
+  });
+  file.data.headings = headings;
+  file.data.toc = buildTocTree(headings);
+}
+const remarkStructure = () => transformer;
+
+export { buildTocTree, remarkStructure };

package/dist/remarktabs.d.ts

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

package/dist/remarktabs.js

@@ -0,0 +1,42 @@
+import { visit } from 'unist-util-visit';
+
+function attribute(name, value) {
+  return { type: "mdxJsxAttribute", name, value };
+}
+function skipped(node) {
+  return !!node.meta && (node.meta.includes("nogroup") || node.meta.includes("standalone"));
+}
+function transformer(tree) {
+  visit(tree, "code", (_node, index, parent) => {
+    if (!parent || index === void 0) return;
+    if (skipped(_node)) return;
+    const group = [_node];
+    let next = index + 1;
+    while (next < parent.children.length) {
+      const sibling = parent.children[next];
+      if (sibling?.type !== "code") break;
+      if (skipped(sibling)) break;
+      group.push(sibling);
+      next++;
+    }
+    if (group.length < 2) return;
+    const tabs = group.map((code) => ({
+      type: "mdxJsxFlowElement",
+      name: "CodeTab",
+      attributes: [attribute("label", code.lang ?? "text"), attribute("value", code.lang ?? "text")],
+      children: [code],
+      data: { _mdxExplicitJsx: true }
+    }));
+    const element = {
+      type: "mdxJsxFlowElement",
+      name: "CodeGroup",
+      attributes: [],
+      children: tabs,
+      data: { _mdxExplicitJsx: true }
+    };
+    parent.children.splice(index, group.length, element);
+  });
+}
+const remarkTabs = () => transformer;
+
+export { remarkTabs };

package/dist/remarktoc.d.ts

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

package/dist/remarktoc.js

@@ -0,0 +1,47 @@
+import { visit } from 'unist-util-visit';
+
+function textContent(node) {
+  const parts = [];
+  visit(node, "text", (t) => {
+    parts.push(t.value);
+  });
+  return parts.join("");
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function isTocMarker(node) {
+  if (node.type !== "paragraph") return false;
+  if (node.children?.length !== 1) return false;
+  const child = node.children[0];
+  return child?.type === "text" && child.value?.trim() === "[toc]";
+}
+const remarkToc = () => (tree) => {
+  const items = [];
+  visit(tree, "heading", (node) => {
+    if (node.depth < 2 || node.depth > 4) return;
+    const text = textContent(node);
+    if (!text) return;
+    items.push({ text, slug: slugify(text), depth: node.depth });
+  });
+  visit(tree, "paragraph", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    if (!isTocMarker(node)) return;
+    const element = {
+      type: "mdxJsxFlowElement",
+      name: "TableOfContents",
+      attributes: [
+        {
+          type: "mdxJsxAttribute",
+          name: "items",
+          value: JSON.stringify(items)
+        }
+      ],
+      children: [],
+      data: { _mdxExplicitJsx: true }
+    };
+    parent.children[index] = element;
+  });
+};
+
+export { remarkToc };

package/dist/remarkts2js.d.ts

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

package/dist/remarkts2js.js

@@ -0,0 +1,88 @@
+import { visit } from 'unist-util-visit';
+
+function stripTypes(code) {
+  let result = code;
+  result = result.replace(/import\s+type\s+.*?from\s+['"].*?['"]/g, "");
+  result = result.replace(/import\s+\{([^}]*)\}\s+from/g, (match, imports) => {
+    const cleaned = imports.split(",").map((imp) => imp.trim()).filter((imp) => !imp.startsWith("type ")).map((imp) => imp.replace(/^type\s+/, "")).join(", ");
+    return cleaned ? `import { ${cleaned} } from` : "";
+  });
+  result = result.replace(/\binterface\s+\w+\s*\{[^}]*\}/g, "");
+  result = result.replace(/\btype\s+\w+\s*=\s*[^;\n]+[;\n]/g, "");
+  result = result.replace(/\btype\s+\w+\s*<[^>]+>\s*=\s*[^;\n]+[;\n]/g, "");
+  result = result.replace(/<[^>]+>/g, "");
+  result = result.replace(/:\s*\w+(\[\])?(\s*\|\s*\w+(\[\])?)*(?=\s*[,;=)\]}])/g, "");
+  result = result.replace(/:\s*\{[^}]*\}/g, "");
+  result = result.replace(/:\s*\([^)]*\)\s*=>/g, "");
+  result = result.replace(/\bas\s+\w+/g, "");
+  result = result.replace(/!/g, "");
+  result = result.replace(/\breadonly\s+/g, "");
+  result = result.replace(/\.tsx?\b/g, (match) => {
+    return match === ".tsx" ? ".jsx" : ".js";
+  });
+  result = result.replace(/\n\s*\n\s*\n+/g, "\n\n");
+  return result.trim();
+}
+function createCodeGroup(tsCode, jsCode, lang) {
+  const jsLang = lang === "tsx" ? "jsx" : "javascript";
+  return {
+    type: "mdxJsxFlowElement",
+    name: "CodeGroup",
+    attributes: [],
+    children: [
+      {
+        type: "mdxJsxFlowElement",
+        name: "CodeTab",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "label",
+            value: "TypeScript"
+          }
+        ],
+        children: [
+          {
+            type: "code",
+            lang,
+            meta: null,
+            value: tsCode
+          }
+        ]
+      },
+      {
+        type: "mdxJsxFlowElement",
+        name: "CodeTab",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "label",
+            value: "JavaScript"
+          }
+        ],
+        children: [
+          {
+            type: "code",
+            lang: jsLang,
+            meta: null,
+            value: jsCode
+          }
+        ]
+      }
+    ]
+  };
+}
+const remarkTs2Js = () => {
+  return (tree) => {
+    visit(tree, "code", (node, index, parent) => {
+      if (!parent || index === null || index === void 0 || typeof index !== "number") return;
+      const lang = node.lang;
+      if (!lang || !["typescript", "ts", "tsx"].includes(lang)) return;
+      if (node.meta?.includes("no-js")) return;
+      const jsCode = stripTypes(node.value);
+      const codeGroup = createCodeGroup(node.value, jsCode, lang);
+      parent.children[index] = codeGroup;
+    });
+  };
+};
+
+export { remarkTs2Js };