@mherod/get-cookie 2.0.0-rc.10 → 2.0.0-rc.11

package/dist/index.js

@@ -146,7 +146,6 @@ function $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb(s) {
 
 
 
-
 class $269fe42bfd555305$export$2e2bcd8739ae039 {
     browserName = "Chrome";
     async queryCookies(name, domain) {
@@ -210,9 +209,12 @@ async function $269fe42bfd555305$var$getChromeCookies({ name: name , domain: dom
             meta: meta
         };
         const expiry = cookieRow.expiry;
-        if (expiry) (0, $7oI3p$lodash.merge)(exportedCookie, {
+        const mergeExpiry = expiry != null && expiry > 0 ? {
             expiry: new Date(expiry)
-        });
+        } : {
+            expiry: "Infinity"
+        };
+        (0, $7oI3p$lodash.merge)(exportedCookie, mergeExpiry);
         return exportedCookie;
     });
     const results = (await Promise.all(decrypted)).filter((0, $d66f40b581ba8bfa$export$963c8d651337e4a4));
@@ -248,9 +250,14 @@ async function $269fe42bfd555305$var$getEncryptedChromeCookie({ name: name , dom
             sql += `host_key LIKE '${sqlEmbedDomain}';`;
         }
     }
+    if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b).verbose) console.log("sql", sql);
+    const domainRegexp = (0, $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb)(domain);
     const sqliteQuery1 = await $269fe42bfd555305$export$bd52b72df8d0d261({
         file: file,
         sql: sql,
+        rowFilter: (row)=>{
+            return row["host_key"].match(domainRegexp) != null;
+        },
         rowTransform: (row)=>{
             const cookieRow = {
                 expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
@@ -263,7 +270,7 @@ async function $269fe42bfd555305$var$getEncryptedChromeCookie({ name: name , dom
         }
     });
     return sqliteQuery1.filter((row)=>{
-        return row.domain.match((0, $68c0ed99fadee6ca$export$4eadcf0bf35a2ddb)(domain)) != null;
+        return row.domain.match(domainRegexp) != null;
     });
 }
 async function $269fe42bfd555305$var$getChromePassword() {
@@ -324,7 +331,7 @@ async function $269fe42bfd555305$var$decrypt(password, encryptedData) {
         });
     });
 }
-async function $269fe42bfd555305$export$bd52b72df8d0d261({ file: file , sql: sql , rowTransform: rowTransform  }) {
+async function $269fe42bfd555305$export$bd52b72df8d0d261({ file: file , sql: sql , rowFilter: rowFilter = ()=>true , rowTransform: rowTransform  }) {
     if (!file || file && !(0, ($parcel$interopDefault($7oI3p$fs))).existsSync(file)) throw new Error(`doSqliteQuery1: file ${file} does not exist`);
     const db = new $7oI3p$sqlite3.Database(file);
     return new Promise((resolve, reject)=>{
@@ -339,7 +346,7 @@ async function $269fe42bfd555305$export$bd52b72df8d0d261({ file: file , sql: sql
                 return;
             }
             if (Array.isArray(rows1)) {
-                const cookieRows = rows1.map((row)=>{
+                const cookieRows = rows1.filter(rowFilter).map((row)=>{
                     const newVar = {
                         meta: {
                             file: file
@@ -543,7 +550,7 @@ class $e4efb16e005540de$export$2e2bcd8739ae039 {
             domain: cookie.domain ?? cookieSpec.domain,
             name: cookie.key ?? cookieSpec.name,
             value: cookie.value,
-            expiry: cookie.expires ?? Infinity,
+            expiry: cookie.expires ?? "Infinity",
             meta: {
                 file: "tough-cookie"
             }
@@ -688,7 +695,6 @@ async function $f9b70200901ad17d$export$c44c5fdef43f0941(params) {
 
 
 
-
 function $9c43c2ed82e63570$export$9abc0a414b0d8b8f(results) {
     // sort by name and expiry descending
     // takes the latest expiry for each name
@@ -704,17 +710,27 @@ function $9c43c2ed82e63570$export$9abc0a414b0d8b8f(results) {
 
 
 
-async function $300d8b33187a203c$export$4d2e9997e2c23417({ name: name , domain: domain  }) {
-    const cookies = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)({
-        name: name,
-        domain: domain
-    }, new (0, $f72befa528c23ca7$export$2e2bcd8739ae039)());
+
+async function $8ef2ebdbd659489d$export$a65902517ae87ba8(cookieSpec) {
+    const cookies = [];
+    if (Array.isArray(cookieSpec)) {
+        const cookieSpecs = cookieSpec;
+        for (const cookieSpec1 of cookieSpecs){
+            const cookies1 = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)(cookieSpec1);
+            cookies.push(...cookies1);
+        }
+    } else {
+        const singleQuery = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)(cookieSpec);
+        cookies.push(...singleQuery);
+    }
+    return (0, $7oI3p$lodash.uniqBy)(cookies, JSON.stringify);
+}
+
+
+async function $300d8b33187a203c$export$4d2e9997e2c23417(cookieSpec) {
+    const cookies = await (0, $8ef2ebdbd659489d$export$a65902517ae87ba8)(cookieSpec);
     if (cookies.length == 0) throw new Error("Cookie not found");
-    const results = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)({
-        name: name,
-        domain: domain
-    });
-    const groupedByFile = (0, $7oI3p$lodash.groupBy)(results, (r)=>r.meta?.file);
+    const groupedByFile = (0, $7oI3p$lodash.groupBy)(cookies, (r)=>r.meta?.file);
     return Object.keys(groupedByFile).map((file)=>{
         const results = groupedByFile[file];
         return (0, $9c43c2ed82e63570$export$9abc0a414b0d8b8f)(results);
@@ -724,18 +740,10 @@ async function $300d8b33187a203c$export$4d2e9997e2c23417({ name: name , domain:
 
 
 
-
-async function $4ffeaeb7bb3c0319$export$cfc0723de5712e57({ name: name , domain: domain  }) {
-    const cookies = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)({
-        name: name,
-        domain: domain
-    }, new (0, $f72befa528c23ca7$export$2e2bcd8739ae039)());
-    if (cookies.length == 0) throw new Error("Cookie not found");
-    const results = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)({
-        name: name,
-        domain: domain
-    });
-    return (0, $9c43c2ed82e63570$export$9abc0a414b0d8b8f)(results);
+async function $4ffeaeb7bb3c0319$export$cfc0723de5712e57(cookieSpec) {
+    const cookies = await (0, $8ef2ebdbd659489d$export$a65902517ae87ba8)(cookieSpec);
+    if (cookies.length > 0) return (0, $9c43c2ed82e63570$export$9abc0a414b0d8b8f)(cookies);
+    return "";
 }
 
 
@@ -747,31 +755,48 @@ async function $4ffeaeb7bb3c0319$export$cfc0723de5712e57({ name: name , domain:
 
 
 
+
+function $2d84054eb5f070a6$export$f266452a5050185d(url) {
+    const url1 = typeof url == "string" ? new URL(url) : url;
+    const cookieSpecs = [];
+    const splits = url1.hostname.split(".");
+    const tld = splits.slice(-2).join(".");
+    const cookieSpec = {
+        name: "%",
+        domain: "%." + tld
+    };
+    cookieSpecs.push(cookieSpec);
+    const cookieSpec1 = {
+        name: "%",
+        domain: url1.hostname
+    };
+    cookieSpecs.push(cookieSpec1);
+    // const isWww = splits.slice(-3)[0] === "www";
+    const cookieSpec2 = {
+        name: "%",
+        domain: tld
+    };
+    cookieSpecs.push(cookieSpec2);
+    return (0, $7oI3p$lodash.uniqBy)(cookieSpecs, JSON.stringify);
+}
+
+
 async function $cfc07ae4aa2c7e44$export$b24a545a0b39f491(url, options = {}, fetch = (0, $7oI3p$crossfetch.fetch)) {
+    const headers = {
+        "User-Agent": new (0, ($parcel$interopDefault($7oI3p$useragents)))().toString()
+    };
     const defaultOptions = {
-        headers: {
-            "User-Agent": new (0, ($parcel$interopDefault($7oI3p$useragents)))().toString()
-        },
+        headers: headers,
         redirect: "manual"
     };
     const url2 = `${url}`;
     const url1 = new URL(url2);
-    const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1)=>{
-        return `%${p1}`;
-    });
-    const cookieSpec = {
-        name: "%",
-        domain: domain
-    };
-    // const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
-    //   () => []
-    // );
-    // const cookie = cookies.pop();
-    const cookie = await (0, $4ffeaeb7bb3c0319$export$cfc0723de5712e57)(cookieSpec).catch(()=>"");
-    const headers = {};
+    const cookieSpecs = (0, $2d84054eb5f070a6$export$f266452a5050185d)(url1);
+    const cookie = await (0, $4ffeaeb7bb3c0319$export$cfc0723de5712e57)(cookieSpecs).catch(()=>"");
     if (cookie.length > 0) (0, $7oI3p$lodash.merge)(headers, {
         Cookie: cookie
     });
+    if ((0, $ef3d5dc2fd8022f5$export$c348dfaf65040d9b)["dump-request-headers"]) console.log((0, $7oI3p$colorette.blue)("Request headers:"), headers);
     const newOptions1 = (0, $7oI3p$lodash.merge)(defaultOptions, options, {
         headers: headers
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mherod/get-cookie",
-  "version": "2.0.0-rc.10",
+  "version": "2.0.0-rc.11",
   "description": "Node.js module for querying a local user's Chrome cookie",
   "source": "src/index.ts",
   "bin": "dist/cli.js",
@@ -25,7 +25,6 @@
   },
   "targets": {
     "main": {},
-    "types": {},
     "library": {
       "source": "src/index.ts",
       "distDir": "dist",
@@ -33,6 +32,7 @@
       "engines": {
         "node": "16"
       },
+      "sourceMap": true,
       "includeNodeModules": false
     },
     "cli": {
@@ -42,6 +42,7 @@
       "engines": {
         "node": "16"
       },
+      "sourceMap": false,
       "includeNodeModules": [
         "colorette"
       ]

package/src/CookieSpec.ts

@@ -2,3 +2,5 @@ export default interface CookieSpec {
   domain: string;
   name: string;
 }
+
+export type MultiCookieSpec = CookieSpec | CookieSpec[];

package/src/CookieStore.ts

@@ -1,5 +1,6 @@
 import { CookieJar } from "tough-cookie";
 import { env } from "./global";
+
 const { FileCookieStore } = require("tough-cookie-file-store");
 
 export const cookieStore = new FileCookieStore(

package/src/browsers/ChromeCookieQueryStrategy.ts

@@ -1,11 +1,10 @@
 import CookieQueryStrategy from "./CookieQueryStrategy";
 import { execSimple } from "../utils";
 import { env, HOME } from "../global";
-import { existsSync } from "fs";
+import fs, { existsSync } from "fs";
 import { findAllFiles } from "../findAllFiles";
 import * as crypto from "crypto";
 import * as path from "path";
-import { doSqliteQuery1 } from "../doSqliteQuery1";
 import { merge } from "lodash";
 import { isCookieRow } from "../IsCookieRow";
 import { isExportedCookie } from "../IsExportedCookie";
@@ -13,7 +12,6 @@ import CookieRow from "../CookieRow";
 import ExportedCookie from "../ExportedCookie";
 import { stringToRegex } from "../StringToRegex";
 import { parsedArgs } from "../argv";
-import fs from "fs";
 import * as sqlite3 from "sqlite3";
 import { DoSqliteQuery1Params } from "../doSqliteQuery1Params";
 
@@ -113,11 +111,15 @@ Promise<ExportedCookie[]> {
         meta: meta,
       };
       const expiry = cookieRow.expiry;
-      if (expiry) {
-        merge(exportedCookie, {
-          expiry: new Date(expiry),
-        });
-      }
+      const mergeExpiry =
+        expiry != null && expiry > 0
+          ? {
+              expiry: new Date(expiry),
+            }
+          : {
+              expiry: "Infinity",
+            };
+      merge(exportedCookie, mergeExpiry);
       return exportedCookie;
     });
   const results: ExportedCookie[] = (await Promise.all(decrypted)).filter(
@@ -179,9 +181,16 @@ async function getEncryptedChromeCookie({
       sql += `host_key LIKE '${sqlEmbedDomain}';`;
     }
   }
+  if (parsedArgs.verbose) {
+    console.log("sql", sql);
+  }
+  const domainRegexp: RegExp = stringToRegex(domain);
   const sqliteQuery1: CookieRow[] = await doChromeSqliteQuery1({
     file: file,
     sql: sql,
+    rowFilter: (row) => {
+      return row["host_key"].match(domainRegexp) != null;
+    },
     rowTransform: (row) => {
       const cookieRow = {
         expiry: (row["expires_utc"] / 1000000 - 11644473600) * 1000,
@@ -196,7 +205,7 @@ async function getEncryptedChromeCookie({
     },
   });
   return sqliteQuery1.filter((row) => {
-    return row.domain.match(stringToRegex(domain)) != null;
+    return row.domain.match(domainRegexp) != null;
   });
 }
 
@@ -304,6 +313,7 @@ async function decrypt(
 export async function doChromeSqliteQuery1({
   file,
   sql,
+  rowFilter = () => true,
   rowTransform,
 }: DoSqliteQuery1Params): Promise<CookieRow[]> {
   if (!file || (file && !fs.existsSync(file))) {
@@ -322,15 +332,17 @@ export async function doChromeSqliteQuery1({
         return;
       }
       if (Array.isArray(rows1)) {
-        const cookieRows: CookieRow[] = rows1.map((row: any) => {
-          const newVar = {
-            meta: {
-              file: file,
-            },
-          };
-          const cookieRow: CookieRow = rowTransform(row);
-          return merge(newVar, cookieRow);
-        });
+        const cookieRows: CookieRow[] = rows1
+          .filter(rowFilter)
+          .map((row: any) => {
+            const newVar = {
+              meta: {
+                file: file,
+              },
+            };
+            const cookieRow: CookieRow = rowTransform(row);
+            return merge(newVar, cookieRow);
+          });
         resolve(cookieRows);
         return;
       }

package/src/browsers/CookieQueryStrategy.ts

@@ -2,5 +2,6 @@ import ExportedCookie from "../ExportedCookie";
 
 export default interface CookieQueryStrategy {
   browserName: string;
+
   queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
 }

package/src/browsers/CookieStoreQueryStrategy.ts

@@ -2,7 +2,7 @@ import CookieQueryStrategy from "./CookieQueryStrategy";
 import CookieSpec from "../CookieSpec";
 import ExportedCookie from "../ExportedCookie";
 import { Cookie } from "tough-cookie";
-import { cookieStore, cookieJar } from "../CookieStore";
+import { cookieJar, cookieStore } from "../CookieStore";
 import { stringToRegex } from "../StringToRegex";
 
 export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
@@ -59,7 +59,7 @@ export default class CookieStoreQueryStrategy implements CookieQueryStrategy {
       domain: cookie.domain ?? cookieSpec.domain,
       name: cookie.key ?? cookieSpec.name,
       value: cookie.value,
-      expiry: cookie.expires ?? Infinity,
+      expiry: cookie.expires ?? "Infinity",
       meta: {
         file: "tough-cookie",
       },

package/src/cli.ts

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 
 import { argv, parsedArgs } from "./argv";
-import { queryCookies } from "./queryCookies";
 import { groupBy } from "lodash";
 import { green, red, yellow } from "colorette";
 import { resultsRendered } from "./resultsRendered";
 import { fetchWithCookies } from "./fetchWithCookies";
 import { unpackHeaders } from "./unpackHeaders";
 import CookieSpec from "./CookieSpec";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
 
-async function cliQueryCookies({ name, domain }: CookieSpec) {
+async function cliQueryCookies(cookieSpec: CookieSpec | CookieSpec[]) {
   try {
-    const results = await queryCookies({ name, domain });
+    const results = await comboQueryCookieSpec(cookieSpec);
     if (results == null || results.length == 0) {
       console.error(red("No results"));
       return;
@@ -49,7 +50,7 @@ async function cliQueryCookies({ name, domain }: CookieSpec) {
   }
 }
 
-function main() {
+async function main() {
   if (parsedArgs["help"] || parsedArgs["h"]) {
     console.log(`Usage: ${argv[1]} [name] [domain] [options] `);
     console.log(`Options:`);
@@ -61,6 +62,8 @@ function main() {
     return;
   }
 
+  parsedArgs["verbose"] = parsedArgs["verbose"] || parsedArgs["v"];
+
   const fetchUrl: string = parsedArgs["fetch"] || parsedArgs["F"];
   if (fetchUrl) {
     let url: URL;
@@ -100,12 +103,24 @@ function main() {
     return;
   }
 
-  const cookieSpec: CookieSpec = {
-    name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
-    domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
-  };
+  const cookieSpecs: CookieSpec[] = [];
+  const argUrl: string = parsedArgs["url"] || parsedArgs["u"];
+  if (argUrl) {
+    for (const cookieSpec of cookieSpecsFromUrl(argUrl)) {
+      cookieSpecs.push(cookieSpec);
+    }
+  } else {
+    cookieSpecs.push({
+      name: parsedArgs["name"] || parsedArgs["_"][0] || "%",
+      domain: parsedArgs["domain"] || parsedArgs["_"][1] || "%",
+    });
+  }
+
+  if (parsedArgs.verbose) {
+    console.log("cookieSpecs", cookieSpecs);
+  }
 
-  cliQueryCookies(cookieSpec).catch(console.error);
+  await cliQueryCookies(cookieSpecs).catch(console.error);
 }
 
-main();
+main().then((r) => r, console.error);

package/src/comboQueryCookieSpec.ts

@@ -0,0 +1,21 @@
+import CookieSpec, { MultiCookieSpec } from "./CookieSpec";
+import ExportedCookie from "./ExportedCookie";
+import { queryCookies } from "./queryCookies";
+import { uniqBy } from "lodash";
+
+export async function comboQueryCookieSpec(
+  cookieSpec: MultiCookieSpec
+): Promise<ExportedCookie[]> {
+  const cookies: ExportedCookie[] = [];
+  if (Array.isArray(cookieSpec)) {
+    const cookieSpecs = <CookieSpec[]>cookieSpec;
+    for (const cookieSpec1 of cookieSpecs) {
+      const cookies1: ExportedCookie[] = await queryCookies(cookieSpec1);
+      cookies.push(...cookies1);
+    }
+  } else {
+    const singleQuery = await queryCookies(cookieSpec);
+    cookies.push(...singleQuery);
+  }
+  return uniqBy(cookies, JSON.stringify);
+}

package/src/cookieSpecsFromUrl.ts

@@ -0,0 +1,26 @@
+import CookieSpec from "./CookieSpec";
+import { uniqBy } from "lodash";
+
+export function cookieSpecsFromUrl(url: URL | string): CookieSpec[] {
+  const url1 = typeof url == "string" ? new URL(url) : url;
+  const cookieSpecs = [];
+  const splits = url1.hostname.split(".");
+  const tld = splits.slice(-2).join(".");
+  const cookieSpec: CookieSpec = {
+    name: "%",
+    domain: "%." + tld,
+  };
+  cookieSpecs.push(cookieSpec);
+  const cookieSpec1: CookieSpec = {
+    name: "%",
+    domain: url1.hostname,
+  };
+  cookieSpecs.push(cookieSpec1);
+  // const isWww = splits.slice(-3)[0] === "www";
+  const cookieSpec2: CookieSpec = {
+    name: "%",
+    domain: tld,
+  };
+  cookieSpecs.push(cookieSpec2);
+  return uniqBy(cookieSpecs, JSON.stringify);
+}

package/src/doSqliteQuery1Params.ts

@@ -3,5 +3,6 @@ import CookieRow from "./CookieRow";
 export interface DoSqliteQuery1Params {
   file: string;
   sql: string;
+  rowFilter?: (row: any) => boolean;
   rowTransform: (row: any) => CookieRow;
 }

package/src/fetchWithCookies.ts

@@ -4,44 +4,38 @@ import { fetch as fetchImpl } from "cross-fetch";
 import { merge } from "lodash";
 // noinspection SpellCheckingInspection
 import destr from "destr";
-import CookieSpec from "./CookieSpec";
 import { cookieJar } from "./CookieStore";
 import UserAgent from "user-agents";
 import { parsedArgs } from "./argv";
 import { blue, yellow } from "colorette";
 import { getMergedRenderedCookies } from "./getMergedRenderedCookies";
+import { cookieSpecsFromUrl } from "./cookieSpecsFromUrl";
+import CookieSpec from "./CookieSpec";
 
 export async function fetchWithCookies(
   url: RequestInfo | URL,
   options: RequestInit | undefined = {},
   fetch: Function = fetchImpl
 ): Promise<Response> {
+  const headers = {
+    "User-Agent": new UserAgent().toString(),
+  };
   const defaultOptions: RequestInit = {
-    headers: {
-      "User-Agent": new UserAgent().toString(),
-    },
+    headers,
     redirect: "manual",
   };
   const url2: string = `${url}`;
   const url1: URL = new URL(url2);
-  const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1) => {
-    return `%${p1}`;
-  });
-  const cookieSpec: CookieSpec = {
-    name: "%",
-    domain: domain,
-  };
-  // const cookies: string[] = await getGroupedRenderedCookies(cookieSpec).catch(
-  //   () => []
-  // );
-  // const cookie = cookies.pop();
-  const cookie = await getMergedRenderedCookies(cookieSpec).catch(() => "");
-  const headers = {};
+  const cookieSpecs: CookieSpec[] = cookieSpecsFromUrl(url1);
+  const cookie = await getMergedRenderedCookies(cookieSpecs).catch(() => "");
   if (cookie.length > 0) {
     merge(headers, {
       Cookie: cookie,
     });
   }
+  if (parsedArgs["dump-request-headers"]) {
+    console.log(blue("Request headers:"), headers);
+  }
   const newOptions1: RequestInit = merge(defaultOptions, options, { headers });
   try {
     const res: Response = await fetch(url2, newOptions1);

package/src/getGroupedRenderedCookies.ts

@@ -1,27 +1,17 @@
 import { groupBy } from "lodash";
-import { queryCookies } from "./queryCookies";
 import { resultsRendered } from "./resultsRendered";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import CookieSpec from "./CookieSpec";
+import { MultiCookieSpec } from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
 
-export async function getGroupedRenderedCookies({
-  name,
-  domain,
-}: CookieSpec): Promise<string[]> {
-  const cookies: ExportedCookie[] = await queryCookies(
-    {
-      name,
-      domain,
-    },
-    new CompositeCookieQueryStrategy()
-    //
-  );
+export async function getGroupedRenderedCookies(
+  cookieSpec: MultiCookieSpec
+): Promise<string[]> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
   if (cookies.length == 0) {
     throw new Error("Cookie not found");
   }
-  const results: ExportedCookie[] = await queryCookies({ name, domain });
-  const groupedByFile = groupBy(results, (r: ExportedCookie) => r.meta?.file);
+  const groupedByFile = groupBy(cookies, (r: ExportedCookie) => r.meta?.file);
   return Object.keys(groupedByFile).map((file: string) => {
     const results: ExportedCookie[] = groupedByFile[file];
     return resultsRendered(results);

package/src/getMergedRenderedCookies.ts

@@ -1,25 +1,14 @@
-import { groupBy } from "lodash";
-import { queryCookies } from "./queryCookies";
 import { resultsRendered } from "./resultsRendered";
-import CompositeCookieQueryStrategy from "./browsers/CompositeCookieQueryStrategy";
-import CookieSpec from "./CookieSpec";
+import { comboQueryCookieSpec } from "./comboQueryCookieSpec";
+import { MultiCookieSpec } from "./CookieSpec";
 import ExportedCookie from "./ExportedCookie";
 
-export async function getMergedRenderedCookies({
-  name,
-  domain,
-}: CookieSpec): Promise<string> {
-  const cookies: ExportedCookie[] = await queryCookies(
-    {
-      name,
-      domain,
-    },
-    new CompositeCookieQueryStrategy()
-    //
-  );
-  if (cookies.length == 0) {
-    throw new Error("Cookie not found");
+export async function getMergedRenderedCookies(
+  cookieSpec: MultiCookieSpec
+): Promise<string> {
+  const cookies: ExportedCookie[] = await comboQueryCookieSpec(cookieSpec);
+  if (cookies.length > 0) {
+    return resultsRendered(cookies);
   }
-  const results: ExportedCookie[] = await queryCookies({ name, domain });
-  return resultsRendered(results);
+  return "";
 }