@da.li/core-libs/dist/base.d.ts

大沥网络函数库是大沥网络提供的一个公共 TypeScript 函数库，封装了基础操作、缓存、加密、文件处理、HTTP 请求等常用功能模块，旨在提高开发效率。

import { D as Dict, d as ITree, f as ITreeMap, I as IList, e as IListMap, A as Action, F as Func, N as NVs } from './types-Cultc70v.js';
export { b as AsyncAction, a as AsyncFunc, M as MaybePromise, c as Nullable } from './types-Cultc70v.js';
export { C as ConsoleEcho, c as createConsoleEcho } from './index-B8nzlgqP.js';
export { c as createEventBus } from './index-BvIGCbO1.js';
import 'chalk';

var name = "@da.li/core-libs";
var title = "大沥网络函数库";
var version = "1.25.1227";
var description = "大沥网络函数库是大沥网络提供的一个公共 TypeScript 函数库，封装了基础操作、缓存、加密、文件处理、HTTP 请求等常用功能模块，旨在提高开发效率。";
var homepage = "http://www.hunandali.com/";

/** 应用信息 */

/** 默认 Logo */
declare const LOGO = "data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAyNCAxMDI0IiB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgd2lkdGg9IjEwMjQiIGhlaWdodD0iMTAyNCIgc3R5bGU9ImJhY2tncm91bmQ6ICNGRkZGRkYiPjxwYXRoIGQ9Ik03ODguNzUwMDggMzkwLjcwMzM2TDcwOS41ODg0OCA0NC43NjY3MmwtOC4wNzU1MiA0Ljg4OTYtNTY0LjYzMzYgMzQxLjkxODcyIDMyMi42NzM5MiA1ODYuMzM0NzIgMjI1LjUzODU2LTI0Ny4zMzU2OGgyNC44MDM4NGwtMjYyLjcwNzIgMjkzLjQyNDY0TDcyLjM3ODg4IDM3NC44MDk2IDcyMS41NjkyOCAwbDg1LjgxODg4IDM5MC43MDMzNmgtMTguNjM2OHogbS02MjYuODU5NTIgNy4zNjUxMkw3MDQuNjU2NjQgNjMuMTc1NjhsNzYuMjIxNDQgMzI3LjUyNzY4aC0yMi4wMDcwNEw2OTEuMjU4ODggMTEzLjExNDg4IDIyNS43MzE4NCA0MTQuNjEzNzZsMjUyLjYyMDggNDkzLjA3Nzc2IDE2Ni4yODk5Mi0xNzcuMTE3NDRoMjkuODcwMDhjLTg2LjQ0NjA4IDk0LjA3NDg4LTE4My41ODUyOCAxOTkuNzgyNC0yMDkuODg4IDIyOC40MDgzMkwxNjEuODkwNTYgMzk4LjA2ODQ4eiIgZmlsbD0iIzAwNUVBNyI+PC9wYXRoPjxwYXRoIGQ9Ik01NDYuOTUwNCA2OTMuNjcwNGwtNjguOTg2ODgtMjI0LjEwNDk2IDYuMjM2MTYgMC4xMzA1NiA0MzYuMDUxMiA5LjExMzYgOS4wNjYyNCA0NDIuMTEwNzItMjEwLjc2NDgtNjcuMDIyMDgtMTQuMTk1MiA4LjE5NTg0IDI0Ny4yNjI3MiA4MS4xMTM2VjQ0Ny45MDRINDU2LjMxODcybDc5Ljk2OTI4IDI1MS45MjE5MiAxMC42NjI0LTYuMTU2OHogbTM2MS4xMzQwOC0yMDIuODg1MTJjLTc3LjE4MDE2LTIuMjU1MzYtNDIxLjIxNzI4LTEyLjMxNjE2LTQyMS4yMTcyOC0xMi4zMTYxNmw2NC41OTEzNiAyMTIuNTk3NzYgMTIuNTkxMzYtNy4yNzE2OC01My4wMTYzMi0xODEuMTc2MzIgMzY1Ljk4NTI4IDE4LjcyNzY4IDE4LjM0MzY4IDM2NS42MDY0LTE1My42Njc4NC00Ni40MTY2NC0xNy4wOTE4NCA5Ljg2ODggMTk1LjU1ODQgNjEuMzU4MDhzLTkuOTUyLTM0Ni44NDE2LTEyLjA3NjgtNDIwLjk3NzkyeiIgZmlsbD0iI0YwODMyMSI+PC9wYXRoPjwvc3ZnPg==";
/** 是否调试模式 */
declare const DEBUG: boolean;
/** 是否测试环境 */
declare const TEST: boolean;
/** 是否服务器端运行 */
declare const SERVERMODE: boolean;
/** 窗口调整尺寸防抖时间 (ms) */
declare const DEBOUNCE_WINDOW_RESIZE = 300;
/**
 * 默认缓存最大时长(天)
 * 注意：服务端的缓存位于内容中；客户端的缓存使用 localforage
 */
declare const CACHE_TIME_MAX: number;

/** 分析数据的类型名称 */
declare function typeName(value: any): string;
/** 判断是否数组 */
declare const isArray: (arg: any) => arg is any[];
/** 判断是否 Symbol */
declare const isSymbol: (value: any) => value is symbol;
/** 判断是否 Object 对象，仅 {}，不包含 [] null 等对象 */
declare const isObject: (value: any) => value is object;
/**
 * 否是原始类型
 * 原始类型: number, string, boolean, symbol, bigint, undefined, null
 */
declare const isPrimitive: (value: any) => boolean;
/** 是否函数 */
declare const isFunction: (value: any) => value is Function;
/** 是否函数 isFunction 的简写 */
declare const isFn: (value: any) => value is Function;
/**
 * 是否异步函数
 * 这实际上是一个最佳猜测的 Promise 检查。你可能应该使用 Promise.resolve(value) 来确保百分之百确定你正在正确处理它
 */
declare const isPromise: (value: any) => value is Promise<any>;
/** 是否异步函数  async function (){} */
declare const isAsync: (value: any) => boolean;
/** 是否字符串 */
declare const isString: (value: any) => value is string;
/** 是否数值 */
declare const isNumber: (value: any) => value is number;
/** 是否日期对象 */
declare const isDate: (value: any) => value is Date;
/** 是否空值，空对象，空数组，空字符串，空函数，空 Symbol */
declare const isEmpty: (value: any) => boolean;
/** 判断是否 Boolean */
declare const isBoolean: (value: any) => value is boolean;
/** 判断是否正则表达式 */
declare const isRegExp: (value: any) => value is RegExp;
/** 判断是否正则表达式 isRegExp 的缩写 */
declare const isReg: (value: any) => value is RegExp;
/** 判断是否 null 或者 undefined */
declare const isNil: (value: any) => value is null | undefined;
/**
 * 判断是否 NaN
 * 一个 NaN 原始值是唯一一个不等于自身的值。
 */
declare const isNaN: (value: any) => boolean;
/**
 * 综合判断一个目标是否为 Vue 组件（涵盖实例和配置对象）。
 *
 * 这个函数会按顺序进行以下检查：
 * 1. 检查目标是否为一个有效的对象。
 * 2. 检查目标是否为一个 Vue 2 或 Vue 3 的组件实例（通过内部标志 `_isVue` 或 `__isVue`）。
 * 3. 如果不是实例，则通过启发式方法检查它是否像一个组件的配置对象（检查 `setup`, `render`, `template` 属性）。
 *
 * @param input - 需要被检查的目标。
 * @returns 如果判断为 Vue 组件，则返回 true，否则返回 false。
 */
declare const isVueComponent: (input: any) => boolean;
/** 判断是否不为空，非空对象，非空数组，非空字符串，非空函数，非空 Symbol */
declare const notEmpty: (value: any) => boolean;
/** 判断是否 Object 对象且对象存在内容 */
declare const hasObject: (value: any) => value is object;
/** 对象是否包含指定的属性 */
declare const hasObjectName: (value: any, name: string) => boolean;
/** 数组是否存在内容 */
declare const hasArray: (value: any) => boolean;
/** 判断是否字符串，且字符串存在内容 */
declare const hasString: (value: any) => boolean;

/** 两个项目是否相同 */
declare const isEqual: <TType>(x: TType, y: TType) => boolean;
/**
 * 正则表达式判断
 * @param val 要检测的值
 * @param reg 正则表达式
 * @returns	  是否匹配
 */
declare function isMatch(val: any, reg: RegExp): boolean;
/** 判断是否为手机号码 */
declare function isMobile(val: number | string): boolean;
/** 判断是否为车牌 */
declare function isCar(val: string): boolean;
/** 判断是否为电话号码 */
declare function isPhone(val: string): boolean;
/** 判断是否为 Email */
declare function isEmail(val: string): boolean;
/** 判断是否为网址，必须含 http / https / ftp */
declare function isUrl(val: string): boolean;
/** 判断是否为全网址，http / https / ftp 可选，且可以带路径与参数 */
declare function isFullUrl(val: string): boolean;
/** 判断是否为网址，仅支持 http / https */
declare function isHttp(val: string): boolean;
/** 判断是否为 GUID */
declare function isGuid(val: string): boolean;
/** 判断是否为汉字 */
declare function isChinese(val: string): boolean;
/** 判断是否为英文字母 */
declare function isEnglish(val: string): boolean;
/** 判断是否为名称，即：英文开头的字符串（仅包含半角字母、数字、下划线与横线），类似于账号名，最少两个字符 */
declare function isName(val: string, len?: number): boolean;
/** 判断是否为 IPv4 字符串 */
declare function isIP(val: string): boolean;
/** 判断是否为有效的 JSON 字符串 */
declare function isJSON(val: string): boolean;
/** 是否整数 */
declare const isInt: (value: any) => value is number;
/** 是否浮点数 */
declare const isFloat: (value: any) => value is number;

/**
 * 字符串模板替换
 * 用于在模板字符串中通过名称替换数据。默认表达式会寻找 {name} 以识别名称。
 *
 * template('Hello, {name}', { name: 'ray' })				// => Hello, ray
 * template('Hello, <name>', { name: 'ray' }, /<(.+?)>/g)		// => Hello, ray
 */
declare const template: (str: string, data: Record<string, any>, regex?: RegExp) => string;
/**
 * 从给定的字符串中修剪所有前缀和后缀字符。
 * 类似于内置的 trim 函数，但接受您希望修剪的其他字符并修剪多个字符。
 * 默认移除回车、换行、制表符和全半角空格。
 *
 * trim('  hello ') 						// => 'hello'
 * trim('__hello__', '_') 					// => 'hello'
 * trim('/repos/:owner/:repo/', '/')		// => 'repos/:owner/:repo'
 * trim('222222__hello__1111111', '12_') 	// => 'hello'
 */
declare const trimEx: (str: string | null | undefined, charsToTrim?: string) => string;
/**
 * 文本转换成实际类型值。
 * 如果存在 splitter 则按照分隔符分割成数组再转换。
 * @param value 文本值
 * @param splitter 是否分割成数组，不设置则直接返回
 * @returns 返回任何有效的类型值或者值数组
 */
declare const string2Value: (value: string, splitter?: string | RegExp) => any | any[];
/**
 * 按指定长度截取字符串
 * @param str	待截取的字符串
 * @param len	截取长度，0 不截取
 * @param eli	省略部分替换的文本，默认为省略号
 * @param mode	截取方式：0 保留两头；1 保留左侧；2 保留右侧
 * @returns		返回截取后的字符串
 */
declare function stringCut(str: string, len?: number, eli?: string, mode?: number): string;
/**
 * 清除字符串中的任何 html 标签，并移除首尾的空白字符后截取指定长度文本，省略部分用省略号代替
 * @param str	待处理的字符串
 * @param len	截取长度，0 不截取
 * @param mode	截取方式:0 保留两头,1 保留左侧 ,2 保留右侧
 * @returns		返回截取后的字符串
 */
declare function stringClear(str: string, len: number, mode?: number): string;
/**
 * 清除字符串中的任何 html 标签，并移除首尾的空白字符
 * @param str	待处理的字符串
 * @returns 	处理后的字符串
 */
declare function htmlClear(str: string): string;
/** 编码 HTML 符号*/
declare function htmlEncode(str: string): string;
/**
 *	判断原始文本中是否存在目标文本（使用 * 作为通配符，匹配任意字符）
 *	1. *xxx 匹配以 xxx 结尾的文本
 *	2. xxx* 匹配以 xxx 开头的文本
 *	3. *xxx* 匹配包含 xxx 的文本
 *	4. xxx*yyy 匹配以 xxx 开头且以 yyy 结尾的文本
 *	5. xxx 匹配完全匹配的文本
 *	6. 使用括号包裹的文本会是为正则表达式匹配

 * @param source 		原始文本
 * @param target 		目标文本
 * @param ingoreCase 	是否忽略大小写，默认忽略
 */
declare function stringIncludes(source: string, target: string, ingoreCase?: boolean): boolean;

/** 清除对象中指定条件的值，默认 null 或者 undefined */
declare const objEmpty: <RemovedKeys extends string, T>(obj: T, filter?: (value: any) => boolean) => Omit<T, RemovedKeys>;
/**
 * 深度去除对象中的空值，不指定则移除所有 null 和 undefined 以及空文本
 * @param obj 		要处理的数据
 * @param filter	空值过滤条件，默认空内容与空文本
 * @param deep 		是否递归处理
 */
declare const objClear: <RemovedKeys extends string, T>(obj: T, filter?: (value: any) => boolean, deep?: boolean) => Omit<T, RemovedKeys> | undefined;
/**
 * 从对象或者数组中获取指定项的值
 * @param value 			要检索的对象/数组
 * @param path 				要解析的属性路径，只是文本或者数组。如：a.b[0].c.2 或者 ['a','b',2]等
 * @param defaultValue		默认值，解析的结果为 undefined / null 时返回这个值
 * @returns					获取的结果
 */
declare const get: <TDefault = unknown>(value: any, path: string | string[], defaultValue?: TDefault) => TDefault;
/**
 * 向对象或者数组中设置指定项的值
 * @param initial 	要检索的对象/数组
 * @param path 		要解析的属性路径，只是文本或者数组。如：a.b[0].c.2 或者 ['a','b',2]等
 * @param value		要设置的值
 *
 * @example
 * set({}, 'name', 'ra') // => { name: 'ra' }
 * set({}, 'cards[0].value', 2) // => { cards: [{ value: 2 }] }
 */
declare const set: <T extends object, K>(initial: T, path: string | string[], value: K) => T;
/**
 * 向对象或者数组中移除指定项
 * @param initial 	要检索的对象/数组
 * @param path 		要解析的属性路径，只是文本或者数组。如：a.b[0].c.2 或者 ['a','b',2]等
 */
declare const remove: (value: any, path: string | string[]) => any;
/**
 * 对象或者数组中是否存在指定项
 * @param initial 	要检索的对象/数组
 * @param path 		要解析的属性路径，只是文本或者数组。如：a.b[0].c.2 或者 ['a','b',2]等
 */
declare const has: (value: any, path: string | string[]) => boolean;
/**
 * 遍历的简化操作
 * @param obj 		要遍历的对象或者数组
 * @param action 	遍历操作，参数一：value；参数二：key / index；参数三：对象本身
 */
declare const each: (obj: Dict | any[], action: (value: any, key: string | number, obj: any) => void) => boolean;
/**
 * 遍历的简化异步操作
 * @param obj 		要遍历的对象或者数组
 * @param action 	遍历操作，参数一：value；参数二：key / index；参数三：对象本身
 */
declare const eachSync: (obj: Dict | any[], action: (value: any, key: string | number, obj: any) => Promise<void>) => Promise<boolean>;
/**
 * 迭代执行的简化操作。每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。
 * @param obj 			要遍历的对象或者数组
 * @param callbackfn 	为每个元素执行的函数。其返回值将作为下一次调用 callbackFn 时的 accumulator 参数。对于最后一次调用，返回值将作为 reduce() 的返回值。
 * @param initialValue 	第一次调用回调时初始化 previousValue 的值。如果指定了 initialValue，则 callbackFn 从数组中的第一个值作为 currentValue 开始执行。如果没有指定 initialValue，则 previousValue 初始化为数组中的第一个值，并且 callbackFn 从数组中的第二个值作为 currentValue 开始执行。在这种情况下，如果数组为空（没有第一个值可以作为 previousValue 返回），则会抛出错误。
 */
declare const reduce: <T = Dict | any[], TDefault = any>(obj: T, callbackfn: (previousValue: TDefault, currentValue: any, currentIndex: number | string, data: T) => any, initialValue?: TDefault) => any;
/**
 * 迭代计算
 * @param obj 			要遍历的对象或者数组
 * @param value 		获取计算值的方法，参数一：value；参数二：key / index；参数三：对象本身。如果获取的非数值，则返回 defaultValue
 * @param math 			计算方法，最大值，最小值，总和，平均值。默认为总和
 * @param defaultValue 	当 value 分析非有效数值时，使用默认值，如果未设置则 min 取 Number.MAX_SAFE_INTEGER，max 取 Number.MIN_SAFE_INTEGER，其他情况取 0
 */
declare const math: (obj: Dict | any[], value: (value: any, key: string | number, obj: any) => number, math?: "max" | "min" | "sum" | "avg", defaultValue?: number | undefined) => any;
/**
 * 测试所有元素是否都能通过指定函数的测试。它返回一个布尔值
 * @param obj 			要遍历的对象或者数组
 * @param callbackfn 	为每个元素执行的函数。
 */
declare const every: <T = Dict | any[]>(obj: T, callbackfn: (element: any, index: number | string, data: T) => boolean) => boolean;
/**
 * 测试所有元素至少有一个元素能通过指定函数的测试。它返回一个布尔值
 * @param obj 			要遍历的对象或者数组
 * @param callbackfn 	为每个元素执行的函数。
 */
declare const some: <T = Dict | any[]>(obj: T, callbackfn: (element: any, index: number | string, data: T) => boolean) => boolean;
/** 将对象转换成数组 */
declare const toArray: <TValue, TKey extends string | number | symbol, KResult>(obj: Record<TKey, TValue>, toItem: (key: TKey, value: TValue) => KResult) => KResult[];
/**
 * 将对象、数组转换成 html 代码
 * @param value 		需要转换的对象、数组
 * @param maxDeep 		转换最大递归深度，默认 10 层
 * @param skipFunction 	是否过滤函数
 * @param skipEmpty 	忽略空值项目
 * @param skipUnderline 忽略下划线开头的键
 * @param enSort 		结果是否排序
 * @returns 			html 代码字符串
 */
declare const toHtml: (value: any, maxDeep?: number, skipFunction?: boolean, skipEmpty?: boolean, skipUnderline?: boolean, enSort?: boolean) => string;
/**
 * 使用 JSON 反序列化文本为对象，如果原始值本身为对象或者数组则直接返回
 * @param str JSON 字符串
 * @returns
 */
declare const toJSON: (source: any) => object | undefined;
/**
 * 克隆对象
 * @param obj 		目标对象
 * @param deep 		是否深拷贝，默认 true
 */
declare const clone: <T>(obj: T, deep?: boolean, hash?: WeakMap<WeakKey, any>) => any;
/** 合并对象/数组，第一个参数为原始被合并的对象/数组，后续参数为用于合并的值 */
declare const merge: <T = object | Dict | any[]>(...args: T[]) => T | undefined;
/**
 * 多层对象转换成单层对象，深层键使用 小数点 间隔
 * @param obj 			要处理的对象
 * @param keepSource	是否同时保留原始对象
 * @returns 			单层对象
 */
declare const toSingleObject: (obj: any, keepSource?: boolean) => Dict;
/**
 * 将单层对象转换成深层对象，其中包含小数点的键将递归到深层
 * @param obj 			要处理的对象
 * @param keepSource 	是否同时保留原始对象
 * @param keepMainKey 	是否同时保留同名父级键。当出现 a 与 a.b 时，当 b 转换到 a 的对象时会将原始 a 的值覆盖，此时如果保留就使用空白键来避免覆盖
 */
declare function toDeepObject(obj: Dict, keepSource?: boolean, keepMainKey?: boolean): Dict;

/**
 * 大小比较函数
 * @param a 		第一个项目
 * @param b 		第二个项目
 * @param getter 	比较的项目
 */
declare const compare: <T extends Dict = any>(a: T, b: T, getter?: string | ((item: T) => number | string | undefined) | undefined) => any;
/**
 * 排序
 * @param array     要操作的数组
 * @param getter    排序函数
 * @param desc      是否降序
 * @returns         排序后的数组
 */
declare const sort: <T>(array: Array<T>, getter: (item: T) => number | string | undefined, desc?: boolean) => T[];
/**
 * 创建用于迭代的范围
 * 给定开始、结束、值和步长，返回一个生成器，该生成器将按步长生成从开始到结束的值。for (let i = 0)对于替换为很有用for of。Range 将返回一个生成器，该生成器for of一次调用一个生成器，因此创建大范围是安全的。
 *
 * @example
 * range(3)                  // yields 0, 1, 2, 3
 * range(0, 3)               // yields 0, 1, 2, 3
 * range(0, 3, 'y')          // yields y, y, y, y
 * range(0, 3, () => 'y')    // yields y, y, y, y
 * range(0, 3, i => i)       // yields 0, 1, 2, 3
 * range(0, 3, i => `y${i}`) // yields y0, y1, y2, y3
 * range(0, 3, obj)          // yields obj, obj, obj, obj
 * range(0, 6, i => i, 2)    // yields 0, 2, 4, 6
 *
 * for (const i of range(0, 200, i=>i 10)) {
 *    console.log(i) // => 0, 10, 20, 30 ... 190, 200
 * }
 */
declare function range<T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number): Generator<T>;
/**
 * 创建包含特定项目的列表
 * 给定开始、结束、值和步长，返回一个列表，其中包含按步长从开始到结束的值。
 * @example
 * list(3)                  // 0, 1, 2, 3
 * list(0, 3)               // 0, 1, 2, 3
 * list(0, 3, 'y')          // y, y, y, y
 * list(0, 3, () => 'y')    // y, y, y, y
 * list(0, 3, i => i)       // 0, 1, 2, 3
 * list(0, 3, i => `y${i}`) // y0, y1, y2, y3
 * list(0, 3, obj)          // obj, obj, obj, obj
 * list(0, 6, i => i, 2)    // 0, 2, 4, 6
 */
declare const list: <T = number>(startOrLength: number, end?: number, valueOrMapper?: T | ((i: number) => T), step?: number) => T[];
/**
 *  统计数组中每个项目出现的次数
 *
 * @example
 * counting([{name: 'Ra', culture: 'egypt' }, { name: 'Zeus', culture: 'greek' }, { name: 'Loki', culture: 'greek'}], g => g.culture) // => { egypt: 1, greek: 2 }
 */
declare const counting: <T, TId extends string | number | symbol>(list: readonly T[], identity: (item: T) => TId) => Record<TId, number>;
/**
 * 分组数组中的项目
 *
 * @example
 * group([1, 2, 3, 4, 5, 6, 7, 8, 9], g => g % 3) // => { 0: [3, 6, 9], 1: [1, 4, 7], 2: [2, 5, 8] }
 */
declare const group: <T, Key extends string | number | symbol>(array: readonly T[], getGroupId: (item: T) => Key) => Partial<Record<Key, T[]>>;
/**
 * 将列表转换为字典对象
 * @param array 	要转换的数组
 * @param getKey 	获取键的函数
 * @param getValue 	获取值的函数
 * @returns 		转换后的对象
 * @example
 * toObject([1, 2, 3, 4, 5, 6, 7, 8, 9], g => g % 3, g => g) // => { 0: 3, 1: 6, 2: 9 }
 */
declare const toObject: <T, Key extends string | number | symbol, Value = T>(array: readonly T[], getKey: (item: T) => Key, getValue?: (item: T) => Value) => Record<Key, Value>;
/**
 * 按条件过滤数组后映射返回对应数组
 * 类似于 Array.prototype.filter + Array.prototype.map
 * @param array 	要操作的数组
 * @param condition 筛选条件
 * @param mapper 	映射方式
 * @example
 * select([1, 2, 3, 4], x > 2, x => x*x) == [9, 16]
 */
declare const select: <T, K>(array: readonly T[], condition: (item: T, index: number) => boolean, mapper: (item: T, index: number) => K) => K[];
/** 从列表中删除所有空项目，默认 null 或者 undefined */
declare const arrEmpty: <T>(list: readonly T[], filter?: (value: any) => boolean) => T[];
/**
 * 移除数组中的项目
 * @param array 	要操作的数组
 * @param predicate 要移除的项目 (item:T)=>boolean
 * @param position 	要移除项目的位置。默认：false。true/left 仅从头开始第一条；right 仅从尾开始第一条；false 全部都移除
 * @returns 		返回处理后的数组
 */
declare const arrRemove: <T>(array: T[], predicate: T | ((value: T, index: number, obj: T[]) => unknown), position?: boolean | "left" | "right") => T[];
/**
 * 清除数组重复项目
 * @param array 要操作的数组
 * @returns 	返回处理后的数组
 */
declare function cleanDuplicate<T>(array: T[], clearValue?: (value: T) => boolean): T[];

/** 尝试转换成数值，不成功则返回 0 */
declare function number(value: any): number;
/**
 * 检查给定的数值是否在 0 到指定数值之间(包括 0 与指定数值)。
 * @param number 需要检查的数值
 * @param end    最大值(不包括)
 */
declare function inRange(number: number, end: number): boolean;
/**
 * 检查给定的数值是否在指定数值之间(包括指定数值)
 * @param number    需要检查的数值
 * @param start     最小值(包括)
 * @param end       最大值(不包括)
 */
declare function inRange(number: number, start: number, end: number): boolean;
/** 将数值转换成浮点数 */
declare const toFloat: <T extends number | null = number>(value: any, defaultValue?: T) => number | T;
/** 将数值转换成整数 */
declare const toInt: <T extends number | null = number>(value: any, defaultValue?: T) => number | T;
/** 获取数值的小数位数 */
declare function DecimalLength(value: number): number;
/** 将秒数值转换成时间 */
declare function toDate(seconds: number): string;

/**
 * 递归执行操作，全部操作一次，不终止
 * @param list	树形数据列表
 * @param func	要执行的操作
 */
declare function treeExecute<T extends ITree>(list: T | T[], func: (item: T) => void, childrenKey?: string): void;
/**
 * 查找首个符合条件的节点
 * @param list			树形数据列表
 * @param func			要匹配条件的函数
 * @param childrenKey 	下级字段名称
 * @returns 			返回查找到的节点
 */
declare function treeFind<T extends ITree>(list: T | T[], func: (item: T) => boolean, childrenKey?: string): T | undefined;
/**
 * 查找所有符合条件的节点
 * @param list			树形数据列表
 * @param func			要匹配条件的函数
 * @param childrenKey 	下级字段名称
 * @returns 			返回所有查找到的节点数组
 */
declare function treeFindAll<T extends ITree>(list: T | T[], func: (item: T) => boolean, childrenKey?: string): T[];
/**
 * 从树形数据中递归获取顶级项目集合
 * @param data		树形数据
 * @param value		要查询的值
 * @param map		树形数据映射，只需要 value 与 parent 字段即可
 * @returns 		返回所有查找到的父级节点数组，当前级别在前面，顶级在后面
 */
declare function treeParents<V, T extends ITree<V>>(data: T[], value: V, map?: ITreeMap, includeSelf?: boolean): T[];
/**
 * 从列表数据中递归获取顶级项目集合
 * @param data		列表数据
 * @param value		要查询的值
 * @param map		树形数据映射，只需要 value 与 parent 字段即可
 * @returns 		返回所有查找到的父级节点数组，当前级别在前面，顶级在后面
 */
declare function listParents<V, T extends IList<V>>(data: T[], value: V, map?: ITreeMap, includeSelf?: boolean): T[];
/**
 * 递归列表数据获取顶级项目
 * @param data		列表数据
 * @param value		要查询的值
 * @param map		树形数据映射，只需要 value 与 parent 字段即可
 * @returns 		返回查找到的顶级节点
 */
declare function listTop<V, T extends IList<V>>(data: T[], value: V, map?: ITreeMap): T | undefined;
/**
 * 将对象数据转换成标准的列表对象数据
 * @param obj 			原始对象
 * @param map 			键值映射
 * @param ext 			扩展转换操作
 * @param skipConvert 	是否忽略转换，如果之前已经转换过仍然进行转换
 * @returns 			转换后的标准列表数据
 */
declare function listConvert<T, V extends IList<T> & {
    __list?: boolean;
}>(obj: Dict, map?: IListMap, ext?: (obj: V, map?: IListMap) => V, skipConvert?: boolean): IList<T> | undefined;
/**
 * 将对象数据转换成标准的树形数据
 * @param obj 			原始对象
 * @param map 			键值映射
 * @param ext 			扩展转换操作
 * @param skipConvert 	是否忽略转换，如果之前已经转换过仍然进行转换
 * @returns 			转换后的标准树形数据
 */
declare function treeConvert<T, V extends ITree<T> & {
    __tree?: boolean;
}>(obj: Dict, map?: ITreeMap, ext?: (obj: V, map?: IListMap) => V, skipConvert?: boolean): ITree<T> | undefined;
/**
 * 树形列表数据转换成标准树形数据，需要数据中上级字段数据完整
 * @param list			要处理的列表
 * @param parent		默认顶级节点
 * @param predicate		筛选条件
 * @param updateItem	更新节点数据
 * @returns			转换后的标准树形数据
 */
declare function list2tree<T, S extends IList<T>, V extends S & ITree<T>>(list: S[], parent: T, predicate?: (parent: T, value: S, index: number, array: S[]) => boolean, updateItem?: (item: S & {
    children?: V[];
    parent: T;
}) => V): V[];

/** 模块加载属性 */
type moduleOptions = {
    /** 是否使用全路径做为 key，否则仅保留文件名作为 key */
    fullPath?: boolean;
    /** 是否包含 index 文件，默认不包含 */
    incIndex?: boolean;
};
/**
 * 异步方式更新模块对象数据，并异步初始化
 *
 * @param modules 	模块数据集合，使用 import.meta.glob 获取
 * @param options 	模块加载属性
 * @param ...args 	其他附加参数，用于初始化附加参数，使用 arguments 获取，并移除前面两个参数
 * @returns 		返回模块对象
 */
declare function modulesUpdateSync(modules: Dict | Dict[], options?: moduleOptions, ...args: any): Promise<Dict>;
/**
 * 同步方式更新模块对象数据，并同步初始化
 *
 * @param modules 	模块数据集合，使用 import.meta.glob 获取
 * @param options 	模块加载属性
 * @param ...args 	其他附加参数，用于初始化附加参数，使用 arguments 获取，并移除前面两个参数
 * @returns 		返回模块对象
 */
declare function modulesUpdate(modules: Dict | Dict[], options?: moduleOptions, ...args: any): Dict;

/**
 * 计算对象的 HASH 值
 * @param obj 	要计算的对象
 * @returns 	hash 值
 */
declare function hash(obj: any): number;
/** 生成随机ID */
declare function rnd(): string;
/**
 * 函数跟踪，检查指定到当前位置函数的所有信息
 * @param returnCount		最多返回记录数
 * @param removeCount		移除前几条，第一行内容是 ERROR，第二行为当前函数，此2行不计算在内
 * @param removeContents	移除包含的内容
 * @returns 				返回跟踪信息
 */
declare function errorTrace(returnCount?: number, removeCount?: number, removeContents?: string[]): string | string[];
/**
 * 异步休眠，使用 await 执行
 * @param ms 休眠时长，单位：毫秒
 */
declare function sleep(ms: number): Promise<unknown>;
/**
 * 执行指定次数函数操作
 * @param fn 		要执行的函数
 * @param count 	执行次数，超过此次数不再执行
 */
declare function execute(fn: Action, count?: number): () => void;
/**
 * 获取函数唯一标识
 * @param fn		要判断的对象内容
 * @param remove	同时移除此数据
 */
declare function fnId(fn: Func, remove?: boolean): string | undefined;
/**
 * 防抖函数
 * @param func		目标函数
 * @param wait 		延迟执行毫秒数
 * @param immediate	true - 立即执行， false - 延迟执行
 */
declare function debounce<T>(func: (this: T, ...args: any[]) => any, wait?: number, immediate?: boolean): (this: T, ...args: any[]) => any;
/**
 * 节流函数
 * @param func 函数
 * @param wait 延迟执行毫秒数
 * @param type true - 使用表时间戳，在时间段开始的时候触发； false - 使用表定时器，在时间段结束的时候触发
 */
declare function throttle<T>(func: (this: T, ...args: any[]) => any, wait?: number, type?: boolean): (this: T, ...args: any[]) => any;
/**
 * 全局唯一标识
 *
 * @param prefix 前缀
 */
declare function globalId(prefix?: string): string;

/**
 * @author        木炭 <woodcoal@qq.com>
 * @date          2025-12-27 20:33:21
 * Copyright © 湖南大沥网络科技有限公司 All rights reserved
 */
/** 判断字符串中【是否包含】任何 Emoji */
declare function containsEmoji(text: string): boolean;
/**
 * 判断字符串【是否仅由】一个 Emoji 组成
 * (用于头像、图标判断等场景)
 */
declare function isSingleEmoji(text: string): boolean;
/** 提取字符串中的所有 Emoji */
declare function extractEmojis(text: string): never[] | RegExpMatchArray;

/** 常用类型判断 */

/** 获取全局顶级对象 */
declare const $Global: typeof globalThis;

interface HasherState {
    buffer: string;
    buflen: number;
    length: number;
    state: number[];
}
declare class MD5$1 {
    /**
     * Hash a UTF-8 string on the spot
     * @param str String to hash
     * @param raw Whether to return the value as an `Int32Array`
     */
    static md5(str: string, raw?: false): string;
    static md5(str: string, raw: true): Int32Array;
    /**
     * Hash a ASCII string on the spot
     * @param str String to hash
     * @param raw Whether to return the value as an `Int32Array`
     */
    static hashAsciiStr(str: string, raw?: false): string;
    static hashAsciiStr(str: string, raw: true): Int32Array;
    private static stateIdentity;
    private static buffer32Identity;
    private static hexChars;
    private static hexOut;
    private static onePassHasher;
    private static _hex;
    private static _md5cycle;
    private _dataLength;
    private _bufferLength;
    private _state;
    private _buffer;
    private _buffer8;
    private _buffer32;
    constructor();
    /**
     * Initialise buffer to be hashed
     */
    start(): this;
    /**
     * Append a UTF-8 string to the hash buffer
     * @param str String to append
     */
    appendStr(str: string): this;
    /**
     * Append an ASCII string to the hash buffer
     * @param str String to append
     */
    appendAsciiStr(str: string): this;
    /**
     * Append a byte array to the hash buffer
     * @param input array to append
     */
    appendByteArray(input: Uint8Array): this;
    /**
     * Get the state of the hash buffer
     */
    getState(): HasherState;
    /**
     * Override the current state of the hash buffer
     * @param state New hash buffer state
     */
    setState(state: HasherState): void;
    /**
     * Hash the current state of the hash buffer and return the result
     * @param raw Whether to return the value as an `Int32Array`
     */
    end(raw?: boolean): string | Int32Array<ArrayBufferLike> | undefined;
}

/** 对文本进行 base64 编码 */
declare const base64Encode: (input: string) => string;
/** 对 base64 编码后文本进行解码 */
declare const base64Decode: (input: string) => string;
/**
 * 对文本 UTF-8 编码后进行 md5 加密
 * @param str   需要加密的文本
 * @param raw   是否返回文本还是 32 位整型数组
 * @returns     加密后的文本 raw 为 true 时返回 32 位整型数组
 */
declare const MD5: typeof MD5$1.md5;
/**
 * XOR 文本编码
 * @param input 原始文本
 * @param key 加密密钥
 */
declare const xor: (input: string, key: string) => string;

/**
 * 通过 JSON 数据导出 Excel
 * @param data		要导出的 JSON 数据
 * @param fileName	导出文件名
 * @param title		工作区标题
 * @param filter	过滤字段
 */
declare function exportJson(data: any, fileName: string, title: string, filter?: string[]): void;
/**
 * 表格内容导出 Excel
 * @param tableHtml	要导出的表格内容(HTML 代码)
 * @param fileName	导出文件名
 * @param title		工作区标题
 */
declare function exportTable(tableHtml: string, fileName: string, title: string): void;

/**
 * 将数据转换成 JSON 后下载
 * @param obj 		要下载的数据
 * @param fileName	文件名
 */
declare const objectDownload: (obj: any, fileName?: string) => void;
/**
 * 下载 JSON 数据。
 * 系统将先尝试将 JSON 字符串反序列化对象，无法反序列的 JSON 将无法下载
 * @param json 		JSON 字符串
 * @param fileName	文件名
 */
declare const jsonDownload: (json: string, fileName?: string) => void;

/*
' ------------------------------------------------------------
'
' 	Copyright © 2022 湖南大沥网络科技有限公司.
'
' 	  author:	木炭(WOODCOAL)
' 	   email:	i@woodcoal.cn
' 	homepage:	http://www.hunandali.com/
'
' ------------------------------------------------------------
'
' 	文件相关类型定义
'
' 	name: files/index.d
' 	create: 2023-11-012
' 	memo: 文件相关类型定义
' 	
' ------------------------------------------------------------
*/

/** 二维码参数 */
interface IQR {
	/** 二维码内容 */
	code?: string;

	/** 二维码尺寸 */
	size?: number;

	/** 纠错级别 */
	level?: QRErrorCorrectLevel;

	/** 二维码颜色 */
	color?: string;

	/** 二维码背景色 */
	backColor?: string;

	// /** Logo 背景色 */
	// logoColor?: string;

	/** 是否显示 logo, 或者路径 */
	logo?: boolean | string;

	/** 颜色反向，前后背景浅色交换 */
	reserve?: boolean;
}

/** 二维码纠错等级枚举 */
declare enum QRErrorCorrectLevel {
	/** 低级别纠错，约可纠错7%的数据码字 */
	L = 1,
	/** 默认值 */
	M = 0,
	/** 中高级纠错，约可纠错25%的数据码字 */
	Q = 3,
	/** 高级别纠错，约可纠错30%的数据码字 */
	H = 2
}
/**
 * QR8bitByte 类 - 处理8位字节编码
 * 用于将输入数据转换为8位字节序列
 */
declare class QR8bitByte {
	mode: number;
	data: string;
	/**
	 * 构造函数
	 * @param data 要编码的数据
	 */
	constructor(data: string);
	/**
	 * 获取数据长度
	 * @returns 数据长度
	 */
	getLength(): number;
	/**
	 * 将数据写入缓冲区
	 * @param buffer 缓冲区
	 */
	write(buffer: QRBitBuffer): void;
}
/**
 * QRCode 类 - 二维码类
 * 用于生成和管理二维码
 */
declare class QRCode {
	static PAD0: number;
	static PAD1: number;
	typeNumber: number;
	errorCorrectLevel: QRErrorCorrectLevel;
	modules: boolean[][] | null;
	moduleCount: number;
	dataCache: number[] | null;
	dataList: QR8bitByte[];
	/**
	 * 构造函数
	 * @param typeNumber QR码版本(1-40)，如果 < 1，则自动计算
	 * @param errorCorrectLevel 错误纠正级别
	 */
	constructor(typeNumber: number, errorCorrectLevel: QRErrorCorrectLevel);
	/**
	 * 添加数据
	 * @param data 要添加的字符串数据
	 */
	addData(data: string): void;
	/**
	 * 判断指定坐标的模块是否为暗色
	 * @param row 行坐标
	 * @param col 列坐标
	 * @returns 是否为暗色
	 */
	isDark(row: number, col: number): boolean;
	/**
	 * 获取模块数量
	 * @returns 模块数量
	 */
	getModuleCount(): number;
	/**
	 * 生成QR码
	 */
	make(): void;
	/**
	 * 获取最佳掩码模式
	 * @returns 掩码模式索引
	 */
	getBestMaskPattern(): number;
	/**
	 * 创建Flash动画元素（用于旧版Flash应用）
	 * @param target_mc 目标电影剪辑
	 * @param instance_name 实例名称
	 * @param depth 深度
	 * @returns 电影剪辑对象
	 */
	createMovieClip(target_mc: any, instance_name: string, depth: number): any;
	/**
	 * 内部生成QR码的实现
	 * @param test 是否测试模式
	 * @param maskPattern 掩码模式
	 */
	makeImpl(test: boolean, maskPattern: number): void;
	/**
	 * 设置定位图形
	 * @param row 行起始坐标
	 * @param col 列起始坐标
	 */
	setupPositionProbePattern(row: number, col: number): void;
	/**
	 * 设置时序图形
	 */
	setupTimingPattern(): void;
	/**
	 * 设置校正图形
	 */
	setupPositionAdjustPattern(): void;
	/**
	 * 设置版本信息
	 * @param test 是否测试模式
	 */
	setupTypeNumber(test: boolean): void;
	/**
	 * 设置格式信息
	 * @param test 是否测试模式
	 * @param maskPattern 掩码模式
	 */
	setupTypeInfo(test: boolean, maskPattern: number): void;
	/**
	 * 将数据映射到矩阵
	 * @param data 数据
	 * @param maskPattern 掩码模式
	 */
	mapData(data: number[], maskPattern: number): void;
	/**
	 * 创建QR码数据
	 * @param typeNumber 版本号
	 * @param errorCorrectLevel 错误纠正级别
	 * @param dataList 数据列表
	 * @returns 编码后的数据
	 */
	static createData(
		typeNumber: number,
		errorCorrectLevel: QRErrorCorrectLevel,
		dataList: QR8bitByte[]
	): number[];
	/**
	 * 创建字节数据
	 * @param buffer 比特缓冲区
	 * @param rsBlocks RS块数组
	 * @returns 最终数据
	 */
	static createBytes(buffer: QRBitBuffer, rsBlocks: QRRSBlock[]): number[];
}
/**
 * QRRSBlock 类 - RS块类
 * 用于纠错编码的RS块
 */
declare class QRRSBlock {
	totalCount: number;
	dataCount: number;
	constructor(totalCount: number, dataCount: number);
	static RS_BLOCK_TABLE: number[][];
	/**
	 * 获取指定版本和纠错级别的RS块
	 * @param typeNumber 版本号(1-40)
	 * @param errorCorrectLevel 纠错级别
	 * @returns RS块数组
	 */
	static getRSBlocks(typeNumber: number, errorCorrectLevel: QRErrorCorrectLevel): QRRSBlock[];
	/**
	 * 获取RS块表
	 * @param typeNumber 版本号
	 * @param errorCorrectLevel 纠错级别
	 * @returns RS块参数
	 */
	static getRsBlockTable(
		typeNumber: number,
		errorCorrectLevel: QRErrorCorrectLevel
	): number[] | undefined;
}
/**
 * QRBitBuffer 类 - 比特流缓冲区
 * 用于存储和管理二维码数据的位流
 */
declare class QRBitBuffer {
	buffer: number[];
	length: number;
	constructor();
	/**
	 * 获取指定位置的位值
	 * @param index 位索引
	 * @returns 位值(true/false)
	 */
	get(index: number): boolean;
	/**
	 * 在缓冲区中放入指定长度的数值
	 * @param num 数值
	 * @param length 位长度
	 */
	put(num: number, length: number): void;
	/**
	 * 获取缓冲区的位长度
	 * @returns 比特数
	 */
	getLengthInBits(): number;
	/**
	 * 在缓冲区中放入单个位
	 * @param bit 位值
	 */
	putBit(bit: boolean): void;
}

/** 画布上下文接口 */
interface CanvasContext extends CanvasRenderingContext2D {
	setFillStyle?: (color: string) => void;
	setFontSize?: (fontSize: number) => void;
	setTextAlign?: (align: CanvasTextAlign) => void;
	setTextBaseline?: (textBaseline: CanvasTextBaseline) => void;
	setGlobalAlpha?: (alpha: number) => void;
	setStrokeStyle?: (color: string) => void;
	setShadow?: (offsetX: number, offsetY: number, blur: number, color: string) => void;
	draw?: (reserve?: boolean, callback?: () => void) => void;
}
/** 绘制模块接口 */
interface DrawModule {
	name: string;
	type: string;
	x: number;
	y: number;
	width: number;
	height: number;
	[key: string]: any;
}
/** 二维码模块单元格接口定义 */
interface QRModule {
	/** 模块类型数组 */
	type: string[];
	/** 模块颜色 */
	color: string;
	/** 是否为黑色模块 */
	isBlack: boolean;
	/** 是否已绘制 */
	isDrawn: boolean;
	/** 目标X坐标 */
	destX: number;
	/** 目标Y坐标 */
	destY: number;
	/** 目标宽度 */
	destWidth: number;
	/** 目标高度 */
	destHeight: number;
	/** X坐标 */
	x: number;
	/** Y坐标 */
	y: number;
	/** 宽度 */
	width: number;
	/** 高度 */
	height: number;
	/** 上内边距 */
	paddingTop: number;
	/** 右内边距 */
	paddingRight: number;
	/** 下内边距 */
	paddingBottom: number;
	/** 左内边距 */
	paddingLeft: number;
}

/** 二维码实例配置接口 */
interface QRCodeOptions {
	/** 二维码文本内容，优先于 data */
	text?: string;
	/** 二维码对应内容 */
	data?: string | number;
	/** 数据编码，默认utf16to8，设为false则传入原始data */
	dataEncode?: boolean;
	/** 二维码大小 */
	size?: number;
	/** 使用动态尺寸，自动计算每一个小方块尺寸为整数 */
	useDynamicSize?: boolean;
	/** 二维码版本，-1为自动计算 */
	typeNumber?: number;
	/** 纠错等级 */
	errorCorrectLevel?: number;
	/** 二维码外边距 */
	margin?: number;
	/** 二维码绘制区域颜色、底部背景色 */
	areaColor?: string;
	/** 背景色 */
	backgroundColor?: string;
	/** 背景图片地址 */
	backgroundImageSrc?: string;
	/** 背景图片宽度，默认与size同宽 */
	backgroundImageWidth?: number;
	/** 背景图片高度，默认与size同高 */
	backgroundImageHeight?: number;
	/** 背景图片位置X坐标，默认0 */
	backgroundImageX?: number;
	/** 背景图片位置Y坐标，默认0 */
	backgroundImageY?: number;
	/** 背景图片透明度，默认不透明 */
	backgroundImageAlpha?: number;
	/** 背景图片圆角，默认不是圆角 */
	backgroundImageBorderRadius?: number;
	/** 背景码点内边距，系数：0.0-1.0 */
	backgroundPadding?: number;
	/** 前景色 */
	foregroundColor?: string;
	/** 前景图片地址 */
	foregroundImageSrc?: string;
	/** 前景图片宽度，默认为size的1/4 */
	foregroundImageWidth?: number;
	/** 前景图片高度，默认为size的1/4 */
	foregroundImageHeight?: number;
	/** 前景图片位置X坐标，默认在画布中间位置 */
	foregroundImageX?: number;
	/** 前景图片位置Y坐标，默认在画布中间位置 */
	foregroundImageY?: number;
	/** 前景图边距填充 */
	foregroundImagePadding?: number;
	/** 前景图背景颜色 */
	foregroundImageBackgroundColor?: string;
	/** 前景图边界圆角 */
	foregroundImageBorderRadius?: number;
	/** 前景图阴影水平偏移值 */
	foregroundImageShadowOffsetX?: number;
	/** 前景图阴影垂直偏移值 */
	foregroundImageShadowOffsetY?: number;
	/** 前景图阴影模糊度 */
	foregroundImageShadowBlur?: number;
	/** 前景图阴影颜色 */
	foregroundImageShadowColor?: string;
	/** 前景码点内边距，0.0-1.0 */
	foregroundPadding?: number;
	/** 定位角区域背景色，默认值跟随背景色 */
	positionProbeBackgroundColor?: string;
	/** 定位角码点颜色，默认值跟随前景色 */
	positionProbeForegroundColor?: string;
	/** 分割区域颜色，默认值跟随背景色 */
	separatorColor?: string;
	/** 对齐区域背景色，默认值跟随背景色 */
	positionAdjustBackgroundColor?: string;
	/** 对齐码点颜色，默认值跟随前景色 */
	positionAdjustForegroundColor?: string;
	/** 时序区域背景色，默认值跟随背景色 */
	timingBackgroundColor?: string;
	/** 时序码点颜色，默认值跟随前景色 */
	timingForegroundColor?: string;
	/** 版本信息区域背景色，默认值跟随背景色 */
	typeNumberBackgroundColor?: string;
	/** 版本信息码点颜色，默认值跟随前景色 */
	typeNumberForegroundColor?: string;
	/** 暗块颜色，默认值跟随前景色 */
	darkBlockColor?: string;
}
/**
 * 插件类型
 * - instance: _当前 QRCode 实例_
 * - options: _实例属性_
 * - isInstance: _是否来自实例注册，`false` 表示为通过 `UQRCode.use` 全局注册，`true` 表示仅当前实例注册_
 */
type QRPlugin = (instance: UQRCode, options: QRCodeOptions, isInstance: boolean) => void;

/**
 * 二维码生成器类
 * 用于生成和绘制二维码，支持自定义样式和图片
 */
declare class UQRCode {
	/** 当前错误消息 */
	errorMessage: string;
	/** 二维码内容 */
	data: string;
	/** 二维码大小 */
	size: number;
	/** 数据编码，默认utf16to8，设为false则传入原始data，如有特殊的编码需求，可以将其设为false，再将数据编码后传入data */
	dataEncode: boolean;
	/** 使用动态尺寸，自动计算每一个小方块尺寸为整数，因为canvas特性，小数点部分会被绘制为透明渐变色，绘制后看起来像是有白色细线，计算为整数则可以解决这个问题，但是实际尺寸已不是原尺寸，canvas的尺寸需要通过获取dynamicSize后重新设置 */
	useDynamicSize: boolean;
	/** 动态尺寸 */
	dynamicSize: number;
	/** 二维码版本，-1为自动计算，自动计算字符越多，版本越高 */
	typeNumber: number;
	/** 纠错等级 */
	errorCorrectLevel: QRErrorCorrectLevel;
	/** 二维码外边距 */
	margin: number;
	/** 二维码绘制区域颜色、底部背景色 */
	areaColor: string;
	/** 背景色 */
	backgroundColor: string;
	/** 背景图片地址 */
	backgroundImageSrc?: string | undefined;
	/** 背景图片宽度 */
	private backgroundImageWidth?: number | undefined;
	/** 背景图片高度 */
	backgroundImageHeight?: number | undefined;
	/** 背景图片X坐标 */
	backgroundImageX?: number | undefined;
	/** 背景图片Y坐标 */
	backgroundImageY?: number | undefined;
	/** 背景图片透明度，默认不透明 */
	backgroundImageAlpha: number;
	/** 背景图片圆角，默认不是圆角 */
	backgroundImageBorderRadius: number;
	/** 背景码点内边距，系数：0.0-1.0 */
	backgroundPadding: number;
	/** 前景色 */
	foregroundColor: string;
	/** 前景图片地址 */
	foregroundImageSrc?: string | undefined;
	/** 前景图片宽度 */
	foregroundImageWidth?: number | undefined;
	/** 前景图片高度 */
	foregroundImageHeight?: number | undefined;
	/** 前景图片X坐标 */
	foregroundImageX?: number | undefined;
	/** 前景图片Y坐标 */
	foregroundImageY?: number | undefined;
	/** 前景图边距填充 */
	foregroundImagePadding: number;
	/** 前景图背景颜色 */
	foregroundImageBackgroundColor: string;
	/** 前景图边界圆角 */
	foregroundImageBorderRadius: number;
	/** 前景图阴影水平偏移值 */
	foregroundImageShadowOffsetX: number;
	/** 前景图阴影垂直偏移值 */
	foregroundImageShadowOffsetY: number;
	/** 前景图阴影模糊度 */
	foregroundImageShadowBlur: number;
	/** 前景图阴影颜色 */
	foregroundImageShadowColor: string;
	/** 前景码点内边距，0.0-1.0 */
	foregroundPadding: number;
	/** 定位角区域背景色，默认值跟随背景色 */
	positionProbeBackgroundColor?: string | undefined;
	/** 定位角码点颜色，默认值跟随背景色 */
	positionProbeForegroundColor?: string | undefined;
	/** 分割区域颜色，默认值跟随背景色 */
	separatorColor?: string | undefined;
	/** 对齐区域背景色，默认值跟随背景色 */
	positionAdjustBackgroundColor?: string | undefined;
	/** 对齐码点颜色，默认值跟随前景色 */
	positionAdjustForegroundColor?: string | undefined;
	/** 时序区域背景色，默认值跟随背景色 */
	timingBackgroundColor?: string | undefined;
	/** 时序码点颜色，默认值跟随前景色 */
	timingForegroundColor?: string | undefined;
	/** 版本信息区域背景色，默认值跟随背景色 */
	typeNumberBackgroundColor?: string | undefined;
	/** 版本信息码点颜色，默认值跟随前景色 */
	typeNumberForegroundColor?: string | undefined;
	/** 暗块颜色，默认值跟随前景色 */
	darkBlockColor?: string | undefined;
	/** 二维码基本对象，通过实例化QRCode类并调用make后得到 */
	base: QRCode | undefined;
	/** 二维码模块数据，基于base的modules但数据格式不一致，这里的modules是定制过的 */
	modules: QRModule[][];
	/** 模块数量 */
	moduleCount: number;
	/** 绘制模块，层级：最底层 -> 绘制区域 -> 背景图片 -> 背景|前景 -> 前景图片 -> 最顶层 */
	drawModules: DrawModule[];
	/** 画布上下文 */
	canvasContext: CanvasContext;
	/** ctx.draw保留绘制，本次绘制是否接着上一次绘制，2d没有draw方法，所以2d该属性对2d无效 */
	drawReserve: boolean;
	/** 制作完成标志 */
	isMaked: boolean;
	/** 插件集合 */
	static plugins: QRPlugin[];
	/**
	 * 全局扩展插件方法
	 * @param plugin 插件函数
	 */
	static use(plugin: QRPlugin): void;
	/**
	 * 构造函数
	 * @param options 配置选项
	 * @param canvasContext canvas上下文
	 */
	constructor(options?: QRCodeOptions, canvasContext?: any);
	/**
	 * 设置选项
	 * @param options 配置选项
	 */
	setOptions(options: QRCodeOptions): void;
	/**
	 * 错误处理
	 * @param msg 错误信息
	 */
	Error(msg: string): void;
	/**
	 * 加载图片
	 * @param src - 图片地址
	 * @returns Promise<any> - 加载完成的图片
	 */
	loadImage(src: string): Promise<string>;
	/**
	 * 制作二维码
	 * 生成二维码数据并进行绘制准备
	 */
	make(): void;
	/**
	 * 获取绘制模块
	 * @returns DrawModule[] - 绘制模块数组
	 */
	getDrawModules(): DrawModule[];
	/**
	 * 判断当前模块是否是黑块（前景部分）
	 * @param rowI - 行索引
	 * @param colI - 列索引
	 * @returns boolean - 是否为黑块
	 */
	isBlack(rowI: number, colI: number): boolean;
	/**
	 * 绘制canvas方法
	 * @param reserve - 是否保留上一次绘制
	 * @returns Promise<void>
	 */
	drawCanvas(reserve?: boolean): Promise<void>;
	/**
	 * 绘制背景图片
	 * @param ctx - 画布上下文
	 * @param drawModule - 绘制模块数据
	 */
	private drawBackgroundImage;
	/**
	 * 绘制前景图片
	 * @param ctx - 画布上下文
	 * @param drawModule - 绘制模块数据
	 */
	private drawForegroundImage;
	/**
	 * 绘制canvas方法，兼容v3.2.0-v3.4.5版本的写法
	 * @param reserve - 是否保留上一次绘制
	 * @returns Promise<void>
	 */
	draw(reserve?: boolean): Promise<void>;
	/**
	 * 注册实例插件
	 * 写扩展插件时需注意，因微信官方旧版Canvas未完全依照Web Canvas API设计，安卓并未兼容，如需要H5和微信小程序旧版Canvas同时兼容，需要在扩展函数里加入这些API的兼容。（如当前未补充的：setLineCap、setTransform、setStrokeStyle等与Web Canvas不一致的API）
	 * @param plugin - 插件函数
	 */
	register(plugin: QRPlugin): void;
}

/** excel 相关操作 */

declare const QR: typeof UQRCode;
/**
 * 创建 QR 对象,后续需要进一步处理
 * 具体请参考 https://uqrcode.cn/doc/
 */
declare function QRObject(params: IQR): Promise<UQRCode | undefined>;
/**
 * 创建二维码图片
 * 具体请参考 https://uqrcode.cn/doc/
 */
declare function QRCreate(params: IQR): Promise<string>;
/**
 * 远程读取文件并转换成 base64
 * @param url 文件地址
 * @param onlyImage 是否只处理图片格式，默认 true
 */
declare function remoteFileToBase64(url: string, onlyImage?: boolean): Promise<string>;

/** Cookies 选项 */
interface CookiesOptions {
    /** 过期时间，单位：秒 */
    expire?: number;
    /** 路径 */
    path?: string;
    /** 安全 */
    secure?: boolean;
    /** HttpOnly */
    httpOnly?: boolean;
}
/**
 * 设置 cookie
 * @param name 名称
 * @param value 值
 * @param options 选项
 */
declare function setCookie(name: string, value: string, options?: CookiesOptions): void;
/**
 * 获取 cookie
 * @param name 名称
 * @returns 值
 */
declare function getCookie(name: string): string | null;
/** 删除 Cookie */
declare function deleteCookie(name: string, path?: string): void;
declare const _default$1: {
    set: typeof setCookie;
    get: typeof getCookie;
    del: typeof deleteCookie;
};

/** LRU 数据结构 */
declare class lruValue {
    /** 缓存键 */
    key: string;
    /** 缓存值 */
    value: any;
    /** 超时时长,单位:秒 */
    exp: number;
    /** 上一个元素 */
    prev: lruValue | undefined;
    /** 下一个元素 */
    next: lruValue | undefined;
    /** 构造,超时设置为 0 时,永不到期 时间单位:秒 */
    constructor(key: string, value: any, exp: number);
    /** 更新值 */
    update(value: any, exp: number): void;
    isExp(): boolean;
}
/** LRU 操作 */
declare class LRU {
    /** 缓存的键 */
    datas: Map<string, lruValue>;
    /** 最大缓存数量 */
    capacity: number;
    /** 头部元素 */
    private head;
    /** 尾部元素 */
    private tail;
    /**
     * 构造
     * @param capacity	最大元素数量
     */
    constructor(capacity?: number);
    /** 获取缓存，不存在返回 undefined */
    get(key: string): any;
    /**
     * 获取缓存
     * @param key	缓存键
     * @param value	缓存内容
     * @param exp	超时时长 单位:秒，0 为永不到期
     */
    set(key: string, value: any, exp: number): void;
    /** 移除缓存 */
    remove(key: string): void;
    /** 是否存在缓存键 */
    has(key: string): boolean;
    /** 清除所有缓存 */
    clear(): void;
    /** 所有缓存的键 */
    keys(): MapIterator<string>;
    /** 缓存数量 */
    length(): number;
    /** 强制清除到期缓存 */
    trim(): void;
    /** 更新调整位置，将新数据移动到尾部 */
    private _updateItem;
    /** 移除最近最少使用节点 */
    private _checkSize;
    /** 强制移除 */
    private _remove;
}

/** 规则接口 */
interface IRule {
    [name: string]: any;
    /** 是否必填 */
    required?: boolean;
    /** 文本是否去除首尾空格后验证 */
    trim?: boolean;
    /** 类型 */
    type?: 'json' | 'url' | 'email' | 'tel' | 'phone' | 'mobile' | 'mobilephone' | 'guid' | 'number' | 'chinese' | 'english' | 'ip' | 'name';
    /** 正则表达式 */
    pattern?: RegExp | string;
    /** 最小值 */
    min?: number;
    /** 最大值 */
    max?: number;
    /** 最小长度 */
    minLength?: number;
    /** 最大长度 */
    maxLength?: number;
    /** 最小时间 */
    minDate?: string;
    /** 最大时间 */
    maxDate?: string;
    /** 提示信息 */
    message?: string;
    /** 自定义验证规则 */
    validate?: (value: any) => true | string;
}
/** 规则列表类型 */
type IRules = Array<IRule> | IRule;
/** 规则验证 */
declare class FormValidate {
    /** 规则合并，并转换成数组规则列表 */
    concat(...args: IRules[]): IRule[] | undefined;
    /********************************************************************/
    /**
     * 规则组验证
     * @param rules	规则对象，数组或者对象
     * @param value	要验证的值
     * @returns 	成功返回 true 否则返回错误提示；无规则则表示无需验证,直接返回成功!
     */
    validate(rules: IRules | undefined, value: any): string | true;
    /**
     * 单条规则验证
     * @param rule	规则对象，数组或者对象
     * @param value	要验证的值
     * @returns 	成功返回 true 否则返回错误提示
     */
    validateRule(rule: IRule, value: any): string | true;
    /** 验证是否必填 */
    private validateRequired;
    /** 验证正则表达式，仅针对字符串 */
    private validateRegular;
    /**
     *	验证类型
     * @param rule 	类型:url / email / mobile / mobilephone / phone
     * @param value 值:非必须填写的项目，对于空值忽略
     */
    private validateType;
    /** 验证区间 */
    private validateRange;
    /** 验证自定义规则函数 */
    private validateFunction;
    /********************************************************************/
    /** 规则描述 */
    description(rules: IRules): string;
    /** 必填 */
    private descriptionRequired;
    /** 正则 */
    private descriptionRegular;
    /** 类型 */
    private descriptionType;
    /** 区间 */
    private descriptionRange;
    /********************************************************************/
    /** 是否存在规则 */
    hasRules(rules: IRules): boolean;
    /** 将规则对象转换成规则列表 */
    private updateRules;
    /** 是否存在必填项目 */
    hasRequired(rules: IRules): any;
}
/** 创建表单验证 */
declare const createFormValidate: () => FormValidate;

declare const _default: (background: string | (() => string), interval?: number) => void;

/** 获取浏览器自动样式 */
declare function UIThemeQuery(options?: {
    /** 深色与浅色模式自动切换开始时间 */
    start: number;
    /** 深色与浅色模式自动切换结束时间 */
    end: number;
    /** 默认支持的主题，不论是否设置都包含 'dark' 和 'light'，主要用于从 class 中获取样式类型 */
    defaultThemes?: string[];
}): string | undefined;
/**
 * 设置浏览器样式
 * 从 html 根节点调整样式
 * @param theme 主题
 * @param el 样式元素，默认 html 根节点
 * @param defaultClass 节点默认样式类名
 */
declare function UIThemeSet(theme: 'light' | 'dark' | string, el?: HTMLElement, defaultClass?: string): void;
/**
 * 重要日期样式变灰
 * @param days 日期，日期组，{日期：水印文本}。如果日期为长日期比较当天，短日期每年比较。如果水印文本以 * 开头，页面变灰。
 */
declare const createImportantStyle: (days: string | string[] | NVs) => void;
/** 样式类名基础类型 */
type ClassNameValue = string | boolean | string[] | Record<string, boolean> | undefined | null;
/** 样式类名类型 */
type ClassName = ClassNameValue | Func<ClassNameValue>;
/** 合并样式中的类名，自动移除重复类名、空值 */
declare const mergeClass: (...classNames: ClassName[]) => string[];

/**
 * 设备屏幕类型
 * @param options 配置参数 宽度(desktop：桌面端最小宽度（含）；mobile：移动端最大宽度（含）)
 * @returns 设备屏幕类型
 */
declare const screenType: (options?: {
    desktop: number;
    mobile: number;
}) => "mobile" | "server" | "desktop" | "tablet";
/** 判断是否全屏 */
declare const isFullscreen: () => any;
/** 进入全屏 */
declare const fullscreenLaunch: (element: Element | string) => boolean;
/** 退出全屏 */
declare const fullscreenExit: () => boolean;

export { $Global, Action, CACHE_TIME_MAX, type CanvasContext, type ClassName, type ClassNameValue, _default$1 as Cookies, type CookiesOptions, DEBOUNCE_WINDOW_RESIZE, DEBUG, description as DESCRIPTION, DecimalLength, Dict, type DrawModule, FormValidate, Func, homepage as HOMEPAGE, IList, IListMap, type IQR, type IRule, type IRules, ITree, ITreeMap, LOGO, LRU, MD5, name as NAME, NVs, QR, QRCode, type QRCodeOptions, QRCreate, QRErrorCorrectLevel, type QRModule, QRObject, type QRPlugin, SERVERMODE, TEST, title as TITLE, UIThemeQuery, UIThemeSet, version as VERSION, arrEmpty, arrRemove, base64Decode, base64Encode, cleanDuplicate, clone, compare, containsEmoji, counting, createFormValidate, createImportantStyle, debounce, deleteCookie, each, eachSync, errorTrace, every, exportJson as excelJson, exportTable as excelTable, execute, extractEmojis, fnId, fullscreenExit, fullscreenLaunch, get, getCookie, globalId, group, has, hasArray, hasObject, hasObjectName, hasString, hash, htmlClear, htmlEncode, inRange, isArray, isAsync, isBoolean, isCar, isChinese, isDate, isEmail, isEmpty, isEnglish, isEqual, isFloat, isFn, isFullUrl, isFullscreen, isFunction, isGuid, isHttp, isIP, isInt, isJSON, isMatch, isMobile, isNaN, isName, isNil, isNumber, isObject, isPhone, isPrimitive, isPromise, isReg, isRegExp, isSingleEmoji, isString, isSymbol, isUrl, isVueComponent, jsonDownload, list, list2tree, listConvert, listParents, listTop, math, merge, mergeClass, type moduleOptions, modulesUpdate, modulesUpdateSync, notEmpty, number, objClear, objEmpty, objectDownload, range, reduce, remoteFileToBase64, remove, rnd, screenType, select, set, setCookie, sleep, some, sort, string2Value, stringClear, stringCut, stringIncludes, template, throttle, toArray, toDate, toDeepObject, toFloat, toHtml, toInt, toJSON, toObject, toSingleObject, treeConvert, treeExecute, treeFind, treeFindAll, treeParents, trimEx, typeName, _default as waterMark, xor };