@antsoo-lib/components 0.0.1

package/dist/src/_util/cssinjs/index.d.ts

@@ -0,0 +1,193 @@
+import { default as Keyframes } from './Keyframes';
+import { StyleContextProps, StyleProviderProps, StyleProvider, createCache, useStyleInject, useStyleProvider, UseStyleProviderProps, HashPriority } from './StyleContext';
+import { default as useCacheToken } from './hooks/useCacheToken';
+import { CSSInterpolation, CSSObject, default as useStyleRegister, extractStyle } from './hooks/useStyleRegister';
+import { Linter, legacyNotSelectorLinter, logicalPropertiesLinter, parentSelectorLinter } from './linters';
+import { DerivativeFunc, TokenType, Theme, createTheme } from './theme';
+import { Transformer } from './transformers/interface';
+import { default as legacyLogicalPropertiesTransformer } from './transformers/legacyLogicalProperties';
+import { default as px2remTransformer, Options } from './transformers/px2rem';
+import { ShallowRef, CreateComponentPublicInstanceWithMixins, ExtractPropTypes, PropType, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps, Plugin } from 'vue';
+import { default as __DTS_DEFAULT_0__ } from './Cache';
+declare const cssinjs: {
+    Theme: typeof Theme;
+    createTheme: typeof createTheme;
+    useStyleRegister: typeof useStyleRegister;
+    useCacheToken: typeof useCacheToken;
+    createCache: typeof createCache;
+    useStyleInject: () => ShallowRef<Partial<StyleContextProps>>;
+    useStyleProvider: (props: UseStyleProviderProps) => ShallowRef<Partial<StyleContextProps>, Partial<StyleContextProps>>;
+    Keyframes: typeof Keyframes;
+    extractStyle: typeof extractStyle;
+    legacyLogicalPropertiesTransformer: Transformer;
+    px2remTransformer: (options?: Options) => Transformer;
+    logicalPropertiesLinter: Linter;
+    legacyNotSelectorLinter: Linter;
+    parentSelectorLinter: Linter;
+    StyleProvider: {
+        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            mock: {
+                type: PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            cache: {
+                type: PropType<__DTS_DEFAULT_0__>;
+                default: __DTS_DEFAULT_0__;
+            };
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hashPriority: {
+                type: PropType<HashPriority>;
+                default: HashPriority;
+            };
+            container: {
+                type: PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transformers: {
+                type: PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            linters: {
+                type: PropType<Linter[]>;
+                default: Linter[];
+            };
+        }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
+            [key: string]: any;
+        }>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+            autoClear: boolean;
+            mock: "server" | "client";
+            cache: __DTS_DEFAULT_0__;
+            defaultCache: boolean;
+            hashPriority: HashPriority;
+            container: Element | ShadowRoot;
+            ssrInline: boolean;
+            transformers: Transformer[];
+            linters: Linter[];
+        }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            mock: {
+                type: PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            cache: {
+                type: PropType<__DTS_DEFAULT_0__>;
+                default: __DTS_DEFAULT_0__;
+            };
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hashPriority: {
+                type: PropType<HashPriority>;
+                default: HashPriority;
+            };
+            container: {
+                type: PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transformers: {
+                type: PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            linters: {
+                type: PropType<Linter[]>;
+                default: Linter[];
+            };
+        }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
+            [key: string]: any;
+        }>[] | undefined, {}, {}, {}, {
+            autoClear: boolean;
+            mock: "server" | "client";
+            cache: __DTS_DEFAULT_0__;
+            defaultCache: boolean;
+            hashPriority: HashPriority;
+            container: Element | ShadowRoot;
+            ssrInline: boolean;
+            transformers: Transformer[];
+            linters: Linter[];
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+        autoClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        mock: {
+            type: PropType<"server" | "client">;
+            default: "server" | "client";
+        };
+        cache: {
+            type: PropType<__DTS_DEFAULT_0__>;
+            default: __DTS_DEFAULT_0__;
+        };
+        defaultCache: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hashPriority: {
+            type: PropType<HashPriority>;
+            default: HashPriority;
+        };
+        container: {
+            type: PropType<Element | ShadowRoot>;
+            default: Element | ShadowRoot;
+        };
+        ssrInline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        transformers: {
+            type: PropType<Transformer[]>;
+            default: Transformer[];
+        };
+        linters: {
+            type: PropType<Linter[]>;
+            default: Linter[];
+        };
+    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
+        [key: string]: any;
+    }>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+        autoClear: boolean;
+        mock: "server" | "client";
+        cache: __DTS_DEFAULT_0__;
+        defaultCache: boolean;
+        hashPriority: HashPriority;
+        container: Element | ShadowRoot;
+        ssrInline: boolean;
+        transformers: Transformer[];
+        linters: Linter[];
+    }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & Plugin;
+};
+export { createCache, createTheme, extractStyle, Keyframes, legacyLogicalPropertiesTransformer, legacyNotSelectorLinter, logicalPropertiesLinter, parentSelectorLinter, px2remTransformer, StyleProvider, Theme, useCacheToken, useStyleInject, useStyleProvider, useStyleRegister, };
+export type { CSSInterpolation, CSSObject, DerivativeFunc, Linter, StyleContextProps, StyleProviderProps, TokenType, Transformer, };
+export declare const _experimental: {
+    supportModernCSS: () => boolean;
+};
+export default cssinjs;

package/dist/src/_util/cssinjs/linters/contentQuotesLinter.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/src/_util/cssinjs/linters/hashedAnimationLinter.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/src/_util/cssinjs/linters/index.d.ts

@@ -0,0 +1,6 @@
+export { default as contentQuotesLinter } from './contentQuotesLinter';
+export { default as hashedAnimationLinter } from './hashedAnimationLinter';
+export type { Linter } from './interface';
+export { default as legacyNotSelectorLinter } from './legacyNotSelectorLinter';
+export { default as logicalPropertiesLinter } from './logicalPropertiesLinter';
+export { default as parentSelectorLinter } from './parentSelectorLinter';

package/dist/src/_util/cssinjs/linters/interface.d.ts

@@ -0,0 +1,8 @@
+export interface LinterInfo {
+    path?: string;
+    hashId?: string;
+    parentSelectors: string[];
+}
+export interface Linter {
+    (key: string, value: string | number, info: LinterInfo): void;
+}

package/dist/src/_util/cssinjs/linters/legacyNotSelectorLinter.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/src/_util/cssinjs/linters/logicalPropertiesLinter.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/src/_util/cssinjs/linters/parentSelectorLinter.d.ts

@@ -0,0 +1,3 @@
+import { Linter } from '..';
+declare const linter: Linter;
+export default linter;

package/dist/src/_util/cssinjs/linters/utils.d.ts

@@ -0,0 +1,2 @@
+import { LinterInfo } from './interface';
+export declare function lintWarning(message: string, info: LinterInfo): void;

package/dist/src/_util/cssinjs/theme/Theme.d.ts

@@ -0,0 +1,11 @@
+import { DerivativeFunc, TokenType } from './interface';
+/**
+ * Theme with algorithms to derive tokens from design tokens.
+ * Use `createTheme` first which will help to manage the theme instance cache.
+ */
+export default class Theme<DesignToken extends TokenType, DerivativeToken extends TokenType> {
+    private derivatives;
+    readonly id: number;
+    constructor(derivatives: DerivativeFunc<DesignToken, DerivativeToken> | DerivativeFunc<DesignToken, DerivativeToken>[]);
+    getDerivativeToken(token: DesignToken): DerivativeToken;
+}

package/dist/src/_util/cssinjs/theme/ThemeCache.d.ts

@@ -0,0 +1,20 @@
+import { default as Theme } from './Theme';
+import { DerivativeFunc } from './interface';
+type DerivativeOptions = DerivativeFunc<any, any>[];
+export declare function sameDerivativeOption(left: DerivativeOptions, right: DerivativeOptions): boolean;
+export default class ThemeCache {
+    static MAX_CACHE_SIZE: number;
+    static MAX_CACHE_OFFSET: number;
+    private readonly cache;
+    private keys;
+    private cacheCallTimes;
+    constructor();
+    size(): number;
+    private internalGet;
+    get(derivativeOption: DerivativeOptions): Theme<any, any> | undefined;
+    has(derivativeOption: DerivativeOptions): boolean;
+    set(derivativeOption: DerivativeOptions, value: Theme<any, any>): void;
+    private deleteByPath;
+    delete(derivativeOption: DerivativeOptions): Theme<any, any> | undefined;
+}
+export {};

package/dist/src/_util/cssinjs/theme/createTheme.d.ts

@@ -0,0 +1,6 @@
+import { default as Theme } from './Theme';
+import { DerivativeFunc, TokenType } from './interface';
+/**
+ * Same as new Theme, but will always return same one if `derivative` not changed.
+ */
+export default function createTheme<DesignToken extends TokenType, DerivativeToken extends TokenType>(derivatives: DerivativeFunc<DesignToken, DerivativeToken>[] | DerivativeFunc<DesignToken, DerivativeToken>): Theme<any, any>;

package/dist/src/_util/cssinjs/theme/index.d.ts

@@ -0,0 +1,4 @@
+export { default as createTheme } from './createTheme';
+export { default as Theme } from './Theme';
+export { default as ThemeCache } from './ThemeCache';
+export type { DerivativeFunc, TokenType } from './interface';

package/dist/src/_util/cssinjs/theme/interface.d.ts

@@ -0,0 +1,2 @@
+export type TokenType = object;
+export type DerivativeFunc<DesignToken extends TokenType, DerivativeToken extends TokenType> = (designToken: DesignToken, derivativeToken?: DerivativeToken) => DerivativeToken;

package/dist/src/_util/cssinjs/transformers/interface.d.ts

@@ -0,0 +1,4 @@
+import { CSSObject } from '..';
+export interface Transformer {
+    visit?: (cssObj: CSSObject) => CSSObject;
+}

package/dist/src/_util/cssinjs/transformers/legacyLogicalProperties.d.ts

@@ -0,0 +1,12 @@
+import { Transformer } from './interface';
+/**
+ * Convert css logical properties to legacy properties.
+ * Such as: `margin-block-start` to `margin-top`.
+ * Transform list:
+ * - inset
+ * - margin
+ * - padding
+ * - border
+ */
+declare const transform: Transformer;
+export default transform;

package/dist/src/_util/cssinjs/transformers/px2rem.d.ts

@@ -0,0 +1,20 @@
+import { Transformer } from './interface';
+export interface Options {
+    /**
+     * The root font size.
+     * @default 16
+     */
+    rootValue?: number;
+    /**
+     * The decimal numbers to allow the REM units to grow to.
+     * @default 5
+     */
+    precision?: number;
+    /**
+     * Whether to allow px to be converted in media queries.
+     * @default false
+     */
+    mediaQuery?: boolean;
+}
+declare const transform: (options?: Options) => Transformer;
+export default transform;

package/dist/src/_util/cssinjs/util.d.ts

@@ -0,0 +1,8 @@
+export declare function flattenToken(token: any): string;
+/**
+ * Convert derivative token to key string
+ */
+export declare function token2key(token: any, salt: string): string;
+export declare function supportLayer(): boolean;
+export declare function supportWhere(): boolean;
+export declare function supportLogicProps(): boolean;

package/dist/src/_util/debouncedWatch.d.ts

@@ -0,0 +1,27 @@
+import { Ref, WatchOptions, WatchStopHandle } from 'vue';
+type MaybeRef<T> = T | Ref<T>;
+type Fn = () => void;
+export type FunctionArgs<Args extends any[] = any[], Return = void> = (...args: Args) => Return;
+export interface FunctionWrapperOptions<Args extends any[] = any[], This = any> {
+    fn: FunctionArgs<Args, This>;
+    args: Args;
+    thisArg: This;
+}
+export type EventFilter<Args extends any[] = any[], This = any> = (invoke: Fn, options: FunctionWrapperOptions<Args, This>) => void;
+/**
+ * Create an EventFilter that debounce the events
+ *
+ * @param ms
+ */
+export declare function debounceFilter(ms: MaybeRef<number>): EventFilter<any[], any>;
+export interface DebouncedWatchOptions<Immediate> extends WatchOptions<Immediate> {
+    debounce?: MaybeRef<number>;
+}
+interface ConfigurableEventFilter {
+    eventFilter?: EventFilter;
+}
+export interface WatchWithFilterOptions<Immediate> extends WatchOptions<Immediate>, ConfigurableEventFilter {
+}
+export declare function watchWithFilter<Immediate extends Readonly<boolean> = false>(source: any, cb: any, options?: WatchWithFilterOptions<Immediate>): WatchStopHandle;
+export default function debouncedWatch<Immediate extends Readonly<boolean> = false>(source: any, cb: any, options?: DebouncedWatchOptions<Immediate>): WatchStopHandle;
+export {};

package/dist/src/_util/eagerComputed.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef } from 'vue';
+export declare type ComputedGetter<T> = (...args: any[]) => T;
+export default function eagerComputed<T>(fn: ComputedGetter<T>): ComputedRef<T>;

package/dist/src/_util/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/dist/src/_util/env.d.ts

@@ -0,0 +1,8 @@
+export declare const inBrowser: boolean;
+export declare const UA: string | false;
+export declare const isIE: boolean | "";
+export declare const isIE9: boolean | "";
+export declare const isEdge: boolean | "";
+export declare const isChrome: boolean | "";
+export declare const isPhantomJS: boolean | "";
+export declare const isFF: false | "" | RegExpMatchArray | null;

package/dist/src/_util/extendsObject.d.ts

@@ -0,0 +1,3 @@
+type RecordType = Record<string, any>;
+declare function extendsObject<T extends RecordType>(...list: T[]): RecordType;
+export default extendsObject;

package/dist/src/_util/firstNotUndefined.d.ts

@@ -0,0 +1,2 @@
+declare function firstNotUndefined<T>(arr?: T[]): T;
+export default firstNotUndefined;

package/dist/src/_util/gapSize.d.ts

@@ -0,0 +1,3 @@
+import { SizeType } from '../config-provider/SizeContext';
+export declare function isPresetSize(size?: SizeType | string | number): size is SizeType;
+export declare function isValidGapNumber(size?: SizeType | string | number): size is number;

package/dist/src/_util/getRequestAnimationFrame.d.ts

@@ -0,0 +1,2 @@
+export default function getRequestAnimationFrame(): any;
+export declare function cancelRequestAnimationFrame(id: any): any;

package/dist/src/_util/getScroll.d.ts

@@ -0,0 +1,2 @@
+export declare function isWindow(obj: any): obj is Window;
+export default function getScroll(target: HTMLElement | Window | Document | null, top: boolean): number;

package/dist/src/_util/getScrollBarSize.d.ts

@@ -0,0 +1,5 @@
+export default function getScrollBarSize(fresh?: boolean): number;
+export declare function getTargetScrollBarSize(target: HTMLElement): {
+    width: number;
+    height: number;
+};

package/dist/src/_util/hooks/_vueuse/_configurable.d.ts

@@ -0,0 +1,16 @@
+export interface ConfigurableWindow {
+    window?: Window;
+}
+export interface ConfigurableDocument {
+    document?: Document;
+}
+export interface ConfigurableNavigator {
+    navigator?: Navigator;
+}
+export interface ConfigurableLocation {
+    location?: Location;
+}
+export declare const defaultWindow: (Window & typeof globalThis) | undefined;
+export declare const defaultDocument: Document | undefined;
+export declare const defaultNavigator: Navigator | undefined;
+export declare const defaultLocation: Location | undefined;

package/dist/src/_util/hooks/_vueuse/is.d.ts

@@ -0,0 +1,16 @@
+export declare const isClient: boolean;
+export declare const isDef: <T = any>(val?: T) => val is T;
+export declare const assert: (condition: boolean, ...infos: any[]) => void;
+export declare const isBoolean: (val: any) => val is boolean;
+export declare const isFunction: <T extends Function>(val: any) => val is T;
+export declare const isNumber: (val: any) => val is number;
+export declare const isString: (val: unknown) => val is string;
+export declare const isObject: (val: any) => val is object;
+export declare const isWindow: (val: any) => val is Window;
+export declare const now: () => number;
+export declare const timestamp: () => number;
+export declare const clamp: (n: number, min: number, max: number) => number;
+export declare const noop: () => void;
+export declare const rand: (min: number, max: number) => number;
+export declare const isIOS: boolean | "";
+export declare const hasOwn: <T extends object, K extends keyof T>(val: T, key: K) => key is K;

package/dist/src/_util/hooks/_vueuse/resolveUnref.d.ts

@@ -0,0 +1,5 @@
+import { MaybeComputedRef } from './types';
+/**
+ * Get the value of value/ref/getter.
+ */
+export declare function resolveUnref<T>(r: MaybeComputedRef<T>): T;

package/dist/src/_util/hooks/_vueuse/tryOnMounted.d.ts

@@ -0,0 +1,8 @@
+import { Fn } from './types';
+/**
+ * Call onMounted() if it's inside a component lifecycle, if not, just call the function
+ *
+ * @param fn
+ * @param sync if set to false, it will run in the nextTick() of Vue
+ */
+export declare function tryOnMounted(fn: Fn, sync?: boolean): void;

package/dist/src/_util/hooks/_vueuse/tryOnScopeDispose.d.ts

@@ -0,0 +1,7 @@
+import { Fn } from './types';
+/**
+ * Call onScopeDispose() if it's inside a effect scope lifecycle, if not, do nothing
+ *
+ * @param fn
+ */
+export declare function tryOnScopeDispose(fn: Fn): boolean;

package/dist/src/_util/hooks/_vueuse/types.d.ts

@@ -0,0 +1,114 @@
+import { ComputedRef, Ref, WatchOptions, WatchSource } from 'vue';
+/**
+ * Any function
+ */
+export type Fn = () => void;
+/**
+ * A ref that allow to set null or undefined
+ */
+export type RemovableRef<T> = Omit<Ref<T>, 'value'> & {
+    get value(): T;
+    set value(value: T | null | undefined);
+};
+/**
+ * @deprecated Use `RemovableRef`
+ */
+export type RemoveableRef<T> = RemovableRef<T>;
+/**
+ * Maybe it's a ref, or a plain value
+ *
+ * ```ts
+ * type MaybeRef<T> = T | Ref<T>
+ * ```
+ */
+export type MaybeRef<T> = T | Ref<T>;
+/**
+ * Maybe it's a ref, or a plain value, or a getter function
+ *
+ * ```ts
+ * type MaybeComputedRef<T> = (() => T) | T | Ref<T> | ComputedRef<T>
+ * ```
+ */
+export type MaybeComputedRef<T> = MaybeReadonlyRef<T> | MaybeRef<T>;
+/**
+ * Maybe it's a computed ref, or a getter function
+ *
+ * ```ts
+ * type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>
+ * ```
+ */
+export type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+/**
+ * Make all the nested attributes of an object or array to MaybeRef<T>
+ *
+ * Good for accepting options that will be wrapped with `reactive` or `ref`
+ *
+ * ```ts
+ * UnwrapRef<DeepMaybeRef<T>> === T
+ * ```
+ */
+export type DeepMaybeRef<T> = T extends Ref<infer V> ? MaybeRef<V> : T extends Array<any> | object ? {
+    [K in keyof T]: DeepMaybeRef<T[K]>;
+} : MaybeRef<T>;
+/**
+ * Infers the element type of an array
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : never;
+export type ShallowUnwrapRef<T> = T extends Ref<infer P> ? P : T;
+export type Awaitable<T> = Promise<T> | T;
+export type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+export interface Pausable {
+    /**
+     * A ref indicate whether a pausable instance is active
+     */
+    isActive: Ref<boolean>;
+    /**
+     * Temporary pause the effect from executing
+     */
+    pause: Fn;
+    /**
+     * Resume the effects
+     */
+    resume: Fn;
+}
+export interface Stoppable {
+    /**
+     * A ref indicate whether a stoppable instance is executing
+     */
+    isPending: Ref<boolean>;
+    /**
+     * Stop the effect from executing
+     */
+    stop: Fn;
+    /**
+     * Start the effects
+     */
+    start: Fn;
+}
+/**
+ * @deprecated Use `Stoppable`
+ */
+export type Stopable = Stoppable;
+export interface ConfigurableFlush {
+    /**
+     * Timing for monitoring changes, refer to WatchOptions for more details
+     *
+     * @default 'pre'
+     */
+    flush?: WatchOptions['flush'];
+}
+export interface ConfigurableFlushSync {
+    /**
+     * Timing for monitoring changes, refer to WatchOptions for more details.
+     * Unlike `watch()`, the default is set to `sync`
+     *
+     * @default 'sync'
+     */
+    flush?: WatchOptions['flush'];
+}
+export type MapSources<T> = {
+    [K in keyof T]: T[K] extends WatchSource<infer V> ? V : never;
+};
+export type MapOldSources<T, Immediate> = {
+    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : never;
+};

package/dist/src/_util/hooks/_vueuse/unrefElement.d.ts

@@ -0,0 +1,13 @@
+import { ComponentPublicInstance } from 'vue';
+import { MaybeComputedRef, MaybeRef } from './types';
+export type VueInstance = ComponentPublicInstance;
+export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
+export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeComputedRef<T>;
+export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
+export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;
+/**
+ * Get the dom element of a ref of element or Vue component instance
+ *
+ * @param elRef
+ */
+export declare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T>;

package/dist/src/_util/hooks/_vueuse/useElementSize.d.ts

@@ -0,0 +1,20 @@
+import { MaybeComputedElementRef } from './unrefElement';
+import { UseResizeObserverOptions } from './useResizeObserver';
+import { ShallowRef } from 'vue';
+export interface ElementSize {
+    width: number;
+    height: number;
+}
+/**
+ * Reactive size of an HTML element.
+ *
+ * @see https://vueuse.org/useElementSize
+ * @param target
+ * @param callback
+ * @param options
+ */
+export declare function useElementSize(target: MaybeComputedElementRef, initialSize?: ElementSize, options?: UseResizeObserverOptions): {
+    width: ShallowRef<number, number>;
+    height: ShallowRef<number, number>;
+};
+export type UseElementSizeReturn = ReturnType<typeof useElementSize>;

package/dist/src/_util/hooks/_vueuse/useMutationObserver.d.ts

@@ -0,0 +1,19 @@
+import { ConfigurableWindow } from './_configurable';
+import { MaybeElementRef } from './unrefElement';
+import { ShallowRef } from 'vue';
+export interface UseMutationObserverOptions extends MutationObserverInit, ConfigurableWindow {
+}
+/**
+ * Watch for changes being made to the DOM tree.
+ *
+ * @see https://vueuse.org/useMutationObserver
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN
+ * @param target
+ * @param callback
+ * @param options
+ */
+export declare function useMutationObserver(target: MaybeElementRef, callback: MutationCallback, options?: UseMutationObserverOptions): {
+    isSupported: ShallowRef<boolean | undefined, boolean | undefined>;
+    stop: () => void;
+};
+export type UseMutationObserverReturn = ReturnType<typeof useMutationObserver>;