@pawover/kit 0.0.0-beta.40 → 0.0.0-beta.41

package/dist/index.js

@@ -1,3 +1,3 @@
-import { $ as arrayFirst, A as mathToDecimal, At as isFalsy, B as isBrowser, Bt as isGeneratorFunction, C as objectMapEntries, Ct as isPositiveInteger, D as enumEntries, Dt as isIterable, E as enumKeys, Et as isWeakMap, F as cloneDeepWith, Ft as isDate, G as arraySplit, Gt as isArray, H as arrayZipToObject, Ht as isBlob, I as to, It as isClass, J as arrayPick, K as arrayReplaceMove, Kt as isTypedArray, L as isTablet, Lt as isAsyncFunction, M as stringToNumber, Mt as isError, N as clone, Nt as isEqual, O as numberWithin, Ot as isIframe, P as cloneDeep, Pt as isEnumeration, Q as arrayFork, R as isIOSMobile, Rt as isAsyncGeneratorFunction, S as objectAssign, St as isNumber, T as enumValues, Tt as isMap, U as arrayUnzip, Ut as isFile, V as isWebWorker, Vt as isBoolean, W as arrayZip, Wt as isBigInt, X as arrayLast, Y as arrayMerge, Z as arrayIntersection, _ as objectPick, _t as isInfinity, a as treeFind, at as isWebSocket, b as objectInvert, bt as isNaN, c as stringTruncate, ct as isSymbol, d as stringToPosix, dt as isRegExp, et as arrayDifference, f as stringToJson, ft as isString, g as objectValues, gt as isObject, h as stringInitialCase, ht as isPromiseLike, i as treeForEach, it as isWindow, j as mathToBignumber, jt as isFalsyLike, k as mathToEvaluate, kt as isInIframe, l as stringTrim, lt as isSet, m as stringReplace, mt as isPromise, n as rowsToTree, nt as arrayCompete, o as treeFilter, ot as isURLSearchParams, p as stringTemplate, pt as isReadableStream, q as arrayReplace, qt as isAbortSignal, r as treeMap, rt as arrayCast, s as getTimeZone, st as isUndefined, t as treeToRows, tt as arrayCounting, u as stringToValues, ut as isWeakSet, v as objectOmit, vt as isInfinityLike, w as objectEntries, wt as isNull, x as objectCrush, xt as isNegativeInteger, y as objectKeys, yt as isInteger, z as isMobile, zt as isFunction } from "./utils-DbMbll5L.js";
+import { $ as arrayIntersection, A as numberWithin, At as isIframe, B as isIOSMobile, Bt as isAsyncGeneratorFunction, C as objectCrush, Ct as isNegativeInteger, D as enumValues, Dt as isMap, E as objectEntries, Et as isNull, F as clone, Ft as isEqual, G as arrayUnzip, Gt as isFile, H as isBrowser, Ht as isGeneratorFunction, I as cloneDeep, It as isEnumeration, J as arrayReplaceMove, Jt as isTypedArray, K as arrayZip, Kt as isBigInt, L as cloneDeepWith, Lt as isDate, M as mathToDecimal, Mt as isFalsy, N as mathToBignumber, Nt as isFalsyLike, O as enumKeys, Ot as isWeakMap, P as stringToNumber, Pt as isError, Q as arrayLast, R as to, Rt as isClass, S as objectInvert, St as isNaN, T as objectMapEntries, Tt as isPositiveInteger, U as isWebWorker, Ut as isBoolean, V as isMobile, Vt as isFunction, W as arrayZipToObject, Wt as isBlob, X as arrayPick, Y as arrayReplace, Yt as isAbortSignal, Z as arrayMerge, _ as stringInitialCase, _t as isPromiseLike, a as treeFind, at as arrayCast, b as objectOmit, bt as isInfinityLike, c as stringTruncate, ct as isURLSearchParams, d as stringToUpperCase, dt as isSet, et as arrayFork, f as stringToPosix, ft as isWeakSet, g as stringReplace, gt as isPromise, h as stringTemplate, ht as isReadableStream, i as treeForEach, it as arrayCompete, j as mathToEvaluate, jt as isInIframe, k as enumEntries, kt as isIterable, l as stringTrim, lt as isUndefined, m as stringToJson, mt as isString, n as rowsToTree, nt as arrayDifference, o as treeFilter, ot as isWindow, p as stringToLowerCase, pt as isRegExp, q as arraySplit, qt as isArray, r as treeMap, rt as arrayCounting, s as getTimeZone, st as isWebSocket, t as treeToRows, tt as arrayFirst, u as stringToValues, ut as isSymbol, v as objectValues, vt as isObject, w as objectAssign, wt as isNumber, x as objectKeys, xt as isInteger, y as objectPick, yt as isInfinity, z as isTablet, zt as isAsyncFunction } from "./utils-_dtCs-qa.js";
 
-export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arrayReplaceMove, arraySplit, arrayUnzip, arrayZip, arrayZipToObject, clone, cloneDeep, cloneDeepWith, enumEntries, enumKeys, enumValues, getTimeZone, isAbortSignal, isArray, isAsyncFunction, isAsyncGeneratorFunction, isBigInt, isBlob, isBoolean, isBrowser, isClass, isDate, isEnumeration, isEqual, isError, isFalsy, isFalsyLike, isFile, isFunction, isGeneratorFunction, isIOSMobile, isIframe, isInIframe, isInfinity, isInfinityLike, isInteger, isIterable, isMap, isMobile, isNaN, isNegativeInteger, isNull, isNumber, isObject, isPositiveInteger, isPromise, isPromiseLike, isReadableStream, isRegExp, isSet, isString, isSymbol, isTablet, isTypedArray, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWebWorker, isWindow, mathToBignumber, mathToDecimal, mathToEvaluate, numberWithin, objectAssign, objectCrush, objectEntries, objectInvert, objectKeys, objectMapEntries, objectOmit, objectPick, objectValues, rowsToTree, stringInitialCase, stringReplace, stringTemplate, stringToJson, stringToNumber, stringToPosix, stringToValues, stringTrim, stringTruncate, to, treeFilter, treeFind, treeForEach, treeMap, treeToRows };
+export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arrayReplaceMove, arraySplit, arrayUnzip, arrayZip, arrayZipToObject, clone, cloneDeep, cloneDeepWith, enumEntries, enumKeys, enumValues, getTimeZone, isAbortSignal, isArray, isAsyncFunction, isAsyncGeneratorFunction, isBigInt, isBlob, isBoolean, isBrowser, isClass, isDate, isEnumeration, isEqual, isError, isFalsy, isFalsyLike, isFile, isFunction, isGeneratorFunction, isIOSMobile, isIframe, isInIframe, isInfinity, isInfinityLike, isInteger, isIterable, isMap, isMobile, isNaN, isNegativeInteger, isNull, isNumber, isObject, isPositiveInteger, isPromise, isPromiseLike, isReadableStream, isRegExp, isSet, isString, isSymbol, isTablet, isTypedArray, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWebWorker, isWindow, mathToBignumber, mathToDecimal, mathToEvaluate, numberWithin, objectAssign, objectCrush, objectEntries, objectInvert, objectKeys, objectMapEntries, objectOmit, objectPick, objectValues, rowsToTree, stringInitialCase, stringReplace, stringTemplate, stringToJson, stringToLowerCase, stringToNumber, stringToPosix, stringToUpperCase, stringToValues, stringTrim, stringTruncate, to, treeFilter, treeFind, treeForEach, treeMap, treeToRows };

package/dist/patches-fetchEventSource.js

@@ -1,4 +1,4 @@
-import { Ct as isPositiveInteger, Vt as isBoolean, bt as isNaN, pt as isReadableStream, qt as isAbortSignal, zt as isFunction } from "./utils-DbMbll5L.js";
+import { St as isNaN, Tt as isPositiveInteger, Ut as isBoolean, Vt as isFunction, Yt as isAbortSignal, ht as isReadableStream } from "./utils-_dtCs-qa.js";
 
 //#region src/patches/fetchEventSource/parse.ts
 const CONTROL_CHARS_ENUM = {

package/dist/{utils-DbMbll5L.js → utils-_dtCs-qa.js}

@@ -542,7 +542,7 @@ function isReadableStream(value) {
 * 检查 value 是否为 string 类型
 *
 * @param value 待检查值
-* @param checkEmpty 是否排除空字符串
+* @param checkEmpty 是否检查空字符串
 * @returns 是否为字符串
 * @example
 * ```ts
@@ -1317,13 +1317,6 @@ const R2 = /[^a-zA-Z\u00C0-\u017F]/;
 * - 纯字母且非全大写时，首字母小写，其余保留
 * - 纯字母且非全大写时，首字母大写，其余保留
 *
-/**
-* 字符串首字母大小写
-* - 包含非西欧字母字符时，不处理
-* - 纯字母且全大写时，不处理
-* - 纯字母且非全大写时，首字母小写，其余保留
-* - 纯字母且非全大写时，首字母大写，其余保留
-*
 * @param input 待处理字符串
 * @param caseType 大小写类型
 * @returns 处理后的字符串
@@ -1350,10 +1343,6 @@ function stringInitialCase(input, caseType) {
 * 字符串替换
 * - 替换第一个匹配项
 *
-/**
-* 字符串替换
-* - 替换第一个匹配项
-*
 * @param input 待处理字符串
 * @param search 匹配项
 * @param replacement 替换项
@@ -1404,9 +1393,6 @@ function stringTemplate(input, template, regex = R1) {
 /**
 * 处理 JSON 字符串
 *
-/**
-* 处理 JSON 字符串
-*
 * @param input 待处理字符串
 * @param safeValue 安全值 (当解析失败或输入无效时返回)
 * @returns 解析后的对象 或 安全值
@@ -1425,6 +1411,13 @@ function stringToJson(input, safeValue) {
 	}
 }
 
+//#endregion
+//#region src/utils/string/stringToLowerCase.ts
+function stringToLowerCase(input) {
+	if (!isString(input, true)) return "";
+	return input.toLowerCase();
+}
+
 //#endregion
 //#region src/utils/string/stringToPosix.ts
 /**
@@ -1464,6 +1457,13 @@ function stringToPosix(input, removeLeadingSlash = false) {
 	return normalized;
 }
 
+//#endregion
+//#region src/utils/string/stringToUpperCase.ts
+function stringToUpperCase(input) {
+	if (!isString(input, true)) return "";
+	return input.toUpperCase();
+}
+
 //#endregion
 //#region src/utils/string/stringToValues.ts
 function stringToValues(input, valueType = "number", splitSymbol = ",") {
@@ -2000,5 +2000,5 @@ function treeToRows(tree, options = {}) {
 }
 
 //#endregion
-export { arrayFirst as $, mathToDecimal as A, isFalsy as At, isBrowser as B, isGeneratorFunction as Bt, objectMapEntries as C, isPositiveInteger as Ct, enumEntries as D, isIterable as Dt, enumKeys as E, isWeakMap as Et, cloneDeepWith as F, isDate as Ft, arraySplit as G, isArray as Gt, arrayZipToObject as H, isBlob as Ht, to as I, isClass as It, arrayPick as J, arrayReplaceMove as K, isTypedArray as Kt, isTablet as L, isAsyncFunction as Lt, stringToNumber as M, isError as Mt, clone as N, isEqual as Nt, numberWithin as O, isIframe as Ot, cloneDeep as P, isEnumeration as Pt, arrayFork as Q, isIOSMobile as R, isAsyncGeneratorFunction as Rt, objectAssign as S, isNumber as St, enumValues as T, isMap as Tt, arrayUnzip as U, isFile as Ut, isWebWorker as V, isBoolean as Vt, arrayZip as W, isBigInt as Wt, arrayLast as X, arrayMerge as Y, arrayIntersection as Z, objectPick as _, isInfinity as _t, treeFind as a, isWebSocket as at, objectInvert as b, isNaN as bt, stringTruncate as c, isSymbol as ct, stringToPosix as d, isRegExp as dt, arrayDifference as et, stringToJson as f, isString as ft, objectValues as g, isObject as gt, stringInitialCase as h, isPromiseLike as ht, treeForEach as i, isWindow as it, mathToBignumber as j, isFalsyLike as jt, mathToEvaluate as k, isInIframe as kt, stringTrim as l, isSet as lt, stringReplace as m, isPromise as mt, rowsToTree as n, arrayCompete as nt, treeFilter as o, isURLSearchParams as ot, stringTemplate as p, isReadableStream as pt, arrayReplace as q, isAbortSignal as qt, treeMap as r, arrayCast as rt, getTimeZone as s, isUndefined as st, treeToRows as t, arrayCounting as tt, stringToValues as u, isWeakSet as ut, objectOmit as v, isInfinityLike as vt, objectEntries as w, isNull as wt, objectCrush as x, isNegativeInteger as xt, objectKeys as y, isInteger as yt, isMobile as z, isFunction as zt };
-//# sourceMappingURL=utils-DbMbll5L.js.map
+export { arrayIntersection as $, numberWithin as A, isIframe as At, isIOSMobile as B, isAsyncGeneratorFunction as Bt, objectCrush as C, isNegativeInteger as Ct, enumValues as D, isMap as Dt, objectEntries as E, isNull as Et, clone as F, isEqual as Ft, arrayUnzip as G, isFile as Gt, isBrowser as H, isGeneratorFunction as Ht, cloneDeep as I, isEnumeration as It, arrayReplaceMove as J, isTypedArray as Jt, arrayZip as K, isBigInt as Kt, cloneDeepWith as L, isDate as Lt, mathToDecimal as M, isFalsy as Mt, mathToBignumber as N, isFalsyLike as Nt, enumKeys as O, isWeakMap as Ot, stringToNumber as P, isError as Pt, arrayLast as Q, to as R, isClass as Rt, objectInvert as S, isNaN as St, objectMapEntries as T, isPositiveInteger as Tt, isWebWorker as U, isBoolean as Ut, isMobile as V, isFunction as Vt, arrayZipToObject as W, isBlob as Wt, arrayPick as X, arrayReplace as Y, isAbortSignal as Yt, arrayMerge as Z, stringInitialCase as _, isPromiseLike as _t, treeFind as a, arrayCast as at, objectOmit as b, isInfinityLike as bt, stringTruncate as c, isURLSearchParams as ct, stringToUpperCase as d, isSet as dt, arrayFork as et, stringToPosix as f, isWeakSet as ft, stringReplace as g, isPromise as gt, stringTemplate as h, isReadableStream as ht, treeForEach as i, arrayCompete as it, mathToEvaluate as j, isInIframe as jt, enumEntries as k, isIterable as kt, stringTrim as l, isUndefined as lt, stringToJson as m, isString as mt, rowsToTree as n, arrayDifference as nt, treeFilter as o, isWindow as ot, stringToLowerCase as p, isRegExp as pt, arraySplit as q, isArray as qt, treeMap as r, arrayCounting as rt, getTimeZone as s, isWebSocket as st, treeToRows as t, arrayFirst as tt, stringToValues as u, isSymbol as ut, objectValues as v, isObject as vt, objectAssign as w, isNumber as wt, objectKeys as x, isInteger as xt, objectPick as y, isInfinity as yt, isTablet as z, isAsyncFunction as zt };
+//# sourceMappingURL=utils-_dtCs-qa.js.map

package/dist/utils-_dtCs-qa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-_dtCs-qa.js","names":["originalKeys: string[]","numericKeys: string[]","valueType: \"string\" | \"number\" | null","values: (string | number)[]","forked: [T[], T[]]","parsedError: Record<LiteralUnion<\"message\" | \"name\" | \"stack\", string>, unknown>","R1","R1","match: RegExpExecArray | null","preImpl","newChildren: T[] | undefined","postImpl","breadthImpl","queue: QueueItem<T, CK>[]","result: T","strategies","strategies","preImpl","postImpl","breadthImpl","queue: QueueItem<T, CK>[]","strategies","preImpl","postImpl","breadthImpl","queue: QueueItem<T, CK>[]","newChildren: TreeLike<R, CK>[] | undefined","queue: QueueItem<T, CK>[]","result: TreeLike<R, CK>","result: R[]","result: R[]"],"sources":["../src/utils/typeof/types.ts","../src/utils/typeof/isAbortSignal.ts","../src/utils/typeof/isArray.ts","../src/utils/typeof/isBigInt.ts","../src/utils/typeof/isBlob.ts","../src/utils/typeof/isBoolean.ts","../src/utils/typeof/isFunction.ts","../src/utils/typeof/isClass.ts","../src/utils/typeof/isDate.ts","../src/utils/typeof/isEnumeration.ts","../src/utils/typeof/isEqual.ts","../src/utils/typeof/isError.ts","../src/utils/typeof/isFalsy.ts","../src/utils/typeof/isIframe.ts","../src/utils/typeof/isIterable.ts","../src/utils/typeof/isMap.ts","../src/utils/typeof/isNull.ts","../src/utils/typeof/isNumber.ts","../src/utils/typeof/isObject.ts","../src/utils/typeof/isPromise.ts","../src/utils/typeof/isReadableStream.ts","../src/utils/typeof/isString.ts","../src/utils/typeof/isRegExp.ts","../src/utils/typeof/isSet.ts","../src/utils/typeof/isSymbol.ts","../src/utils/typeof/isUndefined.ts","../src/utils/typeof/isURLSearchParams.ts","../src/utils/typeof/isWebSocket.ts","../src/utils/typeof/isWindow.ts","../src/utils/array/arrayCast.ts","../src/utils/array/arrayCompete.ts","../src/utils/array/arrayCounting.ts","../src/utils/array/arrayDifference.ts","../src/utils/array/arrayFirst.ts","../src/utils/array/arrayFork.ts","../src/utils/array/arrayIntersection.ts","../src/utils/array/arrayLast.ts","../src/utils/array/arrayMerge.ts","../src/utils/array/arrayPick.ts","../src/utils/array/arrayReplace.ts","../src/utils/array/arrayReplaceMove.ts","../src/utils/array/arraySplit.ts","../src/utils/array/arrayZip.ts","../src/utils/array/arrayZipToObject.ts","../src/utils/device/isBrowser.ts","../src/utils/device/isMobile.ts","../src/utils/device/isTablet.ts","../src/utils/function/to.ts","../src/utils/string/stringToNumber.ts","../src/utils/math/mathToBignumber.ts","../src/utils/math/mathToDecimal.ts","../src/utils/math/mathToEvaluate.ts","../src/utils/number/numberWithin.ts","../src/utils/object/enumEntries.ts","../src/utils/object/enumKeys.ts","../src/utils/object/enumValues.ts","../src/utils/object/objectEntries.ts","../src/utils/object/objectMapEntries.ts","../src/utils/object/objectAssign.ts","../src/utils/object/objectCrush.ts","../src/utils/object/objectInvert.ts","../src/utils/object/objectKeys.ts","../src/utils/object/objectOmit.ts","../src/utils/object/objectPick.ts","../src/utils/object/objectValues.ts","../src/utils/string/stringInitialCase.ts","../src/utils/string/stringReplace.ts","../src/utils/string/stringTemplate.ts","../src/utils/string/stringToJson.ts","../src/utils/string/stringToLowerCase.ts","../src/utils/string/stringToPosix.ts","../src/utils/string/stringToUpperCase.ts","../src/utils/string/stringToValues.ts","../src/utils/string/stringTrim.ts","../src/utils/string/stringTruncate.ts","../src/utils/time/timeZone.ts","../src/utils/tree/types.ts","../src/utils/tree/treeFilter.ts","../src/utils/tree/treeFind.ts","../src/utils/tree/treeForEach.ts","../src/utils/tree/treeMap.ts","../src/utils/tree/rowsToTree.ts","../src/utils/tree/treeToRows.ts"],"sourcesContent":["export const PROTOTYPE_TAGS = Object.freeze({\n  abortSignal: \"[object AbortSignal]\",\n  array: \"[object Array]\",\n  asyncFunction: \"[object AsyncFunction]\",\n  asyncGeneratorFunction: \"[object AsyncGeneratorFunction]\",\n  bigInt: \"[object BigInt]\",\n  blob: \"[object Blob]\",\n  boolean: \"[object Boolean]\",\n  date: \"[object Date]\",\n  error: \"[object Error]\",\n  file: \"[object File]\",\n  function: \"[object Function]\",\n  generatorFunction: \"[object GeneratorFunction]\",\n  global: \"[object global]\",\n  iframe: \"[object HTMLIFrameElement]\",\n  map: \"[object Map]\",\n  null: \"[object Null]\",\n  number: \"[object Number]\",\n  object: \"[object Object]\",\n  promise: \"[object Promise]\",\n  readableStream: \"[object ReadableStream]\",\n  regExp: \"[object RegExp]\",\n  set: \"[object Set]\",\n  string: \"[object String]\",\n  symbol: \"[object Symbol]\",\n  undefined: \"[object Undefined]\",\n  URLSearchParams: \"[object URLSearchParams]\",\n  weakMap: \"[object WeakMap]\",\n  weakSet: \"[object WeakSet]\",\n  webSocket: \"[object WebSocket]\",\n  window: \"[object Window]\",\n} as const);\n\nexport const TYPED_ARRAY_TAGS = new Set([\n  \"[object Int8Array]\",\n  \"[object Uint8Array]\",\n  \"[object Uint8ClampedArray]\",\n  \"[object Int16Array]\",\n  \"[object Uint16Array]\",\n  \"[object Int32Array]\",\n  \"[object Uint32Array]\",\n  \"[object Float32Array]\",\n  \"[object Float64Array]\",\n  \"[object BigInt64Array]\",\n  \"[object BigUint64Array]\",\n]);\n\nexport function resolvePrototypeString (value: unknown) {\n  return Object.prototype.toString.call(value);\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 AbortSignal\n * @param value 待检查值\n * @returns 是否为 AbortSignal\n */\nexport function isAbortSignal (value: unknown): value is AbortSignal {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.abortSignal;\n}\n","import { TYPED_ARRAY_TAGS, resolvePrototypeString } from \"./types\";\n\ntype TypedArray = | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;\n\n/**\n * 检查 value 是否为数组\n *\n * @param value 待检查值\n * @returns 是否为数组\n * @example\n * ```ts\n * isArray([]); // true\n * ```\n */\nexport function isArray (value: unknown): value is unknown[] {\n  return Array.isArray(value);\n}\n\n/**\n * 检查 value 是否为 TypedArray\n *\n * @param value 待检查值\n * @returns 是否为 TypedArray\n * @example\n * ```ts\n * isTypedArray(new Int8Array()); // true\n * ```\n */\nexport function isTypedArray (value: unknown): value is TypedArray {\n  return typeof value === \"object\" && value !== null && TYPED_ARRAY_TAGS.has(resolvePrototypeString(value));\n}\n","/**\n * 检查 value 是否为 BigInt\n * @param value 待检查值\n * @returns 是否为 BigInt\n */\nexport function isBigInt (value: unknown): value is bigint {\n  return typeof value === \"bigint\";\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Blob\n * @param value 待检查值\n * @returns 是否为 Blob\n */\nexport function isBlob (value: unknown): value is Blob {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.blob;\n}\n\nexport function isFile (value: unknown): value is File {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.file;\n}\n","/**\n * 检查 value 是否为 Boolean\n * @param value 待检查值\n * @returns 是否为 Boolean\n */\nexport function isBoolean (value: unknown): value is boolean {\n  return typeof value === \"boolean\";\n}\n","import type { AnyAsyncFunction, AnyAsyncGeneratorFunction, AnyFunction, AnyGeneratorFunction } from \"@pawover/types\";\nimport { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Function\n * @param value 待检查值\n * @returns 是否为 Function\n */\nexport function isFunction (value: unknown): value is AnyFunction {\n  return typeof value === \"function\";\n}\n\n/**\n * 检查 value 是否为 AsyncFunction\n * @param value 待检查值\n * @returns 是否为 AsyncFunction\n */\nexport function isAsyncFunction (value: unknown): value is AnyAsyncFunction {\n  return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.asyncFunction;\n}\n\n/**\n * 检查 value 是否为 GeneratorFunction\n * @param value 待检查值\n * @returns 是否为 GeneratorFunction\n */\nexport function isGeneratorFunction (value: unknown): value is AnyGeneratorFunction {\n  return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.generatorFunction;\n}\n\n/**\n * 检查 value 是否为 AsyncGeneratorFunction\n * @param value 待检查值\n * @returns 是否为 AsyncGeneratorFunction\n */\nexport function isAsyncGeneratorFunction (value: unknown): value is AnyAsyncGeneratorFunction {\n  return isFunction(value) && resolvePrototypeString(value) === PROTOTYPE_TAGS.asyncGeneratorFunction;\n}\n","import type { AnyFunction, AnyObject } from \"@pawover/types\";\nimport type { Class } from \"type-fest\";\nimport { isAsyncFunction, isFunction } from \"./isFunction\";\n\nfunction isConstructable (fn: unknown): boolean {\n  try {\n    // 尝试用 new 调用（但不执行 constructor）\n    Reflect.construct(fn as AnyFunction, []);\n\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * 检查 value 是否为 Class\n *\n * @param value 待检查值\n * @returns 是否为 Class\n * @example\n * ```ts\n * class A {}\n * isClass(A); // true\n * isClass(() => {}); // false\n * ```\n */\nexport function isClass (value: unknown): value is Class<AnyObject> {\n  return (\n    isFunction(value)\n    && !isAsyncFunction(value)\n    && Function.prototype.toString.call(value).startsWith(\"class \")\n    && isConstructable(value)\n    && value.prototype !== undefined\n  );\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Date 对象\n *\n * @param value 待检查值\n * @param invalidCheck 是否要求日期有效（非 Invalid Date）。默认 true\n *   - true: 仅当是有效 Date 对象时返回 true（排除 new Date('invalid')）\n *   - false: 只要 [[Prototype]] 是 Date 即返回 true（包含 Invalid Date）\n * @returns 是否为 Date 对象，根据 invalidCheck 返回不同语义的 Date 判定\n *\n * @example\n * ```ts\n * isDate(new Date()); // true\n * isDate(new Date('invalid')); // false\n * isDate(new Date('invalid'), false); // true\n * isDate(null); // false\n * isDate({}); // false\n * ```\n */\nexport function isDate (value: unknown, invalidCheck = true): value is Date {\n  if (!value || typeof value !== \"object\") {\n    return false;\n  }\n\n  if (resolvePrototypeString(value) !== PROTOTYPE_TAGS.date) {\n    return false;\n  }\n\n  if (!invalidCheck) {\n    return true;\n  }\n\n  // 验证是否为有效日期（排除 Invalid Date）\n  try {\n    const time = (value as Date).getTime();\n\n    return typeof time === \"number\" && !Number.isNaN(time);\n  } catch {\n    return false;\n  }\n}\n","import type { PlainObject } from \"@pawover/types\";\n\n/**\n * 判断一个对象是否为有效的枚举\n * - 枚举成员不能为空\n * - 枚举成员的键不能具有数值名\n * - 枚举成员的值必须类型一致且为 `string` 或 `number` 类型\n * - 枚举成员的值不能重复\n * - 枚举成员的值必须全部为双向映射或非双向映射\n *\n * @param enumeration 待检查值\n * @returns [是否为有效的枚举, 是否为双向枚举]\n */\nexport function isEnumeration (enumeration: PlainObject): [boolean, boolean] {\n  if (typeof enumeration !== \"object\" || enumeration === null) {\n    return [false, false];\n  }\n\n  const keys = Object.keys(enumeration);\n\n  // 枚举成员不能为空\n  if (keys.length === 0) {\n    return [false, false];\n  }\n\n  const originalKeys: string[] = [];\n  const numericKeys: string[] = [];\n\n  // 区分 \"原始枚举键\" 和 \"反向映射产生的数值键\"\n  for (const key of keys) {\n    // 正则 /^\\d+$/ 匹配纯数字字符串，如 \"0\", \"1\", \"123\"\n    // 注意：这只会匹配键名，不会匹配值\n    if (/^\\d+$/.test(key)) {\n      numericKeys.push(key);\n    } else {\n      originalKeys.push(key);\n    }\n  }\n\n  // 必须有原始的枚举成员（即键名不能全是数字）\n  if (originalKeys.length === 0) {\n    return [false, false];\n  }\n\n  // 5. 检查原始枚举成员的值\n  let valueType: \"string\" | \"number\" | null = null;\n  const values: (string | number)[] = [];\n\n  for (const key of originalKeys) {\n    const value = enumeration[key];\n    const type = typeof value;\n\n    // 值必须是 string 或 number\n    if (type !== \"string\" && type !== \"number\") {\n      return [false, false];\n    }\n\n    // 检查类型一致性\n    if (valueType === null) {\n      valueType = type;\n    } else if (type !== valueType) {\n      return [false, false];\n    }\n\n    values.push(value as string | number);\n  }\n\n  // 检查值是否重复\n  if (new Set(values).size !== values.length) {\n    return [false, false];\n  }\n\n  // 判断是否为双向枚举\n  let isBidirectional = false;\n\n  // 如果 numericKeys.length === 0 说明没有反向映射键\n  if (numericKeys.length > 0) {\n    // 如果存在数值键，说明可能是 TS 数字枚举编译后的结果\n    // 此时必须满足严格的双向映射规则：\n\n    // 数值键数量必须等于原始键数量\n    if (numericKeys.length !== originalKeys.length) {\n      return [false, false];\n    }\n\n    const reverseMappedNames = new Set<string>();\n\n    for (const numKey of numericKeys) {\n      const reverseValue = enumeration[numKey];\n\n      // 反向映射的值必须是字符串（即原始键名）\n      if (typeof reverseValue !== \"string\") {\n        return [false, false];\n      }\n\n      // 反向映射的值必须是已知的原始键名之一\n      if (!originalKeys.includes(reverseValue)) {\n        return [false, false];\n      }\n\n      reverseMappedNames.add(reverseValue);\n    }\n\n    // 所有原始键名都必须和反向映射对应\n    if (reverseMappedNames.size !== originalKeys.length) {\n      return [false, false];\n    }\n\n    isBidirectional = true;\n  }\n\n  return [true, isBidirectional];\n}\n","import { isDate, isRegExp } from \".\";\n\n/**\n * 深度比较两个值是否相等\n *\n * @param value 待比较值 A\n * @param other 待比较值 B\n * @returns 是否相等\n * @example\n * ```ts\n * isEqual({ a: 1 }, { a: 1 }); // true\n * ```\n */\nexport function isEqual (x: unknown, y: unknown): boolean {\n  // 使用 WeakMap 记录已比较过的对象对，以防止循环引用导致的无限递归\n  const seen = new WeakMap<object, Set<object>>();\n\n  function _isEqual (a: unknown, b: unknown): boolean {\n    if (Object.is(a, b)) {\n      return true;\n    }\n    if (isDate(a) && isDate(b)) {\n      return a.getTime() === b.getTime();\n    }\n    if (isRegExp(a) && isRegExp(b)) {\n      return a.toString() === b.toString();\n    }\n    // 如果任一值不是对象或为 null，则它们不相等\n    if (typeof a !== \"object\" || a === null || typeof b !== \"object\" || b === null) {\n      return false;\n    }\n\n    // 检查是否已访问过这对对象，防止循环引用\n    if (seen.has(a)) {\n      const matchedPairs = seen.get(a)!;\n      if (matchedPairs.has(b)) {\n        return true; // 如果之前已经确定这对对象相等，则直接返回 true\n      }\n    } else {\n      seen.set(a, new Set());\n    }\n    // 将当前对象对添加到已访问集合中\n    seen.get(a)!.add(b);\n\n    const keysA = Reflect.ownKeys(a) as (keyof typeof a)[];\n    const keysB = Reflect.ownKeys(b);\n    if (keysA.length !== keysB.length) {\n      return false;\n    }\n\n    for (const key of keysA) {\n      if (!Reflect.has(b, key)) {\n        return false;\n      }\n      if (!_isEqual(a[key], b[key])) {\n        // 递归调用内部函数\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return _isEqual(x, y);\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Error 对象\n * @param value 待检查值\n * @returns 是否为 Error\n */\nexport function isError (value: unknown): value is Error {\n  return value instanceof Error || resolvePrototypeString(value) === PROTOTYPE_TAGS.error;\n}\n","import { isNaN, isNull, isUndefined } from \".\";\n\n/**\n * 检查 value 是否为 Falsy 值 (false, 0, \"\", null, undefined, NaN)\n * @param value 待检查值\n * @returns 是否为 Falsy\n */\nexport function isFalsy (value: unknown): value is false | 0 | \"\" | null | undefined {\n  if (isNaN(value) || isNull(value) || isUndefined(value)) {\n    return true;\n  }\n\n  return value === false || value === 0 || value === 0n || value === \"\";\n}\n\nexport function isFalsyLike (value: unknown): boolean {\n  if (isFalsy(value)) {\n    return true;\n  }\n\n  return typeof value === \"string\" && (value === \"null\" || value === \"undefined\" || value === \"NaN\" || value === \"false\" || value === \"0\" || value === \"-0\" || value === \"0n\");\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 HTMLIFrameElement\n * @param value 待检查值\n * @returns 是否为 HTMLIFrameElement\n */\nexport function isIframe (value: unknown): value is HTMLIFrameElement {\n  if (typeof window === \"undefined\") {\n    return false;\n  }\n\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.iframe;\n}\n\nexport function isInIframe () {\n  if (typeof window === \"undefined\") {\n    return false;\n  }\n\n  try {\n    return window.top !== window.self;\n  } catch (error) {\n    // 仅当 SecurityError（跨域 iframe）时返回 true\n    if ((error as Error).name === \"SecurityError\") {\n      return true;\n    }\n\n    return false;\n  }\n}\n","import type { AnyObject } from \"@pawover/types\";\n\n/**\n * 检查 value 是否为可迭代对象 (Iterable)\n * @param value 待检查值\n * @returns 是否为 Iterable\n */\nexport function isIterable (value: unknown): value is { [Symbol.iterator]: () => Iterator<unknown> } {\n  return !!value && typeof (value as AnyObject)[Symbol.iterator] === \"function\";\n}\n","import type { AnyObject } from \"@pawover/types\";\nimport { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Map\n * @param value 待检查值\n * @returns 是否为 Map\n */\nexport function isMap (value: unknown): value is Map<unknown, unknown> {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.map;\n}\n\n/**\n * 检查 value 是否为 WeakMap\n * @param value 待检查值\n * @returns 是否为 WeakMap\n */\nexport function isWeakMap (value: unknown): value is WeakMap<AnyObject, unknown> {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.weakMap;\n}\n","/**\n * 检查 value 是否为 null\n * @param value 待检查值\n * @returns 是否为 null\n */\nexport function isNull (value: unknown): value is null {\n  return value === null;\n}\n","/**\n * 检查 value 是否为 number 类型\n *\n * @param value 待检查值\n * @param NaNCheck 是否排除 `NaN`，默认为 `true`\n * @returns 是否为 number\n * @example\n * ```ts\n * isNumber(1); // true\n * isNumber(NaN); // false (default)\n * isNumber(NaN, false); // true\n * ```\n */\nexport function isNumber (value: unknown, NaNCheck = true): value is number {\n  return typeof value === \"number\" && (!NaNCheck || !isNaN(value));\n}\n\n/**\n * 检查 value 是否为 NaN\n *\n * @param value 待检查值\n * @returns 是否为 NaN\n */\nexport function isNaN (value: unknown): value is number {\n  return Number.isNaN(value);\n}\n\n/**\n * 检查 value 是否为整数\n *\n * @param value 待检查值\n * @param safeCheck 是否附加安全整数检查\n * @returns 是否为整数\n */\nexport function isInteger (value: unknown, safeCheck = true): value is number {\n  const check = Number.isInteger(value);\n\n  return safeCheck ? check && Number.isSafeInteger(value) : check;\n}\n\n/**\n * 检查 value 是否为正整数\n * - 此函数中 `0` 不被视为正整数\n *\n * @param value 待检查值\n * @param safeCheck 是否附加安全整数检查\n */\nexport function isPositiveInteger (value: unknown, safeCheck = true): value is number {\n  return isInteger(value, safeCheck) && value > 0;\n}\n\n/**\n * 检查 value 是否为负整数\n * - 此函数中 `0` 不被视为负整数\n *\n * @param value 待检查值\n * @param safeCheck 是否附加安全整数检查\n */\nexport function isNegativeInteger (value: unknown, safeCheck = true): value is number {\n  return isInteger(value, safeCheck) && value < 0;\n}\n\n/**\n * 检查 value 是否为 Infinity\n * - 排除 `NaN`\n *\n * @param value 待检查值\n */\nexport function isInfinity (value: unknown): value is number {\n  return isNumber(value) && (Number.POSITIVE_INFINITY === value || Number.NEGATIVE_INFINITY === value);\n}\n\n/**\n * 检查 value 是否类似 Infinity\n * - 排除 `NaN`\n *\n * @param value 待检查值\n */\nexport function isInfinityLike (value: unknown): boolean {\n  const check = isInfinity(value);\n\n  if (check) {\n    return check;\n  }\n\n  if (typeof value === \"string\") {\n    const v = value.trim().toLowerCase();\n\n    return v === \"infinity\" || v === \"-infinity\" || v === \"+infinity\";\n  }\n\n  return false;\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 判断是否为普通对象类型\n * - 可选是否检查原型为 `Object.prototype`，防止原型链污染\n *\n * @param value 待检查值\n * @param prototypeCheck 是否进行原型检查，默认 `true`\n * @returns 是否为 Plain Object (当 checkPrototype=true) 或 object\n * @example\n * ```ts\n * isObject({}); // true\n * isObject([]); // false\n * isObject(new Date()); // false (because prototype is not Object.prototype)\n * isObject(new Date(), false); // true (is object type)\n * isObject(Object.create(null)) // false\n * isObject(Object.create(null), false) // true\n * ```\n */\nexport function isObject (value: unknown, prototypeCheck = true): value is Record<PropertyKey, unknown> {\n  const check = resolvePrototypeString(value) === PROTOTYPE_TAGS.object;\n\n  return prototypeCheck ? check && Object.getPrototypeOf(value) === Object.prototype : check;\n}\n","import { isFunction } from \"./isFunction\";\nimport { isObject } from \"./isObject\";\nimport { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Promise\n * @param value 待检查值\n * @returns 是否为 Promise\n */\nexport function isPromise (value: unknown): value is Promise<unknown> {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.promise;\n}\n\n/**\n * 检查 value 是否为 PromiseLike (thenable)\n * @param value 待检查值\n * @returns 是否为 PromiseLike\n */\nexport function isPromiseLike (value: unknown): value is PromiseLike<unknown> {\n  return isPromise(value) || (isObject(value) && isFunction(value[\"then\"]));\n}\n","import { isFunction } from \"./isFunction\";\nimport { isObject } from \"./isObject\";\nimport { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 ReadableStream\n * - Uses `Object.prototype.toString` where supported (modern browsers, Node.js ≥18).\n * - Falls back to duck-typing in older environments.\n * - Resistant to basic forgery, but not 100% secure in all polyfill scenarios.\n * - ⚠️ Note: In older Node.js (<18) or with non-compliant polyfills, this may return false positives or negatives.\n *\n * @param value 待检查值\n * @returns 是否为 ReadableStream\n */\nexport function isReadableStream (value: unknown): value is ReadableStream {\n  if (resolvePrototypeString(value) === PROTOTYPE_TAGS.readableStream) {\n    return true;\n  }\n\n  return isObject(value) && isFunction(value[\"getReader\"]) && isFunction(value[\"pipeThrough\"]);\n}\n","/**\n * 检查 value 是否为 string 类型\n *\n * @param value 待检查值\n * @param checkEmpty 是否检查空字符串\n * @returns 是否为字符串\n * @example\n * ```ts\n * isString(\"abc\"); // true\n * isString(\"\"); // true\n * isString(\"\", true); // false\n * ```\n */\nexport function isString (value: unknown, checkEmpty = false): value is string {\n  return typeof value === \"string\" && (!checkEmpty || !!value.length);\n}\n","import { isBoolean } from \"./isBoolean\";\nimport { isFunction } from \"./isFunction\";\nimport { isString } from \"./isString\";\nimport { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 RegExp\n * @param value 待检查值\n * @returns 是否为 RegExp\n */\nexport function isRegExp (value: unknown): value is RegExp {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n\n  try {\n    const regex = value as unknown as RegExp;\n\n    return (\n      resolvePrototypeString(value) === PROTOTYPE_TAGS.regExp\n      && isString(regex.source)\n      && isString(regex.flags)\n      && isBoolean(regex.global)\n      && isFunction(regex.test)\n    );\n  } catch (error) {\n    return false;\n  }\n}\n","import type { AnyObject } from \"@pawover/types\";\nimport { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Set\n * @param value 待检查值\n * @returns 是否为 Set\n */\nexport function isSet (value: unknown): value is Set<unknown> {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.set;\n}\n\n/**\n * 检查 value 是否为 WeakSet\n * @param value 待检查值\n * @returns 是否为 WeakSet\n */\nexport function isWeakSet (value: unknown): value is WeakSet<AnyObject> {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.weakSet;\n}\n","/**\n * 检查 value 是否为 Symbol\n * @param value 待检查值\n * @returns 是否为 Symbol\n */\nexport function isSymbol (value: unknown): value is symbol {\n  return typeof value === \"symbol\";\n}\n","/**\n * 检查 value 是否为 undefined\n * @param value 待检查值\n * @returns 是否为 undefined\n */\nexport function isUndefined (value: unknown): value is undefined {\n  return typeof value === \"undefined\";\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 URLSearchParams\n * @param value 待检查值\n * @returns 是否为 URLSearchParams\n */\nexport function isURLSearchParams (value: unknown): value is URLSearchParams {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.URLSearchParams;\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 WebSocket\n * @param value 待检查值\n * @returns 是否为 WebSocket\n */\nexport function isWebSocket (value: unknown): value is WebSocket {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.webSocket;\n}\n","import { PROTOTYPE_TAGS, resolvePrototypeString } from \"./types\";\n\n/**\n * 检查 value 是否为 Window\n * @param value 待检查值\n * @returns 是否为 Window\n */\nexport function isWindow (value: unknown): value is Window {\n  return resolvePrototypeString(value) === PROTOTYPE_TAGS.window;\n}\n","import { isArray, isNull, isUndefined } from \"../typeof\";\n\n/**\n * 构造数组\n * @param candidate 待构造项\n * @param checkEmpty 是否检查 `undefined` 和 `null`，默认为 `true`\n * @returns 构造后的数组\n * @example\n * ```ts\n * arrayCast(1); // [1]\n * arrayCast([1, 2]); // [1, 2]\n * arrayCast(null); // []\n * arrayCast(undefined); // []\n * arrayCast(null, false); // [null]\n * ```\n */\nexport function arrayCast<T> (candidate: T | T[] | null | undefined, checkEmpty?: true): NonNullable<T>[];\nexport function arrayCast<T> (candidate: T | T[] | null | undefined, checkEmpty?: false): T[];\nexport function arrayCast<T> (candidate: T | T[] | null | undefined, checkEmpty = true): T[] {\n  if (checkEmpty && (isUndefined(candidate) || isNull(candidate))) {\n    return [];\n  }\n\n  return isArray(candidate) ? [...candidate] : [candidate as T];\n}\n","import { isArray, isFunction } from \"../typeof\";\n\n/**\n * 数组竞争\n * - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算\n *\n * @param initialList 数组\n * @param match 匹配函数\n * @returns 获胜的元素，如果数组为空或参数无效则返回 `null`\n * @example\n * ```ts\n * const list = [1, 10, 5];\n * arrayCompete(list, (a, b) => (a > b ? a : b)); // 10\n * arrayCompete(list, (a, b) => (a < b ? a : b)); // 1\n * ```\n */\nexport function arrayCompete<T> (initialList: readonly T[], match: (a: T, b: T, index: number) => T): T | null {\n  if (!isArray(initialList) || initialList.length === 0 || !isFunction(match)) {\n    return null;\n  }\n\n  return initialList.reduce(match);\n}\n","import type { MatchFunction } from \"../../types/index.type\";\nimport { isArray, isFunction } from \"../typeof\";\n\n/**\n * 统计数组的项目出现次数\n * - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数\n *\n * @param initialList 初始数组\n * @param match 匹配函数\n * @returns 统计对象\n * @example\n * ```ts\n * const list = [\"a\", \"b\", \"a\", \"c\"];\n * arrayCounting(list, (x) => x); // { a: 2, b: 1, c: 1 }\n *\n * const users = [{ id: 1, group: \"A\" }, { id: 2, group: \"B\" }, { id: 3, group: \"A\" }];\n * arrayCounting(users, (u) => u.group); // { A: 2, B: 1 }\n * ```\n */\nexport function arrayCounting<T, K extends PropertyKey> (initialList: readonly T[], match: MatchFunction<T, K>): Record<string, number> {\n  if (!isArray(initialList) || !isFunction(match)) {\n    return {};\n  }\n\n  return initialList.reduce<Record<string, number>>((prev, curr, index) => {\n    const id = match(curr, index).toString();\n    prev[id] = (prev[id] ?? 0) + 1;\n\n    return prev;\n  }, {});\n}\n","import { isArray, isFunction } from \"../typeof\";\n\n/**\n * 求数组差集\n * - 返回在 `initialList` 中存在，但在 `diffList` 中不存在的元素\n *\n * @param initialList 初始数组\n * @param diffList 对比数组\n * @param match 匹配函数\n * @returns 差集数组\n * @example\n * ```ts\n * arrayDifference([1, 2, 3], [2, 3, 4]); // [1]\n * arrayDifference([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 1 }]\n * ```\n */\nexport function arrayDifference<T> (initialList: readonly T[], diffList: readonly T[], match?: (row: T, index: number) => unknown): T[] {\n  if (!isArray(initialList) && !isArray(diffList)) {\n    return [];\n  }\n  if (!isArray(initialList) || !initialList.length) {\n    return [];\n  }\n  if (!isArray(diffList) || !diffList.length) {\n    return [...initialList];\n  }\n  if (!isFunction(match)) {\n    const arraySet = new Set(diffList);\n\n    return Array.from(new Set(initialList.filter((item) => !arraySet.has(item))));\n  }\n\n  const map = new Map<unknown, boolean>();\n\n  diffList.forEach((item, index) => {\n    map.set(match(item, index), true);\n  });\n\n  return initialList.filter((item, index) => !map.get(match(item, index)));\n}\n","import { isArray } from \"../typeof\";\n\n/**\n * 获取数组第一项\n *\n * @param initialList 初始数组\n * @param saveValue 安全值\n * @returns 数组第一项，如果为空则返回安全值\n * @example\n * ```ts\n * arrayFirst([1, 2]); // 1\n * arrayFirst([], 0); // 0\n * ```\n */\nexport function arrayFirst<T> (initialList: readonly T[]): T | undefined;\nexport function arrayFirst<T> (initialList: readonly T[], saveValue: T): T;\nexport function arrayFirst<T> (initialList: readonly T[], saveValue?: T): T | undefined {\n  if (!isArray(initialList) || initialList.length === 0) {\n    return saveValue;\n  }\n\n  return initialList[0];\n}\n","import type { MatchFunction } from \"../../types/index.type\";\nimport { isArray } from \"../typeof\";\n\n/**\n * 数组分组过滤\n * - 给定一个数组和一个条件，返回一个由两个数组组成的元组，其中第一个数组包含所有满足条件的项，第二个数组包含所有不满足条件的项\n *\n * @param initialList 初始数组\n * @param match 条件匹配函数\n * @returns [满足条件的项[], 不满足条件的项[]]\n * @example\n * ```ts\n * arrayFork([1, 2, 3, 4], (n) => n % 2 === 0); // [[2, 4], [1, 3]]\n * ```\n */\nexport function arrayFork<T> (initialList: readonly T[], match: MatchFunction<T, boolean>): [T[], T[]] {\n  const forked: [T[], T[]] = [[], []];\n\n  if (isArray(initialList)) {\n    initialList.forEach((item, index) => {\n      forked[match(item, index) ? 0 : 1].push(item);\n    });\n  }\n\n  return forked;\n}\n","import type { MatchFunction } from \"../../types/index.type\";\nimport { isArray, isFunction } from \"../typeof\";\n\n/**\n * 求数组交集\n * - 返回在 `initialList` 和 `diffList` 中都存在的元素\n *\n * @param initialList 初始数组\n * @param diffList 对比数组\n * @param match 匹配函数\n * @returns 交集数组\n * @example\n * ```ts\n * arrayIntersection([1, 2], [2, 3]); // [2]\n * arrayIntersection([{ id: 1 }, { id: 2 }], [{ id: 2 }], (x) => x.id); // [{ id: 2 }]\n * ```\n */\nexport function arrayIntersection<T> (initialList: readonly T[], diffList: readonly T[]): T[];\nexport function arrayIntersection<T, D = T> (initialList: readonly T[], diffList: readonly D[], match: MatchFunction<T>): T[];\nexport function arrayIntersection<T> (initialList: readonly T[], diffList: readonly T[], match?: MatchFunction<T>): T[] {\n  if (!isArray(initialList) || !isArray(diffList)) {\n    return [];\n  }\n  if (!initialList.length || !diffList.length) {\n    return [];\n  }\n\n  if (!isFunction(match)) {\n    const diffSet = new Set(diffList);\n\n    return initialList.filter((item) => diffSet.has(item));\n  }\n\n  const diffKeys = new Set(diffList.map((item, index) => match(item, index)));\n\n  return initialList.filter((item, index) => diffKeys.has(match(item, index)));\n}\n","import { isArray } from \"../typeof\";\n\n/**\n * 获取数组最后一项\n *\n * @param initialList 初始数组\n * @param saveValue 安全值\n * @returns 数组最后一项，如果为空则返回安全值\n * @example\n * ```ts\n * arrayLast([1, 2, 3]); // 3\n * arrayLast([], 0); // 0\n * ```\n */\nexport function arrayLast<T> (initialList: readonly T[]): T | undefined;\nexport function arrayLast<T> (initialList: readonly T[], saveValue: T): T;\nexport function arrayLast<T> (initialList: readonly T[], saveValue?: T): T | undefined {\n  if (!isArray(initialList) || initialList.length === 0) {\n    return saveValue;\n  }\n\n  return initialList[initialList.length - 1];\n}\n","import type { MatchFunction } from \"../../types/index.type\";\nimport { isArray, isFunction } from \"../typeof\";\n\n/**\n * 数组合并\n * - 如果未提供 `match` 函数，则合并两个数组并去重（Union）\n * - 如果提供了 `match` 函数，则仅更新 `initialList` 中匹配到的项（Left Join Update），不会追加 `mergeList` 中新增的项\n *\n * @param initialList 初始数组\n * @param mergeList 待合并数组\n * @param match 匹配函数\n * @returns 合并后的数组\n * @example\n * ```ts\n * // 基础合并去重\n * arrayMerge([1, 2], [2, 3]); // [1, 2, 3]\n * arrayMerge([], [1, 2, 3]); // [1, 2, 3]\n *\n * // 按条件更新\n * const source = [{ id: 1, val: \"a\" }, { id: 2, val: \"b\" }];\n * const update = [{ id: 2, val: \"new\" }, { id: 3, val: \"c\" }];\n * arrayMerge(source, update, (x) => x.id);\n * // [{ id: 1, val: \"a\" }, { id: 2, val: \"new\" }] -> id:3 被忽略\n * ```\n */\nexport function arrayMerge<T> (initialList: readonly T[], mergeList: readonly T[]): T[];\nexport function arrayMerge<T, D = T> (initialList: readonly T[], mergeList: readonly D[], match: MatchFunction<T>): T[];\nexport function arrayMerge<T> (initialList: readonly T[], mergeList: readonly T[], match?: MatchFunction<T>): T[] {\n  if (!isArray(initialList)) {\n    return [];\n  }\n  if (!isArray(mergeList)) {\n    return [...initialList];\n  }\n  if (!isFunction(match)) {\n    return Array.from(new Set([...initialList, ...mergeList]));\n  }\n\n  const keys = new Map();\n  mergeList.forEach((item, index) => {\n    keys.set(match(item, index), item);\n  });\n\n  return initialList.map((prevItem, index) => {\n    const key = match(prevItem, index);\n\n    return keys.has(key) ? keys.get(key)! : prevItem;\n  });\n}\n","import { isArray, isFunction } from \"../typeof\";\n\n/**\n * 数组选择\n * - 一次性应用 `filter` 和 `map` 操作\n *\n * @param initialList 初始数组\n * @param filter filter 函数\n * @param mapper map 函数\n * @returns 处理后的新数组\n * @example\n * ```ts\n * const list = [1, 2, 3, 4];\n * arrayPick(list, (n) => n % 2 === 0); // [2, 4]\n * arrayPick(list, (n) => n % 2 === 0, (n) => n * 2); // [4, 8]\n * ```\n */\nexport function arrayPick<const T> (initialList: readonly T[], filter: (row: T, index: number) => boolean): T[];\nexport function arrayPick<const T, K = T> (initialList: readonly T[], filter: (row: T, index: number) => boolean, mapper: ((row: T, index: number) => K)): K[];\nexport function arrayPick<const T, K = T> (initialList: readonly T[], filter: (row: T, index: number) => boolean, mapper?: ((row: T, index: number) => K) | undefined) {\n  if (!isArray(initialList)) {\n    return [];\n  }\n  if (!isFunction(filter)) {\n    return [...initialList];\n  }\n\n  const hasMapper = isFunction(mapper);\n\n  return initialList.reduce<K[]>((prev, curr, index) => {\n    if (!filter(curr, index)) {\n      return prev;\n    }\n    if (hasMapper) {\n      prev.push(mapper(curr, index));\n    } else {\n      prev.push(curr as unknown as K);\n    }\n\n    return prev;\n  }, []);\n}\n","import type { MatchFunction } from \"../../types/index.type\";\nimport { isArray, isFunction } from \"../typeof\";\n\n/**\n * 数组项替换\n * - 在给定的数组中，替换符合匹配函数结果的项目\n * - 只替换第一个匹配项\n *\n * @param initialList 初始数组\n * @param newItem 替换项\n * @param match 匹配函数\n * @returns 替换后的新数组\n * @example\n * ```ts\n * arrayReplace([1, 2, 3], 4, (n) => n === 2); // [1, 4, 3]\n * ```\n */\nexport function arrayReplace<const T> (initialList: readonly T[], newItem: T, match: MatchFunction<T, boolean>): T[];\nexport function arrayReplace<const T, K extends T> (initialList: readonly T[], newItem: K, match: MatchFunction<T, boolean>): T[];\nexport function arrayReplace<const T, K> (initialList: readonly T[], newItem: K, match: MatchFunction<T, boolean>): (T | K)[];\nexport function arrayReplace<const T, K> (initialList: readonly T[], newItem: K, match: MatchFunction<T, boolean>): (T | K)[] {\n  if (!isArray(initialList) || !initialList.length) {\n    return [];\n  }\n  if (!isFunction(match)) {\n    return [...initialList];\n  }\n\n  for (let i = 0; i < initialList.length; i++) {\n    const item = initialList[i]!;\n    if (match(item, i)) {\n      return [...initialList.slice(0, i), newItem, ...initialList.slice(i + 1, initialList.length)] as (T | K)[];\n    }\n  }\n\n  return [...initialList];\n}\n","import type { MatchFunction } from \"../../types/index.type\";\nimport { isArray, isFunction, isPositiveInteger } from \"../typeof\";\n\ntype PositionType = \"start\" | \"end\" | number;\n/**\n * 数组项替换并移动\n * - 在给定的数组中，替换并移动符合匹配函数结果的项目\n * - 只替换和移动第一个匹配项\n * - 未匹配时，根据 `position` 在指定位置插入 `newItem`\n *\n * @param initialList 初始数组\n * @param newItem 替换项\n * @param match 匹配函数\n * @param position 移动位置，可选 `start` | `end` | 索引位置， 默认为 `end`\n * @returns\n * @example\n * ```ts\n * arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2, 0); // [5, 1, 3, 4]\n * arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2, 2); // [1, 3, 5, 4]\n * arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2, \"start\"); // [5, 1, 3, 4]\n * arrayReplaceMove([1, 2, 3, 4], 5, (n) => n === 2); // [1, 3, 4, 5]\n * ```\n */\nexport function arrayReplaceMove<const T> (initialList: readonly T[], newItem: T, match: MatchFunction<T, boolean>, position?: PositionType): T[] {\n  if (!isArray(initialList)) {\n    return [];\n  }\n  if (!initialList.length) {\n    return [newItem];\n  }\n  if (!isFunction(match)) {\n    return [...initialList];\n  }\n\n  const result = [...initialList];\n  const matchIndex = initialList.findIndex(match);\n\n  if (matchIndex !== -1) {\n    result.splice(matchIndex, 1);\n  }\n\n  if (position === \"start\") {\n    result.unshift(newItem);\n  } else if (position === 0 || isPositiveInteger(position, false)) {\n    result.splice(Math.min(position, result.length), 0, newItem);\n  } else {\n    result.push(newItem);\n  }\n\n  return result;\n}\n","import { isArray, isPositiveInteger } from \"../typeof\";\n\n/**\n * 数组切分\n * - 将数组以指定的长度切分后，组合在高维数组中\n *\n * @param initialList 初始数组\n * @param size 分割尺寸，默认 `10`\n * @returns 切分后的二维数组\n * @example\n * ```ts\n * arraySplit([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n * ```\n */\nexport function arraySplit<T> (initialList: readonly T[], size: number = 10): T[][] {\n  if (!isArray(initialList)) {\n    return [];\n  }\n  if (!isPositiveInteger(size, false)) {\n    return [];\n  }\n\n  const count = Math.ceil(initialList.length / size);\n\n  return Array.from({ length: count })\n    .fill(null)\n    .map((_c, i) => {\n      return initialList.slice(i * size, i * size + size);\n    });\n}\n","import { isArray } from \"../typeof\";\n\n/**\n * 数组解压\n * - `arrayZip` 的反向操作\n *\n * @param arrays 压缩后的数组\n * @returns 解压后的二维数组\n * @example\n * ```ts\n * arrayUnzip([[1, \"a\"], [2, \"b\"]]); // [[1, 2], [\"a\", \"b\"]]\n * ```\n */\nexport function arrayUnzip<T> (arrays: readonly (readonly T[])[]): T[][] {\n  if (!isArray(arrays) || !arrays.length) {\n    return [];\n  }\n  const out = new Array(arrays.reduce((max, arr) => Math.max(max, arr.length), 0));\n  let index = 0;\n  const get = (array: T[]) => array[index];\n\n  for (; index < out.length; index++) {\n    out[index] = Array.from(arrays as { length: number }, get);\n  }\n\n  return out;\n}\n\n/**\n * 数组压缩\n * - 将多个数组的元素按索引组合成元组\n *\n * @param arrays 多个数组\n * @returns 压缩后的元组数组\n * @example\n * ```ts\n * arrayZip([1, 2], [\"a\", \"b\"]); // [[1, \"a\"], [2, \"b\"]]\n * ```\n */\nexport function arrayZip<T1, T2, T3, T4, T5> (array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[], array5: readonly T5[]): [T1, T2, T3, T4, T5][];\nexport function arrayZip<T1, T2, T3, T4> (array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[]): [T1, T2, T3, T4][];\nexport function arrayZip<T1, T2, T3> (array1: readonly T1[], array2: readonly T2[], array3: readonly T3[]): [T1, T2, T3][];\nexport function arrayZip<T1, T2> (array1: readonly T1[], array2: readonly T2[]): [T1, T2][];\nexport function arrayZip (): [];\nexport function arrayZip<T> (...arrays: (readonly T[])[]): T[][] {\n  return arrayUnzip(arrays);\n}\n","import type { MatchFunction } from \"../../types/index.type\";\nimport type { PlainObject } from \"@pawover/types\";\nimport { isArray, isFunction } from \"../typeof\";\n\n/**\n * 数组压缩为对象\n * - 将键数组和值（数组、函数或静态值）组合成对象\n *\n * @param keys 键数组\n * @param values 值数组、生成值的函数或静态值\n * @returns 生成的对象\n * @example\n * ```ts\n * arrayZipToObject([\"a\", \"b\"], [1, 2]); // { a: 1, b: 2 }\n * arrayZipToObject([\"a\", \"b\"], (k, i) => k + i); // { a: \"a0\", b: \"b1\" }\n * arrayZipToObject([\"a\", \"b\"], 1); // { a: 1, b: 1 }\n * ```\n */\nexport function arrayZipToObject<const K extends PropertyKey, const V> (keys: readonly K[], array: readonly V[]): Record<K, V>;\nexport function arrayZipToObject<const K extends PropertyKey, const V> (keys: readonly K[], match: MatchFunction<K, V>): Record<K, V>;\nexport function arrayZipToObject<const K extends PropertyKey, const V> (keys: readonly K[], value: V): Record<K, V>;\nexport function arrayZipToObject<const K extends PropertyKey, const V> (keys: readonly K[], values: V | MatchFunction<K, V> | readonly V[]): Record<K, V> {\n  const result = {} as PlainObject<K, V>;\n\n  if (!isArray(keys) || !keys.length) {\n    return result;\n  }\n\n  const getValue = isFunction(values)\n    ? values\n    : isArray(values)\n      ? (_k: K, i: number) => values[i]\n      : (_k: K, _i: number) => values;\n\n  return keys.reduce((acc, key, idx) => {\n    acc[key] = getValue(key, idx) as V;\n\n    return acc;\n  }, result);\n}\n","import { isFunction } from \"../typeof\";\n\nexport function isBrowser (): boolean {\n  return typeof window !== \"undefined\" && isFunction(window?.document?.createElement);\n}\n\nexport function isWebWorker () {\n  return typeof window === \"undefined\" && typeof self !== \"undefined\" && \"importScripts\" in self;\n}\n","import { isTablet } from \".\";\nimport { isPositiveInteger } from \"../typeof\";\n\n/**\n * 检测当前设备是否为移动设备\n *\n * @param maxWidth - 移动设备最大宽度（默认 768px）\n * @param dpi - 标准 DPI 基准（默认 160）\n * @returns 是否为移动设备\n * @example\n * ```ts\n * // 假设 window.innerWidth = 500\n * isMobile(); // true\n * ```\n */\nexport function isMobile (maxWidth = 768, dpi = 160) {\n  if (typeof window === \"undefined\" || !isPositiveInteger(maxWidth)) {\n    return false;\n  }\n\n  return !isTablet(maxWidth, 1200, dpi);\n}\n\n/**\n * 检测当前设备是否为IOS移动设备\n *\n * @param maxWidth - 移动设备最大宽度（默认 768px）\n * @param dpi - 标准 DPI 基准（默认 160）\n * @returns 是否为 iOS 移动设备 (iPhone/iPad/iPod 且非平板)\n * @example\n * ```ts\n * // UA contains iPhone\n * isIOSMobile(); // true\n * ```\n */\nexport function isIOSMobile (maxWidth = 768, dpi = 160) {\n  if (typeof navigator === \"undefined\" || !navigator.userAgent || !isPositiveInteger(maxWidth)) {\n    return false;\n  }\n\n  const isIOS = /iPhone|iPad|iPod/i.test(navigator.userAgent);\n\n  return isIOS && !isTablet(maxWidth, 1200, dpi);\n}\n","import { isPositiveInteger } from \"../typeof\";\n\n/**\n * 检测当前设备是否为平板\n *\n * @param minWidth - 平板最小宽度（默认 768px）\n * @param maxWidth - 平板最大宽度（默认 1200px）\n * @param dpi - 标准 DPI 基准（默认 160）\n * @returns 是否为平板设备\n * @example\n * ```ts\n * // 假设 window.innerWidth = 1000\n * isTablet(); // true\n * ```\n */\nexport function isTablet (minWidth = 768, maxWidth = 1200, dpi = 160) {\n  if (typeof window === \"undefined\" || !isPositiveInteger(minWidth) || !isPositiveInteger(maxWidth)) {\n    return false;\n  }\n\n  // 逻辑 1: 检查屏幕宽度\n  const width = window.innerWidth;\n  const isWithinWidthRange = width >= minWidth && width <= maxWidth;\n\n  try {\n    // 逻辑 2: 计算屏幕尺寸（英寸）\n    const widthPx = window.screen.width;\n    const heightPx = window.screen.height;\n    const DPR = window.devicePixelRatio || 1;\n    const DPI = dpi * DPR;\n\n    const widthInch = widthPx / DPI;\n    const heightInch = heightPx / DPI;\n    const screenInches = Math.sqrt(widthInch ** 2 + heightInch ** 2);\n\n    return isWithinWidthRange || screenInches >= 7.0;\n  } catch {\n    // 备用方案：如果计算失败（如无 screen API），仅用宽度判断\n    return isWithinWidthRange;\n  }\n}\n","import type { PlainObject } from \"@pawover/types\";\nimport type { LiteralUnion } from \"type-fest\";\n\n/**\n *将 Promise 转换为 `[err, result]` 格式，方便 async/await 错误处理\n *\n * @param promise 待处理的 Promise\n * @param errorExt 附加到 error 对象的扩展信息（注意：如果原 error 是 Error 实例，扩展属性可能会覆盖或无法正确合并非枚举属性）\n * @returns `[err, null]` 或 `[null, data]`\n * @example\n * ```ts\n * const [err, data] = await to(someAsyncFunc());\n * if (err) return;\n * console.log(data);\n * ```\n */\nexport function to<T, U = Error> (promise: Readonly<Promise<T>>, errorExt?: PlainObject): Promise<[U, undefined] | [null, T]> {\n  return promise\n    .then<[null, T]>((data: T) => [null, data])\n    .catch<[U, undefined]>((err: U) => {\n      if (errorExt) {\n        const parsedError: Record<LiteralUnion<\"message\" | \"name\" | \"stack\", string>, unknown> = { name: \"\", message: \"\", stack: \"\" };\n\n        if (err instanceof Error) {\n          parsedError.message = err.message;\n          parsedError.name = err.name;\n          parsedError.stack = err.stack;\n\n          // 将 err 的其他自有属性也复制过来\n          Object.getOwnPropertyNames(err).forEach((key) => {\n            if (!(key in parsedError)) {\n              parsedError[key] = (err as Record<string, unknown>)[key];\n            }\n          });\n        } else {\n          Object.assign(parsedError, err);\n        }\n\n        Object.assign(parsedError, errorExt);\n\n        return [parsedError as U, undefined];\n      }\n\n      const defaultError = err ? err : new Error(\"defaultError\");\n\n      return [defaultError as U, undefined];\n    });\n}\n","import { isString } from \"../typeof\";\n\nconst R1 = /[^0-9.-]/g;\n\n/**\n * 从字符串中提取数字字符串\n * - 移除非数字字符，保留符号和小数点\n *\n * @param input 待处理字符串\n * @returns 提取出的数字字符串\n * @example\n * ```ts\n * stringToNumber(\"$1,234.56\"); // \"1234.56\"\n * stringToNumber(\"abc-123\"); // \"-123\"\n * ```\n */\nexport function stringToNumber (input: string) {\n  if (!isString(input, true)) {\n    return \"0\";\n  }\n\n  const cleaned = input.replace(R1, \"\");\n\n  if (!cleaned) {\n    return \"0\";\n  }\n\n  let isDecimal = false;\n  let signCount = 0;\n  let firstIndex = -1;\n  const stringList = cleaned.split(\"\").map((s, i) => {\n    if (s === \".\") {\n      if (isDecimal) {\n        return \"\";\n      }\n      isDecimal = true;\n\n      return \".\";\n    }\n    if (s === \"-\") {\n      firstIndex === -1 && signCount++;\n\n      return \"\";\n    }\n\n    firstIndex === -1 && (firstIndex = i);\n\n    return s;\n  });\n\n  const sign = signCount % 2 === 1 ? \"-\" : \"\";\n\n  if (firstIndex === -1) {\n    return sign + \"0\";\n  }\n\n  // 组合符号和数字部分，并处理前导小数点\n  let result = stringList.join(\"\");\n  if (result.startsWith(\".\")) {\n    result = \"0\" + result;\n  }\n  if (result.endsWith(\".\")) {\n    result = result.slice(0, -1);\n  }\n\n  return sign + result;\n}\n","import type { BigNumber, MathJsInstance } from \"mathjs\";\nimport { stringToNumber } from \"../string/stringToNumber\";\nimport { isFalsyLike, isInfinityLike } from \"../typeof\";\n\n/**\n * 将任意类型的值转换为 `math.bignumber`\n *\n * @param mathJsInstance mathJs 实例\n * @param value 任意类型的值\n * @param saveValue 安全值\n * @returns 转换后的 BigNumber\n * @example\n * ```ts\n * import { create, all } from \"mathjs\";\n * const math = create(all);\n * mathToBignumber(math, \"0.1\");\n * ```\n */\nexport function mathToBignumber (mathJsInstance: MathJsInstance, value: unknown, saveValue?: BigNumber | undefined): BigNumber {\n  const errorValue = saveValue ?? mathJsInstance.bignumber(0);\n\n  if (isFalsyLike(value) || isInfinityLike(value)) {\n    return errorValue;\n  }\n\n  try {\n    return mathJsInstance.bignumber(stringToNumber(`${value}`));\n  } catch (error) {\n    return errorValue;\n  }\n}\n","import type { BigNumber, MathJsInstance } from \"mathjs\";\nimport { mathToBignumber } from \"./mathToBignumber\";\n\n/**\n * 将任意类型的值转换为十进制数字字符串\n *\n * @param mathJsInstance mathJs 实例\n * @param value 任意类型的值\n * @param precision 精度\n * @param isFormat 是否格式化为字符串\n * @returns 格式化后的字符串或 BigNumber\n * @example\n * ```ts\n * mathToDecimal(math, 0.12345, 2); // \"0.12\"\n * ```\n */\nexport function mathToDecimal (mathJsInstance: MathJsInstance, value: unknown, precision?: number | undefined, isFormat?: true): string;\nexport function mathToDecimal (mathJsInstance: MathJsInstance, value: unknown, precision?: number | undefined, isFormat?: false): BigNumber;\nexport function mathToDecimal (mathJsInstance: MathJsInstance, value: unknown, precision?: number | undefined, isFormat = true): string | BigNumber {\n  const bigNumber = mathToBignumber(mathJsInstance, value);\n\n  return isFormat ? mathJsInstance.format(bigNumber, { notation: \"fixed\", precision: precision! }) : bigNumber;\n}\n","import type { BigNumber, MathExpression, MathJsInstance, Matrix } from \"mathjs\";\nimport { mathToBignumber } from \"./mathToBignumber\";\n\n/**\n * 数学表达式求值\n *\n * @param mathJsInstance mathJs 实例\n * @param expr 表达式\n * @param scope 键值映射\n * @returns 计算结果的字符串表示\n * @example\n * ```ts\n * mathToEvaluate(math, \"a + b\", { a: 1, b: 2 }); // \"3\"\n * ```\n */\nexport function mathToEvaluate (mathJsInstance: MathJsInstance, expr: MathExpression | Matrix, scope?: Record<string, BigNumber>): string {\n  const evaluateValue = `${mathJsInstance.evaluate(expr, scope || {})}`;\n\n  return mathJsInstance.format(mathToBignumber(mathJsInstance, evaluateValue), { notation: \"fixed\" });\n}\n","import { isInfinity, isNumber } from \"../typeof\";\n\n/**\n * 数字区间检查函数\n *\n * @param input 待检查数字\n * @param interval 由两个数字组成的元组 [left, right]\n * @param includeLeft 是否包含左边界（默认 true）\n * @param includeRight 是否包含右边界（默认 false）\n * @returns 是否在区间内\n * @example\n * ```ts\n * numberWithin(5, [1, 10]); // true\n * numberWithin(1, [1, 10], false); // false\n * ```\n */\nexport function numberWithin (input: number, interval: [number, number], includeLeft = true, includeRight = false) {\n  if (!isNumber(input)) {\n    throw new Error(\"params [input] mast be a number.\");\n  }\n\n  if (isInfinity(input)) {\n    throw new Error(\"params [input] mast be a finite number.\");\n  }\n\n  const [left, right] = interval;\n\n  if (left > right) {\n    throw new Error(`Invalid interval: left (${left}) must be <= right (${right}).`);\n  }\n\n  if (includeLeft && includeRight) {\n    return input >= left && input <= right;\n  } else if (includeLeft) {\n    return input >= left && input < right;\n  } else if (includeRight) {\n    return input > left && input <= right;\n  } else {\n    return input > left && input < right;\n  }\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport { isEnumeration, objectEntries } from \"..\";\n\n/**\n * 获取所有枚举成员的键/值数组\n *\n * @param enumeration 枚举对象\n * @returns 键值对数组\n * @example\n * ```ts\n * enum A { k = \"v\" }\n * enumEntries(A); // [[\"k\", \"v\"]]\n * ```\n */\nexport function enumEntries<E extends PlainObject> (enumeration: E): [keyof E, E[keyof E]][];\nexport function enumEntries<E extends AnyObject> (enumeration: E): [keyof E, E[keyof E]][];\nexport function enumEntries (enumeration: AnyObject) {\n  const [isEnum, isBidirectionalEnum] = isEnumeration(enumeration);\n\n  if (!isEnum) {\n    throw Error(\"function enumEntries expected parameter is a enum, and requires at least one member\");\n  }\n\n  const entries = objectEntries(enumeration);\n\n  if (isBidirectionalEnum) {\n    return entries.splice(entries.length / 2, entries.length / 2);\n  }\n\n  return entries;\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport { isEnumeration, objectKeys } from \"..\";\n\n/**\n * 获取所有枚举成员的键\n *\n * @param enumeration 枚举对象\n * @returns 键数组\n * @example\n * ```ts\n * enum A { k = \"v\" }\n * enumKeys(A); // [\"k\"]\n * ```\n */\nexport function enumKeys<E extends PlainObject> (enumeration: E): (keyof E)[];\nexport function enumKeys<E extends AnyObject> (enumeration: E): (keyof E)[];\nexport function enumKeys (enumeration: AnyObject) {\n  const [isEnum, isBidirectionalEnum] = isEnumeration(enumeration);\n\n  if (!isEnum) {\n    throw Error(\"function enumKeys expected parameter is a enum, and requires at least one member\");\n  }\n\n  const keys = objectKeys(enumeration);\n\n  if (isBidirectionalEnum) {\n    return keys.splice(keys.length / 2, keys.length / 2);\n  }\n\n  return keys;\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport type { UnionToTuple, ValueOf } from \"type-fest\";\nimport { isEnumeration, objectValues } from \"..\";\n\n/**\n * 获取所有枚举成员的值\n *\n * @param enumeration 枚举对象\n * @returns 值数组\n * @example\n * ```ts\n * enum A { k = \"v\" }\n * enumValues(A); // [\"v\"]\n * ```\n */\nexport function enumValues<E extends PlainObject> (enumeration: E): UnionToTuple<ValueOf<E>>;\nexport function enumValues<E extends AnyObject> (enumeration: E): UnionToTuple<ValueOf<E>>;\nexport function enumValues (enumeration: AnyObject) {\n  const [isEnum, isBidirectionalEnum] = isEnumeration(enumeration);\n\n  if (!isEnum) {\n    throw Error(\"function enumValues expected parameter is a enum, and requires at least one member\");\n  }\n\n  const values = objectValues(enumeration);\n\n  if (isBidirectionalEnum) {\n    return values.splice(values.length / 2, values.length / 2);\n  }\n\n  return values;\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport type { Except, Split } from \"type-fest\";\nimport type { TupleToEntries, TupleToGroups } from \"../../types/index.type\";\n\n/**\n * 返回对象的可枚举属性的键/值数组\n *\n * @param value 对象\n * @returns 键值对数组\n * @example\n * ```ts\n * objectEntries({ a: 1 }); // [[\"a\", 1]]\n * ```\n */\nexport function objectEntries<const S extends string> (string: S): TupleToEntries<Split<S, \"\">>;\nexport function objectEntries<const A extends readonly unknown[]> (array: A): TupleToGroups<A>;\nexport function objectEntries<const O extends PlainObject> (plainObject: O): [`${keyof Except<O, symbol>}`, O[keyof Except<O, symbol>]][];\nexport function objectEntries<const O extends AnyObject> (anyObject: O): [`${keyof Except<O, symbol>}`, O[keyof Except<O, symbol>]][];\nexport function objectEntries (value: object) {\n  return Object.entries(value) as unknown;\n}\n","import type { PlainObject } from \"@pawover/types\";\nimport { objectEntries } from \"./objectEntries\";\nimport { isObject } from \"../typeof\";\n\n/**\n * 映射对象条目\n * - 将对象的键值对映射为新的键值对\n *\n * @param plainObject 对象\n * @param toEntry 映射函数\n * @returns 映射后的新对象\n * @example\n * ```ts\n * const obj = { a: 1, b: 2 };\n * objectMapEntries(obj, (k, v) => [k, v * 2]); // { a: 2, b: 4 }\n * ```\n */\nexport function objectMapEntries<O extends PlainObject, NK extends PropertyKey, NV> (plainObject: O, toEntry: (key: keyof O, value: O[keyof O]) => [NK, NV]): PlainObject<NK, NV> {\n  const defaultResult = {} as PlainObject<NK, NV>;\n\n  if (!isObject(plainObject)) {\n    return defaultResult;\n  }\n\n  return objectEntries(plainObject).reduce((acc, [key, value]) => {\n    const [newKey, newValue] = toEntry(key, value);\n    acc[newKey] = newValue;\n\n    return acc;\n  }, defaultResult);\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport type { Assign } from \"radashi\";\nimport { isObject } from \"../typeof\";\n\nconst OBJECT_PROTO = Object.prototype;\n\n/**\n * 为对象创建一个具有相同原型的新副本\n * 这个辅助函数是保留原型的关键。\n */\nfunction cloneWithProto<T extends AnyObject> (obj: T): T {\n  const proto = Object.getPrototypeOf(obj);\n\n  // 如果原型是 Object.prototype (即普通对象 {})，则使用解构赋值即可\n  // 否则，必须使用 Object.create 来保留特殊的原型链\n  return proto === OBJECT_PROTO ? { ...obj } : Object.assign(Object.create(proto), obj);\n}\n\nfunction _objectAssign (initial: AnyObject, override: AnyObject, _seen: WeakSet<object>): AnyObject {\n  // 只有当 initial 和 override 都不是对象时，才返回 {}\n  // 如果其中一个不是对象，我们对其调用 cloneWithProto()，它能正确处理各种对象类型。\n  if (!isObject(initial, false) && !isObject(override, false)) {\n    return {};\n  }\n  if (!isObject(initial, false)) {\n    return cloneWithProto(override);\n  }\n  if (!isObject(override, false)) {\n    return cloneWithProto(initial);\n  }\n\n  // 检测循环引用\n  // 如果 initial 已经被访问过，说明它内部有循环引用。此时，我们应该停止递归，直接用 override 的副本替换它。\n  if (_seen.has(initial)) {\n    return cloneWithProto(override);\n  }\n  _seen.add(initial);\n\n  // 创建 initial 的副本，保留其原型\n  const assigned = cloneWithProto(initial);\n\n  // 执行合并\n  for (const key of Object.keys(override)) {\n    // 只有当两者都是 PlainObject 时才递归合并。\n    if (isObject(initial[key]) && isObject(override[key])) {\n      assigned[key] = _objectAssign(initial[key], override[key], _seen);\n    } else {\n      // 否则直接覆盖\n      assigned[key] = override[key];\n    }\n  }\n\n  _seen.delete(initial);\n\n  return assigned;\n}\n\n/**\n * 递归地将第二个对象合并到第一个对象的副本中\n * - 只有普通对象才会递归合并\n * - 会处理循环引用，避免无限递归\n *\n * @param initial 初始对象\n * @param override 待合并对象\n * @returns 合并后的新对象\n * @example\n * ```ts\n * const initial = { a: 1, b: { c: 2 } };\n * const override = { b: { d: 3 } };\n * objectAssign(initial, override); // { a: 1, b: { c: 2, d: 3 } }\n * ```\n */\nexport function objectAssign<I extends PlainObject, O extends PlainObject> (initial: I, override: O): Assign<I, O>;\nexport function objectAssign<I extends AnyObject, O extends AnyObject> (initial: I, override: O): Assign<I, O>;\nexport function objectAssign (initial: AnyObject, override: AnyObject) {\n  return _objectAssign(initial, override, new WeakSet());\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport type { Simplify, UnionToIntersection } from \"type-fest\";\nimport { isArray, isObject } from \"../typeof\";\n\ntype Crush<T> = T extends readonly (infer U)[]\n  ? Record<string, U extends object ? unknown : U>\n  : Simplify<\n    UnionToIntersection<\n      keyof T extends infer Prop\n        ? Prop extends keyof T\n          ? T[Prop] extends infer Value\n            ? | ([Extract<Value, object>] extends [never] ? never : Record<string, unknown>)\n            | ([Exclude<Value, object>] extends [never]\n              ? never\n              : [Extract<Value, object>] extends [never]\n                ? { [P in Prop]: Value }\n                : Record<string, unknown>)\n            : never\n          : never\n        : never\n    >\n  >;\n\n/**\n * 压平对象\n * - 将多层级的对象转换为单层级的对象，键名使用点号连接\n *\n * @param plainObject 平面对象\n * @returns 压平后的对象\n * @example\n * ```ts\n * const obj = { a: { b: 1 } };\n * objectCrush(obj); // { \"a.b\": 1 }\n * ```\n */\nexport function objectCrush<T extends PlainObject> (plainObject: T): Crush<T>;\nexport function objectCrush<T extends AnyObject> (anyObject: T): Crush<T>;\nexport function objectCrush<T extends AnyObject> (obj: T): Crush<T> {\n  if (!obj) {\n    return {} as Crush<T>;\n  }\n\n  function crushReducer (crushed: Crush<T>, value: unknown, path: string) {\n    if (isObject(value) || isArray(value)) {\n      for (const [prop, propValue] of Object.entries(value)) {\n        crushReducer(crushed, propValue, path ? `${path}.${prop}` : prop);\n      }\n    } else {\n      crushed[path as keyof Crush<T>] = value as Crush<T>[keyof Crush<T>];\n    }\n\n    return crushed;\n  }\n\n  return crushReducer({} as Crush<T>, obj, \"\");\n}\n","import type { AnyFunction, AnyObject } from \"@pawover/types\";\nimport { isNumber, isObject, isString, isSymbol } from \"../typeof\";\nimport { objectEntries } from \"./objectEntries\";\n\ntype IntersectOf<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;\ntype ComputeRaw<A> = A extends AnyFunction ? A : { [K in keyof A]: A[K] } & unknown;\ntype _Invert<O extends Record<PropertyKey, PropertyKey>> = ComputeRaw<IntersectOf<{ [K in keyof O]: Record<O[K], K> }[keyof O]>>;\ntype Invert<O extends Record<keyof O, PropertyKey>> = O extends unknown ? _Invert<O> : never;\n\n/**\n * 尽可能地交换对象的键和值\n *\n * @param obj 对象\n * @returns 键值互换后的对象\n * @example\n * ```ts\n * const obj = { a: \"1\", b: 2 };\n * objectInvert(obj); // { \"1\": \"a\", 2: \"b\" }\n * ```\n */\nexport function objectInvert<const O extends Record<keyof O, PropertyKey>> (plainObject: O): Invert<O>;\nexport function objectInvert<const O extends AnyObject> (anyObject: O): Invert<O>;\nexport function objectInvert (obj: AnyObject) {\n  const result = {} as Invert<AnyObject>;\n\n  if (!isObject(obj)) {\n    return result;\n  }\n\n  for (const [k, v] of objectEntries(obj)) {\n    if (isString(v) || isNumber(v) || isSymbol(v)) {\n      (result as AnyObject)[v] = k;\n    }\n  }\n\n  return result;\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport type { Split, UnionToTuple } from \"type-fest\";\nimport type { Range } from \"../../types/index.type\";\n\n/**\n * 返回对象可枚举属性和方法的名称\n * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型\n *\n * @param value 对象\n * @returns 键数组\n * @example\n * ```ts\n * objectKeys({ a: 1, b: 2 }); // [\"a\", \"b\"]\n * ```\n */\nexport function objectKeys<const S extends string> (string: S): UnionToTuple<Range<0, Split<S, \"\">[\"length\"]>>;\nexport function objectKeys<const A extends ArrayLike<unknown>> (array: A): UnionToTuple<Range<0, A[\"length\"]>>;\nexport function objectKeys<O extends PlainObject> (plainObject: O): `${Extract<keyof O, string | number>}`[];\nexport function objectKeys<O extends AnyObject> (anyObject: O): `${Extract<keyof O, string | number>}`[];\nexport function objectKeys (value: object) {\n  return Object.keys(value);\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport { isArray, isObject } from \"../typeof\";\n\n/**\n * 排除对象的指定属性\n *\n * @param plainObject 对象\n * @param keys 要排除的属性键数组\n * @returns 排除指定属性后的新对象\n * @example\n * ```ts\n * objectOmit({ a: 1, b: 2 }, [\"a\"]); // { b: 2 }\n * ```\n */\nexport function objectOmit<O extends PlainObject, K extends keyof O> (plainObject: O, keys: readonly K[]): Omit<O, K>;\nexport function objectOmit<O extends AnyObject, K extends keyof O> (anyObject: O, keys: readonly K[]): Omit<O, K>;\nexport function objectOmit (obj: object, keys: readonly string[]) {\n  const result = {} as PlainObject;\n\n  if (!isObject(obj)) {\n    return result;\n  }\n  if (!isArray(keys)) {\n    return obj;\n  }\n\n  const keysToOmit = new Set(keys);\n\n  return Object.keys(obj).reduce((acc, key) => {\n    if (!keysToOmit.has(key)) {\n      acc[key] = obj[key];\n    }\n\n    return acc;\n  }, result);\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport { isArray, isObject } from \"../typeof\";\n\n/**\n * 选取对象的指定属性\n *\n * @param plainObject 对象\n * @param keys 要选取的属性键数组\n * @returns 包含指定属性的新对象\n * @example\n * ```ts\n * objectPick({ a: 1, b: 2 }, [\"a\"]); // { a: 1 }\n * ```\n */\nexport function objectPick<O extends PlainObject, K extends keyof O> (plainObject: O, keys: readonly K[]): Pick<O, K>;\nexport function objectPick<O extends AnyObject, K extends keyof O> (anyObject: O, keys: readonly K[]): Pick<O, K>;\nexport function objectPick (obj: object, keys: readonly PropertyKey[]) {\n  const result = {} as PlainObject;\n\n  if (!isObject(obj)) {\n    return result;\n  }\n  if (!isArray(keys)) {\n    return obj;\n  }\n\n  return keys.reduce((acc, key) => {\n    if (key in obj) {\n      acc[key] = obj[key];\n    }\n\n    return acc;\n  }, result);\n}\n","import type { AnyObject, PlainObject } from \"@pawover/types\";\nimport type { Split } from \"type-fest\";\n\n/**\n * 返回对象可枚举属性的值的数组\n *\n * @param value 对象\n * @returns 值数组\n * @example\n * ```ts\n * objectValues({ a: 1, b: 2 }); // [1, 2]\n * ```\n */\nexport function objectValues<S extends string> (string: S): Split<S, \"\">;\nexport function objectValues<A extends ArrayLike<unknown>> (array: A): A;\nexport function objectValues<O extends PlainObject> (plainObject: O): O[keyof O][];\nexport function objectValues<O extends AnyObject> (anyObject: O): O[keyof O][];\nexport function objectValues (value: object) {\n  return Object.values(value);\n}\n","import { isString } from \"../typeof\";\n\nconst R1 = /\\S+/g;\nconst R2 = /[^a-zA-Z\\u00C0-\\u017F]/;\n\n/**\n * 字符串首字母大小写\n * - 包含非西欧字母字符时，不处理\n * - 纯字母且全大写时，不处理\n * - 纯字母且非全大写时，首字母小写，其余保留\n * - 纯字母且非全大写时，首字母大写，其余保留\n *\n * @param input 待处理字符串\n * @param caseType 大小写类型\n * @returns 处理后的字符串\n * @example\n * ```ts\n * stringInitialCase(\"Hello\", \"lower\"); // \"hello\"\n * stringInitialCase(\"hello\", \"upper\"); // \"Hello\"\n * ```\n */\nexport function stringInitialCase (input: string, caseType?: \"lower\" | \"upper\" | undefined) {\n  if (!isString(input, true)) {\n    return \"\";\n  }\n\n  return input.replace(R1, (word) => {\n    // 非西欧字母字符（如.,'-等）→ 保留\n    if (R2.test(word)) {\n      return word;\n    }\n    // 纯字母且全大写 → 保留\n    if (word === word.toLocaleUpperCase()) {\n      return word;\n    }\n    // 纯字母且非全大写 → 首字母小写，其余保留\n    if (caseType === \"lower\" && word[0]) {\n      return word[0].toLocaleLowerCase() + word.slice(1);\n    }\n    // 纯字母且非全大写 → 首字母大写，其余保留\n    if (caseType === \"upper\" && word[0]) {\n      return word[0].toLocaleUpperCase() + word.slice(1);\n    }\n\n    return word;\n  });\n}\n","import type { Replace } from \"type-fest\";\nimport { isString } from \"../typeof\";\n\n/**\n * 字符串替换\n * - 替换第一个匹配项\n *\n * @param input 待处理字符串\n * @param search 匹配项\n * @param replacement 替换项\n * @returns 替换后的字符串\n * @example\n * ```ts\n * stringReplace(\"hello world\", \"world\", \"context\"); // \"hello context\"\n * ```\n */\nexport function stringReplace<I extends string, S extends string, R extends string> (input: I, search: S, replacement: R) {\n  if (!isString(input, true)) {\n    return \"\" as Replace<I, S, R>;\n  }\n\n  return input.replace(search, replacement) as Replace<I, S, R>;\n}\n","import type { PlainObject } from \"@pawover/types\";\nimport { isString } from \"../typeof\"; // 假设 isString 来自这里\n\nconst R1 = /\\{\\{(.+?)\\}\\}/g;\n\n/**\n * 字符串模板替换\n * - 使用对象的属性值替换字符串中的 {{key}} 模板\n *\n * @param input 待处理字符串\n * @param template 模板对象\n * @param regex 模板匹配正则 (默认: `\\{\\{(.+?)\\}\\}`)\n * @returns 替换后的字符串\n * @example\n * ```ts\n * stringTemplate(\"Hello {{name}}\", { name: \"World\" }); // \"Hello World\"\n * ```\n */\nexport function stringTemplate (input: string, template: PlainObject, regex = R1) {\n  if (!isString(input, true)) {\n    return \"\";\n  }\n\n  // 重置正则表达式的 lastIndex，防止上次执行的影响\n  regex.lastIndex = 0;\n\n  let result = \"\";\n  let from = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = regex.exec(input))) {\n    // 获取模板对象中对应的值\n    const replacement = template[match[1]!];\n    // 如果值为 null 或 undefined，则保留原始的占位符\n    const valueToInsert = (replacement === null || replacement === undefined)\n      ? match[0]\n      : replacement;\n\n    result += input.slice(from, match.index) + valueToInsert;\n    from = regex.lastIndex;\n  }\n\n  return result + input.slice(from);\n}\n","import type { AnyObject } from \"@pawover/types\";\nimport { isString } from \"../typeof\";\n\n/**\n * 处理 JSON 字符串\n *\n * @param input 待处理字符串\n * @param safeValue 安全值 (当解析失败或输入无效时返回)\n * @returns 解析后的对象 或 安全值\n * @example\n * ```ts\n * stringToJson('{\"a\": 1}', {}); // { a: 1 }\n * stringToJson('invalid', {}); // {}\n * ```\n */\nexport function stringToJson<D extends AnyObject = AnyObject> (input: string | null | undefined, safeValue: D): D {\n  if (!isString(input, true)) {\n    return safeValue;\n  }\n\n  try {\n    const value = JSON.parse(input);\n\n    return value;\n  } catch (error) {\n    return safeValue;\n  }\n}\n","import { isString } from \"../typeof\";\n\n/**\n * 将字符串转换为小写\n * - 将字符串字面量类型转换为其小写形式\n * - 当输入无效时，返回空字符串\n *\n * @param input 待处理字符串\n * @returns 转换后的小写字符串类型，如果输入无效则返回空字符串类型 \"\"\n * @example\n * ```ts\n * stringToLowerCase(\"HELLO\"); // 类型为 \"hello\"\n * stringToLowerCase(someUnknownString); // 类型为 string\n * stringToLowerCase(null); // 类型为 \"\"\n * ```\n */\nexport function stringToLowerCase<const T extends string> (input: T): Lowercase<T>;\nexport function stringToLowerCase (input: unknown): \"\";\nexport function stringToLowerCase<const T extends string> (input: T): Lowercase<T> | \"\" {\n  if (!isString(input, true)) {\n    return \"\";\n  }\n\n  return input.toLowerCase() as Lowercase<T>;\n}\n","import { isString } from \"../typeof\";\n\n/**\n * 将路径转换为 POSIX 风格\n * - 统一使用正斜杠 (/)\n * - 可选移除 Windows 盘符 (如 C:)\n * - 可选移除开头的斜杠\n * - 规范化连续斜杠为单个斜杠\n *\n * @param input 待处理字符串\n * @param removeLeadingSlash 是否移除开头斜杠，默认为 `false`。如果移除了盘符，路径通常会以 / 开头，此参数可控制是否保留该 /\n * @returns 转换后的路径，如果输入无效则返回空字符串\n *\n * @example\n * ```ts\n * stringToPosix(\"C:\\\\Windows\\\\System32\");\n * // 默认: \"/Windows/System32\" (移除了 C: 并标准化)\n *\n * stringToPosix(\"C:\\\\Windows\\\\System32\", true);\n * // 移除开头斜杠: \"Windows/System32\"\n *\n * stringToPosix(\"\\\\\\\\server\\\\share\\\\file.txt\");\n * // UNC 路径: \"/server/share/file.txt\"\n *\n * stringToPosix(\"folder\\\\subfolder\\\\file.txt\");\n * // 相对路径: \"folder/subfolder/file.txt\"\n * ```\n */\nexport function stringToPosix (input: string | null | undefined, removeLeadingSlash = false) {\n  if (!isString(input, true)) {\n    return \"\";\n  }\n\n  // 1. 移除 Windows 盘符 (例如 \"C:\", \"d:\") 替换为: 如果盘符后有斜杠，则保留一个正斜杠作为根目录标识；否则不留斜杠\n  let normalized = input.replace(/^[A-Za-z]:([\\\\/])?/, (_, separator) => {\n    // 如果盘符后有分隔符 (如 C:\\ 或 C:/)，则替换为单个正斜杠 \"/\"\n    // 如果盘符后无分隔符 (如 C:file.txt，这是 Windows 相对当前目录的路径)，则替换为空字符串\n    return separator ? \"/\" : \"\";\n  });\n  // 2. 替换所有反斜杠为正斜杠\n  normalized = normalized.replace(/\\\\/g, \"/\");\n  // 3. 合并连续斜杠\n  normalized = normalized.replace(/\\/+/g, \"/\");\n  // 4. 移除开头斜杠\n  if (removeLeadingSlash && normalized.startsWith(\"/\")) {\n    normalized = normalized.substring(1);\n  }\n\n  return normalized;\n}\n","import { isString } from \"../typeof\";\n\n/**\n * 将字符串转换为大写\n * - 将字符串字面量类型转换为其大写形式\n * - 当输入无效时，返回空字符串\n *\n * @param input 待处理字符串\n * @returns 转换后的大写字符串，如果输入无效则返回空字符串\n * @example\n * ```ts\n * stringToUpperCase(\"hello\"); // 类型为 \"HELLO\"\n * stringToUpperCase(someUnknownString); // 类型为 string\n * stringToUpperCase(null); // 类型为 \"\"\n * ```\n */\nexport function stringToUpperCase<const T extends string> (input: T): Uppercase<T>;\nexport function stringToUpperCase (input: unknown): \"\";\nexport function stringToUpperCase<const T extends string> (input: T): Uppercase<T> | \"\" {\n  if (!isString(input, true)) {\n    return \"\";\n  }\n\n  return input.toUpperCase() as Uppercase<T>;\n}\n","import { isString } from \"../typeof\";\n\n/**\n * 字符串分割为数组\n * - 按指定分隔符分割字符串，并转换类型\n *\n * @param input 待处理字符串\n * @param valueType 数组中每一项的类型，默认为 \"number\"\n * @param splitSymbol 分隔符，默认为 `,`\n * @returns 分割后的数组\n * @example\n * ```ts\n * stringToValues(\"1,2,3\"); // [1, 2, 3]\n * stringToValues(\"a-b-c\", \"string\", \"-\"); // [\"a\", \"b\", \"c\"]\n * ```\n */\nexport function stringToValues (input: string | null | undefined, valueType?: \"number\" | undefined, splitSymbol?: string | undefined): number[];\nexport function stringToValues (input: string | null | undefined, valueType: \"string\", splitSymbol?: string | undefined): string[];\nexport function stringToValues (input: string | null | undefined, valueType: \"number\" | \"string\" = \"number\", splitSymbol = \",\"): (number | string)[] {\n  if (!isString(input, true)) {\n    return [];\n  }\n\n  try {\n    const values = input.split(splitSymbol);\n\n    if (valueType === \"number\") {\n      return values.map((d) => Number(d));\n    }\n\n    return values;\n  } catch (error) {\n    return [];\n  }\n}\n","import { isString } from \"../typeof\";\n\n/**\n * 从字符串中裁切掉所有的前缀和后缀字符\n *\n * @param input 待处理字符串\n * @param charsToTrim 裁切字符，默认为 `\" \"`\n * @returns 裁切后的字符串\n * @example\n * ```ts\n * stringTrim(\"  hello  \"); // \"hello\"\n * stringTrim(\"__hello__\", \"_\"); // \"hello\"\n * ```\n */\nexport function stringTrim (input: string | null | undefined, charsToTrim = \" \"): string {\n  if (!isString(input, true)) {\n    return \"\";\n  }\n  const toTrim = charsToTrim.replace(/[\\W]{1}/g, \"\\\\$&\");\n  const regex = new RegExp(`^[${toTrim}]+|[${toTrim}]+$`, \"g\");\n\n  return input.replace(regex, \"\");\n}\n","import { isString, isInteger } from \"../typeof\";\n\n/**\n * 截取字符串\n * - 支持自定义省略符，不会截断在汉字中间（因为JS字符串本身按字符处理）\n *\n * @param input 待处理字符串\n * @param maxLength 最大长度 (包含省略符)\n * @param ellipsis 省略符，默认为 `...`\n * @returns 截取后的字符串\n * @example\n * ```ts\n * stringTruncate(\"hello world\", 8); // \"hello...\"\n * ```\n */\nexport function stringTruncate (input: string, maxLength: number, ellipsis = \"...\") {\n  if (!isString(input, true)) {\n    return \"\";\n  }\n\n  // 将字符串转换为码位数组，以正确处理多字节字符\n  const codePoints = Array.from(input);\n\n  if (!isInteger(maxLength) || maxLength < 0) {\n    return input;\n  }\n\n  // 如果整个字符串（以码位计数）都短于或等于最大长度，则返回原字符串\n  if (codePoints.length <= maxLength) {\n    return input;\n  }\n\n  // 计算可用于原始内容的码位数量\n  const availableLength = maxLength - ellipsis.length;\n\n  if (availableLength <= 0) {\n    return \"\";\n  }\n\n  const truncated = codePoints.slice(0, availableLength).join(\"\");\n\n  return truncated + ellipsis;\n}\n","/**\n * 获取当前时区信息\n *\n * @returns 时区信息对象 (UTC偏移和时区名称)\n * @example\n * ```ts\n * getTimeZone(); // { UTC: \"UTC+8\", timeZone: \"Asia/Shanghai\" }\n * ```\n */\nexport function getTimeZone () {\n  const hour = 0 - new Date().getTimezoneOffset() / 60;\n\n  return {\n    UTC: \"UTC\" + (hour >= 0 ? \"+\" + hour : hour),\n    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,\n  };\n}\n","import { isFunction } from \"../typeof\";\n\nexport type RowKey = \"id\";\nexport type ParentIdKey = \"parentId\";\nexport type ChildrenKey = \"children\";\nexport type Strategy = \"pre\" | \"post\" | \"breadth\";\n\nexport interface BaseCallbackMeta<T> {\n  depth: number;\n  parents?: T[];\n}\n\nexport interface BaseOptions<T, CK extends string> {\n  childrenKey?: CK;\n  strategy?: Strategy;\n  getChildrenKey?: ((row: T, meta: BaseCallbackMeta<T>) => CK) | undefined;\n}\n\nexport interface BaseInnerOptions<T, CK extends string> {\n  childrenKey: CK;\n  parents: T[];\n  depth: number;\n  getChildrenKey?: ((row: T, meta: BaseCallbackMeta<T>) => CK) | undefined;\n}\n\nexport interface QueueItem<T, CK extends string> {\n  queueRow: T;\n  queueOptions: BaseInnerOptions<T, CK>;\n}\n\nexport function getFinalChildrenKey<T, CK extends string> (tree: T, meta: BaseCallbackMeta<T>, options: BaseInnerOptions<T, CK>): CK {\n  if (isFunction(options.getChildrenKey)) {\n    const dynamicChildrenKey = options.getChildrenKey(tree, meta);\n    if (dynamicChildrenKey && dynamicChildrenKey !== null) {\n      return dynamicChildrenKey;\n    }\n  }\n\n  return options.childrenKey;\n}\n","import type { AnyObject } from \"@pawover/types\";\nimport { arrayLast } from \"../array\";\nimport { isArray } from \"../typeof\";\nimport { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey, type QueueItem, getFinalChildrenKey } from \"./types\";\n\nexport type TreeFilterOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;\nexport type TreeFilterInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;\nexport type TreeFilterCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;\n\n// 前置遍历\nfunction preImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeFilterCallback<T>, options: TreeFilterInnerOption<T, CK>): T | undefined {\n  const result = callback(row, options);\n  if (!result) {\n    return undefined;\n  }\n\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n  let newChildren: T[] | undefined;\n\n  if (isArray(children)) {\n    const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n    newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions)).filter((c) => !!c);\n  }\n\n  return { ...row, [finalChildrenKey]: newChildren };\n}\n\n// 子节点优先遍历\nfunction postImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeFilterCallback<T>, options: TreeFilterInnerOption<T, CK>): T | undefined {\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n  let newChildren: T[] | undefined;\n\n  if (isArray(children)) {\n    const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n    newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions)).filter((c) => !!c);\n  }\n\n  const result = callback(row, options);\n  if (!result) {\n    return undefined;\n  }\n\n  return { ...row, [finalChildrenKey]: newChildren };\n}\n\n// 广度优先遍历\nfunction breadthImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeFilterCallback<T>, options: TreeFilterInnerOption<T, CK>): T | undefined {\n  const queue: QueueItem<T, CK>[] = [{ queueRow: row, queueOptions: options }];\n  const resultCache = new WeakMap<T, boolean>();\n  const newNodeCache = new WeakMap<T, T>();\n  const childrenKeyCache = new WeakMap<T, CK>();\n  let result: T;\n  const runQueue = (): T | undefined => {\n    if (queue.length === 0) {\n      return result;\n    }\n\n    const { queueRow, queueOptions } = queue.shift()!;\n    const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);\n    const children = queueRow[finalChildrenKey] as T[] | undefined;\n\n    if (isArray(children)) {\n      const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };\n      const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));\n      queue.push(...subQueueItems);\n    }\n\n    const parent = arrayLast(queueOptions.parents);\n    const isTopNode = queueOptions.depth === 0;\n    const parentResult = parent && resultCache.get(parent);\n\n    if (!isTopNode && !parentResult) {\n      return runQueue();\n    }\n\n    const callbackResult = callback(queueRow, queueOptions);\n    if (isTopNode && !callbackResult) {\n      return undefined;\n    }\n\n    const newNode = { ...queueRow, [finalChildrenKey]: undefined };\n    if (isTopNode) {\n      result = newNode;\n    }\n\n    resultCache.set(queueRow, callbackResult);\n    newNodeCache.set(queueRow, newNode);\n    childrenKeyCache.set(queueRow, finalChildrenKey);\n\n    if (callbackResult && parent) {\n      const parentNewNode = newNodeCache.get(parent);\n      const parentChildrenKey = childrenKeyCache.get(parent);\n\n      if (parentNewNode && parentChildrenKey) {\n        if (!parentNewNode[parentChildrenKey]) {\n          (parentNewNode[parentChildrenKey] as T[]) = [];\n        }\n        parentNewNode[parentChildrenKey].push(newNode);\n      }\n    }\n\n    return runQueue();\n  };\n\n  return runQueue();\n}\n\nconst strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };\n\n/**\n * 过滤树节点\n * - 返回新的树结构，包含所有回调返回 true 的节点\n * - 如果父节点被过滤，则其子节点也会被过滤 (pre 策略下)\n *\n * @param tree 树结构数据\n * @param callback 回调函数\n * @param options 配置项 (childrenKey, strategy等)\n * @returns 过滤后的树结构数组\n * @example\n * ```ts\n * const tree = [{ id: 1, visible: true, children: [{ id: 2, visible: false }] }];\n * treeFilter(tree, (node) => node.visible);\n * // [{ id: 1, visible: true, children: [] }]\n * ```\n */\nexport function treeFilter<T extends AnyObject, CK extends string = ChildrenKey> (tree: T[], callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T[];\nexport function treeFilter<T extends AnyObject, CK extends string = ChildrenKey> (tree: T, callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T;\nexport function treeFilter<T extends AnyObject, CK extends string = ChildrenKey> (tree: T | T[], callback: TreeFilterCallback<T>, options: TreeFilterOptions<T, CK> = {}): T | T[] {\n  const { childrenKey = \"children\", strategy = \"pre\", getChildrenKey } = options;\n  const traversalMethod = strategies[strategy];\n  const innerOptions = { childrenKey: childrenKey as CK, depth: 0, parents: [], getChildrenKey };\n\n  return isArray(tree)\n    ? tree.map((row) => traversalMethod(row, callback, innerOptions)).filter((t) => !!t)\n    : traversalMethod(tree, callback, innerOptions) || [];\n}\n","import type { AnyObject } from \"@pawover/types\";\nimport { isArray } from \"../typeof\";\nimport { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey, type QueueItem, getFinalChildrenKey } from \"./types\";\n\nexport type TreeFindOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;\nexport type TreeFindInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;\nexport type TreeFindCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;\n\nconst strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };\n\n// 前置深度优先遍历\nfunction preImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeFindCallback<T>, options: TreeFindInnerOption<T, CK>): T | undefined {\n  const callbackResult = callback(row, options);\n  if (callbackResult) {\n    return row;\n  }\n\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n  if (isArray(children)) {\n    for (const child of children) {\n      const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n      const result = preImpl(child, callback, nextLevelOptions);\n      if (result) {\n        return result;\n      }\n    }\n  }\n\n  return undefined;\n}\n\n// 后置深度优先遍历\nfunction postImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeFindCallback<T>, options: TreeFindInnerOption<T, CK>): T | undefined {\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n  if (isArray(children)) {\n    for (const child of children) {\n      const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n      const result = postImpl(child, callback, nextLevelOptions);\n      if (result) {\n        return result;\n      }\n    }\n  }\n\n  const callbackResult = callback(row, options);\n  if (callbackResult) {\n    return row;\n  }\n\n  return undefined;\n}\n\n// 广度优先遍历\nfunction breadthImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeFindCallback<T>, options: TreeFindInnerOption<T, CK>): T | undefined {\n  const queue: QueueItem<T, CK>[] = [{ queueRow: row, queueOptions: options }];\n  const runQueue = (): T | undefined => {\n    if (queue.length === 0) {\n      return undefined;\n    }\n    const { queueRow, queueOptions } = queue.shift()!;\n    const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);\n    const children = queueRow[finalChildrenKey] as T[] | undefined;\n\n    if (isArray(children)) {\n      const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };\n      const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));\n      queue.push(...subQueueItems);\n    }\n\n    const callbackResult = callback(queueRow, queueOptions);\n    if (callbackResult) {\n      return queueRow;\n    }\n\n    return runQueue();\n  };\n\n  return runQueue();\n}\n\n\n/**\n * 查找树节点\n * - 返回第一个回调返回 true 的节点\n *\n * @param tree 树结构数据\n * @param callback 回调函数\n * @param options 配置项\n * @returns 找到的节点，未找到则返回 undefined\n * @example\n * ```ts\n * const tree = [{ id: 1, children: [{ id: 2 }] }];\n * treeFind(tree, (node) => node.id === 2); // { id: 2, ... }\n * ```\n */\nexport function treeFind<T extends AnyObject, CK extends string = ChildrenKey> (tree: T | T[], callback: TreeFindCallback<T>, options: TreeFindOptions<T, CK> = {}): T | undefined {\n  const { childrenKey = \"children\", strategy = \"pre\", getChildrenKey } = options;\n  const traversalMethod = strategies[strategy];\n  const innerOptions = { childrenKey: childrenKey as CK, depth: 0, parents: [], getChildrenKey };\n\n  if (isArray(tree)) {\n    for (const row of tree) {\n      const result = traversalMethod<T, CK>(row, callback, innerOptions);\n      if (result) {\n        return result;\n      }\n    }\n\n    return undefined;\n  }\n\n  return traversalMethod<T, CK>(tree, callback, innerOptions);\n}\n","import type { AnyObject } from \"@pawover/types\";\nimport { isArray } from \"../typeof\";\nimport { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey, type QueueItem, getFinalChildrenKey } from \"./types\";\n\nexport type TreeForeachOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;\nexport type TreeForeachInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;\nexport type TreeForeachCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => void;\n\nconst strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };\n\n// 前置遍历\nfunction preImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeForeachCallback<T>, options: TreeForeachInnerOption<T, CK>) {\n  callback(row, options);\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n\n  if (isArray(children)) {\n    const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n    for (const child of children) {\n      preImpl(child, callback, nextLevelOptions);\n    }\n  }\n}\n\n// 后置遍历\nfunction postImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeForeachCallback<T>, options: TreeForeachInnerOption<T, CK>) {\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n\n  if (isArray(children)) {\n    const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n    for (const child of children) {\n      postImpl(child, callback, nextLevelOptions);\n    }\n  }\n  callback(row, options);\n}\n\n// 广度优先遍历\nfunction breadthImpl<T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeForeachCallback<T>, options: TreeForeachInnerOption<T, CK>) {\n  const queue: QueueItem<T, CK>[] = [{ queueRow: row, queueOptions: options }];\n  const runQueue = () => {\n    if (queue.length === 0) {\n      return;\n    }\n\n    const { queueRow, queueOptions } = queue.shift()!;\n    const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);\n    const children = queueRow[finalChildrenKey] as T[] | undefined;\n\n    if (isArray(children)) {\n      const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };\n      const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));\n      queue.push(...subQueueItems);\n    }\n    callback(queueRow, queueOptions);\n    runQueue();\n  };\n\n  runQueue();\n}\n\n/**\n * 遍历树节点\n *\n * @param tree 树结构数据\n * @param callback 回调函数\n * @param options 配置项\n * @example\n * ```ts\n * const tree = [{ id: 1, children: [{ id: 2 }] }];\n * const ids: number[] = [];\n * treeForEach(tree, (node) => ids.push(node.id));\n * // ids: [1, 2] (pre-order default)\n * ```\n */\nexport function treeForEach<T extends AnyObject, CK extends string = ChildrenKey> (tree: T | T[], callback: TreeForeachCallback<T>, options: TreeForeachOptions<T, CK> = {}): void {\n  const { childrenKey = \"children\", strategy = \"pre\", getChildrenKey } = options;\n  const traversalMethod = strategies[strategy];\n  const innerOptions = { childrenKey: childrenKey as CK, depth: 0, parents: [], getChildrenKey };\n\n  if (isArray(tree)) {\n    for (const row of tree) {\n      traversalMethod<T, CK>(row, callback, innerOptions);\n    }\n  } else {\n    traversalMethod<T, CK>(tree, callback, innerOptions);\n  }\n}\n","import type { AnyObject, TreeLike } from \"@pawover/types\";\nimport { arrayLast } from \"../array\";\nimport { isArray } from \"../typeof\";\nimport { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey, type QueueItem, getFinalChildrenKey } from \"./types\";\n\n\nexport type TreeMapOptions<T extends AnyObject, CK extends string> = BaseOptions<T, CK>;\nexport type TreeMapInnerOption<T extends AnyObject, CK extends string> = BaseInnerOptions<T, CK>;\nexport type TreeMapCallback<R extends AnyObject, T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => R;\n\nconst strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };\n\n// 前置遍历\nfunction preImpl<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeMapCallback<R, T>, options: TreeMapInnerOption<T, CK>): TreeLike<R, CK> {\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const result = callback(row, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n  let newChildren: TreeLike<R, CK>[] | undefined;\n\n  if (isArray(children)) {\n    const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n    newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions));\n  }\n\n  return { ...result, [finalChildrenKey]: newChildren };\n}\n\n// 子节点优先遍历\nfunction postImpl<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeMapCallback<R, T>, options: TreeMapInnerOption<T, CK>): TreeLike<R, CK> {\n  const finalChildrenKey = getFinalChildrenKey(row, options, options);\n  const children = row[finalChildrenKey] as T[] | undefined;\n  let newChildren: TreeLike<R, CK>[] | undefined;\n\n  if (isArray(children)) {\n    const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };\n    newChildren = children.map((c) => postImpl(c, callback, nextLevelOptions));\n  }\n  const result = callback(row, options);\n\n  return { ...result, [finalChildrenKey]: newChildren };\n}\n\n// 广度优先遍历\nfunction breadthImpl<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey> (row: T, callback: TreeMapCallback<R, T>, options: TreeMapInnerOption<T, CK>): TreeLike<R, CK> {\n  const queue: QueueItem<T, CK>[] = [{ queueRow: row, queueOptions: options }];\n  const cache = new WeakMap<T, TreeLike<R, CK>>();\n  const childrenKeyCache = new WeakMap<T, CK>();\n  let result: TreeLike<R, CK>;\n\n  const runQueue = () => {\n    if (queue.length === 0) {\n      return result;\n    }\n    const { queueRow, queueOptions } = queue.shift()!;\n    const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);\n    const children = queueRow[finalChildrenKey] as T[] | undefined;\n\n    if (isArray(children)) {\n      const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };\n      const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));\n      queue.push(...subQueueItems);\n    }\n    const res = callback(queueRow, queueOptions);\n    cache.set(queueRow, res);\n    childrenKeyCache.set(queueRow, finalChildrenKey);\n\n    // breadth 模式的子节点一定晚于父节点执行，所以可以在cache中找到父节点的生成物\n    const parent = arrayLast(queueOptions.parents);\n    if (parent) {\n      const newParent = cache.get(parent);\n      const parentChildrenKey = childrenKeyCache.get(parent);\n\n      if (newParent && parentChildrenKey) {\n        if (newParent[parentChildrenKey]) {\n          newParent[parentChildrenKey].push(res);\n        } else {\n          (newParent[parentChildrenKey] as TreeLike<R, CK>[]) = [res];\n        }\n      }\n    }\n    // 这棵树的顶点\n    if (queueOptions.depth === 0) {\n      result = res;\n    }\n\n    return runQueue();\n  };\n\n  return runQueue();\n}\n\n/**\n * 映射树节点\n * - 返回新的树结构，保持层级关系\n *\n * @param tree 树结构数据\n * @param callback 回调函数 (返回映射后的节点内容)\n * @param options 配置项\n * @returns 映射后的树结构数组\n * @example\n * ```ts\n * const tree = [{ id: 1, val: 10, children: [{ id: 2, val: 20 }] }];\n * treeMap(tree, (node) => ({ ...node, val: node.val * 2 }));\n * // [{ id: 1, val: 20, children: [{ id: 2, val: 40 }] }]\n * ```\n */\nexport function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey> (tree: T[], callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>[];\nexport function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey> (tree: T, callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>;\nexport function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey> (tree: T | T[], callback: TreeMapCallback<R, T>, options: TreeMapOptions<T, CK> = {}): TreeLike<R, CK> | TreeLike<R, CK>[] {\n  const { childrenKey = \"children\", strategy = \"pre\", getChildrenKey } = options;\n  const traversalMethod = strategies[strategy];\n  const innerOptions = { childrenKey: childrenKey as CK, depth: 0, parents: [], getChildrenKey };\n\n  return isArray(tree)\n    ? tree.map((row) => traversalMethod<R, T, CK>(row, callback, innerOptions))\n    : traversalMethod<R, T, CK>(tree, callback, innerOptions);\n}\n","import type { AnyObject, TreeLike } from \"@pawover/types\";\nimport { isNull, isUndefined } from \"../typeof\";\nimport type { ChildrenKey, ParentIdKey, RowKey } from \"./types\";\n\nexport interface RowsToTreeOptions<\n  RK extends string = RowKey,\n  PK extends string = ParentIdKey,\n  CK extends string = ChildrenKey,\n> {\n  rowKey?: RK;\n  parentIdKey?: PK;\n  childrenKey?: CK;\n}\n\n/**\n * 行结构 转 树结构\n * - 将平铺的数组转换为树形结构\n *\n * @param rows 行数据数组\n * @param options 配置项\n * @returns 树结构数组\n * @example\n * ```ts\n * const rows = [\n *   { id: 1, parentId: null },\n *   { id: 2, parentId: 1 },\n * ];\n * rowsToTree(rows);\n * // [{ id: 1, parentId: null, children: [{ id: 2, parentId: 1 }] }]\n * ```\n */\nexport function rowsToTree<\n  T extends AnyObject = AnyObject,\n  CK extends string = ChildrenKey,\n  R = TreeLike<T, CK>,\n  RK extends string = RowKey,\n  PK extends string = ParentIdKey,\n> (rows: T[], options?: RowsToTreeOptions<RK, PK, CK> | undefined): R[] {\n  const { parentIdKey = \"parentId\", rowKey = \"id\", childrenKey = \"children\" } = options || {};\n  const result: R[] = [];\n  const map = new Map<PropertyKey, T>();\n\n  for (const row of rows) {\n    const id = row[rowKey];\n\n    if (!map.get(id)) {\n      map.set(id, row);\n    }\n  }\n\n  for (const row of rows) {\n    const parentId = row[parentIdKey];\n    const parent = map.get(parentId);\n\n    if (!parent || !parentId) {\n      result.push(row);\n\n      continue;\n    }\n\n    const siblings = parent[childrenKey];\n\n    if (isNull(siblings) || isUndefined(siblings)) {\n      parent[childrenKey] = [row] as T[CK];\n    } else if (Array.isArray(siblings)) {\n      siblings.push(row);\n    } else {\n      const message = `The key \"${childrenKey.toString()}\" in parent item is not an array.`;\n      throw new Error(message);\n    }\n  }\n\n  return result;\n}\n","import type { AnyObject } from \"@pawover/types\";\nimport type { SetOptional } from \"type-fest\";\nimport { treeForEach, type TreeForeachOptions } from \"./treeForEach\";\nimport type { ChildrenKey } from \"./types\";\n\ntype TreeToRowsOptions<T extends AnyObject, CK extends string = ChildrenKey> = TreeForeachOptions<T, CK>;\n\n/**\n * 树结构 转 行结构\n * - 将树形结构扁平化为数组\n *\n * @param tree 树结构数据 (单个节点或节点数组)\n * @param options 配置项\n * @returns 扁平化后的数组\n * @example\n * ```ts\n * const tree = [{ id: 1, children: [{ id: 2 }] }];\n * treeToRows(tree);\n * // [{ id: 1, children: undefined }, { id: 2, children: undefined }]\n * ```\n */\nexport function treeToRows<\n  T extends AnyObject,\n  CK extends string = ChildrenKey,\n  R extends AnyObject = SetOptional<T, CK>,\n> (tree: T | T[], options: TreeToRowsOptions<T, CK> = {}): R[] {\n  const { childrenKey = \"children\" } = options;\n  const result: R[] = [];\n\n  if (!tree) {\n    return result;\n  }\n\n  treeForEach(tree, (t) => result.push({ ...t, [childrenKey]: undefined }), options);\n\n  return result;\n}\n"],"mappings":"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"}

package/metadata.json

@@ -90,8 +90,10 @@
     "stringReplace",
     "stringTemplate",
     "stringToJson",
+    "stringToLowerCase",
     "stringToNumber",
     "stringToPosix",
+    "stringToUpperCase",
     "stringToValues",
     "stringTrim",
     "stringTruncate",
@@ -162,13 +164,6 @@
     "thunder",
     "unknown"
   ],
-  "enums": [
-    "BREAK_POINT_TOKEN_ENUM",
-    "DATE_FORMAT",
-    "MIME",
-    "THEME_ENUM",
-    "THEME_MODE_ENUM"
-  ],
   "hooks": {
     "alova": [
       "useAlovaPagination",

package/package.json

@@ -4,7 +4,7 @@
   "description": "pawover's kit",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.0-beta.40",
+  "version": "0.0.0-beta.41",
   "packageManager": "pnpm@10.28.2",
   "engines": {
     "node": ">=22.20.0"