fromsrc 0.0.2 → 0.0.21

package/dist/rehypeslug.js

@@ -1,7 +1,7 @@
 import { visit } from 'unist-util-visit';
 
 function generateSlug(text) {
-  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return text.toLowerCase().replaceAll(/\s+/g, "-").replaceAll(/[^a-z0-9_-]/g, "").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
 }
 function extractText(node) {
   let text = "";
@@ -15,25 +15,29 @@ function extractText(node) {
   return text;
 }
 const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
-const rehypeSlug = () => {
-  return (tree) => {
-    const seen = /* @__PURE__ */ new Set();
-    visit(tree, "element", (node) => {
-      if (!headings.has(node.tagName)) return;
-      const raw = node.properties?.id;
-      const text = typeof raw === "string" && raw.length > 0 ? raw : extractText(node);
-      let slug = generateSlug(text);
-      if (!slug) return;
-      if (seen.has(slug)) {
-        let counter = 1;
-        while (seen.has(`${slug}-${counter}`)) counter++;
-        slug = `${slug}-${counter}`;
+const rehypeSlug = () => (tree) => {
+  const seen = /* @__PURE__ */ new Set();
+  visit(tree, "element", (node) => {
+    if (!headings.has(node.tagName)) {
+      return;
+    }
+    const raw = node.properties?.id;
+    const text = typeof raw === "string" && raw.length > 0 ? raw : extractText(node);
+    let slug = generateSlug(text);
+    if (!slug) {
+      return;
+    }
+    if (seen.has(slug)) {
+      let counter = 1;
+      while (seen.has(`${slug}-${counter}`)) {
+        counter++;
       }
-      seen.add(slug);
-      node.properties = node.properties || {};
-      node.properties.id = slug;
-    });
-  };
+      slug = `${slug}-${counter}`;
+    }
+    seen.add(slug);
+    node.properties = node.properties || {};
+    node.properties.id = slug;
+  });
 };
 
 export { generateSlug, rehypeSlug };

package/dist/rehypetablewrap.d.ts

@@ -1,9 +1,9 @@
 import { Root } from 'hast';
 import { Plugin } from 'unified';
 
-type TableWrapOptions = {
+interface TableWrapOptions {
     className?: string;
-};
+}
 declare const rehypeTableWrap: Plugin<[TableWrapOptions?], Root>;
 
 export { type TableWrapOptions, rehypeTableWrap };

package/dist/rehypetablewrap.js

@@ -4,17 +4,21 @@ const rehypeTableWrap = (options) => {
   const className = options?.className ?? "overflow-x-auto";
   return (tree) => {
     visit(tree, "element", (node, index, parent) => {
-      if (node.tagName !== "table") return;
-      if (!parent || index === void 0) return;
+      if (node.tagName !== "table") {
+        return;
+      }
+      if (!parent || index === void 0) {
+        return;
+      }
       const wrapper = {
-        type: "element",
-        tagName: "div",
+        children: [node],
         properties: {
           className: [className],
           role: "region",
           tabIndex: 0
         },
-        children: [node]
+        tagName: "div",
+        type: "element"
       };
       parent.children[index] = wrapper;
     });

package/dist/rehypetoc.d.ts

@@ -1,5 +1,5 @@
-import { Plugin } from 'unified';
 import { Root } from 'hast';
+import { Plugin } from 'unified';
 
 interface TocEntry {
     id: string;

package/dist/rehypetoc.js

@@ -25,15 +25,19 @@ function buildTree(headings) {
   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;
+      const last = stack.at(-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);
+      const parent = stack.at(-1);
+      if (parent) {
+        parent.children.push(node);
+      }
     }
     stack.push(node);
   }
@@ -46,12 +50,16 @@ const rehypeToc = (options) => {
     const headings = [];
     visit(tree, "element", (node) => {
       const level = levelMap[node.tagName];
-      if (!level || level < min || level > max) return;
+      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 });
+      if (!id || !text) {
+        return;
+      }
+      headings.push({ id, level, text });
     });
     file.data["headings"] = headings;
     file.data["toc"] = buildTree(headings);

package/dist/remark.js

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

package/dist/remarkadmonition.js

@@ -1,37 +1,61 @@
-const types = /* @__PURE__ */ new Set(["note", "tip", "info", "warning", "danger", "caution", "important"]);
+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("");
+  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;
+  if (node.type !== "paragraph") {
+    return null;
+  }
   const text = extractText(node).trim();
   const match = text.match(openPattern);
-  if (!match) return null;
+  if (!match) {
+    return null;
+  }
   const raw = match[1];
-  if (!raw) return null;
+  if (!raw) {
+    return null;
+  }
   const kind = raw.toLowerCase();
-  if (!types.has(kind)) return null;
+  if (!types.has(kind)) {
+    return null;
+  }
   return { kind, title: match[2]?.trim() || void 0 };
 }
 function isClose(node) {
-  if (node.type !== "paragraph") return false;
+  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 }];
+  const attrs = [
+    { name: "type", type: "mdxJsxAttribute", value: kind }
+  ];
   if (title) {
-    attrs.push({ type: "mdxJsxAttribute", name: "title", value: title });
+    attrs.push({ name: "title", type: "mdxJsxAttribute", value: title });
   }
   return {
-    type: "mdxJsxFlowElement",
-    name: "Callout",
     attributes: attrs,
     children,
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "Callout",
+    type: "mdxJsxFlowElement"
   };
 }
 function processChildren(nodes) {
@@ -56,7 +80,9 @@ function processChildren(nodes) {
     i++;
     while (i < nodes.length) {
       const child = nodes[i];
-      if (!child || isClose(child)) break;
+      if (!child || isClose(child)) {
+        break;
+      }
       inner.push(child);
       i++;
     }

package/dist/remarkannotation.d.ts

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

package/dist/remarkannotation.js

@@ -7,10 +7,16 @@ const patterns = [
 ];
 const validTypes = /* @__PURE__ */ new Set(["highlight", "focus", "warning", "error"]);
 function parseType(raw) {
-  if (raw === "++") return "added";
-  if (raw === "--") return "removed";
+  if (raw === "++") {
+    return "added";
+  }
+  if (raw === "--") {
+    return "removed";
+  }
   const lower = raw.toLowerCase();
-  if (validTypes.has(lower)) return lower;
+  if (validTypes.has(lower)) {
+    return lower;
+  }
   return null;
 }
 function matchAnnotation(line) {
@@ -18,12 +24,16 @@ function matchAnnotation(line) {
     const match = line.match(pattern);
     if (match) {
       const raw = match[1];
-      if (!raw) continue;
+      if (!raw) {
+        continue;
+      }
       const parsed = parseType(raw);
-      if (!parsed) continue;
+      if (!parsed) {
+        continue;
+      }
       return {
-        type: parsed,
-        cleaned: line.replace(pattern, "").trimEnd()
+        cleaned: line.replace(pattern, "").trimEnd(),
+        type: parsed
       };
     }
   }
@@ -31,14 +41,18 @@ function matchAnnotation(line) {
 }
 function transformer(tree) {
   visit(tree, "code", (node) => {
-    if (!node.value) return;
+    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;
+      if (line === void 0) {
+        continue;
+      }
       const result = matchAnnotation(line);
       if (result) {
         annotations.push({ line: i + 1, type: result.type });
@@ -48,7 +62,9 @@ function transformer(tree) {
         cleaned.push(line);
       }
     }
-    if (annotations.length === 0) return;
+    if (annotations.length === 0) {
+      return;
+    }
     node.value = cleaned.join("\n");
     const data = node.data ?? {};
     data.annotations = annotations;

package/dist/remarkbadge.js

@@ -2,39 +2,51 @@ 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 });
+  visit(
+    tree,
+    "text",
+    (node, index, parent) => {
+      if (!parent || index === void 0) {
+        return;
+      }
+      const { value } = node;
+      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({
+          attributes: [
+            { name: "variant", type: "mdxJsxAttribute", value: variant }
+          ],
+          children: [{ type: "text", value: text }],
+          data: { _mdxExplicitJsx: true },
+          name: "Badge",
+          type: "mdxJsxTextElement"
+        });
+        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);
       }
-      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.js

@@ -4,20 +4,20 @@ const langs = /* @__PURE__ */ new Set(["math", "latex", "katex"]);
 const inlinePattern = /(?<!\$)\$(?!\$)(.+?)(?<!\$)\$(?!\$)/;
 function blockElement(value) {
   return {
-    type: "mdxJsxFlowElement",
-    name: "BlockMath",
-    attributes: [{ type: "mdxJsxAttribute", name: "math", value }],
+    attributes: [{ name: "math", type: "mdxJsxAttribute", value }],
     children: [],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "BlockMath",
+    type: "mdxJsxFlowElement"
   };
 }
 function inlineElement(value) {
   return {
-    type: "mdxJsxTextElement",
-    name: "InlineMath",
-    attributes: [{ type: "mdxJsxAttribute", name: "math", value }],
+    attributes: [{ name: "math", type: "mdxJsxAttribute", value }],
     children: [],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "InlineMath",
+    type: "mdxJsxTextElement"
   };
 }
 function splitInline(text) {
@@ -26,29 +26,43 @@ function splitInline(text) {
   while (remaining) {
     const match = remaining.match(inlinePattern);
     if (!match || match.index === void 0) {
-      if (remaining) nodes.push({ type: "text", value: remaining });
+      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));
+    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;
+    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;
+    if (!parent || index === void 0) {
+      return;
+    }
+    if (!inlinePattern.test(node.value)) {
+      return;
+    }
     const nodes = splitInline(node.value);
-    if (nodes.length <= 1) return;
+    if (nodes.length <= 1) {
+      return;
+    }
     parent.children.splice(index, 1, ...nodes);
   });
 }

package/dist/remarkcallout.js

@@ -2,26 +2,34 @@ import { visit } from 'unist-util-visit';
 
 const pattern = /^\[!(\w+)\]\s*/;
 const typeMap = {
+  caution: { name: "Callout", type: "danger" },
+  important: { name: "Note", type: "important" },
   note: { name: "Note" },
   tip: { name: "Callout", type: "tip" },
-  warning: { name: "Callout", type: "warning" },
-  important: { name: "Note", type: "important" },
-  caution: { name: "Callout", type: "danger" }
+  warning: { name: "Callout", type: "warning" }
 };
 function extractType(node) {
   const first = node.children[0];
-  if (first?.type !== "paragraph") return null;
+  if (first?.type !== "paragraph") {
+    return null;
+  }
   const text = first.children?.[0];
-  if (text?.type !== "text" || !text.value) return null;
+  if (text?.type !== "text" || !text.value) {
+    return null;
+  }
   const match = text.value.match(pattern);
-  if (!match) return null;
+  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;
+  if (first?.type !== "paragraph") {
+    return children;
+  }
   const para = { ...first, children: [...first.children] };
   const text = para.children[0];
   if (text?.type === "text" && text.value) {
@@ -41,21 +49,31 @@ function stripPrefix(node) {
 }
 function transformer(tree) {
   visit(tree, "blockquote", (node, index, parent) => {
-    if (!parent || index === void 0) return;
+    if (!parent || index === void 0) {
+      return;
+    }
     const calloutType = extractType(node);
-    if (!calloutType) return;
+    if (!calloutType) {
+      return;
+    }
     const mapping = typeMap[calloutType];
-    if (!mapping) return;
+    if (!mapping) {
+      return;
+    }
     const attrs = [];
     if (mapping.type) {
-      attrs.push({ type: "mdxJsxAttribute", name: "type", value: mapping.type });
+      attrs.push({
+        name: "type",
+        type: "mdxJsxAttribute",
+        value: mapping.type
+      });
     }
     const element = {
-      type: "mdxJsxFlowElement",
-      name: mapping.name,
       attributes: attrs,
       children: stripPrefix(node),
-      data: { _mdxExplicitJsx: true }
+      data: { _mdxExplicitJsx: true },
+      name: mapping.name,
+      type: "mdxJsxFlowElement"
     };
     parent.children[index] = element;
   });