fromsrc 0.0.2 → 0.0.22

package/dist/ansi.js

@@ -1,4 +1,12 @@
 const ansiColors = {
+  100: "#484f58",
+  101: "#ff7b72",
+  102: "#56d364",
+  103: "#e3b341",
+  104: "#79c0ff",
+  105: "#d2a8ff",
+  106: "#56d4dd",
+  107: "#f0f6fc",
   30: "#000000",
   31: "#f85149",
   32: "#3fb950",
@@ -22,32 +30,24 @@ const ansiColors = {
   94: "#79c0ff",
   95: "#d2a8ff",
   96: "#56d4dd",
-  97: "#f0f6fc",
-  100: "#484f58",
-  101: "#ff7b72",
-  102: "#56d364",
-  103: "#e3b341",
-  104: "#79c0ff",
-  105: "#d2a8ff",
-  106: "#56d4dd",
-  107: "#f0f6fc"
+  97: "#f0f6fc"
 };
 function parseAnsi(text) {
   const segments = [];
   const state = {
+    bg: null,
     bold: false,
     dim: false,
-    italic: false,
-    underline: false,
     fg: null,
-    bg: null
+    italic: false,
+    underline: false
   };
   let current = "";
   let i = 0;
   while (i < text.length) {
     if (text[i] === "\x1B" && text[i + 1] === "[") {
       if (current) {
-        segments.push({ text: current, style: { ...state } });
+        segments.push({ style: { ...state }, text: current });
         current = "";
       }
       let j = i + 2;
@@ -114,13 +114,30 @@ function parseAnsi(text) {
     }
   }
   if (current) {
-    segments.push({ text: current, style: { ...state } });
+    segments.push({ style: { ...state }, text: current });
   }
   return segments;
 }
 function ansi256ToHex(n) {
   if (n < 16) {
-    const basic = [0, 128, 0, 128, 0, 128, 0, 192, 128, 255, 0, 255, 0, 255, 0, 255];
+    const basic = [
+      0,
+      128,
+      0,
+      128,
+      0,
+      128,
+      0,
+      192,
+      128,
+      255,
+      0,
+      255,
+      0,
+      255,
+      0,
+      255
+    ];
     const r = basic[n * 3] || 0;
     const g = basic[n * 3 + 1] || 0;
     const b = basic[n * 3 + 2] || 0;
@@ -139,33 +156,49 @@ function ansi256ToHex(n) {
 }
 function transformerAnsi() {
   return {
-    name: "ansi",
-    preprocess(code, options) {
-      if (options.lang === "ansi" || options.lang === "terminal") {
-        return code;
-      }
-    },
     code(node) {
-      const lang = this.options.lang;
-      if (lang !== "ansi" && lang !== "terminal") return;
+      const { lang } = this.options;
+      if (lang !== "ansi" && lang !== "terminal") {
+        return;
+      }
       const lines = node.children;
-      if (!Array.isArray(lines)) return;
+      if (!Array.isArray(lines)) {
+        return;
+      }
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
-        if (!line || line.type !== "element") continue;
+        if (!line || line.type !== "element") {
+          continue;
+        }
         const textNode = line.children[0];
-        if (!textNode || textNode.type !== "text") continue;
+        if (!textNode || textNode.type !== "text") {
+          continue;
+        }
         const text = textNode.value;
         const segments = parseAnsi(text);
-        if (segments.length === 0) continue;
+        if (segments.length === 0) {
+          continue;
+        }
         line.children = segments.map((seg) => {
           const styles = [];
-          if (seg.style.fg) styles.push(`color: ${seg.style.fg}`);
-          if (seg.style.bg) styles.push(`background-color: ${seg.style.bg}`);
-          if (seg.style.bold) styles.push("font-weight: bold");
-          if (seg.style.dim) styles.push("opacity: 0.5");
-          if (seg.style.italic) styles.push("font-style: italic");
-          if (seg.style.underline) styles.push("text-decoration: underline");
+          if (seg.style.fg) {
+            styles.push(`color: ${seg.style.fg}`);
+          }
+          if (seg.style.bg) {
+            styles.push(`background-color: ${seg.style.bg}`);
+          }
+          if (seg.style.bold) {
+            styles.push("font-weight: bold");
+          }
+          if (seg.style.dim) {
+            styles.push("opacity: 0.5");
+          }
+          if (seg.style.italic) {
+            styles.push("font-style: italic");
+          }
+          if (seg.style.underline) {
+            styles.push("text-decoration: underline");
+          }
           if (styles.length === 0) {
             return {
               type: "text",
@@ -173,18 +206,24 @@ function transformerAnsi() {
             };
           }
           return {
-            type: "element",
-            tagName: "span",
-            properties: { style: styles.join("; ") },
             children: [
               {
                 type: "text",
                 value: seg.text
               }
-            ]
+            ],
+            properties: { style: styles.join("; ") },
+            tagName: "span",
+            type: "element"
           };
         });
       }
+    },
+    name: "ansi",
+    preprocess(code, options) {
+      if (options.lang === "ansi" || options.lang === "terminal") {
+        return code;
+      }
     }
   };
 }

package/dist/api.d.ts

@@ -1,25 +1,25 @@
-type ApiResponse<T> = {
+interface ApiResponse<T> {
     data: T;
     status: number;
-};
-type ApiError = {
+}
+interface ApiError {
     error: string;
     status: number;
-};
-type CorsConfig = {
+}
+interface CorsConfig {
     origins?: string[];
     methods?: string[];
     headers?: string[];
-};
-type RateLimitConfig = {
+}
+interface RateLimitConfig {
     windowMs: number;
     maxRequests: number;
-};
-type RateLimitResult = {
+}
+interface RateLimitResult {
     allowed: boolean;
     remaining: number;
     resetAt: number;
-};
+}
 declare function json<T>(data: T, status?: number, headers?: HeadersInit): Response;
 declare function error(message: string, status?: number): Response;
 declare function cors(config?: CorsConfig): Record<string, string>;

package/dist/api.js

@@ -7,14 +7,14 @@ function json(data, status = 200, headers) {
     next.set("Content-Type", "application/json");
   }
   return new Response(JSON.stringify(data), {
-    status,
-    headers: next
+    headers: next,
+    status
   });
 }
 function error(message, status = 500) {
   return new Response(JSON.stringify({ error: message }), {
-    status,
-    headers: { "Content-Type": "application/json" }
+    headers: { "Content-Type": "application/json" },
+    status
   });
 }
 function cors(config) {
@@ -24,9 +24,9 @@ function cors(config) {
   }
   const origin = config?.origins && config.origins.length > 0 ? config.origins.join(", ") : "*";
   return {
-    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Allow-Headers": config?.headers?.join(", ") ?? DEFAULT_HEADERS,
     "Access-Control-Allow-Methods": config?.methods?.join(", ") ?? DEFAULT_METHODS,
-    "Access-Control-Allow-Headers": config?.headers?.join(", ") ?? DEFAULT_HEADERS
+    "Access-Control-Allow-Origin": origin
   };
 }
 function withCors(response, config) {
@@ -35,19 +35,22 @@ function withCors(response, config) {
     headers.set(key, value);
   }
   return new Response(response.body, {
+    headers,
     status: response.status,
-    statusText: response.statusText,
-    headers
+    statusText: response.statusText
   });
 }
 function cache(response, maxAge, stale) {
   const headers = new Headers(response.headers);
   const staleAge = stale ?? maxAge;
-  headers.set("Cache-Control", `public, max-age=${maxAge}, stale-while-revalidate=${staleAge}`);
+  headers.set(
+    "Cache-Control",
+    `public, max-age=${maxAge}, stale-while-revalidate=${staleAge}`
+  );
   return new Response(response.body, {
+    headers,
     status: response.status,
-    statusText: response.statusText,
-    headers
+    statusText: response.statusText
   });
 }
 function rateLimiter(config) {

package/dist/audit.d.ts

@@ -1,18 +1,18 @@
-type AuditConfig = {
+interface AuditConfig {
     docsDir: string;
     maxAge?: number;
     requiredFields?: string[];
-};
-type AuditIssue = {
+}
+interface AuditIssue {
     file: string;
     type: "stale" | "missing-field" | "empty" | "short" | "no-headings" | "orphan";
     message: string;
-};
-type AuditResult = {
+}
+interface AuditResult {
     total: number;
     issues: AuditIssue[];
     score: number;
-};
+}
 declare function audit(config: AuditConfig): Promise<AuditResult>;
 declare function formatAudit(result: AuditResult): string;
 

package/dist/audit.js

@@ -3,10 +3,14 @@ import { relative, join } from 'node:path';
 
 function parsefrontmatter(raw) {
   const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return { fields: {}, body: raw };
+  if (!match) {
+    return { body: raw, fields: {} };
+  }
   const full = match[0];
   const section = match[1];
-  if (!full || section === void 0) return { fields: {}, body: raw };
+  if (!full || section === void 0) {
+    return { body: raw, fields: {} };
+  }
   const body = raw.slice(full.length).trim();
   const fields = {};
   for (const line of section.split("\n")) {
@@ -15,7 +19,7 @@ function parsefrontmatter(raw) {
       fields[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
     }
   }
-  return { fields, body };
+  return { body, fields };
 }
 async function gather(dir) {
   const results = [];
@@ -39,30 +43,45 @@ async function audit(config) {
   const threshold = maxAge * 864e5;
   for (const filepath of files) {
     const rel = relative(config.docsDir, filepath);
-    const [raw, info] = await Promise.all([readFile(filepath, "utf-8"), stat(filepath)]);
+    const [raw, info] = await Promise.all([
+      readFile(filepath, "utf8"),
+      stat(filepath)
+    ]);
     if (now - info.mtimeMs > threshold) {
-      issues.push({ file: rel, type: "stale", message: `modified over ${maxAge} days ago` });
+      issues.push({
+        file: rel,
+        message: `modified over ${maxAge} days ago`,
+        type: "stale"
+      });
     }
     const { fields, body } = parsefrontmatter(raw);
     for (const field of required) {
       if (!fields[field]) {
-        issues.push({ file: rel, type: "missing-field", message: `missing ${field}` });
+        issues.push({
+          file: rel,
+          message: `missing ${field}`,
+          type: "missing-field"
+        });
       }
     }
     if (body.length < 10) {
-      issues.push({ file: rel, type: "empty", message: "content is empty" });
+      issues.push({ file: rel, message: "content is empty", type: "empty" });
     }
     const words = body.split(/\s+/).filter(Boolean).length;
     if (words < 100) {
-      issues.push({ file: rel, type: "short", message: `only ${words} words` });
+      issues.push({ file: rel, message: `only ${words} words`, type: "short" });
     }
     if (!/^##\s/m.test(body)) {
-      issues.push({ file: rel, type: "no-headings", message: "no headings found" });
+      issues.push({
+        file: rel,
+        message: "no headings found",
+        type: "no-headings"
+      });
     }
   }
   const total = files.length;
   const score = total === 0 ? 100 : Math.max(0, Math.min(100, 100 - issues.length / total * 100));
-  return { total, issues, score: Math.round(score) };
+  return { issues, score: Math.round(score), total };
 }
 function formatAudit(result) {
   const lines = [

package/dist/autotype.js

@@ -3,14 +3,14 @@ import { readFile } from 'node:fs/promises';
 const BLOCK_PATTERN = /(?:\/\*\*\s*([\s\S]*?)\s*\*\/\s*)?(?:export\s+)?(?:interface|type)\s+(\w+)(?:<[^>]*>)?(?:\s*=\s*\{|\s*(?:extends\s+([\w\s,<>]+))?\s*\{)([\s\S]*?)\n\}/g;
 const PROP_PATTERN = /(?:\/\*\*\s*([\s\S]*?)\s*\*\/\s*)?(?:readonly\s+)?(\w+)(\??)\s*:\s*([^;\n]+)/g;
 function clean(raw) {
-  return raw.replace(/^\s*\*\s?/gm, "").replace(/@default\s+.*/g, "").trim();
+  return raw.replaceAll(/^\s*\*\s?/gm, "").replaceAll(/@default\s+.*/g, "").trim();
 }
 function extractDefault(raw) {
   const match = raw.match(/@default\s+(.+)/);
   return match?.[1]?.trim();
 }
 function normalizeType(raw) {
-  return raw.replace(/\s+/g, " ").trim();
+  return raw.replaceAll(/\s+/g, " ").trim();
 }
 function parseExtends(raw) {
   return raw.split(",").map((s) => s.replace(/<.*>/, "").trim());
@@ -24,17 +24,23 @@ function parseProperties(body) {
     const name = match[2];
     const optional = match[3];
     const rawType = match[4];
-    if (!name || optional === void 0 || !rawType) continue;
+    if (!name || optional === void 0 || !rawType) {
+      continue;
+    }
     const property = {
       name,
-      type: normalizeType(rawType),
-      required: optional !== "?"
+      required: optional !== "?",
+      type: normalizeType(rawType)
     };
     if (jsdoc) {
       const description = clean(jsdoc);
-      if (description) property.description = description;
+      if (description) {
+        property.description = description;
+      }
       const def = extractDefault(jsdoc);
-      if (def) property.default = def;
+      if (def) {
+        property.default = def;
+      }
     }
     properties.push(property);
   }
@@ -49,14 +55,18 @@ function parseTypes(source) {
     const name = match[2];
     const extendsClause = match[3];
     const body = match[4];
-    if (!name || !body) continue;
+    if (!name || !body) {
+      continue;
+    }
     const definition = {
       name,
       properties: parseProperties(body)
     };
     if (jsdoc) {
       const description = clean(jsdoc);
-      if (description) definition.description = description;
+      if (description) {
+        definition.description = description;
+      }
     }
     if (extendsClause) {
       definition.extends = parseExtends(extendsClause);
@@ -66,7 +76,7 @@ function parseTypes(source) {
   return definitions;
 }
 async function parseTypeFile(filePath) {
-  const source = await readFile(filePath, "utf-8");
+  const source = await readFile(filePath, "utf8");
   return parseTypes(source);
 }
 

package/dist/batch.d.ts

@@ -1,16 +1,16 @@
-type BatchConfig = {
+interface BatchConfig {
     concurrency?: number;
     onProgress?: (done: number, total: number) => void;
-};
-type BatchResult<T> = {
+}
+interface BatchResult<T> {
     results: T[];
     errors: BatchError[];
     duration: number;
-};
-type BatchError = {
+}
+interface BatchError {
     index: number;
     error: string;
-};
+}
 declare function batch<TItem, TResult>(items: TItem[], fn: (item: TItem, index: number) => Promise<TResult>, config?: BatchConfig): Promise<BatchResult<TResult>>;
 declare function batchFiles<T>(dir: string, fn: (path: string, content: string) => Promise<T>, config?: BatchConfig): Promise<BatchResult<T>>;
 declare function mapFiles(dir: string, transform: (content: string, path: string) => string, config?: BatchConfig): Promise<{

package/dist/batch.js

@@ -16,25 +16,32 @@ async function batch(items, fn, config) {
     while (cursor < items.length) {
       const i = cursor++;
       const item = items[i];
-      if (item === void 0) continue;
+      if (item === void 0) {
+        continue;
+      }
       try {
         results[i] = await fn(item, i);
-      } catch (e) {
-        errors.push({ index: i, error: e instanceof Error ? e.message : String(e) });
+      } catch (error) {
+        errors.push({
+          error: error instanceof Error ? error.message : String(error),
+          index: i
+        });
       }
       done++;
       config?.onProgress?.(done, items.length);
     }
   }
-  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => next()));
-  return { results, errors, duration: performance.now() - start };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => next())
+  );
+  return { duration: performance.now() - start, errors, results };
 }
 async function batchFiles(dir, fn, config) {
   const paths = await collect(dir);
   return batch(
     paths,
     async (p) => {
-      const content = await readFile(p, "utf-8");
+      const content = await readFile(p, "utf8");
       return fn(p, content);
     },
     config
@@ -46,10 +53,10 @@ async function mapFiles(dir, transform, config) {
   await batch(
     paths,
     async (p) => {
-      const original = await readFile(p, "utf-8");
+      const original = await readFile(p, "utf8");
       const result = transform(original, p);
       if (result !== original) {
-        await writeFile(p, result, "utf-8");
+        await writeFile(p, result, "utf8");
         modified++;
       }
     },
@@ -60,7 +67,7 @@ async function mapFiles(dir, transform, config) {
 async function forEachDoc(dir, fn) {
   const paths = await collect(dir);
   for (const p of paths) {
-    const content = await readFile(p, "utf-8");
+    const content = await readFile(p, "utf8");
     await fn(p, content);
   }
 }

package/dist/changelog.js

@@ -1,18 +1,26 @@
 const sectionMap = {
   added: "added",
   changed: "changed",
+  deprecated: "deprecated",
   fixed: "fixed",
   removed: "removed",
-  deprecated: "deprecated",
   security: "security"
 };
 function detectType(version, previous) {
-  if (version.includes("-")) return "prerelease";
-  if (!previous) return "major";
+  if (version.includes("-")) {
+    return "prerelease";
+  }
+  if (!previous) {
+    return "major";
+  }
   const [ma, mi, pa] = version.split(".").map(Number);
   const [pma, pmi] = previous.split(".").map(Number);
-  if (ma !== pma) return "major";
-  if (mi !== pmi) return "minor";
+  if (ma !== pma) {
+    return "major";
+  }
+  if (mi !== pmi) {
+    return "minor";
+  }
   return "patch";
 }
 function detectBreaking(items) {
@@ -23,10 +31,14 @@ function parseChangelog(content) {
   const blocks = content.split(/^## /m).slice(1);
   for (const block of blocks) {
     const header = block.match(/^\[([^\]]+)\]\s*-\s*(\S+)(.*)/);
-    if (!header) continue;
+    if (!header) {
+      continue;
+    }
     const version = header[1];
     const date = header[2];
-    if (!version || !date) continue;
+    if (!version || !date) {
+      continue;
+    }
     const rest = header[3] ?? "";
     const title = rest.trim() || void 0;
     const items = [];
@@ -42,31 +54,33 @@ function parseChangelog(content) {
       if (item && currentType) {
         const description = item[1];
         if (description) {
-          items.push({ type: currentType, description: description.trim() });
+          items.push({ description: description.trim(), type: currentType });
         }
       }
     }
     entries.push({
-      version,
+      breaking: detectBreaking(items),
       date,
-      title,
       description: items.map((i) => i.description).join(", "),
+      items,
+      title,
       type: "patch",
-      breaking: detectBreaking(items),
-      items
+      version
     });
   }
   entries.sort((a, b) => b.date.localeCompare(a.date));
   for (let i = 0; i < entries.length; i++) {
     const entry = entries[i];
-    if (!entry) continue;
+    if (!entry) {
+      continue;
+    }
     const prev = entries[i + 1];
     entry.type = detectType(entry.version, prev?.version);
   }
   return entries;
 }
 function escape(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 function generateChangelogRss(config, entries) {
   const items = entries.map(

package/dist/changelogutil.d.ts

@@ -1,16 +1,16 @@
-type ChangelogEntry = {
+interface ChangelogEntry {
     version: string;
     date: string;
     changes: {
         type: string;
         items: string[];
     }[];
-};
-type ChangelogData = {
+}
+interface ChangelogData {
     title?: string;
     description?: string;
     entries: ChangelogEntry[];
-};
+}
 declare function parseChangelog(content: string): ChangelogData;
 declare function formatChangelog(data: ChangelogData): string;
 declare function getLatestVersion(data: ChangelogData): ChangelogEntry | undefined;