fromsrc 0.0.2 → 0.0.22

package/dist/remarkvideo.js

@@ -4,53 +4,79 @@ const extensions = /\.(mp4|webm|mov|ogg)(\?.*)?$/;
 const defaults = [
   {
     pattern: /loom\.com\/share\/([\w-]+)/,
-    transform: (m) => ({ src: `https://www.loom.com/embed/${m[1]}`, type: "loom" })
+    transform: (m) => ({
+      src: `https://www.loom.com/embed/${m[1]}`,
+      type: "loom"
+    })
   },
   {
     pattern: /vimeo\.com\/(\d+)/,
-    transform: (m) => ({ src: `https://player.vimeo.com/video/${m[1]}`, type: "vimeo" })
+    transform: (m) => ({
+      src: `https://player.vimeo.com/video/${m[1]}`,
+      type: "vimeo"
+    })
   }
 ];
 function makeNode(src, type) {
   const attributes = [
-    { type: "mdxJsxAttribute", name: "src", value: src }
+    { name: "src", type: "mdxJsxAttribute", value: src }
   ];
-  if (type) attributes.push({ type: "mdxJsxAttribute", name: "type", value: type });
+  if (type) {
+    attributes.push({ name: "type", type: "mdxJsxAttribute", value: type });
+  }
   return {
-    type: "mdxJsxFlowElement",
-    name: "Video",
     attributes,
     children: [],
-    data: { _mdxExplicitJsx: true }
+    data: { _mdxExplicitJsx: true },
+    name: "Video",
+    type: "mdxJsxFlowElement"
   };
 }
 function resolve(url, providers) {
-  if (extensions.test(url)) return makeNode(url);
+  if (extensions.test(url)) {
+    return makeNode(url);
+  }
   for (const p of providers) {
     const match = url.match(p.pattern);
-    if (!match) continue;
+    if (!match) {
+      continue;
+    }
     const { src, type } = p.transform(match);
     return makeNode(src, type);
   }
   return null;
 }
 function extractUrl(node) {
-  if (node.children.length !== 1) return null;
+  if (node.children.length !== 1) {
+    return null;
+  }
   const child = node.children[0];
-  if (!child) return null;
-  if (child.type === "text") return child.value.trim();
-  if (child.type === "link") return child.url;
+  if (!child) {
+    return null;
+  }
+  if (child.type === "text") {
+    return child.value.trim();
+  }
+  if (child.type === "link") {
+    return child.url;
+  }
   return null;
 }
 const remarkVideo = (options = {}) => {
   const all = [...defaults, ...options.providers ?? []];
   return (tree) => {
     visit(tree, "paragraph", (node, index, parent) => {
-      if (!parent || index === void 0) return;
+      if (!parent || index === void 0) {
+        return;
+      }
       const url = extractUrl(node);
-      if (!url) return;
+      if (!url) {
+        return;
+      }
       const video = resolve(url, all);
-      if (!video) return;
+      if (!video) {
+        return;
+      }
       parent.children[index] = video;
     });
   };

package/dist/schema.d.ts

@@ -2,10 +2,10 @@ import { z } from 'zod';
 export { z } from 'zod';
 
 declare const baseSchema: z.ZodObject<{
-    title: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodNumber>;
     draft: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     title: string;
     order?: number | undefined;
@@ -19,36 +19,36 @@ declare const baseSchema: z.ZodObject<{
 }>;
 type InferSchema<T extends z.ZodType> = z.infer<T>;
 declare function defineSchema<T extends z.ZodRawShape>(schema: z.ZodObject<T>): z.ZodObject<z.objectUtil.extendShape<{
-    title: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodNumber>;
     draft: z.ZodOptional<z.ZodBoolean>;
-}, T>, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<z.objectUtil.extendShape<{
+    order: z.ZodOptional<z.ZodNumber>;
     title: z.ZodString;
+}, T>, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<z.objectUtil.extendShape<{
     description: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodNumber>;
     draft: z.ZodOptional<z.ZodBoolean>;
-}, T>>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<z.objectUtil.extendShape<{
+    order: z.ZodOptional<z.ZodNumber>;
     title: z.ZodString;
+}, T>>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<z.objectUtil.extendShape<{
     description: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodNumber>;
     draft: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodString;
 }, T>> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
 declare function extendSchema<T extends z.ZodRawShape>(fields: T): z.ZodObject<z.objectUtil.extendShape<{
-    title: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodNumber>;
     draft: z.ZodOptional<z.ZodBoolean>;
-}, T>, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<z.objectUtil.extendShape<{
+    order: z.ZodOptional<z.ZodNumber>;
     title: z.ZodString;
+}, T>, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<z.objectUtil.extendShape<{
     description: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodNumber>;
     draft: z.ZodOptional<z.ZodBoolean>;
-}, T>>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<z.objectUtil.extendShape<{
+    order: z.ZodOptional<z.ZodNumber>;
     title: z.ZodString;
+}, T>>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<z.objectUtil.extendShape<{
     description: z.ZodOptional<z.ZodString>;
-    order: z.ZodOptional<z.ZodNumber>;
     draft: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodString;
 }, T>> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
 
 export { type InferSchema, baseSchema, defineSchema, extendSchema };

package/dist/schema.js

@@ -2,10 +2,10 @@ import { z } from 'zod';
 export { z } from 'zod';
 
 const baseSchema = z.object({
-  title: z.string(),
   description: z.string().optional(),
+  draft: z.boolean().optional(),
   order: z.number().optional(),
-  draft: z.boolean().optional()
+  title: z.string()
 });
 function defineSchema(schema) {
   return baseSchema.merge(schema);

package/dist/search.js

@@ -2,12 +2,20 @@ import { defaultweights, scoreterms, termindex } from './searchscore';
 
 const indexCache = /* @__PURE__ */ new WeakMap();
 function fuzzy(text, query) {
-  if (!query || !text) return 0;
-  if (query.length > text.length) return 0;
+  if (!query || !text) {
+    return 0;
+  }
+  if (query.length > text.length) {
+    return 0;
+  }
   const lower = text.toLowerCase();
   const q = query.toLowerCase();
-  if (lower === q) return q.length * 2 + 30;
-  if (lower.startsWith(q)) return q.length * 2 + 10;
+  if (lower === q) {
+    return q.length * 2 + 30;
+  }
+  if (lower.startsWith(q)) {
+    return q.length * 2 + 10;
+  }
   let score = 0;
   let qi = 0;
   let consecutive = 0;
@@ -23,7 +31,7 @@ function fuzzy(text, query) {
   return qi < q.length ? 0 : score;
 }
 function normalize(text) {
-  return text?.toLowerCase().replace(/\s+/g, " ").trim() ?? "";
+  return text?.toLowerCase().replaceAll(/\s+/g, " ").trim() ?? "";
 }
 function split(query) {
   return normalize(query).split(" ").filter(Boolean);
@@ -33,51 +41,80 @@ function words(text) {
 }
 function getIndex(docs) {
   const cached = indexCache.get(docs);
-  if (cached) return cached;
+  if (cached) {
+    return cached;
+  }
   const indexed = docs.map((doc) => ({
-    doc,
-    title: normalize(doc.title),
-    description: normalize(doc.description),
     content: doc.content.toLowerCase(),
+    contentindex: termindex(words(doc.content.toLowerCase())),
     contentraw: doc.content,
-    slug: normalize(doc.slug),
+    description: normalize(doc.description),
+    descriptionindex: termindex(words(normalize(doc.description))),
+    doc,
+    headingindex: termindex(
+      words(
+        (doc.headings ?? []).map((heading) => normalize(heading.text)).join(" ")
+      )
+    ),
     headings: (doc.headings ?? []).map((heading) => ({
       id: heading.id,
-      text: heading.text,
       level: heading.level,
-      normalized: normalize(heading.text)
+      normalized: normalize(heading.text),
+      text: heading.text
     })),
-    titleindex: termindex(words(normalize(doc.title))),
-    descriptionindex: termindex(words(normalize(doc.description))),
+    slug: normalize(doc.slug),
     slugindex: termindex(words(normalize(doc.slug))),
-    headingindex: termindex(words((doc.headings ?? []).map((heading) => normalize(heading.text)).join(" "))),
-    contentindex: termindex(words(doc.content.toLowerCase()))
+    title: normalize(doc.title),
+    titleindex: termindex(words(normalize(doc.title)))
   }));
   indexCache.set(docs, indexed);
   return indexed;
 }
 function searchContent(content, contentraw, query, terms) {
-  if (!content || !query) return null;
-  const positions = [content.indexOf(query), ...terms.map((term) => content.indexOf(term))];
+  if (!content || !query) {
+    return null;
+  }
+  const positions = [
+    content.indexOf(query),
+    ...terms.map((term) => content.indexOf(term))
+  ];
   const idx = positions.filter((value) => value >= 0).sort((a, b) => a - b)[0] ?? -1;
-  if (idx === -1) return null;
-  const termScore = terms.reduce((score, term) => score + (content.includes(term) ? 1 : 0), 0);
+  if (idx === -1) {
+    return null;
+  }
+  const termScore = terms.reduce(
+    (score, term) => score + (content.includes(term) ? 1 : 0),
+    0
+  );
   const start = Math.max(0, idx - 40);
   const source = contentraw ?? content;
   const end = Math.min(source.length, idx + query.length + 60);
   const prefix = start > 0 ? "..." : "";
   const suffix = end < source.length ? "..." : "";
-  return { score: 5 + termScore, snippet: prefix + source.slice(start, end).trim() + suffix };
+  return {
+    score: 5 + termScore,
+    snippet: prefix + source.slice(start, end).trim() + suffix
+  };
 }
 function searchHeadings(headings, query, terms) {
-  if (headings.length === 0 || !query) return null;
+  if (headings.length === 0 || !query) {
+    return null;
+  }
   let best = null;
   for (const heading of headings) {
-    const termScore = terms.reduce((score2, term) => score2 + (heading.normalized.includes(term) ? 3 : 0), 0);
+    const termScore = terms.reduce(
+      (score2, term) => score2 + (heading.normalized.includes(term) ? 3 : 0),
+      0
+    );
     const levelBoost = heading.level === 2 ? 8 : heading.level === 3 ? 5 : 3;
     const score = fuzzy(heading.normalized, query) * 2 + termScore + levelBoost;
     if (score > 0 && (!best || score > best.score)) {
-      best = { score, anchor: heading.id, heading: heading.text, snippet: heading.text };
+      best = {
+        anchor: heading.id,
+        heading: heading.text,
+        score,
+        snippet: heading.text
+      };
     }
   }
   return best;
@@ -91,21 +128,29 @@ function push(results, result, limit) {
   for (let i = 1; i < results.length; i++) {
     const candidate = results[i];
     const current = results[min];
-    if (!candidate || !current) continue;
-    if (candidate.score < current.score) min = i;
+    if (!candidate || !current) {
+      continue;
+    }
+    if (candidate.score < current.score) {
+      min = i;
+    }
   }
   const minEntry = results[min];
-  if (minEntry && result.score <= minEntry.score) return;
+  if (minEntry && result.score <= minEntry.score) {
+    return;
+  }
   results[min] = result;
 }
 function createLocalSearch(options = {}) {
   const weights = {
     ...defaultweights,
-    ...options.weights ?? {}
+    ...options.weights
   };
   return {
     search(query, docs, limit = Number.POSITIVE_INFINITY) {
-      if (!docs || docs.length === 0) return [];
+      if (!docs || docs.length === 0) {
+        return [];
+      }
       const q = query?.trim() ?? "";
       if (!q) {
         return docs.slice(0, limit).map((doc) => ({ doc, score: 0 }));
@@ -118,28 +163,41 @@ function createLocalSearch(options = {}) {
         const titleScore = fuzzy(item.title, normalized) * 3;
         const descScore = fuzzy(item.description, normalized);
         const headingResult = searchHeadings(item.headings, normalized, terms);
-        const contentResult = searchContent(item.content, item.contentraw, normalized, terms);
-        const termScore = scoreterms(terms, {
-          title: item.title,
-          slug: item.slug,
-          description: item.description,
-          content: item.content,
-          titleindex: item.titleindex,
-          slugindex: item.slugindex,
-          descriptionindex: item.descriptionindex,
-          headingindex: item.headingindex,
-          contentindex: item.contentindex
-        }, weights);
+        const contentResult = searchContent(
+          item.content,
+          item.contentraw,
+          normalized,
+          terms
+        );
+        const termScore = scoreterms(
+          terms,
+          {
+            content: item.content,
+            contentindex: item.contentindex,
+            description: item.description,
+            descriptionindex: item.descriptionindex,
+            headingindex: item.headingindex,
+            slug: item.slug,
+            slugindex: item.slugindex,
+            title: item.title,
+            titleindex: item.titleindex
+          },
+          weights
+        );
         const exactScore = item.title === normalized || item.slug === normalized ? 30 : 0;
         const score = titleScore + descScore + termScore + exactScore + (headingResult?.score ?? 0) + (contentResult?.score ?? 0);
         if (score > 0) {
-          push(results, {
-            doc: item.doc,
-            score,
-            snippet: headingResult?.snippet ?? contentResult?.snippet,
-            anchor: headingResult?.anchor,
-            heading: headingResult?.heading
-          }, limit);
+          push(
+            results,
+            {
+              anchor: headingResult?.anchor,
+              doc: item.doc,
+              heading: headingResult?.heading,
+              score,
+              snippet: headingResult?.snippet ?? contentResult?.snippet
+            },
+            limit
+          );
         }
       }
       results.sort((a, b) => b.score - a.score);

package/dist/searchindex.js

@@ -26,21 +26,25 @@ function tokenize(text, config) {
   return text.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= min && !stops.has(w)).map((word) => config?.stemming ? stem(word) : word).filter((word) => word.length >= min);
 }
 function doctext(doc) {
-  return [doc.title, doc.description ?? "", ...doc.headings, doc.content].join(" ");
+  return [doc.title, doc.description ?? "", ...doc.headings, doc.content].join(
+    " "
+  );
 }
 function indexDocument(index, idx, doc) {
   const tokens = tokenize(doctext(doc), index.config);
   for (const token of tokens) {
     const existing = index.terms.get(token);
     if (existing) {
-      if (!existing.includes(idx)) existing.push(idx);
+      if (!existing.includes(idx)) {
+        existing.push(idx);
+      }
     } else {
       index.terms.set(token, [idx]);
     }
   }
 }
 function createIndex(config) {
-  return { documents: [], terms: /* @__PURE__ */ new Map(), version: 1, config };
+  return { config, documents: [], terms: /* @__PURE__ */ new Map(), version: 1 };
 }
 function addDocument(index, doc) {
   const idx = index.documents.length;
@@ -49,13 +53,19 @@ function addDocument(index, doc) {
 }
 function removeDocument(index, path) {
   const idx = index.documents.findIndex((d) => d.path === path);
-  if (idx === -1) return;
+  if (idx === -1) {
+    return;
+  }
   const doc = index.documents[idx];
-  if (!doc) return;
+  if (!doc) {
+    return;
+  }
   const lastidx = index.documents.length - 1;
   const remove = (token, target) => {
     const entries = index.terms.get(token);
-    if (!entries) return;
+    if (!entries) {
+      return;
+    }
     const next = entries.filter((value) => value !== target);
     if (next.length === 0) {
       index.terms.delete(token);
@@ -65,9 +75,13 @@ function removeDocument(index, path) {
   };
   const replace = (token, from, to) => {
     const entries = index.terms.get(token);
-    if (!entries) return;
+    if (!entries) {
+      return;
+    }
     for (let i = 0; i < entries.length; i++) {
-      if (entries[i] === from) entries[i] = to;
+      if (entries[i] === from) {
+        entries[i] = to;
+      }
     }
   };
   for (const token of new Set(tokenize(doctext(doc), index.config))) {
@@ -90,11 +104,15 @@ function removeDocument(index, path) {
 }
 function search(index, query, limit = 10) {
   const tokens = tokenize(query, index.config);
-  if (tokens.length === 0) return [];
+  if (tokens.length === 0) {
+    return [];
+  }
   const scores = /* @__PURE__ */ new Map();
   for (const token of tokens) {
     const indices = index.terms.get(token);
-    if (!indices) continue;
+    if (!indices) {
+      continue;
+    }
     for (const idx of indices) {
       scores.set(idx, (scores.get(idx) ?? 0) + 1);
     }
@@ -103,44 +121,68 @@ function search(index, query, limit = 10) {
 }
 function serializeIndex(index) {
   return JSON.stringify({
+    config: index.config,
     documents: index.documents,
     terms: [...index.terms.entries()],
-    version: index.version,
-    config: index.config
+    version: index.version
   });
 }
 function isrecord(value) {
   return typeof value === "object" && value !== null;
 }
 function issearchdocument(value) {
-  if (!isrecord(value)) return false;
-  if (typeof value.path !== "string") return false;
-  if (typeof value.title !== "string") return false;
-  if (typeof value.content !== "string") return false;
-  if (!Array.isArray(value.headings) || value.headings.some((item) => typeof item !== "string")) return false;
-  if (value.description !== void 0 && typeof value.description !== "string") return false;
+  if (!isrecord(value)) {
+    return false;
+  }
+  if (typeof value.path !== "string") {
+    return false;
+  }
+  if (typeof value.title !== "string") {
+    return false;
+  }
+  if (typeof value.content !== "string") {
+    return false;
+  }
+  if (!Array.isArray(value.headings) || value.headings.some((item) => typeof item !== "string")) {
+    return false;
+  }
+  if (value.description !== void 0 && typeof value.description !== "string") {
+    return false;
+  }
   if (value.tags !== void 0 && (!Array.isArray(value.tags) || value.tags.some((item) => typeof item !== "string"))) {
     return false;
   }
   return true;
 }
 function istermentry(value) {
-  if (!Array.isArray(value) || value.length !== 2) return false;
-  if (typeof value[0] !== "string") return false;
+  if (!Array.isArray(value) || value.length !== 2) {
+    return false;
+  }
+  if (typeof value[0] !== "string") {
+    return false;
+  }
   if (!Array.isArray(value[1]) || value[1].some((item) => typeof item !== "number" || !Number.isInteger(item))) {
     return false;
   }
   return true;
 }
 function isindexconfig(value) {
-  if (!isrecord(value)) return false;
-  if (value.stemming !== void 0 && typeof value.stemming !== "boolean") return false;
+  if (!isrecord(value)) {
+    return false;
+  }
+  if (value.stemming !== void 0 && typeof value.stemming !== "boolean") {
+    return false;
+  }
   if (value.minLength !== void 0 && (typeof value.minLength !== "number" || !Number.isInteger(value.minLength))) {
     return false;
   }
   if (value.stopWords !== void 0) {
-    if (!Array.isArray(value.stopWords)) return false;
-    if (value.stopWords.some((item) => typeof item !== "string")) return false;
+    if (!Array.isArray(value.stopWords)) {
+      return false;
+    }
+    if (value.stopWords.some((item) => typeof item !== "string")) {
+      return false;
+    }
   }
   return true;
 }
@@ -157,27 +199,37 @@ function deserializeIndex(data) {
   if (!termsraw || termsraw.some((item) => !istermentry(item))) {
     throw new Error("invalid search index terms");
   }
-  const version = parsed.version;
+  const { version } = parsed;
   if (typeof version !== "number" || !Number.isInteger(version)) {
-    throw new Error("invalid search index version");
+    throw new TypeError("invalid search index version");
   }
-  const config = parsed.config;
+  const { config } = parsed;
   if (config !== void 0 && !isindexconfig(config)) {
     throw new Error("invalid search index config");
   }
   return {
+    config,
     documents,
     terms: new Map(termsraw),
-    version,
-    config
+    version
   };
 }
 function stem(word) {
-  if (word.length <= 3) return word;
-  if (word.endsWith("ies") && word.length > 4) return `${word.slice(0, -3)}y`;
-  if (word.endsWith("ing") && word.length > 5) return word.slice(0, -3);
-  if (word.endsWith("ed") && word.length > 4) return word.slice(0, -2);
-  if (word.endsWith("s") && !word.endsWith("ss") && word.length > 3) return word.slice(0, -1);
+  if (word.length <= 3) {
+    return word;
+  }
+  if (word.endsWith("ies") && word.length > 4) {
+    return `${word.slice(0, -3)}y`;
+  }
+  if (word.endsWith("ing") && word.length > 5) {
+    return word.slice(0, -3);
+  }
+  if (word.endsWith("ed") && word.length > 4) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !word.endsWith("ss") && word.length > 3) {
+    return word.slice(0, -1);
+  }
   return word;
 }
 

package/dist/searchpolicy.js

@@ -1,6 +1,6 @@
 const searchmaxquery = 200;
 function normalizequery(query) {
-  return query.toLowerCase().replace(/\s+/g, " ").trim().slice(0, searchmaxquery);
+  return query.toLowerCase().replaceAll(/\s+/g, " ").trim().slice(0, searchmaxquery);
 }
 function trimquery(query) {
   return query.slice(0, searchmaxquery);

package/dist/searchscore.js

@@ -1,14 +1,14 @@
 import { typomatch } from './searchtypo';
 
 const defaultweights = {
-  titleExact: 9,
-  titleTypo: 5,
-  slugExact: 7,
-  slugTypo: 4,
+  contentExact: 2,
   descriptionExact: 4,
   descriptionTypo: 2,
   headingTypo: 2,
-  contentExact: 2
+  slugExact: 7,
+  slugTypo: 4,
+  titleExact: 9,
+  titleTypo: 5
 };
 function termindex(words) {
   return { list: words, set: new Set(words) };