vue-devui 1.2.0 → 1.2.1-alpha.0

package/types/dropdown/src/dropdown-types.d.ts

@@ -0,0 +1,71 @@
+import type { PropType, ExtractPropTypes, Ref, ComputedRef } from 'vue';
+export declare type TriggerType = 'click' | 'hover' | 'manually';
+export declare type CloseScopeArea = 'all' | 'blank' | 'none';
+export declare type Placement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+export declare type Alignment = 'start' | 'end';
+export declare type OffsetOptions = {
+    mainAxis?: number;
+    crossAxis?: number;
+};
+export declare type EmitEvent = (event: 'toggle', result: boolean) => void;
+export declare const dropdownProps: {
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    trigger: {
+        type: PropType<TriggerType>;
+        default: string;
+    };
+    closeScope: {
+        type: PropType<CloseScopeArea>;
+        default: string;
+    };
+    position: {
+        type: PropType<Placement[]>;
+        default: string[];
+    };
+    align: {
+        type: PropType<Alignment> | null;
+        default: null;
+    };
+    offset: {
+        type: PropType<number | OffsetOptions>;
+        default: number;
+    };
+    shiftOffset: {
+        type: NumberConstructor;
+    };
+    closeOnMouseLeaveMenu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    overlayClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    destroyOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare type DropdownProps = ExtractPropTypes<typeof dropdownProps>;
+export interface UseDropdownProps {
+    id: string;
+    isOpen: Ref<boolean>;
+    origin: Ref<HTMLElement | undefined>;
+    dropdownRef: Ref<HTMLElement | undefined>;
+    props: DropdownProps;
+    emit: EmitEvent;
+}
+export interface UseOverlayFn {
+    overlayModelValue: Ref<boolean>;
+    overlayShowValue: Ref<boolean>;
+    styles: ComputedRef<Record<string, string>>;
+    classes: ComputedRef<Record<string, boolean>>;
+    handlePositionChange: (pos: string) => void;
+}

package/types/dropdown/src/dropdown.d.ts

@@ -0,0 +1,104 @@
+import './dropdown.scss';
+declare const _default: import("vue").DefineComponent<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    trigger: {
+        type: import("vue").PropType<import("./dropdown-types").TriggerType>;
+        default: string;
+    };
+    closeScope: {
+        type: import("vue").PropType<import("./dropdown-types").CloseScopeArea>;
+        default: string;
+    };
+    position: {
+        type: import("vue").PropType<import("./dropdown-types").Placement[]>;
+        default: string[];
+    };
+    align: {
+        type: import("vue").PropType<import("./dropdown-types").Alignment> | null;
+        default: null;
+    };
+    offset: {
+        type: import("vue").PropType<number | import("./dropdown-types").OffsetOptions>;
+        default: number;
+    };
+    shiftOffset: {
+        type: NumberConstructor;
+    };
+    closeOnMouseLeaveMenu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    overlayClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    destroyOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "toggle"[], "toggle", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    trigger: {
+        type: import("vue").PropType<import("./dropdown-types").TriggerType>;
+        default: string;
+    };
+    closeScope: {
+        type: import("vue").PropType<import("./dropdown-types").CloseScopeArea>;
+        default: string;
+    };
+    position: {
+        type: import("vue").PropType<import("./dropdown-types").Placement[]>;
+        default: string[];
+    };
+    align: {
+        type: import("vue").PropType<import("./dropdown-types").Alignment> | null;
+        default: null;
+    };
+    offset: {
+        type: import("vue").PropType<number | import("./dropdown-types").OffsetOptions>;
+        default: number;
+    };
+    shiftOffset: {
+        type: NumberConstructor;
+    };
+    closeOnMouseLeaveMenu: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    overlayClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    destroyOnHide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onToggle?: ((...args: any[]) => any) | undefined;
+}, {
+    offset: number | import("./dropdown-types").OffsetOptions;
+    position: import("./dropdown-types").Placement[];
+    visible: boolean;
+    align: import("./dropdown-types").Alignment;
+    showAnimation: boolean;
+    trigger: import("./dropdown-types").TriggerType;
+    closeScope: import("./dropdown-types").CloseScopeArea;
+    closeOnMouseLeaveMenu: boolean;
+    overlayClass: string;
+    destroyOnHide: boolean;
+}>;
+export default _default;

package/types/dropdown/src/use-dropdown.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from 'vue';
+import { UseDropdownProps, EmitEvent, DropdownProps, UseOverlayFn } from './dropdown-types';
+export declare const useDropdownEvent: ({ id, isOpen, origin, dropdownRef, props, emit }: UseDropdownProps) => void;
+export declare function useDropdown(id: string, visible: Ref<boolean>, isOpen: Ref<boolean>, origin: Ref<HTMLElement | undefined>, dropdownRef: Ref<HTMLElement | undefined>, popDirection: Ref<string>, emit: EmitEvent): void;
+export declare function useOverlayProps(props: DropdownProps, currentPosition: Ref<string>, isOpen: Ref<boolean>): UseOverlayFn;

package/types/editable-select/__tests__/editable-select.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/editable-select/index.d.ts

@@ -0,0 +1,11 @@
+import type { App } from 'vue';
+import EditableSelect from './src/editable-select';
+export * from './src/editable-select-types';
+export { EditableSelect };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/editable-select/src/composables/use-cache-filtered-options.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef } from 'vue';
+import { OptionObjectItem } from '../editable-select-types';
+interface getOptionValueFunc {
+    getOptionValue: (option: OptionObjectItem) => string | number | undefined;
+}
+export declare function useCacheFilteredOptions(filteredOptions: ComputedRef<OptionObjectItem[]>): getOptionValueFunc;
+export {};

package/types/editable-select/src/composables/use-filter-options.d.ts

@@ -0,0 +1,7 @@
+import { Ref, ComputedRef } from 'vue';
+import { OptionObjectItem } from '../editable-select-types';
+interface useFilterOptionsReturnType {
+    filteredOptions: ComputedRef<OptionObjectItem[]>;
+}
+export declare function useFilterOptions(enableLazyLoad: boolean, normalizeOptions: ComputedRef<OptionObjectItem[]>, inputValue: Ref<string>, searchFn: (option: OptionObjectItem, term: string) => boolean): useFilterOptionsReturnType;
+export {};

package/types/editable-select/src/composables/use-input.d.ts

@@ -0,0 +1,6 @@
+import { SetupContext, Ref } from 'vue';
+interface userInputReturnType {
+    handleInput: (event: Event) => void;
+}
+export declare function useInput(inputValue: Ref<string>, ctx: SetupContext): userInputReturnType;
+export {};

package/types/editable-select/src/composables/use-keyboard-select.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef, Ref } from 'vue';
+import { OptionObjectItem } from '../editable-select-types';
+interface useKeyboardSelectReturnType {
+    handleKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useKeyboardSelect(dropdownRef: Ref, hoverIndex: Ref<number>, filteredOptions: ComputedRef<OptionObjectItem[]>, disabledKey: string, visible: Ref<boolean>, loading: Ref<boolean>, handleClick: (option: OptionObjectItem, index: number) => void, toggleMenu: () => void, closeMenu: () => void): useKeyboardSelectReturnType;
+export {};

package/types/editable-select/src/composables/use-lazy-load.d.ts

@@ -0,0 +1,6 @@
+import { Ref, SetupContext } from 'vue';
+interface useLazyLoadReturenType {
+    loadMore: () => void;
+}
+export declare function useLazyLoad(dropdownRef: Ref<HTMLElement>, enableLazyLoad: boolean, ctx: SetupContext): useLazyLoadReturenType;
+export {};

package/types/editable-select/src/composables/use-select.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef } from 'vue';
+import { EditableSelectProps, OptionObjectItem } from '../editable-select-types';
+interface UseSelectReturnType {
+    normalizeOptions: ComputedRef<OptionObjectItem[]>;
+}
+export declare function useSelect(props: EditableSelectProps): UseSelectReturnType;
+export {};

package/types/editable-select/src/editable-select-types.d.ts

@@ -0,0 +1,50 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+export interface OptionObjectItem {
+    label: string;
+    value: string | number;
+    [key: string]: unknown;
+}
+export declare type Option = string | number | Partial<OptionObjectItem>;
+export declare type Options = Array<Option>;
+export declare const editableSelectProps: {
+    readonly modelValue: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly options: {
+        readonly type: PropType<Options>;
+        readonly default: () => never[];
+    };
+    readonly allowClear: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly disabled: {
+        readonly type: BooleanConstructor;
+    };
+    readonly disabledKey: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Search";
+    };
+    readonly width: {
+        readonly type: NumberConstructor;
+    };
+    readonly maxHeight: {
+        readonly type: NumberConstructor;
+    };
+    readonly loading: {
+        readonly type: BooleanConstructor;
+    };
+    readonly enableLazyLoad: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly searchFn: {
+        readonly type: PropType<(option: OptionObjectItem, term: string) => boolean>;
+    };
+};
+export declare type EditableSelectProps = ExtractPropTypes<typeof editableSelectProps>;

package/types/editable-select/src/editable-select.d.ts

@@ -0,0 +1,3 @@
+import './editable-select.scss';
+declare const _default: import("vue").DefineComponent<unknown, object, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<unknown>, {}>;
+export default _default;

package/types/editable-select/src/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 动态获取class字符串
+ * @param classStr 是一个字符串，固定的class名
+ * @param classOpt 是一个对象，key表示class名，value为布尔值，true则添加，否则不添加
+ * @returns 最终的class字符串
+ */
+export declare function className(classStr: string, classOpt?: {
+    [key: string]: boolean;
+}): string;

package/types/form/__tests__/form.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/form/index.d.ts

@@ -0,0 +1,14 @@
+import type { App } from 'vue';
+import Form from './src/form';
+import FormItem from './src/components/form-item/form-item';
+import FormOperation from './src/components/form-operation/form-operation';
+export { Form, FormItem, FormOperation };
+export * from './src/form-types';
+export * from './src/components/form-item/form-item-types';
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/form/src/components/form-control/form-control-types.d.ts

@@ -0,0 +1,25 @@
+import type { PropType, ExtractPropTypes, ComputedRef } from 'vue';
+import type { FormItemContext } from '../form-item/form-item-types';
+export declare type FeedbackStatus = 'success' | 'error' | 'pending';
+export declare const formControlProps: {
+    feedbackStatus: {
+        type: PropType<FeedbackStatus>;
+    };
+    extraInfo: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export declare type FormControlProps = ExtractPropTypes<typeof formControlProps>;
+export interface UseFormControl {
+    controlClasses: ComputedRef<Record<string, boolean>>;
+    controlContainerClasses: ComputedRef<Record<string, boolean>>;
+}
+export interface UseFormControlValidate {
+    feedbackStatus: ComputedRef<FormItemContext['validateState']>;
+    showFeedback: ComputedRef<boolean | undefined>;
+    showPopover: ComputedRef<boolean>;
+    showMessage: ComputedRef<boolean>;
+    errorMessage: ComputedRef<FormItemContext['validateMessage']>;
+    popPosition: ComputedRef<FormItemContext['popPosition']>;
+}

package/types/form/src/components/form-control/form-control.d.ts

@@ -0,0 +1,21 @@
+import './form-control.scss';
+declare const _default: import("vue").DefineComponent<{
+    feedbackStatus: {
+        type: import("vue").PropType<import("./form-control-types").FeedbackStatus>;
+    };
+    extraInfo: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    feedbackStatus: {
+        type: import("vue").PropType<import("./form-control-types").FeedbackStatus>;
+    };
+    extraInfo: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    extraInfo: string;
+}>;
+export default _default;

package/types/form/src/components/form-control/use-form-control.d.ts

@@ -0,0 +1,3 @@
+import { FormControlProps, UseFormControl, UseFormControlValidate } from './form-control-types';
+export declare function useFormControl(props: FormControlProps): UseFormControl;
+export declare function useFormControlValidate(): UseFormControlValidate;

package/types/form/src/components/form-icons.d.ts

@@ -0,0 +1,4 @@
+export declare function HelpTipsIcon(): JSX.Element;
+export declare function ErrorIcon(): JSX.Element;
+export declare function SuccessIcon(): JSX.Element;
+export declare function PendingIcon(): JSX.Element;

package/types/form/src/components/form-item/form-item-types.d.ts

@@ -0,0 +1,79 @@
+import type { RuleItem, ValidateFieldsError } from 'async-validator';
+import type { ComputedRef, ExtractPropTypes, PropType, InjectionKey, Ref } from 'vue';
+import { LabelAlign, LabelSize, Layout } from '../../form-types';
+import { FeedbackStatus } from '../form-control/form-control-types';
+export declare type FormItemValidateState = '' | 'error' | 'pending' | 'success';
+export declare type MessageType = 'popover' | 'text' | 'none';
+export declare type PopPosition = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+export interface FormRuleItem extends RuleItem {
+    trigger?: Array<string>;
+}
+export declare const formItemProps: {
+    label: {
+        type: StringConstructor;
+    };
+    field: {
+        type: StringConstructor;
+        default: string;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    messageType: {
+        type: PropType<MessageType>;
+    };
+    popPosition: {
+        type: PropType<PopPosition[]>;
+    };
+    rules: {
+        type: PropType<[FormRuleItem, FormRuleItem[]]>;
+    };
+    showFeedback: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    helpTips: {
+        type: StringConstructor;
+        default: string;
+    };
+    feedbackStatus: {
+        type: PropType<FeedbackStatus>;
+    };
+    extraInfo: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export declare type FormItemProps = ExtractPropTypes<typeof formItemProps>;
+export declare type FormValidateCallback = (isValid: boolean, invalidFields?: ValidateFieldsError) => void;
+export declare type FormValidateResult = Promise<boolean>;
+export declare type LabelData = ComputedRef<{
+    layout: Layout;
+    labelSize: LabelSize;
+    labelAlign: LabelAlign;
+}>;
+export interface FormItemContext extends FormItemProps {
+    isRequired: boolean;
+    validateState: FormItemValidateState;
+    validateMessage: string;
+    validate: (trigger: string, callback?: FormValidateCallback) => FormValidateResult;
+    resetField: () => void;
+    clearValidate: () => void;
+}
+export interface UseFormItem {
+    itemClasses: ComputedRef<Record<string, boolean>>;
+    isRequired: ComputedRef<boolean>;
+}
+export interface UseFormItemValidate {
+    validateState: Ref<FormItemValidateState>;
+    validateMessage: Ref<string>;
+    validate: (trigger: string, callback?: FormValidateCallback) => FormValidateResult;
+    resetField: () => void;
+    clearValidate: () => void;
+}
+export interface UseFormItemRule {
+    _rules: ComputedRef<FormRuleItem[]>;
+}
+export declare const FORM_ITEM_TOKEN: InjectionKey<FormItemContext>;
+export declare const LABEL_DATA: InjectionKey<LabelData>;

package/types/form/src/components/form-item/form-item.d.ts

@@ -0,0 +1,81 @@
+import './form-item.scss';
+declare const _default: import("vue").DefineComponent<{
+    label: {
+        type: StringConstructor;
+    };
+    field: {
+        type: StringConstructor;
+        default: string;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    messageType: {
+        type: import("vue").PropType<import("./form-item-types").MessageType>;
+    };
+    popPosition: {
+        type: import("vue").PropType<import("./form-item-types").PopPosition[]>;
+    };
+    rules: {
+        type: import("vue").PropType<[import("./form-item-types").FormRuleItem, import("./form-item-types").FormRuleItem[]]>;
+    };
+    showFeedback: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    helpTips: {
+        type: StringConstructor;
+        default: string;
+    };
+    feedbackStatus: {
+        type: import("vue").PropType<import("../form-control/form-control-types").FeedbackStatus>;
+    };
+    extraInfo: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+    };
+    field: {
+        type: StringConstructor;
+        default: string;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    messageType: {
+        type: import("vue").PropType<import("./form-item-types").MessageType>;
+    };
+    popPosition: {
+        type: import("vue").PropType<import("./form-item-types").PopPosition[]>;
+    };
+    rules: {
+        type: import("vue").PropType<[import("./form-item-types").FormRuleItem, import("./form-item-types").FormRuleItem[]]>;
+    };
+    showFeedback: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    helpTips: {
+        type: StringConstructor;
+        default: string;
+    };
+    feedbackStatus: {
+        type: import("vue").PropType<import("../form-control/form-control-types").FeedbackStatus>;
+    };
+    extraInfo: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    required: boolean;
+    field: string;
+    extraInfo: string;
+    showFeedback: boolean;
+    helpTips: string;
+}>;
+export default _default;

package/types/form/src/components/form-item/use-form-item.d.ts

@@ -0,0 +1,5 @@
+import type { ComputedRef, Ref } from 'vue';
+import { FormItemProps, FormItemValidateState, UseFormItem, FormRuleItem, UseFormItemValidate, MessageType, UseFormItemRule } from './form-item-types';
+export declare function useFormItem(messageType: ComputedRef<MessageType>, _rules: ComputedRef<FormRuleItem[]>, validateState: Ref<FormItemValidateState>): UseFormItem;
+export declare function useFormItemRule(props: FormItemProps): UseFormItemRule;
+export declare function useFormItemValidate(props: FormItemProps, _rules: ComputedRef<FormRuleItem[]>): UseFormItemValidate;

package/types/form/src/components/form-label/form-label-types.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef, ExtractPropTypes } from 'vue';
+export declare const formLabelProps: {
+    helpTips: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export declare type FormLabelProps = ExtractPropTypes<typeof formLabelProps>;
+export interface UseFormLabel {
+    labelClasses: ComputedRef<Record<string, boolean>>;
+    labelInnerClasses: ComputedRef<Record<string, boolean>>;
+}

package/types/form/src/components/form-label/form-label.d.ts

@@ -0,0 +1,15 @@
+import './form-label.scss';
+declare const _default: import("vue").DefineComponent<{
+    helpTips: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    helpTips: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    helpTips: string;
+}>;
+export default _default;

package/types/form/src/components/form-label/use-form-label.d.ts

@@ -0,0 +1,2 @@
+import { UseFormLabel } from './form-label-types';
+export declare function useFormLabel(): UseFormLabel;

package/types/form/src/components/form-operation/form-operation.d.ts

@@ -0,0 +1,3 @@
+import './form-operation.scss';
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/form/src/composables/use-field-collection.d.ts

@@ -0,0 +1,2 @@
+import { UseFieldCollection } from '../form-types';
+export default function useFieldCollection(): UseFieldCollection;

package/types/form/src/composables/use-form-validation.d.ts

@@ -0,0 +1,3 @@
+import { UseFormValidation } from '../form-types';
+import { FormItemContext } from '../components/form-item/form-item-types';
+export default function useFormValidation(itemContexts: FormItemContext[]): UseFormValidation;

package/types/form/src/composables/use-validate.d.ts

@@ -0,0 +1,2 @@
+import type { UseValidate } from '../form-types';
+export default function useValidate(): UseValidate;