mazey 5.4.2 → 5.5.1

package/lib/index.d.ts

@@ -1,114 +1,3 @@
-/**
- * Compute the length of the longest common substring of two strings.
- *
- * Usage:
- *
- * ```javascript
- * import { longestComSubstring } from "mazey";
- *
- * const ret = longestComSubstring("fish", "finish");
- * console.log(ret);
- * ```
- *
- * Output:
- *
- * ```text
- * 3
- * ```
- *
- * @param {string} aStr String
- * @param {string} bStr String
- * @returns {number} Length
- * @category Calculate and Formula
- */
-declare function longestComSubstring(aStr: string, bStr: string): number;
-/**
- * Alias of `longestComSubstring`.
- *
- * @hidden
- */
-declare function calLongestCommonSubstring(aStr: string, bStr: string): number;
-/**
- * Compute the length of the longest common subsequence of two strings.
- *
- * Usage:
- *
- * ```javascript
- * import { longestComSubsequence } from "mazey";
- *
- * const ret = longestComSubsequence("fish", "finish");
- * console.log(ret);
- * ```
- *
- * Output:
- *
- * ```text
- * 4
- * ```
- *
- * @param {string} aStr The first string.
- * @param {string} bStr The second string.
- * @returns {number} The length of the longest common subsequence.
- * @category Calculate and Formula
- */
-declare function longestComSubsequence(aStr: string, bStr: string): number;
-/**
- * Alias of `longestComSubsequence`.
- *
- * @hidden
- */
-declare function calLongestCommonSubsequence(aStr: string, bStr: string): number;
-/**
- * Return whether a random value falls within the given probability.
- *
- * Usage:
- *
- * ```javascript
- * import { isHit } from "mazey";
- *
- * const ret = isHit(0.5); // A 50% chance of returning true.
- * console.log(ret);
- * ```
- *
- * Output:
- *
- * ```text
- * true
- * ```
- *
- * Example: Test the precision.
- *
- * ```javascript
- * let trueCount = 0;
- * let falseCount = 0;
- * new Array(1000000).fill(0).forEach(() => {
- *   if (isHit(0.5)) {
- *     trueCount++;
- *   } else {
- *     falseCount++;
- *   }
- * });
- * console.log(trueCount, falseCount);
- * ```
- *
- * Output:
- *
- * ```text
- * 499994 500006
- * ```
- *
- * @param {number} rate Probability expressed as a value from 0 to 1.
- * @returns {boolean} Whether the random value is less than the probability.
- * @category Calculate and Formula
- */
-declare function isHit(rate: number): boolean;
-/**
- * Alias of `isHit`.
- *
- * @hidden
- */
-declare function inRate(rate: number): boolean;
-
 /**
  * @author Cheng
  */
@@ -206,1383 +95,1702 @@ interface OnURLChangeOptions {
   fireOnInit?: boolean;
 }
 
+type InvestmentReturnRate = number | string;
 /**
- * Copy/Clone Object deeply.
+ * Calculate an investment's Compound Annual Growth Rate (CAGR).
  *
- * Custom class instances are copied as plain objects containing their own
- * properties. Unsupported native instances are preserved by reference.
+ * Numeric total returns use decimal ratios. For example, `0.202` represents
+ * `20.2%`. String total returns use percentage values, so `"20.2%"` and
+ * `"20.2"` both represent `20.2%`. A trailing percent sign is optional, and
+ * the complete trimmed string must be a finite JavaScript number. Scientific
+ * notation such as `"2.02e1%"` is accepted.
+ *
+ * The returned CAGR is a decimal ratio and is not rounded. The calculation
+ * uses:
+ *
+ * `CAGR = (1 + totalReturn)^(365 / durationInDays) - 1`
  *
  * Usage:
  *
- * ```javascript
- * import { deepCopy } from "mazey";
+ * ```typescript
+ * import {
+ *   calculateCAGR,
+ *   floatToPercent,
+ * } from "mazey";
  *
- * const ret1 = deepCopy(["a", "b", "c"]);
- * const ret2 = deepCopy("abc");
- * console.log(ret1);
- * console.log(ret2);
+ * const cagr = calculateCAGR(
+ *   "2022-04-01",
+ *   "2025-10-01",
+ *   "20.2%"
+ * );
+ * const equivalentCagr = calculateCAGR(
+ *   "2022-04-01",
+ *   "2025-10-01",
+ *   0.202
+ * );
+ * const negativeCagr = calculateCAGR(
+ *   "2022-04-01",
+ *   "2025-10-01",
+ *   "-15.5%"
+ * );
+ *
+ * console.log({
+ *   cagr,
+ *   equivalentCagr,
+ *   negativeCagr,
+ *   percentage: floatToPercent(cagr, 2),
+ * });
  * ```
  *
- * Output:
+ * Possible output:
  *
  * ```text
- * ["a", "b", "c"]
- * abc
+ * {
+ *   cagr: 0.053908...,
+ *   equivalentCagr: 0.053908...,
+ *   negativeCagr: -0.046926...,
+ *   percentage: "5.39%"
+ * }
  * ```
  *
- * @param {object} obj The value to clone.
- * @returns {object} Returns the deep cloned value.
- * @category Util
+ * @param startDate Start date as a supported structured string, millisecond timestamp, or `Date`.
+ * @param endDate End date in the same accepted forms. It must be strictly later than `startDate`.
+ * @param totalReturnRate Total period return. Numbers are decimal ratios; strings are percentage values.
+ * @returns The unrounded CAGR as a decimal ratio.
+ * @throws {TypeError} If either date or the total return is invalid.
+ * @throws {RangeError} If the dates are not increasing, the total return is at most `-1`, or the result is not finite.
+ * @remarks Duration uses the exact elapsed milliseconds, including time of day, converted to fractional days. A financial year is always fixed at 365 days. Input `Date` objects are copied and never mutated.
+ * @category Calculate and Formula
  */
-declare function deepCopy<T>(obj: T): T;
+declare function calculateCAGR(startDate: MazeyDate, endDate: MazeyDate, totalReturnRate: InvestmentReturnRate): number;
 /**
- * Recursively freeze an object and its nested enumerable values.
- *
- * Primitive values and objects that are already frozen are returned unchanged.
+ * Compute the length of the longest common substring of two strings.
  *
  * Usage:
  *
  * ```javascript
- * import { deepFreeze } from "mazey";
- *
- * const config = deepFreeze({
- *   api: {
- *     timeout: 5000,
- *   },
- * });
+ * import { longestComSubstring } from "mazey";
  *
- * console.log(Object.isFrozen(config));
- * console.log(Object.isFrozen(config.api));
+ * const ret = longestComSubstring("fish", "finish");
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * true
- * true
+ * 3
  * ```
  *
- * @param value The value to freeze.
- * @returns The original value with its nested enumerable values frozen.
- * @category Util
+ * @param {string} aStr String
+ * @param {string} bStr String
+ * @returns {number} Length
+ * @category Calculate and Formula
  */
-declare function deepFreeze<T>(value: T): T;
+declare function longestComSubstring(aStr: string, bStr: string): number;
 /**
- * Alias of `deepCopy`.
+ * Alias of `longestComSubstring`.
  *
  * @hidden
  */
-declare function deepCopyObject<T>(obj: T): T;
+declare function calLongestCommonSubstring(aStr: string, bStr: string): number;
 /**
- * Convert CamelCase to KebabCase.
+ * Compute the length of the longest common subsequence of two strings.
  *
  * Usage:
  *
  * ```javascript
- * import { convertCamelToKebab } from "mazey";
+ * import { longestComSubsequence } from "mazey";
  *
- * const ret1 = convertCamelToKebab("ABC");
- * const ret2 = convertCamelToKebab("aBC");
- * console.log(ret1);
- * console.log(ret2);
+ * const ret = longestComSubsequence("fish", "finish");
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * a-b-c
- * a-b-c
+ * 4
  * ```
  *
- * @param {string} camelCase "aBC" or "ABC"
- * @returns {string} "a-b-c"
- * @category Util
+ * @param {string} aStr The first string.
+ * @param {string} bStr The second string.
+ * @returns {number} The length of the longest common subsequence.
+ * @category Calculate and Formula
  */
-declare function convertCamelToKebab(camelCase: string): string;
+declare function longestComSubsequence(aStr: string, bStr: string): number;
 /**
- * Convert KebabCase to CamelCase.
+ * Alias of `longestComSubsequence`.
+ *
+ * @hidden
+ */
+declare function calLongestCommonSubsequence(aStr: string, bStr: string): number;
+/**
+ * Return whether a random value falls within the given probability.
  *
  * Usage:
  *
  * ```javascript
- * import { convertKebabToCamel } from "mazey";
+ * import { isHit } from "mazey";
  *
- * const ret1 = convertKebabToCamel("a-b-c");
- * const ret2 = convertKebabToCamel("a-bb-cc");
- * console.log(ret1, ret2);
+ * const ret = isHit(0.5); // A 50% chance of returning true.
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * aBC aBbCc
+ * true
  * ```
  *
- * @param {string} kebabCase "a-bb-cc"
- * @returns {string} "aBbCc"
- * @category Util
+ * Example: Test the precision.
+ *
+ * ```javascript
+ * let trueCount = 0;
+ * let falseCount = 0;
+ * new Array(1000000).fill(0).forEach(() => {
+ *   if (isHit(0.5)) {
+ *     trueCount++;
+ *   } else {
+ *     falseCount++;
+ *   }
+ * });
+ * console.log(trueCount, falseCount);
+ * ```
+ *
+ * Output:
+ *
+ * ```text
+ * 499994 500006
+ * ```
+ *
+ * @param {number} rate Probability expressed as a value from 0 to 1.
+ * @returns {boolean} Whether the random value is less than the probability.
+ * @category Calculate and Formula
  */
-declare function convertKebabToCamel(kebabCase: string): string;
+declare function isHit(rate: number): boolean;
 /**
- * Alias of `convertCamelToKebab`.
+ * Alias of `isHit`.
  *
  * @hidden
  */
-declare function camelCaseToKebabCase(camelCase: string): string;
+declare function inRate(rate: number): boolean;
+
 /**
- * Convert CamelCase to Underscore.
+ * Precision used by `formatLocalDateTime`.
+ *
+ * @category Util
+ */
+type LocalDateTimePrecision = "minute" | "second" | "millisecond";
+/**
+ * Parse an HTML `datetime-local` value into a local `Date`.
+ *
+ * Accepted normalized values use a year with at least four digits followed by
+ * `-MM-DDTHH:mm`, with optional seconds and 1-3 fractional-second digits.
+ * Components are validated strictly, so impossible dates and times return
+ * `null` instead of being normalized by `Date`.
  *
  * Usage:
  *
  * ```javascript
- * import { convertCamelToUnder } from "mazey";
+ * import { parseLocalDateTime } from "mazey";
  *
- * const ret1 = convertCamelToUnder("ABC");
- * const ret2 = convertCamelToUnder("aBC");
- * console.log(ret1);
- * console.log(ret2);
+ * const date = parseLocalDateTime("2026-07-21T14:30:45.123");
+ * console.log(date?.getFullYear());
+ * console.log(date?.getHours());
+ * console.log(date?.getMilliseconds());
  * ```
  *
  * Output:
  *
  * ```text
- * a_b_c
- * a_b_c
+ * 2026
+ * 14
+ * 123
  * ```
  *
- * @param {string} camelCase "aBC" or "ABC"
- * @returns {string} "a_b_c"
+ * @param value A normalized HTML `datetime-local` value without a timezone.
+ * @returns A local `Date`, or `null` when the value is malformed or represents an impossible local date and time.
+ * @remarks The value is interpreted using the runtime's local timezone. Timezone suffixes, surrounding whitespace, and date-only values are rejected.
  * @category Util
  */
-declare function convertCamelToUnder(camelCase: string): string;
+declare function parseLocalDateTime(value: string): Date | null;
 /**
- * Convert Underscore to CamelCase.
+ * Format a `Date` as an HTML `datetime-local` value using local fields.
+ *
+ * | Precision     | Output shape                  |
+ * | ------------- | ----------------------------- |
+ * | `minute`      | `YYYY-MM-DDTHH:mm`            |
+ * | `second`      | `YYYY-MM-DDTHH:mm:ss`         |
+ * | `millisecond` | `YYYY-MM-DDTHH:mm:ss.SSS`     |
  *
  * Usage:
  *
  * ```javascript
- * import { convertUnderToCamel } from "mazey";
+ * import { formatLocalDateTime } from "mazey";
  *
- * const ret1 = convertUnderToCamel("a_b_c");
- * const ret2 = convertUnderToCamel("a_bb_cc");
- * console.log(ret1, ret2);
+ * const date = new Date(2026, 6, 21, 14, 30, 45, 123);
+ * const minutes = formatLocalDateTime(date);
+ * const seconds = formatLocalDateTime(date, { precision: "second" });
+ * const milliseconds = formatLocalDateTime(date, {
+ *   precision: "millisecond",
+ * });
+ * console.log(minutes);
+ * console.log(seconds);
+ * console.log(milliseconds);
  * ```
  *
  * Output:
  *
  * ```text
- * aBC aBbCc
+ * 2026-07-21T14:30
+ * 2026-07-21T14:30:45
+ * 2026-07-21T14:30:45.123
  * ```
  *
- * @param {string} underCase "a_bb_cc"
- * @returns {string} "aBbCc"
+ * @param date A valid `Date` to format.
+ * @param options Formatting options. Precision defaults to `minute`.
+ * @returns A normalized HTML `datetime-local` value containing local calendar fields. The year is padded to at least four digits.
+ * @throws {TypeError} If `date` is not a `Date` or `precision` is unsupported.
+ * @throws {RangeError} If `date` is invalid or its local year is earlier than 1.
+ * @remarks This function does not call `toISOString()` and does not convert the value to UTC. It does not mutate the supplied `Date`.
  * @category Util
  */
-declare function convertUnderToCamel(underCase: string): string;
-/**
- * Alias of `convertCamelToUnder`.
- *
- * @hidden
- */
-declare function camelCase2Underscore(camelCase: string): string;
+declare function formatLocalDateTime(date: Date, options?: {
+    precision?: LocalDateTimePrecision;
+}): string;
 /**
- * Convert text to a deterministic uppercase ASCII JavaScript identifier.
- *
- * Characters outside `A-Z`, `a-z`, `0-9`, `_`, and `$` become `_`. A result
- * beginning with a digit is prefixed with `_`; an empty input therefore returns `_`.
+ * Get the current timestamp in milliseconds.
  *
  * Usage:
  *
  * ```javascript
- * import { toJavaScriptGlobalName } from "mazey";
+ * import { mNow } from "mazey";
  *
- * const globalName = toJavaScriptGlobalName("@scope/my-library");
- * console.log(globalName);
+ * const ret = mNow();
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * _SCOPE_MY_LIBRARY
+ * 1585325367122
  * ```
  *
- * @param value Text such as a package name or bundle filename.
- * @returns An uppercase identifier suitable for an IIFE global name.
- * @throws TypeError when `value` is not a string.
+ * @returns {number} The current timestamp in milliseconds.
  * @category Util
  */
-declare function toJavaScriptGlobalName(value: string): string;
+declare function mNow(): number;
 /**
- * Remove leading and trailing whitespace or specified characters from string.
+ * Calculate the interval between two dates or timestamps.
  *
- * Note: This method is used to replace the native `String.prototype.trim()`. But it is not necessary to use it in modern browsers.
+ * The default `d` type returns the number of whole days. The `text` type
+ * returns an English duration using days, hours, minutes, and seconds while
+ * omitting zero-valued units. A zero interval returns `"0 seconds"`. Any other
+ * type returns the number of whole seconds. Negative intervals and invalid
+ * dates return an empty string.
  *
  * Usage:
  *
  * ```javascript
- * import { mTrim } from "mazey";
+ * import { getDateDifference } from "mazey";
  *
- * const ret1 = mTrim(" 1 2 3 ");
- * const ret2 = mTrim("abc ");
- * console.log(ret1);
- * console.log(ret2);
+ * const days = getDateDifference(0, 90061000);
+ * const text = getDateDifference(0, 90061000, { type: "text" });
+ * const compactText = getDateDifference(0, 90060000, { type: "text" });
+ * const dateStringDays = getDateDifference(
+ *   "2020-03-28 00:09:27",
+ *   "2023-04-18 10:54:00"
+ * );
+ * console.log(days);
+ * console.log(text);
+ * console.log(compactText);
+ * console.log(dateStringDays);
  * ```
  *
  * Output:
  *
  * ```text
- * 1 2 3
- * abc
+ * 1
+ * 1 day 1 hour 1 minute 1 second
+ * 1 day 1 hour 1 minute
+ * 1116
  * ```
  *
- * @param {string} str The string to trim.
- * @returns {string} Trimmed string.
+ * @param start Start date or timestamp.
+ * @param end End date or timestamp.
+ * @param options Formatting options. Use `d` for whole days or `text` for an English duration.
+ * @returns Whole days, whole seconds, an English duration, or an empty string for a negative or invalid interval.
+ * @remarks Strings in `YYYY-MM-DD HH:mm:ss` format are normalized and parsed as local time. Other date strings use the runtime's native `Date` parser; use timestamps or ISO strings with an explicit timezone when parsing must be portable.
  * @category Util
+ */
+declare function getDateDifference(start?: number | string | Date, end?: number | string | Date, options?: {
+    type?: string;
+}): number | string;
+/**
+ * Alias of `getDateDifference`.
+ *
  * @hidden
  */
-declare function mTrim(str: string): string;
+declare function getFriendlyInterval(start?: number | string | Date, end?: number | string | Date, options?: {
+    type?: string;
+}): number | string;
 /**
- * Check whether it is a valid JSON string.
+ * Format a duration in milliseconds using its largest applicable English unit.
+ *
+ * Values are rounded to at most one decimal place. Negative durations are
+ * clamped to zero, and non-finite values return `"0 seconds"`.
  *
  * Usage:
  *
  * ```javascript
- * import { isJSONString } from "mazey";
- *
- * const ret1 = isJSONString(`['a', 'b', 'c']`);
- * const ret2 = isJSONString(`["a", "b", "c"]`);
- * console.log(ret1);
- * console.log(ret2);
- * ```
- *
- * Output:
+ * import { formatDurationFromMs } from "mazey";
  *
- * ```text
- * false
- * true
+ * formatDurationFromMs(500);        // "0.5 seconds"
+ * formatDurationFromMs(90000);      // "1.5 minutes"
+ * formatDurationFromMs(3600000);    // "1 hour"
+ * formatDurationFromMs(129600000);  // "1.5 days"
  * ```
  *
- * @param {string} str The string to check.
- * @returns {boolean} Return the result of checking.
+ * @param {number} durationMs Duration in milliseconds.
+ * @returns {string} Concise duration using seconds, minutes, hours, or days.
  * @category Util
  */
-declare function isJSONString(str: string): boolean;
+declare function formatDurationFromMs(durationMs: number): string;
 /**
- * Alias of `isJSONString`.
+ * Check whether an unknown value represents a valid date.
  *
- * @hidden
- */
-declare function isJsonString(str: string): boolean;
-/**
- * Parse a JSON string and return a caller-defined fallback when parsing fails.
+ * Valid inputs include `Date` instances, finite millisecond timestamps,
+ * structured local date strings, and ISO 8601 strings with `Z` or a numeric
+ * timezone offset. Structured strings are parsed into numeric components and
+ * validated strictly, so invalid calendar dates are not normalized.
+ *
+ * Supported string forms are `YYYY-MM-DD`, `YYYY-MM-DD HH:mm[:ss]`,
+ * `YYYY-MM-DDTHH:mm[:ss]`, and the same `T`-separated date-time with `Z` or
+ * a `+HH:mm`/`-HH:mm` offset. Zoned strings may include 1-3 millisecond digits.
  *
  * Usage:
  *
  * ```javascript
- * import { parseJsonSafe } from "mazey";
+ * import { isValidDate } from "mazey";
  *
- * const data = parseJsonSafe('{"enabled":true}');
- * const fallback = parseJsonSafe("invalid", {});
+ * const ret1 = isValidDate(1577877720000);
+ * const ret2 = isValidDate("2020-01-01 11:22");
+ * const ret3 = isValidDate("2020-02-30");
+ * const ret4 = isValidDate(new Date("invalid"));
+ *
+ * console.log(ret1, ret2, ret3, ret4);
  * ```
  *
- * @param value JSON string to parse.
- * @param fallback Value returned when parsing fails. Defaults to `null`.
- * @returns The parsed JSON value or the supplied fallback.
+ * Output:
+ *
+ * ```text
+ * true true false false
+ * ```
+ *
+ * @param value A `Date`, millisecond timestamp, or supported structured date string.
+ * @returns Whether the value represents a valid date.
  * @category Util
  */
-declare function parseJsonSafe<T, F = null>(value: string, fallback?: F): T | F;
+declare function isValidDate(value: unknown): boolean;
 /**
- * Generate a random string of number, `genRndNumString(7)` => "7658495".
+ * Check whether a date is today in the runtime's local timezone.
  *
  * Usage:
  *
  * ```javascript
- * import { genRndNumString } from "mazey";
+ * import { isToday } from "mazey";
  *
- * const ret1 = genRndNumString(4);
- * const ret2 = genRndNumString(7);
- * console.log(ret1);
- * console.log(ret2);
+ * const ret = isToday(new Date());
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * 9730
- * 2262490
+ * true
  * ```
  *
- * @param {number} n Length
- * @returns {string} Return the random string.
+ * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
+ * @returns Whether the value has the current local year, month, and day. Invalid input returns `false`.
+ * @remarks Hours, minutes, seconds, and milliseconds are ignored. Results depend on the runtime's local timezone.
  * @category Util
  */
-declare function genRndNumString(n?: number): string;
-/**
- * Alias of `genRndNumString`.
- *
- * @hidden
- */
-declare function generateRndNum(n?: number): string;
+declare function isToday(date: MazeyDate): boolean;
 /**
- * Generate a numeric identifier by combining the current timestamp with a
- * random numeric suffix.
+ * Check whether a date is in the current local calendar year.
  *
  * Usage:
  *
  * ```javascript
- * import { genUniqueNumString } from "mazey";
+ * import { isThisYear } from "mazey";
  *
- * const ret1 = genUniqueNumString();
- * const ret2 = genUniqueNumString(3);
- * console.log(ret1);
- * console.log(ret2);
+ * const ret = isThisYear(new Date());
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * 1538324722364123
- * 1538324722364123
+ * true
  * ```
  *
- * @param {number} n Length of the random numeric suffix.
- * @returns {string} A timestamp-based numeric identifier.
+ * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
+ * @returns Whether the value has the current local year. Invalid input returns `false`.
+ * @remarks Results depend on the runtime's local timezone.
  * @category Util
  */
-declare function genUniqueNumString(n?: number): string;
-/**
- * Alias of `genUniqueNumString`.
- *
- * @hidden
- */
-declare function generateUniqueNum(n?: number): string;
+declare function isThisYear(date: MazeyDate): boolean;
 /**
- * Get the current timestamp in milliseconds.
+ * Check whether a date is in the current local calendar month and year.
  *
  * Usage:
  *
  * ```javascript
- * import { mNow } from "mazey";
+ * import { isThisMonth } from "mazey";
  *
- * const ret = mNow();
+ * const ret = isThisMonth(new Date());
  * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * 1585325367122
+ * true
  * ```
  *
- * @returns {number} The current timestamp in milliseconds.
+ * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
+ * @returns Whether the value has the current local year and month. Invalid input returns `false`.
+ * @remarks Results depend on the runtime's local timezone.
  * @category Util
  */
-declare function mNow(): number;
+declare function isThisMonth(date: MazeyDate): boolean;
 /**
- * Convert a floating-point ratio to a percentage string.
+ * Check whether a date is in the current Monday-first local calendar week.
  *
  * Usage:
  *
  * ```javascript
- * import { floatToPercent } from "mazey";
+ * import { isThisWeek } from "mazey";
  *
- * const ret1 = floatToPercent(0.2);
- * const ret2 = floatToPercent(0.2, 2);
- * console.log(ret1);
- * console.log(ret2);
+ * const ret = isThisWeek(new Date());
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * 20%
- * 20.00%
+ * true
  * ```
  *
- * @param {number} num Floating-point ratio to convert.
- * @param {number} fixSize Number of decimal places in the percentage.
- * @returns {string} The percentage string.
+ * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
+ * @returns Whether the value is in the current local week. Invalid input returns `false`.
+ * @remarks The week begins on Monday and ends before the following Monday. Boundaries use local time and a half-open range.
  * @category Util
  */
-declare function floatToPercent(num: number, fixSize?: number): string;
+declare function isThisWeek(date: MazeyDate): boolean;
 /**
- * Format a number with a fixed number of decimal places.
+ * Check whether a date is within the current local clock hour.
  *
  * Usage:
  *
  * ```javascript
- * import { floatFixed } from "mazey";
+ * import { isThisHour } from "mazey";
  *
- * const ret1 = floatFixed(0.2);
- * const ret2 = floatFixed(0.2, 2);
- * console.log(ret1);
- * console.log(ret2);
+ * const ret = isThisHour(new Date());
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * 0
- * 0.20
+ * true
  * ```
  *
- * @param num Number or numeric string to format.
- * @param size Number of decimal places.
- * @returns The fixed-point string.
+ * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
+ * @returns Whether the value has the current local year, month, day, and hour. Invalid input returns `false`.
+ * @remarks Minutes, seconds, and milliseconds are ignored. Results depend on the runtime's local timezone.
  * @category Util
  */
-declare function floatFixed(num: number | string, size?: number): string;
+declare function isThisHour(date: MazeyDate): boolean;
 /**
- * Limit how frequently a function can be invoked over time.
+ * Format the absolute distance from a date to now in concise English words.
  *
  * Usage:
  *
  * ```javascript
- * import { throttle } from "mazey";
+ * import { formatDistanceToNow } from "mazey";
  *
- * const foo = throttle(() => {
- *   console.log("The function will be invoked at most once per every wait 1000 milliseconds.");
- * }, 1000, { leading: true });
+ * const ret = formatDistanceToNow(new Date(Date.now() - 60 * 60 * 1000));
+ * console.log(ret);
  * ```
  *
- * Reference: [Lodash](https://lodash.com/docs/4.17.15#throttle)
+ * Output:
  *
- * @param func Function to throttle.
- * @param wait Minimum interval between invocations, in milliseconds.
- * @param options.leading Whether to invoke on the leading edge.
- * @param options.trailing Whether to invoke on the trailing edge.
- * @returns The throttled function.
+ * ```text
+ * about 1 hour
+ * ```
+ *
+ * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
+ * @returns The absolute approximate distance phrase, or an empty string for invalid input.
+ * @remarks Past and future dates use the same wording without `ago` or `in`. Months and years use fixed approximate durations of 30 and 365 days.
  * @category Util
  */
-declare function throttle<T extends (...args: MazeyFnParams) => MazeyFnReturn>(func: T, wait: number, options?: {
-    leading?: boolean;
-    trailing?: boolean;
-}): ThrottleFunc<T>;
+declare function formatDistanceToNow(date: MazeyDate): string;
 /**
- * Delay function execution until the specified time has passed since the last
- * invocation.
+ * Return the formatted date string in the given format.
+ *
+ * Supported format tokens:
+ *
+ * | Token  | Meaning                                | Range or example |
+ * | ------ | -------------------------------------- | ---------------- |
+ * | `yyyy` | Four-digit year                        | `2022`           |
+ * | `MM`   | Two-digit month                        | `01`–`12`        |
+ * | `dd`   | Two-digit day of the month             | `01`–`31`        |
+ * | `HH`   | Two-digit hour using the 24-hour clock | `00`–`23`        |
+ * | `hh`   | Two-digit hour using the 12-hour clock | `01`–`12`        |
+ * | `mm`   | Two-digit minute                       | `00`–`59`        |
+ * | `ss`   | Two-digit second                       | `00`–`59`        |
+ * | `a`    | Uppercase meridiem indicator           | `AM` or `PM`     |
+ *
+ * The function creates a native `Date` and reads its local date and time
+ * fields. Timestamp output can therefore differ between runtime time zones.
  *
  * Usage:
  *
  * ```javascript
- * import { debounce } from "mazey";
+ * import { formatDate } from "mazey";
  *
- * const foo = debounce(() => {
- *   console.log("The debounced function will only be invoked in 1000 milliseconds, the other invoking will disappear during the wait time.");
- * }, 1000, true);
+ * const ret1 = formatDate();
+ * const ret2 = formatDate("Tue Jan 11 2022 14:12:26 GMT+0800 (China Standard Time)", "yyyy-MM-dd hh:mm:ss a");
+ * const ret3 = formatDate(1641881235000, "yyyy-MM-dd hh:mm:ss a");
+ * const ret4 = formatDate(new Date(2014, 1, 11), "MM/dd/yyyy");
+ * console.log("Default formatDate value:", ret1);
+ * console.log("String formatDate value:", ret2);
+ * console.log("Number formatDate value:", ret3);
+ * console.log("Date formatDate value:", ret4);
  * ```
  *
- * @param func Function to debounce.
- * @param wait Delay after the last invocation, in milliseconds.
- * @param immediate Whether to invoke on the leading edge instead.
- * @returns The debounced function.
+ * Output:
+ *
+ * ```text
+ * Default formatDate value: 2023-01-11
+ * String formatDate value: 2022-01-11 02:12:26 PM
+ * Number formatDate value: 2022-01-11 02:07:15 PM
+ * Date formatDate value: 02/11/2014
+ * ```
+ *
+ * @param {MazeyDate} dateIns Original date value. Defaults to the current date and time.
+ * @param {string} format Format string composed of supported format tokens. Defaults to `yyyy-MM-dd`.
+ * @returns {string} The formatted date string.
+ * @throws {RangeError} If `dateIns` is not a valid date.
  * @category Util
  */
-declare function debounce<T extends (...args: MazeyFnParams) => MazeyFnReturn>(func: T, wait: number, immediate?: boolean): DebounceFunc<T>;
+declare function formatDate(dateIns?: MazeyDate, format?: string): string;
 /**
- * Calculate the interval between two dates or timestamps.
+ * Generate a local-time Calendar Versioning string from a date.
  *
- * The default `d` type returns the number of whole days. The `text` type
- * returns an English duration using days, hours, minutes, and seconds while
- * omitting zero-valued units. A zero interval returns `"0 seconds"`. Any other
- * type returns the number of whole seconds. Negative intervals and invalid
- * dates return an empty string.
+ * The conceptual format is `yyyy.MMdd.HHmmss`. Leading zeroes are removed
+ * from each segment to keep numeric Semantic Versioning identifiers valid.
  *
  * Usage:
  *
  * ```javascript
- * import { getDateDifference } from "mazey";
+ * import { generateCalendarVersion } from "mazey";
  *
- * const days = getDateDifference(0, 90061000);
- * const text = getDateDifference(0, 90061000, { type: "text" });
- * const compactText = getDateDifference(0, 90060000, { type: "text" });
- * const dateStringDays = getDateDifference(
- *   "2020-03-28 00:09:27",
- *   "2023-04-18 10:54:00"
+ * const ret = generateCalendarVersion(new Date(2026, 6, 11, 7, 40, 35));
+ * console.log(ret);
+ * ```
+ *
+ * Output:
+ *
+ * ```text
+ * 2026.711.74035
+ * ```
+ *
+ * @param {MazeyDate} dateIns Original date. Defaults to the current date.
+ * @returns {string} Return the generated calendar version.
+ * @throws {RangeError} If `dateIns` is not a valid date.
+ * @category Util
+ */
+declare function generateCalendarVersion(dateIns?: MazeyDate): string;
+
+/**
+ * Copy/Clone Object deeply.
+ *
+ * Custom class instances are copied as plain objects containing their own
+ * properties. Unsupported native instances are preserved by reference.
+ *
+ * Usage:
+ *
+ * ```javascript
+ * import { deepCopy } from "mazey";
+ *
+ * const ret1 = deepCopy(["a", "b", "c"]);
+ * const ret2 = deepCopy("abc");
+ * console.log(ret1);
+ * console.log(ret2);
+ * ```
+ *
+ * Output:
+ *
+ * ```text
+ * ["a", "b", "c"]
+ * abc
+ * ```
+ *
+ * @param {object} obj The value to clone.
+ * @returns {object} Returns the deep cloned value.
+ * @category Util
+ */
+declare function deepCopy<T>(obj: T): T;
+/**
+ * Recursively freeze an object and its nested enumerable values.
+ *
+ * Primitive values and objects that are already frozen are returned unchanged.
+ *
+ * Usage:
+ *
+ * ```javascript
+ * import { deepFreeze } from "mazey";
+ *
+ * const config = deepFreeze({
+ *   api: {
+ *     timeout: 5000,
+ *   },
+ * });
+ *
+ * console.log(Object.isFrozen(config));
+ * console.log(Object.isFrozen(config.api));
+ * ```
+ *
+ * Output:
+ *
+ * ```text
+ * true
+ * true
+ * ```
+ *
+ * @param value The value to freeze.
+ * @returns The original value with its nested enumerable values frozen.
+ * @category Util
+ */
+declare function deepFreeze<T>(value: T): T;
+/**
+ * Shallowly assign defined properties from one or more sources.
+ *
+ * The target is mutated. Only own enumerable string-keyed properties are
+ * considered, and `undefined` values are skipped. Other falsy values such as
+ * `null`, an empty string, `0`, and `false` are assigned.
+ *
+ * Usage:
+ *
+ * ```javascript
+ * import { assignDefined } from "mazey";
+ *
+ * const options = assignDefined(
+ *   { retries: 3, verbose: true },
+ *   { retries: undefined, verbose: false },
  * );
- * console.log(days);
- * console.log(text);
- * console.log(compactText);
- * console.log(dateStringDays);
+ *
+ * console.log(options);
  * ```
  *
  * Output:
  *
  * ```text
- * 1
- * 1 day 1 hour 1 minute 1 second
- * 1 day 1 hour 1 minute
- * 1116
+ * { retries: 3, verbose: false }
  * ```
  *
- * @param start Start date or timestamp.
- * @param end End date or timestamp.
- * @param options Formatting options. Use `d` for whole days or `text` for an English duration.
- * @returns Whole days, whole seconds, an English duration, or an empty string for a negative or invalid interval.
- * @remarks Strings in `YYYY-MM-DD HH:mm:ss` format are normalized and parsed as local time. Other date strings use the runtime's native `Date` parser; use timestamps or ISO strings with an explicit timezone when parsing must be portable.
+ * @param target The object to mutate.
+ * @param sources Sources applied from left to right.
+ * @returns The mutated target.
  * @category Util
  */
-declare function getDateDifference(start?: number | string | Date, end?: number | string | Date, options?: {
-    type?: string;
-}): number | string;
+declare function assignDefined<T extends object>(target: T, ...sources: ReadonlyArray<Partial<T> | undefined>): T;
 /**
- * Alias of `getDateDifference`.
+ * Alias of `deepCopy`.
  *
  * @hidden
  */
-declare function getFriendlyInterval(start?: number | string | Date, end?: number | string | Date, options?: {
-    type?: string;
-}): number | string;
+declare function deepCopyObject<T>(obj: T): T;
 /**
- * Format a duration in milliseconds using its largest applicable English unit.
+ * Convert CamelCase to KebabCase.
  *
- * Values are rounded to at most one decimal place. Negative durations are
- * clamped to zero, and non-finite values return `"0 seconds"`.
+ * Usage:
+ *
+ * ```javascript
+ * import { convertCamelToKebab } from "mazey";
+ *
+ * const ret1 = convertCamelToKebab("ABC");
+ * const ret2 = convertCamelToKebab("aBC");
+ * console.log(ret1);
+ * console.log(ret2);
+ * ```
+ *
+ * Output:
+ *
+ * ```text
+ * a-b-c
+ * a-b-c
+ * ```
+ *
+ * @param {string} camelCase "aBC" or "ABC"
+ * @returns {string} "a-b-c"
+ * @category Util
+ */
+declare function convertCamelToKebab(camelCase: string): string;
+/**
+ * Convert KebabCase to CamelCase.
  *
  * Usage:
  *
  * ```javascript
- * import { formatDurationFromMs } from "mazey";
+ * import { convertKebabToCamel } from "mazey";
  *
- * formatDurationFromMs(500);        // "0.5 seconds"
- * formatDurationFromMs(90000);      // "1.5 minutes"
- * formatDurationFromMs(3600000);    // "1 hour"
- * formatDurationFromMs(129600000);  // "1.5 days"
+ * const ret1 = convertKebabToCamel("a-b-c");
+ * const ret2 = convertKebabToCamel("a-bb-cc");
+ * console.log(ret1, ret2);
  * ```
  *
- * @param {number} durationMs Duration in milliseconds.
- * @returns {string} Concise duration using seconds, minutes, hours, or days.
+ * Output:
+ *
+ * ```text
+ * aBC aBbCc
+ * ```
+ *
+ * @param {string} kebabCase "a-bb-cc"
+ * @returns {string} "aBbCc"
  * @category Util
  */
-declare function formatDurationFromMs(durationMs: number): string;
+declare function convertKebabToCamel(kebabCase: string): string;
 /**
- * Check whether a value is a number allowed by the supplied options.
+ * Alias of `convertCamelToKebab`.
+ *
+ * @hidden
+ */
+declare function camelCaseToKebabCase(camelCase: string): string;
+/**
+ * Convert CamelCase to Underscore.
  *
  * Usage:
  *
  * ```javascript
- * import { isNumber } from "mazey";
+ * import { convertCamelToUnder } from "mazey";
  *
- * const ret1 = isNumber(123);
- * const ret2 = isNumber("123");
- * // Default: NaN, Infinity is not Number
- * const ret3 = isNumber(Infinity);
- * const ret4 = isNumber(Infinity, { isInfinityAsNumber: true });
- * const ret5 = isNumber(NaN);
- * const ret6 = isNumber(NaN, { isNaNAsNumber: true, isInfinityAsNumber: true });
- * console.log(ret1, ret2, ret3, ret4, ret5, ret6);
+ * const ret1 = convertCamelToUnder("ABC");
+ * const ret2 = convertCamelToUnder("aBC");
+ * console.log(ret1);
+ * console.log(ret2);
  * ```
  *
  * Output:
  *
  * ```text
- * true false false true false true
+ * a_b_c
+ * a_b_c
  * ```
  *
- * @param {*} num Value to check.
- * @param options Controls whether `NaN`, `Infinity`, or other non-finite values count as numbers.
- * @returns {boolean} Whether the value is an allowed number.
+ * @param {string} camelCase "aBC" or "ABC"
+ * @returns {string} "a_b_c"
  * @category Util
  */
-declare function isNumber(num: unknown, options?: IsNumberOptions): boolean;
+declare function convertCamelToUnder(camelCase: string): string;
 /**
- * Invoke a value only when it is a function.
+ * Convert Underscore to CamelCase.
  *
  * Usage:
  *
  * ```javascript
- * import { invokeFn } from "mazey";
+ * import { convertUnderToCamel } from "mazey";
  *
- * const ret = invokeFn(() => {
- *  console.log("invokeFn");
- * });
+ * const ret1 = convertUnderToCamel("a_b_c");
+ * const ret2 = convertUnderToCamel("a_bb_cc");
+ * console.log(ret1, ret2);
  * ```
  *
- * @param {function} fn Potential function to invoke.
- * @param params Arguments passed to the function.
- * @returns The function result, or `null` when `fn` is not callable.
+ * Output:
+ *
+ * ```text
+ * aBC aBbCc
+ * ```
+ *
+ * @param {string} underCase "a_bb_cc"
+ * @returns {string} "aBbCc"
  * @category Util
  */
-declare function invokeFn(fn: MazeyFunction | null | undefined, ...params: Parameters<MazeyFunction>): ReturnType<MazeyFunction> | null;
+declare function convertUnderToCamel(underCase: string): string;
 /**
- * Alias of `invokeFn`.
+ * Alias of `convertCamelToUnder`.
  *
  * @hidden
  */
-declare function doFn(fn: MazeyFunction | null | undefined, ...params: Parameters<MazeyFunction>): ReturnType<MazeyFunction> | null;
+declare function camelCase2Underscore(camelCase: string): string;
 /**
- * Verify the validity of a non-empty array.
+ * Convert text to a deterministic uppercase ASCII JavaScript identifier.
+ *
+ * Characters outside `A-Z`, `a-z`, `0-9`, `_`, and `$` become `_`. A result
+ * beginning with a digit is prefixed with `_`; an empty input therefore returns `_`.
  *
  * Usage:
  *
  * ```javascript
- * import { isNonEmptyArray } from "mazey";
+ * import { toJavaScriptGlobalName } from "mazey";
  *
- * const ret = isNonEmptyArray([1, 2, 3]);
- * console.log(ret);
+ * const globalName = toJavaScriptGlobalName("@scope/my-library");
+ * console.log(globalName);
  * ```
  *
  * Output:
  *
  * ```text
- * true
+ * _SCOPE_MY_LIBRARY
  * ```
  *
+ * @param value Text such as a package name or bundle filename.
+ * @returns An uppercase identifier suitable for an IIFE global name.
+ * @throws TypeError when `value` is not a string.
  * @category Util
  */
-declare function isNonEmptyArray<T>(arr: Array<T>): boolean;
+declare function toJavaScriptGlobalName(value: string): string;
 /**
- * Verify the validity of a pure object.
+ * Remove leading and trailing whitespace or specified characters from string.
+ *
+ * Note: This method is used to replace the native `String.prototype.trim()`. But it is not necessary to use it in modern browsers.
  *
  * Usage:
  *
  * ```javascript
- * import { isPureObject } from "mazey";
+ * import { mTrim } from "mazey";
  *
- * const ret1 = isPureObject({ a: 1 });
- * const ret2 = isPureObject("abc");
- * const ret3 = isPureObject(null);
- * const ret4 = isPureObject([]);
+ * const ret1 = mTrim(" 1 2 3 ");
+ * const ret2 = mTrim("abc ");
+ * console.log(ret1);
+ * console.log(ret2);
+ * ```
  *
- * console.log(ret1, ret2, ret3, ret4);
+ * Output:
+ *
+ * ```text
+ * 1 2 3
+ * abc
+ * ```
+ *
+ * @param {string} str The string to trim.
+ * @returns {string} Trimmed string.
+ * @category Util
+ * @hidden
+ */
+declare function mTrim(str: string): string;
+/**
+ * Check whether it is a valid JSON string.
+ *
+ * Usage:
+ *
+ * ```javascript
+ * import { isJSONString } from "mazey";
+ *
+ * const ret1 = isJSONString(`['a', 'b', 'c']`);
+ * const ret2 = isJSONString(`["a", "b", "c"]`);
+ * console.log(ret1);
+ * console.log(ret2);
  * ```
  *
  * Output:
  *
  * ```text
- * true false false false
+ * false
+ * true
  * ```
  *
- * @param {MazeyObject} obj The object to verify.
- * @returns {boolean} Return TRUE if the object is a pure object.
+ * @param {string} str The string to check.
+ * @returns {boolean} Return the result of checking.
  * @category Util
  */
-declare function isPureObject(obj: MazeyObject): boolean;
+declare function isJSONString(str: string): boolean;
 /**
- * Verify the validity of a function.
+ * Alias of `isJSONString`.
+ *
+ * @hidden
+ */
+declare function isJsonString(str: string): boolean;
+/**
+ * Parse a JSON string and return a caller-defined fallback when parsing fails.
  *
  * Usage:
  *
  * ```javascript
- * import { isFunction } from "mazey";
- *
- * const ret1 = isFunction(() => {});
- * const ret2 = isFunction("abc");
- * const ret3 = isFunction(null);
- * console.log(ret1, ret2, ret3);
- * ```
- *
- * Output:
+ * import { parseJsonSafe } from "mazey";
  *
- * ```text
- * true false false
+ * const data = parseJsonSafe('{"enabled":true}');
+ * const fallback = parseJsonSafe("invalid", {});
  * ```
  *
- * @param {MazeyObject} fn The function to verify.
- * @returns {boolean} Return TRUE if the object is a function.
+ * @param value JSON string to parse.
+ * @param fallback Value returned when parsing fails. Defaults to `null`.
+ * @returns The parsed JSON value or the supplied fallback.
  * @category Util
  */
-declare function isFunction(fn: MazeyObject): boolean;
+declare function parseJsonSafe<T, F = null>(value: string, fallback?: F): T | F;
 /**
- * Verify the validity of a string.
+ * Generate a random string of number, `genRndNumString(7)` => "7658495".
  *
  * Usage:
  *
  * ```javascript
- * import { isString } from "mazey";
+ * import { genRndNumString } from "mazey";
  *
- * const ret1 = isString("abc");
- * const ret2 = isString({ a: 1 });
- * const ret3 = isString(null);
- * console.log(ret1, ret2, ret3);
+ * const ret1 = genRndNumString(4);
+ * const ret2 = genRndNumString(7);
+ * console.log(ret1);
+ * console.log(ret2);
  * ```
  *
  * Output:
  *
  * ```text
- * true false false
+ * 9730
+ * 2262490
  * ```
  *
- * @param {MazeyObject} str The string to verify.
- * @returns {boolean} Return TRUE if the object is a string.
+ * @param {number} n Length
+ * @returns {string} Return the random string.
  * @category Util
  */
-declare function isString(str: MazeyObject): boolean;
+declare function genRndNumString(n?: number): string;
 /**
- * Verify the validity of a boolean.
+ * Alias of `genRndNumString`.
+ *
+ * @hidden
+ */
+declare function generateRndNum(n?: number): string;
+/**
+ * Generate a numeric identifier by combining the current timestamp with a
+ * random numeric suffix.
  *
  * Usage:
  *
  * ```javascript
- * import { isBool } from "mazey";
+ * import { genUniqueNumString } from "mazey";
  *
- * const ret1 = isBool(true);
- * const ret2 = isBool({ a: 1 });
- * const ret3 = isBool("abc");
- * const ret4 = isBool(null);
- * console.log(ret1, ret2, ret3, ret4);
+ * const ret1 = genUniqueNumString();
+ * const ret2 = genUniqueNumString(3);
+ * console.log(ret1);
+ * console.log(ret2);
  * ```
  *
  * Output:
  *
  * ```text
- * true false false false
+ * 1538324722364123
+ * 1538324722364123
  * ```
  *
- * @param {MazeyObject} bool The boolean to verify.
- * @returns {boolean} Return TRUE if the object is a boolean.
+ * @param {number} n Length of the random numeric suffix.
+ * @returns {string} A timestamp-based numeric identifier.
  * @category Util
  */
-declare function isBool(bool: MazeyObject): boolean;
+declare function genUniqueNumString(n?: number): string;
 /**
- * Alias of `isBool`.
+ * Alias of `genUniqueNumString`.
+ *
+ * @hidden
  */
-declare function isBoolean(bool: MazeyObject): boolean;
+declare function generateUniqueNum(n?: number): string;
 /**
- * Verify the validity of a value.
+ * Convert a floating-point ratio to a percentage string.
  *
  * Usage:
  *
  * ```javascript
- * import { isUdfOrNul } from "mazey";
+ * import { floatToPercent } from "mazey";
  *
- * const ret1 = isUdfOrNul(undefined);
- * const ret2 = isUdfOrNul(null);
- * const ret3 = isUdfOrNul("abc");
- * console.log(ret1, ret2, ret3);
+ * const ret1 = floatToPercent(0.2);
+ * const ret2 = floatToPercent(0.2, 2);
+ * console.log(ret1);
+ * console.log(ret2);
  * ```
  *
  * Output:
  *
  * ```text
- * true true false
+ * 20%
+ * 20.00%
  * ```
  *
- * @param {MazeyObject} val The value to verify.
- * @returns {boolean} Return TRUE if the object is undefined or null.
+ * @param {number} num Floating-point ratio to convert.
+ * @param {number} fixSize Number of decimal places in the percentage.
+ * @returns {string} The percentage string.
  * @category Util
  */
-declare function isUdfOrNul(val: MazeyObject): boolean;
+declare function floatToPercent(num: number, fixSize?: number): string;
 /**
- * Verify the validity of an array.
+ * Format a number with a fixed number of decimal places.
  *
  * Usage:
  *
  * ```javascript
- * import { isArray } from "mazey";
+ * import { floatFixed } from "mazey";
  *
- * const ret1 = isArray([1, 2, 3]);
- * const ret2 = isArray({ a: 1 });
- * const ret3 = isArray("abc");
- * const ret4 = isArray(null);
- * console.log(ret1, ret2, ret3, ret4);
+ * const ret1 = floatFixed(0.2);
+ * const ret2 = floatFixed(0.2, 2);
+ * console.log(ret1);
+ * console.log(ret2);
  * ```
  *
  * Output:
  *
  * ```text
- * true false false false
+ * 0
+ * 0.20
  * ```
  *
- * @param {MazeyObject} obj The object to verify.
- * @returns {boolean} Return TRUE if the object is an array.
+ * @param num Number or numeric string to format.
+ * @param size Number of decimal places.
+ * @returns The fixed-point string.
  * @category Util
  */
-declare function isArray(obj: MazeyObject): boolean;
+declare function floatFixed(num: number | string, size?: number): string;
 /**
- * Verify the validity of a non-empty object.
+ * Limit how frequently a function can be invoked over time.
  *
  * Usage:
  *
  * ```javascript
- * import { isNonEmptyObject } from "mazey";
+ * import { throttle } from "mazey";
  *
- * const ret1 = isNonEmptyObject({ a: 1 });
- * const ret2 = isNonEmptyObject({});
- * const ret3 = isNonEmptyObject("abc");
- * const ret4 = isNonEmptyObject(null);
- * console.log(ret1, ret2, ret3, ret4);
+ * const foo = throttle(() => {
+ *   console.log("The function will be invoked at most once per every wait 1000 milliseconds.");
+ * }, 1000, { leading: true });
  * ```
  *
- * Output:
- *
- * ```text
- * true false false false
- * ```
+ * Reference: [Lodash](https://lodash.com/docs/4.17.15#throttle)
  *
- * @param obj
- * @returns
+ * @param func Function to throttle.
+ * @param wait Minimum interval between invocations, in milliseconds.
+ * @param options.leading Whether to invoke on the leading edge.
+ * @param options.trailing Whether to invoke on the trailing edge.
+ * @returns The throttled function.
+ * @category Util
  */
-declare function isNonEmptyObject(obj: MazeyObject): boolean;
+declare function throttle<T extends (...args: MazeyFnParams) => MazeyFnReturn>(func: T, wait: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): ThrottleFunc<T>;
 /**
- * Convert newline characters `\n` into HTML line breaks `<br />`.
+ * Delay function execution until the specified time has passed since the last
+ * invocation.
  *
  * Usage:
  *
  * ```javascript
- * import { convertToHtmlBreaks } from "mazey";
- *
- * const ret1 = convertToHtmlBreaks("a\nb\nc");
- * const ret2 = convertToHtmlBreaks("a\n\nbc");
- * console.log(ret1);
- * console.log(ret2);
- * ```
- *
- * Output:
+ * import { debounce } from "mazey";
  *
- * ```text
- * a<br />b<br />c
- * a<br /><br />bc
+ * const foo = debounce(() => {
+ *   console.log("The debounced function will only be invoked in 1000 milliseconds, the other invoking will disappear during the wait time.");
+ * }, 1000, true);
  * ```
  *
- * @param {string} str The string to make a new line.
- * @returns {string} A newline with `br`.
+ * @param func Function to debounce.
+ * @param wait Delay after the last invocation, in milliseconds.
+ * @param immediate Whether to invoke on the leading edge instead.
+ * @returns The debounced function.
  * @category Util
  */
-declare function convertToHtmlBreaks(str: string): string;
-/**
- * Alias of `convertToHtmlBreaks`.
- *
- * @hidden
- */
-declare function newLine(str: string): string;
+declare function debounce<T extends (...args: MazeyFnParams) => MazeyFnReturn>(func: T, wait: number, immediate?: boolean): DebounceFunc<T>;
 /**
- * Remove HTML tags from a string, and optionally newline characters.
+ * Check whether a value is a number allowed by the supplied options.
  *
  * Usage:
  *
  * ```javascript
- * import { removeHTML } from "mazey";
+ * import { isNumber } from "mazey";
  *
- * const ret = removeHTML("<div>hello world</div>");
- * console.log(ret);
+ * const ret1 = isNumber(123);
+ * const ret2 = isNumber("123");
+ * // Default: NaN, Infinity is not Number
+ * const ret3 = isNumber(Infinity);
+ * const ret4 = isNumber(Infinity, { isInfinityAsNumber: true });
+ * const ret5 = isNumber(NaN);
+ * const ret6 = isNumber(NaN, { isNaNAsNumber: true, isInfinityAsNumber: true });
+ * console.log(ret1, ret2, ret3, ret4, ret5, ret6);
  * ```
  *
  * Output:
  *
  * ```text
- * hello world
+ * true false false true false true
  * ```
  *
- * @param {string} str A string that may contain HTML tags.
- * @returns {string} The string with HTML tags removed.
+ * @param {*} num Value to check.
+ * @param options Controls whether `NaN`, `Infinity`, or other non-finite values count as numbers.
+ * @returns {boolean} Whether the value is an allowed number.
  * @category Util
  */
-declare function removeHTML(str: string, options?: {
-    removeNewLine?: boolean;
-}): string;
+declare function isNumber(num: unknown, options?: IsNumberOptions): boolean;
 /**
- * Alias of `removeHTML`.
+ * Invoke a value only when it is a function.
  *
- * @hidden
- */
-declare function removeHtml(str: string, options?: {
-    removeNewLine?: boolean;
-}): string;
-/**
- * Alias of `removeHTML`.
+ * Usage:
  *
- * @hidden
+ * ```javascript
+ * import { invokeFn } from "mazey";
+ *
+ * const ret = invokeFn(() => {
+ *  console.log("invokeFn");
+ * });
+ * ```
+ *
+ * @param {function} fn Potential function to invoke.
+ * @param params Arguments passed to the function.
+ * @returns The function result, or `null` when `fn` is not callable.
+ * @category Util
  */
-declare function clearHTML(str: string, options?: {
-    removeNewLine?: boolean;
-}): string;
+declare function invokeFn(fn: MazeyFunction | null | undefined, ...params: Parameters<MazeyFunction>): ReturnType<MazeyFunction> | null;
 /**
- * Alias of `removeHTML`.
+ * Alias of `invokeFn`.
  *
  * @hidden
  */
-declare function clearHtml(str: string, options?: {
-    removeNewLine?: boolean;
-}): string;
+declare function doFn(fn: MazeyFunction | null | undefined, ...params: Parameters<MazeyFunction>): ReturnType<MazeyFunction> | null;
 /**
- * Sanitizes user input to prevent XSS attacks.
+ * Verify the validity of a non-empty array.
  *
  * Usage:
  *
  * ```javascript
- * import { sanitizeInput } from "mazey";
+ * import { isNonEmptyArray } from "mazey";
  *
- * const ret = sanitizeInput("<div>hello world</div>");
+ * const ret = isNonEmptyArray([1, 2, 3]);
  * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * &lt;div&gt;hello world&lt;/div&gt;
+ * true
  * ```
  *
- * @param input - The input string to sanitize
- * @returns The sanitized input string
  * @category Util
  */
-declare function sanitizeInput(input: string): string;
+declare function isNonEmptyArray<T>(arr: Array<T>): boolean;
 /**
- * Reverses the sanitization done by the `sanitizeInput` function.
+ * Verify the validity of a pure object.
  *
  * Usage:
  *
  * ```javascript
- * import { unsanitizeInput } from "mazey";
+ * import { isPureObject } from "mazey";
  *
- * const ret = unsanitizeInput("&lt;div&gt;hello world&lt;/div&gt;");
- * console.log(ret);
+ * const ret1 = isPureObject({ a: 1 });
+ * const ret2 = isPureObject("abc");
+ * const ret3 = isPureObject(null);
+ * const ret4 = isPureObject([]);
+ *
+ * console.log(ret1, ret2, ret3, ret4);
  * ```
  *
  * Output:
  *
  * ```text
- * <div>hello world</div>
+ * true false false false
  * ```
  *
- * @param input - The input string to unsanitize
- * @returns The unsanitized input string
+ * @param {MazeyObject} obj The object to verify.
+ * @returns {boolean} Return TRUE if the object is a pure object.
  * @category Util
  */
-declare function unsanitizeInput(input: string): string;
-/**
- * Alias of `unsanitizeInput`.
- *
- * @hidden
- */
-declare function unsanitize(str: string): string;
+declare function isPureObject(obj: MazeyObject): boolean;
 /**
- * Truncate a string by weighted length, counting non-ASCII characters as two
- * units.
+ * Verify the validity of a function.
  *
  * Usage:
  *
  * ```javascript
- * import { cutZHString } from "mazey";
+ * import { isFunction } from "mazey";
  *
- * const ret = cutZHString("hello world", 5);
- * console.log(ret);
+ * const ret1 = isFunction(() => {});
+ * const ret2 = isFunction("abc");
+ * const ret3 = isFunction(null);
+ * console.log(ret1, ret2, ret3);
  * ```
  *
  * Output:
  *
  * ```text
- * hello
+ * true false false
  * ```
  *
- * @param {string} str String to truncate.
- * @param {number} len Maximum weighted length.
- * @param {boolean} options.hasDot Whether to append truncation text.
- * @param {string} options.dotText Text appended when truncation occurs.
- * @returns {string} The truncated string.
+ * @param {MazeyObject} fn The function to verify.
+ * @returns {boolean} Return TRUE if the object is a function.
  * @category Util
  */
-declare function cutZHString(str: string | null | undefined, len: number, options?: {
-    hasDot?: boolean;
-    dotText?: string;
-}): string;
+declare function isFunction(fn: MazeyObject): boolean;
 /**
- * Alias of `cutZHString`.
+ * Verify the validity of a string.
  *
  * Usage:
  *
  * ```javascript
- * import { truncateZHString } from "mazey";
+ * import { isString } from "mazey";
  *
- * const ret = truncateZHString("hello world", 5);
- * console.log(ret);
+ * const ret1 = isString("abc");
+ * const ret2 = isString({ a: 1 });
+ * const ret3 = isString(null);
+ * console.log(ret1, ret2, ret3);
  * ```
  *
  * Output:
  *
  * ```text
- * hello
+ * true false false
  * ```
  *
- * @param {string} str String to truncate.
- * @param {number} len Maximum weighted length.
- * @param {boolean} hasDot Whether to append the default truncation text.
- * @returns {string} The truncated string.
- * @hidden
+ * @param {MazeyObject} str The string to verify.
+ * @returns {boolean} Return TRUE if the object is a string.
+ * @category Util
  */
-declare function truncateZHString(str: string | null | undefined, len: number, hasDot?: boolean): string;
+declare function isString(str: MazeyObject): boolean;
 /**
- * Alias of `truncateZHString`.
+ * Verify the validity of a boolean.
  *
- * @hidden
- */
-declare function cutCHSString(str: string | null | undefined, len: number, hasDot?: boolean): string;
-/**
- * Verify the validity of axios response.
+ * Usage:
  *
- * Reference: [Handling Errors](https://axios-http.com/docs/handling_errors)
+ * ```javascript
+ * import { isBool } from "mazey";
+ *
+ * const ret1 = isBool(true);
+ * const ret2 = isBool({ a: 1 });
+ * const ret3 = isBool("abc");
+ * const ret4 = isBool(null);
+ * console.log(ret1, ret2, ret3, ret4);
+ * ```
+ *
+ * Output:
+ *
+ * ```text
+ * true false false false
+ * ```
  *
+ * @param {MazeyObject} bool The boolean to verify.
+ * @returns {boolean} Return TRUE if the object is a boolean.
  * @category Util
- * @hidden
  */
-declare function zAxiosIsValidRes(res: ZResResponse | undefined, options?: ZResIsValidResOptions | null): boolean;
+declare function isBool(bool: MazeyObject): boolean;
 /**
- * Determine the validity of the data.
+ * Alias of `isBool`.
+ */
+declare function isBoolean(bool: MazeyObject): boolean;
+/**
+ * Verify the validity of a value.
  *
  * Usage:
  *
  * ```javascript
- * import { isValidData } from "mazey";
+ * import { isUdfOrNul } from "mazey";
  *
- * const validData = {
- *   a: {
- *     b: {
- *       c: 413
- *     }
- *   }
- * };
- * const isValidDataResA = isValidData(validData, ["a", "b", "c"], 2333);
- * const isValidDataResB = isValidData(validData, ["a", "b", "c"], 413);
- * const isValidDataResC = isValidData(validData, ["d", "d"], 413);
- * console.log("isValidDataResA:", isValidDataResA);
- * console.log("isValidDataResB:", isValidDataResB);
- * console.log("isValidDataResC:", isValidDataResC);
+ * const ret1 = isUdfOrNul(undefined);
+ * const ret2 = isUdfOrNul(null);
+ * const ret3 = isUdfOrNul("abc");
+ * console.log(ret1, ret2, ret3);
  * ```
  *
  * Output:
  *
  * ```text
- * isValidDataResA: false
- * isValidDataResB: true
- * isValidDataResC: false
+ * true true false
  * ```
  *
- * @param {any} data Original Data
- * @param {string[]} attributes Data Attributes
- * @param {any} validValue Given Value for verifying.
- * @returns {boolean} Return TRUE if the data is valid.
+ * @param {MazeyObject} val The value to verify.
+ * @returns {boolean} Return TRUE if the object is undefined or null.
  * @category Util
  */
-declare function isValidData(data: MazeyObject, attributes: string[], validValue: SimpleType): boolean;
+declare function isUdfOrNul(val: MazeyObject): boolean;
 /**
- * Convert a byte count to a human-readable file size.
+ * Verify the validity of an array.
  *
  * Usage:
  *
  * ```javascript
- * import { getFileSize } from "mazey";
+ * import { isArray } from "mazey";
  *
- * const ret = getFileSize(1024);
- * console.log(ret);
+ * const ret1 = isArray([1, 2, 3]);
+ * const ret2 = isArray({ a: 1 });
+ * const ret3 = isArray("abc");
+ * const ret4 = isArray(null);
+ * console.log(ret1, ret2, ret3, ret4);
  * ```
  *
  * Output:
  *
  * ```text
- * 1 KB
+ * true false false false
  * ```
  *
- * @param size File size in bytes.
- * @returns A rounded file-size string, or an empty string for a non-positive or non-finite value.
+ * @param {MazeyObject} obj The object to verify.
+ * @returns {boolean} Return TRUE if the object is an array.
  * @category Util
  */
-declare function getFileSize(size: number): string;
+declare function isArray(obj: MazeyObject): boolean;
 /**
- * Generate a Hash Code from a string.
+ * Verify the validity of a non-empty object.
  *
  * Usage:
  *
  * ```javascript
- * import { genHashCode } from "mazey";
+ * import { isNonEmptyObject } from "mazey";
  *
- * const ret = genHashCode("hello world");
- * console.log(ret);
+ * const ret1 = isNonEmptyObject({ a: 1 });
+ * const ret2 = isNonEmptyObject({});
+ * const ret3 = isNonEmptyObject("abc");
+ * const ret4 = isNonEmptyObject(null);
+ * console.log(ret1, ret2, ret3, ret4);
  * ```
  *
  * Output:
  *
  * ```text
- * 1794106052
+ * true false false false
  * ```
  *
- * Reference: [Generate a Hash from string in Javascript](https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery)
- *
- * @category Util
+ * @param obj
+ * @returns
  */
-declare function genHashCode(str: string): number;
+declare function isNonEmptyObject(obj: MazeyObject): boolean;
 /**
- * Generate a lowercase SHA-256 hexadecimal digest with the Web Crypto API.
+ * Convert newline characters `\n` into HTML line breaks `<br />`.
  *
  * Usage:
  *
  * ```javascript
- * import { sha256Hex } from "mazey";
+ * import { convertToHtmlBreaks } from "mazey";
  *
- * const digest = await sha256Hex("hello world");
- * console.log(digest);
+ * const ret1 = convertToHtmlBreaks("a\nb\nc");
+ * const ret2 = convertToHtmlBreaks("a\n\nbc");
+ * console.log(ret1);
+ * console.log(ret2);
  * ```
  *
  * Output:
  *
  * ```text
- * b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
+ * a<br />b<br />c
+ * a<br /><br />bc
  * ```
  *
- * @remarks Requires Web Crypto. String input also requires `TextEncoder`.
- * @param input Text or binary data to hash.
- * @returns A promise that resolves to the lowercase hexadecimal digest.
- * @throws When the required platform API is unavailable. Digest failures are propagated.
+ * @param {string} str The string to make a new line.
+ * @returns {string} A newline with `br`.
  * @category Util
  */
-declare function sha256Hex(input: string | BufferSource): Promise<string>;
+declare function convertToHtmlBreaks(str: string): string;
 /**
- * Check whether an unknown value represents a valid date.
- *
- * Valid inputs include `Date` instances, finite millisecond timestamps,
- * structured local date strings, and ISO 8601 strings with `Z` or a numeric
- * timezone offset. Structured strings are parsed into numeric components and
- * validated strictly, so invalid calendar dates are not normalized.
+ * Alias of `convertToHtmlBreaks`.
  *
- * Supported string forms are `YYYY-MM-DD`, `YYYY-MM-DD HH:mm[:ss]`,
- * `YYYY-MM-DDTHH:mm[:ss]`, and the same `T`-separated date-time with `Z` or
- * a `+HH:mm`/`-HH:mm` offset. Zoned strings may include 1-3 millisecond digits.
+ * @hidden
+ */
+declare function newLine(str: string): string;
+/**
+ * Remove HTML tags from a string, and optionally newline characters.
  *
  * Usage:
  *
  * ```javascript
- * import { isValidDate } from "mazey";
- *
- * const ret1 = isValidDate(1577877720000);
- * const ret2 = isValidDate("2020-01-01 11:22");
- * const ret3 = isValidDate("2020-02-30");
- * const ret4 = isValidDate(new Date("invalid"));
+ * import { removeHTML } from "mazey";
  *
- * console.log(ret1, ret2, ret3, ret4);
+ * const ret = removeHTML("<div>hello world</div>");
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * true true false false
+ * hello world
  * ```
  *
- * @param value A `Date`, millisecond timestamp, or supported structured date string.
- * @returns Whether the value represents a valid date.
- * @category Util
+ * @param {string} str A string that may contain HTML tags.
+ * @returns {string} The string with HTML tags removed.
+ * @category Util
+ */
+declare function removeHTML(str: string, options?: {
+    removeNewLine?: boolean;
+}): string;
+/**
+ * Alias of `removeHTML`.
+ *
+ * @hidden
+ */
+declare function removeHtml(str: string, options?: {
+    removeNewLine?: boolean;
+}): string;
+/**
+ * Alias of `removeHTML`.
+ *
+ * @hidden
+ */
+declare function clearHTML(str: string, options?: {
+    removeNewLine?: boolean;
+}): string;
+/**
+ * Alias of `removeHTML`.
+ *
+ * @hidden
  */
-declare function isValidDate(value: unknown): boolean;
+declare function clearHtml(str: string, options?: {
+    removeNewLine?: boolean;
+}): string;
 /**
- * Check whether a date is today in the runtime's local timezone.
+ * Sanitizes user input to prevent XSS attacks.
  *
  * Usage:
  *
  * ```javascript
- * import { isToday } from "mazey";
+ * import { sanitizeInput } from "mazey";
  *
- * const ret = isToday(new Date());
+ * const ret = sanitizeInput("<div>hello world</div>");
  * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * true
+ * &lt;div&gt;hello world&lt;/div&gt;
  * ```
  *
- * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
- * @returns Whether the value has the current local year, month, and day. Invalid input returns `false`.
- * @remarks Hours, minutes, seconds, and milliseconds are ignored. Results depend on the runtime's local timezone.
+ * @param input - The input string to sanitize
+ * @returns The sanitized input string
  * @category Util
  */
-declare function isToday(date: MazeyDate): boolean;
+declare function sanitizeInput(input: string): string;
 /**
- * Check whether a date is in the current local calendar year.
+ * Reverses the sanitization done by the `sanitizeInput` function.
  *
  * Usage:
  *
  * ```javascript
- * import { isThisYear } from "mazey";
+ * import { unsanitizeInput } from "mazey";
  *
- * const ret = isThisYear(new Date());
+ * const ret = unsanitizeInput("&lt;div&gt;hello world&lt;/div&gt;");
  * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * true
+ * <div>hello world</div>
  * ```
  *
- * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
- * @returns Whether the value has the current local year. Invalid input returns `false`.
- * @remarks Results depend on the runtime's local timezone.
+ * @param input - The input string to unsanitize
+ * @returns The unsanitized input string
  * @category Util
  */
-declare function isThisYear(date: MazeyDate): boolean;
+declare function unsanitizeInput(input: string): string;
 /**
- * Check whether a date is in the current local calendar month and year.
+ * Alias of `unsanitizeInput`.
+ *
+ * @hidden
+ */
+declare function unsanitize(str: string): string;
+/**
+ * Truncate a string by weighted length, counting non-ASCII characters as two
+ * units.
  *
  * Usage:
  *
  * ```javascript
- * import { isThisMonth } from "mazey";
+ * import { cutZHString } from "mazey";
  *
- * const ret = isThisMonth(new Date());
+ * const ret = cutZHString("hello world", 5);
  * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * true
+ * hello
  * ```
  *
- * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
- * @returns Whether the value has the current local year and month. Invalid input returns `false`.
- * @remarks Results depend on the runtime's local timezone.
+ * @param {string} str String to truncate.
+ * @param {number} len Maximum weighted length.
+ * @param {boolean} options.hasDot Whether to append truncation text.
+ * @param {string} options.dotText Text appended when truncation occurs.
+ * @returns {string} The truncated string.
  * @category Util
  */
-declare function isThisMonth(date: MazeyDate): boolean;
+declare function cutZHString(str: string | null | undefined, len: number, options?: {
+    hasDot?: boolean;
+    dotText?: string;
+}): string;
 /**
- * Check whether a date is in the current Monday-first local calendar week.
+ * Alias of `cutZHString`.
  *
  * Usage:
  *
  * ```javascript
- * import { isThisWeek } from "mazey";
+ * import { truncateZHString } from "mazey";
  *
- * const ret = isThisWeek(new Date());
+ * const ret = truncateZHString("hello world", 5);
  * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * true
+ * hello
  * ```
  *
- * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
- * @returns Whether the value is in the current local week. Invalid input returns `false`.
- * @remarks The week begins on Monday and ends before the following Monday. Boundaries use local time and a half-open range.
+ * @param {string} str String to truncate.
+ * @param {number} len Maximum weighted length.
+ * @param {boolean} hasDot Whether to append the default truncation text.
+ * @returns {string} The truncated string.
+ * @hidden
+ */
+declare function truncateZHString(str: string | null | undefined, len: number, hasDot?: boolean): string;
+/**
+ * Alias of `truncateZHString`.
+ *
+ * @hidden
+ */
+declare function cutCHSString(str: string | null | undefined, len: number, hasDot?: boolean): string;
+/**
+ * Verify the validity of axios response.
+ *
+ * Reference: [Handling Errors](https://axios-http.com/docs/handling_errors)
+ *
  * @category Util
+ * @hidden
  */
-declare function isThisWeek(date: MazeyDate): boolean;
+declare function zAxiosIsValidRes(res: ZResResponse | undefined, options?: ZResIsValidResOptions | null): boolean;
 /**
- * Check whether a date is within the current local clock hour.
+ * Determine the validity of the data.
  *
  * Usage:
  *
  * ```javascript
- * import { isThisHour } from "mazey";
+ * import { isValidData } from "mazey";
  *
- * const ret = isThisHour(new Date());
- * console.log(ret);
+ * const validData = {
+ *   a: {
+ *     b: {
+ *       c: 413
+ *     }
+ *   }
+ * };
+ * const isValidDataResA = isValidData(validData, ["a", "b", "c"], 2333);
+ * const isValidDataResB = isValidData(validData, ["a", "b", "c"], 413);
+ * const isValidDataResC = isValidData(validData, ["d", "d"], 413);
+ * console.log("isValidDataResA:", isValidDataResA);
+ * console.log("isValidDataResB:", isValidDataResB);
+ * console.log("isValidDataResC:", isValidDataResC);
  * ```
  *
  * Output:
  *
  * ```text
- * true
+ * isValidDataResA: false
+ * isValidDataResB: true
+ * isValidDataResC: false
  * ```
  *
- * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
- * @returns Whether the value has the current local year, month, day, and hour. Invalid input returns `false`.
- * @remarks Minutes, seconds, and milliseconds are ignored. Results depend on the runtime's local timezone.
+ * @param {any} data Original Data
+ * @param {string[]} attributes Data Attributes
+ * @param {any} validValue Given Value for verifying.
+ * @returns {boolean} Return TRUE if the data is valid.
  * @category Util
  */
-declare function isThisHour(date: MazeyDate): boolean;
+declare function isValidData(data: MazeyObject, attributes: string[], validValue: SimpleType): boolean;
 /**
- * Format the absolute distance from a date to now in concise English words.
+ * Options for formatting a byte count.
  *
- * Usage:
+ * @category Util
+ */
+interface FormatByteSizeOptions {
+    /** Unit scale. Defaults to `1024`. */
+    base?: 1000 | 1024;
+    /** Decimal places for rounded values. Must be an integer from 0 to 20. Defaults to `1`. */
+    fractionDigits?: number;
+    /** Returned for negative, non-finite, or otherwise invalid input. Defaults to an empty string. */
+    invalidValue?: string;
+}
+/**
+ * Format a non-negative byte count using `B`, `KB`, `MB`, `GB`, or `TB`.
  *
- * ```javascript
- * import { formatDistanceToNow } from "mazey";
+ * Scaling defaults to 1024 with one fractional digit. Byte values omit
+ * insignificant trailing zeroes, while scaled values retain the requested
+ * number of fractional digits. Values beyond terabytes remain expressed in
+ * `TB`.
  *
- * const ret = formatDistanceToNow(new Date(Date.now() - 60 * 60 * 1000));
- * console.log(ret);
- * ```
+ * Usage:
  *
- * Output:
+ * ```javascript
+ * import { formatByteSize } from "mazey";
  *
- * ```text
- * about 1 hour
+ * formatByteSize(0);       // "0 B"
+ * formatByteSize(1536);    // "1.5 KB"
+ * formatByteSize(1500000, { base: 1000, fractionDigits: 2 }); // "1.50 MB"
  * ```
  *
- * @param date A `Date`, millisecond timestamp, or string accepted by `isValidDate`.
- * @returns The absolute approximate distance phrase, or an empty string for invalid input.
- * @remarks Past and future dates use the same wording without `ago` or `in`. Months and years use fixed approximate durations of 30 and 365 days.
+ * @param bytes Byte count to format.
+ * @param options Formatting options.
+ * @returns A formatted byte-size string, or `invalidValue` for invalid input.
  * @category Util
  */
-declare function formatDistanceToNow(date: MazeyDate): string;
+declare function formatByteSize(bytes: number, options?: FormatByteSizeOptions): string;
 /**
- * Return the formatted date string in the given format.
- *
- * Supported format tokens:
+ * Deprecated alias of `formatByteSize`.
  *
- * | Token  | Meaning                                | Range or example |
- * | ------ | -------------------------------------- | ---------------- |
- * | `yyyy` | Four-digit year                        | `2022`           |
- * | `MM`   | Two-digit month                        | `01`–`12`        |
- * | `dd`   | Two-digit day of the month             | `01`–`31`        |
- * | `HH`   | Two-digit hour using the 24-hour clock | `00`–`23`        |
- * | `hh`   | Two-digit hour using the 12-hour clock | `01`–`12`        |
- * | `mm`   | Two-digit minute                       | `00`–`59`        |
- * | `ss`   | Two-digit second                       | `00`–`59`        |
- * | `a`    | Uppercase meridiem indicator           | `AM` or `PM`     |
- *
- * The function creates a native `Date` and reads its local date and time
- * fields. Timestamp output can therefore differ between runtime time zones.
+ * @deprecated Use `formatByteSize` instead.
+ * @param size Byte count to format.
+ * @param options Formatting options.
+ * @returns The result of `formatByteSize`.
+ * @category Util
+ */
+declare function getFileSize(size: number, options?: FormatByteSizeOptions): string;
+/**
+ * Generate a Hash Code from a string.
  *
  * Usage:
  *
  * ```javascript
- * import { formatDate } from "mazey";
+ * import { genHashCode } from "mazey";
  *
- * const ret1 = formatDate();
- * const ret2 = formatDate("Tue Jan 11 2022 14:12:26 GMT+0800 (China Standard Time)", "yyyy-MM-dd hh:mm:ss a");
- * const ret3 = formatDate(1641881235000, "yyyy-MM-dd hh:mm:ss a");
- * const ret4 = formatDate(new Date(2014, 1, 11), "MM/dd/yyyy");
- * console.log("Default formatDate value:", ret1);
- * console.log("String formatDate value:", ret2);
- * console.log("Number formatDate value:", ret3);
- * console.log("Date formatDate value:", ret4);
+ * const ret = genHashCode("hello world");
+ * console.log(ret);
  * ```
  *
  * Output:
  *
  * ```text
- * Default formatDate value: 2023-01-11
- * String formatDate value: 2022-01-11 02:12:26 PM
- * Number formatDate value: 2022-01-11 02:07:15 PM
- * Date formatDate value: 02/11/2014
+ * 1794106052
  * ```
  *
- * @param {MazeyDate} dateIns Original date value. Defaults to the current date and time.
- * @param {string} format Format string composed of supported format tokens. Defaults to `yyyy-MM-dd`.
- * @returns {string} The formatted date string.
- * @throws {RangeError} If `dateIns` is not a valid date.
+ * Reference: [Generate a Hash from string in Javascript](https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery)
+ *
  * @category Util
  */
-declare function formatDate(dateIns?: MazeyDate, format?: string): string;
+declare function genHashCode(str: string): number;
 /**
- * Generate a local-time Calendar Versioning string from a date.
- *
- * The conceptual format is `yyyy.MMdd.HHmmss`. Leading zeroes are removed
- * from each segment to keep numeric Semantic Versioning identifiers valid.
+ * Generate a lowercase SHA-256 hexadecimal digest with the Web Crypto API.
  *
  * Usage:
  *
  * ```javascript
- * import { generateCalendarVersion } from "mazey";
+ * import { sha256Hex } from "mazey";
  *
- * const ret = generateCalendarVersion(new Date(2026, 6, 11, 7, 40, 35));
- * console.log(ret);
+ * const digest = await sha256Hex("hello world");
+ * console.log(digest);
  * ```
  *
  * Output:
  *
  * ```text
- * 2026.711.74035
+ * b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
  * ```
  *
- * @param {MazeyDate} dateIns Original date. Defaults to the current date.
- * @returns {string} Return the generated calendar version.
- * @throws {RangeError} If `dateIns` is not a valid date.
+ * @remarks Requires Web Crypto. String input also requires `TextEncoder`.
+ * @param input Text or binary data to hash.
+ * @returns A promise that resolves to the lowercase hexadecimal digest.
+ * @throws When the required platform API is unavailable. Digest failures are propagated.
  * @category Util
  */
-declare function generateCalendarVersion(dateIns?: MazeyDate): string;
+declare function sha256Hex(input: string | BufferSource): Promise<string>;
 /**
  * Check if the given string is a mobile phone number.
  *
@@ -3240,6 +3448,79 @@ declare function getTTFB(): Promise<number>;
  */
 declare function getPerformance(camelCase?: boolean): Promise<WebPerformance>;
 
+/**
+ * Conservative visitor classifications detected from supported browser-side
+ * signals.
+ *
+ * - `"crawler"`: a known crawler or automated-fetcher user-agent token matched.
+ * - `"automation"`: an explicit automation user-agent token matched or
+ *   `navigator.webdriver` is `true`.
+ * - `"unknown"`: no supported crawler or automation signal was detected.
+ *
+ * `"unknown"` does not mean that the visitor is verified as human.
+ *
+ * @remarks This heuristic result is not suitable for authentication,
+ * authorization, fraud prevention, access control, or other security decisions.
+ * @category Browser Information
+ */
+type VisitorType = "crawler" | "automation" | "unknown";
+/**
+ * Classify a visitor using conservative browser-side heuristics.
+ *
+ * Classification checks known crawler and automated-fetcher user-agent tokens
+ * first. It then checks explicit browser-automation user-agent tokens and
+ * `navigator.webdriver === true`. All other visitors return `"unknown"`.
+ *
+ * `"unknown"` means that no supported signal was detected. It does not verify
+ * that the visitor is human. User-agent values can be modified or spoofed, and
+ * automation signals can be hidden, modified, or unavailable. Both false
+ * positives and false negatives are possible.
+ *
+ * Usage:
+ *
+ * ```typescript
+ * import { detectVisitorType } from "mazey";
+ *
+ * const visitorType = detectVisitorType();
+ * console.log(visitorType);
+ * ```
+ *
+ * Possible output:
+ *
+ * ```text
+ * unknown
+ * ```
+ *
+ * Explicit user-agent:
+ *
+ * ```typescript
+ * const visitorType = detectVisitorType(
+ *   "Mozilla/5.0 (compatible; Googlebot/2.1)"
+ * );
+ *
+ * console.log(visitorType);
+ * ```
+ *
+ * Output:
+ *
+ * ```text
+ * crawler
+ * ```
+ *
+ * @param userAgent Optional user-agent string. Defaults to
+ * `navigator.userAgent` when available. An explicit value replaces only the
+ * user-agent source; the current browser's WebDriver signal is still checked.
+ * @returns `"crawler"`, `"automation"`, or `"unknown"`, in that priority.
+ * @throws {TypeError} If an explicitly supplied user agent is not a string.
+ * @remarks Safe during SSR and in Node.js. This is a heuristic classification
+ * utility, not human verification, crawler authentication, or a security
+ * boundary. Do not use it by itself for authentication, authorization,
+ * payments, rate limiting, fraud prevention, access control, or
+ * security-sensitive content. Genuine crawler verification generally requires
+ * server-side request information and provider-specific validation.
+ * @category Browser Information
+ */
+declare function detectVisitorType(userAgent?: string): VisitorType;
 /**
  * Options for {@link isSafePWAEnv}.
  *
@@ -3658,5 +3939,5 @@ declare const mazeyCon: Console;
  */
 declare const timeCon: Console;
 
-export { addClass, addEvent, addStyle, calLongestCommonSubsequence, calLongestCommonSubstring, camelCase2Underscore, camelCaseToKebabCase, cancelBubble, clearHTML, clearHtml, convert10To26, convertCamelToKebab, convertCamelToUnder, convertHttpToHttps, convertKebabToCamel, convertObjectToQuery, convertToHtmlBreaks, convertUnderToCamel, cutCHSString, cutZHString, debounce, deepCopy, deepCopyObject, deepFreeze, delCookie, doFn, extractElementText, fireEvent, floatFixed, floatToPercent, formatDate, formatDistanceToNow, formatDurationFromMs, genBrowserAttrs, genCustomConsole, genHashCode, genRndNumString, genStyleString, genUniqueNumString, generateCalendarVersion, generateRndNum, generateUniqueNum, getAllQueryParams, getBrowserInfo, getCLS, getCookie, getCurrentVersion, getDateDifference, getDefineListeners, getDomain, getFCP, getFID, getFP, getFileSize, getFriendlyInterval, getHashQueryParam, getLCP, getLocalStorage, getPageMeta, getPerformance, getQueryParam, getScriptQueryParam, getSessionStorage, getTTFB, getUrlFileType, getUrlHost, getUrlParam, getUrlPath, hasClass, inRate, invokeEvent, invokeFn, isArray, isBool, isBoolean, isBrowser, isFunction, isHit, isJSONString, isJsonString, isNonEmptyArray, isNonEmptyObject, isNumber, isPureObject, isSafePWAEnv, isStandalonePWA, isString, isSupportWebp, isSupportedEntryType, isThisHour, isThisMonth, isThisWeek, isThisYear, isToday, isUdfOrNul, isValidCssSelector, isValidData, isValidDate, isValidEmail, isValidHttpUrl, isValidPhoneNumber, isValidUrl, loadCSS, loadImage, loadScript, loadScriptIfUndefined, longestComSubsequence, longestComSubstring, mNow, mTrim, mazeyCon, newLine, onURLChange, parseGitHubRepository, parseJsonSafe, removeClass, removeCookie, removeEvent, removeHTML, removeHtml, repeatUntilConditionMet, replaceHttp, resolveLanguagePreference, resolveThemePreference, sanitizeInput, setClass, setCookie, setImgSizeBySrc, setImgWidHeiBySrc, setLanguagePreference, setLocalStorage, setSessionStorage, setThemePreference, sha256Hex, sleep, throttle, timeCon, toJavaScriptGlobalName, truncateZHString, unsanitize, unsanitizeInput, updateQueryParam, waitTime, windowLoaded, zAxiosIsValidRes };
-export type { GitHubRepositoryDetails, IsSafePWAEnvOptions, PreferenceResult, ResolvedTheme, ThemePreference };
+export { addClass, addEvent, addStyle, assignDefined, calLongestCommonSubsequence, calLongestCommonSubstring, calculateCAGR, camelCase2Underscore, camelCaseToKebabCase, cancelBubble, clearHTML, clearHtml, convert10To26, convertCamelToKebab, convertCamelToUnder, convertHttpToHttps, convertKebabToCamel, convertObjectToQuery, convertToHtmlBreaks, convertUnderToCamel, cutCHSString, cutZHString, debounce, deepCopy, deepCopyObject, deepFreeze, delCookie, detectVisitorType, doFn, extractElementText, fireEvent, floatFixed, floatToPercent, formatByteSize, formatDate, formatDistanceToNow, formatDurationFromMs, formatLocalDateTime, genBrowserAttrs, genCustomConsole, genHashCode, genRndNumString, genStyleString, genUniqueNumString, generateCalendarVersion, generateRndNum, generateUniqueNum, getAllQueryParams, getBrowserInfo, getCLS, getCookie, getCurrentVersion, getDateDifference, getDefineListeners, getDomain, getFCP, getFID, getFP, getFileSize, getFriendlyInterval, getHashQueryParam, getLCP, getLocalStorage, getPageMeta, getPerformance, getQueryParam, getScriptQueryParam, getSessionStorage, getTTFB, getUrlFileType, getUrlHost, getUrlParam, getUrlPath, hasClass, inRate, invokeEvent, invokeFn, isArray, isBool, isBoolean, isBrowser, isFunction, isHit, isJSONString, isJsonString, isNonEmptyArray, isNonEmptyObject, isNumber, isPureObject, isSafePWAEnv, isStandalonePWA, isString, isSupportWebp, isSupportedEntryType, isThisHour, isThisMonth, isThisWeek, isThisYear, isToday, isUdfOrNul, isValidCssSelector, isValidData, isValidDate, isValidEmail, isValidHttpUrl, isValidPhoneNumber, isValidUrl, loadCSS, loadImage, loadScript, loadScriptIfUndefined, longestComSubsequence, longestComSubstring, mNow, mTrim, mazeyCon, newLine, onURLChange, parseGitHubRepository, parseJsonSafe, parseLocalDateTime, removeClass, removeCookie, removeEvent, removeHTML, removeHtml, repeatUntilConditionMet, replaceHttp, resolveLanguagePreference, resolveThemePreference, sanitizeInput, setClass, setCookie, setImgSizeBySrc, setImgWidHeiBySrc, setLanguagePreference, setLocalStorage, setSessionStorage, setThemePreference, sha256Hex, sleep, throttle, timeCon, toJavaScriptGlobalName, truncateZHString, unsanitize, unsanitizeInput, updateQueryParam, waitTime, windowLoaded, zAxiosIsValidRes };
+export type { FormatByteSizeOptions, GitHubRepositoryDetails, InvestmentReturnRate, IsSafePWAEnvOptions, LocalDateTimePrecision, PreferenceResult, ResolvedTheme, ThemePreference, VisitorType };