misp-ui-library-test 0.0.1

package/src/utils/lodash/index.js

@@ -0,0 +1,2395 @@
+/**
+ * @module @vue2-ui/lodash
+ * @description 基于 lodash 的自定义工具函数库（无外部依赖）
+ */
+
+// ==================== 类型判断 ====================
+
+/**
+ * 检查值是否为 null 或 undefined
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isNil(null) // true
+ * isNil(undefined) // true
+ * isNil(0) // false
+ * isNil('') // false
+ */
+export function isNil(value) {
+  return value === null || value === undefined
+}
+
+/**
+ * 检查值是否为 undefined
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isUndefined(undefined) // true
+ * isUndefined(null) // false
+ * isUndefined(0) // false
+ * isUndefined('') // false
+ */
+export function isUndefined(value) {
+  return value === undefined
+}
+
+/**
+ * 检查值是否为 null
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isNull(null) // true
+ * isNull(undefined) // false
+ * isNull(0) // false
+ * isNull('') // false
+ */
+export function isNull(value) {
+  return value === null
+}
+
+/**
+ * 检查值是否为 boolean 类型
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isBoolean(true) // true
+ * isBoolean(false) // true
+ * isBoolean(1) // false
+ * isBoolean('true') // false
+ */
+export function isBoolean(value) {
+  return typeof value === 'boolean'
+}
+
+/**
+ * 检查值是否为 number 类型
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isNumber(1) // true
+ * isNumber(NaN) // true
+ * isNumber('1') // false
+ */
+export function isNumber(value) {
+  return typeof value === 'number'
+}
+
+/**
+ * 检查值是否为有限数字
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isFiniteNumber(1) // true
+ * isFiniteNumber(0) // true
+ * isFiniteNumber(NaN) // false
+ * isFiniteNumber(Infinity) // false
+ */
+export function isFiniteNumber(value) {
+  return typeof value === 'number' && isFinite(value)
+}
+
+/**
+ * 检查值是否为整数
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isInteger(1) // true
+ * isInteger(0) // true
+ * isInteger(1.5) // false
+ * isInteger('1') // false
+ */
+export function isInteger(value) {
+  return typeof value === 'number' && Number.isInteger(value)
+}
+
+/**
+ * 检查值是否为 NaN
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isNaN(NaN) // true
+ * isNaN(0) // false
+ * isNaN('NaN') // false
+ * isNaN(undefined) // false
+ */
+export function isNaN(value) {
+  return Number.isNaN(value)
+}
+
+/**
+ * 检查值是否为字符串类型
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isString('hello') // true
+ * isString('') // true
+ * isString(123) // false
+ * isString(null) // false
+ */
+export function isString(value) {
+  return typeof value === 'string'
+}
+
+/**
+ * 检查值是否为 Symbol 类型
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isSymbol(Symbol('foo')) // true
+ * isSymbol(Symbol()) // true
+ * isSymbol('foo') // false
+ * isSymbol(123) // false
+ */
+export function isSymbol(value) {
+  return typeof value === 'symbol'
+}
+
+/**
+ * 检查值是否为函数
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isFunction(() => {}) // true
+ * isFunction(function() {}) // true
+ * isFunction(123) // false
+ * isFunction(null) // false
+ */
+export function isFunction(value) {
+  return typeof value === 'function'
+}
+
+/**
+ * 检查值是否为数组
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isArray([1, 2, 3]) // true
+ * isArray([]) // true
+ * isArray('array') // false
+ * isArray({ length: 3 }) // false
+ */
+export function isArray(value) {
+  return Array.isArray(value)
+}
+
+/**
+ * 检查值是否为类数组（有 length 属性且为数字）
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isArrayLike([1, 2, 3]) // true
+ * isArrayLike('hello') // true
+ * isArrayLike({ length: 3 }) // true
+ * isArrayLike(null) // false
+ */
+export function isArrayLike(value) {
+  if (value === null || value === undefined) {
+    return false
+  }
+  const length = value.length
+  return typeof length === 'number' && length >= 0 && Number.isInteger(length)
+}
+
+/**
+ * 检查值是否为对象类型（排除 null 和数组）
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isObject({}) // true
+ * isObject([]) // true
+ * isObject(() => {}) // true
+ * isObject(null) // false
+ * isObject(123) // false
+ */
+export function isObject(value) {
+  const type = typeof value
+  return value !== null && (type === 'object' || type === 'function')
+}
+
+/**
+ * 检查值是否为纯对象（Object 创建的普通对象）
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isPlainObject({}) // true
+ * isPlainObject({ a: 1 }) // true
+ * isPlainObject([]) // false
+ * isPlainObject(new Date()) // false
+ * isPlainObject(null) // false
+ */
+export function isPlainObject(value) {
+  if (!isObject(value)) {
+    return false
+  }
+  const proto = Object.getPrototypeOf(value)
+  return proto === null || proto === Object.prototype
+}
+
+/**
+ * 检查值是否为类实例（如 Date、RegExp 等）
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isObjectLike({}) // true
+ * isObjectLike([]) // true
+ * isObjectLike(new Date()) // true
+ * isObjectLike('string') // false
+ * isObjectLike(null) // false
+ */
+export function isObjectLike(value) {
+  return value !== null && typeof value === 'object'
+}
+
+/**
+ * 检查值是否为 Date 对象
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isDate(new Date()) // true
+ * isDate(new Date('2024-01-01')) // true
+ * isDate('2024-01-01') // false
+ * isDate(1234567890) // false
+ */
+export function isDate(value) {
+  return value instanceof Date
+}
+
+/**
+ * 检查值是否为 RegExp 对象
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isRegExp(/abc/) // true
+ * isRegExp(new RegExp('abc')) // true
+ * isRegExp('abc') // false
+ * isRegExp(123) // false
+ */
+export function isRegExp(value) {
+  return value instanceof RegExp
+}
+
+/**
+ * 检查值是否为 Promise 对象
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isPromise(Promise.resolve()) // true
+ * isPromise(new Promise(() => {})) // true
+ * isPromise(async () => {}) // false (函数)
+ * isPromise({ then: () => {} }) // true (thenable)
+ */
+export function isPromise(value) {
+  return isObject(value) && isFunction(value.then)
+}
+
+/**
+ * 检查值是否为 Map 对象
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isMap(new Map()) // true
+ * isMap(new Map([['a', 1]])) // true
+ * isMap({}) // false
+ * isMap(new WeakMap()) // false
+ */
+export function isMap(value) {
+  return value instanceof Map
+}
+
+/**
+ * 检查值是否为 Set 对象
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isSet(new Set()) // true
+ * isSet(new Set([1, 2, 3])) // true
+ * isSet([]) // false
+ * isSet(new WeakSet()) // false
+ */
+export function isSet(value) {
+  return value instanceof Set
+}
+
+/**
+ * 检查值是否为 WeakMap 对象
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isWeakMap(new WeakMap()) // true
+ * isWeakMap(new Map()) // false
+ * isWeakMap({}) // false
+ */
+export function isWeakMap(value) {
+  return value instanceof WeakMap
+}
+
+/**
+ * 检查值是否为 WeakSet 对象
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isWeakSet(new WeakSet()) // true
+ * isWeakSet(new Set()) // false
+ * isWeakSet([]) // false
+ */
+export function isWeakSet(value) {
+  return value instanceof WeakSet
+}
+
+// ==================== 语言判断 ====================
+
+/**
+ * - 检查文本是否包含韩文字符
+ * - 通过正则表达式匹配韩文音节（\uAC00-\uD7AF）和韩文字母（\u3130-\u318F）
+ * @param {string} text - 要检查的文本
+ * @returns {boolean} 如果包含韩文字符返回 true，否则返回 false
+ * @example
+ * isKorean('안녕하세요') // true
+ * isKorean('가나다') // true
+ * isKorean('hello') // false
+ * isKorean('你好') // false
+ * isKorean('123') // false
+ */
+export function isKorean(text) {
+  const reg = /([(\uAC00-\uD7AF)|(\u3130-\u318F)])+/gi;
+  return reg.test(text);
+}
+
+
+// ==================== 值判断 ====================
+
+/**
+ * 检查值是否为空（null、undefined、空字符串、空数组、空对象）
+ * @param {*} value
+ * @returns {boolean}
+ * @example
+ * isEmpty(null) // true
+ * isEmpty(undefined) // true
+ * isEmpty('') // true
+ * isEmpty([]) // true
+ * isEmpty({}) // true
+ * isEmpty(0) // false
+ * isEmpty(' ') // false
+ */
+export function isEmpty(value) {
+  if (value === null || value === undefined) {
+    return true
+  }
+  if (isArray(value) || isString(value)) {
+    return value.length === 0
+  }
+  if (isObjectLike(value)) {
+    return Object.keys(value).length === 0
+  }
+  return false
+}
+
+/**
+ * 检查两个值是否相等（支持浅比较）
+ * @param {*} a
+ * @param {*} b
+ * @returns {boolean}
+ * @example
+ * isEqual(1, 1) // true
+ * isEqual('a', 'a') // true
+ * isEqual([1, 2], [1, 2]) // true
+ * isEqual({a: 1}, {a: 1}) // true
+ * isEqual(1, '1') // false
+ * isEqual([1, 2], [1, 2, 3]) // false
+ */
+export function isEqual(a, b) {
+  if (a === b) {
+    return true
+  }
+  if (a === null || b === null) {
+    return a === b
+  }
+  if (typeof a !== typeof b) {
+    return false
+  }
+
+  // 数组比较
+  if (isArray(a) && isArray(b)) {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) {
+      if (!isEqual(a[i], b[i])) return false
+    }
+    return true
+  }
+
+  // 对象比较
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const keysA = Object.keys(a)
+    const keysB = Object.keys(b)
+    if (keysA.length !== keysB.length) return false
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) return false
+      if (!isEqual(a[key], b[key])) return false
+    }
+    return true
+  }
+
+  return false
+}
+
+// ==================== 数组函数 ====================
+
+/**
+ * 查找数组中第一个匹配的元素
+ * @template T
+ * @param {T[]} array
+ * @param {Function|*} predicate - 匹配函数或值
+ * @returns {*|undefined}
+ * @example
+ * find([1, 2, 3, 4], n => n % 2 === 0) // 2
+ * find([{name: 'a'}, {name: 'b'}], {name: 'b'}) // {name: 'b'}
+ */
+export function find(array, predicate) {
+  if (!isArrayLike(array)) {
+    return undefined
+  }
+
+  const isFunc = isFunction(predicate)
+  const isObj = isPlainObject(predicate)
+
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i]
+    if (isFunc) {
+      if (predicate(item, i, array)) return item
+    } else if (isObj) {
+      const keys = Object.keys(predicate)
+      const matches = keys.every(key => item[key] === predicate[key])
+      if (matches) return item
+    } else {
+      if (item === predicate) return item
+    }
+  }
+  return undefined
+}
+
+/**
+ * 查找数组中第一个匹配元素的索引
+ * @template T
+ * @param {T[]} array
+ * @param {*} value
+ * @param {number} [fromIndex=0]
+ * @returns {number}
+ * @example
+ * indexOf([1, 2, 3, 4], 3) // 2
+ * indexOf([1, 2, 3, 2], 2) // 1
+ * indexOf([1, 2, 3, 2], 2, 2) // 3
+ * indexOf([1, 2, 3], 5) // -1
+ */
+export function indexOf(array, value, fromIndex = 0) {
+  const len = array ? array.length : 0
+  if (!len) return -1
+
+  const start = fromIndex < 0 ? Math.max(0, len + fromIndex) : fromIndex
+  for (let i = start; i < len; i++) {
+    if (array[i] === value) return i
+  }
+  return -1
+}
+
+/**
+ * 查找数组中最后匹配元素的索引
+ * @template T
+ * @param {T[]} array
+ * @param {*} value
+ * @param {number} [fromIndex=array.length-1]
+ * @returns {number}
+ * @example
+ * lastIndexOf([1, 2, 3, 2], 2) // 3
+ * lastIndexOf([1, 2, 3, 2], 2, 2) // 1
+ * lastIndexOf([1, 2, 3], 5) // -1
+ */
+export function lastIndexOf(array, value, fromIndex) {
+  const len = array ? array.length : 0
+  if (!len) return -1
+
+  const start = fromIndex !== undefined
+    ? Math.min(fromIndex < 0 ? len + fromIndex : fromIndex, len - 1)
+    : len - 1
+
+  for (let i = start; i >= 0; i--) {
+    if (array[i] === value) return i
+  }
+  return -1
+}
+
+/**
+ * 过滤数组中的元素
+ * @template T
+ * @param {T[]} array
+ * @param {Function} predicate
+ * @returns {T[]}
+ * @example
+ * filter([1, 2, 3, 4], n => n % 2 === 0) // [2, 4]
+ * filter([{name: 'a', age: 20}, {name: 'b', age: 30}], o => o.age > 25) // [{name: 'b', age: 30}]
+ * filter([1, 2, 3], n => n > 1) // [2, 3]
+ */
+export function filter(array, predicate) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+
+  const result = []
+  for (let i = 0; i < array.length; i++) {
+    if (predicate(array[i], i, array)) {
+      result.push(array[i])
+    }
+  }
+  return result
+}
+
+/**
+ * 映射数组中的每个元素
+ * @template T, R
+ * @param {T[]} array
+ * @param {Function|string} iteratee - 映射函数或属性名
+ * @returns {R[]}
+ * @example
+ * map([1, 2, 3], n => n * 2) // [2, 4, 6]
+ * map([{name: 'a'}, {name: 'b'}], 'name') // ['a', 'b']
+ */
+export function map(array, iteratee) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+
+  const result = []
+  const isFunc = isFunction(iteratee)
+  const isStringKey = isString(iteratee)
+
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i]
+    if (isFunc) {
+      result.push(iteratee(item, i, array))
+    } else if (isStringKey) {
+      result.push(item[iteratee])
+    } else {
+      result.push(item)
+    }
+  }
+  return result
+}
+
+/**
+ * 数组去重
+ * @template T
+ * @param {T[]} array
+ * @returns {T[]}
+ * @example
+ * uniq([1, 2, 2, 3, 3, 4]) // [1, 2, 3, 4]
+ * uniq(['a', 'b', 'a', 'c']) // ['a', 'b', 'c']
+ * uniq([1, '1', 2]) // [1, '1', 2]
+ */
+export function uniq(array) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+  return [...new Set(array)]
+}
+
+/**
+ * 数组扁平化
+ * @template T
+ * @param {T[]} array
+ * @param {number} [depth=1] - 扁平化深度
+ * @returns {T[]}
+ * @example
+ * flatten([1, [2, 3]]) // [1, 2, 3]
+ * flatten([1, [2, [3, [4]]]], 2) // [1, 2, 3, [4]]
+ * flatten([1, [2, [3, [4]]]], Infinity) // [1, 2, 3, 4]
+ */
+export function flatten(array, depth = 1) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+
+  const result = []
+
+  function flattenDeep(arr, currentDepth) {
+    for (const item of arr) {
+      if (isArray(item) && currentDepth < depth) {
+        flattenDeep(item, currentDepth + 1)
+      } else {
+        result.push(item)
+      }
+    }
+  }
+
+  flattenDeep(array, 0)
+  return result
+}
+
+/**
+ * 深度扁平化数组
+ * @template T
+ * @param {T[]} array
+ * @returns {T[]}
+ * @example
+ * flattenDeep([1, [2, [3, [4]]]]) // [1, 2, 3, 4]
+ * flattenDeep([1, [2, 3], [[4, 5]]]) // [1, 2, 3, 4, 5]
+ * flattenDeep([1, 2, 3]) // [1, 2, 3]
+ */
+export function flattenDeep(array) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+  return flatten(array, Infinity)
+}
+
+/**
+ * 获取数组的第一个元素
+ * @template T
+ * @param {T[]} array
+ * @returns {*|undefined}
+ * @example
+ * first([1, 2, 3]) // 1
+ * first([]) // undefined
+ * first(null) // undefined
+ */
+export function first(array) {
+  return array && array.length ? array[0] : undefined
+}
+
+/**
+ * 获取数组的最后一个元素
+ * @template T
+ * @param {T[]} array
+ * @returns {*|undefined}
+ * @example
+ * last([1, 2, 3]) // 3
+ * last([]) // undefined
+ * last(null) // undefined
+ */
+export function last(array) {
+  return array && array.length ? array[array.length - 1] : undefined
+}
+
+/**
+ * 获取数组除最后一个元素外的所有元素
+ * @template T
+ * @param {T[]} array
+ * @returns {T[]}
+ * @example
+ * initial([1, 2, 3]) // [1, 2]
+ * initial([1]) // []
+ * initial([]) // []
+ */
+export function initial(array) {
+  if (!array || !array.length) {
+    return []
+  }
+  return array.slice(0, -1)
+}
+
+/**
+ * 获取数组除第一个元素外的所有元素
+ * @template T
+ * @param {T[]} array
+ * @returns {T[]}
+ * @example
+ * rest([1, 2, 3]) // [2, 3]
+ * rest([1]) // []
+ * rest([]) // []
+ */
+export function rest(array) {
+  if (!array || !array.length) {
+    return []
+  }
+  return array.slice(1)
+}
+
+/**
+ * 获取数组的前 n 个元素
+ * @template T
+ * @param {T[]} array
+ * @param {number} n
+ * @returns {T[]}
+ * @example
+ * take([1, 2, 3], 2) // [1, 2]
+ * take([1, 2, 3]) // [1]
+ * take([1, 2, 3], 10) // [1, 2, 3]
+ */
+export function take(array, n = 1) {
+  if (!array || !array.length) {
+    return []
+  }
+  return array.slice(0, n)
+}
+
+/**
+ * 获取数组的后 n 个元素
+ * @template T
+ * @param {T[]} array
+ * @param {number} n
+ * @returns {T[]}
+ * @example
+ * takeRight([1, 2, 3], 2) // [2, 3]
+ * takeRight([1, 2, 3]) // [3]
+ * takeRight([1, 2, 3], 10) // [1, 2, 3]
+ */
+export function takeRight(array, n = 1) {
+  if (!array || !array.length) {
+    return []
+  }
+  const start = Math.max(0, array.length - n)
+  return array.slice(start)
+}
+
+/**
+ * 连接多个数组
+ * @template T
+ * @param {T[]} array
+ * @param {...T[]} arrays
+ * @returns {T[]}
+ * @example
+ * concat([1], [2], [3]) // [1, 2, 3]
+ * concat([1, 2], 3, [4, 5]) // [1, 2, 3, 4, 5]
+ * concat([], 1) // [1]
+ */
+export function concat(array, ...arrays) {
+  if (!isArrayLike(array)) {
+    array = []
+  }
+  return array.concat(...arrays.map(a => isArrayLike(a) ? a : [a]))
+}
+
+/**
+ * 获取数组的并集
+ * @template T
+ * @param {T[]} array1
+ * @param {T[]} array2
+ * @returns {T[]}
+ * @example
+ * union([1, 2, 3], [3, 4, 5]) // [1, 2, 3, 4, 5]
+ * union([1, 2], [2, 3]) // [1, 2, 3]
+ * union([1], []) // [1]
+ */
+export function union(array1, array2) {
+  return uniq([...(isArrayLike(array1) ? array1 : []), ...(isArrayLike(array2) ? array2 : [])])
+}
+
+/**
+ * 获取数组的交集
+ * @template T
+ * @param {T[]} array1
+ * @param {T[]} array2
+ * @returns {T[]}
+ * @example
+ * intersection([1, 2, 3], [2, 3, 4]) // [2, 3]
+ * intersection([1, 2], [3, 4]) // []
+ * intersection([1, 2, 2], [2, 2, 3]) // [2]
+ */
+export function intersection(array1, array2) {
+  if (!isArrayLike(array1) || !isArrayLike(array2)) {
+    return []
+  }
+  const set2 = new Set(array2)
+  return uniq(array1.filter(item => set2.has(item)))
+}
+
+/**
+ * 获取 array1 相对于 array2 的差集
+ * @template T
+ * @param {T[]} array1
+ * @param {T[]} array2
+ * @returns {T[]}
+ * @example
+ * difference([1, 2, 3], [2, 3]) // [1]
+ * difference([1, 2, 3], [1, 2, 3]) // []
+ * difference([1, 2, 3], [4, 5]) // [1, 2, 3]
+ */
+export function difference(array1, array2) {
+  if (!isArrayLike(array1)) {
+    return []
+  }
+  if (!isArrayLike(array2)) {
+    return array1.slice()
+  }
+  const set2 = new Set(array2)
+  return array1.filter(item => !set2.has(item))
+}
+
+/**
+ * 将数组分成指定大小的块
+ * @template T
+ * @param {T[]} array
+ * @param {number} size - 每个块的大小
+ * @returns {T[][]}
+ * @example
+ * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]
+ * chunk([1, 2, 3, 4], 3) // [[1, 2, 3], [4]]
+ * chunk([1, 2, 3], 1) // [[1], [2], [3]]
+ */
+export function chunk(array, size = 1) {
+  if (!isArrayLike(array) || size < 1) {
+    return []
+  }
+
+  const result = []
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size))
+  }
+  return result
+}
+
+/**
+ * 反转数组
+ * @template T
+ * @param {T[]} array
+ * @returns {T[]}
+ * @example
+ * reverse([1, 2, 3]) // [3, 2, 1]
+ * reverse(['a', 'b', 'c']) // ['c', 'b', 'a']
+ * reverse([1]) // [1]
+ */
+export function reverse(array) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+  return [...array].reverse()
+}
+
+/**
+ * 创建切片数组
+ * @template T
+ * @param {T[]} array
+ * @param {number} [start=0]
+ * @param {number} [end=array.length]
+ * @returns {T[]}
+ * @example
+ * slice([1, 2, 3, 4], 1, 3) // [2, 3]
+ * slice([1, 2, 3, 4], 2) // [3, 4]
+ * slice([1, 2, 3, 4]) // [1, 2, 3, 4]
+ */
+export function slice(array, start = 0, end) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+  return array.slice(start, end)
+}
+
+/**
+ * 压缩数组（移除 falsy 值）
+ * @template T
+ * @param {T[]} array
+ * @returns {T[]}
+ * @example
+ * compact([0, 1, false, 2, '', 3, null, 4]) // [1, 2, 3, 4]
+ * compact([1, 2, 3]) // [1, 2, 3]
+ * compact([null, undefined, 0]) // []
+ */
+export function compact(array) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+  return array.filter(item => item)
+}
+
+/**
+ * 创建新数组，移除数组开头的所有假值
+ * @template T
+ * @param {T[]} array
+ * @param {number} [n=1]
+ * @returns {T[]}
+ * @example
+ * drop([1, 2, 3], 1) // [2, 3]
+ * drop([1, 2, 3], 2) // [3]
+ * drop([1, 2, 3]) // [2, 3]
+ */
+export function drop(array, n = 1) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+  return array.slice(n)
+}
+
+/**
+ * 创建新数组，移除数组末尾的所有假值
+ * @template T
+ * @param {T[]} array
+ * @param {number} [n=1]
+ * @returns {T[]}
+ * @example
+ * dropRight([1, 2, 3], 1) // [1, 2]
+ * dropRight([1, 2, 3], 2) // [1]
+ * dropRight([1, 2, 3]) // [1, 2]
+ */
+export function dropRight(array, n = 1) {
+  if (!isArrayLike(array)) {
+    return []
+  }
+  return array.slice(0, -n)
+}
+
+// ==================== 对象函数 ====================
+
+/**
+ * 获取对象的所有可枚举属性（包括原型链）
+ * @param {Object} obj
+ * @returns {string[]}
+ * @example
+ * keys({a: 1, b: 2}) // ['a', 'b']
+ * keys([1, 2, 3]) // ['0', '1', '2']
+ * keys(null) // []
+ */
+export function keys(obj) {
+  if (obj === null || obj === undefined) {
+    return []
+  }
+  if (!isObject(obj)) {
+    obj = Object(obj)
+  }
+  return Object.keys(obj)
+}
+
+/**
+ * 获取对象的所有可枚举属性值
+ * @param {Object} obj
+ * @returns {*[]}
+ * @example
+ * values({a: 1, b: 2}) // [1, 2]
+ * values({name: 'John', age: 30}) // ['John', 30]
+ * values(null) // []
+ */
+export function values(obj) {
+  if (obj === null || obj === undefined) {
+    return []
+  }
+  return Object.keys(obj).map(key => obj[key])
+}
+
+/**
+ * 获取对象的所有可枚举属性和值的键值对
+ * @param {Object} obj
+ * @returns {Array<[string, *]>}
+ * @example
+ * entries({a: 1, b: 2}) // [['a', 1], ['b', 2]]
+ * entries({name: 'John'}) // [['name', 'John']]
+ * entries(null) // []
+ */
+export function entries(obj) {
+  if (obj === null || obj === undefined) {
+    return []
+  }
+  return Object.entries(obj)
+}
+
+/**
+ * 获取对象的属性值
+ * @param {Object} obj
+ * @param {string|Array<string>} path - 属性路径
+ * @param {*} [defaultValue] - 默认值
+ * @returns {*}
+ * @example
+ * get({a: {b: {c: 1}}}, 'a.b.c') // 1
+ * get({a: {b: {c: 1}}}, 'a.b.c.d', 'default') // 'default'
+ */
+export function get(obj, path, defaultValue) {
+  if (obj === null || obj === undefined) {
+    return defaultValue
+  }
+
+  const paths = isArray(path) ? path : String(path).split('.')
+
+  let result = obj
+  for (const key of paths) {
+    if (result === null || result === undefined) {
+      return defaultValue
+    }
+    result = result[key]
+  }
+
+  return result === undefined ? defaultValue : result
+}
+
+/**
+ * 设置对象的属性值
+ * @param {Object} obj
+ * @param {string|Array<string>} path - 属性路径
+ * @param {*} value - 要设置的值
+ * @returns {Object}
+ * @example
+ * set({a: 1}, 'b', 2) // {a: 1, b: 2}
+ * set({}, 'a.b.c', 1) // {a: {b: {c: 1}}}
+ * set({a: {b: 1}}, 'a.c', 2) // {a: {b: 1, c: 2}}
+ */
+export function set(obj, path, value) {
+  if (obj === null || obj === undefined) {
+    return obj
+  }
+
+  const paths = isArray(path) ? path : String(path).split('.')
+  let current = obj
+
+  for (let i = 0; i < paths.length - 1; i++) {
+    const key = paths[i]
+    if (!isObject(current[key])) {
+      current[key] = {}
+    }
+    current = current[key]
+  }
+
+  current[paths[paths.length - 1]] = value
+  return obj
+}
+
+/**
+ * 删除对象的属性
+ * @param {Object} obj
+ * @param {string|Array<string>} path - 属性路径
+ * @returns {boolean}
+ * @example
+ * unset({a: 1, b: 2}, 'a') // true
+ * unset({a: {b: 1}}, 'a.b') // true
+ * unset({a: 1}, 'b') // true
+ */
+export function unset(obj, path) {
+  if (obj === null || obj === undefined) {
+    return true
+  }
+
+  const paths = isArray(path) ? path : String(path).split('.')
+  let current = obj
+
+  for (let i = 0; i < paths.length - 1; i++) {
+    const key = paths[i]
+    if (!isObject(current[key])) {
+      return true
+    }
+    current = current[key]
+  }
+
+  const lastKey = paths[paths.length - 1]
+  return delete current[lastKey]
+}
+
+/**
+ * 检查对象是否有指定的属性
+ * @param {Object} obj
+ * @param {string|Array<string>} path - 属性路径
+ * @returns {boolean}
+ * @example
+ * has({a: 1, b: 2}, 'a') // true
+ * has({a: {b: 1}}, 'a.b') // true
+ * has({a: 1}, 'b') // false
+ */
+export function has(obj, path) {
+  if (obj === null || obj === undefined) {
+    return false
+  }
+
+  const paths = isArray(path) ? path : String(path).split('.')
+  let current = obj
+
+  for (const key of paths) {
+    if (current === null || current === undefined) {
+      return false
+    }
+    if (!Object.prototype.hasOwnProperty.call(current, key)) {
+      return false
+    }
+    current = current[key]
+  }
+
+  return true
+}
+
+/**
+ * 获取对象的属性数量
+ * @param {Object} obj
+ * @returns {number}
+ * @example
+ * size({a: 1, b: 2}) // 2
+ * size([1, 2, 3]) // 3
+ * size('hello') // 5
+ * size(null) // 0
+ */
+export function size(obj) {
+  if (obj === null || obj === undefined) {
+    return 0
+  }
+  if (isArrayLike(obj)) {
+    return obj.length
+  }
+  return Object.keys(obj).length
+}
+
+/**
+ * 判断两个对象是否相等（深度比较）
+ * @param {*} a
+ * @param {*} b
+ * @returns {boolean}
+ * @example
+ * isEqualDeep({a: 1}, {a: 1}) // true
+ * isEqualDeep({a: {b: 1}}, {a: {b: 1}}) // true
+ * isEqualDeep({a: 1}, {a: 2}) // false
+ */
+export function isEqualDeep(a, b) {
+  return isEqual(a, b)
+}
+
+/**
+ * 合并对象，覆盖源对象重复路径的值，支持 getter/setter
+ * @param {Object} target - 目标对象
+ * @param {...Object} sources - 一个或多个源对象
+ * @returns {Object} 返回目标对象
+ * @example
+ * merge({a: 1}, {b: 2}) // {a: 1, b: 2}
+ * merge({a: {b: 1}}, {a: {c: 2}}) // {a: {b: 1, c: 2}}
+ * merge({a: [1, 2]}, {a: [3, 4]}) // {a: [1, 2, 3, 4]}
+ */
+export function merge(target, ...sources) {
+  if (!isObject(target)) {
+    target = {}
+  }
+
+  for (const source of sources) {
+    if (!isObject(source)) {
+      continue
+    }
+
+    // 获取源对象所有可枚举的自有属性键
+    const keys = Object.keys(source)
+
+    for (const key of keys) {
+      // 获取完整的属性描述符（包含 value, writable, enumerable, configurable, get, set）
+      const descriptor = Object.getOwnPropertyDescriptor(source, key)
+      
+      // 如果描述符不存在（极少情况），跳过
+      if (!descriptor) continue
+
+      const srcVal = source[key] // 用于逻辑判断的值（如果是访问器，这里会触发 getter）
+      const tgtVal = target[key] // 目标对象当前的值
+
+      // 检查是否为访问器属性 (getter/setter)
+      const isAccessor = 'get' in descriptor || 'set' in descriptor
+
+      if (isAccessor) {
+        Object.defineProperty(target, key, descriptor)
+      } else if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+        target[key] = merge(tgtVal, srcVal)
+      } else if (isArray(srcVal) && isArray(tgtVal)) {
+        target[key] = merge([], tgtVal, srcVal)
+      } else {
+        target[key] = srcVal
+      }
+    }
+  }
+
+  return target
+}
+
+/**
+ * 合并对象，将源对象的所有可枚举自有属性复制到目标对象
+ * @param {Object} target - 目标对象
+ * @param {...Object} sources - 一个或多个源对象
+ * @returns {Object} 返回目标对象
+ * @example
+ * assign({ a: 1 }, { b: 2 }) // { a: 1, b: 2 }
+ * assign({ a: 1 }, { a: 2 }, { b: 3 }) // { a: 2, b: 3 }
+ */
+export function assign(target, ...sources) {
+  if (target === null || target === undefined) {
+    target = {}
+  }
+  return Object.assign(target, ...sources)
+}
+
+/**
+ * 创建对象的部分副本，只包含指定的属性
+ * @param {Object} obj
+ * @param {Array<string>} paths - 要 pick 的属性路径
+ * @returns {Object}
+ * @example
+ * pick({a: 1, b: 2, c: 3}, ['a', 'c']) // {a: 1, c: 3}
+ * pick({a: 1, b: 2}, ['a', 'd']) // {a: 1}
+ * pick({a: {b: 1}}, ['a.b']) // {a: {b: 1}}
+ */
+export function pick(obj, paths) {
+  if (!isObject(obj)) {
+    return {}
+  }
+
+  const result = {}
+  for (const path of paths) {
+    if (has(obj, path)) {
+      set(result, path, get(obj, path))
+    }
+  }
+  return result
+}
+
+/**
+ * 创建对象的部分副本，排除指定的属性
+ * @param {Object} obj
+ * @param {Array<string>} paths - 要排除的属性路径
+ * @returns {Object}
+ * @example
+ * omit({a: 1, b: 2, c: 3}, ['b']) // {a: 1, c: 3}
+ * omit({a: 1, b: 2}, ['c']) // {a: 1, b: 2}
+ * omit({a: 1, b: 2}, ['a', 'b']) // {}
+ */
+export function omit(obj, paths) {
+  if (!isObject(obj)) {
+    return {}
+  }
+
+  const result = {}
+  const allKeys = keys(obj)
+  const excludeKeys = new Set(paths)
+
+  for (const key of allKeys) {
+    if (!excludeKeys.has(key)) {
+      result[key] = obj[key]
+    }
+  }
+  return result
+}
+
+/**
+ * 对象键名转换（kebab-case）
+ * @param {Object} obj
+ * @returns {Object}
+ * @example
+ * keysToKebabCase({firstName: 'John'}) // {'first-name': 'John'}
+ * keysToKebabCase({a: {b: 1}}) // {a: {b: 1}}
+ * keysToKebabCase('not an object') // 'not an object'
+ */
+export function keysToKebabCase(obj) {
+  if (!isObject(obj)) {
+    return obj
+  }
+
+  const result = {}
+  for (const [key, value] of Object.entries(obj)) {
+    const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase().replace(/^-/, '')
+    result[kebabKey] = isObject(value) ? keysToKebabCase(value) : value
+  }
+  return result
+}
+
+/**
+ * 对象键名转换（camelCase）
+ * @param {Object} obj
+ * @returns {Object}
+ * @example
+ * keysToCamelCase({'first-name': 'John'}) // {firstName: 'John'}
+ * keysToCamelCase({a_b: 1}) // {aB: 1}
+ * keysToCamelCase('not an object') // 'not an object'
+ */
+export function keysToCamelCase(obj) {
+  if (!isObject(obj)) {
+    return obj
+  }
+
+  const result = {}
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = key.replace(/-([a-z])/g, (match, letter) => letter.toUpperCase())
+    result[camelKey] = isObject(value) ? keysToCamelCase(value) : value
+  }
+  return result
+}
+
+/**
+ * 根据路径字符串获取对象中的值
+ * @param {Object} object - 要查询的对象
+ * @param {string} [prop=''] - 属性路径，支持点号分隔（如 'a.b.c'）
+ * @returns {*} 如果找到则返回对应的值，否则返回 null
+ * @example
+ * getValueByPath({ a: { b: { c: 1 } } }, 'a.b.c') // 1
+ * getValueByPath({ a: 1 }, 'b') // null
+ * getValueByPath(null, 'a') // null
+ */
+export function getValueByPath(object, prop) {
+  const pathStr = prop || '';
+  const paths = pathStr.split('.');
+  let current = object;
+  let result = null;
+  for (let i = 0, j = paths.length; i < j; i++) {
+    const path = paths[i];
+    if (!current) break;
+
+    if (i === j - 1) {
+      result = current[path];
+      break;
+    }
+    current = current[path];
+  }
+  return result;
+};
+
+/**
+ * 根据路径字符串获取对象中的属性信息
+ * 支持点号分隔符 (.) 和方括号表示法 ([])，例如 'a.b.c' 或 'a[b][c]'。
+ * 
+ * @param {Object} obj - 要查询的目标对象
+ * @param {string} path - 属性路径字符串
+ * @param {boolean} [strict=false] - 是否开启严格模式。
+ *   - 如果为 true，当路径无效或中间节点非对象时抛出错误。
+ *   - 如果为 false，当路径无效时会中断遍历并返回当前状态。
+ * @returns {Object} 返回一个包含以下属性的对象：
+ *   - o: {Object|null} 最后一层有效的父对象。如果路径第一步就失败，则为 null 或原始 obj。
+ *   - k: {string|undefined} 最后一层的键名。
+ *   - v: {*} 最终获取到的值，如果路径无效则为 undefined 或 null。
+ * @throws {Error} 当 strict 为 true 且路径无效时抛出错误
+ */
+export function getPropByPath(obj, path, strict) {
+  // 1. 基础校验
+  if (obj === null || obj === undefined) {
+    if (strict) {
+      throw new Error('please transfer a valid prop path to form item!');
+    }
+    return { o: null, k: undefined, v: undefined };
+  }
+
+  if (typeof path !== 'string' || !path) {
+     if (strict) {
+      throw new Error('please transfer a valid prop path to form item!');
+    }
+    return { o: obj, k: undefined, v: undefined };
+  }
+
+  let tempObj = obj;
+  // 标准化路径：a[b] -> a.b, .a.b -> a.b
+  path = path.replace(/\[(\w+)\]/g, '.$1').replace(/^\./, '');
+  const keyArr = path.split('.');
+  const len = keyArr.length;
+  
+  // 如果路径只有一个键，直接处理
+  if (len === 1) {
+    return {
+      o: obj,
+      k: keyArr[0],
+      v: obj[keyArr[0]]
+    };
+  }
+
+  let i = 0;
+  // 开始遍历
+  for (; i < len - 1; ++i) {
+    const key = keyArr[i];
+    // 检查当前层级是否存在且为对象/数组（排除 null）
+    // 注意：Array 也是 object，in 操作符对数组有效
+    if (tempObj === null || tempObj === undefined || typeof tempObj !== 'object') {
+      // 非严格模式：中断，返回当前状态
+      // 此时 tempObj 是导致中断的那个非对象值（或 null/undefined）
+      // 为了保持与原 API 兼容，我们返回中断前的状态或者 null
+      if (strict) throw new Error(`Property '${key}' does not exist on ${tempObj} at path '${keyArr.slice(0, i).join('.')}'`);
+      return {
+        o: null,
+        k: key,
+        v: undefined
+      };
+    }
+
+    if (key in tempObj) {
+      tempObj = tempObj[key];
+    } else {
+      // 键不存在，中断
+      if (strict) throw new Error('please transfer a valid prop path to form item!');
+      return {
+        o: tempObj, // 父对象还存在
+        k: key,
+        v: undefined
+      };
+    }
+  }
+
+  const lastKey = keyArr[i];
+  if (tempObj === null || tempObj === undefined) {
+    if (strict) throw new Error('please transfer a valid prop path to form item!');
+    return { o: null, k: lastKey, v: undefined };
+  }
+
+  return {
+    o: tempObj,
+    k: lastKey,
+    v: tempObj[lastKey]
+  };
+}
+
+// ==================== 字符串函数 ====================
+
+/**
+ * 将字符串转换为 kebab-case
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * kebabCase('helloWorld') // 'hello-world'
+ * kebabCase('Hello World') // 'hello-world'
+ * kebabCase('hello_world') // 'hello-world'
+ */
+export function kebabCase(str) {
+  if (!isString(str)) {
+    return ''
+  }
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase()
+    .replace(/^-|-$/g, '')
+}
+
+/**
+ * 将字符串转换为 camelCase
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * camelCase('hello-world') // 'helloWorld'
+ * camelCase('Hello World') // 'helloWorld'
+ * camelCase('hello_world') // 'helloWorld'
+ */
+export function camelCase(str) {
+  if (!isString(str)) {
+    return ''
+  }
+  return str
+    .replace(/[-_\s]+(.)?/g, (match, char) => char ? char.toUpperCase() : '')
+    .replace(/^[A-Z]/, char => char.toLowerCase())
+}
+
+/**
+ * 将字符串转换为 PascalCase
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * pascalCase('hello-world') // 'HelloWorld'
+ * pascalCase('hello world') // 'HelloWorld'
+ * pascalCase('hello_world') // 'HelloWorld'
+ */
+export function pascalCase(str) {
+  if (!isString(str)) {
+    return ''
+  }
+  const camel = camelCase(str)
+  return camel.charAt(0).toUpperCase() + camel.slice(1)
+}
+
+/**
+ * 将字符串转换为 snake_case
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * snakeCase('helloWorld') // 'hello_world'
+ * snakeCase('Hello World') // 'hello_world'
+ * snakeCase('hello-world') // 'hello_world'
+ */
+export function snakeCase(str) {
+  if (!isString(str)) {
+    return ''
+  }
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/[\s-]+/g, '_')
+    .toLowerCase()
+}
+
+/**
+ * 将字符串转换为首字母大写
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * capitalize('hello') // 'Hello'
+ * capitalize('HELLO') // 'Hello'
+ * capitalize('hello world') // 'Hello world'
+ */
+export function capitalize(str) {
+  if (!isString(str)) {
+    return ''
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()
+}
+
+/**
+ * 将字符串重复指定次数
+ * @param {string} str
+ * @param {number} n
+ * @returns {string}
+ * @example
+ * repeat('abc', 3) // 'abcabcabc'
+ * repeat('abc', 0) // ''
+ * repeat('abc', 1) // 'abc'
+ */
+export function repeat(str, n = 0) {
+  if (!isString(str) || n < 1) {
+    return ''
+  }
+  return str.repeat(Math.floor(n))
+}
+
+/**
+ * 将字符串填充到指定长度
+ * @param {string} str
+ * @param {number} length
+ * @param {string} [chars=' ']
+ * @returns {string}
+ * @example
+ * pad('abc', 8) // '  abc   '
+ * pad('abc', 8, '_-') // '_-abc_-_'
+ * pad('abc', 3) // 'abc'
+ */
+export function pad(str, length, chars = ' ') {
+  if (!isString(str) || length <= str.length) {
+    return str
+  }
+  const totalPad = length - str.length
+  const padStart = Math.floor(totalPad / 2)
+  const padEnd = totalPad - padStart
+  return chars.repeat(padStart) + str + chars.repeat(padEnd)
+}
+
+/**
+ * 左侧填充字符串
+ * @param {string} str
+ * @param {number} length
+ * @param {string} [chars=' ']
+ * @returns {string}
+ * @example
+ * padStart('abc', 6) // '   abc'
+ * padStart('abc', 6, '_-') // '_-_abc'
+ * padStart('abc', 3) // 'abc'
+ */
+export function padStart(str, length, chars = ' ') {
+  if (!isString(str) || length <= str.length) {
+    return str
+  }
+  return chars.repeat(length - str.length) + str
+}
+
+/**
+ * 右侧填充字符串
+ * @param {string} str
+ * @param {number} length
+ * @param {string} [chars=' ']
+ * @returns {string}
+ * @example
+ * padEnd('abc', 6) // 'abc   '
+ * padEnd('abc', 6, '_-') // 'abc_-_'
+ * padEnd('abc', 3) // 'abc'
+ */
+export function padEnd(str, length, chars = ' ') {
+  if (!isString(str) || length <= str.length) {
+    return str
+  }
+  return str + chars.repeat(length - str.length)
+}
+
+/**
+ * 去除字符串两端的空白
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * trim('  abc  ') // 'abc'
+ * trim('abc') // 'abc'
+ * trim(null) // ''
+ */
+export function trim(str) {
+  return isString(str) ? str.trim() : ''
+}
+
+/**
+ * 去除字符串左端的空白
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * trimStart('  abc  ') // 'abc  '
+ * trimStart('abc') // 'abc'
+ * trimStart(null) // ''
+ */
+export function trimStart(str) {
+  return isString(str) ? str.trimStart() : ''
+}
+
+/**
+ * 去除字符串右端的空白
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * trimEnd('  abc  ') // '  abc'
+ * trimEnd('abc') // 'abc'
+ * trimEnd(null) // ''
+ */
+export function trimEnd(str) {
+  return isString(str) ? str.trimEnd() : ''
+}
+
+/**
+ * 将字符串截断到指定长度
+ * @param {string} str
+ * @param {Object} [options]
+ * @param {number} [options.length=30] - 最大长度
+ * @param {string} [options.omission='...'] - 截断标记
+ * @param {boolean} [options.separator=false] - 是否在单词边界截断
+ * @returns {string}
+ * @example
+ * truncate('hello world', {length: 8}) // 'he...'
+ * truncate('hello world', {length: 8, omission: '→'}) // 'hello w→'
+ * truncate('hello world', {length: 15}) // 'hello world'
+ */
+export function truncate(str, options = {}) {
+  if (!isString(str)) {
+    return ''
+  }
+
+  const {
+    length: maxLength = 30,
+    omission = '...',
+    separator = false
+  } = options
+
+  if (str.length <= maxLength) {
+    return str
+  }
+
+  let result = str.slice(0, maxLength - omission.length)
+
+  if (separator) {
+    const separatorIndex = result.lastIndexOf(/\s/)
+    if (separatorIndex > 0) {
+      result = result.slice(0, separatorIndex)
+    }
+  }
+
+  return result + omission
+}
+
+/**
+ * 转义 HTML 字符
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * escape('<script>alert("XSS")</script>') // '&lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;'
+ * escape('a & b') // 'a &amp; b'
+ * escape('hello') // 'hello'
+ */
+export function escape(str) {
+  if (!isString(str)) {
+    return ''
+  }
+  const escapes = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+  }
+  return str.replace(/[&<>"']/g, char => escapes[char])
+}
+
+/**
+ * 反转义 HTML 字符
+ * @param {string} str
+ * @returns {string}
+ * @example
+ * unescape('&lt;script&gt;') // '<script>'
+ * unescape('&amp;') // '&'
+ * unescape('hello') // 'hello'
+ */
+export function unescape(str) {
+  if (!isString(str)) {
+    return ''
+  }
+  const escapes = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'"
+  }
+  return str.replace(/&(amp|lt|gt|quot|#39);/g, match => escapes[match])
+}
+
+/**
+ * 转义正则表达式特殊字符
+ * @param {*} [value=''] - 需要转义的字符串
+ * @returns {string} 转义后的字符串，可安全用于 RegExp 构造函数
+ * @example
+ * escapeRegexpString('hello.world') // 'hello\\.world'
+ * escapeRegexpString('(test)') // '\\(test\\)'
+ * escapeRegexpString('a+b*c?') // 'a\\+b\\*c\\?'
+ */
+export function escapeRegexpString(value = '') {
+  return String(value).replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
+}
+
+// ==================== 数字函数 ====================
+
+/**
+ * 将数字四舍五入到指定的小数位数
+ * @param {number} num
+ * @param {number} [precision=0] - 小数位数
+ * @returns {number}
+ * @example
+ * round(4.006) // 4
+ * round(4.006, 2) // 4.01
+ * round(4060, -2) // 4100
+ */
+export function round(num, precision = 0) {
+  if (!isFiniteNumber(num)) {
+    return num
+  }
+  const factor = Math.pow(10, precision)
+  return Math.round(num * factor) / factor
+}
+
+/**
+ * 将数字向上取整到指定的小数位数
+ * @param {number} num
+ * @param {number} [precision=0]
+ * @returns {number}
+ * @example
+ * ceil(4.006) // 5
+ * ceil(4.006, 2) // 4.01
+ * ceil(4060, -2) // 4100
+ */
+export function ceil(num, precision = 0) {
+  if (!isFiniteNumber(num)) {
+    return num
+  }
+  const factor = Math.pow(10, precision)
+  return Math.ceil(num * factor) / factor
+}
+
+/**
+ * 将数字向下取整到指定的小数位数
+ * @param {number} num
+ * @param {number} [precision=0]
+ * @returns {number}
+ * @example
+ * floor(4.006) // 4
+ * floor(4.006, 2) // 4
+ * floor(4060, -2) // 4000
+ */
+export function floor(num, precision = 0) {
+  if (!isFiniteNumber(num)) {
+    return num
+  }
+  const factor = Math.pow(10, precision)
+  return Math.floor(num * factor) / factor
+}
+
+/**
+ * 获取随机数
+ * @param {number} [min=0]
+ * @param {number} [max=1]
+ * @returns {number}
+ * @example
+ * random(0, 5) // 0 到 5 之间的随机数
+ * random(1.2, 5.5) // 1.2 到 5.5 之间的随机数
+ * random() // 0 到 1 之间的随机数
+ */
+export function random(min = 0, max = 1) {
+  if (max < min) {
+    [min, max] = [max, min]
+  }
+  return Math.random() * (max - min) + min
+}
+
+/**
+ * 获取范围内的随机整数
+ * @param {number} [min=0]
+ * @param {number} [max=1]
+ * @returns {number}
+ * @example
+ * randomInt(0, 5) // 0 到 5 之间的随机整数
+ * randomInt(3) // 0 到 3 之间的随机整数
+ * randomInt() // 0 或 1
+ */
+export function randomInt(min = 0, max = 1) {
+  if (max < min) {
+    [min, max] = [max, min]
+  }
+  min = Math.ceil(min)
+  max = Math.floor(max)
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+/**
+ * 确保数字在范围内
+ * @param {number} num
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ * @example
+ * clamp(-10, 0, 100) // 0
+ * clamp(50, 0, 100) // 50
+ * clamp(150, 0, 100) // 100
+ */
+export function clamp(num, min, max) {
+  return Math.min(Math.max(num, min), max)
+}
+
+/**
+ * 检查值是否在范围内
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @param {Object} [options]
+ * @param {boolean} [options.leftClosed=true]
+ * @param {boolean} [options.rightClosed=true]
+ * @returns {boolean}
+ * @example
+ * isInRange(5, 1, 10) // true
+ * isInRange(1, 1, 10, {leftClosed: false}) // false
+ * isInRange(10, 1, 10, {rightClosed: false}) // false
+ */
+export function isInRange(value, min, max, options = {}) {
+  const {
+    leftClosed = true,
+    rightClosed = true
+  } = options
+
+  if (!isFiniteNumber(value) || !isFiniteNumber(min) || !isFiniteNumber(max)) {
+    return false
+  }
+
+  const [minVal, maxVal] = min <= max ? [min, max] : [max, min]
+
+  const leftCheck = leftClosed ? value >= minVal : value > minVal
+  const rightCheck = rightClosed ? value <= maxVal : value < maxVal
+
+  return leftCheck && rightCheck
+}
+
+// ==================== 函数函数 ====================
+
+/**
+ * 创建一个防抖函数
+ * @param {Function} func
+ * @param {number} wait - 等待毫秒数
+ * @param {Object} [options]
+ * @param {boolean} [options.immediate=false] - 是否立即执行
+ * @returns {Function}
+ * @example
+ * const debouncedFn = debounce(() => console.log('executed'), 300)
+ * debouncedFn() // 300ms 后执行
+ * const immediateDebounce = debounce(fn, 300, {immediate: true}) // 立即执行
+ */
+export function debounce(func, wait, options = {}) {
+  const { immediate = false } = options
+  let timeout = null
+
+  return function (...args) {
+    const context = this
+    const later = () => {
+      timeout = null
+      if (!immediate) {
+        func.apply(context, args)
+      }
+    }
+
+    const callNow = immediate && !timeout
+    clearTimeout(timeout)
+    timeout = setTimeout(later, wait)
+
+    if (callNow) {
+      func.apply(context, args)
+    }
+  }
+}
+
+/**
+ * 创建一个节流函数
+ * @param {Function} func
+ * @param {number} wait - 等待毫秒数
+ * @param {Object} [options]
+ * @param {boolean} [options.leading=true] - 是否执行开头
+ * @param {boolean} [options.trailing=true] - 是否执行结尾
+ * @returns {Function}
+ * @example
+ * const throttledFn = throttle(() => console.log('executed'), 1000)
+ * throttledFn() // 立即执行，然后 1 秒内不再执行
+ * const trailingFn = throttle(fn, 1000, {leading: false}) // 只执行结尾
+ */
+export function throttle(func, wait, options = {}) {
+  const { leading = true, trailing = true } = options
+  let timeout = null
+  let previous = 0
+  let lastArgs = null
+  let lastContext = null
+
+  const invoke = () => {
+    previous = leading ? Date.now() : 0
+    if (trailing && lastArgs) {
+      func.apply(lastContext, lastArgs)
+      lastArgs = null
+      lastContext = null
+    }
+  }
+
+  return function (...args) {
+    const now = Date.now()
+
+    if (!previous && !leading) {
+      previous = now
+    }
+
+    const remaining = wait - (now - previous)
+    lastArgs = args
+    lastContext = this
+
+    if (remaining <= 0) {
+      clearTimeout(timeout)
+      timeout = null
+      previous = now
+      func.apply(this, args)
+    } else if (!timeout && trailing) {
+      timeout = setTimeout(invoke, remaining)
+    }
+  }
+}
+
+/**
+ * 创建一个只执行一次的函数
+ * @param {Function} func
+ * @returns {Function}
+ * @example
+ * const initOnce = once(() => console.log('initialized'))
+ * initOnce() // 'initialized'
+ * initOnce() // 无输出
+ */
+export function once(func) {
+  let called = false
+  let result
+
+  return function (...args) {
+    if (!called) {
+      called = true
+      result = func.apply(this, args)
+    }
+    return result
+  }
+}
+
+/**
+ * 创建一个取反结果的函数
+ * @param {Function} predicate
+ * @returns {Function}
+ * @example
+ * const isEven = n => n % 2 === 0
+ * const isOdd = negate(isEven)
+ * isOdd(3) // true
+ * isOdd(2) // false
+ */
+export function negate(predicate) {
+  return function (...args) {
+    return !predicate.apply(this, args)
+  }
+}
+
+/**
+ * 空函数，什么都不做
+ * @returns {void}
+ * @example
+ * noop() // undefined
+ * const callback = options.callback || noop
+ */
+export function noop() {}
+
+/**
+ * 返回传入的值（恒等函数）
+ * @param {*} value
+ * @returns {*}
+ * @example
+ * identity(1) // 1
+ * identity({a: 1}) // {a: 1}
+ * [1, 2, 3].map(identity) // [1, 2, 3]
+ */
+export function identity(value) {
+  return value
+}
+
+/**
+ * 创建一个返回固定值的函数
+ * @param {*} value
+ * @returns {Function}
+ * @example
+ * const returnZero = constant(0)
+ * returnZero() // 0
+ * const defaultOptions = constant({debug: false})
+ */
+export function constant(value) {
+  return () => value
+}
+
+/**
+ * 创建一个组合函数（从右到左执行）
+ * @param  {...Function} funcs
+ * @returns {Function}
+ * @example
+ * const double = n => n * 2
+ * const addOne = n => n + 1
+ * const transform = compose(double, addOne)
+ * transform(5) // 12 (先加 1 得 6，再乘 2 得 12)
+ */
+export function compose(...funcs) {
+  return function (arg) {
+    return funcs.reduceRight((result, func) => func(result), arg)
+  }
+}
+
+/**
+ * 创建一个组合函数（从左到右执行）
+ * @param  {...Function} funcs
+ * @returns {Function}
+ * @example
+ * const double = n => n * 2
+ * const addOne = n => n + 1
+ * const transform = pipe(double, addOne)
+ * transform(5) // 11 (先乘 2 得 10，再加 1 得 11)
+ */
+export function pipe(...funcs) {
+  return function (arg) {
+    return funcs.reduce((result, func) => func(result), arg)
+  }
+}
+
+// ==================== 日期函数 ====================
+
+/**
+ * 格式化日期
+ * @param {Date|string|number} date
+ * @param {string} [format='YYYY-MM-DD HH:mm:ss']
+ * @returns {string}
+ * @example
+ * formatDate(new Date('2024-01-15')) // '2024-01-15 00:00:00'
+ * formatDate(new Date(), 'YYYY/MM/DD') // '2024/03/25'
+ * formatDate(1705305600000) // '2024-01-15 00:00:00'
+ */
+export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
+  if (!date) {
+    return ''
+  }
+
+  const d = new Date(date)
+  if (isNaN(d.getTime())) {
+    return ''
+  }
+
+  const year = d.getFullYear()
+  const month = String(d.getMonth() + 1).padStart(2, '0')
+  const day = String(d.getDate()).padStart(2, '0')
+  const hours = String(d.getHours()).padStart(2, '0')
+  const minutes = String(d.getMinutes()).padStart(2, '0')
+  const seconds = String(d.getSeconds()).padStart(2, '0')
+  const milliseconds = String(d.getMilliseconds()).padStart(3, '0')
+
+  return format
+    .replace('YYYY', year)
+    .replace('MM', month)
+    .replace('DD', day)
+    .replace('HH', hours)
+    .replace('mm', minutes)
+    .replace('ss', seconds)
+    .replace('SSS', milliseconds)
+}
+
+/**
+ * 解析日期字符串
+ * @param {string} str
+ * @param {string} [format='YYYY-MM-DD HH:mm:ss']
+ * @returns {Date|null}
+ * @example
+ * parseDate('2024-01-15 12:30:00') // Date 对象
+ * parseDate('2024/01/15', 'YYYY/MM/DD') // Date 对象
+ * parseDate('invalid') // null
+ */
+export function parseDate(str, format = 'YYYY-MM-DD HH:mm:ss') {
+  if (!str) {
+    return null
+  }
+
+  const parts = {}
+  const pattern = format
+    .replace('YYYY', '(?<year>\\d{4})')
+    .replace('MM', '(?<month>\\d{2})')
+    .replace('DD', '(?<day>\\d{2})')
+    .replace('HH', '(?<hours>\\d{2})')
+    .replace('mm', '(?<minutes>\\d{2})')
+    .replace('ss', '(?<seconds>\\d{2})')
+    .replace('SSS', '(?<milliseconds>\\d{3})')
+
+  const regex = new RegExp(pattern)
+  const match = str.match(regex)
+
+  if (!match || !match.groups) {
+    return null
+  }
+
+  const { year, month, day, hours, minutes, seconds, milliseconds } = match.groups
+
+  return new Date(
+    parseInt(year),
+    parseInt(month) - 1,
+    parseInt(day),
+    parseInt(hours || 0),
+    parseInt(minutes || 0),
+    parseInt(seconds || 0),
+    parseInt(milliseconds || 0)
+  )
+}
+
+/**
+ * 获取两个日期之间的差异
+ * @param {Date} date1
+ * @param {Date} date2
+ * @param {string} [unit='ms'] - 单位：ms, s, m, h, d
+ * @returns {number}
+ * @example
+ * dateDiff(new Date('2024-01-02'), new Date('2024-01-01')) // 86400000
+ * dateDiff(new Date('2024-01-02'), new Date('2024-01-01'), 'd') // 1
+ * dateDiff(new Date('2024-01-02'), new Date('2024-01-01'), 'h') // 24
+ */
+export function dateDiff(date1, date2, unit = 'ms') {
+  const diff = new Date(date1).getTime() - new Date(date2).getTime()
+
+  switch (unit) {
+    case 's': return Math.floor(diff / 1000)
+    case 'm': return Math.floor(diff / 60000)
+    case 'h': return Math.floor(diff / 3600000)
+    case 'd': return Math.floor(diff / 86400000)
+    default: return diff
+  }
+}
+
+// ==================== 深度克隆 ====================
+
+/**
+ * 深度克隆值
+ * @template T
+ * @param {T} obj
+ * @param {WeakMap} [hash] 用于处理循环引用的缓存
+ * @returns {T}
+ * @example
+ * cloneDeep({a: 1, b: {c: 2}}) // 深拷贝对象
+ * cloneDeep([1, [2, [3]]]) // 深拷贝数组
+ * cloneDeep(new Date()) // 深拷贝日期
+ */
+export function cloneDeep(obj, hash = new WeakMap()) {
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+
+  if (hash.has(obj)) {
+    return hash.get(obj)
+  }
+
+  if (obj instanceof Date) {
+    return new Date(obj.getTime())
+  }
+
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags)
+  }
+
+  if (obj instanceof Map) {
+    const result = new Map()
+    hash.set(obj, result)
+    for (const [key, value] of obj.entries()) {
+      result.set(key, cloneDeep(value, hash))
+    }
+    return result
+  }
+
+  if (obj instanceof Set) {
+    const result = new Set()
+    hash.set(obj, result)
+    for (const value of obj.values()) {
+      result.add(cloneDeep(value, hash))
+    }
+    return result
+  }
+
+  if (Array.isArray(obj)) {
+    const result = []
+    hash.set(obj, result)
+    return obj.map(item => cloneDeep(item, hash))
+  }
+
+  if (obj.constructor === Object) {
+    const result = Object.create(Object.getPrototypeOf(obj))
+    hash.set(obj, result)
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        result[key] = cloneDeep(obj[key], hash)
+      }
+    }
+    return result
+  }
+
+  return obj
+}
+
+// ==================== 工具类函数 ====================
+
+/**
+ * 创建一个定时器 Promise
+ * @param {number} ms
+ * @returns {Promise<void>}
+ * @example
+ * await sleep(1000) // 等待 1 秒
+ * sleep(500).then(() => console.log('done')) // 500ms 后打印
+ */
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * 尝试执行函数，失败时返回默认值
+ * @template T
+ * @param {Function} fn
+ * @param {T} defaultValue
+ * @returns {T}
+ * @example
+ * tryCatch(() => JSON.parse('{invalid}'), {}) // {}
+ * tryCatch(() => 1 + 1, 0) // 2
+ * tryCatch(() => { throw new Error() }, 'error') // 'error'
+ */
+export function tryCatch(fn, defaultValue) {
+  try {
+    return fn()
+  } catch (e) {
+    return defaultValue
+  }
+}
+
+/**
+ * 创建一个延迟执行的 Promise
+ * @param {number} ms
+ * @param {*} value
+ * @returns {Promise<*>}
+ * @example
+ * await delay(1000, 'result') // 1 秒后返回 'result'
+ * delay(500, {data: 1}).then(console.log) // 500ms 后打印对象
+ */
+export function delay(ms, value) {
+  return new Promise(resolve => setTimeout(() => resolve(value), ms))
+}
+
+// ==================== 导出默认对象 ====================
+
+export default {
+  // 类型判断
+  isNil,
+  isUndefined,
+  isNull,
+  isBoolean,
+  isNumber,
+  isFiniteNumber,
+  isInteger,
+  isNaN: isNaN,
+  isString,
+  isSymbol,
+  isFunction,
+  isArray,
+  isArrayLike,
+  isObject,
+  isPlainObject,
+  isObjectLike,
+  isDate,
+  isRegExp,
+  isPromise,
+  isMap,
+  isSet,
+  isWeakMap,
+  isWeakSet,
+
+  // 值判断
+  isEmpty,
+  isEqual,
+
+  // 数组函数
+  find,
+  indexOf,
+  lastIndexOf,
+  filter,
+  map,
+  uniq,
+  flatten,
+  flattenDeep,
+  first,
+  last,
+  initial,
+  rest,
+  take,
+  takeRight,
+  concat,
+  union,
+  intersection,
+  difference,
+  chunk,
+  reverse,
+  slice,
+  compact,
+  drop,
+  dropRight,
+
+  // 对象函数
+  keys,
+  values,
+  entries,
+  get,
+  set,
+  unset,
+  has,
+  size,
+  merge,
+  pick,
+  omit,
+  keysToKebabCase,
+  keysToCamelCase,
+
+  // 字符串函数
+  kebabCase,
+  camelCase,
+  pascalCase,
+  snakeCase,
+  capitalize,
+  repeat,
+  pad,
+  padStart,
+  padEnd,
+  trim,
+  trimStart,
+  trimEnd,
+  truncate,
+  escape,
+  unescape,
+
+  // 数字函数
+  round,
+  ceil,
+  floor,
+  random,
+  randomInt,
+  clamp,
+  isInRange,
+
+  // 函数函数
+  debounce,
+  throttle,
+  once,
+  negate,
+  noop,
+  identity,
+  constant,
+  compose,
+  pipe,
+
+  // 日期函数
+  formatDate,
+  parseDate,
+  dateDiff,
+
+  // 深度克隆
+  cloneDeep,
+
+  // 工具类函数
+  sleep,
+  tryCatch,
+  delay
+}