fromsrc 0.0.0 → 0.0.1

package/dist/remarkdetails.js

@@ -0,0 +1,61 @@
+const openPattern = /^\+\+\+\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 title = match[1];
+  return title ? title.trim() : null;
+}
+function isClose(node) {
+  if (node.type !== "paragraph") return false;
+  return closePattern.test(extractText(node).trim());
+}
+function buildElement(title, children) {
+  return {
+    type: "mdxJsxFlowElement",
+    name: "Details",
+    attributes: [{ type: "mdxJsxAttribute", name: "title", value: title }],
+    children,
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function processChildren(nodes) {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    if (!node) break;
+    const title = isOpen(node);
+    if (!title) {
+      if (node.children) node.children = processChildren(node.children);
+      result.push(node);
+      i++;
+      continue;
+    }
+    const inner = [];
+    i++;
+    while (i < nodes.length) {
+      const current = nodes[i];
+      if (!current || isClose(current)) break;
+      inner.push(current);
+      i++;
+    }
+    if (i < nodes.length) i++;
+    result.push(buildElement(title, processChildren(inner)));
+  }
+  return result;
+}
+function transformer(tree) {
+  const root = tree;
+  if (root.children) root.children = processChildren(root.children);
+}
+const remarkDetails = () => transformer;
+
+export { remarkDetails };

package/dist/remarkdirective.d.ts

@@ -0,0 +1,7 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+type DirectiveType = "note" | "tip" | "warning" | "danger" | "info" | "caution";
+declare const remarkDirective: Plugin<[], Root>;
+
+export { type DirectiveType, remarkDirective };

package/dist/remarkdirective.js

@@ -0,0 +1,98 @@
+const directives = /* @__PURE__ */ new Set(["note", "tip", "warning", "danger", "info", "caution"]);
+const openPattern = /^:::(\w+)(?:\{(.+?)\})?$/;
+function parseAttributes(raw) {
+  const attrs = {};
+  const regex = /(\w+)="([^"]*?)"/g;
+  let match;
+  while ((match = regex.exec(raw)) !== null) {
+    const key = match[1];
+    const value = match[2];
+    if (!key || value === void 0) continue;
+    attrs[key] = value;
+  }
+  return attrs;
+}
+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 name = raw.toLowerCase();
+  if (!directives.has(name)) return null;
+  const attrs = match[2] ? parseAttributes(match[2]) : {};
+  return { type: name, attrs };
+}
+function isClose(node) {
+  if (node.type !== "paragraph") return false;
+  return extractText(node).trim() === ":::";
+}
+function attribute(name, value) {
+  return { type: "mdxJsxAttribute", name, value };
+}
+const defaultTitles = {
+  note: "Note",
+  tip: "Tip",
+  warning: "Warning",
+  danger: "Danger",
+  info: "Info",
+  caution: "Caution"
+};
+function buildElement(type, attrs, children) {
+  const jsxAttrs = [attribute("type", type)];
+  const title = attrs.title ?? defaultTitles[type];
+  jsxAttrs.push(attribute("title", title));
+  return {
+    type: "mdxJsxFlowElement",
+    name: "Callout",
+    attributes: jsxAttrs,
+    children,
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function processChildren(nodes) {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    if (!node) break;
+    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 current = nodes[i];
+      if (!current || isClose(current)) break;
+      inner.push(current);
+      i++;
+    }
+    if (i < nodes.length) {
+      i++;
+    }
+    const processed = processChildren(inner);
+    result.push(buildElement(open.type, open.attrs, processed));
+  }
+  return result;
+}
+function transformer(tree) {
+  const root = tree;
+  if (root.children) {
+    root.children = processChildren(root.children);
+  }
+}
+const remarkDirective = () => transformer;
+
+export { remarkDirective };

package/dist/remarkembed.d.ts

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

package/dist/remarkembed.js

@@ -0,0 +1,72 @@
+import { visit } from 'unist-util-visit';
+
+const providers = [
+  {
+    pattern: /(?:youtube\.com\/watch\?v=|youtu\.be\/)([\w-]+)/,
+    name: "YouTube",
+    group: 1
+  },
+  {
+    pattern: /(?:twitter\.com|x\.com)\/\w+\/status\/(\d+)/,
+    name: "Tweet",
+    group: 1
+  },
+  {
+    pattern: /codesandbox\.io\/s\/([\w-]+)/,
+    name: "CodeSandbox",
+    group: 1
+  },
+  {
+    pattern: /stackblitz\.com\/edit\/([\w-]+)/,
+    name: "StackBlitz",
+    group: 1
+  },
+  {
+    pattern: /gist\.github\.com\/[\w-]+\/([\w]+)/,
+    name: "Gist",
+    group: 1
+  }
+];
+const urlPattern = /^https?:\/\/.+/;
+function isUrl(value) {
+  return urlPattern.test(value.trim());
+}
+function matchProvider(url) {
+  for (const provider of providers) {
+    const match = url.match(provider.pattern);
+    if (!match) continue;
+    const id = match[provider.group];
+    if (!id) continue;
+    return {
+      type: "mdxJsxFlowElement",
+      name: provider.name,
+      attributes: [
+        {
+          type: "mdxJsxAttribute",
+          name: "id",
+          value: id
+        }
+      ],
+      children: [],
+      data: { _mdxExplicitJsx: true }
+    };
+  }
+  return null;
+}
+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) return;
+    if (child.type !== "text") return;
+    const text = child.value.trim();
+    if (!isUrl(text)) return;
+    const embed = matchProvider(text);
+    if (!embed) return;
+    parent.children[index] = embed;
+  });
+}
+const remarkEmbed = () => transformer;
+
+export { remarkEmbed };

package/dist/remarkfiletree.d.ts

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

package/dist/remarkfiletree.js

@@ -0,0 +1,67 @@
+import { visit } from 'unist-util-visit';
+
+function attribute(name, value) {
+  return { type: "mdxJsxAttribute", name, value };
+}
+function parse(content) {
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  const root = [];
+  const stack = [{ depth: -1, children: root }];
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    const depth = indent === 0 ? 0 : Math.floor(indent / 2);
+    const folder = trimmed.endsWith("/");
+    const name = folder ? trimmed.slice(0, -1) : trimmed;
+    const node = { name, folder, children: [] };
+    while (stack.length > 1) {
+      const last = stack[stack.length - 1];
+      if (!last || last.depth < depth) break;
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1];
+    if (!parent) continue;
+    parent.children.push(node);
+    if (folder) {
+      stack.push({ depth, children: node.children });
+    }
+  }
+  return root;
+}
+function toElement(node) {
+  if (node.folder) {
+    return {
+      type: "mdxJsxFlowElement",
+      name: "Folder",
+      attributes: [attribute("name", node.name)],
+      children: node.children.map(toElement),
+      data: { _mdxExplicitJsx: true }
+    };
+  }
+  return {
+    type: "mdxJsxFlowElement",
+    name: "File",
+    attributes: [attribute("name", node.name)],
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function transformer(tree) {
+  visit(tree, "code", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const isFiletree = node.lang === "filetree" || node.meta?.includes("filetree");
+    if (!isFiletree) return;
+    const nodes = parse(node.value);
+    const element = {
+      type: "mdxJsxFlowElement",
+      name: "Files",
+      attributes: [],
+      children: nodes.map(toElement),
+      data: { _mdxExplicitJsx: true }
+    };
+    parent.children[index] = element;
+  });
+}
+const remarkFileTree = () => transformer;
+
+export { remarkFileTree };

package/dist/remarkfootnote.d.ts

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

package/dist/remarkfootnote.js

@@ -0,0 +1,63 @@
+import { visit } from 'unist-util-visit';
+
+const refPattern = /\[\^([^\]]+)\]/g;
+const defPattern = /^\[\^([^\]]+)\]:\s*(.+)$/;
+const attr = (name, value) => ({ type: "mdxJsxAttribute", name, value });
+const expr = (v) => ({ type: "mdxJsxAttributeValueExpression", value: v });
+const remarkFootnote = () => (tree) => {
+  const definitions = /* @__PURE__ */ new Map();
+  const seen = [];
+  const root = tree;
+  if (!root.children) return;
+  root.children = root.children.filter((node) => {
+    if (node.type !== "paragraph") return true;
+    const text = node.children?.[0];
+    if (text?.type !== "text" || !text.value) return true;
+    const match = text.value.match(defPattern);
+    if (!match) return true;
+    const id = match[1];
+    const value = match[2];
+    if (!id || value === void 0) return true;
+    definitions.set(id, value);
+    return false;
+  });
+  visit(tree, "text", (node, index, parent) => {
+    if (!parent || index === void 0) return;
+    const text = node.value;
+    if (!refPattern.test(text)) return;
+    refPattern.lastIndex = 0;
+    const parts = [];
+    let last = 0;
+    let match;
+    while ((match = refPattern.exec(text)) !== null) {
+      if (match.index > last) {
+        parts.push({ type: "text", value: text.slice(last, match.index) });
+      }
+      const id = match[1];
+      if (!id) continue;
+      if (!seen.includes(id)) seen.push(id);
+      parts.push({
+        type: "mdxJsxTextElement",
+        name: "FootnoteRef",
+        attributes: [attr("id", id), attr("index", expr(String(seen.indexOf(id) + 1)))],
+        children: [],
+        data: { _mdxExplicitJsx: true }
+      });
+      last = match.index + match[0].length;
+    }
+    if (last < text.length) {
+      parts.push({ type: "text", value: text.slice(last) });
+    }
+    parent.children.splice(index, 1, ...parts);
+  });
+  const items = seen.map((id) => ({ id, text: definitions.get(id) || "" }));
+  root.children.push({
+    type: "mdxJsxFlowElement",
+    name: "FootnoteList",
+    attributes: [attr("items", JSON.stringify(items))],
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  });
+};
+
+export { remarkFootnote };

package/dist/remarkgfm.d.ts

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

package/dist/remarkgfm.js

@@ -0,0 +1,60 @@
+import { visit } from 'unist-util-visit';
+
+const combined = /~~([^~]+)~~|https?:\/\/[^\s<>)}\]]+/g;
+function makeDel(content) {
+  return {
+    type: "mdxJsxTextElement",
+    name: "del",
+    attributes: [],
+    children: [{ type: "text", value: content }],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function makeLink(url) {
+  return {
+    type: "mdxJsxTextElement",
+    name: "a",
+    attributes: [{ type: "mdxJsxAttribute", name: "href", value: url }],
+    children: [{ type: "text", value: url }],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function transformer(tree) {
+  visit(tree, "paragraph", (node) => {
+    const next = [];
+    let changed = false;
+    for (const child of node.children) {
+      if (child.type !== "text" || !combined.test(child.value)) {
+        next.push(child);
+        continue;
+      }
+      changed = true;
+      combined.lastIndex = 0;
+      let cursor = 0;
+      let match;
+      while ((match = combined.exec(child.value)) !== null) {
+        if (match.index > cursor) {
+          next.push({
+            type: "text",
+            value: child.value.slice(cursor, match.index)
+          });
+        }
+        if (match[1] !== void 0) {
+          next.push(makeDel(match[1]));
+        } else {
+          next.push(makeLink(match[0]));
+        }
+        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 remarkGfm = () => transformer;
+
+export { remarkGfm };

package/dist/remarkheadingid.d.ts

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

package/dist/remarkheadingid.js

@@ -0,0 +1,40 @@
+import { visit } from 'unist-util-visit';
+
+const pattern = /\s*\{#([a-zA-Z0-9_-]+)\}\s*$/;
+function findTrailingId(children) {
+  for (let i = children.length - 1; i >= 0; i--) {
+    const child = children[i];
+    if (!child) continue;
+    if (child.type === "text") {
+      const match = child.value.match(pattern);
+      const id = match?.[1];
+      if (id) return { index: i, id };
+    }
+  }
+  return null;
+}
+function stripId(node, index) {
+  const child = node.children[index];
+  if (!child || child.type !== "text") return;
+  const stripped = child.value.replace(pattern, "");
+  if (stripped) {
+    node.children[index] = { ...child, value: stripped };
+  } else {
+    node.children.splice(index, 1);
+  }
+}
+function transformer(tree) {
+  visit(tree, "heading", (node) => {
+    if (node.children.length === 0) return;
+    const result = findTrailingId(node.children);
+    if (!result) return;
+    const data = node.data ?? {};
+    data.id = result.id;
+    data.hProperties = { ...data.hProperties ?? {}, id: result.id };
+    node.data = data;
+    stripId(node, result.index);
+  });
+}
+const remarkHeadingId = () => transformer;
+
+export { remarkHeadingId };

package/dist/remarkimage.d.ts

@@ -0,0 +1,11 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+interface RemarkImageOptions {
+    basePath?: string;
+    figure?: boolean;
+    lazyAfter?: number;
+}
+declare const remarkImage: Plugin<[RemarkImageOptions?], Root>;
+
+export { type RemarkImageOptions, remarkImage };

package/dist/remarkimage.js

@@ -0,0 +1,91 @@
+import { visit } from 'unist-util-visit';
+
+const dimensionPattern = /^(.+)\|(\d+)x(\d+)$/;
+function parseDimensions(alt) {
+  const match = alt.match(dimensionPattern);
+  if (!match) return { alt };
+  const text = match[1];
+  const width = match[2];
+  const height = match[3];
+  if (!text || !width || !height) return { alt };
+  return { alt: text, width: Number(width), height: Number(height) };
+}
+function resolveUrl(url, basePath) {
+  if (!basePath || url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//"))
+    return url;
+  if (url.startsWith("/")) return url;
+  return `${basePath.replace(/\/$/, "")}/${url}`;
+}
+function createImageProperties(parsed, url, isLazy) {
+  const props = {
+    src: url,
+    alt: parsed.alt,
+    loading: isLazy ? "lazy" : "eager",
+    decoding: "async"
+  };
+  if (parsed.width) props.width = parsed.width;
+  if (parsed.height) props.height = parsed.height;
+  return props;
+}
+function wrapInFigure(imageNode, alt) {
+  const children = [imageNode];
+  if (alt) {
+    children.push({
+      type: "mdxJsxFlowElement",
+      name: "figcaption",
+      attributes: [],
+      children: [{ type: "text", value: alt }]
+    });
+  }
+  const figure = {
+    type: "mdxJsxFlowElement",
+    name: "figure",
+    attributes: [],
+    children
+  };
+  return figure;
+}
+const remarkImage = (options = {}) => {
+  const { basePath, figure = false, lazyAfter = 0 } = options;
+  return (tree) => {
+    let imageIndex = 0;
+    visit(tree, "image", (node, index, parent) => {
+      if (!parent || index === void 0) return;
+      const current = imageIndex++;
+      const isLazy = current > lazyAfter;
+      const parsed = parseDimensions(node.alt || "");
+      const url = resolveUrl(node.url, basePath);
+      node.alt = parsed.alt;
+      node.url = url;
+      const data = node.data ?? {};
+      data.hProperties = createImageProperties(parsed, url, isLazy);
+      node.data = data;
+      if (figure) {
+        parent.children[index] = wrapInFigure(node, parsed.alt);
+      }
+    });
+    visit(tree, "html", (node) => {
+      const imgPattern = /<img\s([^>]*)>/g;
+      node.value = node.value.replace(imgPattern, (match, attrs) => {
+        const current = imageIndex++;
+        const isLazy = current > lazyAfter;
+        const loading = isLazy ? "lazy" : "eager";
+        let result = match;
+        if (!attrs.includes("loading=")) {
+          result = result.replace("<img ", `<img loading="${loading}" `);
+        }
+        if (!attrs.includes("decoding=")) {
+          result = result.replace("<img ", `<img decoding="async" `);
+        }
+        if (basePath) {
+          result = result.replace(/src="(?!https?:\/\/|\/\/)([^"]+)"/g, (_, src) => {
+            return `src="${resolveUrl(src, basePath)}"`;
+          });
+        }
+        return result;
+      });
+    });
+  };
+};
+
+export { remarkImage };

package/dist/remarkinclude.d.ts

@@ -0,0 +1,10 @@
+import { Root } from 'mdast';
+import { Plugin } from 'unified';
+
+interface IncludeOptions {
+    basePath?: string;
+    maxDepth?: number;
+}
+declare const remarkInclude: Plugin<[IncludeOptions?], Root>;
+
+export { type IncludeOptions, remarkInclude };

package/dist/remarkinclude.js

@@ -0,0 +1,49 @@
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+import { visit } from 'unist-util-visit';
+
+const pattern = /^@include\s+(.+)$/;
+const parser = unified().use(remarkParse);
+function inside(rootDir, filepath) {
+  const root = resolve(rootDir);
+  const full = resolve(filepath);
+  const rooted = `${root}/`;
+  return full === root || full.startsWith(rooted);
+}
+function expand(tree, rootDir, base, max, depth) {
+  if (depth > max) return;
+  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(pattern);
+    if (!match) return;
+    const includePath = match[1];
+    if (!includePath) return;
+    const filepath = resolve(base, includePath);
+    if (!inside(rootDir, filepath)) {
+      return;
+    }
+    let content;
+    try {
+      content = readFileSync(filepath, "utf-8");
+    } catch {
+      return;
+    }
+    const parsed = parser.parse(content);
+    const nodes = parsed.children;
+    parent.children.splice(index, 1, ...nodes);
+    const subtree = { type: "root", children: nodes };
+    expand(subtree, rootDir, dirname(filepath), max, depth + 1);
+  });
+}
+const remarkInclude = (options) => {
+  const rootDir = resolve(options?.basePath ?? ".");
+  const max = options?.maxDepth ?? 3;
+  return (tree) => expand(tree, rootDir, rootDir, max, 0);
+};
+
+export { remarkInclude };

package/dist/remarkinstall.d.ts

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