fromsrc 0.0.2 → 0.0.21

package/dist/remarkfootnote.js

@@ -2,29 +2,50 @@ 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 attr = (name, value) => ({
+  name,
+  type: "mdxJsxAttribute",
+  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;
+  if (!root.children) {
+    return;
+  }
   root.children = root.children.filter((node) => {
-    if (node.type !== "paragraph") return true;
+    if (node.type !== "paragraph") {
+      return true;
+    }
     const text = node.children?.[0];
-    if (text?.type !== "text" || !text.value) return true;
+    if (text?.type !== "text" || !text.value) {
+      return true;
+    }
     const match = text.value.match(defPattern);
-    if (!match) return true;
+    if (!match) {
+      return true;
+    }
     const id = match[1];
     const value = match[2];
-    if (!id || value === void 0) return true;
+    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;
+    if (!parent || index === void 0) {
+      return;
+    }
     const text = node.value;
-    if (!refPattern.test(text)) return;
+    if (!refPattern.test(text)) {
+      return;
+    }
     refPattern.lastIndex = 0;
     const parts = [];
     let last = 0;
@@ -34,14 +55,21 @@ const remarkFootnote = () => (tree) => {
         parts.push({ type: "text", value: text.slice(last, match.index) });
       }
       const id = match[1];
-      if (!id) continue;
-      if (!seen.includes(id)) seen.push(id);
+      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)))],
+        attributes: [
+          attr("id", id),
+          attr("index", expr(String(seen.indexOf(id) + 1)))
+        ],
         children: [],
-        data: { _mdxExplicitJsx: true }
+        data: { _mdxExplicitJsx: true },
+        name: "FootnoteRef",
+        type: "mdxJsxTextElement"
       });
       last = match.index + match[0].length;
     }
@@ -52,11 +80,11 @@ const remarkFootnote = () => (tree) => {
   });
   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 }
+    data: { _mdxExplicitJsx: true },
+    name: "FootnoteList",
+    type: "mdxJsxFlowElement"
   });
 };
 

package/dist/remarkgfm.js

@@ -3,20 +3,22 @@ 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 }
+    data: { _mdxExplicitJsx: true },
+    name: "del",
+    type: "mdxJsxTextElement"
   };
 }
 function makeLink(url) {
   return {
-    type: "mdxJsxTextElement",
-    name: "a",
-    attributes: [{ type: "mdxJsxAttribute", name: "href", value: url }],
+    attributes: [
+      { name: "href", type: "mdxJsxAttribute", value: url }
+    ],
     children: [{ type: "text", value: url }],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "a",
+    type: "mdxJsxTextElement"
   };
 }
 function transformer(tree) {
@@ -47,7 +49,10 @@ function transformer(tree) {
         cursor = match.index + match[0].length;
       }
       if (cursor < child.value.length) {
-        next.push({ type: "text", value: child.value.slice(cursor) });
+        next.push({
+          type: "text",
+          value: child.value.slice(cursor)
+        });
       }
     }
     if (changed) {

package/dist/remarkheadingid.js

@@ -4,18 +4,24 @@ 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) {
+      continue;
+    }
     if (child.type === "text") {
       const match = child.value.match(pattern);
       const id = match?.[1];
-      if (id) return { index: i, id };
+      if (id) {
+        return { id, index: i };
+      }
     }
   }
   return null;
 }
 function stripId(node, index) {
   const child = node.children[index];
-  if (!child || child.type !== "text") return;
+  if (!child || child.type !== "text") {
+    return;
+  }
   const stripped = child.value.replace(pattern, "");
   if (stripped) {
     node.children[index] = { ...child, value: stripped };
@@ -25,12 +31,16 @@ function stripId(node, index) {
 }
 function transformer(tree) {
   visit(tree, "heading", (node) => {
-    if (node.children.length === 0) return;
+    if (node.children.length === 0) {
+      return;
+    }
     const result = findTrailingId(node.children);
-    if (!result) return;
+    if (!result) {
+      return;
+    }
     const data = node.data ?? {};
     data.id = result.id;
-    data.hProperties = { ...data.hProperties ?? {}, id: result.id };
+    data.hProperties = { ...data.hProperties, id: result.id };
     node.data = data;
     stripId(node, result.index);
   });

package/dist/remarkimage.js

@@ -3,45 +3,56 @@ import { visit } from 'unist-util-visit';
 const dimensionPattern = /^(.+)\|(\d+)x(\d+)$/;
 function parseDimensions(alt) {
   const match = alt.match(dimensionPattern);
-  if (!match) return { alt };
+  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) };
+  if (!text || !width || !height) {
+    return { alt };
+  }
+  return { alt: text, height: Number(height), width: Number(width) };
 }
 function resolveUrl(url, basePath) {
-  if (!basePath || url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//"))
+  if (!basePath || url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) {
+    return url;
+  }
+  if (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,
+    decoding: "async",
     loading: isLazy ? "lazy" : "eager",
-    decoding: "async"
+    src: url
   };
-  if (parsed.width) props.width = parsed.width;
-  if (parsed.height) props.height = parsed.height;
+  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 }]
+      children: [{ type: "text", value: alt }],
+      name: "figcaption",
+      type: "mdxJsxFlowElement"
     });
   }
   const figure = {
-    type: "mdxJsxFlowElement",
-    name: "figure",
     attributes: [],
-    children
+    children,
+    name: "figure",
+    type: "mdxJsxFlowElement"
   };
   return figure;
 }
@@ -50,7 +61,9 @@ const remarkImage = (options = {}) => {
   return (tree) => {
     let imageIndex = 0;
     visit(tree, "image", (node, index, parent) => {
-      if (!parent || index === void 0) return;
+      if (!parent || index === void 0) {
+        return;
+      }
       const current = imageIndex++;
       const isLazy = current > lazyAfter;
       const parsed = parseDimensions(node.alt || "");
@@ -61,29 +74,36 @@ const remarkImage = (options = {}) => {
       data.hProperties = createImageProperties(parsed, url, isLazy);
       node.data = data;
       if (figure) {
-        parent.children[index] = wrapInFigure(node, parsed.alt);
+        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)}"`;
-          });
+      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.replaceAll(
+              /src="(?!https?:\/\/|\/\/)([^"]+)"/g,
+              (_, src) => `src="${resolveUrl(src, basePath)}"`
+            );
+          }
+          return result;
         }
-        return result;
-      });
+      );
     });
   };
 };

package/dist/remarkinclude.js

@@ -13,30 +13,42 @@ function inside(rootDir, filepath) {
   return full === root || full.startsWith(rooted);
 }
 function expand(tree, rootDir, base, max, depth) {
-  if (depth > max) return;
+  if (depth > max) {
+    return;
+  }
   visit(tree, "paragraph", (node, index, parent) => {
-    if (!parent || index === void 0) return;
-    if (node.children.length !== 1) return;
+    if (!parent || index === void 0) {
+      return;
+    }
+    if (node.children.length !== 1) {
+      return;
+    }
     const child = node.children[0];
-    if (child?.type !== "text") return;
+    if (child?.type !== "text") {
+      return;
+    }
     const match = child.value.trim().match(pattern);
-    if (!match) return;
+    if (!match) {
+      return;
+    }
     const includePath = match[1];
-    if (!includePath) return;
+    if (!includePath) {
+      return;
+    }
     const filepath = resolve(base, includePath);
     if (!inside(rootDir, filepath)) {
       return;
     }
     let content;
     try {
-      content = readFileSync(filepath, "utf-8");
+      content = readFileSync(filepath, "utf8");
     } catch {
       return;
     }
     const parsed = parser.parse(content);
     const nodes = parsed.children;
     parent.children.splice(index, 1, ...nodes);
-    const subtree = { type: "root", children: nodes };
+    const subtree = { children: nodes, type: "root" };
     expand(subtree, rootDir, dirname(filepath), max, depth + 1);
   });
 }

package/dist/remarkinstall.js

@@ -1,34 +1,42 @@
 import { visit } from 'unist-util-visit';
 
 function attribute(name, value) {
-  return { type: "mdxJsxAttribute", name, value };
+  return { name, type: "mdxJsxAttribute", value };
 }
 function commands(pkg, dev) {
   if (dev) {
     return {
+      bun: `bun add -d ${pkg}`,
       npm: `npm install -D ${pkg}`,
-      yarn: `yarn add -D ${pkg}`,
       pnpm: `pnpm add -D ${pkg}`,
-      bun: `bun add -d ${pkg}`
+      yarn: `yarn add -D ${pkg}`
     };
   }
   return {
+    bun: `bun add ${pkg}`,
     npm: `npm install ${pkg}`,
-    yarn: `yarn add ${pkg}`,
     pnpm: `pnpm add ${pkg}`,
-    bun: `bun add ${pkg}`
+    yarn: `yarn add ${pkg}`
   };
 }
 function transformer(tree) {
   visit(tree, "code", (node, index, parent) => {
-    if (!parent || index === void 0) return;
+    if (!parent || index === void 0) {
+      return;
+    }
     const isInstall = node.lang === "install" || node.meta && node.meta.includes("install");
-    if (!isInstall) return;
+    if (!isInstall) {
+      return;
+    }
     const raw = node.value.trim();
-    if (!raw) return;
+    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;
+    if (!pkg) {
+      return;
+    }
     const cmds = commands(pkg, dev);
     const attrs = [
       attribute("packages", pkg),
@@ -38,11 +46,11 @@ function transformer(tree) {
       attribute("bun", cmds.bun)
     ];
     const element = {
-      type: "mdxJsxFlowElement",
-      name: "Install",
       attributes: attrs,
       children: [],
-      data: { _mdxExplicitJsx: true }
+      data: { _mdxExplicitJsx: true },
+      name: "Install",
+      type: "mdxJsxFlowElement"
     };
     parent.children[index] = element;
   });

package/dist/remarklinkcard.js

@@ -1,37 +1,56 @@
 import { visit } from 'unist-util-visit';
 
 function extract(node) {
-  if (node.children.length !== 1) return null;
+  if (node.children.length !== 1) {
+    return null;
+  }
   const child = node.children[0];
-  if (!child) return null;
-  if (child.type !== "link") return null;
+  if (!child) {
+    return null;
+  }
+  if (child.type !== "link") {
+    return null;
+  }
   const link = child;
-  if (!link.url.startsWith("https://")) return null;
+  if (!link.url.startsWith("https://")) {
+    return null;
+  }
   const text = link.children[0];
-  if (!text || text.type !== "text") return null;
+  if (!text || text.type !== "text") {
+    return null;
+  }
   const raw = text.value;
-  if (!raw.startsWith("card")) return null;
+  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 }
+      { name: "href", type: "mdxJsxAttribute", value: href },
+      { name: "title", type: "mdxJsxAttribute", value: title }
     ],
     children: [],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "LinkCard",
+    type: "mdxJsxFlowElement"
   };
 }
 const remarkLinkCard = () => (tree) => {
   visit(tree, "paragraph", (node, index, parent) => {
-    if (!parent || index === void 0) return;
+    if (!parent || index === void 0) {
+      return;
+    }
     const result = extract(node);
-    if (!result) return;
-    parent.children[index] = makeNode(result.href, result.title);
+    if (!result) {
+      return;
+    }
+    parent.children[index] = makeNode(
+      result.href,
+      result.title
+    );
   });
 };
 

package/dist/remarkmath.js

@@ -4,32 +4,46 @@ const blockPattern = /^\$\$([\s\S]*)\$\$$/;
 const inlinePattern = /\$([^$]+)\$/g;
 function makeInline(math) {
   return {
-    type: "mdxJsxTextElement",
-    name: "InlineMath",
-    attributes: [{ type: "mdxJsxAttribute", name: "math", value: math }],
+    attributes: [
+      { name: "math", type: "mdxJsxAttribute", value: math }
+    ],
     children: [],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "InlineMath",
+    type: "mdxJsxTextElement"
   };
 }
 function makeBlock(math) {
   return {
-    type: "mdxJsxFlowElement",
-    name: "BlockMath",
-    attributes: [{ type: "mdxJsxAttribute", name: "math", value: math }],
+    attributes: [
+      { name: "math", type: "mdxJsxAttribute", value: math }
+    ],
     children: [],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "BlockMath",
+    type: "mdxJsxFlowElement"
   };
 }
 function transformer(tree) {
   visit(tree, "paragraph", (node, index, parent) => {
-    if (!parent || index === void 0) return;
-    if (node.children.length !== 1) return;
+    if (!parent || index === void 0) {
+      return;
+    }
+    if (node.children.length !== 1) {
+      return;
+    }
     const child = node.children[0];
-    if (child?.type !== "text") return;
+    if (child?.type !== "text") {
+      return;
+    }
     const match = child.value.trim().match(blockPattern);
-    if (!match) return;
+    if (!match) {
+      return;
+    }
     const block = match[1];
-    if (block === void 0) return;
+    if (block === void 0) {
+      return;
+    }
     parent.children[index] = makeBlock(block.trim());
   });
   visit(tree, "paragraph", (node) => {
@@ -52,11 +66,16 @@ function transformer(tree) {
           });
         }
         const inline = match[1];
-        if (inline !== void 0) next.push(makeInline(inline));
+        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) });
+        next.push({
+          type: "text",
+          value: child.value.slice(cursor)
+        });
       }
     }
     if (changed) {

package/dist/remarkmermaid.js

@@ -2,16 +2,20 @@ 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;
+    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 }
+        { name: "chart", type: "mdxJsxAttribute", value: node.value }
       ],
       children: [],
-      data: { _mdxExplicitJsx: true }
+      data: { _mdxExplicitJsx: true },
+      name: "Mermaid",
+      type: "mdxJsxFlowElement"
     };
     parent.children[index] = element;
   });

package/dist/remarkmeta.d.ts

@@ -1,14 +1,14 @@
 import { Root } from 'mdast';
 import { Plugin } from 'unified';
 
-type CodeMeta = {
+interface 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>;