@ardennguyen/zalo-agent-cli 1.0.7 → 2.1.0

package/node_modules/tough-cookie/dist/memstore.d.ts

@@ -0,0 +1,220 @@
+import type { Cookie } from './cookie/cookie';
+import { Store } from './store';
+import { Callback, ErrorCallback, Nullable } from './utils';
+/**
+ * The internal structure used in {@link MemoryCookieStore}.
+ * @internal
+ */
+export type MemoryCookieStoreIndex = {
+    [domain: string]: {
+        [path: string]: {
+            [key: string]: Cookie;
+        };
+    };
+};
+/**
+ * An in-memory {@link Store} implementation for {@link CookieJar}. This is the default implementation used by
+ * {@link CookieJar} and supports both async and sync operations. Also supports serialization, getAllCookies, and removeAllCookies.
+ * @public
+ */
+export declare class MemoryCookieStore extends Store {
+    /**
+     * This value is `true` since {@link MemoryCookieStore} implements synchronous functionality.
+     */
+    synchronous: boolean;
+    /**
+     * @internal
+     */
+    idx: MemoryCookieStoreIndex;
+    /**
+     * Create a new {@link MemoryCookieStore}.
+     */
+    constructor();
+    /**
+     * Retrieve a {@link Cookie} with the given `domain`, `path`, and `key` (`name`). The RFC maintains that exactly
+     * one of these cookies should exist in a store. If the store is using versioning, this means that the latest or
+     * newest such cookie should be returned.
+     *
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     * @param key - The cookie name to match against.
+     */
+    findCookie(domain: Nullable<string>, path: Nullable<string>, key: Nullable<string>): Promise<Cookie | undefined>;
+    /**
+     * Retrieve a {@link Cookie} with the given `domain`, `path`, and `key` (`name`). The RFC maintains that exactly
+     * one of these cookies should exist in a store. If the store is using versioning, this means that the latest or
+     * newest such cookie should be returned.
+     *
+     * Callback takes an error and the resulting Cookie object. If no cookie is found then null MUST be passed instead (that is, not an error).
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     * @param key - The cookie name to match against.
+     * @param callback - A function to call with either the found cookie or an error.
+     */
+    findCookie(domain: Nullable<string>, path: Nullable<string>, key: Nullable<string>, callback: Callback<Cookie | undefined>): void;
+    /**
+     * Locates all {@link Cookie} values matching the given `domain` and `path`.
+     *
+     * The resulting list is checked for applicability to the current request according to the RFC (`domain-match`, `path-match`,
+     * `http-only-flag`, `secure-flag`, `expiry`, and so on), so it's OK to use an optimistic search algorithm when implementing
+     * this method. However, the search algorithm used SHOULD try to find cookies that {@link domainMatch} the `domain` and
+     * {@link pathMatch} the `path` in order to limit the amount of checking that needs to be done.
+     *
+     * @remarks
+     * - As of version `0.9.12`, the `allPaths` option to cookiejar.getCookies() above causes the path here to be `null`.
+     *
+     * - If the `path` is `null`, `path-matching` MUST NOT be performed (that is, `domain-matching` only).
+     *
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     * @param allowSpecialUseDomain - If `true` then special-use domain suffixes, will be allowed in matches. Defaults to `false`.
+     */
+    findCookies(domain: string, path: string, allowSpecialUseDomain?: boolean): Promise<Cookie[]>;
+    /**
+     * Locates all {@link Cookie} values matching the given `domain` and `path`.
+     *
+     * The resulting list is checked for applicability to the current request according to the RFC (`domain-match`, `path-match`,
+     * `http-only-flag`, `secure-flag`, `expiry`, and so on), so it's OK to use an optimistic search algorithm when implementing
+     * this method. However, the search algorithm used SHOULD try to find cookies that {@link domainMatch} the `domain` and
+     * {@link pathMatch} the `path` in order to limit the amount of checking that needs to be done.
+     *
+     * @remarks
+     * - As of version `0.9.12`, the `allPaths` option to cookiejar.getCookies() above causes the path here to be `null`.
+     *
+     * - If the `path` is `null`, `path-matching` MUST NOT be performed (that is, `domain-matching` only).
+     *
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     * @param allowSpecialUseDomain - If `true` then special-use domain suffixes, will be allowed in matches. Defaults to `false`.
+     * @param callback - A function to call with either the found cookies or an error.
+     */
+    findCookies(domain: string, path: string, allowSpecialUseDomain?: boolean, callback?: Callback<Cookie[]>): void;
+    /**
+     * Adds a new {@link Cookie} to the store. The implementation SHOULD replace any existing cookie with the same `domain`,
+     * `path`, and `key` properties.
+     *
+     * @remarks
+     * - Depending on the nature of the implementation, it's possible that between the call to `fetchCookie` and `putCookie`
+     * that a duplicate `putCookie` can occur.
+     *
+     * - The {@link Cookie} object MUST NOT be modified; as the caller has already updated the `creation` and `lastAccessed` properties.
+     *
+     * @param cookie - The cookie to store.
+     */
+    putCookie(cookie: Cookie): Promise<void>;
+    /**
+     * Adds a new {@link Cookie} to the store. The implementation SHOULD replace any existing cookie with the same `domain`,
+     * `path`, and `key` properties.
+     *
+     * @remarks
+     * - Depending on the nature of the implementation, it's possible that between the call to `fetchCookie` and `putCookie`
+     * that a duplicate `putCookie` can occur.
+     *
+     * - The {@link Cookie} object MUST NOT be modified; as the caller has already updated the `creation` and `lastAccessed` properties.
+     *
+     * @param cookie - The cookie to store.
+     * @param callback - A function to call when the cookie has been stored or an error has occurred.
+     */
+    putCookie(cookie: Cookie, callback: ErrorCallback): void;
+    /**
+     * Update an existing {@link Cookie}. The implementation MUST update the `value` for a cookie with the same `domain`,
+     * `path`, and `key`. The implementation SHOULD check that the old value in the store is equivalent to oldCookie -
+     * how the conflict is resolved is up to the store.
+     *
+     * @remarks
+     * - The `lastAccessed` property is always different between the two objects (to the precision possible via JavaScript's clock).
+     *
+     * - Both `creation` and `creationIndex` are guaranteed to be the same.
+     *
+     * - Stores MAY ignore or defer the `lastAccessed` change at the cost of affecting how cookies are selected for automatic deletion.
+     *
+     * - Stores may wish to optimize changing the `value` of the cookie in the store versus storing a new cookie.
+     *
+     * - The `newCookie` and `oldCookie` objects MUST NOT be modified.
+     *
+     * @param oldCookie - the cookie that is already present in the store.
+     * @param newCookie - the cookie to replace the one already present in the store.
+     */
+    updateCookie(oldCookie: Cookie, newCookie: Cookie): Promise<void>;
+    /**
+     * Update an existing {@link Cookie}. The implementation MUST update the `value` for a cookie with the same `domain`,
+     * `path`, and `key`. The implementation SHOULD check that the old value in the store is equivalent to oldCookie -
+     * how the conflict is resolved is up to the store.
+     *
+     * @remarks
+     * - The `lastAccessed` property is always different between the two objects (to the precision possible via JavaScript's clock).
+     *
+     * - Both `creation` and `creationIndex` are guaranteed to be the same.
+     *
+     * - Stores MAY ignore or defer the `lastAccessed` change at the cost of affecting how cookies are selected for automatic deletion.
+     *
+     * - Stores may wish to optimize changing the `value` of the cookie in the store versus storing a new cookie.
+     *
+     * - The `newCookie` and `oldCookie` objects MUST NOT be modified.
+     *
+     * @param oldCookie - the cookie that is already present in the store.
+     * @param newCookie - the cookie to replace the one already present in the store.
+     * @param callback - A function to call when the cookie has been updated or an error has occurred.
+     */
+    updateCookie(oldCookie: Cookie, newCookie: Cookie, callback: ErrorCallback): void;
+    /**
+     * Remove a cookie from the store (see notes on `findCookie` about the uniqueness constraint).
+     *
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     * @param key - The cookie name to match against.
+     */
+    removeCookie(domain: string, path: string, key: string): Promise<void>;
+    /**
+     * Remove a cookie from the store (see notes on `findCookie` about the uniqueness constraint).
+     *
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     * @param key - The cookie name to match against.
+     * @param callback - A function to call when the cookie has been removed or an error occurs.
+     */
+    removeCookie(domain: string, path: string, key: string, callback: ErrorCallback): void;
+    /**
+     * Removes matching cookies from the store. The `path` parameter is optional and if missing,
+     * means all paths in a domain should be removed.
+     *
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     */
+    removeCookies(domain: string, path: string): Promise<void>;
+    /**
+     * Removes matching cookies from the store. The `path` parameter is optional and if missing,
+     * means all paths in a domain should be removed.
+     *
+     * @param domain - The cookie domain to match against.
+     * @param path - The cookie path to match against.
+     * @param callback - A function to call when the cookies have been removed or an error occurs.
+     */
+    removeCookies(domain: string, path: string, callback: ErrorCallback): void;
+    /**
+     * Removes all cookies from the store.
+     */
+    removeAllCookies(): Promise<void>;
+    /**
+     * Removes all cookies from the store.
+     *
+     * @param callback - A function to call when all the cookies have been removed or an error occurs.
+     */
+    removeAllCookies(callback: ErrorCallback): void;
+    /**
+     * Gets all the cookies in the store.
+     *
+     * @remarks
+     * - Cookies SHOULD be returned in creation order to preserve sorting via {@link cookieCompare}.
+     */
+    getAllCookies(): Promise<Cookie[]>;
+    /**
+     * Gets all the cookies in the store.
+     *
+     * @remarks
+     * - Cookies SHOULD be returned in creation order to preserve sorting via {@link cookieCompare}.
+     *
+     * @param callback - A function to call when all the cookies have been retrieved or an error occurs.
+     */
+    getAllCookies(callback: Callback<Cookie[]>): void;
+}

package/node_modules/tough-cookie/dist/memstore.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCookieStore = void 0;
+const pathMatch_1 = require("./pathMatch");
+const permuteDomain_1 = require("./permuteDomain");
+const store_1 = require("./store");
+const utils_1 = require("./utils");
+/**
+ * An in-memory {@link Store} implementation for {@link CookieJar}. This is the default implementation used by
+ * {@link CookieJar} and supports both async and sync operations. Also supports serialization, getAllCookies, and removeAllCookies.
+ * @public
+ */
+class MemoryCookieStore extends store_1.Store {
+    /**
+     * Create a new {@link MemoryCookieStore}.
+     */
+    constructor() {
+        super();
+        this.synchronous = true;
+        this.idx = Object.create(null);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    findCookie(domain, path, key, callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(callback);
+        if (domain == null || path == null || key == null) {
+            return promiseCallback.resolve(undefined);
+        }
+        const result = this.idx[domain]?.[path]?.[key];
+        return promiseCallback.resolve(result);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    findCookies(domain, path, allowSpecialUseDomain = false, callback) {
+        if (typeof allowSpecialUseDomain === 'function') {
+            callback = allowSpecialUseDomain;
+            // TODO: It's weird that `allowSpecialUseDomain` defaults to false with no callback,
+            // but true with a callback. This is legacy behavior from v4.
+            allowSpecialUseDomain = true;
+        }
+        const results = [];
+        const promiseCallback = (0, utils_1.createPromiseCallback)(callback);
+        if (!domain) {
+            return promiseCallback.resolve([]);
+        }
+        let pathMatcher;
+        if (!path) {
+            // null means "all paths"
+            pathMatcher = function matchAll(domainIndex) {
+                for (const curPath in domainIndex) {
+                    const pathIndex = domainIndex[curPath];
+                    for (const key in pathIndex) {
+                        const value = pathIndex[key];
+                        if (value) {
+                            results.push(value);
+                        }
+                    }
+                }
+            };
+        }
+        else {
+            pathMatcher = function matchRFC(domainIndex) {
+                //NOTE: we should use path-match algorithm from S5.1.4 here
+                //(see : https://github.com/ChromiumWebApps/chromium/blob/b3d3b4da8bb94c1b2e061600df106d590fda3620/net/cookies/canonical_cookie.cc#L299)
+                for (const cookiePath in domainIndex) {
+                    if ((0, pathMatch_1.pathMatch)(path, cookiePath)) {
+                        const pathIndex = domainIndex[cookiePath];
+                        for (const key in pathIndex) {
+                            const value = pathIndex[key];
+                            if (value) {
+                                results.push(value);
+                            }
+                        }
+                    }
+                }
+            };
+        }
+        const domains = (0, permuteDomain_1.permuteDomain)(domain, allowSpecialUseDomain) || [domain];
+        const idx = this.idx;
+        domains.forEach((curDomain) => {
+            const domainIndex = idx[curDomain];
+            if (!domainIndex) {
+                return;
+            }
+            pathMatcher(domainIndex);
+        });
+        return promiseCallback.resolve(results);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    putCookie(cookie, callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(callback);
+        const { domain, path, key } = cookie;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (domain == null || path == null || key == null) {
+            return promiseCallback.resolve(undefined);
+        }
+        const domainEntry = this.idx[domain] ??
+            Object.create(null);
+        this.idx[domain] = domainEntry;
+        const pathEntry = domainEntry[path] ??
+            Object.create(null);
+        domainEntry[path] = pathEntry;
+        pathEntry[key] = cookie;
+        return promiseCallback.resolve(undefined);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    updateCookie(_oldCookie, newCookie, callback) {
+        // updateCookie() may avoid updating cookies that are identical.  For example,
+        // lastAccessed may not be important to some stores and an equality
+        // comparison could exclude that field.
+        // Don't return a value when using a callback, so that the return type is truly "void"
+        if (callback)
+            this.putCookie(newCookie, callback);
+        else
+            return this.putCookie(newCookie);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    removeCookie(domain, path, key, callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(callback);
+        delete this.idx[domain]?.[path]?.[key];
+        return promiseCallback.resolve(undefined);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    removeCookies(domain, path, callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(callback);
+        const domainEntry = this.idx[domain];
+        if (domainEntry) {
+            if (path) {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete domainEntry[path];
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete this.idx[domain];
+            }
+        }
+        return promiseCallback.resolve(undefined);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    removeAllCookies(callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(callback);
+        this.idx = Object.create(null);
+        return promiseCallback.resolve(undefined);
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    getAllCookies(callback) {
+        const promiseCallback = (0, utils_1.createPromiseCallback)(callback);
+        const cookies = [];
+        const idx = this.idx;
+        const domains = Object.keys(idx);
+        domains.forEach((domain) => {
+            const domainEntry = idx[domain] ?? {};
+            const paths = Object.keys(domainEntry);
+            paths.forEach((path) => {
+                const pathEntry = domainEntry[path] ?? {};
+                const keys = Object.keys(pathEntry);
+                keys.forEach((key) => {
+                    const keyEntry = pathEntry[key];
+                    if (keyEntry != null) {
+                        cookies.push(keyEntry);
+                    }
+                });
+            });
+        });
+        // Sort by creationIndex so deserializing retains the creation order.
+        // When implementing your own store, this SHOULD retain the order too
+        cookies.sort((a, b) => {
+            return (a.creationIndex || 0) - (b.creationIndex || 0);
+        });
+        return promiseCallback.resolve(cookies);
+    }
+}
+exports.MemoryCookieStore = MemoryCookieStore;

package/node_modules/tough-cookie/dist/pathMatch.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Answers "does the request-path path-match a given cookie-path?" as per {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.1.4 | RFC6265 Section 5.1.4}.
+ * This is essentially a prefix-match where cookiePath is a prefix of reqPath.
+ *
+ * @remarks
+ * A request-path path-matches a given cookie-path if at least one of
+ * the following conditions holds:
+ *
+ * - The cookie-path and the request-path are identical.
+ * - The cookie-path is a prefix of the request-path, and the last character of the cookie-path is %x2F ("/").
+ * - The cookie-path is a prefix of the request-path, and the first character of the request-path that is not included in the cookie-path is a %x2F ("/") character.
+ *
+ * @param reqPath - the path of the request
+ * @param cookiePath - the path of the cookie
+ * @public
+ */
+export declare function pathMatch(reqPath: string, cookiePath: string): boolean;

package/node_modules/tough-cookie/dist/pathMatch.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathMatch = pathMatch;
+/**
+ * Answers "does the request-path path-match a given cookie-path?" as per {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.1.4 | RFC6265 Section 5.1.4}.
+ * This is essentially a prefix-match where cookiePath is a prefix of reqPath.
+ *
+ * @remarks
+ * A request-path path-matches a given cookie-path if at least one of
+ * the following conditions holds:
+ *
+ * - The cookie-path and the request-path are identical.
+ * - The cookie-path is a prefix of the request-path, and the last character of the cookie-path is %x2F ("/").
+ * - The cookie-path is a prefix of the request-path, and the first character of the request-path that is not included in the cookie-path is a %x2F ("/") character.
+ *
+ * @param reqPath - the path of the request
+ * @param cookiePath - the path of the cookie
+ * @public
+ */
+function pathMatch(reqPath, cookiePath) {
+    // "o  The cookie-path and the request-path are identical."
+    if (cookiePath === reqPath) {
+        return true;
+    }
+    const idx = reqPath.indexOf(cookiePath);
+    if (idx === 0) {
+        // "o  The cookie-path is a prefix of the request-path, and the last
+        // character of the cookie-path is %x2F ("/")."
+        if (cookiePath[cookiePath.length - 1] === '/') {
+            return true;
+        }
+        // " o  The cookie-path is a prefix of the request-path, and the first
+        // character of the request-path that is not included in the cookie- path
+        // is a %x2F ("/") character."
+        if (reqPath.startsWith(cookiePath) && reqPath[cookiePath.length] === '/') {
+            return true;
+        }
+    }
+    return false;
+}

package/node_modules/tough-cookie/dist/permuteDomain.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates the permutation of all possible values that {@link domainMatch} the given `domain` parameter. The
+ * array is in shortest-to-longest order. Useful when building custom {@link Store} implementations.
+ *
+ * @example
+ * ```
+ * permuteDomain('foo.bar.example.com')
+ * // ['example.com', 'bar.example.com', 'foo.bar.example.com']
+ * ```
+ *
+ * @public
+ * @param domain - the domain to generate permutations for
+ * @param allowSpecialUseDomain - flag to control if {@link https://www.rfc-editor.org/rfc/rfc6761.html | Special Use Domains} such as `localhost` should be allowed
+ */
+export declare function permuteDomain(domain: string, allowSpecialUseDomain?: boolean): string[] | undefined;

package/node_modules/tough-cookie/dist/permuteDomain.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permuteDomain = permuteDomain;
+const getPublicSuffix_1 = require("./getPublicSuffix");
+/**
+ * Generates the permutation of all possible values that {@link domainMatch} the given `domain` parameter. The
+ * array is in shortest-to-longest order. Useful when building custom {@link Store} implementations.
+ *
+ * @example
+ * ```
+ * permuteDomain('foo.bar.example.com')
+ * // ['example.com', 'bar.example.com', 'foo.bar.example.com']
+ * ```
+ *
+ * @public
+ * @param domain - the domain to generate permutations for
+ * @param allowSpecialUseDomain - flag to control if {@link https://www.rfc-editor.org/rfc/rfc6761.html | Special Use Domains} such as `localhost` should be allowed
+ */
+function permuteDomain(domain, allowSpecialUseDomain) {
+    const pubSuf = (0, getPublicSuffix_1.getPublicSuffix)(domain, {
+        allowSpecialUseDomain: allowSpecialUseDomain,
+    });
+    if (!pubSuf) {
+        return undefined;
+    }
+    if (pubSuf == domain) {
+        return [domain];
+    }
+    // Nuke trailing dot
+    if (domain.slice(-1) == '.') {
+        domain = domain.slice(0, -1);
+    }
+    const prefix = domain.slice(0, -(pubSuf.length + 1)); // ".example.com"
+    const parts = prefix.split('.').reverse();
+    let cur = pubSuf;
+    const permutations = [cur];
+    while (parts.length) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const part = parts.shift();
+        cur = `${part}.${cur}`;
+        permutations.push(cur);
+    }
+    return permutations;
+}