import { Element as Element$1 } from "domhandler";
import { Options } from "tsup";

//#region src/types.d.ts
declare global {
    interface Window {
        webkitRequestAnimationFrame: (callback: FrameRequestCallback) => number;
        mozRequestAnimationFrame: (callback: FrameRequestCallback) => number;
        msRequestAnimationFrame: (callback: FrameRequestCallback) => number;
        oRequestAnimationFrame: (callback: FrameRequestCallback) => number;
        webkitCancelAnimationFrame: (handle: number) => void;
        mozCancelAnimationFrame: (handle: number) => void;
        oCancelAnimationFrame: (handle: number) => void;
        msCancelAnimationFrame: (handle: number) => void;
        webkitIndexedDB: IDBFactory;
        mozIndexedDB: IDBFactory;
        msIndexedDB: IDBFactory;
        indexedDB: IDBFactory;
        SpeechRecognition: any;
        webkitSpeechRecognition: any;
    }
    interface Navigator {
        webkitGetUserMedia: () => void;
        mozGetUserMedia: () => void;
        msGetUserMedia: () => void;
        getUserMedia: () => void;
    }
}
type Redirect = 'follow' | 'error' | 'manual';
type Cache = 'default' | 'no-store' | 'reload' | 'no-cache' | 'force-cache';
type Mode = 'cors' | 'no-cors' | 'same-origin' | 'navigate';
type ResponseType = 'formData' | 'text' | 'blob' | 'arrayBuffer' | 'json';
type BodyType = 'form' | 'json' | 'file';
type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'OPTIONS';
type Credentials = 'omit' | 'include' | 'same-origin';
interface IFetchInterceptors {
    request?: {
        success?: (config: IFetchConfig) => IFetchConfig;
        error?: (error: any) => Promise<never>;
    };
    response?: {
        success?: (response: any) => any;
        error?: (error: any) => Promise<never>;
    };
    success?: (response: Response) => Response;
    error?: (error: any) => Promise<never>;
}
interface IFetchConfig extends IFetchOptions {
    url?: string;
    keepalive?: boolean;
    body?: any;
    retry?: number;
    integrity?: string;
    referrer?: string;
    referrerPolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'unsafe-url' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'same-origin';
    method?: Method;
    credentials?: Credentials;
    params?: Record<string, string>;
    responseType?: ResponseType;
    bodyType?: BodyType;
    cache?: Cache;
    redirect?: Redirect;
    mode?: Mode;
    signal?: AbortSignal;
    cancel?: () => void;
    transformResponse?: (response: Response) => Response;
}
interface IFetchOptions {
    baseURL?: string;
    timeout?: number;
    headers?: Record<string, any>;
    interceptors?: IFetchInterceptors;
}
interface DeviceType {
    os: string;
    dev: string;
}
type TrimType = 'all' | 'pre' | 'around' | 'post';
interface EventBus {
    data: Record<string, Function[]>;
    emit: (event: string, data?: any) => void;
    on: (event: string, fn: (data?: any) => void) => void;
    off: (event: string, fn: Function) => void;
}
interface Position {
    x: number;
    y: number;
}
type FileType = 'file' | 'blob' | 'url';
interface JSCookie {
    get: (key: string) => string | undefined;
    set: (key: string, value: string, extdays?: number) => void;
    delete: (key: string) => void;
}
interface LRU {
    set: (key: string, value: any) => void;
    get: (key: string) => any;
    cache: Map<string, any>;
    max: number;
    size: () => number;
}
interface ISignature {
    canvas: HTMLCanvasElement;
    ctx: CanvasRenderingContext2D;
    createCanvas: (lineWidth: number, w: number, h: number) => void;
    clearCanvas: () => void;
    mount: (el: MaybeElement) => void;
    unmount: () => void;
    setColor: (color: string) => void;
    setBgColor: (bg: string) => void;
    undo: () => void;
    redo: () => void;
    save: (type?: string, quality?: any) => string;
}
interface FileMD5 {
    HASH: string;
    suffix: string;
    filename: string;
    buffer: ArrayBuffer;
}
interface FileChunk {
    file: Blob;
    filename: string;
}
type ChunkDetail = ChunkInfo & {
    isDone: boolean;
    remaining: number;
    type: string;
    size: number;
    lastModified: number;
};
interface ChunkInfo {
    start: number;
    end: number;
    index: number;
    hash: string;
}
interface FileSpliceOptions {
    file: File;
    chunkSize: number;
    callback: (chunk: ChunkDetail) => void;
}
interface Deadline {
    timeRemaining: () => number;
    didTimeout: boolean;
}
interface DragEvent {
    dragStart?: (e: any) => void;
    dragMove?: (e: any) => void;
    dragEnd?: (e: any) => void;
}
interface MutationObserverInit {
    childList?: boolean;
    attributes?: boolean;
    characterData?: boolean;
    subtree?: boolean;
    attributeOldValue?: boolean;
    characterDataOldValue?: boolean;
    attributeFilter?: string[];
}
interface ParsedURL {
    protocol?: string;
    host?: string;
    auth?: string;
    pathname: string;
    hash: string;
    search: string;
}
interface IShellMessage {
    status: number | null;
    result: string;
    pid: number;
}
type PkgTool = 'npm' | 'yarn' | 'pnpm' | 'bun';
type Keys<A, B> = keyof A | keyof B;
type Val<key, A, B> = key extends keyof A ? key extends keyof B ? A[key] extends number | string | boolean | symbol | null | undefined ? A[key] | B[key] : Merge<A[key], B[key]> : A[key] : key extends keyof B ? B[key] : never;
type Merge<A, B> = {
    [key in Keys<A, B>]: Val<key, A, B>;
};
interface IsESModule {
    default: any;
}
interface NodeWorkerPayload {
    params: string | string[];
    stdio?: 'inherit' | 'pipe';
    errorExit?: boolean;
    isLog?: boolean;
}
type UseTimeoutReturn<T> = T extends Function ? () => void : undefined;
type MaybeElement = string | HTMLElement;
type Lang = 'zh-CN' | 'en-US' | 'ja-JP' | 'ko-KR' | 'zh-TW' | 'zh-HK' | 'zh-MO' | 'zh-SG';
type Direction = 'horizontal' | 'horizontal-reverse' | 'vertical' | 'vertical-reverse' | 'center-out' | 'out-center';
type TimeUnit = 'days' | 'hours' | 'minutes' | 'seconds';
type DateString = `${number}-${number}-${number}` | `${number}/${number}/${number}`;
interface ImageData$1 {
    width: number;
    height: number;
    data: Uint8ClampedArray;
}
interface DotTextCanvasOptions {
    text: string;
    fontSize: number;
    color: string;
    fontWeight: number;
    direction?: Direction;
    isPreferred?: boolean;
    charSpacing?: number;
    charSpacings?: number[];
}
interface DotImageCanvasOptions {
    src: string;
    color: string;
    fontWeight: number;
    bgColor?: string;
    direction?: Direction;
    isPreferred?: boolean;
}

//#endregion
//#region src/array/diff.d.ts
interface Options$3 {
    compare?: 'same' | 'different';
    result?: 'value' | 'index';
}
/**
*
* @param { any[] } array1 数组1
* @param { any[] } array2 数组2
* @param { Options } [options] {}
* @param { 'same' | 'different' } [options.compare] 'same' | 'different'
* @param { 'value' | 'index' } [options.compresultare] 'value' | 'index'
* @returns 返回相同项或不同项的索引或值
*/
declare function diff(array1: any[], array2: any[], options?: Options$3): any[];

//#endregion
//#region src/array/forEach.d.ts
interface ForEachCallback<T> {
    (value: T, index: number, array: T[]): any;
}
/**
*
* @param { any[] } array 数组
* @param { Function } callback ForEachCallback
* @returns
*/
declare function forEach<T>(array: T[], callback: ForEachCallback<T>): any;

//#endregion
//#region src/array/getAverage.d.ts
/**
*
* @param { number[] } array 数字数组
* @param { number } fraction 保留几位小数
* @returns 平均值
*/
declare function getAverage(array: number[], fraction?: number): string;

//#endregion
//#region src/array/quickFilter.d.ts
/**
*
* @param { any[] } array 数组
* @param { string | Array<string> } key 过滤条件
* @returns
*/
declare function quickFilter(array: any[], key: string | Array<string>): any[];

//#endregion
//#region src/array/quickFind.d.ts
/**
*
* @param { T[] } array 数组
* @param { string | number } id 主键
* @returns
*/
declare function quickFind<T>(array: T[], id: T[keyof T]): QuickFind<T>;
declare class QuickFind<T> {
    array: T[];
    indexMap: Map<any, number>;
    id: T[keyof T];
    constructor(array: T[], indexMap: Map<any, number>, id: T[keyof T]);
    find(id: T[keyof T]): T | undefined;
    _update(id: T[keyof T], key: keyof T | T, value: any): T[];
    delete(id: T[keyof T]): T[] | undefined;
    set(id: T[keyof T], key: keyof T | T, value?: any): T[];
}

//#endregion
//#region src/array/sort.d.ts
/**
*
* @param { any[] } array 数组
* @param { Array<string | number> | number | string } match 匹配条件
* @returns
*/
declare function sort<T>(array: T[], match: Array<string | number> | number | string): T[];

//#endregion
//#region src/array/sortByOrder.d.ts
/**
*
* @param { any[] } sortArr 数组
* @param { string[] } order 顺序
* @param { string } prop 按照哪个属性
* @returns
*/
declare function sortByOrder<T>(sortArr: T[], order: string[], prop?: string): T[];

//#endregion
//#region src/array/uniqueArray.d.ts
/**
*
* @param { any[] } array 数组
* @returns 去重后的数组
*/
declare function uniqueArray(array: any[]): any[];

//#endregion
//#region src/array/chunk.d.ts
/**
*
* @param { T[] } arr 数组
* @param { number } size 以多少为基准分割
* @returns  分割后的数组
*/
declare function chunk<T>(arr: T[], size?: number): T[][];

//#endregion
//#region src/array/countBy.d.ts
/**
*
* @param { any[] } array 数组
* @param { Function } iterator 迭代数组函数
* @returns 结果的个数
*/
declare function countBy<T extends Record<string, any>>(array: T[], iterator: (item: T) => any): Record<string, number>;

//#endregion
//#region src/array/flatten.d.ts
/**
*
* @param { Record<string, any> | Record<string, any>[] } o 对象或者数组
* @param { string }flattenProps 展开的属性默认为children
* @param { boolean }onlyLastNode  只保留最后一层级的数据
* @returns 一层的数组
*/
declare function flatten<T extends Record<string, any>>(o: T | T[], flattenProps?: string, onlyLastNode?: boolean, result?: T[]): T[];

//#endregion
//#region src/array/filterEmpty.d.ts
/**
*
* @param { any[] } array 数组
* @returns 过滤空值后的数组
*/
declare function filterEmpty<T>(array: T[]): T[];

//#endregion
//#region src/canvas/Canvas.d.ts
declare class Canvas {
    canvas: HTMLCanvasElement;
    ctx: CanvasRenderingContext2D;
    constructor(width?: number, height?: number);
}

//#endregion
//#region src/canvas/CreateSignatureCanvas.d.ts
declare class CreateSignatureCanvas implements ISignature {
    canvas: HTMLCanvasElement;
    ctx: CanvasRenderingContext2D;
    stop: (() => void)[];
    active: boolean;
    historyStack: ImageData[];
    resetStack: ImageData[];
    color: string;
    bg: string;
    constructor(lineWidth?: number, w?: number, h?: number, color?: string, bg?: string);
    createCanvas(lineWidth: number | undefined, w: number, h: number): void;
    clearCanvas(): void;
    mount(el: MaybeElement): this;
    setColor(color: string): void;
    setBgColor(color: string): void;
    unmount(): void;
    listen(): void;
    undo(): void;
    redo(): void;
    erase(lineWidth?: number): void;
    unerased(): void;
    save(type?: string, quality?: number): string;
}

//#endregion
//#region src/canvas/DotImageCanvas.d.ts
/**
* DotImageCanvas 将图片转换为点阵图形式展示，并提供动画绘制效果
*
* 支持多种绘制方向，颜色控制，背景设置，以及动画效果控制
* @class
*/
declare class DotImageCanvas {
    /** 用于绘制的 Canvas 元素 */
    canvas: HTMLCanvasElement;
    /** Canvas 的绘制上下文 */
    ctx: CanvasRenderingContext2D;
    /** 缓存已处理图像的点阵数据 */
    points: Map<string, Record<string, any>>;
    /** 原始图片源地址 */
    originSrc: string;
    /** 点阵图颜色，设置后将覆盖原图颜色 */
    color: string;
    /** 点阵粗细，影响绘制的圆点大小 */
    fontWeight: number;
    /** 绘制状态：pending-绘制中，success-完成，fail-失败，reverted-已撤销 */
    status: string;
    /** 背景颜色 */
    bgColor?: string;
    /** 停止当前动画的函数 */
    stop: () => void;
    /** 绘制方向 */
    direction: Direction;
    /** 所有绘制任务 */
    allTasks: Function[];
    /** 已完成的任务索引 */
    completedTaskIndex: number;
    /** 是否正在撤销绘制 */
    isReverting: boolean;
    /** 每个绘制任务中的点坐标记录 */
    drawnPoints: Array<{
        x: number;
        y: number;
        color: any;
    }[]>;
    /** 清除任务列表 */
    clearTasks: Function[];
    /** 是否使用优先渲染模式 (RAF) */
    isPreferred: boolean;
    /** 是否已挂载到DOM */
    mounted: boolean;
    /**
     * 创建 DotImageCanvas 实例
     *
     * @param {string | DotImageCanvasOptions} srcOrOptions - 图片URL或选项对象
     * @param {string} [color] - 绘制颜色，为空时保留原图颜色
     * @param {number} [fontWeight] - 点阵粗细
     * @param {string} [bgColor] - 背景颜色
     * @param {Direction} [direction] - 绘制方向
     */
    constructor(srcOrOptions: string | DotImageCanvasOptions, color?: string, fontWeight?: number, bgColor?: string, direction?: Direction);
    createDotImage(img: HTMLImageElement): (string | number | undefined)[][];
    createImage(): Promise<unknown> | undefined;
    hasImage(): boolean;
    executor(): Promise<this>;
    /**
     * 创建绘制和清除任务的辅助方法 - 保持原有实现方式
     */
    createDrawAndClearTasks(pointsGenerator: () => {
        x: number;
        y: number;
        color: any;
    }[], size: number): {
        drawTask: () => void;
        clearTask: () => void;
    };
    getCanvas(imagePointSet: (string | number | undefined)[][]): void;
    startAnimation(): this;
    revert(): this;
    continue(): this;
    initOptions(src: string, color: string, fontWeight: number, bgColor: string, direction?: Direction): void;
    /**
     * 重新绘制图像，可以更新配置
     *
     * @param {string | Partial<DotImageCanvasOptions>} srcOrOptions - 图片URL或选项对象
     * @param {string} [color] - 点阵颜色
     * @param {number} [fontWeight] - 点阵粗细
     * @param {string} [bgColor] - 背景颜色
     * @param {Direction} [direction] - 绘制方向
     * @returns {Promise<DotImageCanvas>} 更新后的实例
     */
    repaint(srcOrOptions: string | Partial<DotImageCanvasOptions>, color?: string, fontWeight?: number, bgColor?: string, direction?: Direction): Promise<this>;
    clearCanvas(): void;
    append(container: MaybeElement): this;
    destory(): void;
}

//#endregion
//#region src/canvas/DotTextCanvas.d.ts
/**
* DotTextCanvas 将文字转换为点阵形式展示，并提供动画绘制效果
*
* 支持多种绘制方向、颜色控制、间距设置以及动画效果
* @class
*/
declare class DotTextCanvas {
    /** 用于绘制的 Canvas 元素 */
    canvas: HTMLCanvasElement;
    /** Canvas 的绘制上下文 */
    ctx: CanvasRenderingContext2D;
    /** 缓存已处理字符的点阵数据 */
    points: Map<string, Array<number[]>>;
    /** 原始文本内容 */
    originText: string;
    /** 字体大小 */
    fontSize: number;
    /** 点阵颜色 */
    color: string;
    /** 点阵粗细，影响绘制的圆点大小 */
    fontWeight: number;
    /** 绘制方向 */
    direction: Direction;
    /** 全局字符间距，默认为0 */
    charSpacing: number;
    /** 每个字符对之间的间距数组，优先级高于全局间距 */
    charSpacings: number[];
    /** 存储最终合成的点阵数据 */
    textPointSet: Array<number[]>;
    /** 绘制状态：pending-绘制中，success-完成 */
    status: string;
    /** 容器元素 */
    container?: HTMLElement;
    /** 停止当前动画的函数 */
    stop: () => void;
    /** 是否已挂载到DOM */
    mounted: boolean;
    /** 是否使用优先渲染模式(RAF) */
    isPreferred: boolean;
    /** 用于文本绘制的临时Canvas元素 */
    private _textCanvas?;
    /** 临时Canvas的绘制上下文 */
    private _textCtx?;
    /**
     * 创建 DotTextCanvas 实例
     *
     * @param {string | DotTextCanvasOptions} textOrOptions - 文本内容或选项对象
     * @param {number} [fontSize] - 字体大小
     * @param {string} [color] - 点阵颜色
     * @param {number} [fontWeight] - 点阵粗细
     * @param {Direction} [direction] - 绘制方向
     * @param {boolean} [isPreferred] - 是否使用优先渲染模式
     * @param {number} [charSpacing] - 全局字符间距
     * @param {number[]} [charSpacings] - 每个字符对之间的间距数组
     */
    constructor(textOrOptions: string | DotTextCanvasOptions, fontSize?: number, color?: string, fontWeight?: number, direction?: Direction, isPreferred?: boolean, charSpacing?: number, charSpacings?: number[]);
    /**
     * 为单个字符创建点阵数据
     *
     * @param {string} text - 要转换为点阵的字符
     * @returns {Array<number[]>} 字符的点阵数据
     */
    createTextPoint(text: string): number[][];
    /**
     * 执行文字点阵转换流程
     */
    executor(): void;
    /**
     * 获取字符的点阵数据，如果不存在则创建
     *
     * @param {string} text - 要获取点阵数据的字符
     * @returns {Array<number[]>|undefined} 字符的点阵数据
     */
    getText(text: string): number[][] | undefined;
    /**
     * 合并所有字符的点阵数据，并应用字符间距
     *
     * @returns {Array<number[]>} 合并后的点阵数据
     */
    combineText(): number[][];
    /**
     * 根据绘制方向生成点坐标数组
     *
     * @param {number} h - 点阵高度
     * @param {number} w - 点阵宽度
     * @returns {Array<[number, number]>} 按指定方向排列的点坐标数组
     */
    getPointsForDirection(h: number, w: number): Array<[number, number]>;
    /**
     * 设置Canvas大小并准备绘制
     */
    getCanvas(): void;
    /**
     * 创建分批绘制任务
     *
     * @param {Array<[number, number]>} pointsToDraw - 要绘制的点坐标数组
     * @param {number} batchSize - 每批绘制的点数量
     * @param {Function} getPoint - 点坐标计算函数
     * @param {number} size - 点的大小
     * @returns {Array<Function>} 绘制任务数组
     */
    createDrawTasks(pointsToDraw: Array<[number, number]>, batchSize: number, getPoint: Function, size: number): Function[];
    /**
     * 创建一批点的绘制任务
     *
     * @param {Array<[number, number]>} points - 一批要绘制的点坐标
     * @param {Function} getPoint - 点坐标计算函数
     * @param {number} size - 点的大小
     * @returns {Function} 绘制任务函数
     */
    createBatchDrawTask(points: Array<[number, number]>, getPoint: Function, size: number): () => void;
    /**
     * 开始执行动画绘制
     *
     * @param {Array<Function>} tasks - 绘制任务数组
     */
    startDrawing(tasks: Array<Function>): void;
    /**
     * 重新绘制文字，可以更新配置
     *
     * @param {string | Partial<DotTextCanvasOptions>} textOrOptions - 文本内容或选项对象
     * @param {number} [fontSize] - 字体大小
     * @param {string} [color] - 点阵颜色
     * @param {number} [fontWeight] - 点阵粗细
     * @param {Direction} [direction] - 绘制方向
     * @returns {DotTextCanvas} 当前实例
     */
    repaint(this: any, textOrOptions: string | Partial<DotTextCanvasOptions>, fontSize?: number, color?: string, fontWeight?: number, direction?: Direction): DotTextCanvas;
    /**
     * 清除Canvas上的内容
     */
    clearCanvas(): void;
    /**
     * 将Canvas元素添加到DOM容器中
     *
     * @param {MaybeElement} container - 要插入的容器元素
     * @returns {DotTextCanvas} 当前实例
     */
    append(container: MaybeElement): this;
    /**
     * 销毁实例，移除DOM元素并停止所有动画
     */
    destory(): void;
}

//#endregion
//#region src/canvas/getImageData.d.ts
declare function getImageData(src: string): Promise<ImageData$1>;

//#endregion
//#region src/canvas/removeRoundSpace.d.ts
declare function removeRoundSpace(data: number[][]): number[][];

//#endregion
//#region src/canvas/sliderValidation.d.ts
declare function sliderValidation(url: string, container: HTMLElement | string, l: number | (() => void) | undefined, callback: () => void): Promise<void>;

//#endregion
//#region src/canvas/Line.d.ts
declare class Line {
    ctx: CanvasRenderingContext2D;
    color: string;
    isFill: boolean;
    constructor(ctx: CanvasRenderingContext2D, color?: string, isFill?: boolean);
    draw(points: number[][], color?: string): void;
}

//#endregion
//#region src/canvas/Point.d.ts
declare class Point {
    r: number;
    ctx: CanvasRenderingContext2D;
    color: string;
    constructor(ctx: CanvasRenderingContext2D, r?: number, color?: string);
    draw(x: number, y: number, color?: string, r?: number): void;
}

//#endregion
//#region src/canvas/Square.d.ts
declare class Square {
    ctx: CanvasRenderingContext2D;
    r: number;
    color: string;
    isFill: boolean;
    constructor(ctx: CanvasRenderingContext2D, r?: number, color?: string, isFill?: boolean);
    draw(x: number, y: number, r?: number): void;
}

//#endregion
//#region src/compress/compressCss.d.ts
declare function compressCss(s: string): string;

//#endregion
//#region src/compress/compressImage.d.ts
type CompressImageOptionsType = 'base64' | 'blob';
interface CompressImageOptions {
    quality?: number;
    maxWidth?: number;
    maxHeight?: number;
    type?: CompressImageOptionsType;
}
declare function compressImage(source: string | File, options?: CompressImageOptions): Promise<unknown>;

//#endregion
//#region src/css/getClasses.d.ts
declare const classesReg: RegExp;
declare function getClasses(str: string, callback: (classes: string, block: string, index: number) => string): string;

//#endregion
//#region src/css/getCssVar.d.ts
declare function getCssVar(element: MaybeElement, style: string, callback: (css: string) => void): void;

//#endregion
//#region src/css/hasClassName.d.ts
declare function hasClassName(element: Element, className: string): boolean;

//#endregion
//#region src/css/setCssVar.d.ts
declare function setCssVar(element: MaybeElement, styleObj: Record<string, string>): void;

//#endregion
//#region src/css/useNamespace.d.ts
declare function useNamespace(defaultNamespace: string): (block: string) => {
    namespace: string;
    b: (blockSuffix?: string) => string;
    e: (element?: string) => string;
    m: (modifier?: string) => string;
    be: (blockSuffix?: string, element?: string) => string;
    em: (element?: string, modifier?: string) => string;
    bm: (blockSuffix?: string, modifier?: string) => string;
    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
    is: {
        (name: string, state: boolean | undefined): string;
        (name: string): string;
    };
    cssVar: (object: Record<string, string>) => Record<string, string>;
    cssVarName: (name: string) => string;
    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
    cssVarBlockName: (name: string) => string;
};

//#endregion
//#region src/css/setStyle.d.ts
declare function setStyle(el: HTMLElement | string, styleObj: Record<string, any>): void;

//#endregion
//#region src/css/removeStyle.d.ts
declare function removeStyle(el: HTMLElement | string, styles: string[] | string): void;

//#endregion
//#region src/css/addStyleRules.d.ts
/**
*
* @param { string } rule '#blanc { color: white }'
* @param { number } [index] cssRules 中的位置
*/
declare function addRules(rule: string, index?: number): void;

//#endregion
//#region src/css/addClass.d.ts
/**
* dom上添加class
* @param { MaybeElement } selector 元素
* @param { string } className class类
* @returns
*/
declare function addClass(selector: MaybeElement, className: string): void;

//#endregion
//#region src/css/removeClass.d.ts
/**
* dom上删除class
* @param { MaybeElement } selector 元素
* @param { string } className class类
* @returns
*/
declare function removeClass(selector: MaybeElement, className: string): void;

//#endregion
//#region src/date/formateDate.d.ts
declare function formateDate(datetime: Date, fmt?: string): string;

//#endregion
//#region src/date/getDateList.d.ts
/**
* Generates a list of dates starting from a given date.
*
* @param {string} start - The start date in the format 'YYYY-MM-DD' or 'YYYY/MM/DD'.
* @param {number} [day] - The number of days to generate. If negative, dates will be generated in reverse order.
* @returns {string[]} An array of date strings in the format 'YYYY-MM-DD'.
*
* @example
* ```typescript
* getDateList('2023-01-01', 5);
* // Returns ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05', '2023-01-06']
* ```
*/
declare function getDateList(start: string, day?: number): string[];

//#endregion
//#region src/date/getDaysOfMonth.d.ts
/**
* Returns the number of days in a given month.
*
* @param {number} currentMonth - The month for which to get the number of days (0-based, where 0 = January, 11 = December).
* @returns {number} The number of days in the specified month.
*/
declare function getDaysOfMonth(currentMonth: number): number;

//#endregion
//#region src/date/createCalendar.d.ts
/**
* 返回当前月份的日历数组信息
* @param currentMonth 今天的月份-1 从0开始
* @returns number[][]
*/
declare function createCalendar(currentMonth: number): unknown[][];

//#endregion
//#region src/date/compareDate.d.ts
/**
* 比较2个月份的大小
* @param date1 '2021-02-01' | '2021/02/01'
* @param date2 '2021-03-02' | '2021/03/02'
* @param separator '-' | '/' 默认 '-'
* @returns -1 | 1 | 0
*/
declare function compareDate(date1: DateString, date2: DateString, separator?: '-' | '/'): 0 | 1 | -1;

//#endregion
//#region src/date/compareTime.d.ts
/**
* 比较两个时间的大小
*
* 该函数接受两个时间字符串，格式为 'HH:MM'，并比较它们的大小。
* 返回值为 0 表示两个时间相同，1 表示第一个时间大于第二个时间，-1 表示第一个时间小于第二个时间。
*
* @param {string} time1 - 第一个时间字符串，格式为 'HH:MM'
* @param {string} time2 - 第二个时间字符串，格式为 'HH:MM'
* @returns {number} - 返回 0 表示两个时间相同，1 表示第一个时间大于第二个时间，-1 表示第一个时间小于第二个时间
*/
declare function compareTime(time1: string, time2: string): 0 | 1 | -1;

//#endregion
//#region src/date/compareDateTime.d.ts
/**
* 比较2个日期时间的大小
* @param date1 '2021-02-01 12:00:01' | '2021/02/01 12:00:01'
* @param date2 '2021-03-02 12:00:00' | '2021/03/02 12:00:00'
* @param separator '-' | '/' 默认 '-'
* @returns -1 | 1 | 0
*/
declare function compareDateTime(date1: DateString, date2: DateString): 0 | 1 | -1;

//#endregion
//#region src/date/getFirstDay.d.ts
/**
* 获取当前周的周一日期
* @returns
*/
declare function getFirstDay(): string;

//#endregion
//#region src/date/getDifferenceDays.d.ts
declare function getDifferenceDays(date1: Date | string, date2?: Date | string, unit?: TimeUnit): number;

//#endregion
//#region src/event/createElement.d.ts
/**
* 创建dom元素
* @param { string } tag 创建的标签元素
* @param { Record<string, string> } [attributes] 属性 {}
* @param { string } [innerHTML] 插入的内容innerHTML
* @param { ElementCreationOptions } [options] 通过 customElements.define() 定义的自定义元素的标签名称
* @returns
*/
declare function createElement<T extends keyof HTMLElementTagNameMap>(tag: T, attributes?: Record<string, string>, innerHTML?: string, options?: ElementCreationOptions): HTMLElementTagNameMap[T];

//#endregion
//#region src/event/createFragment.d.ts
/**
* 创建fragment
* @returns
*/
declare function createFragment(): DocumentFragment;

//#endregion
//#region src/event/dragEvent.d.ts
/**
* 拖砖
* @param { HTMLElement | string } target 元素
* @param { DragEvent } options {}
* @param { (e: any) => void } options.dragStart 开始拖拽callback
* @param { (e: any) => void } options.dragMove 拖拽过程callback
* @param { (e: any) => void } options.dragEnd 拖拽结束callback
* @param trigger
* @returns
*/
declare function dragEvent(target: HTMLElement | string, options?: DragEvent, trigger?: boolean): () => true | undefined;

//#endregion
//#region src/event/findElement.d.ts
/**
* 查找元素
* @param { string | string[] } selector 选择器
* @param { boolean } [all] 是否获取所有节点
* @param { HTMLElement | Document } [currentNode] 在哪个节点下查找
*/
declare function findElement(selector: string | string[]): HTMLElement | null;
declare function findElement<T extends boolean | HTMLElement>(selector: string | string[], all?: T, currentNode?: HTMLElement | Document): T extends true ? NodeListOf<Element> | undefined : HTMLElement | null;

//#endregion
//#region src/event/insertElement.d.ts
/**
* 插入元素
* @param { HTMLElement | string } parent 父元素
* @param { HTMLElement | DocumentFragment | string } element 将被插入的元素
* @param { HTMLElement } target 插入在这个元素之前
* @returns
*/
declare function insertElement(parent: HTMLElement | string, element: HTMLElement | DocumentFragment | string, target?: HTMLElement | null): void;

//#endregion
//#region src/event/removeElement.d.ts
/**
* 删除元素
* @param {  HTMLElement | ChildNode | DocumentFragment | string } el 待被删除的节点
* @returns 父节点
*/
declare function removeElement(el: HTMLElement | ChildNode | DocumentFragment | string): HTMLElement | null;

//#endregion
//#region src/event/useClick.d.ts
/**
* 点击事件
* @param { MaybeElement } target 元素
* @param { (e: MouseEvent) => void } callback 点击回调
* @returns 停止
*/
declare function useClick(target: MaybeElement | Document, callback: (e: MouseEvent) => void): () => true | undefined;

//#endregion
//#region src/event/useElementBounding.d.ts
/**
* getBoundingClientRect
* @param { Element | string } element 元素
* @param { (rect: DOMRect) => void } callback 位置变化回调函数
* @returns 停止
*/
declare function useElementBounding(element: Element | string, callback: (rect: DOMRect) => void): () => void;

//#endregion
//#region src/event/useEventListener.d.ts
/**
* 事件监听
* @param { Window | Document | Element | string } target 元素
* @param { T } eventName 事件名
* @param { (e: (WindowEventMap & DocumentEventMap)[T]) => void } callback 回调
* @param { boolean | AddEventListenerOptions } useCapture 捕获
* @param { boolean } autoRemove 是否自动被移除
* @returns 停止
*/
declare function useEventListener<T extends keyof (WindowEventMap & DocumentEventMap)>(target: Window | Document | Element | MediaQueryList | string, eventName: T, callback: (e: (WindowEventMap & DocumentEventMap)[T]) => void, useCapture?: boolean | AddEventListenerOptions, autoRemove?: boolean): () => void;

//#endregion
//#region src/event/useFocus.d.ts
/**
* input聚焦
* @param { MaybeElement } target 元素
*/
declare function useFocus(target?: MaybeElement): void;

//#endregion
//#region src/event/useHover.d.ts
/**
* 元素hover事件
* @param { MaybeElement } target 元素
* @param { (isHover: boolean, e: MouseEvent) => void } callback hover回调
* @returns
*/
declare function useHover(target: MaybeElement, callback: (isHover: boolean, e: MouseEvent) => void): () => void;

//#endregion
//#region src/event/useIntersectionObserver.d.ts
interface IntersectionObserverOptions {
    root?: Element | Document | string | null;
    rootMargin?: string;
    threshold?: number | number[];
}
/**
* 检测物体可见
* @param { Element | string } element 元素
* @param { (entries: IntersectionObserverEntry[]) => void } callback 元素可见回调
* @param { IntersectionObserverOptions } options {}
* @param { Element | Document | string | null } options.root 相对容器节点
* @param { string } options.rootMargin 相对容器节点位置"10px 20px 30px 40px"
* @param { number | number[] } options.threshold 相对容器节点百分比 [0, 0.25, 0.5, 0.75, 1]
* @returns
*/
declare function useIntersectionObserver(element: Element | string, callback: (entries: IntersectionObserverEntry[]) => void, options?: IntersectionObserverOptions): () => void;

//#endregion
//#region src/event/useInterval.d.ts
type UseIntervalReturn<T> = T extends Function ? () => void : undefined;
/**
* setInterval
* @param { Function } fn 函数
* @param { number } duration 间隔时间
* @returns 停止
*/
declare function useInterval<T>(fn: T, duration: number): UseIntervalReturn<T>;

//#endregion
//#region src/event/useKeyBoard.d.ts
/**
* 检测指定按键
* @param { string } c 按键字符串
* @param { Function } callback 按键与案件字符串一致时的回调
* @returns 停止
*/
declare function useKeyBoard(c: string, callback: (code: string) => void): () => void;

//#endregion
//#region src/event/useMouse.d.ts
/**
* 检测鼠标移动
* @param { Function } callback 坚挺鼠标移动回调
* @param { number } delay 间隔多久触发
* @returns 停止
*/
declare function useMouse(callback: (e: MouseEvent) => void, delay?: number): () => void;

//#endregion
//#region src/event/useMutationObserver.d.ts
/**
* 检测元素变化
* @param { Element | string | ParentNode | null } element 元素
* @param { MutationCallback } callback 默认 { childList: true }
* @param { boolean } [callback.childList] 是否监听孩子元素
* @param { boolean } [callback.attributes] 是否监听属性
* @param { boolean } [callback.characterData] 是否监听内容
* @param { boolean } [callback.subtree] 是否监听树节点
* @param { boolean } [callback.attributeOldValue] 是否监听旧属性
* @param { string[] } [callback.attributeFilter] 属性过滤
* @param options
* @returns
*/
declare function useMutationObserver(element: Element | string | ParentNode | Text | null, callback: MutationCallback, options?: MutationObserverInit): (() => true | undefined) | undefined;

//#endregion
//#region src/event/useResizeObserver.d.ts
/**
* 检测视口变化
* @param { Function } callback 浏览器尺寸变化回调
* @returns
*/
declare function useResizeObserver(callback: (width: number, height: number) => void): () => void;

//#endregion
//#region src/event/useWindowScroll.d.ts
/**
* 检测浏览器滚动
* @param { Function } callback 坚挺浏览器滚动条位置变化回调
* @returns 停止
*/
declare function useWindowScroll(callback: (left: number, top: number) => void): () => void;

//#endregion
//#region src/event/useTimeout.d.ts
/**
* setTimeout
* @param { Function } fn 函数
* @param { number } duration 间隔时长
* @returns 停止
*/
declare function useTimeout<T>(fn: T, duration?: number): UseTimeoutReturn<T>;

//#endregion
//#region src/event/collisionDetection.d.ts
/**
* 检测2个物体是否碰撞
* @param { MaybeElement } o1 元素1
* @param { MaybeElement } o2 元素2
* @returns
*/
declare function collisionDetection(o1: MaybeElement, o2: MaybeElement): boolean;

//#endregion
//#region src/event/download.d.ts
/**
* 下载
* @param { string } href 链接
* @param { string } download 名字
*/
declare function download(href: string, download?: string): void;

//#endregion
//#region src/event/useHead.d.ts
interface IMeta {
    name: 'description' | 'viewport' | 'keywords' | 'robots' | string;
    content: string;
}
interface IScript {
    src: string;
    type: 'async' | 'module' | 'nomodule' | 'defer';
}
interface ILink {
    rel: 'stylesheet' | 'preload' | 'icon' | 'prefetch' | string;
    href: string;
}
interface HeadOptions {
    title?: string | (() => string);
    meta?: IMeta[];
    script?: IScript[];
    link?: ILink[];
}
/**
* 创建head相关标签
* @param { HeadOptions } options
* @param { string | (() => string) } options.title 返回一个title字符串
* @param { IMeta[] } options.meta 'description' | 'viewport' | 'keywords' | 'robots' | string
* @param { IScript[] } options.script 'async' | 'module' | 'nomodule' | 'defer'
* @param { ILink[] } options.link 'stylesheet' | 'preload' | 'icon' | 'prefetch' | string
* @returns 移除函数
*/
declare function useHead(options: HeadOptions): HTMLElement | null;

//#endregion
//#region src/event/useLongPress.d.ts
/**
* 检测元素鼠标长按
* @param { MaybeElement } el 元素
* @param { number } ms 时长
* @param { Function } callback 回调
* @returns 停止
*/
declare function useLongPress(el: MaybeElement, ms: number, callback: () => void): () => void;

//#endregion
//#region src/event/useBlur.d.ts
/**
* 失去焦点
* @param { MaybeElement } el 元素
* @param { Function } callback 失去焦点时的回调
* @returns 停止
*/
declare function useBlur(el: MaybeElement, callback: () => void): () => true | undefined;

//#endregion
//#region src/event/createTextNode.d.ts
declare function createTextNode(text: string): Text;

//#endregion
//#region src/event/useRange.d.ts
/**
* 获取target元素所在位置最后的位置
* 注意如果外容器有偏移量，需要减去偏移量
* @param target
* @returns
*/
declare function useRange(target: Node): DOMRect;

//#endregion
//#region src/flex/waterfall.d.ts
/**
* 创建图片瀑布流
* @param { string[] } imageList 图片列表
* @param { string } target mount元素 默认 body
* @param { number } width 图片宽度 默认 200
* @param { number } space 图片间距 默认 20
* @returns
*/
declare function waterfall(imageList: string[], target: MaybeElement | number, width?: number, space?: number): (imageList: string[]) => void;

//#endregion
//#region src/html/escapeHtml.d.ts
/**
* 转义html
* @param { string } s 字符串
* @returns
*/
declare function escapeHtml(s: string): string;

//#endregion
//#region src/html/htmlTransform.d.ts
interface Update {
    setAttribs: (key: string, value?: string) => void;
    beforeInsert: (str: string) => void;
    afterInsert: (s: string) => void;
    renameAttribs: (key: string, value: string) => void;
}
type HtmlTransformOptions = Record<string, (node: Element$1, update: Update) => void>;
/**
* htmlparser
* @param { string } s 字符串
* @param options {}
* @param { (key: string, value?: string) => void } options.setAttribs 设置属性
* @param { (str: string) => void } options.beforeInsert 插入前
* @param { (s: string) => void } options.afterInsert 插入后
* @param { (key: string, value?: string) => void } options.renameAttribs 重命名
* @returns
*/
declare function htmlTransform(s?: string, options?: HtmlTransformOptions): Promise<string>;

//#endregion
//#region src/html/unescapeHtml.d.ts
/**
* 反转义html
* @param { string } s 字符串
* @returns
*/
declare function unescapeHtml(s: string): string;

//#endregion
//#region src/html/getStyles.d.ts
declare const stylesReg: RegExp;
/**
*
* @param { string } str 字符串模板
* @param { Function } callback 读取style时的回调
* @returns
*/
declare function getStyles(str: string, callback: (style: string, block: string, index: number) => string): string;

//#endregion
//#region src/https/httpsRedirect.d.ts
/**
* http重定向到https
*/
declare function httpsRedirect(): void;

//#endregion
//#region src/is/isAbsolute.d.ts
/**
* 判断是否是绝对路径
* @param url
* @returns
*/
declare function isAbsolute(url: string): boolean;

//#endregion
//#region src/is/isArray.d.ts
/**
* 判断是否是数组
*/
declare const isArray: (arg: any) => arg is any[];

//#endregion
//#region src/is/isBlob.d.ts
/**
* 判断是否是blob
* @param o
* @returns
*/
declare function isBlob(o: any): o is Blob;

//#endregion
//#region src/is/isBool.d.ts
/**
* 判断是否是boolean类型
* @param value
* @returns
*/
declare function isBool(value: any): value is boolean;

//#endregion
//#region src/is/isBottom.d.ts
/**
* 判断滚动条到达窗口底部
* @param distance
* @returns
*/
declare function isBottom(distance?: number): boolean;

//#endregion
//#region src/is/isBrowser.d.ts
declare const isBrowser: boolean;

//#endregion
//#region src/is/isContainCn.d.ts
/**
* 判断是否包含中文
* @param s
* @returns
*/
declare function isContainCn(s: string): boolean;

//#endregion
//#region src/is/isDate.d.ts
/**
* 判断是否是日期格式
* @param d
* @returns
*/
declare function isDate(d: any): d is Date;

//#endregion
//#region src/is/isDef.d.ts
/**
* 判断元素不是undefined
* @param v
* @returns
*/
declare function isDef<T = any>(v: T): v is T extends undefined ? never : T;

//#endregion
//#region src/is/isElement.d.ts
/**
* 判断元素是HTMLElement
* @param element
* @returns
*/
declare function isElement(element: any): element is HTMLElement;

//#endregion
//#region src/is/isEqual.d.ts
/**
* 判断2个对象是否相等
* @param { any } o1 对象1
* @param { any } o2 对象2
* @returns
*/
declare function isEqual(o1: any, o2: any): boolean;

//#endregion
//#region src/is/isEsModule.d.ts
/**
* 判断对象是ESModule
* @param obj
* @returns
*/
declare function isESModule(obj: any): obj is IsESModule;

//#endregion
//#region src/is/isFalse.d.ts
/**
* 判断是否是false
* @param v
* @returns
*/
declare function isFalse(v: any): v is false;

//#endregion
//#region src/is/isFileType.d.ts
/**
* 判断文件类型
* @param { string } file 文件路径
* @param { string } appendix 文件类型
* @returns
*/
declare function isFileType(file: string, appendix: string): boolean;

//#endregion
//#region src/is/isFn.d.ts
/**
* 判读是否是函数
* @param o
* @returns
*/
declare function isFn(o: any): o is Function;

//#endregion
//#region src/is/isIPv4.d.ts
/**
* 判断是否是ipv4
* @param ip
* @returns
*/
declare function isIPv4(ip: string): boolean;

//#endregion
//#region src/is/isIPv6.d.ts
/**
* 判断是否是ipv6
*/
declare function isIPv6(ip: string): boolean;

//#endregion
//#region src/is/isIdCard.d.ts
/**
* 判断是否是身份证
* @param s
* @returns
*/
declare function isIdCard(s: string): boolean;

//#endregion
//#region src/is/isLeapYear.d.ts
/**
* 判断是否是闰年
*/
declare function isLeapYear(year: number): boolean;

//#endregion
//#region src/is/isMap.d.ts
/**
* 判断是否是Map
*/
declare function isMap(o: any): o is Map<any, any>;

//#endregion
//#region src/is/isMobile.d.ts
/**
* 判断是否是手机号
*/
declare function isMobile(s: string): boolean;

//#endregion
//#region src/is/isNaN.d.ts
/**
* 判断是否是NaN
*/
declare function isNaN(o: any): boolean;

//#endregion
//#region src/is/isNil.d.ts
/**
* 判断是否是null或undefined
*/
declare function isNil(value: any): value is null | undefined;

//#endregion
//#region src/is/isNull.d.ts
/**
* 判断是否是null
*/
declare function isNull(o: any): o is null;

//#endregion
//#region src/is/isNum.d.ts
/**
* 判断是否是number类型
*/
declare function isNum(o: any): o is number;

//#endregion
//#region src/is/isObject.d.ts
/**
* 判断是否是对象
*/
declare function isObject(value: any): boolean;

//#endregion
//#region src/is/isPlainObject.d.ts
/**
* 判断是否是{}类型
*/
declare function isPlainObject(o: any): o is Record<any, any>;

//#endregion
//#region src/is/isPostCode.d.ts
/**
* 判断是否是邮编
*/
declare function isPostCode(s: string | number): boolean;

//#endregion
//#region src/is/isPromise.d.ts
/**
* 判断是否是promise
*/
declare function isPromise(o: any): o is Promise<any>;

//#endregion
//#region src/is/isReg.d.ts
/**
* 判断是否是正则
*/
declare function isReg(o: any): o is RegExp;

//#endregion
//#region src/is/isRelative.d.ts
/**
* 判断是否是相对路径
*/
declare function isRelative(str: string): boolean;

//#endregion
//#region src/is/isSameDay.d.ts
/**
* 判断是否是同一天
* @param { Date } dateLeft 日期一
* @param { Date } dateRight 日期二
*/
declare function isSameDay(dateLeft: Date, dateRight: Date): boolean;

//#endregion
//#region src/is/isSet.d.ts
/**
* 判断是否是Set
*/
declare function isSet(o: any): o is Set<any>;

//#endregion
//#region src/is/isStr.d.ts
/**
* 判断是否是字符串类型
*/
declare function isStr(o: any): o is string;

//#endregion
//#region src/is/isSupportCamera.d.ts
/**
* 判断是否支持调用摄像头
*/
declare function isSupportCamera(): boolean;

//#endregion
//#region src/is/isSupportWebp.d.ts
/**
* 判断是否支持webp格式
*/
declare function isSupportWebp(): boolean;

//#endregion
//#region src/is/isSymbol.d.ts
/**
* 判断是否是symbol类型
*/
declare function isSymbol(o: any): o is symbol;

//#endregion
//#region src/is/isTrue.d.ts
/**
* 判断是否是true
*/
declare function isTrue(v: any): v is true;

//#endregion
//#region src/is/isType.d.ts
/**
* 判断对象类型
*/
declare function isType<T>(s: T, type: string): boolean;

//#endregion
//#region src/is/isUndef.d.ts
/**
* 判断是否是undefined
*/
declare function isUndef(o: any): o is undefined;

//#endregion
//#region src/is/isUrl.d.ts
/**
* 判断是否是url
*/
declare function isUrl(url: string): boolean;

//#endregion
//#region src/is/isVideo.d.ts
/**
* 判断是否是video
*/
declare function isVideo(filepath: string): boolean;

//#endregion
//#region src/is/isWeakMap.d.ts
/**
* 判断是否是WeakMap
*/
declare function isWeakMap(o: any): o is WeakMap<any, any>;

//#endregion
//#region src/is/isWeakSet.d.ts
/**
* 判断是否是WeakSet
*/
declare function isWeakSet(o: any): o is WeakSet<any>;

//#endregion
//#region src/is/isWin.d.ts
/**
* 判断是windows电脑
*/
declare function isWin(): boolean;

//#endregion
//#region src/is/isSocketUrl.d.ts
/**
* 判断是否是websocket地址
*/
declare function isSocketUrl(url: string): boolean;

//#endregion
//#region src/is/isBase64.d.ts
/**
* 判断是否是base64格式
* @param { string } base64
* @returns
*/
declare function isBase64(base64: string): boolean;

//#endregion
//#region src/is/isTrainNumber.d.ts
/**
* 判断是否是火车号
*/
declare const isTrainNumber: (s: string) => boolean;

//#endregion
//#region src/is/isNameCn.d.ts
/**
* 判断输入的是中文
*/
declare const isNameCn: (s: string) => boolean;

//#endregion
//#region src/is/isNameEn.d.ts
/**
* 判断输入的是否是英文
*/
declare function isNameEn(s: string): boolean;

//#endregion
//#region src/is/isSoldierId.d.ts
/**
* 判断是否是军官证
*/
declare function isSoldierId(s: string): boolean;

//#endregion
//#region src/is/isVersion.d.ts
/**
* 判断是否是版本号
*/
declare function isVersion(version: string): boolean;

//#endregion
//#region src/is/isDivElement.d.ts
declare function isDivElement(target: unknown): target is HTMLDivElement;

//#endregion
//#region src/is/isIFrameElement.d.ts
declare function isIFrameElement(target: unknown): target is HTMLIFrameElement;

//#endregion
//#region src/is/isImageElement.d.ts
declare function isImageElement(target: unknown): target is HTMLImageElement;

//#endregion
//#region src/is/isNode.d.ts
declare function isNode(target: unknown): target is Node;

//#endregion
//#region src/is/isProxyDocument.d.ts
declare function isProxyDocument(target: unknown): target is Document;

//#endregion
//#region src/is/isScriptElement.d.ts
declare function isScriptElement(target: unknown): target is HTMLScriptElement;

//#endregion
//#region src/is/isShadowRoot.d.ts
declare function isShadowRoot(target: unknown): target is ShadowRoot;

//#endregion
//#region src/is/isStyleElement.d.ts
declare function isStyleElement(target: unknown): target is HTMLStyleElement;

//#endregion
//#region src/is/isVue.d.ts
/**
* 判断文件是不是.vue
* @param { string } src 文件路径
* @returns
*/
declare function isVue(src: string): boolean;

//#endregion
//#region src/is/isComment.d.ts
/**
* 判断是否是<! -- xxx -->注释
* @param { string } s 字符串
* @returns
*/
declare function isComment(s: string): boolean;

//#endregion
//#region src/is/isActive.d.ts
/**
* 判断当前页面是否处于活跃状态
* @returns
*/
declare function isActive(): boolean;

//#endregion
//#region src/is/isFile.d.ts
/**
* 判断是否是文件
* @param o
* @returns
*/
declare function isFile(o: Blob | string): o is File;

//#endregion
//#region src/js/listenStack.d.ts
/**
* 监听目标元素的子元素变化的栈
* @param { string | Element } target 元素
* @returns
*/
declare function listenStack(target: string | Element): (() => true | undefined) | undefined;

//#endregion
//#region src/js/copy.d.ts
/**
* 获取电脑粘贴板的内容
* @param { string } s 内容
* @returns
*/
declare function copy(s: string): boolean;

//#endregion
//#region src/js/curry.d.ts
/**
* 柯里化
* @param { Function } f 函数
* @returns 函数
*/
declare function curry(f: Function): (...args: any[]) => any;

//#endregion
//#region src/js/sleep.d.ts
/**
* 等待函数
* @param { number }  ms 延迟秒数
* @returns
*/
declare function sleep(ms: number): Promise<unknown>;

//#endregion
//#region src/js/parallel.d.ts
/**
* 并行执行
* @param { any[] } tasks 数组
* @param { (...args: any[]) => any } fn 函数
* @returns
*/
declare function parallel(tasks: any[], fn: (...args: any[]) => any): Promise<any[]>;

//#endregion
//#region src/js/promiseFinally.d.ts
/**
*
* @param { Function } fn 函数 ｜ 异步函数
* @param { Function } finalFn 函数
* @returns
*/
declare function promiseFinally(fn: Promise<any> | Function, finalFn: Function): Promise<any>;

//#endregion
//#region src/js/timeout.d.ts
/**
* 超时函数
* @param { Function } fn 函数
* @param { number } ms 时间
* @param { string } msg 错误消息
* @returns
*/
declare const timeout: (fn: Function, ms: number, msg: string) => Promise<any>;

//#endregion
//#region src/js/noop.d.ts
declare function noop(): void;

//#endregion
//#region src/js/chainFns.d.ts
/**
* 链式调用
* @param { Function[] } fns 函数数组
* @returns
*/
declare function chainFns(...fns: Function[]): Function;

//#endregion
//#region src/js/nextTick.d.ts
/**
*
* @param { () => any } flushCallbacks 函数
* @returns
*/
declare function nextTick(flushCallbacks: () => any): void;

//#endregion
//#region src/js/singleModel.d.ts
/**
* 单例模式
*/
declare function singleModel(className: any): any;

//#endregion
//#region src/js/useWebWorker.d.ts
/**
* webWorker
* @param { string } [url] url自定义worker文件路径 或者 worker函数
*/
declare function useWebWorker(url: string): any;
declare function useWebWorker(useWebWorkerThread: () => void): any;

//#endregion
//#region src/js/useServiceWorker.d.ts
/**
*
* @param url url自定义worker文件路径 或者 worker函数
* @param { RegistrationOptions } options {
*  scope?: string;
*  type?: WorkerType;
*  updateViaCache?: ServiceWorkerUpdateViaCache;
*  }
* @returns
*/
declare function useServiceWorker(url: string | (() => void), options: RegistrationOptions): Promise<ServiceWorkerRegistration>;

//#endregion
//#region src/js/noopFalse.d.ts
declare const noopFalse: () => boolean;

//#endregion
//#region src/js/updateDetection.d.ts
/**
* 用户停留在老页面但是已经有新的版本
*/
/**
* 检测首页中script src是否存在更新
* @param { number } s 检测时间间隔 默认 2000
* @param callback 如果页面检测出有更新则会被调用
* @returns
*/
declare function updateDetection(s: number | undefined, callback: () => void): () => void;

//#endregion
//#region src/js/streamToUrl.d.ts
/**
* 将流文件转为base64
* @param { ArrayBuffer } stream 流
* @returns
*/
declare function streamToUrl(stream: ArrayBuffer): Promise<string>;

//#endregion
//#region src/js/useReader.d.ts
/**
* 读取ReadableStream
* @param { ReadableStreamDefaultReader<Uint8Array> } reader getReader() 的结果
* @param { Function } callback 每片读取的回调
* @returns
*/
declare function useReader(reader: ReadableStreamDefaultReader<Uint8Array>, callback?: (value?: any) => any): Promise<string>;

//#endregion
//#region src/js/useSwitch.d.ts
declare function useSwitch(options: any[]): () => any;

//#endregion
//#region src/js/catchAwait.d.ts
declare function catchAwait<T, U = Error>(promise: Promise<T> | any, errorExt?: object): Promise<[U, undefined] | [undefined, T]>;

//#endregion
//#region src/js/executeStr.d.ts
declare function executeStr(str: string): any;

//#endregion
//#region src/js/handleImageError.d.ts
/**
* handleImageError
* @param errorImageSrc string[] - Array of image sources to use as fallback
* @returns (event: Event) => void - Function to handle error event on image element
*/
declare function handleImageError(errorImageSrc: string[]): (event: Event) => void;

//#endregion
//#region src/js/replaceAsync.d.ts
declare function replaceAsync(str: string, searchValue: string | RegExp, replaceValue: string | ((...args: any[]) => string | Promise<string>)): Promise<string>;

//#endregion
//#region src/js/reduceAsync.d.ts
declare function reduceAsync<T, K>(arr: K[], reducer: (acc: T, item: K, index: number, arr: K[]) => any, initialValue: T): Promise<T>;

//#endregion
//#region src/js/retryAsync.d.ts
declare function retryAsync<T>(fn: () => Promise<T>, retries: number): Promise<T>;

//#endregion
//#region src/log/debugWarn.d.ts
declare function throwError(scope: string, m: string): never;
declare function debugWarn(err: Error): void;
declare function debugWarn(scope: string, message: string): void;

//#endregion
//#region src/log/globalErrorCapture.d.ts
/**
* 全局错误捕获
*/
declare function globalErrorCapture(): () => void;

//#endregion
//#region src/log/interceptError.d.ts
declare function interceptError(fn: Function): Promise<unknown>;

//#endregion
//#region src/log/log.d.ts
/**
* 日志输出
* @param { string } s 内容
* @param { Record<string, string | number>  } styleObj 样式
* @param { string } type 类型 'warn' | 'error' | 'log'
*/
declare function log(s: string | number, options?: {
    type?: 'warn' | 'error' | 'log';
    style?: Record<string, string | number> | string;
    args?: any[];
}): void;

//#endregion
//#region src/message/createEventBus.d.ts
/**
* eventbus
*/
declare function createEventBus(): EventBus;

//#endregion
//#region src/message/useStorageListen.d.ts
/**
*  跨标签页通信通过storage事件实现
* @param { (type: string, newValue: any, oldValue: any) => void } callback storage数据更新回调
* @returns
*/
declare function useStorageListen(callback: (type: string, newValue: any, oldValue: any) => void): () => void;
declare function sendStorage(type: string, value: any): void;

//#endregion
//#region src/message/useSocket.d.ts
/**
* WebSocket
* @param { string } url 要连接的 URL；这应该是 WebSocket 服务器将响应的 URL。
* @param { string | string[] } [protocols] 一个协议字符串或者一个包含协议字符串的数组。
* @returns
*/
declare function useSocket(url: string, protocols?: string | string[]): {
    socket: WebSocket;
    receive: (callback: (event: MessageEvent<any>) => void) => void;
    send: (data: string | ArrayBufferLike | Blob | ArrayBufferView) => void;
    open: (callback: (event: Event) => void) => void;
    close: (callback: (event: Event) => void) => void;
    error: (callback: (event: Event) => void) => void;
};

//#endregion
//#region src/message/createChannel.d.ts
type Channel = BroadcastChannel & {
    listeners: Set<number>;
    id: number;
};
declare function createChannel(name: string): Channel;

//#endregion
//#region src/monitor/calFps.d.ts
declare function calFps(): () => void;

//#endregion
//#region src/monitor/getDevice.d.ts
/**
* 获取当前环境设备信息 os 手机设备 dev 浏览器环境
* @returns {DeviceType} 设备信息
*/
declare function getDevice(): DeviceType;

//#endregion
//#region src/monitor/monitorPef.d.ts
/**
* 检测性能指标
* @returns {Record<string, number> | null} 返回性能指标对象，如果不支持则返回null
*/
declare function monitorPef(): Record<string, number> | null;

//#endregion
//#region src/monitor/timeCost.d.ts
/**
* 检测函数执行耗时
* @param { Function } fn 函数
* @returns number
*/
declare function timeCost(fn: Function): number;

//#endregion
//#region src/monitor/getLocation.d.ts
/**
*
* @param { boolean } [enableHighAccuracy] 开启高精度模式 默认 false
* @param { number } [timeout] 超时时间 默认 5000
* @param { number } [maximumAge] 最大缓存位置时间 默认 0
* @returns
*/
declare function getLocation(enableHighAccuracy?: boolean, timeout?: number, maximumAge?: number): Promise<GeolocationCoordinates>;

//#endregion
//#region src/num/calNum.d.ts
/**
* add 数字求和
* sub 数字求差
* mul 数字相乘
* div 数字相除
*/
declare const calNum: {
    add(...args: (number | string)[]): number;
    sub(...args: (number | string)[]): number;
    mul(...args: (number | string)[]): number;
    div(...args: (number | string)[]): number;
};

//#endregion
//#region src/num/formateNum.d.ts
/**
* 数字格式化
* @param { number } number 数字
* @param { number } decimals 小数位
* @param { 'floor' | 'ceil' } integer 向上截取 ｜ 向下截取 默认 'ceil'
* @returns
*/
declare function formateNum(number: number | string, decimals?: number, integer?: 'floor' | 'ceil'): string;

//#endregion
//#region src/num/uppercaseNum.d.ts
/**
* 大写数字
* @param { number } n 数字
* @returns 返回大写数字
*/
declare function uppercaseNum(n: number): string;

//#endregion
//#region src/num/multiply.d.ts
/**
* 乘倍
* @param { number | string } i
* @param { number } multiple 倍数
* @returns
*/
declare function multiply(i: number | string, multiple: number): string | number;

//#endregion
//#region src/num/isEven.d.ts
/**
* 判断偶数
* @param { number } n 数字
* @returns
*/
declare function isEven(n: number | string): boolean;

//#endregion
//#region src/object/deepMerge.d.ts
/**
* 深合并
* @param target 对象
* @param sources 其他对象
* @returns
*/
declare function deepMerge(target: Record<any, any>, ...sources: Record<any, any>[]): Record<any, any>;

//#endregion
//#region src/object/generateKeyObject.d.ts
declare function generateKeyObject(o: Record<string, any>, key: string, mapKey: string): {};

//#endregion
//#region src/object/mapTransform.d.ts
declare function mapTransform(o: Record<string, any>, map: Record<string, string>, keepRest?: boolean): Record<string, any>;
declare function mapTransformBack(o: Record<string, any>, map: Record<string, string>, keepRest?: boolean): {};

//#endregion
//#region src/object/stringify.d.ts
interface StringifyOptions {
    sep?: string;
    eq?: string;
    hyp?: boolean;
    px?: boolean;
    encode?: boolean;
}
/**
* 对象序列化
* @param { Record<string, string | number> } o {}
* @param { StringifyOptions } options {}
* @param { string } [options.sep] 分割字符 默认 &
* @param { string } [options.eq] 连接字符 默认 =
* @param { boolean } [options.hyp] aBb属性名转为a-bb
* @param { boolean } [options.px] 自动给数字添加px
* @param { boolean } [options.encode] 将结果encode
* @returns
*/
declare function stringify(o: Record<string, string | number>, options?: StringifyOptions): string;

//#endregion
//#region src/object/transformKey.d.ts
declare function transformKey(target: Record<string, any> | Record<string, any>[], options: Record<string, string>, deleteEmpty?: boolean): Record<string, any> | Record<string, any>[];

//#endregion
//#region src/object/traverse.d.ts
/**
* 通过函数的方式获取对象中指定的数据
* @param { Record<any, any> | any[] } target 对象或数组
* @param { Record<string, Function> } options {}
* @returns
*/
declare function traverse<T extends Record<any, any> | any[]>(target: T, options?: Record<string, (res: any, i: number, target: T) => void>): T;

//#endregion
//#region src/object/deepClone.d.ts
/**
* 神拷贝
* @param { any } target 克隆的目标
* @returns
*/
declare function deepClone(target: any): any;

//#endregion
//#region src/object/deepCompare.d.ts
/**
* 深比较
* @param { any } comp1 对象1
* @param { any } comp2 对象2
* @param { string[] | RegExp } ignoreKeys 忽律某项属性的比较
* @returns
*/
declare function deepCompare(comp1: any, comp2: any, ignoreKeys?: string[] | RegExp, error?: string[], errorMsg?: string[], name?: string, index?: string): {
    error: string[];
    errorMsg: string[];
};

//#endregion
//#region src/object/objectToMap.d.ts
declare function objectToMap(obj: Record<string, any>): Map<any, any>;

//#endregion
//#region src/object/mapToObject.d.ts
declare function mapToObject(map: Map<any, any>): Record<string, any>;

//#endregion
//#region src/parse/parse.d.ts
interface ParseOptions {
    sep?: string;
    eq?: string;
    camel?: boolean;
}
/**
*
* @param { string } str 字符串
* @param { ParseOptions } options {
sep?: string
eq?: string
camel?: boolean
}
* @param { string } options.seq 默认 &
* @param { string } options.eq 默认 =
* @param { string } options.camel 默认 false
* @returns
*/
declare function parse(str: string, options?: ParseOptions): Record<string, string>;

//#endregion
//#region src/parse/parseCss.d.ts
/**
* 解析css转换为对象
* @param { string } str
* @returns
*/
declare function parseCss(str: string): Record<string, string>;

//#endregion
//#region src/parse/parseUrl.d.ts
declare function hasProtocol(inputStr: string, acceptProtocolRelative?: boolean): boolean;
/**
* 解析URL
* @param { string } input 链接
* @param defaultProto
* @returns
*/
declare function parseURL(input?: string, defaultProto?: string): ParsedURL;
declare function parsePath(input?: string): ParsedURL;

//#endregion
//#region src/perf/debounce.d.ts
/**
* 防抖函数
* @param { Function } fn 函数
* @param { number } time 时间
* @returns
*/
declare function debounce(fn: Function, time: number): (this: any, e?: any) => void;

//#endregion
//#region src/perf/fileSplice.d.ts
/**
*
* @param { File } _file 文件
* @param { number } _chunkSize 切分大小 默认 1024 * 100
* @returns
*/
declare function fileSplice(options: FileSpliceOptions): Promise<ChunkDetail[]>;

//#endregion
//#region src/perf/getLru.d.ts
/**
*
* @param max 最大存储量 默认 50
* @returns
*/
declare function getLru(max?: number): LRU;

//#endregion
//#region src/perf/lazyLoad.d.ts
/**
*
* @param { MaybeElement } element 元素
* @param { string } loadingUrl 懒加载的loading图
* @returns { Function } 停止懒加载的函数
*/
declare function lazyLoad(element: MaybeElement, loadingUrl?: string): void;

//#endregion
//#region src/perf/memorizeFn.d.ts
/**
* 函数缓存结果
* @param { Function } fn 函数
* @param { Map<string, any> } cache 缓存对象
* @param { number } maxSize 最大缓存条目数，默认为100
* @returns { Function } 带缓存的函数
*/
declare function memorizeFn(fn: Function, cache?: Map<string, any>, maxSize?: number): (...args: any[]) => any;

//#endregion
//#region src/perf/preload.d.ts
/**
* 图片视频预加载函数
* @param { string[] } list 图片数组
* @param { string } style 设置样式
* @returns { HTMLImageElement[] } 图片数组
*/
declare function preload(list: string[] | string, style?: string): HTMLImageElement[];

//#endregion
//#region src/perf/prefetch.d.ts
/**
* 借助浏览器空闲时间去加载一些图片资源
* @param { string[] } list 图片或视频地址数组
* @param { number } timeRemaining 浏览器空闲时间大于多少去加载
* @returns { Function } 停止加载的函数
*/
declare function prefetch(list: string[], timeRemaining?: number): () => void;

//#endregion
//#region src/perf/throttle.d.ts
/**
* 截流函数
* @param { Function } fn 函数
* @param { number } stop 时间
* @returns
*/
declare function throttle(fn: Function, stop: number): (this: any, ...args: any[]) => any;

//#endregion
//#region src/perf/useRaf.d.ts
/**
* 使用 requestAnimationFrame 执行一个函数，并提供停止执行的功能。
*
* @param {function(number): void} fn - 在每一帧调用的函数，参数是时间戳。
* @param {object} [options] - 配置选项。
* @param {number} [options.delta] - 两次调用之间的最小时间间隔（毫秒）。
* @param {boolean} [options.autoStop] - 是否在首次调用后自动停止。
* @param {boolean} [options.immediate] - 是否在首次调用时立即执行。
* @returns {function(): void} - 停止执行的函数。
*/
declare function useRaf(fn: (timestamp: number) => void, options?: {
    delta?: number;
    autoStop?: boolean;
    immediate?: boolean;
}): () => void;

//#endregion
//#region src/perf/useRic.d.ts
interface Options$2 {
    timeRemaining?: number;
    timeout?: number;
    callback?: (taskArr: any[]) => void;
}
/**
* 浏览器空闲时期被调用
* @param { Function[] } tasks 函数队列
* @param { number } timeRemaining 剩余时间大于多少才继续执行
* @param { number } timeout 超时时间
* @param { Function } callback 回调
* @returns
*/
declare function useRic(tasks: Function[], options?: Options$2): () => void;

//#endregion
//#region src/perf/once.d.ts
/**
* 只执行一次函数
* @param { Function } fn 函数
* @returns { Function } 函数
*/
declare function once(fn: Function): Function;

//#endregion
//#region src/perf/createChunk.d.ts
declare function createChunk(file: File, index: number, chunkSize: number): Promise<ChunkInfo>;

//#endregion
//#region src/perf/createHybridMap.d.ts
type Primitive = string | number | symbol | boolean | null | undefined;
type KeyType = object | Primitive;
declare class HybridMap<K extends KeyType, V> {
    private objectStore;
    private primitiveStore;
    constructor(entries?: readonly (readonly [K, V])[] | null);
    private isObjectKey;
    set(key: K, value: V): this;
    get(key: K): V | undefined;
    has(key: K): boolean;
    delete(key: K): boolean;
    clear(): void;
    get size(): number;
    forEach(): void;
    keys(): void;
    values(): void;
    entries(): void;
    [Symbol.iterator](): void;
}
declare function createHybridMap<K extends KeyType, V>(entries?: readonly (readonly [K, V])[] | null): HybridMap<K, V>;

//#endregion
//#region src/qrcode/generateQRCode.d.ts
type Options$1<T, K> = T extends HTMLCanvasElement ? {
    errorCorrectionLevel: 'H';
} : K extends true ? {
    errorCorrectionLevel?: 'H';
    type?: 'image/png' | 'image/jpeg' | 'image/webp';
    quality?: number;
    margin?: number;
    color?: {
        dark: string;
        light: string;
    };
} : {
    type?: 'terminal' | 'utf8' | 'svg';
};
/**
* 生成二维码
* @param { string | HTMLCanvasElement } content 元素
* @param { boolean } base64 生成base64格式
* @param options
* @returns
*/
declare function generateQRCode<T extends string | HTMLCanvasElement, K extends boolean>(content: T, base64?: K, options?: Options$1<T, K>): Promise<unknown>;

//#endregion
//#region src/random/randomDate.d.ts
/**
* 随机日期函数
* @param { string } start 开始日期 默认 '1999/01/1
* @param { string } [end] 截止日期
* @returns
*/
declare function randomDate(start?: string, end?: string): Date;

//#endregion
//#region src/random/randomHexColor.d.ts
/**
* 随机hex颜色
* @returns
*/
declare function randomHexColor(): string;

//#endregion
//#region src/random/randomRange.d.ts
/**
* 获取随机范围值
* @param min 最小值 默认 MIN_SAFE_INTEGER
* @param max 最大值 默认 MAX_VALUE
* @returns
*/
declare function randomRange(min?: number, max?: number): number;

//#endregion
//#region src/random/randomRgba.d.ts
/**
* 随机rgba颜色
* @param { number } [opacity] 透明度 默认 1
* @returns
*/
declare function randomRgba(opacity?: number): string;

//#endregion
//#region src/random/randomArray.d.ts
/**
* 随机打乱数组
* @param array any[]
* @returns array
*/
declare function randomArray(array: any[]): any[];

//#endregion
//#region src/random/uuid.d.ts
/**
* 生成uuid
* @param { number } len 长度
* @param {  number | 'hex' } radix  number | 'hex'
* @returns
*/
declare function uuid(len?: number, radix?: number | 'hex'): string;

//#endregion
//#region src/request/VFetch.d.ts
/**
* Class fetch请求封装
*/
declare class VFetch {
    config: IFetchConfig;
    constructor(baseOptions?: IFetchOptions);
    init(this: VFetch, options: IFetchConfig): Promise<any>;
    request(this: VFetch): Promise<any>;
    getResponseData(response: Response, responseType?: ResponseType): Promise<any> | undefined;
    get(this: VFetch, url: string, options?: IFetchConfig): Promise<any>;
    get(this: VFetch, options: IFetchConfig): Promise<any>;
    post(this: VFetch, url: string, options?: IFetchConfig): Promise<any>;
    post(this: VFetch, options: IFetchConfig): Promise<any>;
    put(this: VFetch, url: string, options?: IFetchConfig): Promise<any>;
    put(this: VFetch, options: IFetchConfig): Promise<any>;
    delete(this: VFetch, url: string, options?: IFetchConfig): Promise<any>;
    delete(this: VFetch, options: IFetchConfig): Promise<any>;
}

//#endregion
//#region src/request/asyncPool.d.ts
/**
* 并行执行任务
* @param { number } limit 并行数量 默认 4
* @param { Function[] } tasks 任务队列
* @returns
*/
declare function asyncPool(limit: number | undefined, tasks: Function[]): Promise<any[]>;

//#endregion
//#region src/request/sendBeacon.d.ts
/**
* 将分析数据发送到 Web 服务器
* @param { string } url 接收数据的 URL
* @param { BodyInit } [analyticsData] ArrayBuffer 、 TypedArray 、 DataView 、 Blob 、字符串文字或对象、包含要发送的数据的 FormData 或 URLSearchParams 对象。
* @returns
*/
declare function sendBeacon(url: string | URL, analyticsData?: BodyInit | null): () => void;

//#endregion
//#region src/screen/exitFullscreen.d.ts
/**
* 退出全屏模式
* @returns
*/
declare function exitFullscreen(): Error | undefined;

//#endregion
//#region src/screen/fullScreen.d.ts
/**
* 全屏模式
* @returns
*/
declare function fullScreen(): Error | undefined;

//#endregion
//#region src/screen/picInPic.d.ts
/**
* 画中画模式
* @param {  HTMLVideoElement | string } video video元素
* @returns
*/
declare function picInPic(video: HTMLVideoElement | string): () => Promise<void>;

//#endregion
//#region src/screen/shareScreen.d.ts
/**
* 分享屏幕
* @param { MaybeElement } container 容器
* @param { Function } callback 停止回调
* @returns
*/
declare function shareScreen(container: MaybeElement, callback: (msg: string) => void): Promise<unknown>;

//#endregion
//#region src/screen/useCamera.d.ts
interface IVideo {
    width: number;
    height: number;
}
/**
* 录像功能
* @param video 容器大小 默认{ width: 640, height: 480 }
* @param container 容器
* @param autoplay 是否自动播放
* @returns
*/
declare function useCamera(video?: IVideo | boolean, container?: string | HTMLVideoElement, autoplay?: boolean): void | (() => true | void | Promise<void>);

//#endregion
//#region src/screen/useShare.d.ts
/**
* 分享内容
* @param options    files?: File[];
text?: string;
title?: string;
url?: string;
* @returns
*/
declare function useShare(options?: ShareData): Promise<void> | undefined;

//#endregion
//#region src/screen/useVideo.d.ts
interface Sources {
    src: string;
    type: string;
}
interface VideoOptions {
    container: HTMLElement | string;
    controls?: boolean;
    width?: number;
    height?: number;
    className?: string;
    style?: string;
}
/**
* 操作video
* @param sources {
src: string
type: string
}
* @param videoOptions {
container: HTMLElement | string
controls?: boolean
width?: number
height?: number
className?: string
style?: string
}
* @returns
*/
declare function useVideo(sources: Sources[] | undefined, videoOptions: VideoOptions): {
    play(): void;
    playReset: () => void;
    playRate(rate?: number): void;
    playTime(timing?: number): void;
    playProgress(currentTime?: number): void;
};

//#endregion
//#region src/screen/useRecorder.d.ts
/**
* 录制功能
* @param fileName
* @returns
*/
declare function useRecorder(fileName?: string): Promise<() => void>;

//#endregion
//#region src/screen/useVideoSubtitle.d.ts
interface UseVideoSubtitle {
    start: number;
    duration?: number;
    end?: number;
    left: number;
    top: number;
    content: string;
}
/**
* 生成弹幕内容
* @param options
* @param name
*/
declare function useVideoSubtitle(options: UseVideoSubtitle[], name?: string): string;

//#endregion
//#region src/screen/useAudio.d.ts
/**
* 录音功能
* @param { string | HTMLAudioElement } container 容器
* @returns
*/
declare function useAudio(container: string | HTMLAudioElement): void | {
    toggle(): true | void;
    download(): void;
};

//#endregion
//#region src/screen/useFrequency.d.ts
interface FrequencyOptions {
    audio: MaybeElement;
    fftSize?: number;
}
/**
* 处理audio获取频域数组
* @param { FrequencyOptions } options { audio: 目标元素, fftSize: 分析细粒度 2^n 默认 512 }
* @param { ( dataArray: Uint8Array, audioCtx: AudioContext, analyser: AnalyserNode ) => void } callback 回调
*/
declare function useFrequency(options: FrequencyOptions, callback: (dataArray: Uint8Array, audioCtx: AudioContext, analyser: AnalyserNode) => void): void;

//#endregion
//#region src/screen/getVideoFrame.d.ts
/**
* 从视频文件中获取指定时间帧的图片
* @param file 视频类型的File对象
* @param time 需要截取帧的时间（单位：秒）
* @returns Promise<{ url: string; blob: Blob }>
*/
declare function getVideoFrame(file: File, time?: number): Promise<{
    url: string;
    blob: Blob;
}>;

//#endregion
//#region src/script/addLink.d.ts
/**
* head添加link标签
* @param { string } href css路径
* @returns
*/
declare function addLink(href: string): () => void;

//#endregion
//#region src/script/addScript.d.ts
/**
* head添加script标签
* @param { string } src 路径
* @returns
*/
declare function addScript(src: string): () => void;

//#endregion
//#region src/script/addStyle.d.ts
/**
* 将style添加到head
* @param { string } s style
* @param { string } scoped 独立作用域 针对局部组件生效<div data-v-xxx></div>, 传入data-v-xxx
* @returns
*/
type StyleObject = Record<string, Record<string, string | number>>;
declare function addStyle(s: string | StyleObject, scoped?: string): () => HTMLElement | null;

//#endregion
//#region src/script/addStyleScoped.d.ts
declare function addStyleScoped(s: string, scoped: string): string;

//#endregion
//#region src/scroll/getScrollPosition.d.ts
/**
* 获取滚动条位置
* @param el 默认window
* @returns Position
*/
declare function getScrollPosition(el?: Window): Position;

//#endregion
//#region src/scroll/scrollToTop.d.ts
/**
* 滚动到顶部
*/
declare function scrollToTop(): void;

//#endregion
//#region src/scroll/scrollToView.d.ts
/**
* 滚动到可视区域
* @param {  Element | string | null } e 元素
* @param { ScrollIntoViewOptions } options {
*   block?: ScrollLogicalPosition;
*   inline?: ScrollLogicalPosition;
* }
* @returns void
*/
declare function scrollToView(e: Element | string | null, options?: ScrollIntoViewOptions): void;

//#endregion
//#region src/scroll/getScrollProgress.d.ts
declare function getScrollProgress(callback: (percent: string) => void, time?: number): () => void;

//#endregion
//#region src/speak/speech.d.ts
interface SpeechOptions {
    text: string;
    voice?: SpeechSynthesisVoice | null;
    rate?: number;
    pitch?: number;
    volume?: number;
    lang?: Lang;
}
interface SpeechResult {
    cancel: () => void;
    pause: () => void;
    resume: () => void;
    speak: (options?: string | SpeechOptions) => void;
    isSpeaking: () => boolean;
}
declare function speech(text?: string): SpeechResult;
declare function speech(options?: SpeechOptions): SpeechResult;

//#endregion
//#region src/speak/speechToText.d.ts
interface SpeechToTextOptions {
    continuous: boolean;
    interimResults: boolean;
    lang: Lang;
    maxAlternatives: number;
}
/**
* 语音转文字
* @param { SpeechOptions } options {
continuous: boolean // 每次识别都返回连续结果
interimResults: boolean // 返回临时结果的设置
lang: Lang
maxAlternatives: number
}
* @param { (result: any) => any } callback 结果回调函数
* @returns { { toggle: () => void, abort: () => void } }
*/
declare function speechToText(options?: SpeechToTextOptions | ((result: any) => any), callback?: (result: any) => any): {
    toggle: () => void;
    abort: () => any;
};

//#endregion
//#region src/storage/dbStorage.d.ts
/**
* 快速操作indexedDB
* @returns get set remove
*/
declare function dbStorage(): Promise<unknown>;

//#endregion
//#region src/storage/jsCookie.d.ts
/**
* 快速操作cookie
*/
declare const jsCookie: JSCookie;

//#endregion
//#region src/storage/jsLocal.d.ts
/**
* 快速操纵localstorage
* @returns get set delete clear
*/
declare function jsLocal(): {
    set(key: string | Record<string, string>, value?: string): void;
    get(key: string): string | null;
    delete(key: string | string[]): void;
    clear(): void;
};

//#endregion
//#region src/storage/jsSession.d.ts
/**
* 快速操纵session
* @returns get set delete clear
*/
declare function jsSession(): {
    set(key: string | Record<string, string>, value?: string): void;
    get(key: string): string | null;
    delete(key: string | string[]): void;
    clear(): void;
};

//#endregion
//#region src/string/camelize.d.ts
/**
* 将xx-xx转为xxXx 大驼峰格式
* @param { string } s 字符串
* @returns string
*/
declare function camelize(s: string): string;

//#endregion
//#region src/string/getUrlParam.d.ts
/**
* 获取url中的参数
* @param { string } s url地址
* @returns Record<string, string> | undefined
*/
declare function getUrlParam(s?: string): Record<string, string> | undefined;

//#endregion
//#region src/string/hyphenate.d.ts
/**
* 将大驼峰转为xx-xx
* @param { string } s 字符串
* @returns string
*/
declare function hyphenate(s: string): string;

//#endregion
//#region src/string/pwdLevel.d.ts
/**
* 检测字符串强度
* @param { string | number } s 字符串
* @param { number } minimum 长度 默认 6
* @returns
*/
declare function pwdLevel(s: string | number, minimum?: number): number;

//#endregion
//#region src/string/trim.d.ts
/**
* 删除空格
* @param { string } s 字符串
* @param { TrimType } type 所有 ｜ 前置 ｜ 前后 ｜ 后置 'all' | 'pre' | 'around' | 'post'
* @returns string
*/
declare function trim(s: string, type?: TrimType): string;

//#endregion
//#region src/string/useJSONParse.d.ts
/**
* 将字符串转为JSON.stringify的格式并parse出结果
* @param { string } str 字符串
* @returns { any }
*/
declare function useJSONParse(str: string): any;

//#endregion
//#region src/string/spaceFormat.d.ts
/**
* 将多个空格统一处理
* @param { string } str 字符串
* @param { string } replacer 替换为 默认 ' '
* @returns
*/
declare function spaceFormat(str: string, replacer?: string): string;

//#endregion
//#region src/string/parseLrc.d.ts
/**
* 解析歌词字符串
* 得到一个歌词对象的数组
* 每个歌词对象
* {time: 开始时间, words: 歌词内容}
* @param lrc
*/
interface ParseLrcResult {
    time: number;
    words: string;
}
declare function parseLrc(lrc: string): ParseLrcResult[];

//#endregion
//#region src/string/parseTime.d.ts
/**
* 将时间字符串解析为数字 (秒)
* '01:02:03' => 1 * 60 * 60 + 2 * 60 + 3
* @param { string } timeStr 字符串
* @returns number
*/
declare function parseTime(timeStr: string): number;

//#endregion
//#region src/string/hash.d.ts
declare function hash(str: string): string;

//#endregion
//#region src/string/transformWithBack.d.ts
declare function transformWithBack(code: string, rules: RegExp[]): [string, (newCode: string) => string];

//#endregion
//#region src/string/escapeRegExp.d.ts
/**
* escapeRegExp
* @description 对字符串中的特殊字符进行转义以在正则表达式中使用它
* @param str string
* @returns string
*/
declare function escapeRegExp(str: string): string;

//#endregion
//#region src/string/compareVersion.d.ts
/**
* 比较两个版本字符串。
*
* @param {string} v1 - 第一个版本字符串。
* @param {string} v2 - 第二个版本字符串。
* @returns {number} - 如果 v1 大于 v2 返回 1，如果 v2 大于 v1 返回 -1，如果它们相等返回 0。
*/
declare function compareVersion(v1: string, v2: string): number;

//#endregion
//#region src/string/findMatchEnd.d.ts
/**
* 查找匹配符号的结束偏移量
*
* @param matchStr - 要匹配的符号
* @param code - 包含符号的代码字符串
* @returns 匹配符号的结束偏移量
* @throws 如果在代码字符串中找不到匹配符号的结束偏移量，则抛出错误
*/
declare function findMatchEndOffset(matchStr: string, code: string): number;

//#endregion
//#region src/string/findMatchStart.d.ts
/**
* 查找匹配符号的结束偏移量
*
* @param matchStr - 要匹配的符号
* @param code - 包含符号的代码字符串
* @returns 匹配符号的结束偏移量
* @throws 如果在代码字符串中找不到匹配符号的结束偏移量，则抛出错误
*/
declare function findMatchStartOffset(matchStr: string, code: string): number;

//#endregion
//#region src/to/arrayToExcel.d.ts
interface IArrayToExcel {
    data: Record<string, any>[];
    filename?: string;
    title?: string[];
    filter?: string[];
}
/**
* 数组转换为excel
* @param { IArrayToExcel } options {
data: Record<string, any>[]
filename?: string
title?: string[]
filter?: string[]
}
* @returns { void }
*/
declare function arrayToExcel(options: IArrayToExcel): void;

//#endregion
//#region src/to/arrayToTree.d.ts
interface ArrayToTreeOptions {
    id?: number | string;
    pid?: number | string;
    children?: string;
}
/**
* 将数组转为树
* @param { Record<string, any>[] } array 数组
* @param { number } parentId 父节点的id 默认 0
* @param { ArrayToTreeOptions } options {
id?: number | string 默认 'id'
pid?: number | string 默认 'pid'
children?: string 默认 'children'
}
* @returns Record<string, any>
*/
declare function arrayToTree(array: Record<string, any>[], parentId?: number, options?: ArrayToTreeOptions): Record<string, any>;

//#endregion
//#region src/to/base64ToBlob.d.ts
/**
*
* @param { string } s base64
* @returns Blob
*/
declare function base64ToBlob(s: string): Blob;

//#endregion
//#region src/to/base64ToFile.d.ts
/**
*
* @param { string } s base64
* @param { string } filename 文件名
* @returns File
*/
declare function base64ToFile(s: string, filename: string): File;

//#endregion
//#region src/to/toAbsolutePath.d.ts
/**
*
* @param { string } url 路径
* @returns 绝对路径
*/
declare function toAbsolutePath(url: string): string;

//#endregion
//#region src/to/toSlice.d.ts
/**
* 截取函数
* @param { string | any[] } list 数组
* @param { number } start 启示索引
* @returns any[]
*/
declare function toSlice(list: any, start?: number): Array<any>;

//#endregion
//#region src/to/toBase64.d.ts
/**
* 转为base64格式
* @param { File | string | Blob } o 传入类型 File | string | Blob
* @returns { Promise<string> }
*/
declare function toBase64(o: File | string | Blob): Promise<string>;
declare function fileToBase64(file: File | Blob): Promise<string>;
declare function urlToBase64(url: string): Promise<string>;

//#endregion
//#region src/to/toObject.d.ts
/**
* 将数组中指定的元素转换为对象
* @param { Array<any> } arr 数组
* @param { string[] } filter 指定数组
* @returns { object }
*/
declare function toObject(arr: Array<any>, filter?: string[]): object;

//#endregion
//#region src/to/toArray.d.ts
/**
* 如果是数组直接返回否则封装成数组
* @param { any } array
* @returns T & any[]
*/
declare function toArray<T>(array: T): (T & any[]) | T[];

//#endregion
//#region src/to/treeToArray.d.ts
/**
* 将数转换为数组
* @description 将数转换为数组
* @param { Record<string, any> } tree 树
* @param { string } children 字节点 默认 'children'
* @returns
*/
declare function treeToArray(tree?: Record<string, any>, children?: string): Record<string, any>[];

//#endregion
//#region src/to/fileToBlob.d.ts
/**
* File文件转为Blob
* @param { File } file 文件
* @returns Blob
*/
declare function fileToBlob(file: File, type?: string): Promise<Blob>;

//#endregion
//#region src/to/fileToArrayBuffer.d.ts
/**
* 文件转buffer
* @param { File } file 文件
* @returns Promise<Uint8Array>
*/
declare function fileToArrayBuffer(file: File): Promise<Uint8Array>;

//#endregion
//#region src/to/blobToUrl.d.ts
/**
* Blob转为url
* @param { Blob } blob Blob
* @returns url
*/
declare function blobToUrl(blob: Blob): string;

//#endregion
//#region src/to/rgbToHex.d.ts
declare function rgbToHex(style: string): string | undefined;

//#endregion
//#region src/to/hexToRgb.d.ts
declare function hexToRgb(hex: string, opacity?: number): string;

//#endregion
//#region src/utils/common.d.ts
declare const _toString: () => string;
declare const ESM_STATIC_IMPORT_RE: RegExp;
declare const DYNAMIC_IMPORT_RE: RegExp;
declare const EXPORT_DECAL_RE: RegExp;
declare const EXPORT_NAMED_RE: RegExp;
declare const EXPORT_STAR_RE: RegExp;
declare const EXPORT_DEFAULT_RE: RegExp;

//#endregion
//#region src/utils/hasOwn.d.ts
declare function hasOwn(obj: object, key: string): boolean;

//#endregion
//#region src/utils/mount.d.ts
type MountArgs = [
    ...Array<string | Element | Window | Document | MediaQueryList | ParentNode | Text>,
    (...elements: HTMLElement[]) => void
];
declare function mount(...args: MountArgs): void;

//#endregion
//#region src/utils/unmount.d.ts
/**
* 浏览器卸载时
* @description 浏览器卸载时
* @param { (ev: Event) => void } callback 回调
* @returns { (ev: Event) => void }
*/
declare function unmount(callback: (ev: Event) => void): (ev: Event) => void;

//#endregion
//#region src/utils/assign.d.ts
declare const assign: {
    <T extends {}, U>(target: T, source: U): T & U;
    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
    (target: object, ...sources: any[]): any;
};

//#endregion
//#region src/utils/beforeUnmount.d.ts
/**
* 浏览器关闭前
* @description 浏览器关闭前
* @param { (ev: Event) => void } callback 回调
* @returns { (ev: Event) => void }
*/
declare function beforeUnmount(callback: (ev: Event) => void): (ev: Event) => void;

//#endregion
//#region src/tsup/unConfig.d.ts
declare function unConfig(options?: Options): Record<any, any>;

//#endregion
//#region src/iframe/postMessage.d.ts
declare function postMessage(el: HTMLIFrameElement, data: any, targetOrigin: string, transfer?: Transferable[]): void;

//#endregion
//#region src/animate/backIn.d.ts
declare function backIn(t: number): number;

//#endregion
//#region src/animate/backInOut.d.ts
declare function backInOut(t: number): number;

//#endregion
//#region src/animate/backOut.d.ts
declare function backOut(t: number): number;

//#endregion
//#region src/animate/bounceIn.d.ts
declare function bounceIn(t: number): number;

//#endregion
//#region src/animate/bounceInOut.d.ts
declare function bounceInOut(t: number): number;

//#endregion
//#region src/animate/bounceOut.d.ts
declare function bounceOut(t: number): number;

//#endregion
//#region src/animate/circIn.d.ts
declare function circIn(t: number): number;

//#endregion
//#region src/animate/circInOut.d.ts
declare function circInOut(t: number): number;

//#endregion
//#region src/animate/circOut.d.ts
declare function circOut(t: number): number;

//#endregion
//#region src/animate/cubicIn.d.ts
declare function cubicIn(t: number): number;

//#endregion
//#region src/animate/cubicInOut.d.ts
declare function cubicInOut(t: number): number;

//#endregion
//#region src/animate/cubicOut.d.ts
declare function cubicOut(t: number): number;

//#endregion
//#region src/animate/elasticIn.d.ts
declare function elasticIn(t: number): number;

//#endregion
//#region src/animate/elasticInOut.d.ts
declare function elasticInOut(t: number): number;

//#endregion
//#region src/animate/elasticOut.d.ts
declare function elasticOut(t: number): number;

//#endregion
//#region src/animate/expoIn.d.ts
declare function expoIn(t: number): number;

//#endregion
//#region src/animate/expoInOut.d.ts
declare function expoInOut(t: number): number;

//#endregion
//#region src/animate/expoOut.d.ts
declare function expoOut(t: number): number;

//#endregion
//#region src/animate/quadIn.d.ts
declare function quadIn(t: number): number;

//#endregion
//#region src/animate/quadInOut.d.ts
declare function quadInOut(t: number): number;

//#endregion
//#region src/animate/quadOut.d.ts
declare function quadOut(t: number): number;

//#endregion
//#region src/animate/quartIn.d.ts
declare function quartIn(t: number): number;

//#endregion
//#region src/animate/quartInOut.d.ts
declare function quartInOut(t: number): number;

//#endregion
//#region src/animate/quartOut.d.ts
declare function quartOut(t: number): number;

//#endregion
//#region src/animate/quintIn.d.ts
declare function quintIn(t: number): number;

//#endregion
//#region src/animate/quintInOut.d.ts
declare function quintInOut(t: number): number;

//#endregion
//#region src/animate/quintOut.d.ts
declare function quintOut(t: number): number;

//#endregion
//#region src/animate/sineIn.d.ts
declare function sineIn(t: number): number;

//#endregion
//#region src/animate/sineInOut.d.ts
declare function sineInOut(t: number): number;

//#endregion
//#region src/animate/sineOut.d.ts
declare function sineOut(t: number): number;

//#endregion
//#region src/animate/useNumberAnimation.d.ts
/**
* 贝塞尔曲线变化数字
* @param from 起始数字
* @param to 结束数字
* @param duration 动画时长
* @param onProgress 回调
*/
declare function useNumberAnimation(from: number, to: number, duration: number, onProgress?: (newValue: number) => void): void;

//#endregion
//#region src/theme/useSystemColor.d.ts
type Color = 'light' | 'dark';
declare function useSystemColor(callback: (color: Color) => void): () => void;

//#endregion
export { BodyType, Cache, Canvas, ChunkDetail, ChunkInfo, CreateSignatureCanvas, Credentials, DYNAMIC_IMPORT_RE, DateString, Deadline, DeviceType, Direction, DotImageCanvas, DotImageCanvasOptions, DotTextCanvas, DotTextCanvasOptions, DragEvent, ESM_STATIC_IMPORT_RE, EXPORT_DECAL_RE, EXPORT_DEFAULT_RE, EXPORT_NAMED_RE, EXPORT_STAR_RE, EventBus, FileChunk, FileMD5, FileSpliceOptions, FileType, HeadOptions, HybridMap, IFetchConfig, IFetchInterceptors, IFetchOptions, ILink, IMeta, IScript, IShellMessage, ISignature, ImageData$1 as ImageData, IsESModule, JSCookie, LRU, Lang, Line, MaybeElement, Merge, Method, Mode, MutationObserverInit, NodeWorkerPayload, ParsedURL, PkgTool, Point, Position, Redirect, ResponseType, SpeechOptions, SpeechResult, SpeechToTextOptions, Square, TimeUnit, TrimType, UseTimeoutReturn, VFetch, _toString, addClass, addLink, addRules, addScript, addStyle, addStyleScoped, arrayToExcel, arrayToTree, assign, asyncPool, backIn, backInOut, backOut, base64ToBlob, base64ToFile, beforeUnmount, blobToUrl, bounceIn, bounceInOut, bounceOut, calFps, calNum, camelize, catchAwait, chainFns, chunk, circIn, circInOut, circOut, classesReg, collisionDetection, compareDate, compareDateTime, compareTime, compareVersion, compressCss, compressImage, copy, countBy, createCalendar, createChannel, createChunk, createElement, createEventBus, createFragment, createHybridMap, createTextNode, cubicIn, cubicInOut, cubicOut, curry, dbStorage, debounce, debugWarn, deepClone, deepCompare, deepMerge, diff, download, dragEvent, elasticIn, elasticInOut, elasticOut, escapeHtml, escapeRegExp, executeStr, exitFullscreen, expoIn, expoInOut, expoOut, fileSplice, fileToArrayBuffer, fileToBase64, fileToBlob, filterEmpty, findElement, findMatchEndOffset, findMatchStartOffset, flatten, forEach, formateDate, formateNum, fullScreen, generateKeyObject, generateQRCode, getAverage, getClasses, getCssVar, getDateList, getDaysOfMonth, getDevice, getDifferenceDays, getFirstDay, getImageData, getLocation, getLru, getScrollPosition, getScrollProgress, getStyles, getUrlParam, getVideoFrame, globalErrorCapture, handleImageError, hasClassName, hasOwn, hasProtocol, hash, hexToRgb, htmlTransform, httpsRedirect, hyphenate, insertElement, interceptError, isAbsolute, isActive, isArray, isBase64, isBlob, isBool, isBottom, isBrowser, isComment, isContainCn, isDate, isDef, isDivElement, isESModule, isElement, isEqual, isEven, isFalse, isFile, isFileType, isFn, isIFrameElement, isIPv4, isIPv6, isIdCard, isImageElement, isLeapYear, isMap, isMobile, isNaN, isNameCn, isNameEn, isNil, isNode, isNull, isNum, isObject, isPlainObject, isPostCode, isPromise, isProxyDocument, isReg, isRelative, isSameDay, isScriptElement, isSet, isShadowRoot, isSocketUrl, isSoldierId, isStr, isStyleElement, isSupportCamera, isSupportWebp, isSymbol, isTrainNumber, isTrue, isType, isUndef, isUrl, isVersion, isVideo, isVue, isWeakMap, isWeakSet, isWin, jsCookie, jsLocal, jsSession, lazyLoad, listenStack, log, mapToObject, mapTransform, mapTransformBack, memorizeFn, monitorPef, mount, multiply, nextTick, noop, noopFalse, objectToMap, once, parallel, parse, parseCss, parseLrc, parsePath, parseTime, parseURL, picInPic, postMessage, prefetch, preload, promiseFinally, pwdLevel, quadIn, quadInOut, quadOut, quartIn, quartInOut, quartOut, quickFilter, quickFind, quintIn, quintInOut, quintOut, randomArray, randomDate, randomHexColor, randomRange, randomRgba, reduceAsync, removeClass, removeElement, removeRoundSpace, removeStyle, replaceAsync, retryAsync, rgbToHex, scrollToTop, scrollToView, sendBeacon, sendStorage, setCssVar, setStyle, shareScreen, sineIn, sineInOut, sineOut, singleModel, sleep, sliderValidation, sort, sortByOrder, spaceFormat, speech, speechToText, streamToUrl, stringify, stylesReg, throttle, throwError, timeCost, timeout, toAbsolutePath, toArray, toBase64, toObject, toSlice, transformKey, transformWithBack, traverse, treeToArray, trim, unConfig, unescapeHtml, uniqueArray, unmount, updateDetection, uppercaseNum, urlToBase64, useAudio, useBlur, useCamera, useClick, useElementBounding, useEventListener, useFocus, useFrequency, useHead, useHover, useIntersectionObserver, useInterval, useJSONParse, useKeyBoard, useLongPress, useMouse, useMutationObserver, useNamespace, useNumberAnimation, useRaf, useRange, useReader, useRecorder, useResizeObserver, useRic, useServiceWorker, useShare, useSocket, useStorageListen, useSwitch, useSystemColor, useTimeout, useVideo, useVideoSubtitle, useWebWorker, useWindowScroll, uuid, waterfall };