@ardennguyen/zalo-agent-cli 1.0.7 → 2.0.0

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

@@ -0,0 +1,211 @@
+import type { Cookie } from './cookie';
+import type { Callback, ErrorCallback, Nullable } from './utils';
+/**
+ * Base class for {@link CookieJar} stores.
+ *
+ * The storage model for each {@link CookieJar} instance can be replaced with a custom implementation. The default is
+ * {@link MemoryCookieStore}.
+ *
+ * @remarks
+ * - Stores should inherit from the base Store class, which is available as a top-level export.
+ *
+ * - Stores are asynchronous by default, but if {@link Store.synchronous} is set to true, then the `*Sync` methods
+ *     of the containing {@link CookieJar} can be used.
+ *
+ * @public
+ */
+export declare class Store {
+    /**
+     * Store implementations that support synchronous methods must return `true`.
+     */
+    synchronous: boolean;
+    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.
+     *
+     * 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.
+     */
+    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: Nullable<string>, path: Nullable<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: Nullable<string>, path: Nullable<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: Nullable<string>, path: Nullable<string>, key: Nullable<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: Nullable<string>, path: Nullable<string>, key: Nullable<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: Nullable<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: Nullable<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/store.js

@@ -0,0 +1,76 @@
+"use strict";
+// disabling this lint on this whole file because Store should be abstract
+// but we have implementations in the wild that may not implement all features
+/* eslint-disable @typescript-eslint/no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+/**
+ * Base class for {@link CookieJar} stores.
+ *
+ * The storage model for each {@link CookieJar} instance can be replaced with a custom implementation. The default is
+ * {@link MemoryCookieStore}.
+ *
+ * @remarks
+ * - Stores should inherit from the base Store class, which is available as a top-level export.
+ *
+ * - Stores are asynchronous by default, but if {@link Store.synchronous} is set to true, then the `*Sync` methods
+ *     of the containing {@link CookieJar} can be used.
+ *
+ * @public
+ */
+class Store {
+    constructor() {
+        this.synchronous = false;
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    findCookie(_domain, _path, _key, _callback) {
+        throw new Error('findCookie is not implemented');
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    findCookies(_domain, _path, _allowSpecialUseDomain = false, _callback) {
+        throw new Error('findCookies is not implemented');
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    putCookie(_cookie, _callback) {
+        throw new Error('putCookie is not implemented');
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    updateCookie(_oldCookie, _newCookie, _callback) {
+        // recommended default implementation:
+        // return this.putCookie(newCookie, cb);
+        throw new Error('updateCookie is not implemented');
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    removeCookie(_domain, _path, _key, _callback) {
+        throw new Error('removeCookie is not implemented');
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    removeCookies(_domain, _path, _callback) {
+        throw new Error('removeCookies is not implemented');
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    removeAllCookies(_callback) {
+        throw new Error('removeAllCookies is not implemented');
+    }
+    /**
+     * @internal No doc because this is an overload that supports the implementation
+     */
+    getAllCookies(_callback) {
+        throw new Error('getAllCookies is not implemented (therefore jar cannot be serialized)');
+    }
+}
+exports.Store = Store;

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

@@ -0,0 +1,34 @@
+/**
+ * A callback function that accepts an error or a result.
+ * @public
+ */
+export interface Callback<T> {
+    (error: Error, result?: never): void;
+    (error: null, result: T): void;
+}
+/**
+ * A callback function that only accepts an error.
+ * @public
+ */
+export interface ErrorCallback {
+    (error: Error | null): void;
+}
+/**
+ * The inverse of NonNullable<T>.
+ * @public
+ */
+export type Nullable<T> = T | null | undefined;
+/** Wrapped `Object.prototype.toString`, so that you don't need to remember to use `.call()`. */
+export declare const objectToString: (obj: unknown) => string;
+/** Safely converts any value to string, using the value's own `toString` when available. */
+export declare const safeToString: (val: unknown) => string;
+/** Utility object for promise/callback interop. */
+export interface PromiseCallback<T> {
+    promise: Promise<T>;
+    callback: Callback<T>;
+    resolve: (value: T) => Promise<T>;
+    reject: (error: Error) => Promise<T>;
+}
+/** Converts a callback into a utility object where either a callback or a promise can be used. */
+export declare function createPromiseCallback<T>(cb?: Callback<T>): PromiseCallback<T>;
+export declare function inOperator<K extends string, T extends object>(k: K, o: T): o is T & Record<K, unknown>;

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeToString = exports.objectToString = void 0;
+exports.createPromiseCallback = createPromiseCallback;
+exports.inOperator = inOperator;
+/** Wrapped `Object.prototype.toString`, so that you don't need to remember to use `.call()`. */
+const objectToString = (obj) => Object.prototype.toString.call(obj);
+exports.objectToString = objectToString;
+/**
+ * Converts an array to string, safely handling symbols, null prototype objects, and recursive arrays.
+ */
+const safeArrayToString = (arr, seenArrays) => {
+    // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString#description
+    if (typeof arr.join !== 'function')
+        return (0, exports.objectToString)(arr);
+    seenArrays.add(arr);
+    const mapped = arr.map((val) => val === null || val === undefined || seenArrays.has(val)
+        ? ''
+        : safeToStringImpl(val, seenArrays));
+    return mapped.join();
+};
+const safeToStringImpl = (val, seenArrays = new WeakSet()) => {
+    // Using .toString() fails for null/undefined and implicit conversion (val + "") fails for symbols
+    // and objects with null prototype
+    if (typeof val !== 'object' || val === null) {
+        return String(val);
+    }
+    else if (typeof val.toString === 'function') {
+        return Array.isArray(val)
+            ? // Arrays have a weird custom toString that we need to replicate
+                safeArrayToString(val, seenArrays)
+            : // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                String(val);
+    }
+    else {
+        // This case should just be objects with null prototype, so we can just use Object#toString
+        return (0, exports.objectToString)(val);
+    }
+};
+/** Safely converts any value to string, using the value's own `toString` when available. */
+const safeToString = (val) => safeToStringImpl(val);
+exports.safeToString = safeToString;
+/** Converts a callback into a utility object where either a callback or a promise can be used. */
+function createPromiseCallback(cb) {
+    let callback;
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    if (typeof cb === 'function') {
+        callback = (err, result) => {
+            try {
+                if (err)
+                    cb(err);
+                // If `err` is null, we know `result` must be `T`
+                // The assertion isn't *strictly* correct, as `T` could be nullish, but, ehh, good enough...
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                else
+                    cb(null, result);
+            }
+            catch (e) {
+                reject(e instanceof Error ? e : new Error());
+            }
+        };
+    }
+    else {
+        callback = (err, result) => {
+            try {
+                // If `err` is null, we know `result` must be `T`
+                // The assertion isn't *strictly* correct, as `T` could be nullish, but, ehh, good enough...
+                if (err)
+                    reject(err);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                else
+                    resolve(result);
+            }
+            catch (e) {
+                reject(e instanceof Error ? e : new Error());
+            }
+        };
+    }
+    return {
+        promise,
+        callback,
+        resolve: (value) => {
+            callback(null, value);
+            return promise;
+        },
+        reject: (error) => {
+            callback(error);
+            return promise;
+        },
+    };
+}
+function inOperator(k, o) {
+    return k in o;
+}

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

@@ -0,0 +1,24 @@
+import { Callback } from './utils';
+/** Determines whether the argument is a non-empty string. */
+export declare function isNonEmptyString(data: unknown): boolean;
+/** Determines whether the argument is a *valid* Date. */
+export declare function isDate(data: unknown): boolean;
+/** Determines whether the argument is the empty string. */
+export declare function isEmptyString(data: unknown): boolean;
+/** Determines whether the argument is a string. */
+export declare function isString(data: unknown): boolean;
+/** Determines whether the string representation of the argument is "[object Object]". */
+export declare function isObject(data: unknown): boolean;
+/** Determines whether the argument is an integer. */
+export declare function isInteger(data: unknown): boolean;
+/**
+ * When the first argument is false, an error is created with the given message. If a callback is
+ * provided, the error is passed to the callback, otherwise the error is thrown.
+ */
+export declare function validate(bool: boolean, cbOrMessage?: Callback<never> | string, message?: string): void;
+/**
+ * Represents a validation error.
+ * @public
+ */
+export declare class ParameterError extends Error {
+}

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

@@ -0,0 +1,90 @@
+"use strict";
+/* ************************************************************************************
+Extracted from check-types.js
+https://gitlab.com/philbooth/check-types.js
+
+MIT License
+
+Copyright (c) 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 Phil Booth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+************************************************************************************ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterError = void 0;
+exports.isNonEmptyString = isNonEmptyString;
+exports.isDate = isDate;
+exports.isEmptyString = isEmptyString;
+exports.isString = isString;
+exports.isObject = isObject;
+exports.isInteger = isInteger;
+exports.validate = validate;
+const utils_1 = require("./utils");
+/* Validation functions copied from check-types package - https://www.npmjs.com/package/check-types */
+/** Determines whether the argument is a non-empty string. */
+function isNonEmptyString(data) {
+    return isString(data) && data !== '';
+}
+/** Determines whether the argument is a *valid* Date. */
+function isDate(data) {
+    return data instanceof Date && isInteger(data.getTime());
+}
+/** Determines whether the argument is the empty string. */
+function isEmptyString(data) {
+    return data === '' || (data instanceof String && data.toString() === '');
+}
+/** Determines whether the argument is a string. */
+function isString(data) {
+    return typeof data === 'string' || data instanceof String;
+}
+/** Determines whether the string representation of the argument is "[object Object]". */
+function isObject(data) {
+    return (0, utils_1.objectToString)(data) === '[object Object]';
+}
+/** Determines whether the argument is an integer. */
+function isInteger(data) {
+    return typeof data === 'number' && data % 1 === 0;
+}
+/* -- End validation functions -- */
+/**
+ * When the first argument is false, an error is created with the given message. If a callback is
+ * provided, the error is passed to the callback, otherwise the error is thrown.
+ */
+function validate(bool, cbOrMessage, message) {
+    if (bool)
+        return; // Validation passes
+    const cb = typeof cbOrMessage === 'function' ? cbOrMessage : undefined;
+    let options = typeof cbOrMessage === 'function' ? message : cbOrMessage;
+    // The default message prior to v5 was '[object Object]' due to a bug, and the message is kept
+    // for backwards compatibility.
+    if (!isObject(options))
+        options = '[object Object]';
+    const err = new ParameterError((0, utils_1.safeToString)(options));
+    if (cb)
+        cb(err);
+    else
+        throw err;
+}
+/**
+ * Represents a validation error.
+ * @public
+ */
+class ParameterError extends Error {
+}
+exports.ParameterError = ParameterError;

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

@@ -0,0 +1,5 @@
+/**
+ * The version of `tough-cookie`
+ * @public
+ */
+export declare const version = "5.1.2";

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+/**
+ * The version of `tough-cookie`
+ * @public
+ */
+exports.version = '5.1.2';