@mherod/get-cookie 2.0.0-beta.8 → 2.0.0-rc.1

package/dist/index.js

@@ -1,3 +1,616 @@
 #!/usr/bin/env node
-var r=require("lodash"),e=(require("fs"),require("crypto"),require("path"));require("child_process"),require("sqlite3"),require("jsonwebtoken"),require("cross-fetch"),require("destr");var i=r.merge;const o={};i(o,process.env);const s=o.HOME;if(!s)throw new Error("HOME environment variable is not set");e.join(s,"Library","Application Support","Google","Chrome");
+var $7oI3p$lodash = require("lodash");
+var $7oI3p$lrucache = require("lru-cache");
+var $7oI3p$fs = require("fs");
+var $7oI3p$crypto = require("crypto");
+var $7oI3p$path = require("path");
+var $7oI3p$child_process = require("child_process");
+var $7oI3p$sqlite3 = require("sqlite3");
+var $7oI3p$jsonwebtoken = require("jsonwebtoken");
+var $7oI3p$crossfetch = require("cross-fetch");
+var $7oI3p$destr = require("destr");
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {
+      return;
+    }
+
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
+
+  return dest;
+}
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+
+$parcel$export(module.exports, "getCookie", () => $cd1ba0160120c006$export$4be65e66cfa2648a);
+$parcel$export(module.exports, "getFirefoxCookie", () => $cd1ba0160120c006$export$c44c5fdef43f0941);
+$parcel$export(module.exports, "getChromeCookie", () => $cd1ba0160120c006$export$e5637297e9eb6f2e);
+$parcel$export(module.exports, "getGroupedRenderedCookies", () => $300d8b33187a203c$export$4d2e9997e2c23417);
+$parcel$export(module.exports, "fetchWithCookies", () => $cfc07ae4aa2c7e44$export$b24a545a0b39f491);
+
+const $fac425c10fbbada5$export$a7b6bc01c63cdfc3 = {};
+(0, $7oI3p$lodash.merge)($fac425c10fbbada5$export$a7b6bc01c63cdfc3, process.env);
+const $fac425c10fbbada5$export$a7c5707626fc90f = $fac425c10fbbada5$export$a7b6bc01c63cdfc3["HOME"];
+if (!$fac425c10fbbada5$export$a7c5707626fc90f) throw new Error("HOME environment variable is not set");
+
+
+
+
+async function $25b78d6746d4ad48$export$8d71c74f97c0202e(command) {
+    return new Promise((resolve, reject)=>{
+        (0, $7oI3p$child_process.exec)(command, {
+            encoding: "binary",
+            maxBuffer: 5120
+        }, (error, stdout, stderr)=>{
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (stderr) {
+                reject(error);
+                return;
+            }
+            if (stdout) resolve(stdout.trim());
+        });
+    });
+}
+function $25b78d6746d4ad48$export$d53bf2de587a369(result) {
+    if (result == null) return null;
+    if (process.env.VERBOSE) console.log("result", result);
+    if (typeof result === "string" && result.length > 0) return result;
+    if (result.slice && result.toString) // noinspection JSCheckFunctionSignatures
+    return result.toString("utf8");
+    return null;
+}
+function $25b78d6746d4ad48$export$99ce3e33a555daf1(input) {
+    return typeof input !== "string" || input.length === 0;
+}
+function $25b78d6746d4ad48$export$5348b46700dd771c(input) {
+    return typeof input == "string" && input.length > 0;
+}
+
+
+
+
+
+
+async function $e62c2c56eb720f29$export$2c9faf86071156ae({ path: path , name: name , maxDepth: maxDepth = 2  }) {
+    const rootSegments = path.split("/").length;
+    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log(`Searching for ${name} in ${path}`);
+    const files = [];
+    let readdirSync;
+    try {
+        readdirSync = $7oI3p$fs.readdirSync(path);
+    } catch (e) {
+        if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log(`Error reading ${path}`, e);
+        return [];
+    }
+    for (const file of readdirSync){
+        const filePath = path + "/" + file;
+        let stat;
+        try {
+            stat = $7oI3p$fs.statSync(filePath);
+        } catch (e1) {
+            if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.error(`Error getting stat for ${filePath}`, e1);
+            continue;
+        }
+        if (stat.isDirectory()) {
+            if (filePath.split("/").length < rootSegments + maxDepth) try {
+                const subFiles = await $e62c2c56eb720f29$export$2c9faf86071156ae({
+                    path: filePath,
+                    name: name,
+                    maxDepth: 2
+                });
+                files.push(...subFiles);
+            } catch (e2) {
+                if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.error(e2);
+            }
+        } else if (file === name) files.push(filePath);
+    }
+    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) {
+        if (files.length > 0) {
+            console.log(`Found ${files.length} ${name} files`);
+            console.log(files);
+        }
+    }
+    return files;
+}
+
+
+
+
+
+
+
+async function $a085b524d8ee9fce$export$f19f611d1fa7c6f3({ file: file , sql: sql , rowTransform: rowTransform  }) {
+    if (!file || file && !$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)=>{
+        db.all(sql, (err, rows)=>{
+            if (err) {
+                reject(err);
+                return;
+            }
+            const rows1 = rows;
+            if (rows1 == null || rows1.length === 0) {
+                resolve([]);
+                return;
+            }
+            if (Array.isArray(rows1)) {
+                const cookieRows = rows1.map((row)=>{
+                    const newVar = {
+                        meta: {
+                            file: file
+                        }
+                    };
+                    const cookieRow = rowTransform(row);
+                    return (0, $7oI3p$lodash.merge)(newVar, cookieRow);
+                });
+                resolve(cookieRows);
+                return;
+            }
+            if (process.env.VERBOSE) console.log(`doSqliteQuery1: rows ${JSON.stringify(rows1)}`);
+            resolve([
+                rows1
+            ]);
+        });
+    });
+}
+
+
+
+function $af69dfb8766652d8$export$bc926c43858bd3cb(obj) {
+    return obj.domain !== undefined && obj.name !== undefined && obj.value !== undefined;
+}
+
+
+function $d66f40b581ba8bfa$export$963c8d651337e4a4(obj) {
+    return obj.domain !== undefined && obj.name !== undefined && obj.value !== undefined;
+}
+
+
+class $269fe42bfd555305$export$2e2bcd8739ae039 {
+    async queryCookies(name, domain) {
+        if (process.platform !== "darwin") throw new Error("This only works on macOS");
+        if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).FIREFOX_ONLY) return [];
+        return $269fe42bfd555305$var$getChromeCookies({
+            requireJwt: false,
+            name: name,
+            domain: domain
+        });
+    }
+}
+async function $269fe42bfd555305$var$getPromise1(name, domain, file) {
+    try {
+        return await $269fe42bfd555305$var$getEncryptedChromeCookie({
+            name: name,
+            domain: domain,
+            file: file
+        });
+    } catch (e) {
+        if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("Error getting encrypted cookie", e);
+        return [];
+    }
+}
+async function $269fe42bfd555305$var$getPromise(name, domain) {
+    try {
+        const files = await (0, $e62c2c56eb720f29$export$2c9faf86071156ae)({
+            path: $269fe42bfd555305$var$chromeLocal,
+            name: "Cookies"
+        });
+        const promises = files.map((file)=>$269fe42bfd555305$var$getPromise1(name, domain, file));
+        const results1 = await Promise.all(promises);
+        return results1.flat().filter((0, $af69dfb8766652d8$export$bc926c43858bd3cb));
+    } catch (error) {
+        if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("error", error);
+        return [];
+    }
+}
+async function $269fe42bfd555305$var$decryptValue(password, encryptedValue) {
+    let d;
+    try {
+        d = await $269fe42bfd555305$var$decrypt(password, encryptedValue);
+    } catch (e) {
+        if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("Error decrypting cookie", e);
+        d = null;
+    }
+    return d ?? encryptedValue.toString("utf-8");
+}
+async function $269fe42bfd555305$var$getChromeCookies({ name: name , domain: domain = "%" , requireJwt: requireJwt = false  }) {
+    const encryptedDataItems = await $269fe42bfd555305$var$getPromise(name, domain);
+    const password = await $269fe42bfd555305$var$getChromePassword();
+    const decrypted = encryptedDataItems.filter(({ value: value  })=>value != null && value.length > 0).map(async (cookieRow)=>{
+        const encryptedValue = cookieRow.value;
+        const decryptedValue = await $269fe42bfd555305$var$decryptValue(password, encryptedValue);
+        const meta = {};
+        (0, $7oI3p$lodash.merge)(meta, cookieRow.meta ?? {});
+        return {
+            domain: cookieRow.domain,
+            name: cookieRow.name,
+            value: decryptedValue,
+            meta: meta
+        };
+    });
+    const results = (await Promise.all(decrypted)).filter((0, $d66f40b581ba8bfa$export$963c8d651337e4a4));
+    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("results", results);
+    return results;
+}
+const $269fe42bfd555305$var$chromeLocal = $7oI3p$path.join((0, $fac425c10fbbada5$export$a7c5707626fc90f), "Library", "Application Support", "Google", "Chrome");
+async function $269fe42bfd555305$var$getEncryptedChromeCookie({ name: name , domain: domain , file: file = $7oI3p$path.join($269fe42bfd555305$var$chromeLocal, "Default", "Cookies")  }) {
+    if (!(0, $7oI3p$fs.existsSync)(file)) throw new Error(`File ${file} does not exist`);
+    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) {
+        const s = file.split("/").slice(-3).join("/");
+        console.log(`Trying Chrome (at ${s}) cookie ${name} for domain ${domain}`);
+    }
+    let sql;
+    //language=SQL
+    sql = "SELECT encrypted_value, name, host_key FROM cookies";
+    const wildcardRegexp = /^([*%])$/i;
+    const specifiedName = name.match(wildcardRegexp) == null;
+    const specifiedDomain = domain.match(wildcardRegexp) == null;
+    if (specifiedName || specifiedDomain) {
+        sql += ` WHERE `;
+        if (specifiedName) {
+            sql += `name = '${name}'`;
+            if (specifiedDomain) sql += ` AND `;
+        }
+        if (specifiedDomain) sql += `host_key LIKE '${domain}';`;
+    }
+    return (0, $a085b524d8ee9fce$export$f19f611d1fa7c6f3)({
+        file: file,
+        sql: sql,
+        rowTransform: (row)=>{
+            return {
+                domain: row["host_key"],
+                name: row["name"],
+                value: row["encrypted_value"]
+            };
+        }
+    });
+}
+async function $269fe42bfd555305$var$getChromePassword() {
+    return (0, $25b78d6746d4ad48$export$8d71c74f97c0202e)('security find-generic-password -w -s "Chrome Safe Storage"');
+}
+async function $269fe42bfd555305$var$decrypt(password, encryptedData) {
+    if (typeof password !== "string") throw new Error("password must be a string: " + password);
+    let encryptedData1;
+    encryptedData1 = encryptedData;
+    if (encryptedData1 == null || typeof encryptedData1 !== "object") throw new Error("encryptedData must be a object: " + encryptedData1);
+    if (!(encryptedData1 instanceof Buffer)) {
+        if (Array.isArray(encryptedData1) && encryptedData1[0] instanceof Buffer) {
+            [encryptedData1] = encryptedData1;
+            if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log(`encryptedData is an array of buffers, selected first: ${encryptedData1}`);
+        } else throw new Error("encryptedData must be a Buffer: " + encryptedData1);
+        encryptedData1 = Buffer.from(encryptedData1);
+    }
+    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log(`Trying to decrypt with password ${password}`);
+    return new Promise((resolve, reject)=>{
+        $7oI3p$crypto.pbkdf2(password, "saltysalt", 1003, 16, "sha1", (error, buffer)=>{
+            try {
+                if (error) {
+                    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("Error doing pbkdf2", error);
+                    reject(error);
+                    return;
+                }
+                if (buffer.length !== 16) {
+                    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("Error doing pbkdf2, buffer length is not 16", buffer.length);
+                    reject(new Error("Buffer length is not 16"));
+                    return;
+                }
+                const str = new Array(17).join(" ");
+                const iv = Buffer.from(str, "binary");
+                const decipher = $7oI3p$crypto.createDecipheriv("aes-128-cbc", buffer, iv);
+                decipher.setAutoPadding(false);
+                if (encryptedData1 && encryptedData1.slice) encryptedData1 = encryptedData1.slice(3);
+                if (encryptedData1.length % 16 !== 0) {
+                    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("Error doing pbkdf2, encryptedData length is not a multiple of 16", encryptedData1.length);
+                    reject(new Error("encryptedData length is not a multiple of 16"));
+                    return;
+                }
+                let decoded = decipher.update(encryptedData1);
+                try {
+                    decipher.final("utf-8");
+                } catch (e) {
+                    if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log("Error doing decipher.final()", e);
+                    reject(e);
+                    return;
+                }
+                const padding = decoded[decoded.length - 1];
+                if (padding) decoded = decoded.slice(0, 0 - padding);
+                // noinspection JSCheckFunctionSignatures
+                const decodedString = decoded.toString("utf8");
+                resolve(decodedString);
+            } catch (e1) {
+                reject(e1);
+            }
+        });
+    });
+}
+
+
+
+
+
+
+
+function $b744d19cc39f964e$export$da22813e5a2ec500({ name: name , domain: domain  }) {
+    const wildcardRegexp = /^([*%])$/i;
+    return {
+        specifiedName: name.match(wildcardRegexp) == null,
+        specifiedDomain: domain.match(wildcardRegexp) == null
+    };
+}
+
+
+class $7bb7da9a77b2fd99$export$2e2bcd8739ae039 {
+    async queryCookies(name, domain) {
+        if (process.platform !== "darwin") throw new Error("This only works on macOS");
+        if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).CHROME_ONLY) return [];
+        const cookies = await this.#getFirefoxCookie({
+            name: name,
+            domain: domain
+        });
+        if (Array.isArray(cookies)) return cookies.map((cookie)=>{
+            return {
+                domain: cookie.domain,
+                name: cookie.name,
+                value: cookie.value.toString("utf8")
+            };
+        });
+        else return [];
+    }
+    async #getFirefoxCookie({ name: name , domain: domain  } //
+    ) {
+        const files = await (0, $e62c2c56eb720f29$export$2c9faf86071156ae)({
+            path: $7oI3p$path.join((0, $fac425c10fbbada5$export$a7c5707626fc90f), "Library", "Application Support", "Firefox", "Profiles"),
+            name: "cookies.sqlite"
+        });
+        const fn = async (file)=>{
+            return await this.#queryCookiesDb(file, name, domain);
+        };
+        const all = await Promise.all(files.map(fn));
+        return all.flat();
+    }
+    async #queryCookiesDb(file, name1, domain1) {
+        if (file && !(0, $7oI3p$fs.existsSync)(file)) throw new Error(`File ${file} does not exist`);
+        let sql;
+        //language=SQL
+        sql = "SELECT value, name, host FROM moz_cookies";
+        const { specifiedName: specifiedName , specifiedDomain: specifiedDomain  } = (0, $b744d19cc39f964e$export$da22813e5a2ec500)({
+            name: name1,
+            domain: domain1
+        });
+        if (specifiedName || specifiedDomain) {
+            sql += ` WHERE `;
+            if (specifiedName) {
+                sql += `name = '${name1}'`;
+                if (specifiedDomain) sql += ` AND `;
+            }
+            if (specifiedDomain) sql += `host LIKE '${domain1}';`;
+        }
+        const rowTransform = (row)=>{
+            // row is object key by column name
+            const value = row.value;
+            return {
+                domain: row.domain,
+                name: row.name,
+                value: Buffer.from(value, "utf8")
+            };
+        };
+        try {
+            return await (0, $a085b524d8ee9fce$export$f19f611d1fa7c6f3)({
+                file: file,
+                sql: sql,
+                rowTransform: rowTransform
+            });
+        } catch (e) {
+            console.error(`Error querying ${file}`, e);
+            return [];
+        }
+    }
+}
+
+
+class $fad6f51bd5c7bae2$export$2e2bcd8739ae039 {
+    async queryCookies(name, domain) {
+        return [];
+    }
+}
+
+
+
+const $f72befa528c23ca7$var$cache = new (0, ($parcel$interopDefault($7oI3p$lrucache)))({
+    ttl: 2000,
+    max: 10
+});
+class $f72befa528c23ca7$export$2e2bcd8739ae039 {
+    #strategies;
+    constructor(){
+        this.#strategies = [
+            (0, $269fe42bfd555305$export$2e2bcd8739ae039),
+            (0, $7bb7da9a77b2fd99$export$2e2bcd8739ae039),
+            (0, $fad6f51bd5c7bae2$export$2e2bcd8739ae039), 
+        ].map((strategy)=>{
+            return new strategy();
+        });
+    }
+    async queryCookies(name, domain) {
+        const key = `${name}:${domain}`;
+        const cached = $f72befa528c23ca7$var$cache.get(key);
+        if (cached) return cached;
+        const results = await Promise.all(this.#strategies.map(async (strategy)=>{
+            // @ts-ignore
+            const cookies = strategy.queryCookies(name, domain);
+            return cookies.catch(()=>[]);
+        }));
+        const flat = results.flat();
+        $f72befa528c23ca7$var$cache.set(`${name}:${domain}`, flat);
+        return flat;
+    }
+}
+
+
+
+
+function $9a6b2ace073cf1d7$export$2e2bcd8739ae039(token) {
+    try {
+        const result = (0, ($parcel$interopDefault($7oI3p$jsonwebtoken))).decode(token, {
+            complete: true
+        });
+        if ((0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).VERBOSE) console.log(result);
+        const payload = result?.payload;
+        if (payload) {
+            const exp = payload.exp;
+            if (exp) {
+                const now = new Date().getTime() / 1000;
+                if (now > exp) return false;
+            }
+        }
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+
+
+async function $7a068a32d4710f0b$export$e6d428437cf2cacb({ name: name , domain: domain  }, strategy = new (0, $f72befa528c23ca7$export$2e2bcd8739ae039)()) {
+    const results = await strategy.queryCookies(name, domain);
+    const results1 = (0, $7oI3p$lodash.uniqBy)(results, JSON.stringify);
+    const jwtCookies = [];
+    for (const result of results1){
+        const value = result.value;
+        if ((0, $9a6b2ace073cf1d7$export$2e2bcd8739ae039)(value)) jwtCookies.push(result);
+    }
+    const resultsUniq = (0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).REQUIRE_JWT ? jwtCookies : results1;
+    return (0, $fac425c10fbbada5$export$a7b6bc01c63cdfc3).SINGLE ? [
+        resultsUniq[0]
+    ] : resultsUniq;
+}
+
+
+
+
+
+
+
+
+
+function $9c43c2ed82e63570$export$9abc0a414b0d8b8f(results) {
+    return (0, $7oI3p$lodash.uniqBy)(results, (r)=>r.name).map((r)=>r.name + "=" + r.value).join("; ");
+}
+
+
+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)());
+    if (Array.isArray(cookies) && cookies.length > 0) {
+        const results = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)({
+            name: name,
+            domain: domain
+        });
+        const groupedByFile = (0, $7oI3p$lodash.groupBy)(results, (r)=>r.meta?.file);
+        return Object.keys(groupedByFile).map((file)=>{
+            const results = groupedByFile[file];
+            return (0, $9c43c2ed82e63570$export$9abc0a414b0d8b8f)(results);
+        });
+    } else throw new Error("Cookie not found");
+}
+
+
+
+
+
+
+async function $cfc07ae4aa2c7e44$export$b24a545a0b39f491(url, options = {}) {
+    const defaultOptions = {
+        headers: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
+        },
+        redirect: "manual"
+    };
+    const url2 = `${url}`;
+    const url1 = new URL(url2);
+    const domain = url1.hostname.replace(/^.*(\.\w+\.\w+)$/, (match, p1)=>{
+        return `%${p1}`;
+    });
+    const cookies = await (0, $300d8b33187a203c$export$4d2e9997e2c23417)({
+        name: "%",
+        domain: domain
+    });
+    const cookie = cookies.pop();
+    const newOptions1 = (0, $7oI3p$lodash.merge)(defaultOptions, options, {
+        headers: {
+            Cookie: cookie
+        }
+    });
+    try {
+        const res = await (0, $7oI3p$crossfetch.fetch)(url2, newOptions1);
+        const newUrl = res.headers.get("location");
+        if (res.redirected || newUrl && newUrl !== url2) return $cfc07ae4aa2c7e44$export$b24a545a0b39f491(newUrl, newOptions1);
+        const arrayBuffer1 = res.arrayBuffer();
+        const arrayBuffer = async ()=>arrayBuffer1;
+        const buffer = async ()=>arrayBuffer().then(Buffer.from);
+        const text = async ()=>buffer().then((buffer)=>buffer.toString("utf8"));
+        const json = async ()=>text().then((0, ($parcel$interopDefault($7oI3p$destr))));
+        const formData = async ()=>text().then((text)=>new URLSearchParams(text));
+        const source2 = {
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+            arrayBuffer: arrayBuffer,
+            buffer: buffer,
+            text: text,
+            json: json,
+            formData: formData
+        };
+        return (0, $7oI3p$lodash.merge)({}, res, source2);
+    } catch (e) {
+        throw e;
+    }
+}
+
+
+var $d5b6386167d289d2$exports = {};
+
+
+var $3d7e27b54f670f46$exports = {};
+
+
+var $6c197c88880e045c$exports = {};
+
+
+async function $cd1ba0160120c006$export$4be65e66cfa2648a(params) {
+    const cookies = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)(params, new (0, $f72befa528c23ca7$export$2e2bcd8739ae039)());
+    if (Array.isArray(cookies) && cookies.length > 0) return cookies.find((cookie)=>cookie != null);
+    else throw new Error("Cookie not found");
+}
+async function $cd1ba0160120c006$export$c44c5fdef43f0941(params) {
+    const cookies = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)(params, new (0, $7bb7da9a77b2fd99$export$2e2bcd8739ae039)());
+    if (Array.isArray(cookies) && cookies.length > 0) return cookies.find((cookie)=>cookie != null);
+    else throw new Error("Cookie not found");
+}
+async function $cd1ba0160120c006$export$e5637297e9eb6f2e(params) {
+    const cookies = await (0, $7a068a32d4710f0b$export$e6d428437cf2cacb)(params, new (0, $269fe42bfd555305$export$2e2bcd8739ae039)());
+    if (Array.isArray(cookies) && cookies.length > 0) return cookies.find((cookie)=>cookie != null);
+    else throw new Error("Cookie not found");
+}
+$parcel$exportWildcard(module.exports, $d5b6386167d289d2$exports);
+$parcel$exportWildcard(module.exports, $3d7e27b54f670f46$exports);
+$parcel$exportWildcard(module.exports, $6c197c88880e045c$exports);
+
+
 //# sourceMappingURL=index.js.map