fromsrc 0.0.0 → 0.0.1

package/dist/remarktwoslash.d.ts

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

package/dist/remarktwoslash.js

@@ -0,0 +1,86 @@
+import { visit } from 'unist-util-visit';
+
+function parseannotations(code) {
+  const lines = code.split("\n");
+  const output = [];
+  const annotations = [];
+  let noErrors = false;
+  let offset = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const trimmed = line.trim();
+    if (trimmed === "// @noErrors") {
+      noErrors = true;
+      offset++;
+      continue;
+    }
+    if (trimmed === "// @errors: next-line" || trimmed.startsWith("// @errors:")) {
+      offset++;
+      continue;
+    }
+    const query = line.match(/^(\s*)\/\/\s*\^(\?)(.*)$/);
+    if (query) {
+      const indent = query[1];
+      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
+      });
+      offset++;
+      continue;
+    }
+    const completion = line.match(/^(\s*)\/\/\s*\^(\|)(.*)$/);
+    if (completion) {
+      const indent = completion[1];
+      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
+      });
+      offset++;
+      continue;
+    }
+    output.push(line);
+  }
+  return { code: output.join("\n"), annotations, noErrors };
+}
+function serialize(annotations) {
+  return JSON.stringify(
+    annotations.map((a) => ({
+      t: a.type === "query" ? "q" : "c",
+      l: a.line,
+      ch: a.character,
+      ...a.text ? { tx: a.text } : {}
+    }))
+  );
+}
+function transformer(tree) {
+  visit(tree, "code", (node) => {
+    if (!node.meta?.includes("twoslash")) return;
+    const result = parseannotations(node.value);
+    if (result.annotations.length === 0) return;
+    node.value = result.code;
+    node.meta = node.meta.replace(/\btwoslash\b/, "").trim() || null;
+    node.data ??= {};
+    const data = node.data;
+    data.hProperties ??= {};
+    const props = data.hProperties;
+    props["data-twoslash"] = "";
+    props["data-twoslash-annotations"] = serialize(result.annotations);
+    if (result.noErrors) {
+      props["data-twoslash-noerrors"] = "";
+    }
+  });
+}
+const remarkTwoslash = () => transformer;
+
+export { parseannotations, remarkTwoslash, serialize };

package/dist/remarkvideo.d.ts

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

package/dist/remarkvideo.js

@@ -0,0 +1,59 @@
+import { visit } from 'unist-util-visit';
+
+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" })
+  },
+  {
+    pattern: /vimeo\.com\/(\d+)/,
+    transform: (m) => ({ src: `https://player.vimeo.com/video/${m[1]}`, type: "vimeo" })
+  }
+];
+function makeNode(src, type) {
+  const attributes = [
+    { type: "mdxJsxAttribute", name: "src", value: src }
+  ];
+  if (type) attributes.push({ type: "mdxJsxAttribute", name: "type", value: type });
+  return {
+    type: "mdxJsxFlowElement",
+    name: "Video",
+    attributes,
+    children: [],
+    data: { _mdxExplicitJsx: true }
+  };
+}
+function resolve(url, providers) {
+  if (extensions.test(url)) return makeNode(url);
+  for (const p of providers) {
+    const match = url.match(p.pattern);
+    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;
+  const child = node.children[0];
+  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;
+      const url = extractUrl(node);
+      if (!url) return;
+      const video = resolve(url, all);
+      if (!video) return;
+      parent.children[index] = video;
+    });
+  };
+};
+
+export { remarkVideo };

package/dist/remix.d.ts

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

package/dist/remix.js

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

package/dist/schema.d.ts

@@ -0,0 +1,54 @@
+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>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    order?: number | undefined;
+    description?: string | undefined;
+    draft?: boolean | undefined;
+}, {
+    title: string;
+    order?: number | undefined;
+    description?: string | undefined;
+    draft?: boolean | undefined;
+}>;
+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<{
+    title: z.ZodString;
+    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<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    draft: z.ZodOptional<z.ZodBoolean>;
+}, 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<{
+    title: z.ZodString;
+    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<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    draft: z.ZodOptional<z.ZodBoolean>;
+}, 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

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

package/dist/search.d.ts

@@ -0,0 +1,24 @@
+import { SearchDoc } from './content.js';
+import { Searchweights } from './searchscore.js';
+import 'zod';
+import './schema.js';
+
+interface SearchResult {
+    doc: SearchDoc;
+    score: number;
+    snippet?: string;
+    anchor?: string;
+    heading?: string;
+}
+interface SearchAdapter {
+    search(query: string, docs: SearchDoc[], limit?: number): SearchResult[] | Promise<SearchResult[]>;
+    index?(docs: SearchDoc[]): void | Promise<void>;
+}
+interface LocalSearchOptions {
+    weights?: Partial<Searchweights>;
+}
+declare function createLocalSearch(options?: LocalSearchOptions): SearchAdapter;
+declare const localSearch: SearchAdapter;
+declare function createSearchAdapter<T extends SearchAdapter>(adapter: T): T;
+
+export { type LocalSearchOptions, type SearchAdapter, type SearchResult, createLocalSearch, createSearchAdapter, localSearch };

package/dist/search.js

@@ -0,0 +1,155 @@
+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;
+  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;
+  let score = 0;
+  let qi = 0;
+  let consecutive = 0;
+  for (let i = 0; i < lower.length && qi < q.length; i++) {
+    if (lower[i] === q[qi]) {
+      score += 1 + consecutive;
+      consecutive++;
+      qi++;
+    } else {
+      consecutive = 0;
+    }
+  }
+  return qi < q.length ? 0 : score;
+}
+function normalize(text) {
+  return text?.toLowerCase().replace(/\s+/g, " ").trim() ?? "";
+}
+function split(query) {
+  return normalize(query).split(" ").filter(Boolean);
+}
+function words(text) {
+  return text.split(/[^a-z0-9]+/).filter(Boolean);
+}
+function getIndex(docs) {
+  const cached = indexCache.get(docs);
+  if (cached) return cached;
+  const indexed = docs.map((doc) => ({
+    doc,
+    title: normalize(doc.title),
+    description: normalize(doc.description),
+    content: doc.content.toLowerCase(),
+    contentraw: doc.content,
+    slug: normalize(doc.slug),
+    headings: (doc.headings ?? []).map((heading) => ({
+      id: heading.id,
+      text: heading.text,
+      level: heading.level,
+      normalized: normalize(heading.text)
+    })),
+    titleindex: termindex(words(normalize(doc.title))),
+    descriptionindex: termindex(words(normalize(doc.description))),
+    slugindex: termindex(words(normalize(doc.slug))),
+    headingindex: termindex(words((doc.headings ?? []).map((heading) => normalize(heading.text)).join(" "))),
+    contentindex: termindex(words(doc.content.toLowerCase()))
+  }));
+  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))];
+  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);
+  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 };
+}
+function searchHeadings(headings, query, terms) {
+  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 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 };
+    }
+  }
+  return best;
+}
+function push(results, result, limit) {
+  if (!Number.isFinite(limit) || results.length < limit) {
+    results.push(result);
+    return;
+  }
+  let min = 0;
+  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;
+  }
+  const minEntry = results[min];
+  if (minEntry && result.score <= minEntry.score) return;
+  results[min] = result;
+}
+function createLocalSearch(options = {}) {
+  const weights = {
+    ...defaultweights,
+    ...options.weights ?? {}
+  };
+  return {
+    search(query, docs, limit = Number.POSITIVE_INFINITY) {
+      if (!docs || docs.length === 0) return [];
+      const q = query?.trim() ?? "";
+      if (!q) {
+        return docs.slice(0, limit).map((doc) => ({ doc, score: 0 }));
+      }
+      const terms = split(q);
+      const normalized = normalize(q);
+      const indexed = getIndex(docs);
+      const results = [];
+      for (const item of indexed) {
+        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 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);
+        }
+      }
+      results.sort((a, b) => b.score - a.score);
+      return results;
+    }
+  };
+}
+const localSearch = createLocalSearch();
+function createSearchAdapter(adapter) {
+  return adapter;
+}
+
+export { createLocalSearch, createSearchAdapter, localSearch };

package/dist/searchindex.d.ts

@@ -0,0 +1,28 @@
+interface SearchDocument {
+    path: string;
+    title: string;
+    description?: string;
+    headings: string[];
+    content: string;
+    tags?: string[];
+}
+interface SearchIndex {
+    documents: SearchDocument[];
+    terms: Map<string, number[]>;
+    version: number;
+    config?: IndexConfig;
+}
+interface IndexConfig {
+    stemming?: boolean;
+    stopWords?: string[];
+    minLength?: number;
+}
+declare function tokenize(text: string, config?: IndexConfig): string[];
+declare function createIndex(config?: IndexConfig): SearchIndex;
+declare function addDocument(index: SearchIndex, doc: SearchDocument): void;
+declare function removeDocument(index: SearchIndex, path: string): void;
+declare function search(index: SearchIndex, query: string, limit?: number): SearchDocument[];
+declare function serializeIndex(index: SearchIndex): string;
+declare function deserializeIndex(data: string): SearchIndex;
+
+export { type IndexConfig, type SearchDocument, type SearchIndex, addDocument, createIndex, deserializeIndex, removeDocument, search, serializeIndex, tokenize };

package/dist/searchindex.js

@@ -0,0 +1,184 @@
+const DEFAULT_STOPS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "and",
+  "or",
+  "but",
+  "not",
+  "with",
+  "this",
+  "that"
+]);
+function tokenize(text, config) {
+  const stops = config?.stopWords ? new Set(config.stopWords) : DEFAULT_STOPS;
+  const min = config?.minLength ?? 2;
+  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(" ");
+}
+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);
+    } else {
+      index.terms.set(token, [idx]);
+    }
+  }
+}
+function createIndex(config) {
+  return { documents: [], terms: /* @__PURE__ */ new Map(), version: 1, config };
+}
+function addDocument(index, doc) {
+  const idx = index.documents.length;
+  index.documents.push(doc);
+  indexDocument(index, idx, doc);
+}
+function removeDocument(index, path) {
+  const idx = index.documents.findIndex((d) => d.path === path);
+  if (idx === -1) return;
+  const doc = index.documents[idx];
+  if (!doc) return;
+  const lastidx = index.documents.length - 1;
+  const remove = (token, target) => {
+    const entries = index.terms.get(token);
+    if (!entries) return;
+    const next = entries.filter((value) => value !== target);
+    if (next.length === 0) {
+      index.terms.delete(token);
+    } else {
+      index.terms.set(token, next);
+    }
+  };
+  const replace = (token, from, to) => {
+    const entries = index.terms.get(token);
+    if (!entries) return;
+    for (let i = 0; i < entries.length; i++) {
+      if (entries[i] === from) entries[i] = to;
+    }
+  };
+  for (const token of new Set(tokenize(doctext(doc), index.config))) {
+    remove(token, idx);
+  }
+  if (idx === lastidx) {
+    index.documents.pop();
+    return;
+  }
+  const lastdoc = index.documents[lastidx];
+  if (!lastdoc) {
+    index.documents.pop();
+    return;
+  }
+  for (const token of new Set(tokenize(doctext(lastdoc), index.config))) {
+    replace(token, lastidx, idx);
+  }
+  index.documents[idx] = lastdoc;
+  index.documents.pop();
+}
+function search(index, query, limit = 10) {
+  const tokens = tokenize(query, index.config);
+  if (tokens.length === 0) return [];
+  const scores = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const indices = index.terms.get(token);
+    if (!indices) continue;
+    for (const idx of indices) {
+      scores.set(idx, (scores.get(idx) ?? 0) + 1);
+    }
+  }
+  return [...scores.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([idx]) => index.documents[idx]).filter((doc) => doc !== void 0);
+}
+function serializeIndex(index) {
+  return JSON.stringify({
+    documents: index.documents,
+    terms: [...index.terms.entries()],
+    version: index.version,
+    config: index.config
+  });
+}
+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 (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[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 (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;
+  }
+  return true;
+}
+function deserializeIndex(data) {
+  const parsed = JSON.parse(data);
+  if (!isrecord(parsed)) {
+    throw new Error("invalid search index");
+  }
+  const documents = Array.isArray(parsed.documents) ? parsed.documents : null;
+  if (!documents || documents.some((item) => !issearchdocument(item))) {
+    throw new Error("invalid search index documents");
+  }
+  const termsraw = Array.isArray(parsed.terms) ? parsed.terms : null;
+  if (!termsraw || termsraw.some((item) => !istermentry(item))) {
+    throw new Error("invalid search index terms");
+  }
+  const version = parsed.version;
+  if (typeof version !== "number" || !Number.isInteger(version)) {
+    throw new Error("invalid search index version");
+  }
+  const config = parsed.config;
+  if (config !== void 0 && !isindexconfig(config)) {
+    throw new Error("invalid search index config");
+  }
+  return {
+    documents,
+    terms: new Map(termsraw),
+    version,
+    config
+  };
+}
+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);
+  return word;
+}
+
+export { addDocument, createIndex, deserializeIndex, removeDocument, search, serializeIndex, tokenize };

package/dist/searchpolicy.d.ts

@@ -0,0 +1,5 @@
+declare const searchmaxquery = 200;
+declare function normalizequery(query: string): string;
+declare function trimquery(query: string): string;
+
+export { normalizequery, searchmaxquery, trimquery };

package/dist/searchpolicy.js

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