fromsrc 0.0.2 → 0.0.21

package/dist/ranking.js

@@ -12,8 +12,12 @@ function positions(text, q) {
 function scored(text, q, w) {
   const l = text.toLowerCase();
   const lq = q.toLowerCase();
-  if (l === lq) return w * 3;
-  if (l.startsWith(lq)) return w * 2;
+  if (l === lq) {
+    return w * 3;
+  }
+  if (l.startsWith(lq)) {
+    return w * 2;
+  }
   return l.includes(lq) ? w : 0;
 }
 function rank(items, query, options) {
@@ -27,26 +31,38 @@ function rank(items, query, options) {
     const m = [];
     s += scored(item.title, query, tw);
     const tp = positions(item.title, query);
-    if (tp.length) m.push({ field: "title", positions: tp });
+    if (tp.length) {
+      m.push({ field: "title", positions: tp });
+    }
     if (item.description) {
       s += scored(item.description, query, dw);
       const dp = positions(item.description, query);
-      if (dp.length) m.push({ field: "description", positions: dp });
+      if (dp.length) {
+        m.push({ field: "description", positions: dp });
+      }
     }
     if (item.content) {
       s += scored(item.content, query, cw);
       const cp = positions(item.content, query);
-      if (cp.length) m.push({ field: "content", positions: cp });
+      if (cp.length) {
+        m.push({ field: "content", positions: cp });
+      }
     }
     if (item.tags) {
       for (const tag of item.tags) {
         s += scored(tag, query, gw);
         const gp = positions(tag, query);
-        if (gp.length) m.push({ field: "tag", positions: gp });
+        if (gp.length) {
+          m.push({ field: "tag", positions: gp });
+        }
       }
     }
-    if (item.weight) s *= item.weight;
-    if (s > 0) results.push({ item, score: s, matches: m });
+    if (item.weight) {
+      s *= item.weight;
+    }
+    if (s > 0) {
+      results.push({ item, matches: m, score: s });
+    }
   }
   return results.sort((a, b) => b.score - a.score);
 }
@@ -57,13 +73,19 @@ function bm25(items, query) {
   );
   const avgdl = docs.reduce((s, d) => s + d.length, 0) / (docs.length || 1);
   const df = /* @__PURE__ */ new Map();
-  for (const doc of docs) for (const t of new Set(doc)) df.set(t, (df.get(t) ?? 0) + 1);
+  for (const doc of docs) {
+    for (const t of new Set(doc)) {
+      df.set(t, (df.get(t) ?? 0) + 1);
+    }
+  }
   const n = docs.length;
   const results = [];
   for (let i = 0; i < items.length; i++) {
     const item = items[i];
     const doc = docs[i];
-    if (!item || !doc) continue;
+    if (!item || !doc) {
+      continue;
+    }
     let s = 0;
     const dl = doc.length;
     for (const term of terms) {
@@ -72,17 +94,21 @@ function bm25(items, query) {
       const idf = Math.log((n - d + 0.5) / (d + 0.5) + 1);
       s += idf * (tf * 2.2 / (tf + 1.2 * (1 - 0.75 + 0.75 * (dl / avgdl))));
     }
-    if (item.weight) s *= item.weight;
+    if (item.weight) {
+      s *= item.weight;
+    }
     const mp = positions([item.title, item.content].join(" "), query);
     if (s > 0) {
       const matches = mp.length ? [{ field: "content", positions: mp }] : [];
-      results.push({ item, score: s, matches });
+      results.push({ item, matches, score: s });
     }
   }
   return results.sort((a, b) => b.score - a.score);
 }
 function boostRecent(results, dateFn, maxBoost = 1.5) {
-  if (!results.length) return results;
+  if (!results.length) {
+    return results;
+  }
   const now = Date.now();
   const oldest = Math.min(...results.map((r) => dateFn(r.item).getTime()));
   const range = now - oldest || 1;

package/dist/readtime.js

@@ -1,6 +1,8 @@
 function calcReadTime(content, wpm = 200) {
   const text = content.trim();
-  if (!text) return 0;
+  if (!text) {
+    return 0;
+  }
   const words = text.split(/\s+/).length;
   return Math.max(1, Math.ceil(words / wpm));
 }

package/dist/redirects.d.ts

@@ -12,13 +12,13 @@ declare function createRedirects(config: RedirectConfig): {
         permanent: boolean;
     } | null;
     toNextConfig: () => {
-        source: string;
         destination: string;
         permanent: boolean;
+        source: string;
     }[];
     toVercelConfig: () => {
-        source: string;
         destination: string;
+        source: string;
         statusCode: number;
     }[];
 };

package/dist/redirects.js

@@ -1,13 +1,13 @@
 function compile(source) {
   const keys = [];
-  const pattern = source.replace(/\/\*/g, () => {
+  const pattern = source.replaceAll("/*", () => {
     keys.push("*");
     return "/(.*)";
-  }).replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+  }).replaceAll(/:([a-zA-Z0-9_]+)/g, (_, key) => {
     keys.push(key);
     return "([^/]+)";
   });
-  return { regex: new RegExp(`^${pattern}/?$`), keys };
+  return { keys, regex: new RegExp(`^${pattern}/?$`) };
 }
 function substitute(destination, params) {
   let result = destination;
@@ -29,12 +29,16 @@ function createRedirects(config) {
     const normalized = pathname === "" ? "/" : pathname;
     for (const entry of compiled) {
       const m = normalized.match(entry.regex);
-      if (!m) continue;
+      if (!m) {
+        continue;
+      }
       const params = {};
       for (let i = 0; i < entry.keys.length; i++) {
         const key = entry.keys[i];
         const value = m[i + 1];
-        if (!key || value === void 0) continue;
+        if (!key || value === void 0) {
+          continue;
+        }
         params[key] = value;
       }
       return {
@@ -46,15 +50,15 @@ function createRedirects(config) {
   }
   function toNextConfig() {
     return config.redirects.map((r) => ({
-      source: r.source.replace("*", ":path*"),
       destination: r.destination.replace("*", ":path*"),
-      permanent: r.permanent !== false
+      permanent: r.permanent !== false,
+      source: r.source.replace("*", ":path*")
     }));
   }
   function toVercelConfig() {
     return config.redirects.map((r) => ({
-      source: r.source.replace("*", "(.*)").replace(/:([a-zA-Z0-9_]+)/g, "($1)"),
-      destination: r.destination.replace("*", "$1").replace(/:([a-zA-Z0-9_]+)/g, "$1"),
+      destination: r.destination.replace("*", "$1").replaceAll(/:([a-zA-Z0-9_]+)/g, "$1"),
+      source: r.source.replace("*", "(.*)").replaceAll(/:([a-zA-Z0-9_]+)/g, "($1)"),
       statusCode: r.permanent !== false ? 301 : 302
     }));
   }
@@ -65,10 +69,14 @@ function parseRedirectsFile(content) {
     const parts = line.split(/\s+/);
     const source = parts[0] ?? "";
     const destination = parts[1] ?? "";
-    const redirect = { source, destination };
-    if (parts[2] === "302") redirect.permanent = false;
+    const redirect = { destination, source };
+    if (parts[2] === "302") {
+      redirect.permanent = false;
+    }
     return redirect;
-  }).filter((redirect) => redirect.source.length > 0 && redirect.destination.length > 0);
+  }).filter(
+    (redirect) => redirect.source.length > 0 && redirect.destination.length > 0
+  );
 }
 
 export { createRedirects, parseRedirectsFile };

package/dist/rehype.js

@@ -3,23 +3,30 @@ import { visit } from 'unist-util-visit';
 function rehypeAnchors() {
   return (tree) => {
     visit(tree, "element", (node) => {
-      if (!["h2", "h3", "h4"].includes(node.tagName)) return;
+      if (!["h2", "h3", "h4"].includes(node.tagName)) {
+        return;
+      }
       const raw = node.properties?.id;
       const id = typeof raw === "string" ? raw : void 0;
-      if (!id) return;
+      if (!id) {
+        return;
+      }
       const link = {
-        type: "element",
-        tagName: "a",
-        properties: { href: `#${id}`, className: ["heading-anchor"] },
         children: [
           ...node.children,
           {
-            type: "element",
+            children: [{ type: "text", value: "#" }],
+            properties: {
+              className: ["heading-anchor-icon"],
+              ariaHidden: "true"
+            },
             tagName: "span",
-            properties: { className: ["heading-anchor-icon"], ariaHidden: "true" },
-            children: [{ type: "text", value: "#" }]
+            type: "element"
           }
-        ]
+        ],
+        properties: { className: ["heading-anchor"], href: `#${id}` },
+        tagName: "a",
+        type: "element"
       };
       node.children = [link];
     });

package/dist/rehypeautolink.d.ts

@@ -1,11 +1,11 @@
 import { Root } from 'hast';
 import { Plugin } from 'unified';
 
-type AutolinkOptions = {
+interface AutolinkOptions {
     behavior?: "prepend" | "append" | "wrap";
     className?: string;
     properties?: Record<string, string>;
-};
+}
 declare function rehypeAutolink(options?: AutolinkOptions): Plugin<[], Root>;
 
 export { type AutolinkOptions, rehypeAutolink };

package/dist/rehypeautolink.js

@@ -3,40 +3,42 @@ import { visit } from 'unist-util-visit';
 const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
 function anchor(id, className, extra) {
   return {
-    type: "element",
-    tagName: "a",
+    children: [],
     properties: {
-      href: `#${id}`,
-      className,
       ariaHidden: "true",
+      className,
+      href: `#${id}`,
       tabIndex: -1,
       ...extra
     },
-    children: []
+    tagName: "a",
+    type: "element"
   };
 }
 function rehypeAutolink(options) {
   const behavior = options?.behavior ?? "prepend";
   const className = options?.className ?? "anchor";
   const extra = options?.properties ?? {};
-  return () => {
-    return (tree) => {
-      visit(tree, "element", (node) => {
-        if (!headings.has(node.tagName)) return;
-        const raw = node.properties?.id;
-        const id = typeof raw === "string" ? raw : void 0;
-        if (!id) return;
-        const link = anchor(id, className, extra);
-        if (behavior === "wrap") {
-          link.children = node.children;
-          node.children = [link];
-        } else if (behavior === "append") {
-          node.children.push(link);
-        } else {
-          node.children.unshift(link);
-        }
-      });
-    };
+  return () => (tree) => {
+    visit(tree, "element", (node) => {
+      if (!headings.has(node.tagName)) {
+        return;
+      }
+      const raw = node.properties?.id;
+      const id = typeof raw === "string" ? raw : void 0;
+      if (!id) {
+        return;
+      }
+      const link = anchor(id, className, extra);
+      if (behavior === "wrap") {
+        link.children = node.children;
+        node.children = [link];
+      } else if (behavior === "append") {
+        node.children.push(link);
+      } else {
+        node.children.unshift(link);
+      }
+    });
   };
 }
 

package/dist/rehypecode.js

@@ -6,19 +6,25 @@ function parse(meta) {
   for (const match of meta.matchAll(/(\w+)="([^"]*)"/g)) {
     const key = match[1];
     const value = match[2];
-    if (!key || value === void 0) continue;
+    if (!key || value === void 0) {
+      continue;
+    }
     attrs[key] = value;
     cleaned = cleaned.replace(match[0], "");
   }
   for (const match of meta.matchAll(/\{([^}]*)\}/g)) {
     const lines = match[1];
-    if (!lines) continue;
+    if (!lines) {
+      continue;
+    }
     attrs.lines = lines;
     cleaned = cleaned.replace(match[0], "");
   }
   for (const match of meta.matchAll(/\/([^/]+)\//g)) {
     const word = match[1];
-    if (!word) continue;
+    if (!word) {
+      continue;
+    }
     attrs.word = word;
     cleaned = cleaned.replace(match[0], "");
   }
@@ -32,37 +38,41 @@ function parse(meta) {
   return attrs;
 }
 const keymap = {
-  title: "data-title",
   caption: "data-caption",
+  copy: "data-copy",
+  diff: "data-diff",
   lines: "data-lines",
-  word: "data-word",
   showLineNumbers: "data-line-numbers",
-  diff: "data-diff",
-  copy: "data-copy",
+  title: "data-title",
+  word: "data-word",
   wrap: "data-wrap"
 };
-const rehypeCode = () => {
-  return (tree) => {
-    visit(tree, "element", (node) => {
-      if (node.tagName !== "pre") return;
-      const code = node.children.find(
-        (child) => child.type === "element" && child.tagName === "code"
-      );
-      if (!code) return;
-      const fromdata = code.properties?.["data-meta"];
-      const frommeta = code.properties?.meta;
-      const meta = typeof fromdata === "string" ? fromdata : typeof frommeta === "string" ? frommeta : "";
-      if (!meta) return;
-      const attrs = parse(meta);
-      for (const [key, value] of Object.entries(attrs)) {
-        const prop = keymap[key];
-        if (prop) {
-          node.properties ??= {};
-          node.properties[prop] = value === "" ? "true" : value;
-        }
+const rehypeCode = () => (tree) => {
+  visit(tree, "element", (node) => {
+    if (node.tagName !== "pre") {
+      return;
+    }
+    const code = node.children.find(
+      (child) => child.type === "element" && child.tagName === "code"
+    );
+    if (!code) {
+      return;
+    }
+    const fromdata = code.properties?.["data-meta"];
+    const frommeta = code.properties?.meta;
+    const meta = typeof fromdata === "string" ? fromdata : typeof frommeta === "string" ? frommeta : "";
+    if (!meta) {
+      return;
+    }
+    const attrs = parse(meta);
+    for (const [key, value] of Object.entries(attrs)) {
+      const prop = keymap[key];
+      if (prop) {
+        node.properties ??= {};
+        node.properties[prop] = value === "" ? "true" : value;
       }
-    });
-  };
+    }
+  });
 };
 
 export { rehypeCode };

package/dist/rehypecopy.js

@@ -11,19 +11,23 @@ function extractText(node) {
   }
   return result;
 }
-const rehypeCopy = () => {
-  return (tree) => {
-    visit(tree, "element", (node) => {
-      if (node.tagName !== "pre") return;
-      const code = node.children.find(
-        (child) => child.type === "element" && child.tagName === "code"
-      );
-      if (!code) return;
-      const text = extractText(code).replace(/\n$/, "").trim();
-      if (!node.properties) node.properties = {};
-      node.properties["data-copy"] = text;
-    });
-  };
+const rehypeCopy = () => (tree) => {
+  visit(tree, "element", (node) => {
+    if (node.tagName !== "pre") {
+      return;
+    }
+    const code = node.children.find(
+      (child) => child.type === "element" && child.tagName === "code"
+    );
+    if (!code) {
+      return;
+    }
+    const text = extractText(code).replace(/\n$/, "").trim();
+    if (!node.properties) {
+      node.properties = {};
+    }
+    node.properties["data-copy"] = text;
+  });
 };
 
 export { rehypeCopy };

package/dist/rehypeinline.js

@@ -1,32 +1,38 @@
 import { visit } from 'unist-util-visit';
 
-const rehypeInlineCode = () => {
-  return (tree) => {
-    visit(tree, "element", (node, _index, parent) => {
-      if (node.tagName !== "code") return;
-      if (parent && parent.type === "element" && parent.tagName === "pre") return;
-      const textNode = node.children[0];
-      if (!textNode || textNode.type !== "text") return;
-      const text = textNode.value;
-      const match = text.match(/\{:(\w+)\}$/);
-      if (!match) return;
-      const lang = match[1];
-      const cleanText = text.slice(0, -match[0].length);
-      textNode.value = cleanText;
-      if (!node.properties) {
-        node.properties = {};
-      }
-      node.properties.dataLanguage = lang;
-      const existingClass = node.properties.className;
-      if (Array.isArray(existingClass)) {
-        node.properties.className = [...existingClass, "inline-code-highlight"];
-      } else if (typeof existingClass === "string") {
-        node.properties.className = [existingClass, "inline-code-highlight"];
-      } else {
-        node.properties.className = ["inline-code-highlight"];
-      }
-    });
-  };
+const rehypeInlineCode = () => (tree) => {
+  visit(tree, "element", (node, _index, parent) => {
+    if (node.tagName !== "code") {
+      return;
+    }
+    if (parent && parent.type === "element" && parent.tagName === "pre") {
+      return;
+    }
+    const textNode = node.children[0];
+    if (!textNode || textNode.type !== "text") {
+      return;
+    }
+    const text = textNode.value;
+    const match = text.match(/\{:(\w+)\}$/);
+    if (!match) {
+      return;
+    }
+    const lang = match[1];
+    const cleanText = text.slice(0, -match[0].length);
+    textNode.value = cleanText;
+    if (!node.properties) {
+      node.properties = {};
+    }
+    node.properties.dataLanguage = lang;
+    const existingClass = node.properties.className;
+    if (Array.isArray(existingClass)) {
+      node.properties.className = [...existingClass, "inline-code-highlight"];
+    } else if (typeof existingClass === "string") {
+      node.properties.className = [existingClass, "inline-code-highlight"];
+    } else {
+      node.properties.className = ["inline-code-highlight"];
+    }
+  });
 };
 
 export { rehypeInlineCode };

package/dist/rehypelinks.js

@@ -4,41 +4,49 @@ const rehypeExternalLinks = (options = {}) => {
   const { icon = false, domain } = options;
   return (tree) => {
     visit(tree, "element", (node) => {
-      if (node.tagName !== "a") return;
+      if (node.tagName !== "a") {
+        return;
+      }
       const href = node.properties?.href;
-      if (!href || typeof href !== "string") return;
+      if (!href || typeof href !== "string") {
+        return;
+      }
       const isExternal = href.startsWith("http://") || href.startsWith("https://");
-      if (!isExternal) return;
-      if (domain && href.startsWith(domain)) return;
+      if (!isExternal) {
+        return;
+      }
+      if (domain && href.startsWith(domain)) {
+        return;
+      }
       node.properties = node.properties || {};
       node.properties.target = "_blank";
       node.properties.rel = "noopener noreferrer";
       if (icon) {
         const svg = {
-          type: "element",
-          tagName: "svg",
-          properties: {
-            viewBox: "0 0 24 24",
-            fill: "none",
-            stroke: "currentColor",
-            strokeWidth: "2",
-            width: "12",
-            height: "12",
-            style: "display:inline;vertical-align:text-top;margin-left:2px",
-            ariaHidden: "true"
-          },
           children: [
             {
-              type: "element",
-              tagName: "path",
+              children: [],
               properties: {
                 d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6M15 3h6v6M10 14 21 3",
                 strokeLinecap: "round",
                 strokeLinejoin: "round"
               },
-              children: []
+              tagName: "path",
+              type: "element"
             }
-          ]
+          ],
+          properties: {
+            ariaHidden: "true",
+            fill: "none",
+            height: "12",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            style: "display:inline;vertical-align:text-top;margin-left:2px",
+            viewBox: "0 0 24 24",
+            width: "12"
+          },
+          tagName: "svg",
+          type: "element"
         };
         node.children.push(svg);
       }

package/dist/rehyperaw.js

@@ -4,7 +4,9 @@ function istext(node) {
   return typeof node === "object" && node !== null && node.type === "text";
 }
 function extractText(node) {
-  if (istext(node)) return node.value;
+  if (istext(node)) {
+    return node.value;
+  }
   if (typeof node === "object" && node !== null && Array.isArray(node.children)) {
     return node.children?.map(extractText).join("") ?? "";
   }
@@ -12,11 +14,15 @@ function extractText(node) {
 }
 function transformer(tree) {
   visit(tree, "element", (node) => {
-    if (node.tagName !== "pre") return;
+    if (node.tagName !== "pre") {
+      return;
+    }
     const code = node.children.find(
       (c) => c.type === "element" && c.tagName === "code"
     );
-    if (!code) return;
+    if (!code) {
+      return;
+    }
     const raw = extractText(code).replace(/\n$/, "");
     node.properties ??= {};
     node.properties["data-raw"] = raw;

package/dist/rehypeslug.d.ts

@@ -1,5 +1,5 @@
-import { Plugin } from 'unified';
 import { Root } from 'hast';
+import { Plugin } from 'unified';
 
 declare function generateSlug(text: string): string;
 declare const rehypeSlug: Plugin<[], Root>;