@antsoo-lib/components 0.0.1

package/dist/src/vc-upload/Upload.d.ts

@@ -0,0 +1,109 @@
+import { RcFile, Action, UploadRequestMethod, UploadRequestHeader, BeforeUploadFileType, UploadProgressEvent, UploadRequestOption } from './interface';
+import { DefineComponent, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    capture: PropType<boolean | "user" | "environment">;
+    multipart: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    componentTag: PropType<any>;
+    action: PropType<Action>;
+    method: PropType<UploadRequestMethod>;
+    directory: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    data: PropType<Record<string, unknown> | ((file: RcFile | string | Blob) => Record<string, unknown>)>;
+    headers: PropType<UploadRequestHeader>;
+    accept: StringConstructor;
+    multiple: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onBatchStart: PropType<(fileList: {
+        file: RcFile;
+        parsedFile: Exclude< BeforeUploadFileType, boolean>;
+    }[]) => void>;
+    onReject: PropType<(fileList: RcFile[]) => void>;
+    onStart: PropType<(file: RcFile) => void>;
+    onError: PropType<(error: Error, ret: Record<string, unknown>, file: RcFile) => void>;
+    onSuccess: PropType<(response: Record<string, unknown>, file: RcFile, xhr: XMLHttpRequest) => void>;
+    onProgress: PropType<(event: UploadProgressEvent, file: RcFile) => void>;
+    beforeUpload: PropType<(file: RcFile, FileList: RcFile[]) => BeforeUploadFileType | Promise<void | BeforeUploadFileType>>;
+    customRequest: PropType<(option: UploadRequestOption) => void>;
+    withCredentials: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openFileDialogOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+    id: StringConstructor;
+    onMouseenter: PropType<(e: MouseEvent) => void>;
+    onMouseleave: PropType<(e: MouseEvent) => void>;
+    onClick: PropType<(e: MouseEvent | KeyboardEvent) => void>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    capture: PropType<boolean | "user" | "environment">;
+    multipart: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    componentTag: PropType<any>;
+    action: PropType<Action>;
+    method: PropType<UploadRequestMethod>;
+    directory: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    data: PropType<Record<string, unknown> | ((file: RcFile | string | Blob) => Record<string, unknown>)>;
+    headers: PropType<UploadRequestHeader>;
+    accept: StringConstructor;
+    multiple: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onBatchStart: PropType<(fileList: {
+        file: RcFile;
+        parsedFile: Exclude< BeforeUploadFileType, boolean>;
+    }[]) => void>;
+    onReject: PropType<(fileList: RcFile[]) => void>;
+    onStart: PropType<(file: RcFile) => void>;
+    onError: PropType<(error: Error, ret: Record<string, unknown>, file: RcFile) => void>;
+    onSuccess: PropType<(response: Record<string, unknown>, file: RcFile, xhr: XMLHttpRequest) => void>;
+    onProgress: PropType<(event: UploadProgressEvent, file: RcFile) => void>;
+    beforeUpload: PropType<(file: RcFile, FileList: RcFile[]) => BeforeUploadFileType | Promise<void | BeforeUploadFileType>>;
+    customRequest: PropType<(option: UploadRequestOption) => void>;
+    withCredentials: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openFileDialogOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+    id: StringConstructor;
+    onMouseenter: PropType<(e: MouseEvent) => void>;
+    onMouseleave: PropType<(e: MouseEvent) => void>;
+    onClick: PropType<(e: MouseEvent | KeyboardEvent) => void>;
+}>> & Readonly<{}>, {
+    multiple: boolean;
+    disabled: boolean;
+    multipart: boolean;
+    directory: boolean;
+    withCredentials: boolean;
+    openFileDialogOnClick: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-upload/attr-accept.d.ts

@@ -0,0 +1,3 @@
+import { RcFile } from './interface';
+declare const _default: (file: RcFile, acceptedFiles: string | string[]) => boolean;
+export default _default;

package/dist/src/vc-upload/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Upload } from './Upload';
+import { UploadProps } from './interface';
+export type { UploadProps };
+export default Upload;

package/dist/src/vc-upload/interface.d.ts

@@ -0,0 +1,79 @@
+import { ExtractPropTypes, PropType } from 'vue';
+export type BeforeUploadFileType = File | Blob | boolean | string;
+export type Action = string | ((file: RcFile) => string | PromiseLike<string>);
+export declare const uploadProps: () => {
+    capture: PropType<boolean | "user" | "environment">;
+    multipart: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    componentTag: PropType<any>;
+    action: PropType<Action>;
+    method: PropType<UploadRequestMethod>;
+    directory: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    data: PropType<Record<string, unknown> | ((file: RcFile | string | Blob) => Record<string, unknown>)>;
+    headers: PropType<UploadRequestHeader>;
+    accept: StringConstructor;
+    multiple: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    onBatchStart: PropType<(fileList: {
+        file: RcFile;
+        parsedFile: Exclude<BeforeUploadFileType, boolean>;
+    }[]) => void>;
+    onReject: PropType<(fileList: RcFile[]) => void>;
+    onStart: PropType<(file: RcFile) => void>;
+    onError: PropType<(error: Error, ret: Record<string, unknown>, file: RcFile) => void>;
+    onSuccess: PropType<(response: Record<string, unknown>, file: RcFile, xhr: XMLHttpRequest) => void>;
+    onProgress: PropType<(event: UploadProgressEvent, file: RcFile) => void>;
+    beforeUpload: PropType<(file: RcFile, FileList: RcFile[]) => BeforeUploadFileType | Promise<void | BeforeUploadFileType>>;
+    customRequest: PropType<(option: UploadRequestOption) => void>;
+    withCredentials: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    openFileDialogOnClick: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    prefixCls: StringConstructor;
+    id: StringConstructor;
+    onMouseenter: PropType<(e: MouseEvent) => void>;
+    onMouseleave: PropType<(e: MouseEvent) => void>;
+    onClick: PropType<(e: MouseEvent | KeyboardEvent) => void>;
+};
+export type UploadProps = Partial<ExtractPropTypes<ReturnType<typeof uploadProps>>>;
+export interface UploadProgressEvent extends Partial<ProgressEvent> {
+    percent?: number;
+}
+export type UploadRequestMethod = 'POST' | 'PUT' | 'PATCH' | 'post' | 'put' | 'patch';
+export type UploadRequestHeader = Record<string, string>;
+export interface UploadRequestError extends Error {
+    status?: number;
+    method?: UploadRequestMethod;
+    url?: string;
+}
+export interface UploadRequestOption<T = any> {
+    onProgress?: (event: UploadProgressEvent) => void;
+    onError?: (event: UploadRequestError | ProgressEvent, body?: T) => void;
+    onSuccess?: (body: T, xhr?: XMLHttpRequest) => void;
+    data?: Record<string, unknown>;
+    filename?: string;
+    file: Exclude<BeforeUploadFileType, File | boolean> | RcFile;
+    withCredentials?: boolean;
+    action: string;
+    headers?: UploadRequestHeader;
+    method: UploadRequestMethod;
+}
+export interface RcFile extends File {
+    uid: string;
+}

package/dist/src/vc-upload/request.d.ts

@@ -0,0 +1,4 @@
+import { UploadRequestOption } from './interface';
+export default function upload(option: UploadRequestOption): {
+    abort(): void;
+};

package/dist/src/vc-upload/traverseFileTree.d.ts

@@ -0,0 +1,14 @@
+import { RcFile } from './interface';
+interface InternalDataTransferItem extends DataTransferItem {
+    isFile: boolean;
+    file: (cd: (file: RcFile & {
+        webkitRelativePath?: string;
+    }) => void) => void;
+    createReader: () => any;
+    fullPath: string;
+    isDirectory: boolean;
+    name: string;
+    path: string;
+}
+declare const traverseFileTree: (files: InternalDataTransferItem[], callback: any, isAccepted: any) => void;
+export default traverseFileTree;

package/dist/src/vc-upload/uid.d.ts

@@ -0,0 +1 @@
+export default function uid(): string;

package/dist/src/vc-util/Children/toArray.d.ts

@@ -0,0 +1,4 @@
+export interface Option {
+    keepEmpty?: boolean;
+}
+export default function toArray(children: any[], option?: Option): any[];

package/dist/src/vc-util/Dom/contains.d.ts

@@ -0,0 +1 @@
+export default function contains(root: Node | null | undefined, n?: Node): boolean;

package/dist/src/vc-util/Dom/css.d.ts

@@ -0,0 +1,22 @@
+export declare function get(node: HTMLElement, name: any): {};
+export declare function set(node: HTMLElement, name: any, value: string | number): {};
+export declare function getOuterWidth(el: HTMLElement): number;
+export declare function getOuterHeight(el: HTMLElement): number;
+export declare function getDocSize(): {
+    width: number;
+    height: number;
+};
+export declare function getClientSize(): {
+    width: number;
+    height: number;
+};
+export declare function getScroll(): {
+    scrollLeft: number;
+    scrollTop: number;
+};
+export declare function getOffset(node: any): {
+    left: number;
+    top: number;
+};
+export declare function styleToString(style: CSSStyleDeclaration): string;
+export declare function styleObjectToString(style: Record<string, string>): string;

package/dist/src/vc-util/Dom/dynamicCSS.d.ts

@@ -0,0 +1,20 @@
+export type ContainerType = Element | ShadowRoot;
+export type Prepend = boolean | 'queue';
+export type AppendType = 'prependQueue' | 'append' | 'prepend';
+interface Options {
+    attachTo?: ContainerType;
+    csp?: {
+        nonce?: string;
+    };
+    prepend?: Prepend;
+    mark?: string;
+    priority?: number;
+}
+export declare function injectCSS(css: string, option?: Options): HTMLStyleElement | null;
+export declare function removeCSS(key: string, option?: Options): void;
+/**
+ * manually clear container cache to avoid global cache in unit testes
+ */
+export declare function clearContainerCache(): void;
+export declare function updateCSS(css: string, key: string, option?: Options): HTMLStyleElement | null;
+export {};

package/dist/src/vc-util/Dom/isVisible.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (element: HTMLElement | SVGGraphicsElement) => boolean;
+export default _default;

package/dist/src/vc-util/Dom/scrollLocker.d.ts

@@ -0,0 +1,12 @@
+export interface scrollLockOptions {
+    container: HTMLElement;
+}
+export default class ScrollLocker {
+    private lockTarget;
+    private options;
+    constructor(options?: scrollLockOptions);
+    getContainer: () => HTMLElement | undefined;
+    reLock: (options?: scrollLockOptions) => void;
+    lock: () => void;
+    unLock: () => void;
+}

package/dist/src/vc-util/devWarning.d.ts

@@ -0,0 +1,4 @@
+import { resetWarned } from './warning';
+export { resetWarned };
+declare const _default: (valid: boolean, component: string, message: string) => void;
+export default _default;

package/dist/src/vc-util/get.d.ts

@@ -0,0 +1 @@
+export default function get(entity: any, path: (string | number)[]): any;

package/dist/src/vc-util/isEqual.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deeply compares two object literals.
+ * @param obj1 object 1
+ * @param obj2 object 2
+ * @param shallow shallow compare
+ * @returns
+ */
+declare function isEqual(obj1: any, obj2: any, shallow?: boolean): boolean;
+export default isEqual;

package/dist/src/vc-util/isMobile.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => boolean;
+export default _default;

package/dist/src/vc-util/set.d.ts

@@ -0,0 +1 @@
+export default function set<Entity = any, Output = Entity, Value = any>(entity: Entity, paths: (string | number)[], value: Value, removeIfUndefined?: boolean): Output;

package/dist/src/vc-util/warning.d.ts

@@ -0,0 +1,7 @@
+export declare function warning(valid: boolean, message: string): void;
+export declare function note(valid: boolean, message: string): void;
+export declare function resetWarned(): void;
+export declare function call(method: (valid: boolean, message: string) => void, valid: boolean, message: string): void;
+export declare function warningOnce(valid: boolean, message: string): void;
+export declare function noteOnce(valid: boolean, message: string): void;
+export default warningOnce;

package/dist/src/vc-virtual-list/Filler.d.ts

@@ -0,0 +1,11 @@
+import { FunctionalComponent } from 'vue';
+interface FillerProps {
+    prefixCls?: string;
+    /** Virtual filler height. Should be `count * itemMinHeight` */
+    height: number;
+    /** Set offset of visible items. Should be the top of start item position */
+    offset?: number;
+    onInnerResize?: () => void;
+}
+declare const Filter: FunctionalComponent<FillerProps>;
+export default Filter;

package/dist/src/vc-virtual-list/Item.d.ts

@@ -0,0 +1,6 @@
+import { FunctionalComponent } from 'vue';
+export interface ItemProps {
+    setRef: (element: HTMLElement) => void;
+}
+declare const Item: FunctionalComponent<ItemProps>;
+export default Item;

package/dist/src/vc-virtual-list/ScrollBar.d.ts

@@ -0,0 +1,58 @@
+import { PropType, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    scrollTop: NumberConstructor;
+    scrollHeight: NumberConstructor;
+    height: NumberConstructor;
+    count: NumberConstructor;
+    onScroll: {
+        type: PropType<(scrollTop: number) => void>;
+    };
+    onStartMove: {
+        type: PropType<() => void>;
+    };
+    onStopMove: {
+        type: PropType<() => void>;
+    };
+}>, {
+    moveRaf: null;
+    scrollbarRef: any;
+    thumbRef: any;
+    visibleTimeout: null;
+    state: {
+        dragging: boolean;
+        pageY: number | null;
+        startTop: number | null;
+        visible: boolean;
+    };
+}, {}, {}, {
+    delayHidden(): void;
+    onScrollbarTouchStart(e: TouchEvent): void;
+    onContainerMouseDown(e: MouseEvent): void;
+    patchEvents(): void;
+    removeEvents(): void;
+    onMouseDown(e: MouseEvent | TouchEvent): void;
+    onMouseMove(e: MouseEvent | TouchEvent): void;
+    onMouseUp(): void;
+    getSpinHeight(): number;
+    getEnableScrollRange(): number;
+    getEnableHeightRange(): number;
+    getTop(): number;
+    showScroll(): boolean;
+}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    scrollTop: NumberConstructor;
+    scrollHeight: NumberConstructor;
+    height: NumberConstructor;
+    count: NumberConstructor;
+    onScroll: {
+        type: PropType<(scrollTop: number) => void>;
+    };
+    onStartMove: {
+        type: PropType<() => void>;
+    };
+    onStopMove: {
+        type: PropType<() => void>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-virtual-list/hooks/useFrameWheel.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+interface FireFoxDOMMouseScrollEvent {
+    detail: number;
+    preventDefault: Function;
+}
+export default function useFrameWheel(inVirtual: Ref<boolean>, isScrollAtTop: Ref<boolean>, isScrollAtBottom: Ref<boolean>, onWheelDelta: (offset: number) => void): [(e: WheelEvent) => void, (e: FireFoxDOMMouseScrollEvent) => void];
+export {};

package/dist/src/vc-virtual-list/hooks/useHeights.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ShallowRef } from 'vue';
+import { GetKey } from '../interface';
+export type CacheMap = Map<any, number>;
+export default function useHeights<T>(mergedData: ShallowRef<any[]>, getKey: GetKey<T>, onItemAdd?: ((item: T) => void) | null, onItemRemove?: ((item: T) => void) | null): [(item: T, instance: HTMLElement) => void, () => void, CacheMap, Ref<symbol>];

package/dist/src/vc-virtual-list/hooks/useMobileTouchMove.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export default function useMobileTouchMove(inVirtual: Ref<boolean>, listRef: Ref<HTMLDivElement | undefined>, callback: (offsetY: number, smoothOffset?: boolean) => boolean): void;

package/dist/src/vc-virtual-list/hooks/useOriginScroll.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+declare const _default: (isScrollAtTop: Ref<boolean>, isScrollAtBottom: Ref<boolean>) => (deltaY: number, smoothOffset?: boolean) => boolean;
+export default _default;

package/dist/src/vc-virtual-list/hooks/useScrollTo.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ShallowRef } from 'vue';
+import { GetKey } from '../interface';
+import { CacheMap } from './useHeights';
+export default function useScrollTo(containerRef: Ref<Element | undefined>, mergedData: ShallowRef<any[]>, heights: CacheMap, props: any, getKey: GetKey, collectHeight: () => void, syncScrollTop: (newTop: number) => void, triggerFlash: () => void): (arg?: any) => void;

package/dist/src/vc-virtual-list/index.d.ts

@@ -0,0 +1,2 @@
+import { default as List } from './List';
+export default List;

package/dist/src/vc-virtual-list/interface.d.ts

@@ -0,0 +1,9 @@
+import { CSSProperties, VNodeTypes } from 'vue';
+import { Key } from '../_util/type';
+export type RenderFunc<T> = (item: T, index: number, props: {
+    style?: CSSProperties;
+}) => VNodeTypes;
+export interface SharedConfig<T> {
+    getKey: (item: T) => Key;
+}
+export type GetKey<T = object> = (item: T) => Key;

package/dist/src/vc-virtual-list/utils/isFirefox.d.ts

@@ -0,0 +1,2 @@
+declare const isFF: boolean;
+export default isFF;

package/dist/src/watermark/index.d.ts

@@ -0,0 +1,131 @@
+import { ExtractPropTypes, PropType, CreateComponentPublicInstanceWithMixins, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps, Plugin } from 'vue';
+export interface WatermarkFontType {
+    color?: string;
+    fontSize?: number | string;
+    fontWeight?: 'normal' | 'light' | 'weight' | number;
+    fontStyle?: 'none' | 'normal' | 'italic' | 'oblique';
+    fontFamily?: string;
+}
+export declare const watermarkProps: () => {
+    zIndex: NumberConstructor;
+    rotate: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    image: StringConstructor;
+    content: {
+        type: PropType<string | string[]>;
+        default: string | string[];
+    };
+    font: {
+        type: PropType<WatermarkFontType>;
+        default: WatermarkFontType;
+    };
+    rootClassName: StringConstructor;
+    gap: {
+        type: PropType<[number, number]>;
+        default: [number, number];
+    };
+    offset: {
+        type: PropType<[number, number]>;
+        default: [number, number];
+    };
+};
+export type WatermarkProps = Partial<ExtractPropTypes<ReturnType<typeof watermarkProps>>>;
+declare const _default: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
+        zIndex: NumberConstructor;
+        rotate: NumberConstructor;
+        width: NumberConstructor;
+        height: NumberConstructor;
+        image: StringConstructor;
+        content: {
+            type: PropType<string | string[]>;
+            default: string | string[];
+        };
+        font: {
+            type: PropType<WatermarkFontType>;
+            default: WatermarkFontType;
+        };
+        rootClassName: StringConstructor;
+        gap: {
+            type: PropType<[number, number]>;
+            default: [number, number];
+        };
+        offset: {
+            type: PropType<[number, number]>;
+            default: [number, number];
+        };
+    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        font: WatermarkFontType;
+        content: string | string[];
+        gap: [number, number];
+        offset: [number, number];
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<ExtractPropTypes<{
+        zIndex: NumberConstructor;
+        rotate: NumberConstructor;
+        width: NumberConstructor;
+        height: NumberConstructor;
+        image: StringConstructor;
+        content: {
+            type: PropType<string | string[]>;
+            default: string | string[];
+        };
+        font: {
+            type: PropType<WatermarkFontType>;
+            default: WatermarkFontType;
+        };
+        rootClassName: StringConstructor;
+        gap: {
+            type: PropType<[number, number]>;
+            default: [number, number];
+        };
+        offset: {
+            type: PropType<[number, number]>;
+            default: [number, number];
+        };
+    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
+        font: WatermarkFontType;
+        content: string | string[];
+        gap: [number, number];
+        offset: [number, number];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<{
+    zIndex: NumberConstructor;
+    rotate: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    image: StringConstructor;
+    content: {
+        type: PropType<string | string[]>;
+        default: string | string[];
+    };
+    font: {
+        type: PropType<WatermarkFontType>;
+        default: WatermarkFontType;
+    };
+    rootClassName: StringConstructor;
+    gap: {
+        type: PropType<[number, number]>;
+        default: [number, number];
+    };
+    offset: {
+        type: PropType<[number, number]>;
+        default: [number, number];
+    };
+}>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    font: WatermarkFontType;
+    content: string | string[];
+    gap: [number, number];
+    offset: [number, number];
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & Plugin;
+export default _default;

package/dist/src/watermark/utils.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties } from 'vue';
+/** converting camel-cased strings to be lowercase and link it with Separato */
+export declare function toLowercaseSeparator(key: string): string;
+export declare function getStyleStr(style: CSSProperties): string;
+/** Returns the ratio of the device's physical pixel resolution to the css pixel resolution */
+export declare function getPixelRatio(): number;
+/** Rotate with the watermark as the center point */
+export declare function rotateWatermark(ctx: CanvasRenderingContext2D, rotateX: number, rotateY: number, rotate: number): void;
+/** Whether to re-render the watermark */
+export declare const reRendering: (mutation: MutationRecord, watermarkElement?: HTMLElement) => boolean;