extract-webpage 1.2.5

package/dist/search/public-searxng.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Search Web via SearXNG metasearch of all major search engines.
+ */
+export declare function searchWeb(query: string, options?: SearchOptions): Promise<SearxngSearchResult[] | SearchResponse>;
+interface SearxngSearchOptions {
+    categories?: string[];
+    engines?: string[];
+    language?: string;
+    pageno?: number;
+}
+export declare const searchSearxng: (query: string, opts?: SearxngSearchOptions) => Promise<{
+    results: SearxngSearchResult[];
+    suggestions: string[];
+}>;
+interface SearchOptions {
+    category?: string | number;
+    recency?: string;
+    privateSearxng?: string | boolean | null;
+    maxRetries?: number;
+    page?: number;
+    safesearch?: boolean;
+    lang?: string;
+    proxy?: string | null;
+    useProxy?: boolean;
+}
+export interface SearxngSearchResult {
+    title: string;
+    url: string;
+    snippet?: string;
+    domain?: string;
+    favicon?: string;
+    score?: number;
+    source?: string;
+    date?: string;
+    img_src?: string;
+    thumbnail_src?: string;
+    thumbnail?: string;
+    content?: string;
+    author?: string;
+    iframe_src?: string;
+}
+export interface SearchResponse {
+    results: SearxngSearchResult[];
+    suggestions: string[];
+    infoboxes?: any[];
+}
+export {};

package/dist/search/search-web.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Search Web via SearXNG metasearch of all major search engines.
+ * Options are 10 search categories, recency, and how many
+ * times to retry other domains if first time fails.
+ * SearXNG is a free internet metasearch engine which aggregates results from
+ *  more than [180+ search sources](https://docs.searxng.org/user/configured_engines.html).
+ *
+ * [Searxng Overview](https://medium.com/@elmo92/search-in-peace-with-searxng-an-alternative-search-engine-that-keeps-your-searches-private-accd8cddd6fc)
+ * [Searxng Installation Guide](https://github.com/searxng/searxng-docker/tree/master)
+ *
+ * ![google_dead](https://i.imgur.com/6rRpaY1.png)
+ * @param {string} query - The search query string.
+ * @param {Object} [options]
+ * @param {string} options.category default=general - ["general", "news", "videos", "images",
+ *  "science","it", "files", "social+media",  "map", "music"]
+ * @param {string} options.recency default=all - ["all", "day", "week", "month", "year"]
+ * @param {string|boolean} options.privateSearxng default=null - Use your custom domain SearXNG
+ * @param {number} options.maxRetries default=3 - Maximum number of retry attempts if the initial search fails.
+ * @param {number} options.page default=1 - The page number to retrieve.
+ * @param {boolean} options.safesearch default=false - Whether to block adult content.
+ * @param {string} options.lang default="en-US" - The language to use for the search.
+ * @param {string} options.proxy default=false - Use corsproxy.io to access in frontend JS
+ * @returns {Promise<Array<{title: string, url: string, snippet: string, domain: string, favicon: string, path: string, engines: string[]}>>} An array of search result objects.
+ * @example  const advancedResults = await searchWeb('Node.js', {
+ *   category: 2,
+ *   recency: 1,
+ *   maxRetries: 5
+ * });
+ * @category Search
+ * @author [vtempest (2025)](https://github.com/vtempest)
+ * [Heiser, M., Tauber, A., Flament, A., et al. (2014-)](https://github.com/searxng/searxng/graphs/contributors)
+ */
+export declare function searchWeb(query: any, options?: any): Promise<any>;

package/dist/search/tavily.d.ts

@@ -0,0 +1,20 @@
+interface TavilySearchOptions {
+    searchDepth?: "basic" | "advanced";
+    maxResults?: number;
+    includeDomains?: string[];
+    excludeDomains?: string[];
+}
+interface TavilySearchResult {
+    title: string;
+    url: string;
+    content: string;
+    score: number;
+    raw_content?: string;
+}
+export declare const searchTavily: (query: string, opts?: TavilySearchOptions) => Promise<{
+    results: TavilySearchResult[];
+    suggestions: string[];
+}>;
+export declare const getTavilyApiKey: () => any;
+export declare const isTavilyConfigured: () => boolean;
+export {};

package/dist/search/url-to-html.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ### Tardigrade the Web Crawler
+ *
+ * 1. **Use Fetch API, check for bot detection.
+ * Scrape  any domain's URL to get its HTML, JSON, or arraybuffer.<br />
+ * Scraping internet pages is a [free speech right
+ * ](https://blog.apify.com/is-web-scraping-legal/).
+ * 2. Features: timeout, redirects, default UA, referer as google, and bot
+ * detection checking. <br />
+ * 3. If fetch method does not get needed HTML, use Docker proxy as backup.
+ *
+ * 4. [Setup Docker](https://github.com/vtempest/ai-research-agent/tree/master/src/crawler)
+ *  container with NodeJS server API renders with puppeteer DOM to get all HTML loaded by
+ *  secondary in-page API requests after the initial page request, including user login and cookie storage.
+ * 5. Bypass Cloudflare bot check: A webpage proxy that request
+ * through Chromium (puppeteer) - can be used to bypass Cloudflare
+ * anti bot using cookie id javascript method.
+ * 6. Send your request to the server with the port 3000 and add your URL to the "url"
+ *  query string like this: `http://localhost:3000/?url=https://example.org`
+ *
+ * 7. Optional: Setup residential IP proxy to access sites that IP-block datacenters
+ *  and manage rotation with [Scrapoxy](https://scrapoxy.io). Recommended:
+ * [Hypeproxy](https://hypeproxy.io/products/static-residential-proxies)
+ * [NinjasProxy](https://ninjasproxy.com/residential-proxies/)
+ * [Proxy-Cheap](https://app.proxy-cheap.com/order)
+ * [LiveProxies](https://liveproxies.io/rotating-residential-proxies-pricing)
+ *
+ * @param {string} url - any domain's URL
+ * @param {Object} [options]
+ * @param {number} options.timeout default=5 -  abort request if not retrived, in seconds
+ * @param {number} options.maxRedirects default=3 - max redirects to follow
+ * @param {number} options.checkBotDetection default=true - check for bot detection messages
+ * @param {number} options.changeReferer default=true - set referer as google
+ * @param {number} options.userAgentIndex default=0 - index of [google bot, default chrome]
+ * @param {string} options.proxy default=false - use proxy url
+ * @param {boolean} options.checkRobotsAllowed default=false - check robots.txt rules
+ * @returns {Promise<string>} -  HTML, JSON, arraybuffer, or error object
+ * @category Extract
+ * @example await scrapeURL("https://hckrnews.com", {timeout: 5, userAgentIndex: 1})
+ * @author [vtempest (2025)](https://github.com/vtempest)
+ * @license MIT
+ */
+export declare function scrapeURL(url: any, options?: any): Promise<any>;
+/**
+ * As backup, scrape with JINA to get html
+ * @param {string} url
+ * @returns {Promise<string>}
+ */
+export declare function scrapeJINA(url: any, timeout?: number): Promise<string>;
+/**
+ * Fetches and parses the robots.txt file for a given URL.
+ * @param {string} url - The base URL to fetch the robots.txt from.
+ * @returns {Promise<Object>} A JSON object representing the parsed robots.txt.
+ */
+export declare function fetchScrapingRules(url: any): Promise<{
+    directives: {};
+    crawlDelay: {};
+    sitemaps: any[];
+    preferredHost: any;
+} | {
+    error: string;
+}>;

package/dist/seektopic/fold-keyphrases.d.ts

@@ -0,0 +1,28 @@
+import { KeyphraseEntry } from './types';
+/**
+ * Folds smaller keyphrases that are near-subsets of larger ones, merging their
+ * weights and sentence lists upward.
+ *
+ * Two phrases are considered overlapping when they share all-but-one word
+ * (i.e., the number of words in the smaller phrase that do **not** appear in
+ * the larger phrase is fewer than 2). When a merge occurs:
+ * - The larger phrase absorbs a fraction of the smaller one's weight
+ *   (`smallWeight / largerWordCount`).
+ * - Sentence indices are union-merged.
+ * - If the smaller phrase actually outweighs the larger at that point, the
+ *   larger entry adopts the smaller phrase's text (best representative wins).
+ *
+ * Phrases are processed largest-first so that supersets are always evaluated
+ * before their constituent sub-phrases.
+ *
+ * @param keyphrases - Raw scored keyphrases, any order.
+ * @returns Deduplicated, folded array \u2014 larger representative phrases only.
+ *
+ * @example
+ * const folded = foldSubphrases([
+ *   { keyphrase: "machine learning", words: 2, weight: 10, sentences: [0, 1] },
+ *   { keyphrase: "machine",          words: 1, weight:  4, sentences: [0, 2] },
+ * ]);
+ * // "machine" is absorbed into "machine learning"
+ */
+export declare function foldSubphrases(keyphrases: KeyphraseEntry[]): KeyphraseEntry[];

package/dist/seektopic/ngrams.d.ts

@@ -0,0 +1,27 @@
+import { NgramMap, TopicToken } from './types';
+/**
+ * Extracts noun-anchored edge-grams from a token array and accumulates them into `nGrams`.
+ *
+ * An edge-gram is a contiguous slice of `nGramSize` tokens where:
+ * - The **first** and **last** tokens are topic entities (noun or wiki title).
+ * - Every token is either a topic entity or a common stop word (e.g. "of", "the").
+ * - Every token meets the `minWordLength` character threshold.
+ *
+ * This allows natural multi-word keyphrases like "state of the art" or
+ * "machine learning" while ignoring pure function-word sequences.
+ *
+ * @param nGramSize - Number of tokens in the slice to evaluate.
+ * @param terms - Full token array for the current sentence.
+ * @param index - Start position for this slice within `terms`.
+ * @param nGrams - Accumulator map mutated in-place: `nGrams[size][phrase] = [sentenceIdx, ...]`.
+ * @param minWordLength - Minimum character length for any word to be included.
+ * @param sentenceIndex - Index of the originating sentence, appended to the phrase's entry.
+ * @returns The same `nGrams` reference (mutated).
+ *
+ * @example
+ * const terms: TopicToken[] = [["machine", 1, 4, ""], ["learning", 1, 5, ""]];
+ * const nGrams: NgramMap = {};
+ * extractNounEdgeGrams(2, terms, 0, nGrams, 3, 0);
+ * // nGrams[2]["machine learning"] === [0]
+ */
+export declare function extractNounEdgeGrams(nGramSize: number, terms: TopicToken[], index: number, nGrams: NgramMap, minWordLength: number, sentenceIndex: number): NgramMap;

package/dist/seektopic/rank-sentences-keyphrases.d.ts

@@ -0,0 +1,28 @@
+import { SentenceEntry, RankOptions } from './types';
+/**
+ * ### TextRank: Rank Sentences by Centrality to Shared Keyphrases
+ *
+ * Builds a weighted undirected graph where each node is a sentence and edges
+ * connect sentences that share keyphrases. Sentence importance is estimated by
+ * a random-walk simulation (analogous to PageRank): nodes visited more often
+ * during the walk are considered more central to the document's key concepts.
+ *
+ * **Key optimisations vs. na\u00efve implementation:**
+ * - Weighted sampling via a single O(degree) scan instead of an O(weight) array.
+ * - `Set`-based keyphrase intersection (O(1) lookup) instead of `Array.includes`.
+ * - `Map<text, index>` for O(1) weight increment instead of O(n) linear scan.
+ * - Flat `Map<string, Map<string, number>>` graph \u2014 no object-method overhead.
+ * - Periodic forced reset prevents the walk from getting stuck in dense clusters.
+ *
+ * **References:**
+ * 1. Zhao & Xie (2021) \u2014 "An Improved TextRank Multi-feature Fusion Algorithm"
+ *    https://iopscience.iop.org/article/10.1088/1742-6596/2078/1/012021/pdf
+ * 2. Pan et al. (2019) \u2014 "An improved TextRank keywords extraction algorithm"
+ *    https://dl.acm.org/doi/10.1145/3321408.3326659
+ *
+ * @param sentencesWithKeyphrases - Sentences with pre-attached keyphrase lists.
+ * @param options - Walk parameters.
+ * @returns The same array with `weight` set on each sentence, or `undefined`
+ *          if no edges exist (no shared keyphrases between any pair).
+ */
+export declare function rankSentencesCentralToKeyphrase(sentencesWithKeyphrases: SentenceEntry[], options?: RankOptions): SentenceEntry[] | undefined;

package/dist/seektopic/seektopic-keyphrases.d.ts

@@ -0,0 +1,53 @@
+import { KeyphraseEntry, SEEKTOPICOptions, SEEKTOPICResult } from './types';
+/**
+ * ### SEEKTOPIC \u2014 Keyphrase & Sentence Extraction
+ *
+ * Pulls the most important phrases and sentences out of any document.
+ * Given raw text, it returns a ranked list of key concepts (e.g. "neural
+ * network", "climate change") and, optionally, the sentences that best
+ * summarise the document around those concepts.
+ *
+ * <img src="https://i.imgur.com/gZ4kI1V.png" width="360px" />
+ *
+ * **How it works \u2014 8-step pipeline:**
+ *
+ * 1. **Clean** \u2014 strip HTML tags and entities.
+ * 2. **Split** \u2014 break text into sentences, respecting abbreviations and URLs.
+ * 3. **Topic Extraction** *(LLM Path)* \u2014 sends the first 5000 words to an LLM
+ *    to extract the most descriptive key topic phrases labeling the document.
+ * 4. **Vector Search** *(LLM Path)* \u2014 calculates cosine similarity embeddings
+ *    for all sentences vs topic phrases, finding the top relevant sentences per topic.
+ * 5. **Tokenise & Extract** *(Fallback)* \u2014 if LLM fails, identify noun-anchored
+ *    n-grams (1-N words).
+ * 6. **Score & Fold** *(Fallback)* \u2014 weight phrases and merge subsumed phrases.
+ * 7. **Re-weight** *(Fallback)* \u2014 boost Wikipedia entities and rare domain terms.
+ * 8. **TextRank** *(Fallback)* \u2014 build sentence similarity graph and run random walk.
+ *
+ * <video src="https://github.com/user-attachments/assets/73348d63-7671-4e20-8df9-29a13d5b0768"
+ *  width="550px" controls />
+ *
+ * @param docText - Plain text or HTML document to analyse.
+ * @param options - Optional tuning parameters (word limits, thresholds, query bias).
+ * @returns
+ *   - `optionSkipRanking: true` (default) \u2192 `KeyphraseEntry[]` sorted by weight.
+ *   - `optionSkipRanking: false` \u2192 `SEEKTOPICResult` with `topSentences`,
+ *     `keyphrases`, and the full `sentences` array.
+ *
+ * @example
+ * // Fast: just extract keyphrases
+ * const keyphrases = extractSEEKTOPIC(articleText, { phrasesModel });
+ * // \u2192 [{ keyphrase: "machine learning", weight: 84 }, ...]
+ *
+ * @example
+ * // Full: keyphrases + summary sentences, biased toward a search query
+ * const { topSentences, keyphrases } = extractSEEKTOPIC(articleText, {
+ *   phrasesModel,
+ *   optionSkipRanking: false,
+ *   heavyWeightQuery: "transformer attention",
+ *   limitTopSentences: 5,
+ * }) as SEEKTOPICResult;
+ *
+ * @author [ai-research-agent (2024)](https://airesearch.js.org)
+ * @category Topics
+ */
+export declare function extractSEEKTOPIC(docText: string, options?: SEEKTOPICOptions): Promise<KeyphraseEntry[] | SEEKTOPICResult>;

package/dist/seektopic/types.d.ts

@@ -0,0 +1,86 @@
+import { TopicToken, PhrasesModel } from '../tokenize/text-to-topic-tokens';
+export type { TopicToken, PhrasesModel };
+/** Map from n-gram size \u2192 { phrase text \u2192 sentence indices } */
+export type NgramMap = Record<number, Record<string, number[]>>;
+/**
+ * A ranked keyphrase with its scoring metadata and the sentence indices it appears in.
+ */
+export interface KeyphraseEntry {
+    /** The keyphrase text */
+    keyphrase: string;
+    /** Indices of sentences containing this keyphrase (or comma-separated string form) */
+    sentences: number[] | string;
+    /** Sentences representing this keyphrase directly with their relevance similarity */
+    topSentences?: Array<{
+        text: string;
+        similarity: number;
+    }>;
+    /** Number of words in the keyphrase */
+    words: number;
+    /** Composite ranking weight */
+    weight: number;
+    /** True if the phrase is a Wikipedia-linked entity */
+    wiki?: boolean;
+}
+/**
+ * A sentence node used during graph construction and TextRank scoring.
+ */
+export interface SentenceEntry {
+    text: string;
+    index: number;
+    keyphrases: Array<{
+        keyphrase: string;
+        weight: number;
+    }>;
+    weight: number;
+}
+/**
+ * A sentence in the final SEEKTOPIC output \u2014 keyphrases are resolved to strings.
+ */
+export interface SentenceResult {
+    text: string;
+    index: number;
+    keyphrases: string[];
+    weight: number;
+}
+/** Options for {@link extractSEEKTOPIC} */
+export interface SEEKTOPICOptions {
+    /** Trie phrases model for wiki-phrase tokenization */
+    phrasesModel?: PhrasesModel;
+    /** Maximum words per keyphrase (default 2) */
+    maxWords?: number;
+    /** Minimum words per keyphrase (default 1) */
+    minWords?: number;
+    /** Minimum character length of any word in a keyphrase (default 3) */
+    minWordLength?: number;
+    /** Fraction of all keyphrases to use as the TextRank graph limit (default 0.5) */
+    topKeyphrasesPercent?: number;
+    /** Max sentences to return in full-ranking mode (default 5) */
+    limitTopSentences?: number;
+    /** Max keyphrases to return (default 10) */
+    limitTopKeyphrases?: number;
+    /** Minimum character length of the full keyphrase string (default 5) */
+    minKeyPhraseLength?: number;
+    /** Query string to bias keyphrase weights toward (default "") */
+    heavyWeightQuery?: string;
+    /** Strip HTML tags before processing (default true) */
+    removeHTML?: boolean;
+    /** Return only keyphrases without running TextRank (default true) */
+    optionSkipRanking?: boolean;
+    getEnv?: (key: string) => string | undefined;
+}
+/** Full SEEKTOPIC output when `optionSkipRanking` is false */
+export interface SEEKTOPICResult {
+    topSentences: SentenceResult[];
+    keyphrases: Array<Omit<KeyphraseEntry, "sentences"> & {
+        sentences: string;
+    }>;
+    sentences: string[];
+}
+/** Options for {@link rankSentencesCentralToKeyphrase} */
+export interface RankOptions {
+    /** Number of random-walk steps (default 1000) */
+    iterations?: number;
+    /** Steps between forced random resets to avoid cluster traps (default 100) */
+    resetInterval?: number;
+}

package/dist/seektopic/vector-search.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Text embeddings convert words or phrases into numerical vectors in a high-dimensional
+ * space, where each dimension represents a semantic feature extracted by a model like
+ * MiniLM-L6-v2. In this concept space, words with similar meanings have vectors that
+ * are close together, allowing for quantitative comparisons of semantic similarity.
+ * These vector representations enable powerful applications in natural language processing,
+ * including semantic search, text classification, and clustering, by leveraging the
+ * geometric properties of the embedding space to capture and analyze the relationships
+ * between words and concepts.
+ * [Text Embeddings, Classification, and Semantic Search
+ *  (Youtube)](https://www.youtube.com/watch?v=sNa_uiqSlJo&t=129s)
+ *
+ * <img src="https://i.imgur.com/wtJqEqX.png" width="350" />
+ * @param {string} text - The text to embed.
+ * @param {Object} [options]
+ * @param {AutoTokenizer} options.pipeline
+ *  - The pipeline to use for embedding.
+ * @param {number} options.precision default=4 - The number of decimal places to round to.
+ * @returns {Promise<{embeddingsDict: Object.<string, number[]>, embedding: number[]}>}
+ * @category Similarity
+ */
+export declare function convertTextToEmbedding(text: string | string[], options?: any): Promise<any>;
+/**
+ * Calculate the semantic similarity between one text and a list of
+ * other sentences by comparing their embeddings.
+ * https://huggingface.co/docs/api-inference/detailed_parameters#sentence-similarity-task
+ *
+ * <img src="https://i.imgur.com/ex2UWnu.png" width="350px" />
+ * @param {string} source_sentence The string that you wish to
+ * compare the other strings with. This can be a phrase, sentence,
+ * or longer passage, depending on the model being used.
+ * @param {Array<string>} sentences A list of strings which will be compared
+ * against the source_sentence.
+ * @param {Object} [options]
+ * @param {string} options.model default="sentence-transformers/all-MiniLM-L6-v2"
+ * @param {string} options.HF_API_KEY Required https://huggingface.co/settings/tokens
+ * @returns array of 0-1 similarity scores for each sentence
+ * @category Similarity
+ */
+export declare function weighRelevanceConceptVectorAPI(source_sentence: any, sentences: any, options?: {}): Promise<string | {
+    error: string;
+}>;
+/**
+ * Initialize HuggingFace Transformers pipeline for embedding text.
+ *
+ * <img src="https://i.imgur.com/3R5Tsrf.png" width="350px" />
+ * @param {Object} [options]
+ * @param {string} options.pipelineName default "feature-extraction",
+ * @param {string} options.modelName default="Xenova/all-MiniLM-L6-v2" -
+ * The name of the model to use
+ * @returns {Promise<import("@huggingface/transformers").AutoTokenizer>} The pipeline.
+ * @category Similarity
+ */
+export declare function getEmbeddingModel(options?: any): Promise<any>;
+/**
+ * [Cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity) gets similarity of two
+ * vectors by whether they have the same direction (similar) or are poles apart. Cosine similarity
+ * is often used with text representations to compare how similar two documents or sentences
+ * are to each other. The output of cosine similarity ranges from -1 to 1, where -1 means the
+ * two vectors are completely dissimilar, and 1 indicates maximum similarity.
+ * @param {Array<number>} vectorA
+ * @param {Array<number>} vectorB
+ * @returns {number} -1 to 1 similarity score
+ */
+export declare function calculateCosineSimilarity(vectorA: any, vectorB: any): number;
+/**
+ * Rerank documents's chunks based on relevance to query,
+ * based on cosine similarity of their concept vectors generated
+ * by a 20MB MiniLM transformer model downloaded locally.
+ *
+ * [A Complete Overview of Word Embeddings](https://www.youtube.com/watch?v=5MaWmXwxFNQ&t=323s)
+ * @param {Array<string>} documents
+ * @param {string} query
+ * @param {Object} [options]
+ * @returns {Promise<Array<{content: string, similarity: number}>>}
+ * @category Similarity
+ */
+export declare function weighRelevanceConceptVector(documents: any, query: any, options?: {}): Promise<any>;
+/**
+ * Rerank documents's chunks based on relevance to multiple queries,
+ * optimizing by embedding documents only once.
+ *
+ * @param {Array<string>} documents
+ * @param {Array<string>} queries
+ * @param {Object} [options]
+ * @returns {Promise<Object<string, Array<{content: string, similarity: number}>>>}
+ * @category Similarity
+ */
+export declare function weighRelevanceConceptVectorMultiple(documents: any, queries: any, options?: {}): Promise<{}>;

package/dist/seektopic/weight-keyphrases.d.ts

@@ -0,0 +1,22 @@
+import { KeyphraseEntry, PhrasesModel } from './types';
+/**
+ * Applies two weighting passes to a keyphrase list:
+ *
+ * 1. **Wiki-entity bonus** \u2014 if any token in the phrase is a Wikipedia-linked
+ *    entity (POS tag 5), the keyphrase weight is doubled and `wiki` is set.
+ * 2. **IDF domain-specificity** \u2014 weight is multiplied by the average POS
+ *    uniqueness score across the phrase's tokens. Rare, domain-specific terms
+ *    (high uniqueness) receive a larger multiplier than common nouns.
+ * 3. **Heavy-query bias** (optional) \u2014 if `heavyWeightQuery` is set, keyphrases
+ *    that closely match the query words receive a large additive bonus, allowing
+ *    dynamic re-ranking when a user clicks a term or arrives via a search query.
+ *
+ * @param keyphrases - Keyphrases to weight; mutated in-place for efficiency.
+ * @param phrasesModel - Trie model passed to the tokenizer (may be undefined).
+ * @param heavyWeightQuery - Space-separated query string to bias ranking toward.
+ * @returns The same array with updated `weight` and `wiki` fields.
+ *
+ * @example
+ * const weighted = weightKeyphrasesBySpecificity(keyphrases, model, "self attention");
+ */
+export declare function weightKeyphrasesBySpecificity(keyphrases: KeyphraseEntry[], phrasesModel: PhrasesModel | undefined, heavyWeightQuery: string): KeyphraseEntry[];

package/dist/suggest-next-words/autocomplete-search-engines.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Provides search query autocomplete/suggestions from various search engines.
+ */
+/**
+ * Autocomplete function type
+ */
+type AutocompleteFunction = (query: string, locale?: string) => Promise<string[]>;
+/**
+ * Baidu autocomplete
+ */
+export declare function baidu(query: string, _locale?: string): Promise<string[]>;
+/**
+ * Brave autocomplete
+ */
+export declare function brave(query: string, _locale?: string): Promise<string[]>;
+/**
+ * DuckDuckGo autocomplete
+ */
+export declare function duckduckgo(query: string, locale?: string): Promise<string[]>;
+/**
+ * Google autocomplete
+ */
+export declare function google(query: string, locale?: string): Promise<string[]>;
+/**
+ * Qwant autocomplete
+ */
+export declare function qwant(query: string, locale?: string): Promise<string[]>;
+/**
+ * Startpage autocomplete
+ */
+export declare function startpage(query: string, locale?: string): Promise<string[]>;
+/**
+ * Wikipedia autocomplete
+ */
+export declare function wikipedia(query: string, locale?: string): Promise<string[]>;
+/**
+ * Yandex autocomplete
+ */
+export declare function yandex(query: string, _locale?: string): Promise<string[]>;
+/**
+ * Available autocomplete backends
+ */
+export declare const backends: {
+    [key: string]: AutocompleteFunction;
+};
+/**
+ * Get autocomplete suggestions from a specific backend
+ *
+ * @param backendName - Name of the autocomplete backend
+ * @param query - Search query
+ * @param locale - Locale/language code (e.g., 'en-US', 'de-DE')
+ * @returns Array of suggestion strings
+ */
+export declare function searchAutocomplete(backendName: string, query: string, locale?: string): Promise<string[]>;
+/**
+ * Get autocomplete suggestions from multiple backends and merge them
+ *
+ * @param backendNames - Array of backend names to query
+ * @param query - Search query
+ * @param locale - Locale/language code
+ * @returns Merged and deduplicated array of suggestions
+ */
+export declare function searchAutocompleteMulti(backendNames: string[], query: string, locale?: string): Promise<string[]>;
+export {};

package/dist/tokenize/suggest-complete-word.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Utility for suggesting word and phrase completions based on a trie model.
+ * Used for search autocomplete and real-time query suggestions.
+ */
+export interface SuggestCompletionsOptions {
+    phrasesModel: Record<string, Record<string, Array<[string | null, number, number]>>>;
+    limitMaxResults?: number;
+    numberOfLastWordsToCheck?: number;
+    optionShowFullQuery?: boolean;
+}
+export interface SuggestionResult {
+    name?: string;
+    word?: string;
+    phrase?: string;
+}
+/**
+ * ### Autocomplete Topic Phrase Completions
+ * <img width="350px"  src="https://i.imgur.com/0k5mO76.png" />
+ *
+ * Completes the query with the most likely next words for phrases.
+ * If typing 2+ letters of a word, returns all possible words matching those few letters.
+ *
+ *
+ * @param {string} query - The input query which can be pertial words or phrases.
+ * @param {Object} [options]
+ * @param {Object} options.phrasesModel - A custom phrases model to use for autocomplete suggestions.
+ * @param {number} options.limitMaxResults default=10 - The maximum number of autocomplete suggestions to return.
+ * @param {number} options.numberOfLastWordsToCheck default=5 - The number of last words in the query to check for phrase completions.
+ * @returns {Promise<Array<Object>>} An array of autocomplete suggestions, each containing either a 'phrase' or 'word' property.
+ * @example
+ * // Basic usage
+ * const suggestions = await suggestNextWordCompletions("self att");
+ * // Possible output: [{ phrase: "self attention" }, { phrase: "self attract" }, { phrase: "self attack" }]
+ *
+ * @example
+ * // Using options
+ * const customModel = await import("./custom-phrases-model.json");
+ * const suggestions = await suggestNextWordCompletions("artificial int", {
+ *   phrasesModel: customModel,
+ *   limitMaxResults: 5,
+ *   numberOfLastWordsToCheck: 3
+ * });
+ * // Possible output: [{ phrase: "artificial intelligence" }, { phrase: "artificial interpretation" }]
+ *
+ * @author [vtempest (2025)](https://github.com/vtempest)
+ * @category Topics
+ */
+export declare function suggestNextWordCompletions(query: string, options?: Partial<SuggestCompletionsOptions>): Promise<SuggestionResult[] | undefined>;