fromsrc 0.0.2 → 0.0.21

package/dist/remarkmeta.js

@@ -9,18 +9,24 @@ function parseRange(raw) {
       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);
+        for (let i = a; i <= b; i++) {
+          result.push(i);
+        }
       }
     } else {
       const n = Number.parseInt(trimmed, 10);
-      if (!Number.isNaN(n)) result.push(n);
+      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);
+  if (/^[\d,\s-]+$/.test(inner)) {
+    return parseRange(inner);
+  }
   try {
     return JSON.parse(raw);
   } catch {
@@ -35,7 +41,9 @@ function parseMeta(meta) {
     if (match[1] && match[2]) {
       const key = match[1];
       const val = match[2];
-      if (!key || !val) continue;
+      if (!key || !val) {
+        continue;
+      }
       if (val.startsWith('"') || val.startsWith("'")) {
         result[key] = val.slice(1, -1);
       } else {
@@ -51,7 +59,9 @@ function parseMeta(meta) {
 }
 function transformer(tree) {
   visit(tree, "code", (node) => {
-    if (!node.meta) return;
+    if (!node.meta) {
+      return;
+    }
     const meta = parseMeta(node.meta);
     const data = node.data ?? {};
     data.meta = meta;

package/dist/remarkreadingtime.d.ts

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

package/dist/remarkreadingtime.js

@@ -2,7 +2,9 @@ import { visit } from 'unist-util-visit';
 
 function countWords(text) {
   const trimmed = text.trim();
-  if (!trimmed) return 0;
+  if (!trimmed) {
+    return 0;
+  }
   return trimmed.split(/\s+/).length;
 }
 function collectText(node) {

package/dist/remarksteps.js

@@ -1,15 +1,21 @@
 import { visit } from 'unist-util-visit';
 
 function isStepsList(node) {
-  if (!node.ordered) return false;
+  if (!node.ordered) {
+    return false;
+  }
   return node.children.every((item) => {
     const first = item.children[0];
-    if (!first || first.type !== "paragraph") return false;
+    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 "";
+  if (!strong || !("children" in strong) || !Array.isArray(strong.children)) {
+    return "";
+  }
   return strong.children.map((child) => "value" in child ? child.value ?? "" : "").join("");
 }
 function makeStep(item) {
@@ -22,32 +28,38 @@ function makeStep(item) {
   const children = [];
   if (trimmed.length > 0) {
     children.push({
-      type: "paragraph",
-      children: trimmed
+      children: trimmed,
+      type: "paragraph"
     });
   }
   for (const child of item.children.slice(1)) {
     children.push(child);
   }
   return {
-    type: "mdxJsxFlowElement",
-    name: "Step",
-    attributes: [{ type: "mdxJsxAttribute", name: "title", value: title }],
+    attributes: [
+      { name: "title", type: "mdxJsxAttribute", value: title }
+    ],
     children,
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "Step",
+    type: "mdxJsxFlowElement"
   };
 }
 function transformer(tree) {
   visit(tree, "list", (node, index, parent) => {
-    if (!parent || index === void 0) return;
-    if (!isStepsList(node)) return;
+    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 }
+      data: { _mdxExplicitJsx: true },
+      name: "Steps",
+      type: "mdxJsxFlowElement"
     };
   });
 }

package/dist/remarkstructure.js

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

package/dist/remarktabs.js

@@ -1,40 +1,57 @@
 import { visit } from 'unist-util-visit';
 
 function attribute(name, value) {
-  return { type: "mdxJsxAttribute", name, value };
+  return { name, type: "mdxJsxAttribute", 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;
+    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;
+      if (sibling?.type !== "code") {
+        break;
+      }
+      if (skipped(sibling)) {
+        break;
+      }
       group.push(sibling);
       next++;
     }
-    if (group.length < 2) return;
+    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")],
+      attributes: [
+        attribute("label", code.lang ?? "text"),
+        attribute("value", code.lang ?? "text")
+      ],
       children: [code],
-      data: { _mdxExplicitJsx: true }
+      data: { _mdxExplicitJsx: true },
+      name: "CodeTab",
+      type: "mdxJsxFlowElement"
     }));
     const element = {
-      type: "mdxJsxFlowElement",
-      name: "CodeGroup",
       attributes: [],
       children: tabs,
-      data: { _mdxExplicitJsx: true }
+      data: { _mdxExplicitJsx: true },
+      name: "CodeGroup",
+      type: "mdxJsxFlowElement"
     };
-    parent.children.splice(index, group.length, element);
+    parent.children.splice(
+      index,
+      group.length,
+      element
+    );
   });
 }
 const remarkTabs = () => transformer;

package/dist/remarktoc.js

@@ -8,40 +8,56 @@ function textContent(node) {
   return parts.join("");
 }
 function slugify(text) {
-  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  return text.toLowerCase().replaceAll(/\s+/g, "-").replaceAll(/[^a-z0-9-]/g, "");
 }
 function isTocMarker(node) {
-  if (node.type !== "paragraph") return false;
-  if (node.children?.length !== 1) return false;
+  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;
+    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;
+    if (!text) {
+      return;
+    }
+    items.push({ depth: node.depth, slug: slugify(text), text });
   });
+  visit(
+    tree,
+    "paragraph",
+    (node, index, parent) => {
+      if (!parent || index === void 0) {
+        return;
+      }
+      if (!isTocMarker(node)) {
+        return;
+      }
+      const element = {
+        attributes: [
+          {
+            name: "items",
+            type: "mdxJsxAttribute",
+            value: JSON.stringify(items)
+          }
+        ],
+        children: [],
+        data: { _mdxExplicitJsx: true },
+        name: "TableOfContents",
+        type: "mdxJsxFlowElement"
+      };
+      parent.children[index] = element;
+    }
+  );
 };
 
 export { remarkToc };

package/dist/remarkts2js.js

@@ -2,37 +2,40 @@ 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");
+  result = result.replaceAll(/import\s+type\s+.*?from\s+['"].*?['"]/g, "");
+  result = result.replaceAll(
+    /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.replaceAll(/\binterface\s+\w+\s*\{[^}]*\}/g, "");
+  result = result.replaceAll(/\btype\s+\w+\s*=\s*[^;\n]+[;\n]/g, "");
+  result = result.replaceAll(/\btype\s+\w+\s*<[^>]+>\s*=\s*[^;\n]+[;\n]/g, "");
+  result = result.replaceAll(/<[^>]+>/g, "");
+  result = result.replaceAll(
+    /:\s*\w+(\[\])?(\s*\|\s*\w+(\[\])?)*(?=\s*[,;=)\]}])/g,
+    ""
+  );
+  result = result.replaceAll(/:\s*\{[^}]*\}/g, "");
+  result = result.replaceAll(/:\s*\([^)]*\)\s*=>/g, "");
+  result = result.replaceAll(/\bas\s+\w+/g, "");
+  result = result.replaceAll("!", "");
+  result = result.replaceAll(/\breadonly\s+/g, "");
+  result = result.replaceAll(
+    /\.tsx?\b/g,
+    (match) => match === ".tsx" ? ".jsx" : ".js"
+  );
+  result = result.replaceAll(/\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",
@@ -47,11 +50,11 @@ function createCodeGroup(tsCode, jsCode, lang) {
             meta: null,
             value: tsCode
           }
-        ]
+        ],
+        name: "CodeTab",
+        type: "mdxJsxFlowElement"
       },
       {
-        type: "mdxJsxFlowElement",
-        name: "CodeTab",
         attributes: [
           {
             type: "mdxJsxAttribute",
@@ -66,23 +69,31 @@ function createCodeGroup(tsCode, jsCode, lang) {
             meta: null,
             value: jsCode
           }
-        ]
+        ],
+        name: "CodeTab",
+        type: "mdxJsxFlowElement"
       }
-    ]
+    ],
+    name: "CodeGroup",
+    type: "mdxJsxFlowElement"
   };
 }
-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;
-    });
-  };
+const remarkTs2Js = () => (tree) => {
+  visit(tree, "code", (node, index, parent) => {
+    if (!parent || index === null || index === void 0 || typeof index !== "number") {
+      return;
+    }
+    const { lang } = node;
+    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 };

package/dist/remarktwoslash.d.ts

@@ -1,17 +1,17 @@
 import { Root } from 'mdast';
 import { Plugin } from 'unified';
 
-type TwoslashAnnotation = {
+interface TwoslashAnnotation {
     type: "query" | "completion";
     line: number;
     character: number;
     text?: string;
-};
-type TwoslashResult = {
+}
+interface TwoslashResult {
     code: string;
     annotations: TwoslashAnnotation[];
     noErrors: boolean;
-};
+}
 declare function parseannotations(code: string): TwoslashResult;
 declare function serialize(annotations: TwoslashAnnotation[]): string;
 

package/dist/remarktwoslash.js

@@ -8,7 +8,9 @@ function parseannotations(code) {
   let offset = 0;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    if (line === void 0) continue;
+    if (line === void 0) {
+      continue;
+    }
     const trimmed = line.trim();
     if (trimmed === "// @noErrors") {
       noErrors = true;
@@ -22,14 +24,16 @@ function parseannotations(code) {
     const query = line.match(/^(\s*)\/\/\s*\^(\?)(.*)$/);
     if (query) {
       const indent = query[1];
-      if (indent === void 0) continue;
+      if (indent === void 0) {
+        continue;
+      }
       const col = indent.length;
       const text = query[3]?.trim() || void 0;
       annotations.push({
-        type: "query",
-        line: i - offset - 1,
         character: col,
-        text
+        line: i - offset - 1,
+        text,
+        type: "query"
       });
       offset++;
       continue;
@@ -37,37 +41,43 @@ function parseannotations(code) {
     const completion = line.match(/^(\s*)\/\/\s*\^(\|)(.*)$/);
     if (completion) {
       const indent = completion[1];
-      if (indent === void 0) continue;
+      if (indent === void 0) {
+        continue;
+      }
       const col = indent.length;
       const text = completion[3]?.trim() || void 0;
       annotations.push({
-        type: "completion",
-        line: i - offset - 1,
         character: col,
-        text
+        line: i - offset - 1,
+        text,
+        type: "completion"
       });
       offset++;
       continue;
     }
     output.push(line);
   }
-  return { code: output.join("\n"), annotations, noErrors };
+  return { annotations, code: output.join("\n"), noErrors };
 }
 function serialize(annotations) {
   return JSON.stringify(
     annotations.map((a) => ({
-      t: a.type === "query" ? "q" : "c",
-      l: a.line,
       ch: a.character,
+      l: a.line,
+      t: a.type === "query" ? "q" : "c",
       ...a.text ? { tx: a.text } : {}
     }))
   );
 }
 function transformer(tree) {
   visit(tree, "code", (node) => {
-    if (!node.meta?.includes("twoslash")) return;
+    if (!node.meta?.includes("twoslash")) {
+      return;
+    }
     const result = parseannotations(node.value);
-    if (result.annotations.length === 0) return;
+    if (result.annotations.length === 0) {
+      return;
+    }
     node.value = result.code;
     node.meta = node.meta.replace(/\btwoslash\b/, "").trim() || null;
     node.data ??= {};

package/dist/remarkvideo.d.ts

@@ -1,16 +1,16 @@
 import { Root } from 'mdast';
 import { Plugin } from 'unified';
 
-type Provider = {
+interface Provider {
     pattern: RegExp;
     transform: (match: RegExpMatchArray) => {
         src: string;
         type: string;
     };
-};
-type RemarkVideoOptions = {
+}
+interface RemarkVideoOptions {
     providers?: Provider[];
-};
+}
 declare const remarkVideo: Plugin<[RemarkVideoOptions?], Root>;
 
 export { type RemarkVideoOptions, remarkVideo };