nosible 0.1.5

package/dist/index.cjs

@@ -0,0 +1,1841 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  Search: () => Search,
+  NosibleClient: () => NosibleClient
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/search/sqlFilter.ts
+var import_zod = __toESM(require("zod"));
+var sqlFilterSchema = import_zod.default.object({
+  publishStart: import_zod.default.date().optional(),
+  publishEnd: import_zod.default.date().optional(),
+  visitedStart: import_zod.default.date().optional(),
+  visitedEnd: import_zod.default.date().optional(),
+  certain: import_zod.default.boolean().optional(),
+  includeNetlocs: import_zod.default.array(import_zod.default.string()).max(50).optional(),
+  excludeNetlocs: import_zod.default.array(import_zod.default.string()).max(50).optional(),
+  includeCompanies: import_zod.default.array(import_zod.default.string()).max(50).optional(),
+  excludeCompanies: import_zod.default.array(import_zod.default.string()).max(50).optional(),
+  includeDocs: import_zod.default.array(import_zod.default.string()).max(50).optional(),
+  excludeDocs: import_zod.default.array(import_zod.default.string()).max(50).optional()
+});
+function generateSqlFilter(input) {
+  const validatedInput = sqlFilterSchema.parse(input);
+  const {
+    publishStart,
+    publishEnd,
+    visitedStart,
+    visitedEnd,
+    certain,
+    includeNetlocs,
+    excludeNetlocs,
+    includeCompanies,
+    excludeCompanies,
+    includeDocs,
+    excludeDocs
+  } = validatedInput;
+  const sql = ["SELECT loc FROM engine"];
+  const clauses = [];
+  if (publishStart || publishEnd) {
+    if (publishStart && publishEnd) {
+      clauses.push(`published >= '${publishStart.toISOString()}' AND published <= '${publishEnd.toISOString()}'`);
+    } else if (publishStart) {
+      clauses.push(`published >= '${publishStart.toISOString()}'`);
+    } else if (publishEnd) {
+      clauses.push(`published <= '${publishEnd.toISOString()}'`);
+    }
+  }
+  if (visitedStart || visitedEnd) {
+    if (visitedStart && visitedEnd) {
+      clauses.push(`visited >= '${visitedStart.toISOString()}' AND visited <= '${visitedEnd.toISOString()}'`);
+    } else if (visitedStart) {
+      clauses.push(`visited >= '${visitedStart.toISOString()}'`);
+    } else if (visitedEnd) {
+      clauses.push(`visited <= '${visitedEnd.toISOString()}'`);
+    }
+  }
+  if (certain === true) {
+    clauses.push("certain = TRUE");
+  } else if (certain === false) {
+    clauses.push("certain = FALSE");
+  }
+  if (includeNetlocs) {
+    const variants = new Set;
+    for (const n of includeNetlocs) {
+      variants.add(n);
+      if (n.startsWith("www.")) {
+        variants.add(n.slice(4));
+      } else {
+        variants.add("www." + n);
+      }
+    }
+    const inList = Array.from(variants).sort().map((v) => `'${v}'`).join(", ");
+    clauses.push(`netloc IN (${inList})`);
+  }
+  if (excludeNetlocs) {
+    const variants = new Set;
+    for (const n of excludeNetlocs) {
+      variants.add(n);
+      if (n.startsWith("www.")) {
+        variants.add(n.slice(4));
+      } else {
+        variants.add("www." + n);
+      }
+    }
+    const exList = Array.from(variants).sort().map((v) => `'${v}'`).join(", ");
+    clauses.push(`netloc NOT IN (${exList})`);
+  }
+  if (includeCompanies) {
+    const companyList = includeCompanies.map((c) => `ARRAY_CONTAINS(companies, '${c}')`).join(" OR ");
+    clauses.push(`(companies IS NOT NULL AND (${companyList}))`);
+  }
+  if (excludeCompanies) {
+    const companyList = excludeCompanies.map((c) => `ARRAY_CONTAINS(companies, '${c}')`).join(" OR ");
+    clauses.push(`(companies IS NULL OR NOT (${companyList}))`);
+  }
+  if (includeDocs) {
+    const docHashes = includeDocs.map((doc) => `'${doc}'`).join(", ");
+    clauses.push(`doc_hash IN (${docHashes})`);
+  }
+  if (excludeDocs) {
+    const docHashes = excludeDocs.map((doc) => `'${doc}'`).join(", ");
+    clauses.push(`doc_hash NOT IN (${docHashes})`);
+  }
+  if (clauses.length > 0) {
+    sql.push("WHERE " + clauses.join(" AND "));
+  }
+  if (sql.length === 1) {
+    return null;
+  }
+  const sqlFilter = sql.join(" ");
+  return sqlFilter;
+}
+
+// src/search/search.ts
+var import_zod5 = require("zod");
+
+// src/api/schemas.ts
+var import_zod3 = __toESM(require("zod"));
+
+// src/scrape/types.ts
+var import_zod2 = require("zod");
+var snippetStatisticsSchema = import_zod2.z.object({
+  sentences: import_zod2.z.number(),
+  words: import_zod2.z.number(),
+  characters: import_zod2.z.number(),
+  links: import_zod2.z.number().optional(),
+  images: import_zod2.z.number().optional()
+});
+var snippetSchema = import_zod2.z.object({
+  url_hash: import_zod2.z.string(),
+  snippet_hash: import_zod2.z.string(),
+  prev_snippet_hash: import_zod2.z.string().nullable(),
+  next_snippet_hash: import_zod2.z.string().nullable(),
+  content: import_zod2.z.string(),
+  words: import_zod2.z.string().optional(),
+  language: import_zod2.z.string(),
+  statistics: snippetStatisticsSchema.optional(),
+  links: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+  images: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var scrapeStatisticsSchema = import_zod2.z.object({
+  snippets: import_zod2.z.number(),
+  sentences: import_zod2.z.number(),
+  words: import_zod2.z.number(),
+  characters: import_zod2.z.number(),
+  images: import_zod2.z.number(),
+  videos: import_zod2.z.number(),
+  audio: import_zod2.z.number(),
+  tables: import_zod2.z.number(),
+  lists: import_zod2.z.number(),
+  blocks: import_zod2.z.number(),
+  links: import_zod2.z.number(),
+  files: import_zod2.z.number()
+});
+var scrapePageSchema = import_zod2.z.object({
+  title: import_zod2.z.string(),
+  description: import_zod2.z.string(),
+  author: import_zod2.z.string(),
+  published: import_zod2.z.coerce.date(),
+  visited: import_zod2.z.coerce.date(),
+  certain: import_zod2.z.boolean().optional()
+});
+var querySchema = import_zod2.z.object({});
+var scrapeRequestSchema = import_zod2.z.object({
+  raw_url: import_zod2.z.string(),
+  url: import_zod2.z.string(),
+  hash: import_zod2.z.string(),
+  geo: import_zod2.z.string(),
+  proxy: import_zod2.z.string(),
+  scheme: import_zod2.z.string(),
+  netloc: import_zod2.z.string(),
+  prefix: import_zod2.z.string(),
+  domain: import_zod2.z.string(),
+  suffix: import_zod2.z.string(),
+  path: import_zod2.z.string(),
+  query: import_zod2.z.string(),
+  fragment: import_zod2.z.string(),
+  query_allowed: querySchema,
+  query_blocked: querySchema
+});
+var metadataSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any());
+var logoSchema = import_zod2.z.object({
+  "@type": import_zod2.z.string().optional(),
+  "@id": import_zod2.z.string().optional(),
+  caption: import_zod2.z.string().optional(),
+  inLanguage: import_zod2.z.string().optional(),
+  url: import_zod2.z.string(),
+  width: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  height: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional()
+});
+var publisherSchema = import_zod2.z.object({
+  "@type": import_zod2.z.string(),
+  name: import_zod2.z.string().optional(),
+  url: import_zod2.z.string().optional(),
+  logo: import_zod2.z.union([logoSchema, import_zod2.z.string()]).optional(),
+  sameAs: import_zod2.z.union([import_zod2.z.array(import_zod2.z.string()), import_zod2.z.string()]).optional()
+});
+var structuredSchema = import_zod2.z.object({
+  "@context": import_zod2.z.string().optional(),
+  "@type": import_zod2.z.string().optional(),
+  headline: import_zod2.z.string().optional(),
+  publisher: publisherSchema.optional()
+});
+var urlTreeSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.any());
+var scrapeResponseSchema = import_zod2.z.object({
+  request: scrapeRequestSchema,
+  page: scrapePageSchema,
+  statistics: scrapeStatisticsSchema,
+  languages: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.number()),
+  snippets: import_zod2.z.record(import_zod2.z.string(), snippetSchema),
+  full_text: import_zod2.z.string(),
+  metadata: metadataSchema,
+  structured: import_zod2.z.array(structuredSchema),
+  url_tree: urlTreeSchema
+});
+var scrapeFullResSchema = import_zod2.z.object({
+  message: import_zod2.z.string(),
+  added_to_batch: import_zod2.z.boolean(),
+  response: scrapeResponseSchema
+});
+
+// src/api/schemas.ts
+var queryTypeEnum = import_zod3.default.enum(["fast-search", "search", "bulk-search"]);
+var algorithmEnum = import_zod3.default.enum([
+  "string",
+  "lexical",
+  "baseline",
+  "hamming",
+  "hybrid-1",
+  "hybrid-2",
+  "hybrid-3",
+  "company"
+]);
+var brandSafetyEnum = import_zod3.default.enum(["safe", "sensitive", "unsafe"]);
+var continentEnum = import_zod3.default.enum([
+  "Africa",
+  "Asia",
+  "Europe",
+  "North America",
+  "Oceania",
+  "South America",
+  "Worldwide"
+]);
+var regionEnum = import_zod3.default.enum([
+  "Caribbean",
+  "Central Africa",
+  "Central America",
+  "Central Asia",
+  "Central Europe",
+  "East Africa",
+  "East Asia",
+  "Eastern Europe",
+  "Middle East",
+  "North Africa",
+  "North America",
+  "Northern Europe",
+  "Oceania",
+  "South America",
+  "South Asia",
+  "Southeast Asia",
+  "Southern Africa",
+  "Southern Europe",
+  "Sub-Saharan Africa",
+  "The Amazon Basin",
+  "The Andes",
+  "The Arctic Region",
+  "The Balkans",
+  "The Caucasus",
+  "The Horn of Africa",
+  "The Levant",
+  "The Middle East",
+  "The Sahel",
+  "West Africa",
+  "Western Europe",
+  "Worldwide"
+]);
+var searchQuerySchema = import_zod3.default.object({
+  instruction: import_zod3.default.string(),
+  question: import_zod3.default.string(),
+  expansions: import_zod3.default.array(import_zod3.default.string()),
+  brand_safety: import_zod3.default.null(),
+  language: import_zod3.default.string().nullable(),
+  continent: import_zod3.default.string().nullable(),
+  region: import_zod3.default.string().nullable(),
+  country: import_zod3.default.string().nullable(),
+  sector: import_zod3.default.string().nullable(),
+  industry_group: import_zod3.default.string().nullable(),
+  industry: import_zod3.default.string().nullable(),
+  sub_industry: import_zod3.default.string().nullable(),
+  iab_tier_1: import_zod3.default.string().nullable(),
+  iab_tier_2: import_zod3.default.string().nullable(),
+  iab_tier_3: import_zod3.default.string().nullable(),
+  iab_tier_4: import_zod3.default.string().nullable(),
+  algorithm: import_zod3.default.string(),
+  n_results: import_zod3.default.number(),
+  n_contextify: import_zod3.default.number(),
+  n_probes: import_zod3.default.number(),
+  min_similarity: import_zod3.default.number(),
+  pass_similarity: import_zod3.default.number(),
+  must_exclude: import_zod3.default.array(import_zod3.default.string()),
+  must_include: import_zod3.default.array(import_zod3.default.string()),
+  shard_selector: import_zod3.default.string(),
+  shard_reranker: import_zod3.default.string(),
+  search_lang: import_zod3.default.string(),
+  search_words: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.number()),
+  search_intents: import_zod3.default.record(import_zod3.default.string(), import_zod3.default.any()),
+  companies: import_zod3.default.array(import_zod3.default.any())
+});
+var searchResultSemanticsSchema = import_zod3.default.object({
+  origin_shard: import_zod3.default.number(),
+  chunks_total: import_zod3.default.number(),
+  chunks_matched: import_zod3.default.number(),
+  chunks_kept: import_zod3.default.number(),
+  similarity: import_zod3.default.number(),
+  bitstring: import_zod3.default.string()
+});
+var searchResponseSchema = import_zod3.default.object({
+  url_hash: import_zod3.default.string(),
+  url: import_zod3.default.string(),
+  netloc: import_zod3.default.string(),
+  published: import_zod3.default.string(),
+  visited: import_zod3.default.string(),
+  language: import_zod3.default.string(),
+  author: import_zod3.default.string(),
+  title: import_zod3.default.string(),
+  description: import_zod3.default.string(),
+  content: import_zod3.default.string(),
+  best_chunk: import_zod3.default.string(),
+  semantics: searchResultSemanticsSchema
+});
+var bulkResSchema = import_zod3.default.object({
+  message: import_zod3.default.string(),
+  decrypt_using: import_zod3.default.string(),
+  download_from: import_zod3.default.string()
+});
+
+// src/utils/llm.ts
+var defaultModel = "google/gemini-2.0-flash-001";
+var getSentiment = async ({
+  text,
+  model = defaultModel,
+  llmClient
+}) => {
+  if (!llmClient) {
+    throw new Error("A OpenAI client instance must be provided as 'llmClient'.");
+  }
+  if (!text || text.trim() === "") {
+    throw new Error("Text must not be empty or whitespace.");
+  }
+  const prompt = `
+    # TASK DESCRIPTION
+    On a scale from -1.0 (very negative) to 1.0 (very positive),
+    please rate the sentiment of the following text and return _only_ the numeric score:
+    ${text.trim()}
+
+    # RESPONSE FORMAT
+
+    The response must be a float in [-1.0, 1.0]. No other text must be returned.
+  `;
+  try {
+    const completion = await llmClient.chat.completions.create({
+      model,
+      messages: [{ role: "user", content: prompt.trim() }],
+      temperature: 0.7
+    });
+    const raw = completion.choices[0]?.message?.content;
+    const score = parseFloat(raw);
+    if (Number.isNaN(score)) {
+      throw new Error(`Sentiment response is not a float: ${JSON.stringify(raw)}`);
+    }
+    if (score < -1 || score > 1) {
+      throw new Error(`Sentiment ${score} outside valid range [-1.0, 1.0]`);
+    }
+    return score;
+  } catch (error) {
+    throw error;
+  }
+};
+var generateExpansions = async ({
+  question,
+  model = defaultModel,
+  llmClient
+}) => {
+  if (!llmClient) {
+    throw new Error("A OpenAI client instance must be provided as 'llmClient'.");
+  }
+  if (!question || question.trim() === "") {
+    throw new Error("Question must not be empty or whitespace.");
+  }
+  const prompt = `
+            # TASK DESCRIPTION
+
+
+            Given a search question you must generate a list of 10 similar questions that have the same exact
+            semantic meaning but are contextually and lexically different to improve search recall.
+
+
+            ## Question
+
+            Here is the question you must generate expansions for:
+
+            Question: ${question.trim()}
+
+            # RESPONSE FORMAT
+
+            Your response must be a JSON object structured as follows: a list of ten strings. Each string must
+            be a grammatically correct question that expands on the original question to improve recall.
+
+            [
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string
+            ]
+
+            # EXPANSION GUIDELINES
+
+            1. **Use specific named entities** - To improve the quality of your search results you must mention
+               specific named entities (people, locations, organizations, products, places) in expansions.
+            2. **Expansions must be highly targeted** - To improve the quality of search results each expansion
+               must be semantically unambiguous. Questions must be use between ten and fifteen words.
+            3. **Expansions must improve recall** - When expanding the question leverage semantic and contextual
+               expansion to maximize the ability of the search engine to find semantically relevant documents:
+               - Semantic Example: Swap "climate change" with "global warming" or "environmental change".
+               - Contextual Example: Swap "diabetes treatment" with "insulin therapy" or "blood sugar management".
+  `;
+  try {
+    const completion = await llmClient.chat.completions.create({
+      model,
+      messages: [{ role: "user", content: prompt.trim() }],
+      temperature: 0.7
+    });
+    let raw = completion.choices[0]?.message?.content ?? "";
+    let toParse = raw.trim();
+    if (toParse.startsWith("```")) {
+      toParse = toParse.replace(/^```+/, "").trim();
+      if (toParse.toLowerCase().startsWith("json")) {
+        toParse = toParse.slice(4).trim();
+      }
+      toParse = toParse.replace(/```+$/, "").trim();
+    }
+    let expansions;
+    try {
+      expansions = JSON.parse(toParse);
+    } catch (decodeErr) {
+      throw new Error(`OpenRouter response was not valid JSON: '${toParse}'`);
+    }
+    if (!Array.isArray(expansions) || expansions.length !== 10 || !expansions.every((q) => typeof q === "string")) {
+      throw new Error("Invalid response: 'choices' missing or empty");
+    }
+    console.debug("Expansions: ", expansions);
+    return expansions;
+  } catch (error) {
+    throw error;
+  }
+};
+
+// src/api/index.ts
+var import_zod4 = require("zod");
+var fastNResults = import_zod4.z.number().min(10).max(100).optional().default(100);
+var searchNResults = import_zod4.z.number().min(100).max(1000).optional().default(100);
+var bulkNResults = import_zod4.z.number().min(1000).max(1e4).optional().default(1000);
+var aiSearchParamsSchema = import_zod4.z.object({
+  prompt: import_zod4.z.string().min(25).max(2500),
+  agent: import_zod4.z.string().optional()
+});
+var stdSearchParams = import_zod4.z.object({
+  question: import_zod4.z.string(),
+  expansions: import_zod4.z.array(import_zod4.z.string()).optional(),
+  sql_filter: import_zod4.z.string().optional(),
+  algorithm: algorithmEnum.optional(),
+  n_results: import_zod4.z.number(),
+  n_probes: import_zod4.z.number().min(1).max(10).optional(),
+  n_contextify: import_zod4.z.number().min(64).max(1024).optional(),
+  min_similarity: import_zod4.z.number().min(0).max(1).optional(),
+  must_include: import_zod4.z.array(import_zod4.z.string()).max(100).optional(),
+  must_exclude: import_zod4.z.array(import_zod4.z.string()).max(100).optional(),
+  brand_safety: brandSafetyEnum.optional(),
+  language: import_zod4.z.string().min(2).max(2).optional(),
+  continent: continentEnum.optional(),
+  region: regionEnum.optional(),
+  country: import_zod4.z.string().optional(),
+  sector: import_zod4.z.string().optional(),
+  industry_group: import_zod4.z.string().optional(),
+  industry: import_zod4.z.string().optional(),
+  sub_industry: import_zod4.z.string().optional(),
+  iab_tier_1: import_zod4.z.string().optional(),
+  iab_tier_2: import_zod4.z.string().optional(),
+  iab_tier_3: import_zod4.z.string().optional(),
+  iab_tier_4: import_zod4.z.string().optional(),
+  companies: import_zod4.z.array(import_zod4.z.string()).max(30).optional()
+});
+var fastSearchParamsSchema = import_zod4.z.object({
+  ...stdSearchParams.shape,
+  n_results: fastNResults
+});
+var bulkSearchParamsSchema = import_zod4.z.object({
+  ...stdSearchParams.shape,
+  n_results: bulkNResults
+});
+var validateFastSearchParams = (params) => {
+  const validatedParams = fastSearchParamsSchema.parse(params);
+  return validatedParams;
+};
+var validateBulkSearchParams = (params) => {
+  const validatedParams = bulkSearchParamsSchema.parse(params);
+  return validatedParams;
+};
+var scapeUrlBody = import_zod4.z.object({
+  url: import_zod4.z.string()
+});
+var topicTrendBody = import_zod4.z.object({
+  query: import_zod4.z.string(),
+  sql_filter: import_zod4.z.string().optional()
+});
+var callNosibleApi = async ({
+  baseUrl = "https://www.nosible.ai/search/v2",
+  endpoint,
+  body,
+  apiKey
+}) => {
+  const response = await fetch(`${baseUrl}/${endpoint}`, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "Api-Key": `${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    console.error("Status: " + response.status);
+    if (response.status === 401) {
+      throw new Error("Your API key is not valid.");
+    }
+    if (response.status === 422) {
+      const contentType = response.headers.get("Content-Type") || "";
+      if (contentType.startsWith("application/json")) {
+        const body2 = await response.json();
+        const errorBody = Array.isArray(body2) ? body2[0] : body2;
+        console.error(errorBody);
+        if (errorBody?.type === "string_too_short") {
+          throw new Error("Your API key is not valid: Too Short.");
+        }
+      }
+      throw new Error("You made a bad request.");
+    }
+    if (response.status === 429) {
+      throw new Error("You have hit your rate limit.");
+    }
+    if (response.status === 409) {
+      throw new Error("Too many concurrent searches.");
+    }
+    if (response.status === 500) {
+      throw new Error("An unexpected error occurred.");
+    }
+    if (response.status === 502) {
+      throw new Error("NOSIBLE is currently restarting.");
+    }
+    if (response.status === 504) {
+      throw new Error("NOSIBLE is currently overloaded.");
+    }
+    console.error(await response.text());
+    throw new Error(`HTTP error! status: ${response.status}`);
+  } else {
+    const data = await response.json();
+    return data;
+  }
+};
+
+// src/search/search.ts
+var userSearchParamsSchema = sqlFilterSchema.extend({
+  question: import_zod5.z.string().optional(),
+  autoGenerateExpansions: import_zod5.z.boolean().optional(),
+  expansions: import_zod5.z.array(import_zod5.z.string()).optional(),
+  sqlFilter: import_zod5.z.string().optional(),
+  algorithm: algorithmEnum.optional(),
+  nResults: import_zod5.z.number().optional(),
+  nProbes: import_zod5.z.number().min(1).max(10).optional(),
+  nContextify: import_zod5.z.number().min(64).max(1024).optional(),
+  minSimilarity: import_zod5.z.number().min(0).max(1).optional(),
+  mustInclude: import_zod5.z.array(import_zod5.z.string()).max(100).optional(),
+  mustExclude: import_zod5.z.array(import_zod5.z.string()).max(100).optional(),
+  brandSafety: brandSafetyEnum.optional(),
+  language: import_zod5.z.string().min(2).max(2).optional(),
+  continent: continentEnum.optional(),
+  region: regionEnum.optional(),
+  country: import_zod5.z.string().optional(),
+  sector: import_zod5.z.string().optional(),
+  industryGroup: import_zod5.z.string().optional(),
+  industry: import_zod5.z.string().optional(),
+  subIndustry: import_zod5.z.string().optional(),
+  iabTier1: import_zod5.z.string().optional(),
+  iabTier2: import_zod5.z.string().optional(),
+  iabTier3: import_zod5.z.string().optional(),
+  iabTier4: import_zod5.z.string().optional(),
+  companies: import_zod5.z.array(import_zod5.z.string()).max(30).optional()
+});
+var clientDefaultSearchParamsSchema = userSearchParamsSchema.omit({
+  question: true
+});
+var similarUserSearchParams = userSearchParamsSchema.omit({
+  question: true
+});
+
+class Search {
+  question;
+  nResults;
+  expansions;
+  autoGenerateExpansions;
+  nProbes;
+  nContextify;
+  algorithm;
+  sqlFilter;
+  minSimilarity;
+  mustInclude;
+  mustExclude;
+  brandSafety;
+  language;
+  continent;
+  region;
+  country;
+  sector;
+  industryGroup;
+  industry;
+  subIndustry;
+  iabTier1;
+  iabTier2;
+  iabTier3;
+  iabTier4;
+  companies;
+  publishStart;
+  publishEnd;
+  visitedStart;
+  visitedEnd;
+  certain;
+  includeNetlocs;
+  excludeNetlocs;
+  includeCompanies;
+  excludeCompanies;
+  includeDocs;
+  excludeDocs;
+  constructor(params) {
+    Object.assign(this, params);
+  }
+  searchBody = async ({
+    client
+  }) => {
+    let expansions = this.expansions;
+    if (this.autoGenerateExpansions) {
+      expansions = await generateExpansions({
+        question: this.question,
+        model: client.expansionsModel,
+        llmClient: client.llmClient
+      });
+    }
+    let sqlFilter = generateSqlFilter({
+      publishStart: this.publishStart || undefined,
+      publishEnd: this.publishEnd || undefined,
+      visitedStart: this.visitedStart || undefined,
+      visitedEnd: this.visitedEnd || undefined,
+      certain: this.certain || undefined,
+      includeNetlocs: this.includeNetlocs || undefined,
+      excludeNetlocs: this.excludeNetlocs || undefined,
+      includeCompanies: this.includeCompanies || undefined,
+      excludeCompanies: this.excludeCompanies || undefined,
+      includeDocs: this.includeDocs || undefined,
+      excludeDocs: this.excludeDocs || undefined
+    });
+    const output = {
+      question: this.question,
+      expansions,
+      sql_filter: sqlFilter || undefined,
+      algorithm: this.algorithm,
+      n_probes: this.nProbes,
+      n_results: this.nResults,
+      n_contextify: this.nContextify,
+      min_similarity: this.minSimilarity,
+      must_include: this.mustInclude,
+      must_exclude: this.mustExclude,
+      brand_safety: this.brandSafety,
+      language: this.language,
+      continent: this.continent,
+      region: this.region,
+      country: this.country,
+      sector: this.sector,
+      industry_group: this.industryGroup,
+      industry: this.industry,
+      sub_industry: this.subIndustry,
+      iab_tier_1: this.iabTier1,
+      iab_tier_2: this.iabTier2,
+      iab_tier_3: this.iabTier3,
+      iab_tier_4: this.iabTier4,
+      companies: this.companies
+    };
+    const outputWithoutUndefined = Object.fromEntries(Object.entries(output).filter(([, value]) => value !== undefined));
+    return outputWithoutUndefined;
+  };
+}
+
+// src/utils/index.ts
+var isBrowser = () => {
+  return typeof window !== "undefined";
+};
+
+// src/utils/browser.ts
+var downloadBlob = (data, mimeType, fileName) => {
+  const blob = new Blob([data], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+};
+
+// src/utils/file.ts
+var import_papaparse = __toESM(require("papaparse"));
+var exportJson = async (data, outputPath) => {
+  try {
+    if (isBrowser()) {
+      const filename = outputPath.split("/").pop() || "export.json";
+      const jsonString = JSON.stringify(data);
+      const finalFilename = filename.endsWith(".json") ? filename : `${filename}.json`;
+      downloadBlob(jsonString, "application/json", finalFilename);
+    } else {
+      const { writeFile } = await import("node:fs/promises");
+      await writeFile(outputPath, JSON.stringify(data));
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to write JSON: ${errorMessage}`);
+  }
+};
+var importJson = async (options) => {
+  try {
+    if ("file" in options) {
+      const text = await options.file.text();
+      return JSON.parse(text);
+    } else {
+      if (isBrowser()) {
+        throw new Error("File path import is not supported in browser. Use {file: File} instead.");
+      }
+      const { readFile } = await import("node:fs/promises");
+      const data = await readFile(options.filePath, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read JSON: ${errorMessage}`);
+  }
+};
+var importCsv = async (options) => {
+  try {
+    let csvText;
+    if ("file" in options) {
+      csvText = await options.file.text();
+    } else {
+      if (isBrowser()) {
+        throw new Error("File path import is not supported in browser. Use {file: File} instead.");
+      }
+      const { readFile } = await import("node:fs/promises");
+      csvText = await readFile(options.filePath, "utf-8");
+    }
+    if (!csvText.trim()) {
+      return [];
+    }
+    const result = import_papaparse.default.parse(csvText, {
+      header: true,
+      skipEmptyLines: true,
+      dynamicTyping: true
+    });
+    const significantErrors = result.errors.filter((error) => !error.message.includes("Unable to auto-detect delimiting character"));
+    if (significantErrors.length > 0) {
+      const errorMessages = significantErrors.map((err) => err.message).join(", ");
+      throw new Error(`CSV parsing errors: ${errorMessages}`);
+    }
+    return result.data;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read CSV: ${errorMessage}`);
+  }
+};
+var exportNdjson = async (data, outputPath) => {
+  try {
+    if (isBrowser()) {
+      const filename = outputPath.split("/").pop() || "export.ndjson";
+      const ndjsonString = data.map((item) => JSON.stringify(item)).join(`
+`);
+      const finalFilename = filename.endsWith(".ndjson") ? filename : `${filename}.ndjson`;
+      downloadBlob(ndjsonString, "application/x-ndjson", finalFilename);
+    } else {
+      const pl = await import("nodejs-polars");
+      const df = pl.DataFrame(data);
+      await df.writeJSON(outputPath, { format: "lines" });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to write NDJSON: ${errorMessage}`);
+  }
+};
+var exportCsv = async (data, outputPath) => {
+  try {
+    if (!Array.isArray(data) || data.length === 0) {
+      throw new Error("Data must be a non-empty array");
+    }
+    if (!outputPath || typeof outputPath !== "string") {
+      throw new Error("Output path must be a non-empty string");
+    }
+    const csvString = import_papaparse.default.unparse(data, {
+      header: true,
+      newline: `
+`
+    });
+    if (isBrowser()) {
+      const filename = outputPath.split("/").pop() || "export.csv";
+      const finalFilename = filename.endsWith(".csv") ? filename : `${filename}.csv`;
+      downloadBlob(csvString, "text/csv", finalFilename);
+    } else {
+      const { writeFile } = await import("node:fs/promises");
+      await writeFile(outputPath, csvString);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to write CSV: ${errorMessage}`);
+  }
+};
+
+// src/scrape/webPageData.ts
+class WebPageData {
+  client;
+  data;
+  snippets;
+  page;
+  fullText;
+  metadata;
+  structured;
+  urlTree;
+  statistics;
+  constructor(client, res) {
+    this.client = client;
+    this.data = res;
+    this.snippets = mapSnippetToArray(res);
+    this.page = this.data.page;
+    this.fullText = this.data.full_text;
+    this.metadata = this.data.metadata;
+    this.structured = this.data.structured;
+    this.urlTree = this.data.url_tree;
+    this.statistics = this.data.statistics;
+  }
+  static async fromJson(client, inputPath) {
+    const data = await importJson({ filePath: inputPath });
+    const validData = scrapeResponseSchema.parse(data);
+    return new WebPageData(client, validData);
+  }
+  async writeJson(outputPath) {
+    return await exportJson(this.data, outputPath);
+  }
+  getSnippets() {
+    return this.snippets;
+  }
+  getSnippet(hashKey) {
+    return this.snippets.find((snippet) => snippet.url_hash === hashKey);
+  }
+}
+var mapSnippetToArray = (data) => {
+  const snippets = [];
+  const snippetKeys = Object.keys(data.snippets);
+  if (snippetKeys.length === 0) {
+    return snippets;
+  }
+  const unsortedSnippets = [];
+  snippetKeys.forEach((key) => {
+    unsortedSnippets.push(data.snippets[key]);
+  });
+  const first = unsortedSnippets.find((snippet) => snippet.prev_snippet_hash === null);
+  if (!first) {
+    throw new Error("No first snippet found");
+  }
+  snippets.push(first);
+  let current = first;
+  while (current.next_snippet_hash) {
+    const next = unsortedSnippets.find((snippet) => snippet.snippet_hash === current.next_snippet_hash);
+    if (!next) {
+      throw new Error("No next snippet found");
+    }
+    snippets.push(next);
+    current = next;
+  }
+  return snippets;
+};
+
+// src/topicTrend/topicTrend.ts
+class TopicTrend {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+  peakDate() {
+    const maxValue = Math.max(...Object.values(this.data.response));
+    const date = Object.keys(this.data.response).find((key) => this.data.response[key] === maxValue || undefined);
+    if (!date) {
+      throw new Error("No peak date found");
+    }
+    return new Date(date);
+  }
+}
+
+// src/utils/userPlan.ts
+var import_bottleneck = __toESM(require("bottleneck"));
+var planLimits = [
+  {
+    key: "test",
+    name: "Test",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 300 },
+      bulk: { minute: 60, month: 300 },
+      fast: { minute: 60, month: 3000 }
+    }
+  },
+  {
+    key: "basic",
+    name: "Basic",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 1400 },
+      bulk: { minute: 60, month: 1400 },
+      fast: { minute: 60, month: 14000 }
+    }
+  },
+  {
+    key: "pro",
+    name: "Pro",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 6700 },
+      bulk: { minute: 60, month: 6700 },
+      fast: { minute: 60, month: 67000 }
+    }
+  },
+  {
+    key: "pro+",
+    name: "Pro+",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 32000 },
+      bulk: { minute: 60, month: 32000 },
+      fast: { minute: 60, month: 320000 }
+    }
+  },
+  {
+    key: "bus",
+    name: "Business",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 200000 },
+      bulk: { minute: 60, month: 200000 },
+      fast: { minute: 60, month: 2000000 }
+    }
+  },
+  {
+    key: "bus+",
+    name: "Business+",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 500000 },
+      bulk: { minute: 60, month: 500000 },
+      fast: { minute: 120, month: 5000000 }
+    }
+  },
+  {
+    key: "ent",
+    name: "Enterprise",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 1500000 },
+      bulk: { minute: 60, month: 1500000 },
+      fast: { minute: 360, month: 15000000 }
+    }
+  },
+  {
+    key: "prod",
+    name: "Production",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 1500000 },
+      bulk: { minute: 60, month: 1500000 },
+      fast: { minute: 360, month: 15000000 }
+    }
+  },
+  {
+    key: "chat",
+    name: "Chat",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 1500000 },
+      bulk: { minute: 60, month: 1500000 },
+      fast: { minute: 360, month: 15000000 }
+    }
+  },
+  {
+    key: "self",
+    name: "Self",
+    rateLimits: {
+      scrapeUrl: { minute: 6000, month: 1500000 },
+      bulk: { minute: 6000, month: 1500000 },
+      fast: { minute: 36000, month: 15000000 }
+    }
+  },
+  {
+    key: "cons",
+    name: "Consumer",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 3000 },
+      bulk: { minute: 60, month: 3000 },
+      fast: { minute: 120, month: 30000 }
+    }
+  },
+  {
+    key: "stup",
+    name: "Startup",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 30000 },
+      bulk: { minute: 60, month: 30000 },
+      fast: { minute: 360, month: 300000 }
+    }
+  },
+  {
+    key: "busn",
+    name: "Business Network",
+    rateLimits: {
+      scrapeUrl: { minute: 60, month: 300000 },
+      bulk: { minute: 60, month: 300000 },
+      fast: { minute: 360, month: 3000000 }
+    }
+  }
+];
+var getUserPlan = (apiKey) => {
+  const planKey = apiKey.split("|")[0];
+  const plan = planLimits.find((p) => p.key === planKey);
+  if (!plan) {
+    throw new Error("Invalid API key");
+  }
+  return plan;
+};
+var minMs = 60 * 1000;
+var monthMs = 60 * 60 * 24 * 30 * 1000;
+var getLimiters = (planKey) => {
+  const plan = getUserPlan(planKey);
+  const scrapeUrlMinLimiter = new import_bottleneck.default({
+    reservoir: plan.rateLimits.scrapeUrl.minute,
+    reservoirRefreshAmount: plan.rateLimits.scrapeUrl.minute,
+    reservoirRefreshInterval: minMs
+  });
+  const scrapeUrlMonthLimiter = new import_bottleneck.default({
+    reservoir: plan.rateLimits.scrapeUrl.month,
+    reservoirRefreshAmount: plan.rateLimits.scrapeUrl.month,
+    reservoirRefreshInterval: monthMs
+  });
+  const scrapeUrlLimiter = scrapeUrlMinLimiter.chain(scrapeUrlMonthLimiter);
+  const bulkMinLimiter = new import_bottleneck.default({
+    reservoir: plan.rateLimits.bulk.minute,
+    reservoirRefreshAmount: plan.rateLimits.bulk.minute,
+    reservoirRefreshInterval: minMs
+  });
+  const bulkMonthLimiter = new import_bottleneck.default({
+    reservoir: plan.rateLimits.bulk.month,
+    reservoirRefreshAmount: plan.rateLimits.bulk.month,
+    reservoirRefreshInterval: monthMs
+  });
+  const bulkLimiter = bulkMinLimiter.chain(bulkMonthLimiter);
+  const fastMinLimiter = new import_bottleneck.default({
+    reservoir: plan.rateLimits.fast.minute,
+    reservoirRefreshAmount: plan.rateLimits.fast.minute,
+    reservoirRefreshInterval: minMs
+  });
+  const fastMonthLimiter = new import_bottleneck.default({
+    reservoir: plan.rateLimits.fast.month,
+    reservoirRefreshAmount: plan.rateLimits.fast.month,
+    reservoirRefreshInterval: monthMs
+  });
+  const fastLimiter = fastMinLimiter.chain(fastMonthLimiter);
+  return {
+    scrapeUrl: scrapeUrlLimiter,
+    bulk: bulkLimiter,
+    fast: fastLimiter
+  };
+};
+
+// src/client.ts
+var import_openai = require("openai");
+var import_zod7 = __toESM(require("zod"));
+
+// src/search/result.ts
+class Result {
+  url_hash;
+  url;
+  netloc;
+  published;
+  visited;
+  language;
+  author;
+  title;
+  description;
+  content;
+  best_chunk;
+  semantics;
+  brand_safety;
+  continent;
+  region;
+  country;
+  sector;
+  industry_group;
+  industry;
+  sub_industry;
+  iab_tier_1;
+  iab_tier_2;
+  iab_tier_3;
+  iab_tier_4;
+  client;
+  constructor(params) {
+    this.client = params.client;
+    Object.assign(this, params.result);
+  }
+  static fromFlatten = (client, flatten) => {
+    const unflattened = {
+      ...flatten,
+      semantics: {
+        origin_shard: flatten.origin_shard,
+        chunks_total: flatten.chunks_total,
+        chunks_matched: flatten.chunks_matched,
+        chunks_kept: flatten.chunks_kept,
+        similarity: flatten.similarity
+      }
+    };
+    return new Result({
+      client,
+      result: unflattened
+    });
+  };
+  getSentiment = async (model) => {
+    if (!this.client.llmClient) {
+      throw new Error("A Nosible client instance must be provided with a OpenRouter API key.");
+    }
+    return getSentiment({
+      text: this.content,
+      model,
+      llmClient: this.client.llmClient
+    });
+  };
+  getSimilar = async (params) => {
+    return this.client.fastSearch({
+      question: this.title,
+      excludeDocs: [this.url_hash],
+      ...params
+    });
+  };
+  scrapeUrl = async () => {
+    return this.client.scrapeUrl(this.url);
+  };
+  flatten = () => {
+    return {
+      url_hash: this.url_hash,
+      url: this.url,
+      netloc: this.netloc,
+      published: this.published,
+      visited: this.visited,
+      language: this.language,
+      author: this.author,
+      title: this.title,
+      description: this.description,
+      content: this.content,
+      best_chunk: this.best_chunk,
+      origin_shard: this.semantics.origin_shard,
+      chunks_total: this.semantics.chunks_total,
+      chunks_matched: this.semantics.chunks_matched,
+      chunks_kept: this.semantics.chunks_kept,
+      similarity: this.semantics.similarity,
+      brand_safety: this.brand_safety,
+      continent: this.continent,
+      region: this.region,
+      country: this.country,
+      sector: this.sector,
+      industry_group: this.industry_group,
+      industry: this.industry,
+      sub_industry: this.sub_industry,
+      iab_tier_1: this.iab_tier_1,
+      iab_tier_2: this.iab_tier_2,
+      iab_tier_3: this.iab_tier_3,
+      iab_tier_4: this.iab_tier_4
+    };
+  };
+  data = () => {
+    return {
+      url_hash: this.url_hash,
+      url: this.url,
+      netloc: this.netloc,
+      published: this.published,
+      visited: this.visited,
+      language: this.language,
+      author: this.author,
+      title: this.title,
+      description: this.description,
+      content: this.content,
+      best_chunk: this.best_chunk,
+      brand_safety: this.brand_safety,
+      continent: this.continent,
+      region: this.region,
+      country: this.country,
+      sector: this.sector,
+      industry_group: this.industry_group,
+      industry: this.industry,
+      sub_industry: this.sub_industry,
+      iab_tier_1: this.iab_tier_1,
+      iab_tier_2: this.iab_tier_2,
+      iab_tier_3: this.iab_tier_3,
+      iab_tier_4: this.iab_tier_4,
+      semantics: this.semantics
+    };
+  };
+}
+
+// src/search/resultSet.ts
+var import_lunr = __toESM(require("lunr"));
+
+// src/search/analyze.ts
+var import_simple_statistics = require("simple-statistics");
+var analyzeResults = (results, by) => {
+  switch (by) {
+    case 0 /* netloc */:
+      const netlocValues = results.map((r) => r.netloc);
+      const netlocStats = analyzeCategorical(netlocValues);
+      return netlocStats;
+    case 1 /* published */:
+      const publishedValues = results.map((r) => new Date(r.published));
+      const publishedStats = analyzeDateByMonth(publishedValues);
+      return publishedStats;
+    case 2 /* visited */:
+      const visitedValues = results.map((r) => new Date(r.visited));
+      const visitedStats = analyzeDateByMonth(visitedValues);
+      return visitedStats;
+    case 3 /* author */:
+      const authorValues = results.map((r) => {
+        if (r.author) {
+          return r.author;
+        } else {
+          return "Unknown Author";
+        }
+      });
+      const authorStats = analyzeCategorical(authorValues);
+      return authorStats;
+    case 4 /* language */:
+      const languageValues = results.map((r) => r.language);
+      const languageStats = analyzeCategorical(languageValues);
+      return languageStats;
+    case 5 /* similarity */:
+      const simValues = results.map((r) => r.semantics.similarity);
+      const simStats = analyzeNumeric(simValues);
+      return simStats;
+    default:
+      return {};
+  }
+};
+var analyzeCategorical = (arr) => {
+  const result = {};
+  for (const v of arr) {
+    if (result[v]) {
+      result[v] += 1;
+    } else {
+      result[v] = 1;
+    }
+  }
+  return result;
+};
+var analyzeNumeric = (arr) => {
+  const meanValue = import_simple_statistics.mean(arr);
+  const stdValue = import_simple_statistics.standardDeviation(arr);
+  const minValue = import_simple_statistics.min(arr);
+  const maxValue = import_simple_statistics.max(arr);
+  const q25 = import_simple_statistics.quantile(arr, 0.25);
+  const q50 = import_simple_statistics.quantile(arr, 0.5);
+  const q75 = import_simple_statistics.quantile(arr, 0.75);
+  return {
+    count: arr.length,
+    null_count: arr.filter((v) => v === null).length,
+    mean: meanValue,
+    std: stdValue,
+    min: minValue,
+    q25,
+    q50,
+    q75,
+    max: maxValue
+  };
+};
+var analyzeDateByMonth = (arr) => {
+  if (!arr || arr.length === 0)
+    return {};
+  let minDate = null;
+  let maxDate = null;
+  const counts = {};
+  for (const d of arr) {
+    if (!(d instanceof Date))
+      continue;
+    const time = d.getTime();
+    if (Number.isNaN(time))
+      continue;
+    if (!minDate || d < minDate)
+      minDate = d;
+    if (!maxDate || d > maxDate)
+      maxDate = d;
+    const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+    counts[key] = (counts[key] ?? 0) + 1;
+  }
+  if (!minDate || !maxDate)
+    return {};
+  const result = {};
+  let y = minDate.getFullYear();
+  let m = minDate.getMonth() + 1;
+  const endY = maxDate.getFullYear();
+  const endM = maxDate.getMonth() + 1;
+  while (y < endY || y === endY && m <= endM) {
+    const key = `${y}-${String(m).padStart(2, "0")}`;
+    result[key] = counts[key] ?? 0;
+    m += 1;
+    if (m > 12) {
+      m = 1;
+      y += 1;
+    }
+  }
+  return result;
+};
+
+// src/search/resultSet.ts
+class ResultSet {
+  results;
+  constructor(results) {
+    this.results = results;
+  }
+  static async fromFilePath(filePath, client) {
+    if (filePath.endsWith(".json")) {
+      const json = await importJson({ filePath });
+      const results = json.map((result) => {
+        return new Result({ client, result });
+      });
+      return new ResultSet(results);
+    } else if (filePath.endsWith(".csv")) {
+      const csv = await importCsv({ filePath });
+      const results = csv.map((result) => {
+        return Result.fromFlatten(client, result);
+      });
+      return new ResultSet(results);
+    } else {
+      throw new Error("Unsupported file type");
+    }
+  }
+  static async fromFile(file, client) {
+    if (file.name.endsWith(".json")) {
+      const json = await importJson({ file });
+      const results = json.map((result) => {
+        return new Result({ client, result });
+      });
+      return new ResultSet(results);
+    } else if (file.name.endsWith(".csv")) {
+      const csv = await importCsv({ file });
+      const results = csv.map((result) => {
+        return new Result({ client, result });
+      });
+      return new ResultSet(results);
+    } else {
+      throw new Error("Unsupported file type");
+    }
+  }
+  static fromResults(results, searchQuery, client) {
+    const processedResults = results.map((result) => {
+      if (result instanceof Result) {
+        return result;
+      } else {
+        const fullResult = { ...searchQuery, ...result };
+        return new Result({ client, result: fullResult });
+      }
+    });
+    return new ResultSet(processedResults);
+  }
+  static join(resultSets) {
+    const newSet = [];
+    resultSets.forEach((resultSet) => newSet.push(...resultSet.results));
+    return new ResultSet(newSet);
+  }
+  getResults = () => {
+    return this.results.map((result) => result.data());
+  };
+  getFlattenResults = () => {
+    return this.results.map((result) => result.flatten());
+  };
+  findInResults = (query) => {
+    const results = this.results;
+    const index = import_lunr.default(function() {
+      this.ref("index");
+      this.field("content");
+      results.forEach((result, i) => {
+        this.add({
+          index: i,
+          content: result.content
+        });
+      });
+    });
+    const hits = index.search(query);
+    console.log("Number of results: " + this.results.length);
+    const matchedResults = [];
+    hits.forEach((hit) => {
+      let index2 = Number(hit.ref);
+      const found = this.results[index2];
+      if (found) {
+        matchedResults.push(found);
+      } else {
+        console.warn(`findInSearchResults: Hit not found (index ${index2})`);
+      }
+    });
+    console.log("Number of hits: " + hits.length);
+    console.log("Number of matchedResults: " + matchedResults.length);
+    console.log("matchedResults: ", typeof matchedResults);
+    return matchedResults;
+  };
+  analyze = (by) => {
+    return analyzeResults(this.results, by);
+  };
+  toPolars = async () => {
+    if (isBrowser()) {
+      throw new Error("toPolars is not supported in the browser");
+    } else {
+      const pl = await import("nodejs-polars");
+      const flattenedData = this.getFlattenResults();
+      const df = pl.DataFrame(flattenedData);
+      return df;
+    }
+  };
+  writeToCsv = async (fileName) => {
+    const flattenedData = this.getFlattenResults();
+    await exportCsv(flattenedData, fileName);
+  };
+  writeToParquet = async (fileName) => {
+    if (isBrowser()) {
+      throw new Error("writeToParquet is not supported in the browser");
+    } else {
+      const pl = await import("nodejs-polars");
+      const flattenedData = this.getFlattenResults();
+      const df = pl.DataFrame(flattenedData);
+      await df.writeParquet(fileName);
+    }
+  };
+  writeToIpc = async (fileName) => {
+    if (isBrowser()) {
+      throw new Error("writeToIpc is not supported in the browser");
+    } else {
+      const pl = await import("nodejs-polars");
+      const flattenedData = this.getFlattenResults();
+      const df = pl.DataFrame(flattenedData);
+      await df.writeIPC(fileName);
+    }
+  };
+  writeToJson = async (fileName) => {
+    await exportJson(this.getResults(), fileName);
+  };
+  writeToNdjson = async (fileName) => {
+    const flattenedData = this.getFlattenResults();
+    await exportNdjson(flattenedData, fileName);
+  };
+}
+
+// src/search/resultFactory.ts
+function createResult(client, result) {
+  return new Result({ client, result });
+}
+function createResultSet(client, rawResults) {
+  const resultInstances = rawResults.map((result) => createResult(client, result));
+  return new ResultSet(resultInstances);
+}
+
+// src/search/bulkSearch.ts
+var import_zlib = require("zlib");
+
+// src/utils/fernet.ts
+var import_crypto = require("crypto");
+var fernetDecrypt = (token, key) => {
+  try {
+    const keyBuffer = Buffer.from(key, "base64");
+    const signingKey = keyBuffer.subarray(0, 16);
+    const encryptionKey = keyBuffer.subarray(16, 32);
+    const hmac = token.subarray(token.length - 32);
+    const payload = token.subarray(0, token.length - 32);
+    const expectedHmac = import_crypto.createHmac("sha256", signingKey).update(payload).digest();
+    if (!import_crypto.timingSafeEqual(hmac, expectedHmac)) {
+      throw new Error("HMAC verification failed");
+    }
+    const version = payload[0];
+    if (version !== 128) {
+      throw new Error(`Unsupported Fernet version: ${version}`);
+    }
+    const iv = payload.subarray(9, 25);
+    const ciphertext = payload.subarray(25);
+    const decipher = import_crypto.createDecipheriv("aes-128-cbc", encryptionKey, iv);
+    const decrypted = Buffer.concat([
+      decipher.update(ciphertext),
+      decipher.final()
+    ]);
+    return decrypted;
+  } catch (error) {
+    console.error("Error decrypting data:", error);
+    throw error;
+  }
+};
+
+// src/search/bulkSearch.ts
+async function bulkSearchDownload({
+  downloadFrom,
+  decryptUsing
+}) {
+  if (downloadFrom.includes(".zstd.")) {
+    downloadFrom = downloadFrom.replace(".zstd.", ".gzip.");
+  } else {
+    throw new Error("Results were not retrieved from Nosible");
+  }
+  try {
+    for (let attempt = 0;attempt < 100; attempt++) {
+      const response = await fetch(downloadFrom);
+      if (response.status === 200) {
+        try {
+          const responseData = await response.arrayBuffer();
+          const encryptedData = Buffer.from(responseData);
+          const tokenBuffer = Buffer.from(encryptedData.toString("utf-8"), "base64");
+          const decrypted = fernetDecrypt(tokenBuffer, decryptUsing);
+          const decompressed = import_zlib.gunzipSync(decrypted);
+          const apiResp = JSON.parse(decompressed.toString("utf-8"));
+          return apiResp;
+        } catch (error) {
+          console.error("Error decrypting data:", error);
+          break;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1e4));
+    }
+  } catch (error) {
+    console.error("Error downloading data:", error);
+    throw error;
+  }
+}
+
+// src/search/searchSet.ts
+var import_zod6 = require("zod");
+var searchSetParams = import_zod6.z.union([
+  import_zod6.z.object({
+    searches: import_zod6.z.array(import_zod6.z.instanceof(Search))
+  }),
+  import_zod6.z.array(import_zod6.z.instanceof(Search))
+]);
+
+class SearchSet {
+  searches = [];
+  index;
+  constructor(params) {
+    if (Array.isArray(params)) {
+      this.searches = params;
+    } else {
+      this.searches = params.searches;
+    }
+    this.index = 0;
+  }
+  static async fromFilePath(filePath) {
+    if (filePath.endsWith(".json")) {
+      const searches = await importJson({ filePath });
+      return new SearchSet(searches.map((search) => new Search(search)));
+    } else if (filePath.endsWith(".csv")) {
+      const searches = await importCsv({ filePath });
+      return new SearchSet(searches.map((search) => new Search(search)));
+    } else
+      throw new Error("Unsupported file type");
+  }
+  static async fromFile(file) {
+    if (file.name.endsWith(".json")) {
+      const searches = await importJson({ file });
+      return new SearchSet(searches.map((search) => new Search(search)));
+    } else if (file.name.endsWith(".csv")) {
+      const searches = await importCsv({ file });
+      return new SearchSet(searches.map((search) => new Search(search)));
+    } else
+      throw new Error("Unsupported file type");
+  }
+  next = () => {
+    this.index++;
+    const search = this.searches[this.index];
+    if (!search) {
+      return null;
+    }
+    return search;
+  };
+  add = (search) => {
+    this.searches.push(search);
+  };
+  remove = (index) => {
+    this.searches.splice(index, 1);
+  };
+  toPolars = async () => {
+    if (isBrowser()) {
+      throw new Error("toPolars is not supported in the browser");
+    } else {
+      const pl = await import("nodejs-polars");
+      const df = pl.DataFrame(this.searches);
+      return df;
+    }
+  };
+  writeToCsv = async (fileName) => {
+    await exportCsv(this.searches, fileName);
+  };
+  writeToJson = async (fileName) => {
+    await exportJson(this.searches, fileName);
+  };
+  writeToNdjson = async (fileName) => {
+    await exportNdjson(this.searches, fileName);
+  };
+}
+
+// src/client.ts
+var fastSearchesParamsSchema = import_zod7.default.union([
+  userSearchParamsSchema.omit({ question: true }).extend({
+    questions: import_zod7.default.array(import_zod7.default.string())
+  }),
+  import_zod7.default.instanceof(SearchSet)
+]);
+var nosibleClientParams = import_zod7.default.union([
+  import_zod7.default.string(),
+  import_zod7.default.object({
+    apiKey: import_zod7.default.string(),
+    llmApiKey: import_zod7.default.string().optional(),
+    openAiBaseURL: import_zod7.default.string().optional(),
+    sentimentModel: import_zod7.default.string().optional(),
+    expansionsModel: import_zod7.default.string().optional(),
+    searchDefaults: clientDefaultSearchParamsSchema.optional()
+  })
+]);
+
+class NosibleClient {
+  baseUrl = "https://www.nosible.ai/search/v2";
+  apiKey;
+  llmClient;
+  expansionsModel = "openai/gpt-4o";
+  searchDefaults;
+  plan;
+  limiters;
+  constructor(params) {
+    let apiKeyToUse;
+    let llmApiKeyToUse;
+    let openAiBaseURL;
+    let searchDefaultsToUse;
+    if (typeof params === "string") {
+      apiKeyToUse = params;
+    } else if (params) {
+      apiKeyToUse = params.apiKey;
+      llmApiKeyToUse = params.llmApiKey;
+      openAiBaseURL = params.openAiBaseURL;
+      searchDefaultsToUse = params.searchDefaults;
+    } else {
+      apiKeyToUse = process.env.NOSIBLE_API_KEY;
+      llmApiKeyToUse = process.env.LLM_API_KEY;
+    }
+    if (!apiKeyToUse) {
+      throw new Error("API key is required");
+    } else {
+      this.verifyAndSetApiKey(apiKeyToUse);
+    }
+    if (llmApiKeyToUse) {
+      this.llmClient = new import_openai.OpenAI({
+        apiKey: llmApiKeyToUse,
+        baseURL: openAiBaseURL
+      });
+    }
+    this.apiKey = apiKeyToUse;
+    this.searchDefaults = searchDefaultsToUse;
+    this.plan = getUserPlan(this.apiKey);
+    this.limiters = getLimiters(this.apiKey);
+  }
+  mergeWithDefaultSearch(params) {
+    if (!this.searchDefaults) {
+      return params;
+    }
+    return {
+      ...this.searchDefaults,
+      ...params
+    };
+  }
+  verifyAndSetApiKey(apiKey) {
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    const splits = apiKey.split("|");
+    if (splits.length !== 2) {
+      throw new Error("API key is invalid - expected format 'key_id|secret_key'");
+    }
+    this.apiKey = apiKey;
+  }
+  async _request(endpoint, body) {
+    return callNosibleApi({
+      endpoint,
+      body,
+      apiKey: this.apiKey
+    });
+  }
+  async fastSearch(params) {
+    let search;
+    const hasSearchInstance = (params2) => {
+      return "search" in params2;
+    };
+    if (hasSearchInstance(params)) {
+      if (params.search instanceof Search) {
+        search = params.search;
+      } else {
+        throw new Error("Invalid search parameter provided.");
+      }
+    } else {
+      const mergedParams = this.mergeWithDefaultSearch(params);
+      search = new Search(mergedParams);
+    }
+    const body = await search.searchBody({ client: this });
+    const validatedBody = validateFastSearchParams(body);
+    const { message, query, response } = await this._request("fast-search", validatedBody);
+    const results = response.map((result) => {
+      const fullResult = { ...query, ...result };
+      return fullResult;
+    });
+    const resultSet = createResultSet(this, results);
+    return resultSet;
+  }
+  async fastSearches(params) {
+    let searchSet;
+    if (params instanceof SearchSet) {
+      searchSet = params;
+    } else {
+      const { questions, ...sharedParams } = params;
+      const mergedSharedParams = this.mergeWithDefaultSearch(sharedParams);
+      const searches = questions.map((question) => new Search({ question, ...mergedSharedParams }));
+      searchSet = new SearchSet(searches);
+    }
+    const results = await Promise.all(searchSet.searches.map((search) => this.fastSearch({ search })));
+    return results;
+  }
+  async aiSearch(params) {
+    const json = await this._request("search", params);
+    const results = json.response.map((result) => {
+      const fullResult = { ...json.query, ...result };
+      return fullResult;
+    });
+    const resultSet = createResultSet(this, results);
+    return resultSet;
+  }
+  async bulkSearch(params) {
+    let search;
+    const hasSearchInstance = (params2) => {
+      return "search" in params2;
+    };
+    if (hasSearchInstance(params)) {
+      if (params.search instanceof Search) {
+        search = params.search;
+      } else {
+        throw new Error("Invalid search parameter provided.");
+      }
+    } else {
+      const mergedParams = this.mergeWithDefaultSearch(params);
+      search = new Search(mergedParams);
+    }
+    const body = await search.searchBody({ client: this });
+    const validatedBody = validateBulkSearchParams(body);
+    const fileLocation = await this._request("bulk-search", validatedBody);
+    const json = await bulkSearchDownload({
+      downloadFrom: fileLocation.download_from,
+      decryptUsing: fileLocation.decrypt_using
+    });
+    const results = json.response.map((result) => {
+      const fullResult = { ...json.query, ...result };
+      return fullResult;
+    });
+    const resultSet = createResultSet(this, results);
+    return resultSet;
+  }
+  async scrapeUrl(url) {
+    return this.limiters.scrapeUrl.schedule(async () => {
+      const json = await this._request("scrape-url", { url });
+      const webPage = new WebPageData(this, json.response);
+      return webPage;
+    });
+  }
+  async topicTrend(query, sqlFilter) {
+    const body = { query, sql_filter: sqlFilter };
+    const json = await this._request("topic-trend", body);
+    const topicTrend = new TopicTrend(json);
+    return topicTrend;
+  }
+}
+
+//# debugId=E7A50C56345E2B0F64756E2164756E21