fromsrc 0.0.2 → 0.0.21

package/dist/remarkcaption.js

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

package/dist/remarkcodetitle.js

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

package/dist/remarkcolumns.js

@@ -12,11 +12,11 @@ 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 }
+    data: { _mdxExplicitJsx: true },
+    name,
+    type: "mdxJsxFlowElement"
   };
 }
 function processChildren(nodes) {
@@ -30,38 +30,50 @@ function processChildren(nodes) {
     }
     const open = isColumnsOpen(node);
     if (!open) {
-      if (node.children) node.children = processChildren(node.children);
+      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 });
+      attrs.push({ name: "count", type: "mdxJsxAttribute", value: open.count });
     }
     const columns = [];
     let current = null;
     i++;
     while (i < nodes.length) {
       const child = nodes[i];
-      if (!child || isClose(child)) break;
+      if (!child || isClose(child)) {
+        break;
+      }
       if (isColumnOpen(child)) {
-        if (current) columns.push(mdx("Column", [], current));
+        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++;
+    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);
+  if (root.children) {
+    root.children = processChildren(root.children);
+  }
 };
 
 export { remarkColumns };

package/dist/remarkdetails.js

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

package/dist/remarkdirective.js

@@ -1,4 +1,11 @@
-const directives = /* @__PURE__ */ new Set(["note", "tip", "warning", "danger", "info", "caution"]);
+const directives = /* @__PURE__ */ new Set([
+  "note",
+  "tip",
+  "warning",
+  "danger",
+  "info",
+  "caution"
+]);
 const openPattern = /^:::(\w+)(?:\{(.+?)\})?$/;
 function parseAttributes(raw) {
   const attrs = {};
@@ -7,53 +14,69 @@ function parseAttributes(raw) {
   while ((match = regex.exec(raw)) !== null) {
     const key = match[1];
     const value = match[2];
-    if (!key || value === void 0) continue;
+    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("");
+  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 name = raw.toLowerCase();
-  if (!directives.has(name)) return null;
+  if (!directives.has(name)) {
+    return null;
+  }
   const attrs = match[2] ? parseAttributes(match[2]) : {};
-  return { type: name, attrs };
+  return { attrs, type: name };
 }
 function isClose(node) {
-  if (node.type !== "paragraph") return false;
+  if (node.type !== "paragraph") {
+    return false;
+  }
   return extractText(node).trim() === ":::";
 }
 function attribute(name, value) {
-  return { type: "mdxJsxAttribute", name, value };
+  return { name, type: "mdxJsxAttribute", value };
 }
 const defaultTitles = {
-  note: "Note",
-  tip: "Tip",
-  warning: "Warning",
+  caution: "Caution",
   danger: "Danger",
   info: "Info",
-  caution: "Caution"
+  note: "Note",
+  tip: "Tip",
+  warning: "Warning"
 };
 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 }
+    data: { _mdxExplicitJsx: true },
+    name: "Callout",
+    type: "mdxJsxFlowElement"
   };
 }
 function processChildren(nodes) {
@@ -61,7 +84,9 @@ function processChildren(nodes) {
   let i = 0;
   while (i < nodes.length) {
     const node = nodes[i];
-    if (!node) break;
+    if (!node) {
+      break;
+    }
     const open = isOpen(node);
     if (!open) {
       if (node.children) {
@@ -75,7 +100,9 @@ function processChildren(nodes) {
     i++;
     while (i < nodes.length) {
       const current = nodes[i];
-      if (!current || isClose(current)) break;
+      if (!current || isClose(current)) {
+        break;
+      }
       inner.push(current);
       i++;
     }

package/dist/remarkembed.js

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

package/dist/remarkfiletree.js

@@ -1,29 +1,35 @@
 import { visit } from 'unist-util-visit';
 
 function attribute(name, value) {
-  return { type: "mdxJsxAttribute", name, value };
+  return { name, type: "mdxJsxAttribute", value };
 }
 function parse(content) {
   const lines = content.split("\n").filter((l) => l.trim().length > 0);
   const root = [];
-  const stack = [{ depth: -1, children: root }];
+  const stack = [
+    { children: root, depth: -1 }
+  ];
   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: [] };
+    const node = { children: [], folder, name };
     while (stack.length > 1) {
-      const last = stack[stack.length - 1];
-      if (!last || last.depth < depth) break;
+      const last = stack.at(-1);
+      if (!last || last.depth < depth) {
+        break;
+      }
       stack.pop();
     }
-    const parent = stack[stack.length - 1];
-    if (!parent) continue;
+    const parent = stack.at(-1);
+    if (!parent) {
+      continue;
+    }
     parent.children.push(node);
     if (folder) {
-      stack.push({ depth, children: node.children });
+      stack.push({ children: node.children, depth });
     }
   }
   return root;
@@ -31,33 +37,37 @@ function parse(content) {
 function toElement(node) {
   if (node.folder) {
     return {
-      type: "mdxJsxFlowElement",
-      name: "Folder",
       attributes: [attribute("name", node.name)],
       children: node.children.map(toElement),
-      data: { _mdxExplicitJsx: true }
+      data: { _mdxExplicitJsx: true },
+      name: "Folder",
+      type: "mdxJsxFlowElement"
     };
   }
   return {
-    type: "mdxJsxFlowElement",
-    name: "File",
     attributes: [attribute("name", node.name)],
     children: [],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "File",
+    type: "mdxJsxFlowElement"
   };
 }
 function transformer(tree) {
   visit(tree, "code", (node, index, parent) => {
-    if (!parent || index === void 0) return;
+    if (!parent || index === void 0) {
+      return;
+    }
     const isFiletree = node.lang === "filetree" || node.meta?.includes("filetree");
-    if (!isFiletree) return;
+    if (!isFiletree) {
+      return;
+    }
     const nodes = parse(node.value);
     const element = {
-      type: "mdxJsxFlowElement",
-      name: "Files",
       attributes: [],
       children: nodes.map(toElement),
-      data: { _mdxExplicitJsx: true }
+      data: { _mdxExplicitJsx: true },
+      name: "Files",
+      type: "mdxJsxFlowElement"
     };
     parent.children[index] = element;
   });