@mherod/get-cookie 2.1.0 → 2.1.2

package/dist/types.d.ts

@@ -1,30 +1,361 @@
-import { fetch } from "cross-fetch";
-interface CookieSpec {
-    domain: string;
-    name: string;
-}
-type MultiCookieSpec = CookieSpec | CookieSpec[];
-interface ExportedCookie {
-    domain: string;
-    name: string;
-    value: string;
-    expiry?: Date | "Infinity";
-    meta?: any;
-}
-interface CookieQueryStrategy {
-    browserName: string;
-    queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
-}
-export function getCookie(params: CookieSpec): Promise<ExportedCookie | undefined>;
-export function getChromeCookie(params: CookieSpec): Promise<ExportedCookie | undefined>;
-export function getFirefoxCookie(params: CookieSpec): Promise<ExportedCookie | undefined>;
-export function getGroupedRenderedCookies(cookieSpec: MultiCookieSpec): Promise<string[]>;
-export function getMergedRenderedCookies(cookieSpec: MultiCookieSpec, strategy?: CookieQueryStrategy): Promise<string>;
-interface FetchRequestInit {
-    url: RequestInfo | URL | string;
-    options?: RequestInit;
-}
-type FetchFn = typeof fetch | ((url: URL, options?: RequestInit) => Promise<Response>);
-export function fetchWithCookies(url: RequestInfo | URL | string, options?: RequestInit | undefined, fetch?: FetchFn, originalRequest?: FetchRequestInit): Promise<Response>;
-
-//# sourceMappingURL=types.d.ts.map
+#!/usr/bin/env bun
+/// <reference types="node" />
+declare module "logger" {
+    const consola: import("consola/dist/core").ConsolaInstance;
+    export default consola;
+}
+declare module "CookieRow" {
+    /**
+     * The CookieRow interface represents the structure of a cookie row object.
+     */
+    export default interface CookieRow {
+        expiry?: number;
+        domain: string;
+        name: string;
+        value: Uint8Array | Buffer;
+        meta?: Record<string, unknown>;
+    }
+    /**
+     * Type guard to check if an object is a CookieRow.
+     * @param obj - The object to check.
+     * @returns True if the object is a CookieRow, false otherwise.
+     */
+    export function isCookieRow(obj: any): obj is CookieRow;
+}
+declare module "CookieSpec" {
+    /**
+     * Define the CookieSpec interface with domain and name properties
+     */
+    export default interface CookieSpec {
+        domain: string;
+        name: string;
+    }
+    /**
+     * Function to check if an object is of type CookieSpec
+     * @param obj - The object to check
+     * @returns True if the object is of type CookieSpec, otherwise false
+     */
+    export function isCookieSpec(obj: unknown): obj is CookieSpec;
+    /**
+     * Define a type that can be either a single CookieSpec or an array of CookieSpecs
+     */
+    export type MultiCookieSpec = CookieSpec | CookieSpec[];
+    /**
+     * Function to check if an object is of type MultiCookieSpec
+     * @param obj - The object to check
+     * @returns True if the object is of type MultiCookieSpec, otherwise false
+     */
+    export function isMultiCookieSpec(obj: unknown): obj is MultiCookieSpec;
+}
+declare module "ExportedCookie" {
+    export default interface ExportedCookie {
+        domain: string;
+        name: string;
+        value: string;
+        expiry?: Date | "Infinity";
+        meta?: any;
+    }
+    export function isExportedCookie(obj: any): obj is ExportedCookie;
+}
+declare module "FetchResponse" {
+    export default interface FetchResponse {
+        status: number;
+        statusText: string;
+        headers: Headers;
+        url: string;
+        text: () => Promise<string>;
+        json: () => Promise<any>;
+        formData: () => Promise<URLSearchParams>;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+        buffer: () => Promise<Buffer>;
+    }
+}
+declare module "SpecialCases" {
+    import CookieSpec from "CookieSpec";
+    export function specialCases({ name, domain }: CookieSpec): {
+        specifiedName: boolean;
+        specifiedDomain: boolean;
+    };
+}
+declare module "StringToRegex" {
+    export function stringToRegex(s: string): RegExp;
+}
+declare module "argv" {
+    import minimist from "minimist";
+    export interface MyParsedArgs extends minimist.ParsedArgs {
+        verbose: boolean;
+        render?: string;
+        fetch?: string;
+        cs?: string;
+        dump?: string;
+        "dump-request-headers"?: string;
+        "dump-response-headers"?: string;
+        "dump-response-body"?: string;
+    }
+    export const argv: string[];
+    export const parsedArgs: MyParsedArgs;
+}
+declare module "resultsRendered" {
+    import ExportedCookie from "ExportedCookie";
+    export function resultsRendered(results: ExportedCookie[]): string;
+}
+declare module "browsers/CookieQueryStrategy" {
+    import ExportedCookie from "ExportedCookie";
+    export default interface CookieQueryStrategy {
+        browserName: string;
+        queryCookies(name: string, domain: string): Promise<Array<ExportedCookie>>;
+    }
+}
+declare module "global" {
+    export const env: {
+        [key: string]: string | undefined;
+    };
+    export const HOME: string | undefined;
+}
+declare module "browsers/chrome/ChromeApplicationSupport" {
+    export const chromeApplicationSupport: string;
+}
+declare module "browsers/chrome/decrypt" {
+    interface Decryptor {
+        decrypt(password: string, encryptedData: Buffer): Promise<string>;
+    }
+    export const decryptor: Decryptor;
+    export function decrypt(password: string, encryptedData: Buffer): Promise<string>;
+}
+declare module "findAllFiles" {
+    type FindFilesOptions = {
+        path: string;
+        name: string;
+        maxDepth?: number;
+    };
+    /**
+     * Finds all files matching the specified name within a given path and depth.
+     *
+     * @param {FindFilesOptions} options - The options for finding files.
+     * @param {string} options.path - The path to search within.
+     * @param {string} options.name - The name of the files to search for.
+     * @param {number} [options.maxDepth=2] - The maximum depth to search within.
+     * @returns {string[]} An array of file paths that match the search criteria.
+     * @throws Will throw an error if the specified path does not exist.
+     */
+    export function findAllFiles({ path, name, maxDepth, }: FindFilesOptions): string[];
+}
+declare module "execSimple" {
+    export function execSimple(command: string): Promise<string>;
+}
+declare module "browsers/chrome/getChromePassword" {
+    export function getChromePassword(): Promise<string>;
+}
+declare module "util/flatMapAsync" {
+    export function flatMapAsync<T, O>(array: T[], // The input array to transform.
+    callback: (value: T, index: number, array: T[]) => Promise<O[]>, // The async function to apply to each input array element.
+    or?: O[] | ((error: any) => O[] | Promise<O[]>)): Promise<O[]>;
+}
+declare module "browsers/QuerySqliteThenTransform" {
+    import CookieRow from "CookieRow";
+    interface FnOptions {
+        file: string;
+        sql: string;
+        rowFilter?: (row: any) => boolean;
+        rowTransform: (row: any) => CookieRow;
+    }
+    export function querySqliteThenTransform({ file, sql, rowFilter, rowTransform, }: FnOptions): Promise<CookieRow[]>;
+}
+declare module "browsers/getEncryptedChromeCookie" {
+    import CookieRow from "CookieRow";
+    interface GetEncryptedChromeCookieParams {
+        name: string;
+        domain: string;
+        file?: string;
+    }
+    export function getEncryptedChromeCookie({ name, domain, file, }: GetEncryptedChromeCookieParams): Promise<CookieRow[]>;
+}
+declare module "browsers/chrome/ChromeCookieQueryStrategy" {
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    import ExportedCookie from "ExportedCookie";
+    export const consola: import("consola/dist/core").ConsolaInstance;
+    export default class ChromeCookieQueryStrategy implements CookieQueryStrategy {
+        browserName: string;
+        queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
+        private ensurePlatformIsMacOS;
+        private getChromeCookies;
+        private getEncryptedCookies;
+        private getCookiesFromFile;
+        private decryptCookies;
+        private decryptValue;
+        private createExportedCookie;
+    }
+}
+declare module "browsers/firefox/FirefoxCookieQueryStrategy" {
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    import ExportedCookie from "ExportedCookie";
+    export default class FirefoxCookieQueryStrategy implements CookieQueryStrategy {
+        browserName: string;
+        queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
+        private getFirefoxCookie;
+        private queryCookiesDb;
+    }
+}
+declare module "decodeBinaryCookies" {
+    import CookieRow from "CookieRow";
+    export const decodeBinaryCookies: (cookieDbPath: string) => Promise<CookieRow[]>;
+}
+declare module "browsers/safari/SafariCookieQueryStrategy" {
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    import ExportedCookie from "ExportedCookie";
+    export default class SafariCookieQueryStrategy implements CookieQueryStrategy {
+        browserName: string;
+        queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
+    }
+}
+declare module "browsers/CompositeCookieQueryStrategy" {
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    import ExportedCookie from "ExportedCookie";
+    export default class CompositeCookieQueryStrategy implements CookieQueryStrategy {
+        browserName: string;
+        private readonly strategies;
+        constructor();
+        queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
+    }
+}
+declare module "isValidJwt" {
+    export default function isValidJwt(token: string): boolean;
+}
+declare module "cookieQueryOptions" {
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    export type CookieQueryOptions<T extends CookieQueryStrategy> = {
+        strategy?: T;
+        limit?: number;
+        removeExpired?: boolean;
+    };
+    export const defaultCookieQueryOptions: CookieQueryOptions<CookieQueryStrategy>;
+    export function mergedWithDefaults<T extends CookieQueryStrategy>(options?: CookieQueryOptions<T>): CookieQueryOptions<T>;
+}
+declare module "queryCookies" {
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    import CookieSpec from "CookieSpec";
+    import ExportedCookie from "ExportedCookie";
+    import { CookieQueryOptions } from "cookieQueryOptions";
+    export function queryCookies({ name, domain }: CookieSpec, options?: CookieQueryOptions<CookieQueryStrategy>): Promise<ExportedCookie[]>;
+}
+declare module "util/index" {
+    export * from "util/flatMapAsync";
+}
+declare module "processBeforeReturn" {
+    import ExportedCookie from "ExportedCookie";
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    import { CookieQueryOptions } from "cookieQueryOptions";
+    export function processBeforeReturn<T extends CookieQueryStrategy>(cookies: ExportedCookie[], options?: CookieQueryOptions<T>): ExportedCookie[];
+}
+declare module "comboQueryCookieSpec" {
+    import { MultiCookieSpec } from "CookieSpec";
+    import ExportedCookie from "ExportedCookie";
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    import { CookieQueryOptions } from "cookieQueryOptions";
+    export function comboQueryCookieSpec(cookieSpec: MultiCookieSpec, options?: CookieQueryOptions<CookieQueryStrategy>): Promise<ExportedCookie[]>;
+}
+declare module "getMergedRenderedCookies" {
+    import { MultiCookieSpec } from "CookieSpec";
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    export function getMergedRenderedCookies(cookieSpec: MultiCookieSpec, strategy?: CookieQueryStrategy): Promise<string>;
+}
+declare module "cookieSpecsFromUrl" {
+    import CookieSpec from "CookieSpec";
+    /**
+     * Generates a list of cookie specifications from a given URL.
+     * Each cookie spec consists of a domain and a name, where the name is a wildcard.
+     * The domain is formatted to enable querying against the cookie store for matching cookies.
+     * @param url - The URL to generate cookie specs from.
+     * @returns An array of unique cookie specifications.
+     */
+    export function cookieSpecsFromUrl(url: URL | string): CookieSpec[];
+}
+declare module "fetchWithCookies" {
+    import { fetch as fetchImpl } from "cross-fetch";
+    interface FetchRequestInit {
+        url: RequestInfo | URL | string;
+        options?: RequestInit;
+    }
+    export type FetchFn = typeof fetchImpl | ((url: URL, options?: RequestInit) => Promise<Response>);
+    /**
+     * Fetches a URL with cookies.
+     * @param url - The URL to fetch.
+     * @param options - The request options.
+     * @param fetch - The fetch function to use.
+     * @param originalRequest - The original request information.
+     * @returns A promise that resolves to the response.
+     */
+    export function fetchWithCookies(url: RequestInfo | URL | string, options?: RequestInit | undefined, fetch?: FetchFn, originalRequest?: FetchRequestInit): Promise<Response>;
+}
+declare module "unpackHeaders" {
+    export function unpackHeaders(headerArgs: string[] | string | null): Record<string, string>;
+}
+declare module "cliQueryCookies" {
+    import CookieSpec from "CookieSpec";
+    export function cliQueryCookies(cookieSpec: CookieSpec | CookieSpec[], limit?: number, removeExpired?: boolean): Promise<void>;
+}
+declare module "cli" { }
+declare module "browsers/mock/MockCookieQueryStrategy" {
+    import ExportedCookie from "ExportedCookie";
+    import CookieQueryStrategy from "browsers/CookieQueryStrategy";
+    export default class MockCookieQueryStrategy implements CookieQueryStrategy {
+        browserName: string;
+        private cookies;
+        constructor(cookies: ExportedCookie[]);
+        queryCookies(name: string, domain: string): Promise<ExportedCookie[]>;
+    }
+}
+declare module "comboQueryCookieSpec.test" { }
+declare module "cookieSpecsFromUrl.test" { }
+declare module "fetchWithCookies.test" { }
+declare module "getChromeCookie" {
+    import CookieSpec from "CookieSpec";
+    import ExportedCookie from "ExportedCookie";
+    export function getChromeCookie(params: CookieSpec): Promise<ExportedCookie | undefined>;
+}
+declare module "getCookie" {
+    import CookieSpec from "CookieSpec";
+    import ExportedCookie from "ExportedCookie";
+    export function getCookie(params: CookieSpec): Promise<ExportedCookie | undefined>;
+    export default getCookie;
+}
+declare module "getFirefoxCookie" {
+    import CookieSpec from "CookieSpec";
+    import ExportedCookie from "ExportedCookie";
+    export function getFirefoxCookie(params: CookieSpec): Promise<ExportedCookie | undefined>;
+}
+declare module "getGroupedRenderedCookies" {
+    import { MultiCookieSpec } from "CookieSpec";
+    export function getGroupedRenderedCookies(cookieSpec: MultiCookieSpec): Promise<string[]>;
+}
+declare module "getMergedRenderedCookies.test" { }
+declare module "index" {
+    const getCookie: () => Promise<typeof import("getCookie").getCookie>;
+    const getChromeCookie: () => Promise<typeof import("getChromeCookie").getChromeCookie>;
+    const getFirefoxCookie: () => Promise<typeof import("getFirefoxCookie").getFirefoxCookie>;
+    const getGroupedRenderedCookies: () => Promise<typeof import("getGroupedRenderedCookies").getGroupedRenderedCookies>;
+    const getMergedRenderedCookies: () => Promise<typeof import("getMergedRenderedCookies").getMergedRenderedCookies>;
+    const fetchWithCookies: () => Promise<typeof import("fetchWithCookies").fetchWithCookies>;
+    export { getCookie, getChromeCookie, getFirefoxCookie, getMergedRenderedCookies, getGroupedRenderedCookies, fetchWithCookies, };
+}
+declare module "listChromeProfiles" {
+    export function listChromeProfilePaths(): Promise<string[]>;
+    export function listChromeProfiles(): Promise<ChromeProfile[]>;
+    export type ChromeProfileAccountInfo = {
+        account_id: string;
+        accountcapabilities: any;
+        email: string;
+        full_name: string;
+        gaia: string;
+        given_name: string;
+        hd: string;
+        is_supervised_child: number;
+        is_under_advanced_protection: boolean;
+        last_downloaded_image_url_with_size: string;
+        locale: string;
+        picture_url: string;
+    };
+    export type ChromeProfile = {
+        account_info: ChromeProfileAccountInfo[];
+    };
+}