@pmun/utils 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,1201 @@
+import { Dayjs, QUnitType, OpUnitType, ManipulateType } from 'dayjs';
+
+/**
+ * @module 数组操作
+ * @description 提供各种数组处理函数，包括数组转换、查询、过滤等实用功能。这些函数都不会修改原始数组，而是返回新的数组或值。
+ */
+/**
+ * 从数组中移除指定的项
+ * @param array 原始数组
+ * @param item 要移除的项
+ * @returns 移除指定项后的新数组，不会修改原始数组
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5]
+ * const newArray = remove(numbers, 3) // [1, 2, 4, 5]
+ * console.log(numbers) // 原数组不变: [1, 2, 3, 4, 5]
+ *
+ * // 移除字符串
+ * const fruits = ['苹果', '香蕉', '橙子']
+ * const newFruits = remove(fruits, '香蕉') // ['苹果', '橙子']
+ * ```
+ */
+declare function remove<T>(array: T[], item: T): T[];
+/**
+ * 数组去重，移除数组中的重复元素
+ * @param array 原始数组
+ * @returns 去重后的新数组，保持原始顺序
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 2, 3, 3, 4, 5, 5]
+ * const uniqueArray = unique(numbers) // [1, 2, 3, 4, 5]
+ *
+ * // 对象数组会基于引用去重，内容相同但引用不同的对象会被视为不同元素
+ * const objArray = [{id: 1}, {id: 2}, {id: 1}]
+ * const uniqueObjArray = unique(objArray) // [{id: 1}, {id: 2}, {id: 1}]
+ * ```
+ */
+declare function unique<T>(array: T[]): T[];
+/**
+ * 将数组分成指定大小的块
+ * @param array 原始数组
+ * @param size 每个块的大小，必须为正整数
+ * @returns 二维数组，每个子数组最多包含 size 个元素
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * const chunks = chunk(numbers, 3)
+ * // 结果: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
+ *
+ * // 如果 size 小于等于 0，则返回包含原始数组的数组
+ * chunk(numbers, 0) // [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
+ * ```
+ */
+declare function chunk<T>(array: T[], size: number): T[][];
+/**
+ * 获取数组中的最后一个元素
+ * @param array 数组
+ * @returns 最后一个元素，如果数组为空则返回 undefined
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5]
+ * const lastNumber = last(numbers) // 5
+ *
+ * const empty = []
+ * const lastEmpty = last(empty) // undefined
+ * ```
+ */
+declare function last<T>(array: T[]): T | undefined;
+/**
+ * 获取数组中的第一个元素
+ * @param array 数组
+ * @returns 第一个元素，如果数组为空则返回 undefined
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5]
+ * const firstNumber = first(numbers) // 1
+ *
+ * const empty = []
+ * const firstEmpty = first(empty) // undefined
+ * ```
+ */
+declare function first<T>(array: T[]): T | undefined;
+/**
+ * 随机打乱数组元素顺序
+ * @param array 原始数组
+ * @returns 打乱后的新数组，不会修改原始数组
+ * @example
+ * ```ts
+ * const numbers = [1, 2, 3, 4, 5]
+ * const shuffled = shuffle(numbers)
+ * // 可能的结果: [3, 1, 5, 2, 4]
+ * console.log(numbers) // 原数组不变: [1, 2, 3, 4, 5]
+ * ```
+ */
+declare function shuffle<T>(array: T[]): T[];
+/**
+ * 从数组中随机选择一个元素
+ * @param array 数组
+ * @returns 随机选择的元素，如果数组为空则返回 undefined
+ * @example
+ * ```ts
+ * const fruits = ['苹果', '香蕉', '橙子', '梨', '葡萄']
+ * const randomFruit = sample(fruits)
+ * // 可能返回: '香蕉'
+ *
+ * const empty = []
+ * const emptyResult = sample(empty) // undefined
+ * ```
+ */
+declare function sample<T>(array: T[]): T | undefined;
+/**
+ * 比较两个数组是否相等（元素顺序和值都相同）
+ * @param a 第一个数组
+ * @param b 第二个数组
+ * @returns 如果两个数组长度相同且对应位置的元素全部相等则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isEqual([1, 2, 3], [1, 2, 3]) // true
+ * isEqual([1, 2, 3], [1, 3, 2]) // false，顺序不同
+ * isEqual([1, 2, 3], [1, 2]) // false，长度不同
+ *
+ * // 对象比较是基于引用的
+ * const obj = { id: 1 }
+ * isEqual([obj], [obj]) // true，同一个对象引用
+ * isEqual([{ id: 1 }], [{ id: 1 }]) // false，不同对象引用
+ * ```
+ */
+declare function isEqual<T>(a: T[], b: T[]): boolean;
+/**
+ * 根据条件对数组中的元素进行分组
+ * @param array 原始数组
+ * @param keyFn 用于生成分组键的函数，接收数组元素并返回用作分组键的值
+ * @returns 分组后的对象，键为分组键，值为对应的元素数组
+ * @example
+ * ```ts
+ * const people = [
+ *   { name: '张三', age: 25 },
+ *   { name: '李四', age: 30 },
+ *   { name: '王五', age: 25 },
+ *   { name: '赵六', age: 30 }
+ * ]
+ *
+ * // 按年龄分组
+ * const groupedByAge = groupBy(people, person => person.age)
+ * // 结果:
+ * // {
+ * //   25: [{ name: '张三', age: 25 }, { name: '王五', age: 25 }],
+ * //   30: [{ name: '李四', age: 30 }, { name: '赵六', age: 30 }]
+ * // }
+ *
+ * // 使用字符串键
+ * const groupedByAgeRange = groupBy(people, person =>
+ *   person.age < 30 ? '青年' : '成年')
+ * // 结果:
+ * // {
+ * //   '青年': [{ name: '张三', age: 25 }, { name: '王五', age: 25 }],
+ * //   '成年': [{ name: '李四', age: 30 }, { name: '赵六', age: 30 }]
+ * // }
+ * ```
+ */
+declare function groupBy<T, K extends string | number | symbol>(array: T[], keyFn: (item: T) => K): Record<K, T[]>;
+/**
+ * 在选项数组前添加一个"全部"选项
+ *
+ * @param options - 原始选项数组
+ * @param config - 配置选项
+ * @param config.name - 选项标签的字段名 (默认为 'label')
+ * @param config.value - "全部"选项的值 (默认为 '')
+ * @param config.valueKey - 选项值的字段名 (默认为 'value')
+ * @returns 添加了"全部"选项的新数组
+ *
+ * @example
+ * ```ts
+ * // 基本用法
+ * const options = [
+ * { label: '选项1', value: 1 },
+ * { label: '选项2', value: 2 }
+ * ]
+ * const result = appendUniversalOption(options)
+ * // 结果: [
+ * //    { label: '全部', value: '' },
+ * //    { label: '选项1', value: 1 },
+ * //    { label: '选项2', value: 2 }
+ * // ]
+ *
+ * // 自定义字段名和值
+ * const customOptions = [
+ * { text: '选项1', id: 1 },
+ * { text: '选项2', id: 2 }
+ * ]
+ * const customResult = appendUniversalOption(customOptions, {
+ * name: 'text',
+ * valueKey: 'id',
+ * value: 0
+ * })
+ * // 结果: [
+ * //    { text: '全部', id: 0 },
+ * //    { text: '选项1', id: 1 },
+ * //    { text: '选项2', id: 2 }
+ * // ]
+ * ```
+ */
+declare function appendUniversalOption<T extends Record<string, any>, V = any>(options: T[], { name, value, valueKey, }?: {
+    name?: string;
+    value?: V;
+    valueKey?: string;
+}): T[];
+
+/**
+ * 创建 dayjs 对象
+ * @param date 日期参数，可以是日期对象、时间戳或日期字符串
+ * @returns dayjs 对象
+ * @example
+ * ```ts
+ * createDate() // 当前日期时间
+ * createDate('2023-05-15') // 指定日期
+ * createDate(1684123456000) // 时间戳
+ * ```
+ */
+declare function createDate(date?: string | number | Date | Dayjs): Dayjs;
+/**
+ * 格式化日期为指定格式的字符串
+ * @param date 日期对象、时间戳或日期字符串
+ * @param format 格式字符串，支持的占位符请参考 dayjs 文档
+ * @returns 格式化后的日期字符串
+ * @example
+ * ```ts
+ * formatDate(new Date(), 'YYYY-MM-DD HH:mm:ss') // "2023-05-16 14:30:45"
+ * formatDate('2023-05-15', 'YYYY年MM月DD日') // "2023年05月15日"
+ * formatDate(1684123456000, 'MM/DD/YYYY') // "05/15/2023"
+ * ```
+ */
+declare function formatDate(date: Date | string | number, format?: string): string;
+/**
+ * 获取当前日期时间的时间戳
+ * @returns 当前时间戳（毫秒）
+ * @example
+ * ```ts
+ * now() // 例如: 1684123456789
+ * ```
+ */
+declare function now(): number;
+/**
+ * 解析日期字符串为日期对象
+ * @param dateStr 日期字符串
+ * @returns 日期对象
+ * @throws 如果日期格式无效，抛出 TypeError
+ * @example
+ * ```ts
+ * parseDate('2023-05-15') // Date 对象: Mon May 15 2023 00:00:00
+ * parseDate('2023/05/15 14:30:45') // Date 对象: Mon May 15 2023 14:30:45
+ * parseDate('invalid date') // 抛出 TypeError: 无效的日期格式
+ * ```
+ */
+declare function parseDate(dateStr: string): Date;
+/**
+ * 计算两个日期之间的差异
+ * @param date1 第一个日期
+ * @param date2 第二个日期
+ * @param unit 计量单位，默认为 'day'，可以是 'year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'
+ * @returns 两个日期之间的差值，正数表示 date1 晚于 date2，负数表示 date1 早于 date2
+ * @example
+ * ```ts
+ * diff('2023-05-15', '2023-05-10') // 5（相差5天）
+ * diff('2023-05-15', '2023-06-15', 'month') // -1（相差1个月，且第一个日期早于第二个）
+ * diff('2023-05-15 08:00', '2023-05-15 06:00', 'hour') // 2（相差2小时）
+ * ```
+ */
+declare function diff(date1: Date | string | number, date2: Date | string | number, unit?: QUnitType | OpUnitType): number;
+/**
+ * 向日期添加指定时间
+ * @param date 原始日期
+ * @param amount 要添加的数量，可以为负数
+ * @param unit 时间单位，默认为 'day'，可以是 'year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'
+ * @returns 添加后的新日期对象
+ * @example
+ * ```ts
+ * add(new Date('2023-05-15'), 2, 'day') // Date 对象: Wed May 17 2023
+ * add('2023-05-15', -1, 'month') // Date 对象: Sat Apr 15 2023
+ * add('2023-05-15 12:00', 30, 'minute') // Date 对象: Mon May 15 2023 12:30:00
+ * ```
+ */
+declare function add(date: Date | string | number, amount: number, unit?: ManipulateType): Date;
+/**
+ * 向日期添加指定天数
+ * @param date 原始日期
+ * @param days 要添加的天数（可以为负数）
+ * @returns 添加天数后的新日期对象
+ * @example
+ * ```ts
+ * addDays(new Date('2023-05-15'), 5) // Date 对象: Sat May 20 2023
+ * addDays('2023-05-15', -3) // Date 对象: Fri May 12 2023
+ * ```
+ */
+declare function addDays(date: Date | string | number, days: number): Date;
+/**
+ * 向日期添加指定月数
+ * @param date 原始日期
+ * @param months 要添加的月数（可以为负数）
+ * @returns 添加月数后的新日期对象
+ * @example
+ * ```ts
+ * addMonths(new Date('2023-05-15'), 2) // Date 对象: Sat Jul 15 2023
+ * addMonths('2023-05-31', 1) // Date 对象: Fri Jun 30 2023（注意月份天数自动调整）
+ * addMonths('2023-01-15', -3) // Date 对象: Wed Oct 15 2022
+ * ```
+ */
+declare function addMonths(date: Date | string | number, months: number): Date;
+/**
+ * 向日期添加指定年数
+ * @param date 原始日期
+ * @param years 要添加的年数（可以为负数）
+ * @returns 添加年数后的新日期对象
+ * @example
+ * ```ts
+ * addYears(new Date('2023-05-15'), 1) // Date 对象: Wed May 15 2024
+ * addYears('2023-05-15', -3) // Date 对象: Fri May 15 2020
+ * addYears('2024-02-29', 1) // Date 对象: Fri Feb 28 2025（注意闰年自动调整）
+ * ```
+ */
+declare function addYears(date: Date | string | number, years: number): Date;
+/**
+ * 获取指定日期是一周中的第几天
+ * @param date 日期
+ * @param startOnMonday 是否从周一开始计算（默认为 false，即从周日开始）
+ * @returns 一周中的第几天（0-6），周日为 0，周六为 6；如果 startOnMonday 为 true，则周一为 0，周日为 6
+ * @example
+ * ```ts
+ * getDayOfWeek(new Date('2023-05-15')) // 1（周一，从周日开始算是第1天）
+ * getDayOfWeek('2023-05-15', true) // 0（周一，从周一开始算是第0天）
+ * getDayOfWeek('2023-05-14') // 0（周日，从周日开始算是第0天）
+ * getDayOfWeek('2023-05-14', true) // 6（周日，从周一开始算是第6天）
+ * ```
+ */
+declare function getDayOfWeek(date: Date | string | number, startOnMonday?: boolean): number;
+/**
+ * 检查日期是否在指定范围内
+ * @param date 要检查的日期
+ * @param startDate 范围起始日期
+ * @param endDate 范围结束日期
+ * @returns 如果日期在指定范围内（不包括边界）则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isDateInRange('2023-05-15', '2023-05-10', '2023-05-20') // true
+ * isDateInRange('2023-05-15', '2023-05-15', '2023-05-20') // false（不包括开始日期）
+ * isDateInRange('2023-05-15', '2023-05-10', '2023-05-15') // false（不包括结束日期）
+ * ```
+ */
+declare function isDateInRange(date: Date | string | number, startDate: Date | string | number, endDate: Date | string | number): boolean;
+/**
+ * 获取指定月份的天数
+ * @param year 年份
+ * @param month 月份（0-11），0 表示一月，11 表示十二月
+ * @returns 该月的天数
+ * @example
+ * ```ts
+ * getDaysInMonth(2023, 1) // 28（2023年2月有28天）
+ * getDaysInMonth(2024, 1) // 29（2024年2月有29天，闰年）
+ * getDaysInMonth(2023, 0) // 31（2023年1月有31天）
+ * ```
+ */
+declare function getDaysInMonth(year: number, month: number): number;
+/**
+ * 获取相对时间描述
+ * @param date 日期
+ * @param baseDate 基准日期，默认为当前时间
+ * @returns 相对时间描述，如"几分钟前"、"几天后"等
+ * @example
+ * ```ts
+ * fromNow(new Date(Date.now() - 5 * 60 * 1000)) // "5分钟前"
+ * fromNow(new Date(Date.now() + 24 * 60 * 60 * 1000)) // "1天后"
+ * fromNow('2023-01-01', '2023-01-05') // "4天前"
+ * ```
+ */
+declare function fromNow(date: Date | string | number, baseDate?: Date | string | number): string;
+/**
+ * 获取日期的开始时间
+ * @param date 日期
+ * @param unit 单位，可以是 'year', 'month', 'week', 'day', 'hour', 'minute', 'second'
+ * @returns 单位开始时间的日期对象
+ * @example
+ * ```ts
+ * startOf(new Date('2023-05-15 15:30:45'), 'day') // Date 对象: Mon May 15 2023 00:00:00
+ * startOf('2023-05-15 15:30:45', 'month') // Date 对象: Mon May 01 2023 00:00:00
+ * startOf('2023-05-15 15:30:45', 'hour') // Date 对象: Mon May 15 2023 15:00:00
+ * ```
+ */
+declare function startOf(date: Date | string | number, unit: OpUnitType): Date;
+/**
+ * 获取日期的结束时间
+ * @param date 日期
+ * @param unit 单位，可以是 'year', 'month', 'week', 'day', 'hour', 'minute', 'second'
+ * @returns 单位结束时间的日期对象
+ * @example
+ * ```ts
+ * endOf(new Date('2023-05-15 15:30:45'), 'day') // Date 对象: Mon May 15 2023 23:59:59.999
+ * endOf('2023-05-15 15:30:45', 'month') // Date 对象: Wed May 31 2023 23:59:59.999
+ * endOf('2023-05-15 15:30:45', 'hour') // Date 对象: Mon May 15 2023 15:59:59.999
+ * ```
+ */
+declare function endOf(date: Date | string | number, unit: OpUnitType): Date;
+/**
+ * 格式化日期为人类友好的格式
+ * @param date 日期
+ * @returns 人类友好的日期描述，如"今天 HH:mm"、"昨天 HH:mm"、"明天 HH:mm"或"YYYY-MM-DD HH:mm"
+ * @example
+ * ```ts
+ * formatHumanReadable(new Date()) // "今天 15:30"
+ * formatHumanReadable(new Date(Date.now() - 24 * 60 * 60 * 1000)) // "昨天 15:30"
+ * formatHumanReadable(new Date(Date.now() + 24 * 60 * 60 * 1000)) // "明天 15:30"
+ * formatHumanReadable('2023-01-01') // "2023-01-01 00:00"
+ * ```
+ */
+declare function formatHumanReadable(date: Date | string | number): string;
+
+/**
+ * @module 类型检查
+ * @description 提供各种数据类型检查函数，用于判断值的类型、判断对象特性等
+ */
+/**
+ * 检查值是否为字符串类型
+ * @param val 要检查的值
+ * @returns 如果是字符串则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isString('hello') // true
+ * isString(123) // false
+ * isString(new String('hello')) // false（注意：包装对象不是原始字符串类型）
+ * ```
+ */
+declare function isString(val: unknown): val is string;
+/**
+ * 检查值是否为数字类型
+ * @param val 要检查的值
+ * @returns 如果是数字则返回 true，否则返回 false（NaN 会返回 false）
+ * @example
+ * ```ts
+ * isNumber(123) // true
+ * isNumber(-45.67) // true
+ * isNumber('123') // false
+ * isNumber(NaN) // false
+ * isNumber(Infinity) // true
+ * ```
+ */
+declare function isNumber(val: unknown): val is number;
+/**
+ * 检查值是否为布尔类型
+ * @param val 要检查的值
+ * @returns 如果是布尔值则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isBoolean(true) // true
+ * isBoolean(false) // true
+ * isBoolean(0) // false
+ * isBoolean('false') // false
+ * isBoolean(new Boolean(true)) // false（包装对象不是原始布尔类型）
+ * ```
+ */
+declare function isBoolean(val: unknown): val is boolean;
+/**
+ * 检查值是否为函数类型
+ * @param val 要检查的值
+ * @returns 如果是函数则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isFunction(() => {}) // true
+ * isFunction(function() {}) // true
+ * isFunction(class {}) // true
+ * isFunction(Math.sin) // true
+ * isFunction({}) // false
+ * ```
+ */
+declare function isFunction(val: unknown): val is ((...args: any[]) => any);
+/**
+ * 检查值是否为对象类型（不包括 null）
+ * @param val 要检查的值
+ * @returns 如果是对象则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isObject({}) // true
+ * isObject([]) // true（数组也是对象）
+ * isObject(new Date()) // true
+ * isObject(null) // false
+ * isObject(undefined) // false
+ * isObject(123) // false
+ * ```
+ */
+declare function isObject(val: unknown): val is Record<any, any>;
+/**
+ * 检查值是否为数组类型
+ * @param val 要检查的值
+ * @returns 如果是数组则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isArray([]) // true
+ * isArray([1, 2, 3]) // true
+ * isArray(new Array()) // true
+ * isArray({}) // false
+ * isArray('abc') // false
+ * ```
+ */
+declare function isArray(val: unknown): val is any[];
+/**
+ * 检查值是否为日期类型
+ * @param val 要检查的值
+ * @returns 如果是日期对象则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isDate(new Date()) // true
+ * isDate(Date.now()) // false（时间戳是数字，不是日期对象）
+ * isDate('2023-05-15') // false（日期字符串不是日期对象）
+ * ```
+ */
+declare function isDate(val: unknown): val is Date;
+/**
+ * 检查值是否为正则表达式
+ * @param val 要检查的值
+ * @returns 如果是正则表达式则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isRegExp(/abc/) // true
+ * isRegExp(new RegExp('abc')) // true
+ * isRegExp('/abc/') // false（字符串不是正则表达式）
+ * isRegExp({}) // false
+ * ```
+ */
+declare function isRegExp(val: unknown): val is RegExp;
+/**
+ * 检查值是否为 Promise
+ * @param val 要检查的值
+ * @returns 如果是 Promise 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isPromise(Promise.resolve()) // true
+ * isPromise(new Promise(() => {})) // true
+ * isPromise({ then: () => {}, catch: () => {} }) // true（类 Promise 对象也会返回 true）
+ * isPromise({}) // false
+ * isPromise(null) // false
+ * ```
+ */
+declare function isPromise<T = any>(val: unknown): val is Promise<T>;
+/**
+ * 检查值是否为 Map
+ * @param val 要检查的值
+ * @returns 如果是 Map 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isMap(new Map()) // true
+ * isMap(new WeakMap()) // false
+ * isMap({}) // false
+ * ```
+ */
+declare function isMap<K = any, V = any>(val: unknown): val is Map<K, V>;
+/**
+ * 检查值是否为 Set
+ * @param val 要检查的值
+ * @returns 如果是 Set 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isSet(new Set()) // true
+ * isSet(new WeakSet()) // false
+ * isSet([]) // false
+ * ```
+ */
+declare function isSet<T = any>(val: unknown): val is Set<T>;
+/**
+ * 检查值是否为 Symbol
+ * @param val 要检查的值
+ * @returns 如果是 Symbol 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isSymbol(Symbol('foo')) // true
+ * isSymbol(Symbol.for('bar')) // true
+ * isSymbol('symbol') // false
+ * ```
+ */
+declare function isSymbol(val: unknown): val is symbol;
+/**
+ * 检查值是否为原始类型（string、number、boolean、symbol、bigint、null、undefined）
+ * @param val 要检查的值
+ * @returns 如果是原始类型则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isPrimitive('hello') // true
+ * isPrimitive(123) // true
+ * isPrimitive(true) // true
+ * isPrimitive(Symbol()) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive(BigInt(123)) // true
+ * isPrimitive({}) // false
+ * isPrimitive([]) // false
+ * isPrimitive(() => {}) // false
+ * ```
+ */
+declare function isPrimitive(val: unknown): boolean;
+/**
+ * 检查值是否为 undefined
+ * @param val 要检查的值
+ * @returns 如果是 undefined 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isUndefined(undefined) // true
+ * isUndefined(void 0) // true
+ * isUndefined(null) // false
+ * isUndefined('') // false
+ * ```
+ */
+declare function isUndefined(val: unknown): val is undefined;
+/**
+ * 检查值是否为 null
+ * @param val 要检查的值
+ * @returns 如果是 null 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isNull(null) // true
+ * isNull(undefined) // false
+ * isNull(0) // false
+ * isNull('') // false
+ * ```
+ */
+declare function isNull(val: unknown): val is null;
+/**
+ * 检查值是否为 null 或 undefined
+ * @param val 要检查的值
+ * @returns 如果是 null 或 undefined 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isNullOrUndefined(null) // true
+ * isNullOrUndefined(undefined) // true
+ * isNullOrUndefined(void 0) // true
+ * isNullOrUndefined('') // false
+ * isNullOrUndefined(0) // false
+ * ```
+ */
+declare function isNullOrUndefined(val: unknown): val is null | undefined;
+/**
+ * 检查对象是否为空对象（没有自身可枚举属性）
+ * @param val 要检查的值
+ * @returns 如果是空对象则返回 true，否则返回 false；如果不是对象类型则返回 false
+ * @example
+ * ```ts
+ * isEmptyObject({}) // true
+ * isEmptyObject({ a: 1 }) // false
+ * isEmptyObject([]) // true（空数组也会返回 true）
+ * isEmptyObject(null) // false（不是对象）
+ * isEmptyObject(Object.create(null)) // true
+ * isEmptyObject(Object.create({ toString: () => '' })) // true（不包括继承的属性）
+ * ```
+ */
+declare function isEmptyObject(val: unknown): boolean;
+/**
+ * 检查值是否为空（null、undefined、空字符串、空数组或空对象）
+ * @param val 要检查的值
+ * @returns 如果是空值则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isEmpty(null) // true
+ * isEmpty(undefined) // true
+ * isEmpty('') // true
+ * isEmpty('   ') // true（空白字符串也视为空）
+ * isEmpty([]) // true
+ * isEmpty({}) // true
+ * isEmpty(0) // false
+ * isEmpty(false) // false
+ * isEmpty(' hello ') // false
+ * ```
+ */
+declare function isEmpty(val: unknown): boolean;
+/**
+ * 检查值是否为 NaN
+ * @param value 要检查的值
+ * @returns 如果值是 NaN 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isNaN(NaN) // true
+ * isNaN(Number('abc')) // true
+ * isNaN(0 / 0) // true
+ * isNaN(123) // false
+ * isNaN('123') // false（不同于全局 isNaN，此函数不会先尝试转换为数字）
+ * ```
+ */
+declare function isNaN(value: unknown): boolean;
+/**
+ * 检查值是否为普通对象（由 Object 构造函数创建或对象字面量）
+ *
+ * @param {unknown} value - 要检查的值
+ * @returns {boolean} 如果值是普通对象则返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject({ a: 1 }) // true
+ * isPlainObject(new Date()) // false
+ * isPlainObject([]) // false
+ * isPlainObject(null) // false
+ * ```
+ */
+declare function isPlainObject(value: unknown): value is Record<string, any>;
+
+/**
+ * @module 数字处理
+ * @description 提供各种数字处理函数，包括数字格式化、计算、范围控制等实用功能
+ */
+/**
+ * 将数字四舍五入到指定小数位
+ * @param num 要处理的数字
+ * @param precision 小数位数，默认为0（整数）
+ * @returns 四舍五入后的数字
+ * @example
+ * ```ts
+ * round(3.1415) // 3
+ * round(3.1415, 2) // 3.14
+ * round(3.1415, 3) // 3.142
+ * round(3.9999) // 4
+ * ```
+ */
+declare function round(num: number, precision?: number): number;
+/**
+ * 将数字格式化为带千位分隔符的字符串
+ * @param num 要格式化的数字
+ * @param locale 区域设置，默认为浏览器默认区域
+ * @returns 格式化后的字符串
+ * @example
+ * ```ts
+ * formatThousands(1234567) // '1,234,567'（根据浏览器默认区域可能有所不同）
+ * formatThousands(1234567.89, 'en-US') // '1,234,567.89'
+ * formatThousands(1234567.89, 'de-DE') // '1.234.567,89'
+ * ```
+ */
+declare function formatThousands(num: number, locale?: string): string;
+/**
+ * 将数字格式化为货币字符串
+ * @param value 要格式化的数字
+ * @param options 格式化选项
+ * @param options.currency 货币代码（如 'CNY', 'USD'），默认为 'CNY'
+ * @param options.locale 地区设置（如 'zh-CN', 'en-US'），默认为 'zh-CN'
+ * @param options.minimumFractionDigits 最小小数位数，默认为 2
+ * @param options.maximumFractionDigits 最大小数位数，默认为 2
+ * @returns 格式化后的货币字符串
+ * @example
+ * ```ts
+ * formatCurrency(1234.56) // '¥1,234.56'
+ * formatCurrency(1234.56, { currency: 'USD', locale: 'en-US' }) // '$1,234.56'
+ * formatCurrency(1234.56789, { maximumFractionDigits: 4 }) // '¥1,234.5679'
+ * formatCurrency(1234, { minimumFractionDigits: 0 }) // '¥1,234'
+ * ```
+ */
+declare function formatCurrency(value: number, options?: {
+    currency?: string;
+    locale?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}): string;
+/**
+ * 确保数字在指定范围内
+ * @param num 要限制范围的数字
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 在指定范围内的数字：如果小于最小值返回最小值，如果大于最大值返回最大值
+ * @example
+ * ```ts
+ * clamp(5, 0, 10) // 5 - 在范围内，保持不变
+ * clamp(-5, 0, 10) // 0 - 小于最小值，返回最小值
+ * clamp(15, 0, 10) // 10 - 大于最大值，返回最大值
+ * ```
+ */
+declare function clamp(num: number, min: number, max: number): number;
+/**
+ * 生成指定范围内的随机整数（包含边界值）
+ * @param min 最小值（包含）
+ * @param max 最大值（包含）
+ * @returns 指定范围内的随机整数
+ * @example
+ * ```ts
+ * randomInt(1, 10) // 返回 1 到 10 之间的随机整数，包括 1 和 10
+ * randomInt(0, 1) // 返回 0 或 1
+ * randomInt(5, 5) // 总是返回 5
+ * ```
+ */
+declare function randomInt(min: number, max: number): number;
+/**
+ * 检查一个数字是否为偶数
+ * @param num 要检查的数字
+ * @returns 如果是偶数则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isEven(2) // true
+ * isEven(3) // false
+ * isEven(0) // true
+ * isEven(-4) // true
+ * ```
+ */
+declare function isEven(num: number): boolean;
+/**
+ * 检查一个数字是否为奇数
+ * @param num 要检查的数字
+ * @returns 如果是奇数则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isOdd(3) // true
+ * isOdd(2) // false
+ * isOdd(0) // false
+ * isOdd(-3) // true
+ * ```
+ */
+declare function isOdd(num: number): boolean;
+/**
+ * 计算百分比值
+ * @param value 当前值
+ * @param total 总值
+ * @param precision 结果保留的小数位数，默认为2
+ * @returns 百分比值，如果总值为零则返回 0
+ * @example
+ * ```ts
+ * percentage(25, 100) // 25
+ * percentage(1, 3) // 33.33
+ * percentage(1, 3, 0) // 33
+ * percentage(5, 0) // 0，避免除以零错误
+ * ```
+ */
+declare function percentage(value: number, total: number, precision?: number): number;
+/**
+ * 将数值转换为带"万"单位的字符串
+ * @param num 要转换的数值
+ * @param fractionDigits 小数位数，默认为2
+ * @returns 转换后的字符串，如果值大于等于10000则转为"万"单位
+ * @example
+ * ```ts
+ * formatNumberWithTenThousand(1234) // '1234'
+ * formatNumberWithTenThousand(12345) // '1.23万'
+ * formatNumberWithTenThousand(12345, 1) // '1.2万'
+ * formatNumberWithTenThousand(0) // '0'
+ * ```
+ */
+declare function formatNumberWithTenThousand(num: number, fractionDigits?: number): string;
+
+/**
+ * @module 对象操作
+ * @description 提供各种对象处理函数，包括对象深拷贝、合并、转换等实用功能
+ */
+/**
+ * 检查对象是否具有指定的自有属性。
+ *
+ * @param {object} obj - 需要检查的对象
+ * @param {string | symbol} prop - 需要检查的属性键
+ * @returns {boolean} 如果对象具有该自有属性，则返回 true，否则返回 false
+ *
+ * @example
+ * ```ts
+ * const obj = { name: 'Tom', age: 25 }
+ * hasOwnProp(obj, 'name') // true
+ * hasOwnProp(obj, 'toString') // false，toString 是继承的属性
+ * ```
+ */
+declare function hasOwnProp(obj: object, prop: string | symbol): boolean;
+/**
+ * 深拷贝对象，支持基本类型、数组、对象、日期和正则表达式
+ * @param obj 要拷贝的对象
+ * @returns 深拷贝后的对象，与原对象完全独立
+ * @example
+ * ```ts
+ * const original = { a: 1, b: { c: 2 }, d: [1, 2, 3], e: new Date() }
+ * const copy = deepClone(original)
+ * copy.b.c = 100
+ * console.log(original.b.c) // 2，原对象不受影响
+ *
+ * // 支持日期对象
+ * const date = new Date()
+ * const clonedDate = deepClone(date)
+ * console.log(date === clonedDate) // false，不是同一引用
+ * ```
+ */
+declare function deepClone<T>(obj: T): T;
+/**
+ * 从对象中获取指定路径的值，支持点分隔的嵌套路径
+ * @param obj 源对象
+ * @param path 属性路径，如 'user.address.street'
+ * @param defaultValue 默认值，当路径不存在时返回
+ * @returns 路径对应的值，如果路径不存在则返回默认值
+ * @example
+ * ```ts
+ * const obj = { user: { profile: { name: 'Tom', age: 25 }, roles: ['admin'] } }
+ *
+ * get(obj, 'user.profile.name') // 'Tom'
+ * get(obj, 'user.roles.0') // 'admin'
+ * get(obj, 'user.settings', { theme: 'dark' }) // { theme: 'dark' }（路径不存在，返回默认值）
+ * get(obj, 'user.profile.gender') // undefined（路径不存在且没提供默认值）
+ * get(obj, 'user.profile.gender', 'unknown') // 'unknown'（使用默认值）
+ * ```
+ */
+declare function get<T = any>(obj: Record<string, any>, path: string, defaultValue?: T): T | undefined;
+/**
+ * 从对象中选择指定的属性，创建一个新对象
+ * @param obj 原始对象
+ * @param keys 要选择的键数组
+ * @returns 包含指定键的新对象
+ * @example
+ * ```ts
+ * const user = { id: 1, name: 'Tom', age: 25, email: 'tom@example.com' }
+ *
+ * pick(user, ['name', 'email']) // { name: 'Tom', email: 'tom@example.com' }
+ * pick(user, ['name', 'gender']) // { name: 'Tom' }（不存在的键会被忽略）
+ * pick(user, []) // {}（空数组返回空对象）
+ * ```
+ */
+declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * 从对象中排除指定的属性，创建一个新对象
+ * @param obj 原始对象
+ * @param keys 要排除的键数组
+ * @returns 不包含指定键的新对象
+ * @example
+ * ```ts
+ * const user = { id: 1, name: 'Tom', age: 25, password: '123456' }
+ *
+ * omit(user, ['password']) // { id: 1, name: 'Tom', age: 25 }
+ * omit(user, ['id', 'age']) // { name: 'Tom', password: '123456' }
+ * omit(user, ['nonExistent']) // 原对象的拷贝，不存在的键会被忽略
+ * ```
+ */
+declare function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * 将对象转换为 URL 查询字符串
+ * @param obj 要转换的对象
+ * @returns 格式化后的查询字符串（不包含前导?）
+ * @example
+ * ```ts
+ * objectToQueryString({ name: 'Tom', age: 25 }) // 'name=Tom&age=25'
+ * objectToQueryString({ search: 'hello world', page: 1 }) // 'search=hello%20world&page=1'
+ * objectToQueryString({ tags: ['js', 'ts'] }) // 'tags=js&tags=ts'
+ * objectToQueryString({ name: 'Tom', empty: null }) // 'name=Tom'（null 和 undefined 会被过滤）
+ * ```
+ */
+declare function objectToQueryString(obj: Record<string, any>): string;
+/**
+ * 合并多个对象，后面的对象的属性会覆盖前面的
+ * @param objects 要合并的对象数组
+ * @returns 合并后的新对象
+ * @example
+ * ```ts
+ * merge({ a: 1 }, { b: 2 }) // { a: 1, b: 2 }
+ * merge({ a: 1 }, { a: 2, b: 2 }) // { a: 2, b: 2 }（后面对象的属性会覆盖前面的）
+ * merge({ a: { x: 1 } }, { a: { y: 2 } }) // { a: { y: 2 } }（不是深度合并）
+ * merge({}, { a: 1 }, { b: 2 }, { c: 3 }) // { a: 1, b: 2, c: 3 }
+ * ```
+ */
+declare function merge<T extends Record<string, any>>(...objects: T[]): T;
+/**
+ * 深度合并多个对象，会递归合并嵌套对象
+ * @param objects 要合并的对象数组
+ * @returns 深度合并后的新对象
+ * @example
+ * ```ts
+ * deepMerge({ a: { x: 1 } }, { a: { y: 2 } }) // { a: { x: 1, y: 2 } }
+ * deepMerge({ a: 1 }, { b: 2 }) // { a: 1, b: 2 }
+ * deepMerge({ a: [1, 2] }, { a: [3, 4] }) // { a: [3, 4] }（数组会被替换，不会合并）
+ * deepMerge({}, { a: null }, { a: { b: 2 } }) // { a: { b: 2 } }（null 会被后面的对象覆盖）
+ * ```
+ */
+declare function deepMerge(...objects: Record<string, any>[]): Record<string, any>;
+/**
+ * 根据传入的键数组和键名映射对象过滤并重命名对象，返回一个新对象
+ * @param originalObject 要过滤的原始对象
+ * @param keysArray 要保留的键名数组
+ * @param keyMapping 可选的键名映射对象，格式为 { 原键名: 新键名 }
+ * @returns 返回一个新对象，其中只包含原对象中匹配的键值对，并根据映射重命名键
+ * @example
+ * ```ts
+ * const originalObject = { name: "John", age: 30, gender: "male", country: "USA" }
+ * const keysToFilter = ["name", "country"]
+ * const keyMapping = { name: "fullName", country: "location" }
+ * const result = filterObjectByKeys(originalObject, keysToFilter, keyMapping)
+ * // 结果: { fullName: 'John', location: 'USA' }
+ * ```
+ */
+declare function filterObjectByKeys(originalObject: Record<string, any>, keysArray: string[], keyMapping?: Record<string, string>): Record<string, any>;
+
+/**
+ * 延迟指定的毫秒数
+ *
+ * @param {number} ms - 需要延迟的毫秒数
+ * @returns {Promise<void>} 返回一个在指定时间后resolve的Promise
+ *
+ * @example
+ * ```ts
+ * // 延迟2秒
+ * await delay(2000)
+ * console.log('2秒后执行')
+ *
+ * // 在异步函数中使用
+ * async function fetchWithDelay() {
+ *   await delay(1000)
+ *   return fetch('/api/data')
+ * }
+ * ```
+ */
+declare function delay(ms: number): Promise<void>;
+
+/**
+ * @module 字符串处理
+ * @description 提供各种字符串处理函数，包括字符串转换、格式化、验证等实用功能
+ */
+/**
+ * 将字符串首字母转为大写
+ * @param str 输入字符串
+ * @returns 首字母大写后的字符串
+ * @example
+ * ```ts
+ * capitalize('hello') // 'Hello'
+ * capitalize('') // ''
+ * capitalize('a') // 'A'
+ * ```
+ */
+declare function capitalize(str: string): string;
+/**
+ * 将驼峰命名转换为短横线命名（kebab-case）
+ * @param str 驼峰命名的字符串
+ * @returns 短横线命名的字符串
+ * @example
+ * ```ts
+ * camelToKebab('helloWorld') // 'hello-world'
+ * camelToKebab('HelloWorld') // 'hello-world'
+ * camelToKebab('APIVersion') // 'api-version'
+ * camelToKebab('iOS9App') // 'i-os9-app'
+ * ```
+ */
+declare function camelToKebab(str: string): string;
+/**
+ * 将短横线命名（kebab-case）转换为驼峰命名（camelCase）
+ * @param str 短横线命名的字符串
+ * @returns 驼峰命名的字符串
+ * @example
+ * ```ts
+ * kebabToCamel('hello-world') // 'helloWorld'
+ * kebabToCamel('api-version') // 'apiVersion'
+ * kebabToCamel('i-os9-app') // 'iOs9App'
+ * kebabToCamel('--hello') // 'hello'
+ * ```
+ */
+declare function kebabToCamel(str: string): string;
+/**
+ * 截取字符串并添加省略号
+ * @param str 原始字符串
+ * @param length 截取的最大长度，默认为 50
+ * @param ellipsis 省略号字符，默认为'...'
+ * @returns 截取后的字符串，如果原字符串长度小于等于截取长度，则返回原字符串
+ * @example
+ * ```ts
+ * truncate('这是一个很长的字符串', 5) // '这是...'
+ * truncate('这是一个很长的字符串', 5, '…') // '这是一…'
+ * truncate('短字符', 10) // '短字符'
+ * ```
+ */
+declare function truncate(str: string, length?: number, ellipsis?: string): string;
+/**
+ * 生成指定长度的随机字符串
+ * @param length 字符串长度
+ * @param chars 可选的字符集，默认包含大小写字母和数字
+ * @returns 生成的随机字符串
+ * @example
+ * ```ts
+ * randomString(5) // 例如: 'aB9cD'
+ * randomString(10) // 例如: 'aBcD1eF2gH'
+ * randomString(3, '123456') // 例如: '426'
+ * ```
+ */
+declare function randomString(length: number, chars?: string): string;
+/**
+ * 将字符串中的 HTML 特殊字符转义，防止 XSS 攻击
+ * @param html 包含 HTML 的字符串
+ * @returns 转义后的安全字符串
+ * @example
+ * ```ts
+ * escapeHtml('<div>Hello & World</div>') // '&lt;div&gt;Hello &amp; World&lt;/div&gt;'
+ * escapeHtml('<script>alert("XSS")</script>') // '&lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;'
+ * ```
+ */
+declare function escapeHtml(html: string): string;
+/**
+ * 检查字符串是否为有效的 URL
+ * @param url 要检查的 URL 字符串
+ * @returns 如果是有效的 URL 则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isValidUrl('https://example.com') // true
+ * isValidUrl('http://localhost:3000') // true
+ * isValidUrl('example.com') // false，缺少协议
+ * isValidUrl('not a url') // false
+ * ```
+ */
+declare function isValidUrl(url: string): boolean;
+/**
+ * 检查字符串是否为有效的电子邮件地址
+ * @param email 要检查的电子邮件地址
+ * @returns 如果是有效的电子邮件地址则返回 true，否则返回 false
+ * @example
+ * ```ts
+ * isValidEmail('user@example.com') // true
+ * isValidEmail('user.name+tag@example.co.uk') // true
+ * isValidEmail('invalid@email') // false，缺少顶级域名
+ * isValidEmail('not an email') // false
+ * ```
+ */
+declare function isValidEmail(email: string): boolean;
+/**
+ * 检查字符串是否为空或只包含空白字符
+ * @param str 要检查的字符串
+ * @returns 如果字符串为空或只包含空白字符，则返回 true
+ * @example
+ * ```ts
+ * isEmptyString('') // true
+ * isEmptyString('  \t\n  ') // true
+ * isEmptyString('hello') // false
+ * isEmptyString(' hello ') // false
+ * ```
+ */
+declare function isEmptyString(str: string): boolean;
+/**
+ * 确保值具有 rpx 单位，主要用于小程序/uni-app 样式处理
+ * @param val 需要转化的值，可以是数字或字符串
+ * @returns 转化后带有 rpx 单位的字符串，如果输入不是数字则原样返回
+ * @example
+ * ```ts
+ * ensureRpxUnit(100) // '100rpx'
+ * ensureRpxUnit('100') // '100rpx'
+ * ensureRpxUnit('100px') // '100px'，不是数字，保持原样
+ * ensureRpxUnit('auto') // 'auto'，不是数字，保持原样
+ * ```
+ */
+declare function ensureRpxUnit(val: string | number): string;
+/**
+ * 替换表格数据中指定字段的 &nbsp; 为不换行空格
+ *
+ * @param {Array<Record<string, any>>} tableData - 表格数据数组或Vue ref
+ * @param {string} key - 需要处理的字段名
+ * @returns {Array<Record<string, any>>} 处理后的表格数据数组
+ *
+ * @example
+ * ```ts
+ * // 基本用法
+ * const data = [
+ *   { name: 'John&nbsp;Doe', age: 30 },
+ *   { name: 'Jane&nbsp;&nbsp;Smith', age: 25 }
+ * ]
+ * const result = replaceNBSP(data, 'name')
+ * // 结果: [
+ * //   { name: 'John  Doe', age: 30 },
+ * //   { name: 'Jane    Smith', age: 25 }
+ * // ]
+ *
+ * // 使用ref包装的数据 (在Vue中使用)
+ * const refData = ref([
+ *   { desc: 'Product&nbsp;Info', price: 99 },
+ *   { desc: 'Service&nbsp;&nbsp;Details', price: 50 }
+ * ])
+ * const result = replaceNBSP(refData, 'desc')
+ * // 结果: [
+ * //   { desc: 'Product  Info', price: 99 },
+ * //   { desc: 'Service    Details', price: 50 }
+ * // ]
+ *
+ * // 空数组情况
+ * const emptyData = []
+ * const result = replaceNBSP(emptyData, 'name')
+ * // 结果: []
+ * ```
+ */
+declare function replaceNBSP<T extends Record<string, string | number | boolean | object>>(tableData: T[] | {
+    value: T[];
+}, key: string): T[];
+
+/**
+ * 将对象转换为URL查询字符串
+ *
+ * @deprecated 请使用 objectToQueryString 函数代替，它在 object 模块中。该函数将在下一个主要版本中移除。
+ * @param {Record<string, any>} params - 需要转换的对象
+ * @returns {string} 转换后的查询字符串，如果有参数则以?开头
+ *
+ * @example
+ * ```ts
+ * // 基本用法
+ * getQueryStringify({ name: 'John', age: 30 })
+ * // 返回: ?name=John&age=30
+ *
+ * // 包含对象的情况
+ * getQueryStringify({ user: { name: 'John', age: 30 }, active: true })
+ * // 返回: ?user={"name":"John","age":30}&active=true
+ *
+ * // 空对象
+ * getQueryStringify({})
+ * // 返回: ''
+ *
+ * // null 或 undefined
+ * getQueryStringify(null)
+ * // 返回: ''
+ * ```
+ */
+declare function getQueryStringify(params: Record<string, any> | null | undefined): string;
+
+export { add, addDays, addMonths, addYears, appendUniversalOption, camelToKebab, capitalize, chunk, clamp, createDate, deepClone, deepMerge, delay, diff, endOf, ensureRpxUnit, escapeHtml, filterObjectByKeys, first, formatCurrency, formatDate, formatHumanReadable, formatNumberWithTenThousand, formatThousands, fromNow, get, getDayOfWeek, getDaysInMonth, getQueryStringify, groupBy, hasOwnProp, isArray, isBoolean, isDate, isDateInRange, isEmpty, isEmptyObject, isEmptyString, isEqual, isEven, isFunction, isMap, isNaN, isNull, isNullOrUndefined, isNumber, isObject, isOdd, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isUndefined, isValidEmail, isValidUrl, kebabToCamel, last, merge, now, objectToQueryString, omit, parseDate, percentage, pick, randomInt, randomString, remove, replaceNBSP, round, sample, shuffle, startOf, truncate, unique };