@ardennguyen/zalo-agent-cli 2.5.8 → 3.0.0

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

@@ -1,220 +0,0 @@
-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

@@ -1,187 +0,0 @@
-"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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-"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;
-}