@ardennguyen/zalo-agent-cli 1.0.7 → 2.0.0

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

@@ -0,0 +1,40 @@
+import type { Nullable } from '../utils';
+/**
+ * Given a current request/response path, gives the path appropriate for storing
+ * in a cookie. This is basically the "directory" of a "file" in the path, but
+ * is specified by {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.1.4 | RFC6265 - Section 5.1.4}.
+ *
+ * @remarks
+ * ### RFC6265 - Section 5.1.4
+ *
+ * The user agent MUST use an algorithm equivalent to the following algorithm to compute the default-path of a cookie:
+ *
+ * 1. Let uri-path be the path portion of the request-uri if such a
+ *     portion exists (and empty otherwise).  For example, if the
+ *     request-uri contains just a path (and optional query string),
+ *     then the uri-path is that path (without the %x3F ("?") character
+ *     or query string), and if the request-uri contains a full
+ *     absoluteURI, the uri-path is the path component of that URI.
+ *
+ * 2. If the uri-path is empty or if the first character of the uri-
+ *     path is not a %x2F ("/") character, output %x2F ("/") and skip
+ *     the remaining steps.
+ *
+ * 3. If the uri-path contains no more than one %x2F ("/") character,
+ *     output %x2F ("/") and skip the remaining step.
+ *
+ * 4. Output the characters of the uri-path from the first character up
+ *     to, but not including, the right-most %x2F ("/").
+ *
+ * @example
+ * ```
+ * defaultPath('') === '/'
+ * defaultPath('/some-path') === '/'
+ * defaultPath('/some-parent-path/some-path') === '/some-parent-path'
+ * defaultPath('relative-path') === '/'
+ * ```
+ *
+ * @param path - the path portion of the request-uri (excluding the hostname, query, fragment, and so on)
+ * @public
+ */
+export declare function defaultPath(path?: Nullable<string>): string;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPath = defaultPath;
+/**
+ * Given a current request/response path, gives the path appropriate for storing
+ * in a cookie. This is basically the "directory" of a "file" in the path, but
+ * is specified by {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.1.4 | RFC6265 - Section 5.1.4}.
+ *
+ * @remarks
+ * ### RFC6265 - Section 5.1.4
+ *
+ * The user agent MUST use an algorithm equivalent to the following algorithm to compute the default-path of a cookie:
+ *
+ * 1. Let uri-path be the path portion of the request-uri if such a
+ *     portion exists (and empty otherwise).  For example, if the
+ *     request-uri contains just a path (and optional query string),
+ *     then the uri-path is that path (without the %x3F ("?") character
+ *     or query string), and if the request-uri contains a full
+ *     absoluteURI, the uri-path is the path component of that URI.
+ *
+ * 2. If the uri-path is empty or if the first character of the uri-
+ *     path is not a %x2F ("/") character, output %x2F ("/") and skip
+ *     the remaining steps.
+ *
+ * 3. If the uri-path contains no more than one %x2F ("/") character,
+ *     output %x2F ("/") and skip the remaining step.
+ *
+ * 4. Output the characters of the uri-path from the first character up
+ *     to, but not including, the right-most %x2F ("/").
+ *
+ * @example
+ * ```
+ * defaultPath('') === '/'
+ * defaultPath('/some-path') === '/'
+ * defaultPath('/some-parent-path/some-path') === '/some-parent-path'
+ * defaultPath('relative-path') === '/'
+ * ```
+ *
+ * @param path - the path portion of the request-uri (excluding the hostname, query, fragment, and so on)
+ * @public
+ */
+function defaultPath(path) {
+    // "2. If the uri-path is empty or if the first character of the uri-path is not
+    // a %x2F ("/") character, output %x2F ("/") and skip the remaining steps.
+    if (!path || path.slice(0, 1) !== '/') {
+        return '/';
+    }
+    // "3. If the uri-path contains no more than one %x2F ("/") character, output
+    // %x2F ("/") and skip the remaining step."
+    if (path === '/') {
+        return path;
+    }
+    const rightSlash = path.lastIndexOf('/');
+    if (rightSlash === 0) {
+        return '/';
+    }
+    // "4. Output the characters of the uri-path from the first character up to,
+    // but not including, the right-most %x2F ("/")."
+    return path.slice(0, rightSlash);
+}

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

@@ -0,0 +1,38 @@
+import type { Nullable } from '../utils';
+/**
+ * Answers "does this real domain match the domain in a cookie?". The `domain` is the "current" domain name and the
+ * `cookieDomain` is the "cookie" domain name. Matches according to {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.1.3 | RFC6265 - Section 5.1.3},
+ * but it helps to think of it as a "suffix match".
+ *
+ * @remarks
+ * ### 5.1.3.  Domain Matching
+ *
+ * A string domain-matches a given domain string if at least one of the
+ * following conditions hold:
+ *
+ * - The domain string and the string are identical.  (Note that both
+ *     the domain string and the string will have been canonicalized to
+ *     lower case at this point.)
+ *
+ * - All of the following conditions hold:
+ *
+ *     - The domain string is a suffix of the string.
+ *
+ *     - The last character of the string that is not included in the
+ *         domain string is a %x2E (".") character.
+ *
+ *     - The string is a host name (i.e., not an IP address).
+ *
+ * @example
+ * ```
+ * domainMatch('example.com', 'example.com') === true
+ * domainMatch('eXaMpLe.cOm', 'ExAmPlE.CoM') === true
+ * domainMatch('no.ca', 'yes.ca') === false
+ * ```
+ *
+ * @param domain - The domain string to test
+ * @param cookieDomain - The cookie domain string to match against
+ * @param canonicalize - The canonicalize parameter toggles whether the domain parameters get normalized with canonicalDomain or not
+ * @public
+ */
+export declare function domainMatch(domain?: Nullable<string>, cookieDomain?: Nullable<string>, canonicalize?: boolean): boolean | undefined;

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domainMatch = domainMatch;
+const canonicalDomain_1 = require("./canonicalDomain");
+// Dumped from ip-regex@4.0.0, with the following changes:
+// * all capturing groups converted to non-capturing -- "(?:)"
+// * support for IPv6 Scoped Literal ("%eth1") removed
+// * lowercase hexadecimal only
+const IP_REGEX_LOWERCASE = /(?:^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}$)|(?:^(?:(?:[a-f\d]{1,4}:){7}(?:[a-f\d]{1,4}|:)|(?:[a-f\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|:[a-f\d]{1,4}|:)|(?:[a-f\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-f\d]{1,4}){1,2}|:)|(?:[a-f\d]{1,4}:){4}(?:(?::[a-f\d]{1,4}){0,1}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-f\d]{1,4}){1,3}|:)|(?:[a-f\d]{1,4}:){3}(?:(?::[a-f\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-f\d]{1,4}){1,4}|:)|(?:[a-f\d]{1,4}:){2}(?:(?::[a-f\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-f\d]{1,4}){1,5}|:)|(?:[a-f\d]{1,4}:){1}(?:(?::[a-f\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-f\d]{1,4}){1,6}|:)|(?::(?:(?::[a-f\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-f\d]{1,4}){1,7}|:)))$)/;
+/**
+ * Answers "does this real domain match the domain in a cookie?". The `domain` is the "current" domain name and the
+ * `cookieDomain` is the "cookie" domain name. Matches according to {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.1.3 | RFC6265 - Section 5.1.3},
+ * but it helps to think of it as a "suffix match".
+ *
+ * @remarks
+ * ### 5.1.3.  Domain Matching
+ *
+ * A string domain-matches a given domain string if at least one of the
+ * following conditions hold:
+ *
+ * - The domain string and the string are identical.  (Note that both
+ *     the domain string and the string will have been canonicalized to
+ *     lower case at this point.)
+ *
+ * - All of the following conditions hold:
+ *
+ *     - The domain string is a suffix of the string.
+ *
+ *     - The last character of the string that is not included in the
+ *         domain string is a %x2E (".") character.
+ *
+ *     - The string is a host name (i.e., not an IP address).
+ *
+ * @example
+ * ```
+ * domainMatch('example.com', 'example.com') === true
+ * domainMatch('eXaMpLe.cOm', 'ExAmPlE.CoM') === true
+ * domainMatch('no.ca', 'yes.ca') === false
+ * ```
+ *
+ * @param domain - The domain string to test
+ * @param cookieDomain - The cookie domain string to match against
+ * @param canonicalize - The canonicalize parameter toggles whether the domain parameters get normalized with canonicalDomain or not
+ * @public
+ */
+function domainMatch(domain, cookieDomain, canonicalize) {
+    if (domain == null || cookieDomain == null) {
+        return undefined;
+    }
+    let _str;
+    let _domStr;
+    if (canonicalize !== false) {
+        _str = (0, canonicalDomain_1.canonicalDomain)(domain);
+        _domStr = (0, canonicalDomain_1.canonicalDomain)(cookieDomain);
+    }
+    else {
+        _str = domain;
+        _domStr = cookieDomain;
+    }
+    if (_str == null || _domStr == null) {
+        return undefined;
+    }
+    /*
+     * S5.1.3:
+     * "A string domain-matches a given domain string if at least one of the
+     * following conditions hold:"
+     *
+     * " o The domain string and the string are identical. (Note that both the
+     * domain string and the string will have been canonicalized to lower case at
+     * this point)"
+     */
+    if (_str == _domStr) {
+        return true;
+    }
+    /* " o All of the following [three] conditions hold:" */
+    /* "* The domain string is a suffix of the string" */
+    const idx = _str.lastIndexOf(_domStr);
+    if (idx <= 0) {
+        return false; // it's a non-match (-1) or prefix (0)
+    }
+    // next, check it's a proper suffix
+    // e.g., "a.b.c".indexOf("b.c") === 2
+    // 5 === 3+2
+    if (_str.length !== _domStr.length + idx) {
+        return false; // it's not a suffix
+    }
+    /* "  * The last character of the string that is not included in the
+     * domain string is a %x2E (".") character." */
+    if (_str.substring(idx - 1, idx) !== '.') {
+        return false; // doesn't align on "."
+    }
+    /* "  * The string is a host name (i.e., not an IP address)." */
+    return !IP_REGEX_LOWERCASE.test(_str);
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Format a {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date | Date} into
+ * the {@link https://www.rfc-editor.org/rfc/rfc2616#section-3.3.1 | preferred Internet standard format}
+ * defined in {@link https://www.rfc-editor.org/rfc/rfc822#section-5 | RFC822} and
+ * updated in {@link https://www.rfc-editor.org/rfc/rfc1123#page-55 | RFC1123}.
+ *
+ * @example
+ * ```
+ * formatDate(new Date(0)) === 'Thu, 01 Jan 1970 00:00:00 GMT`
+ * ```
+ *
+ * @param date - the date value to format
+ * @public
+ */
+export declare function formatDate(date: Date): string;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = formatDate;
+/**
+ * Format a {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date | Date} into
+ * the {@link https://www.rfc-editor.org/rfc/rfc2616#section-3.3.1 | preferred Internet standard format}
+ * defined in {@link https://www.rfc-editor.org/rfc/rfc822#section-5 | RFC822} and
+ * updated in {@link https://www.rfc-editor.org/rfc/rfc1123#page-55 | RFC1123}.
+ *
+ * @example
+ * ```
+ * formatDate(new Date(0)) === 'Thu, 01 Jan 1970 00:00:00 GMT`
+ * ```
+ *
+ * @param date - the date value to format
+ * @public
+ */
+function formatDate(date) {
+    return date.toUTCString();
+}

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

@@ -0,0 +1,29 @@
+export { MemoryCookieStore, type MemoryCookieStoreIndex } from '../memstore';
+export { pathMatch } from '../pathMatch';
+export { permuteDomain } from '../permuteDomain';
+export { getPublicSuffix, type GetPublicSuffixOptions, } from '../getPublicSuffix';
+export { Store } from '../store';
+export { ParameterError } from '../validators';
+export { version } from '../version';
+export { type Callback, type ErrorCallback, type Nullable } from '../utils';
+export { canonicalDomain } from './canonicalDomain';
+export { PrefixSecurityEnum, type SerializedCookie, type SerializedCookieJar, } from './constants';
+export { Cookie, type CreateCookieOptions, type ParseCookieOptions, } from './cookie';
+export { cookieCompare } from './cookieCompare';
+export { CookieJar, type CreateCookieJarOptions, type GetCookiesOptions, type SetCookieOptions, } from './cookieJar';
+export { defaultPath } from './defaultPath';
+export { domainMatch } from './domainMatch';
+export { formatDate } from './formatDate';
+export { parseDate } from './parseDate';
+export { permutePath } from './permutePath';
+import { Cookie, ParseCookieOptions } from './cookie';
+/**
+ * {@inheritDoc Cookie.parse}
+ * @public
+ */
+export declare function parse(str: string, options?: ParseCookieOptions): Cookie | undefined;
+/**
+ * {@inheritDoc Cookie.fromJSON}
+ * @public
+ */
+export declare function fromJSON(str: unknown): Cookie | undefined;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permutePath = exports.parseDate = exports.formatDate = exports.domainMatch = exports.defaultPath = exports.CookieJar = exports.cookieCompare = exports.Cookie = exports.PrefixSecurityEnum = exports.canonicalDomain = exports.version = exports.ParameterError = exports.Store = exports.getPublicSuffix = exports.permuteDomain = exports.pathMatch = exports.MemoryCookieStore = void 0;
+exports.parse = parse;
+exports.fromJSON = fromJSON;
+var memstore_1 = require("../memstore");
+Object.defineProperty(exports, "MemoryCookieStore", { enumerable: true, get: function () { return memstore_1.MemoryCookieStore; } });
+var pathMatch_1 = require("../pathMatch");
+Object.defineProperty(exports, "pathMatch", { enumerable: true, get: function () { return pathMatch_1.pathMatch; } });
+var permuteDomain_1 = require("../permuteDomain");
+Object.defineProperty(exports, "permuteDomain", { enumerable: true, get: function () { return permuteDomain_1.permuteDomain; } });
+var getPublicSuffix_1 = require("../getPublicSuffix");
+Object.defineProperty(exports, "getPublicSuffix", { enumerable: true, get: function () { return getPublicSuffix_1.getPublicSuffix; } });
+var store_1 = require("../store");
+Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return store_1.Store; } });
+var validators_1 = require("../validators");
+Object.defineProperty(exports, "ParameterError", { enumerable: true, get: function () { return validators_1.ParameterError; } });
+var version_1 = require("../version");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return version_1.version; } });
+var canonicalDomain_1 = require("./canonicalDomain");
+Object.defineProperty(exports, "canonicalDomain", { enumerable: true, get: function () { return canonicalDomain_1.canonicalDomain; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "PrefixSecurityEnum", { enumerable: true, get: function () { return constants_1.PrefixSecurityEnum; } });
+var cookie_1 = require("./cookie");
+Object.defineProperty(exports, "Cookie", { enumerable: true, get: function () { return cookie_1.Cookie; } });
+var cookieCompare_1 = require("./cookieCompare");
+Object.defineProperty(exports, "cookieCompare", { enumerable: true, get: function () { return cookieCompare_1.cookieCompare; } });
+var cookieJar_1 = require("./cookieJar");
+Object.defineProperty(exports, "CookieJar", { enumerable: true, get: function () { return cookieJar_1.CookieJar; } });
+var defaultPath_1 = require("./defaultPath");
+Object.defineProperty(exports, "defaultPath", { enumerable: true, get: function () { return defaultPath_1.defaultPath; } });
+var domainMatch_1 = require("./domainMatch");
+Object.defineProperty(exports, "domainMatch", { enumerable: true, get: function () { return domainMatch_1.domainMatch; } });
+var formatDate_1 = require("./formatDate");
+Object.defineProperty(exports, "formatDate", { enumerable: true, get: function () { return formatDate_1.formatDate; } });
+var parseDate_1 = require("./parseDate");
+Object.defineProperty(exports, "parseDate", { enumerable: true, get: function () { return parseDate_1.parseDate; } });
+var permutePath_1 = require("./permutePath");
+Object.defineProperty(exports, "permutePath", { enumerable: true, get: function () { return permutePath_1.permutePath; } });
+const cookie_2 = require("./cookie");
+/**
+ * {@inheritDoc Cookie.parse}
+ * @public
+ */
+function parse(str, options) {
+    return cookie_2.Cookie.parse(str, options);
+}
+/**
+ * {@inheritDoc Cookie.fromJSON}
+ * @public
+ */
+function fromJSON(str) {
+    return cookie_2.Cookie.fromJSON(str);
+}

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

@@ -0,0 +1,103 @@
+import type { Nullable } from '../utils';
+/**
+ * Parse a cookie date string into a {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date | Date}. Parses according to
+ * {@link https://www.rfc-editor.org/rfc/rfc6265.html#section-5.1.1 | RFC6265 - Section 5.1.1}, not
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse | Date.parse()}.
+ *
+ * @remarks
+ *
+ * ### RFC6265 - 5.1.1. Dates
+ *
+ * The user agent MUST use an algorithm equivalent to the following
+ * algorithm to parse a cookie-date.  Note that the various boolean
+ * flags defined as a part of the algorithm (i.e., found-time, found-
+ * day-of-month, found-month, found-year) are initially "not set".
+ *
+ * 1.  Using the grammar below, divide the cookie-date into date-tokens.
+ *
+ * ```
+ *     cookie-date     = *delimiter date-token-list *delimiter
+ *     date-token-list = date-token *( 1*delimiter date-token )
+ *     date-token      = 1*non-delimiter
+ *
+ *     delimiter       = %x09 / %x20-2F / %x3B-40 / %x5B-60 / %x7B-7E
+ *     non-delimiter   = %x00-08 / %x0A-1F / DIGIT / ":" / ALPHA / %x7F-FF
+ *     non-digit       = %x00-2F / %x3A-FF
+ *
+ *     day-of-month    = 1*2DIGIT ( non-digit *OCTET )
+ *     month           = ( "jan" / "feb" / "mar" / "apr" /
+ *                        "may" / "jun" / "jul" / "aug" /
+ *                        "sep" / "oct" / "nov" / "dec" ) *OCTET
+ *     year            = 2*4DIGIT ( non-digit *OCTET )
+ *     time            = hms-time ( non-digit *OCTET )
+ *     hms-time        = time-field ":" time-field ":" time-field
+ *     time-field      = 1*2DIGIT
+ * ```
+ *
+ * 2. Process each date-token sequentially in the order the date-tokens
+ *     appear in the cookie-date:
+ *
+ *     1. If the found-time flag is not set and the token matches the
+ *         time production, set the found-time flag and set the hour-
+ *         value, minute-value, and second-value to the numbers denoted
+ *         by the digits in the date-token, respectively.  Skip the
+ *         remaining sub-steps and continue to the next date-token.
+ *
+ *     2. If the found-day-of-month flag is not set and the date-token
+ *         matches the day-of-month production, set the found-day-of-
+ *         month flag and set the day-of-month-value to the number
+ *         denoted by the date-token.  Skip the remaining sub-steps and
+ *         continue to the next date-token.
+ *
+ *     3. If the found-month flag is not set and the date-token matches
+ *         the month production, set the found-month flag and set the
+ *         month-value to the month denoted by the date-token.  Skip the
+ *         remaining sub-steps and continue to the next date-token.
+ *
+ *     4. If the found-year flag is not set and the date-token matches
+ *         the year production, set the found-year flag and set the
+ *         year-value to the number denoted by the date-token.  Skip the
+ *         remaining sub-steps and continue to the next date-token.
+ *
+ *  3. If the year-value is greater than or equal to 70 and less than or
+ *      equal to 99, increment the year-value by 1900.
+ *
+ *  4. If the year-value is greater than or equal to 0 and less than or
+ *      equal to 69, increment the year-value by 2000.
+ *
+ *      1. NOTE: Some existing user agents interpret two-digit years differently.
+ *
+ *  5. Abort these steps and fail to parse the cookie-date if:
+ *
+ *      - at least one of the found-day-of-month, found-month, found-
+ *          year, or found-time flags is not set,
+ *
+ *      - the day-of-month-value is less than 1 or greater than 31,
+ *
+ *      - the year-value is less than 1601,
+ *
+ *      - the hour-value is greater than 23,
+ *
+ *      - the minute-value is greater than 59, or
+ *
+ *      - the second-value is greater than 59.
+ *
+ *      (Note that leap seconds cannot be represented in this syntax.)
+ *
+ *  6. Let the parsed-cookie-date be the date whose day-of-month, month,
+ *      year, hour, minute, and second (in UTC) are the day-of-month-
+ *      value, the month-value, the year-value, the hour-value, the
+ *      minute-value, and the second-value, respectively.  If no such
+ *      date exists, abort these steps and fail to parse the cookie-date.
+ *
+ *  7. Return the parsed-cookie-date as the result of this algorithm.
+ *
+ * @example
+ * ```
+ * parseDate('Wed, 09 Jun 2021 10:18:14 GMT')
+ * ```
+ *
+ * @param cookieDate - the cookie date string
+ * @public
+ */
+export declare function parseDate(cookieDate: Nullable<string>): Date | undefined;