@fangzhongya/fang-ui 0.1.89 → 0.1.90

package/dist/components/sliders/index.d.ts

@@ -1,6 +1,6 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-declare const Sliders: SFCWithInstall<DefineComponent<ExtractPropTypes<{
+declare const _default: SFCWithInstall<DefineComponent<ExtractPropTypes<{
     modelValue: {
         type: (ObjectConstructor | NumberConstructor)[];
     };
@@ -46,5 +46,50 @@ declare const Sliders: SFCWithInstall<DefineComponent<ExtractPropTypes<{
     min: number;
     max: number;
 }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>>;
-export { Sliders };
-export default Sliders;
+export declare const Sliders: SFCWithInstall<DefineComponent<ExtractPropTypes<{
+    modelValue: {
+        type: (ObjectConstructor | NumberConstructor)[];
+    };
+    advance: {
+        type: NumberConstructor;
+    };
+    advanceColor: {
+        type: StringConstructor;
+    };
+    min: {
+        type: NumberConstructor;
+        default(): 0;
+    };
+    max: {
+        type: NumberConstructor;
+        default(): 100;
+    };
+    size: {
+        type: StringConstructor;
+    };
+}>, ObjAny, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: {
+        type: (ObjectConstructor | NumberConstructor)[];
+    };
+    advance: {
+        type: NumberConstructor;
+    };
+    advanceColor: {
+        type: StringConstructor;
+    };
+    min: {
+        type: NumberConstructor;
+        default(): 0;
+    };
+    max: {
+        type: NumberConstructor;
+        default(): 100;
+    };
+    size: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{}>, {
+    min: number;
+    max: number;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>>;
+export default _default;

package/dist/components/sliders/index.js

@@ -2,6 +2,7 @@ import { withInstall } from "../../utils/vues/withInstall.js";
 /* empty css                 */
 import src_default from "./src/index.js";
 //#region packages/components/packages/subset/sliders/index.ts
-var Sliders = withInstall(src_default, "Sliders");
+var _default = withInstall(src_default, "Sliders");
+var Sliders = _default;
 //#endregion
-export { Sliders as default };
+export { Sliders, _default as default };

package/dist/components/sliders/src/index.vue_vue_type_script_setup_true_lang.js

@@ -2,7 +2,7 @@ import { useCssName } from "../../../hooks/cssname/index.js";
 import { useLocale } from "../../../hooks/locale/index.js";
 import { getProps, usePropsDefault } from "../../../hooks/props-default/index.js";
 import { useExpose } from "../../../hooks/expose/index.js";
-import Slider from "../../slider/index.js";
+import _default from "../../slider/index.js";
 import { useInherit } from "../../../hooks/inherit/index.js";
 import inserted_default from "../../../directives/inserted/index.js";
 import { dataEmits, dataExpose, dataProps, name } from "./data.js";
@@ -42,7 +42,7 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 			return openBlock(), createElementBlock("div", mergeProps({ class: [unref(cs).z()] }, unref(attrs).root, { style: unref(cs).vdo({
 				advanceWidth: advanceWidth.value,
 				advanceColor: unref(props).advanceColor
-			}) }), [withDirectives(createVNode(unref(Slider), mergeProps(unref(attrs).assem, {
+			}) }), [withDirectives(createVNode(unref(_default), mergeProps(unref(attrs).assem, {
 				class: unref(cs).z("slider"),
 				size: unref(props).size,
 				modelValue: value.value,

package/dist/components/stick-div/index.cjs

@@ -1,7 +1,6 @@
 const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
 const require_index$1 = require("./src/index.cjs");
-//#region packages/components/packages/frame/sticks/stick-div/index.ts
 var StickDiv = require_withInstall.withInstall(require_index$1.default, "StickDiv");
 //#endregion
-exports.default = StickDiv;
+exports.StickDiv = StickDiv;

package/dist/components/stick-div/index.d.ts

@@ -1,7 +1,7 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { CreateComponentPublicInstanceWithMixins, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
 import { Direction } from './src/data';
-declare const StickDiv: SFCWithInstall<{
+declare const _default: SFCWithInstall<{
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
         drag: {
             type: StringConstructor;
@@ -122,5 +122,125 @@ declare const StickDiv: SFCWithInstall<{
         [x: string]: ((props: {}) => any) | undefined;
     };
 })>;
-export { StickDiv };
-export default StickDiv;
+export declare const StickDiv: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        direction: {
+            type: PropType<Direction>;
+            default: string;
+        };
+        directions: {
+            type: {
+                (arrayLength: number): Direction[];
+                (...items: Direction[]): Direction[];
+                new (arrayLength: number): Direction[];
+                new (...items: Direction[]): Direction[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): string[];
+        };
+        often: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        direction: Direction;
+        often: boolean;
+        directions: Direction[];
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        direction: {
+            type: PropType<Direction>;
+            default: string;
+        };
+        directions: {
+            type: {
+                (arrayLength: number): Direction[];
+                (...items: Direction[]): Direction[];
+                new (arrayLength: number): Direction[];
+                new (...items: Direction[]): Direction[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): string[];
+        };
+        often: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        direction: Direction;
+        often: boolean;
+        directions: Direction[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    drag: {
+        type: StringConstructor;
+    };
+    direction: {
+        type: PropType<Direction>;
+        default: string;
+    };
+    directions: {
+        type: {
+            (arrayLength: number): Direction[];
+            (...items: Direction[]): Direction[];
+            new (arrayLength: number): Direction[];
+            new (...items: Direction[]): Direction[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): string[];
+    };
+    often: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    direction: Direction;
+    often: boolean;
+    directions: Direction[];
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        [x: string]: ((props: {}) => any) | undefined;
+    };
+})>;
+export default _default;

package/dist/components/stick-div/index.js

@@ -1,7 +1,6 @@
 import { withInstall } from "../../utils/vues/withInstall.js";
 /* empty css                 */
 import src_default from "./src/index.js";
-//#region packages/components/packages/frame/sticks/stick-div/index.ts
 var StickDiv = withInstall(src_default, "StickDiv");
 //#endregion
-export { StickDiv as default };
+export { StickDiv };

package/dist/components/stick-edge/index.cjs

@@ -1,7 +1,6 @@
 const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
 const require_index$1 = require("./src/index.cjs");
-//#region packages/components/packages/frame/sticks/stick-edge/index.ts
 var StickEdge = require_withInstall.withInstall(require_index$1.default, "StickEdge");
 //#endregion
-exports.default = StickEdge;
+exports.StickEdge = StickEdge;

package/dist/components/stick-edge/index.d.ts

@@ -1,6 +1,6 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { CreateComponentPublicInstanceWithMixins, ExtractPropTypes, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
-declare const StickEdge: SFCWithInstall<{
+declare const _default: SFCWithInstall<{
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
         drag: {
             type: StringConstructor;
@@ -104,5 +104,108 @@ declare const StickEdge: SFCWithInstall<{
         [x: string]: ((props: {}) => any) | undefined;
     };
 })>;
-export { StickEdge };
-export default StickEdge;
+export declare const StickEdge: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        direction: {
+            type: (StringConstructor | {
+                (arrayLength: number): ("" | "top" | "bottom" | "left" | "right")[];
+                (...items: ("" | "top" | "bottom" | "left" | "right")[]): ("" | "top" | "bottom" | "left" | "right")[];
+                new (arrayLength: number): ("" | "top" | "bottom" | "left" | "right")[];
+                new (...items: ("" | "top" | "bottom" | "left" | "right")[]): ("" | "top" | "bottom" | "left" | "right")[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            })[];
+            default: string;
+        };
+        isFixed: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        direction: string | ("" | "top" | "bottom" | "left" | "right")[];
+        isFixed: boolean;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        direction: {
+            type: (StringConstructor | {
+                (arrayLength: number): ("" | "top" | "bottom" | "left" | "right")[];
+                (...items: ("" | "top" | "bottom" | "left" | "right")[]): ("" | "top" | "bottom" | "left" | "right")[];
+                new (arrayLength: number): ("" | "top" | "bottom" | "left" | "right")[];
+                new (...items: ("" | "top" | "bottom" | "left" | "right")[]): ("" | "top" | "bottom" | "left" | "right")[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            })[];
+            default: string;
+        };
+        isFixed: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        direction: string | ("" | "top" | "bottom" | "left" | "right")[];
+        isFixed: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    drag: {
+        type: StringConstructor;
+    };
+    direction: {
+        type: (StringConstructor | {
+            (arrayLength: number): ("" | "top" | "bottom" | "left" | "right")[];
+            (...items: ("" | "top" | "bottom" | "left" | "right")[]): ("" | "top" | "bottom" | "left" | "right")[];
+            new (arrayLength: number): ("" | "top" | "bottom" | "left" | "right")[];
+            new (...items: ("" | "top" | "bottom" | "left" | "right")[]): ("" | "top" | "bottom" | "left" | "right")[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        })[];
+        default: string;
+    };
+    isFixed: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    direction: string | ("" | "top" | "bottom" | "left" | "right")[];
+    isFixed: boolean;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    };
+})>;
+export default _default;

package/dist/components/stick-edge/index.js

@@ -1,7 +1,6 @@
 import { withInstall } from "../../utils/vues/withInstall.js";
 /* empty css                 */
 import src_default from "./src/index.js";
-//#region packages/components/packages/frame/sticks/stick-edge/index.ts
 var StickEdge = withInstall(src_default, "StickEdge");
 //#endregion
-export { StickEdge as default };
+export { StickEdge };

package/dist/components/stick-window/index.cjs

@@ -1,7 +1,6 @@
 const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
 const require_index$1 = require("./src/index.cjs");
-//#region packages/components/packages/frame/sticks/stick-window/index.ts
 var StickWindow = require_withInstall.withInstall(require_index$1.default, "StickWindow");
 //#endregion
-exports.default = StickWindow;
+exports.StickWindow = StickWindow;

package/dist/components/stick-window/index.d.ts

@@ -2,7 +2,7 @@ import { SFCWithInstall } from '../../../utils/vues';
 import { CreateComponentPublicInstanceWithMixins, ExtractPropTypes, PropType, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
 import { Direction } from '../stick-div/src/data';
 import { FunctConfig } from '../../../utils/enums';
-declare const StickWindow: SFCWithInstall<{
+declare const _default: SFCWithInstall<{
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
         drag: {
             type: StringConstructor;
@@ -168,5 +168,170 @@ declare const StickWindow: SFCWithInstall<{
         [x: string]: ((props: {}) => any) | undefined;
     };
 })>;
-export { StickWindow };
-export default StickWindow;
+export declare const StickWindow: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        direction: {
+            type: PropType<Direction>;
+            default: string;
+        };
+        directions: {
+            type: {
+                (arrayLength: number): Direction[];
+                (...items: Direction[]): Direction[];
+                new (arrayLength: number): Direction[];
+                new (...items: Direction[]): Direction[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): string[];
+        };
+        often: {
+            type: BooleanConstructor;
+        };
+        to: {
+            type: StringConstructor;
+            default: FunctConfig;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {
+        add: (s: symbol, a: () => void, r: () => void, t?: string) => void;
+        remove: (s: symbol, t?: string) => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        disabled: boolean;
+        direction: Direction;
+        to: string;
+        often: boolean;
+        directions: Direction[];
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        direction: {
+            type: PropType<Direction>;
+            default: string;
+        };
+        directions: {
+            type: {
+                (arrayLength: number): Direction[];
+                (...items: Direction[]): Direction[];
+                new (arrayLength: number): Direction[];
+                new (...items: Direction[]): Direction[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): string[];
+        };
+        often: {
+            type: BooleanConstructor;
+        };
+        to: {
+            type: StringConstructor;
+            default: FunctConfig;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+    }>> & Readonly<{}>, {
+        add: (s: symbol, a: () => void, r: () => void, t?: string) => void;
+        remove: (s: symbol, t?: string) => void;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        direction: Direction;
+        to: string;
+        often: boolean;
+        directions: Direction[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    drag: {
+        type: StringConstructor;
+    };
+    direction: {
+        type: PropType<Direction>;
+        default: string;
+    };
+    directions: {
+        type: {
+            (arrayLength: number): Direction[];
+            (...items: Direction[]): Direction[];
+            new (arrayLength: number): Direction[];
+            new (...items: Direction[]): Direction[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default(): string[];
+    };
+    often: {
+        type: BooleanConstructor;
+    };
+    to: {
+        type: StringConstructor;
+        default: FunctConfig;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    add: (s: symbol, a: () => void, r: () => void, t?: string) => void;
+    remove: (s: symbol, t?: string) => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    disabled: boolean;
+    direction: Direction;
+    to: string;
+    often: boolean;
+    directions: Direction[];
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        [x: string]: ((props: {
+            values: {
+                key: symbol;
+                value: () => void;
+                close: () => void;
+                title?: string | undefined;
+            }[];
+        }) => any) | undefined;
+    } & {
+        [x: string]: ((props: {}) => any) | undefined;
+    };
+})>;
+export default _default;

package/dist/components/stick-window/index.js

@@ -1,7 +1,6 @@
 import { withInstall } from "../../utils/vues/withInstall.js";
 /* empty css                 */
 import src_default from "./src/index.js";
-//#region packages/components/packages/frame/sticks/stick-window/index.ts
 var StickWindow = withInstall(src_default, "StickWindow");
 //#endregion
-export { StickWindow as default };
+export { StickWindow };

package/dist/components/stick-window/src/index.vue_vue_type_script_setup_true_lang.js

@@ -1,9 +1,9 @@
 import { useCssName } from "../../../hooks/cssname/index.js";
 import { useLocale } from "../../../hooks/locale/index.js";
 import { getProps, usePropsDefault } from "../../../hooks/props-default/index.js";
-import Icon from "../../icon/index.js";
+import _default from "../../icon/index.js";
 import close_default from "../../../icons/vue/close.js";
-import BoxTeleport from "../../box-teleport/index.js";
+import _default$1 from "../../box-teleport/index.js";
 import { dataEmits, dataExpose, dataProps, dataSlot, name } from "./data.js";
 import stick_default from "../../../directives/stick/index.js";
 import { Fragment, createBlock, createElementBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, ref, renderList, renderSlot, toDisplayString, unref, withCtx, withDirectives } from "vue";
@@ -53,7 +53,7 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 			remove
 		});
 		return (_ctx, _cache) => {
-			return openBlock(), createBlock(unref(BoxTeleport), {
+			return openBlock(), createBlock(unref(_default$1), {
 				disabled: unref(props).disabled,
 				to: unref(props).to
 			}, {
@@ -66,7 +66,7 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 						}, [createElementVNode("span", {
 							class: normalizeClass(unref(cs).z("window-li-title")),
 							onClick: ($event) => onClick(item, index)
-						}, toDisplayString(item.title), 11, _hoisted_1), createVNode(unref(Icon), {
+						}, toDisplayString(item.title), 11, _hoisted_1), createVNode(unref(_default), {
 							onClick: ($event) => onClose(item, index),
 							class: normalizeClass(unref(cs).z("window-li-close")),
 							title: unref(getLocale)("close")

package/dist/components/sub-menu/index.cjs

@@ -2,6 +2,8 @@ const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
 const require_index$1 = require("./src/index.cjs");
 //#region packages/components/packages/element/menus/sub-menu/index.ts
-var SubMenu = require_withInstall.withInstall(require_index$1.default, "SubMenu");
+var _default = require_withInstall.withInstall(require_index$1.default, "SubMenu");
+var SubMenu = _default;
 //#endregion
-exports.default = SubMenu;
+exports.SubMenu = SubMenu;
+exports.default = _default;