fromsrc 0.0.0 → 0.0.2

package/dist/ranking.js

@@ -0,0 +1,95 @@
+function positions(text, q) {
+  const r = [];
+  const l = text.toLowerCase();
+  const lq = q.toLowerCase();
+  let i = l.indexOf(lq);
+  while (i !== -1) {
+    r.push(i);
+    i = l.indexOf(lq, i + 1);
+  }
+  return r;
+}
+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;
+  return l.includes(lq) ? w : 0;
+}
+function rank(items, query, options) {
+  const tw = options?.titleWeight ?? 10;
+  const dw = options?.descriptionWeight ?? 5;
+  const cw = options?.contentWeight ?? 1;
+  const gw = options?.tagWeight ?? 8;
+  const results = [];
+  for (const item of items) {
+    let s = 0;
+    const m = [];
+    s += scored(item.title, query, tw);
+    const tp = positions(item.title, query);
+    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 (item.content) {
+      s += scored(item.content, query, cw);
+      const cp = positions(item.content, query);
+      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 (item.weight) s *= item.weight;
+    if (s > 0) results.push({ item, score: s, matches: m });
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+function bm25(items, query) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const docs = items.map(
+    (it) => [it.title, it.description, it.content, ...it.tags ?? []].join(" ").toLowerCase().split(/\s+/)
+  );
+  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);
+  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;
+    let s = 0;
+    const dl = doc.length;
+    for (const term of terms) {
+      const tf = doc.filter((w) => w === term).length;
+      const d = df.get(term) ?? 0;
+      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;
+    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 });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score);
+}
+function boostRecent(results, dateFn, maxBoost = 1.5) {
+  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;
+  return results.map((r) => {
+    const boost = 1 + (maxBoost - 1) * (1 - (now - dateFn(r.item).getTime()) / range);
+    return { ...r, score: r.score * boost };
+  }).sort((a, b) => b.score - a.score);
+}
+
+export { bm25, boostRecent, rank };

package/dist/reactrouter.d.ts

@@ -0,0 +1,3 @@
+export { reactRouterAdapter } from './adapterreactrouter.js';
+export { AdapterContext, AdapterProvider, FrameworkAdapter, createadapter, useAdapter } from './adapter.js';
+import 'react';

package/dist/reactrouter.js

@@ -0,0 +1,3 @@
+"use client";
+export { reactRouterAdapter } from './adapterreactrouter';
+export { AdapterContext, AdapterProvider, createadapter, useAdapter } from './adapter';

package/dist/readtime.d.ts

@@ -0,0 +1,3 @@
+declare function calcReadTime(content: string, wpm?: number): number;
+
+export { calcReadTime };

package/dist/readtime.js

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

package/dist/redirects.d.ts

@@ -0,0 +1,27 @@
+interface Redirect {
+    source: string;
+    destination: string;
+    permanent?: boolean;
+}
+interface RedirectConfig {
+    redirects: Redirect[];
+}
+declare function createRedirects(config: RedirectConfig): {
+    match: (pathname: string) => {
+        destination: string;
+        permanent: boolean;
+    } | null;
+    toNextConfig: () => {
+        source: string;
+        destination: string;
+        permanent: boolean;
+    }[];
+    toVercelConfig: () => {
+        source: string;
+        destination: string;
+        statusCode: number;
+    }[];
+};
+declare function parseRedirectsFile(content: string): Redirect[];
+
+export { type Redirect, type RedirectConfig, createRedirects, parseRedirectsFile };

package/dist/redirects.js

@@ -0,0 +1,74 @@
+function compile(source) {
+  const keys = [];
+  const pattern = source.replace(/\/\*/g, () => {
+    keys.push("*");
+    return "/(.*)";
+  }).replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  });
+  return { regex: new RegExp(`^${pattern}/?$`), keys };
+}
+function substitute(destination, params) {
+  let result = destination;
+  for (const [key, value] of Object.entries(params)) {
+    if (key === "*") {
+      result = result.split("*").join(value);
+    } else {
+      result = result.split(`:${key}`).join(value);
+    }
+  }
+  return result;
+}
+function createRedirects(config) {
+  const compiled = config.redirects.map((r) => ({
+    ...r,
+    ...compile(r.source)
+  }));
+  function match(pathname) {
+    const normalized = pathname === "" ? "/" : pathname;
+    for (const entry of compiled) {
+      const m = normalized.match(entry.regex);
+      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;
+        params[key] = value;
+      }
+      return {
+        destination: substitute(entry.destination, params),
+        permanent: entry.permanent !== false
+      };
+    }
+    return null;
+  }
+  function toNextConfig() {
+    return config.redirects.map((r) => ({
+      source: r.source.replace("*", ":path*"),
+      destination: r.destination.replace("*", ":path*"),
+      permanent: r.permanent !== false
+    }));
+  }
+  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"),
+      statusCode: r.permanent !== false ? 301 : 302
+    }));
+  }
+  return { match, toNextConfig, toVercelConfig };
+}
+function parseRedirectsFile(content) {
+  return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => {
+    const parts = line.split(/\s+/);
+    const source = parts[0] ?? "";
+    const destination = parts[1] ?? "";
+    const redirect = { source, destination };
+    if (parts[2] === "302") redirect.permanent = false;
+    return redirect;
+  }).filter((redirect) => redirect.source.length > 0 && redirect.destination.length > 0);
+}
+
+export { createRedirects, parseRedirectsFile };

package/dist/rehype.d.ts

@@ -0,0 +1,5 @@
+import { Root } from 'hast';
+
+declare function rehypeAnchors(): (tree: Root) => void;
+
+export { rehypeAnchors as default, rehypeAnchors };

package/dist/rehype.js

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

package/dist/rehypeautolink.d.ts

@@ -0,0 +1,11 @@
+import { Root } from 'hast';
+import { Plugin } from 'unified';
+
+type 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

@@ -0,0 +1,43 @@
+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",
+    properties: {
+      href: `#${id}`,
+      className,
+      ariaHidden: "true",
+      tabIndex: -1,
+      ...extra
+    },
+    children: []
+  };
+}
+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);
+        }
+      });
+    };
+  };
+}
+
+export { rehypeAutolink };

package/dist/rehypecode.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'hast';
+import { Plugin } from 'unified';
+
+declare const rehypeCode: Plugin<[], Root>;
+
+export { rehypeCode };

package/dist/rehypecode.js

@@ -0,0 +1,68 @@
+import { visit } from 'unist-util-visit';
+
+function parse(meta) {
+  const attrs = {};
+  let cleaned = meta;
+  for (const match of meta.matchAll(/(\w+)="([^"]*)"/g)) {
+    const key = match[1];
+    const value = match[2];
+    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;
+    attrs.lines = lines;
+    cleaned = cleaned.replace(match[0], "");
+  }
+  for (const match of meta.matchAll(/\/([^/]+)\//g)) {
+    const word = match[1];
+    if (!word) continue;
+    attrs.word = word;
+    cleaned = cleaned.replace(match[0], "");
+  }
+  const bare = ["showLineNumbers", "diff", "copy", "wrap"];
+  for (const word of bare) {
+    if (cleaned.includes(word)) {
+      attrs[word] = "";
+      cleaned = cleaned.replace(word, "");
+    }
+  }
+  return attrs;
+}
+const keymap = {
+  title: "data-title",
+  caption: "data-caption",
+  lines: "data-lines",
+  word: "data-word",
+  showLineNumbers: "data-line-numbers",
+  diff: "data-diff",
+  copy: "data-copy",
+  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;
+        }
+      }
+    });
+  };
+};
+
+export { rehypeCode };

package/dist/rehypecopy.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'hast';
+import { Plugin } from 'unified';
+
+declare const rehypeCopy: Plugin<[], Root>;
+
+export { rehypeCopy };

package/dist/rehypecopy.js

@@ -0,0 +1,29 @@
+import { visit } from 'unist-util-visit';
+
+function extractText(node) {
+  let result = "";
+  for (const child of node.children) {
+    if (child.type === "text") {
+      result += child.value;
+    } else if (child.type === "element") {
+      result += extractText(child);
+    }
+  }
+  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;
+    });
+  };
+};
+
+export { rehypeCopy };

package/dist/rehypeinline.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'hast';
+import { Plugin } from 'unified';
+
+declare const rehypeInlineCode: Plugin<[], Root>;
+
+export { rehypeInlineCode };

package/dist/rehypeinline.js

@@ -0,0 +1,32 @@
+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"];
+      }
+    });
+  };
+};
+
+export { rehypeInlineCode };

package/dist/rehypelinks.d.ts

@@ -0,0 +1,10 @@
+import { Root } from 'hast';
+import { Plugin } from 'unified';
+
+interface RehypeLinksOptions {
+    icon?: boolean;
+    domain?: string;
+}
+declare const rehypeExternalLinks: Plugin<[RehypeLinksOptions?], Root>;
+
+export { type RehypeLinksOptions, rehypeExternalLinks };

package/dist/rehypelinks.js

@@ -0,0 +1,49 @@
+import { visit } from 'unist-util-visit';
+
+const rehypeExternalLinks = (options = {}) => {
+  const { icon = false, domain } = options;
+  return (tree) => {
+    visit(tree, "element", (node) => {
+      if (node.tagName !== "a") return;
+      const href = node.properties?.href;
+      if (!href || typeof href !== "string") return;
+      const isExternal = href.startsWith("http://") || href.startsWith("https://");
+      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",
+              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: []
+            }
+          ]
+        };
+        node.children.push(svg);
+      }
+    });
+  };
+};
+
+export { rehypeExternalLinks };

package/dist/rehyperaw.d.ts

@@ -0,0 +1,6 @@
+import { Root } from 'hast';
+import { Plugin } from 'unified';
+
+declare const rehypeRaw: Plugin<[], Root>;
+
+export { rehypeRaw };

package/dist/rehyperaw.js

@@ -0,0 +1,27 @@
+import { visit } from 'unist-util-visit';
+
+function istext(node) {
+  return typeof node === "object" && node !== null && node.type === "text";
+}
+function extractText(node) {
+  if (istext(node)) return node.value;
+  if (typeof node === "object" && node !== null && Array.isArray(node.children)) {
+    return node.children?.map(extractText).join("") ?? "";
+  }
+  return "";
+}
+function transformer(tree) {
+  visit(tree, "element", (node) => {
+    if (node.tagName !== "pre") return;
+    const code = node.children.find(
+      (c) => c.type === "element" && c.tagName === "code"
+    );
+    if (!code) return;
+    const raw = extractText(code).replace(/\n$/, "");
+    node.properties ??= {};
+    node.properties["data-raw"] = raw;
+  });
+}
+const rehypeRaw = () => transformer;
+
+export { rehypeRaw };

package/dist/rehypeslug.d.ts

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

package/dist/rehypeslug.js

@@ -0,0 +1,39 @@
+import { visit } from 'unist-util-visit';
+
+function generateSlug(text) {
+  return text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function extractText(node) {
+  let text = "";
+  for (const child of node.children) {
+    if (child.type === "text") {
+      text += child.value;
+    } else if (child.type === "element") {
+      text += extractText(child);
+    }
+  }
+  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}`;
+      }
+      seen.add(slug);
+      node.properties = node.properties || {};
+      node.properties.id = slug;
+    });
+  };
+};
+
+export { generateSlug, rehypeSlug };

package/dist/rehypetablewrap.d.ts

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

package/dist/rehypetablewrap.js

@@ -0,0 +1,24 @@
+import { visit } from 'unist-util-visit';
+
+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;
+      const wrapper = {
+        type: "element",
+        tagName: "div",
+        properties: {
+          className: [className],
+          role: "region",
+          tabIndex: 0
+        },
+        children: [node]
+      };
+      parent.children[index] = wrapper;
+    });
+  };
+};
+
+export { rehypeTableWrap };

package/dist/rehypetoc.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from 'unified';
+import { Root } from 'hast';
+
+interface TocEntry {
+    id: string;
+    text: string;
+    level: number;
+    children: TocEntry[];
+}
+interface RehypeTocOptions {
+    minLevel?: number;
+    maxLevel?: number;
+}
+declare const rehypeToc: Plugin<[RehypeTocOptions?], Root>;
+
+export { type RehypeTocOptions, type TocEntry, rehypeToc };