fast-element-plus 2.0.19 → 2.0.20

package/dist/index.mjs

@@ -26,9 +26,9 @@ import { FaForm, FaFormItem } from "./components/form/index.mjs";
 import { FaIconSelector } from "./components/iconSelector/index.mjs";
 import { faImageEmits, faImageProps } from "./components/image/src/image.mjs";
 import { FaImage } from "./components/image/index.mjs";
+import { SelectV2Props, tableColumnProps, tableProps } from "./internal/props.mjs";
 import { tableUtil } from "./components/table/utils/table.mjs";
-import { tableColumnProps } from "./components/table/src/tableColumn.mjs";
-import { faTableEmits, faTableProps, tableProps } from "./components/table/src/table.mjs";
+import { faTableEmits, faTableProps } from "./components/table/src/table.mjs";
 import { FaTable, FaTableColumn } from "./components/table/index.mjs";
 import { faInputDialogPageEmits, faInputDialogPageProps } from "./components/inputDialogPage/src/inputDialogPage.mjs";
 import { FaInputDialogPage } from "./components/inputDialogPage/index.mjs";
@@ -36,7 +36,7 @@ import { faSelectProps } from "./components/select/src/select.mjs";
 import { FaSelect, FaSelectOption } from "./components/select/index.mjs";
 import { faSelectPageEmits, faSelectPageProps } from "./components/selectPage/src/selectPage.mjs";
 import { FaSelectPage } from "./components/selectPage/index.mjs";
-import { SelectV2Props, faSelectV2Props } from "./components/selectV2/src/selectV2.mjs";
+import { faSelectV2Props } from "./components/selectV2/src/selectV2.mjs";
 import { FaSelectV2 } from "./components/selectV2/index.mjs";
 import { faTreeEmits, faTreeProps } from "./components/tree/src/tree.mjs";
 import { FaTree } from "./components/tree/index.mjs";

package/dist/internal/props.d.ts

@@ -0,0 +1,685 @@
+import type { SelectV2Props as ElementPlusSelectV2Props, Options, Placement, TableColumnCtx, TableProps } from "element-plus";
+import type { CSSProperties, Component, PropType } from "vue";
+import type { ElSelectorModelValue } from "../components/select/src/select.type";
+import type { DefaultRow } from "../components/table/src/table.state";
+type Layout = "fixed" | "auto";
+/** FaTable 树形数据的字段配置。 */
+export interface TreeProps {
+    hasChildren?: string;
+    children?: string;
+    checkStrictly?: boolean;
+}
+/** Element Plus Table 的透传 Props 定义。 */
+export declare const tableProps: {
+    /**
+     * table data
+     */
+    data: {
+        type: PropType<DefaultRow[]>;
+        default: () => DefaultRow[];
+    };
+    /**
+     * size of Table
+     */
+    size: {
+        readonly type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    width: (NumberConstructor | StringConstructor)[];
+    /**
+     * table's height. By default it has an `auto` height. If its value is a number, the height is measured in pixels; if its value is a string, the value will be assigned to element's style.height, the height is affected by external styles
+     */
+    height: (NumberConstructor | StringConstructor)[];
+    /**
+     * table's max-height. The legal value is a number or the height in px
+     */
+    maxHeight: (NumberConstructor | StringConstructor)[];
+    /**
+     * whether width of column automatically fits its container
+     */
+    fit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * whether Table is striped
+     */
+    stripe: BooleanConstructor;
+    /**
+     * whether Table has vertical border
+     */
+    border: BooleanConstructor;
+    /**
+     * key of row data, used for optimizing rendering. Required if `reserve-selection` is on or display tree data. When its type is String, multi-level access is supported, e.g. `user.info.id`, but `user.info[0].id` is not supported, in which case `Function` should be used
+     */
+    rowKey: PropType<TableProps<DefaultRow>["rowKey"]>;
+    /**
+     * whether Table header is visible
+     */
+    showHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * whether to display a summary row
+     */
+    showSummary: BooleanConstructor;
+    /**
+     * displayed text for the first column of summary row
+     */
+    sumText: StringConstructor;
+    /**
+     * custom summary method
+     */
+    summaryMethod: PropType<TableProps<DefaultRow>["summaryMethod"]>;
+    /**
+     * function that returns custom class names for a row, or a string assigning class names for every row
+     */
+    rowClassName: PropType<TableProps<DefaultRow>["rowClassName"]>;
+    /**
+     * function that returns custom style for a row, or an object assigning custom style for every row
+     */
+    rowStyle: PropType<TableProps<DefaultRow>["rowStyle"]>;
+    /**
+     * function that returns custom class names for a cell, or a string assigning class names for every cell
+     */
+    cellClassName: PropType<TableProps<DefaultRow>["cellClassName"]>;
+    /**
+     * function that returns custom style for a cell, or an object assigning custom style for every cell
+     */
+    cellStyle: PropType<TableProps<DefaultRow>["cellStyle"]>;
+    /**
+     * function that returns custom class names for a row in table header, or a string assigning class names for every row in table header
+     */
+    headerRowClassName: PropType<TableProps<DefaultRow>["headerRowClassName"]>;
+    /**
+     * function that returns custom style for a row in table header, or an object assigning custom style for every row in table header
+     */
+    headerRowStyle: PropType<TableProps<DefaultRow>["headerRowStyle"]>;
+    /**
+     * function that returns custom class names for a cell in table header, or a string assigning class names for every cell in table header
+     */
+    headerCellClassName: PropType<TableProps<DefaultRow>["headerCellClassName"]>;
+    /**
+     * function that returns custom style for a cell in table header, or an object assigning custom style for every cell in table header
+     */
+    headerCellStyle: PropType<TableProps<DefaultRow>["headerCellStyle"]>;
+    /**
+     * whether current row is highlighted
+     */
+    highlightCurrentRow: BooleanConstructor;
+    /**
+     * key of current row, a set only prop
+     */
+    currentRowKey: (NumberConstructor | StringConstructor)[];
+    /**
+     * displayed text when data is empty. You can customize this area with `#empty`
+     */
+    emptyText: StringConstructor;
+    /**
+     * set expanded rows by this prop, prop's value is the keys of expand rows, you should set row-key before using this prop
+     */
+    expandRowKeys: PropType<TableProps<DefaultRow>["expandRowKeys"]>;
+    /** controls whether a row can be expanded */
+    rowExpandable: PropType<TableProps<DefaultRow>["rowExpandable"]>;
+    /**
+     * whether expand all rows by default, works when the table has a column type="expand" or contains tree structure data
+     */
+    defaultExpandAll: BooleanConstructor;
+    /**
+     * set the default sort column and order. property `prop` is used to set default sort column, property `order` is used to set default sort order
+     */
+    defaultSort: PropType<TableProps<DefaultRow>["defaultSort"]>;
+    /**
+     * the `effect` of the overflow tooltip
+     */
+    tooltipEffect: StringConstructor;
+    /**
+     * the options for the overflow tooltip, [see the following tooltip component](tooltip.html#attributes)
+     */
+    tooltipOptions: PropType<TableProps<DefaultRow>["tooltipOptions"]>;
+    /**
+     * method that returns rowspan and colspan
+     */
+    spanMethod: PropType<TableProps<DefaultRow>["spanMethod"]>;
+    /**
+     * controls the behavior of master checkbox in multi-select tables when only some rows are selected (but not all). If true, all rows will be selected, else deselected
+     */
+    selectOnIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * horizontal indentation of tree data
+     */
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * configuration for rendering nested data
+     */
+    treeProps: {
+        type: PropType<TreeProps>;
+        default: () => {
+            hasChildren: string;
+            children: string;
+            checkStrictly: boolean;
+        };
+    };
+    /**
+     * whether to lazy loading data
+     */
+    lazy: BooleanConstructor;
+    /**
+     * method for loading child row data, only works when `lazy` is true
+     */
+    load: PropType<TableProps<DefaultRow>["load"]>;
+    style: {
+        type: PropType<CSSProperties>;
+        default: () => CSSProperties;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * sets the algorithm used to lay out table cells, rows, and columns
+     */
+    tableLayout: {
+        type: PropType<Layout>;
+        default: string;
+    };
+    /**
+     * always show scrollbar
+     */
+    scrollbarAlwaysOn: BooleanConstructor;
+    /**
+     * ensure main axis minimum-size doesn't follow the content
+     */
+    flexible: BooleanConstructor;
+    /**
+     * whether to hide extra content and show them in a tooltip when hovering on the cell.It will affect all the table columns
+     */
+    showOverflowTooltip: PropType<TableProps<DefaultRow>["showOverflowTooltip"]>;
+    /** formats overflow tooltip content */
+    tooltipFormatter: PropType<TableProps<DefaultRow>["tooltipFormatter"]>;
+    /** element to which the filter panel is appended */
+    appendFilterPanelTo: StringConstructor;
+    scrollbarTabindex: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    /** whether the last column can be resized */
+    allowDragLastColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** whether collapsed expanded-row content remains mounted */
+    preserveExpandedContent: BooleanConstructor;
+    /** whether to use native scrollbars */
+    nativeScrollbar: BooleanConstructor;
+};
+/** Element Plus TableColumn 的透传 Props 定义 */
+export declare const tableColumnProps: {
+    /**
+     * type of the column. If set to `selection`, the column will display checkbox. If set to `index`, the column will display index of the row (staring from 1). If set to `expand`, the column will display expand icon
+     */
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * column label
+     */
+    label: StringConstructor;
+    /**
+     * class name of cells in the column
+     */
+    className: StringConstructor;
+    /**
+     * class name of the label of this column
+     */
+    labelClassName: StringConstructor;
+    /**
+     *
+     */
+    property: StringConstructor;
+    /**
+     * field name. You can also use its alias: `property`
+     */
+    prop: StringConstructor;
+    /**
+     * column width
+     */
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * column minimum width. Columns with `width` has a fixed width, while columns with `min-width` has a width that is distributed in proportion
+     */
+    minWidth: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    /**
+     * render function for table header of this column
+     */
+    renderHeader: PropType<TableColumnCtx<DefaultRow>["renderHeader"]>;
+    /**
+     * whether column can be sorted. Remote sorting can be done by setting this attribute to 'custom' and listening to the `sort-change` event of Table
+     */
+    sortable: {
+        type: (StringConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    /**
+     * sorting method, works when `sortable` is `true`. Should return a number, just like Array.sort
+     */
+    sortMethod: PropType<TableColumnCtx<DefaultRow>["sortMethod"]>;
+    /**
+     * specify which property to sort by, works when `sortable` is `true` and `sort-method` is `undefined`. If set to an Array, the column will sequentially sort by the next property if the previous one is equal
+     */
+    sortBy: PropType<TableColumnCtx<DefaultRow>["sortBy"]>;
+    /**
+     * whether column width can be resized, works when `border` of `el-table` is `true`
+     */
+    resizable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * column's key. If you need to use the filter-change event, you need this attribute to identify which column is being filtered
+     */
+    columnKey: StringConstructor;
+    /**
+     * alignment, the value should be 'left' \/ 'center' \/ 'right'
+     */
+    align: StringConstructor;
+    /**
+     * alignment of the table header. If omitted, the value of the above `align` attribute will be applied, the value should be 'left' \/ 'center' \/ 'right'
+     */
+    headerAlign: StringConstructor;
+    /**
+     * whether to hide extra content and show them in a tooltip when hovering on the cell
+     */
+    showOverflowTooltip: {
+        type: PropType<TableColumnCtx<DefaultRow>["showOverflowTooltip"]>;
+        default: undefined;
+    };
+    /** function that formats cell tooltip content, works when show-overflow-tooltip is enabled */
+    tooltipFormatter: PropType<TableColumnCtx<DefaultRow>["tooltipFormatter"]>;
+    /**
+     * whether column is fixed at left / right. Will be fixed at left if `true`
+     */
+    fixed: (StringConstructor | BooleanConstructor)[];
+    /**
+     * function that formats cell content
+     */
+    formatter: PropType<TableColumnCtx<DefaultRow>["formatter"]>;
+    /**
+     * function that determines if a certain row can be selected, works when `type` is 'selection'
+     */
+    selectable: PropType<TableColumnCtx<DefaultRow>["selectable"]>;
+    /**
+     * whether to reserve selection after data refreshing, works when `type` is 'selection'. Note that `row-key` is required for this to work
+     */
+    reserveSelection: BooleanConstructor;
+    /**
+     * data filtering method. If `filter-multiple` is on, this method will be called multiple times for each row, and a row will display if one of the calls returns `true`
+     */
+    filterMethod: PropType<TableColumnCtx<DefaultRow>["filterMethod"]>;
+    /**
+     * filter value for selected data, might be useful when table header is rendered with `render-header`
+     */
+    filteredValue: PropType<TableColumnCtx<DefaultRow>["filteredValue"]>;
+    /**
+     * an array of data filtering options. For each element in this array, `text` and `value` are required
+     */
+    filters: PropType<TableColumnCtx<DefaultRow>["filters"]>;
+    /**
+     * placement for the filter dropdown
+     */
+    filterPlacement: StringConstructor;
+    /**
+     * whether data filtering supports multiple options
+     */
+    filterMultiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * className for the filter dropdown
+     */
+    filterClassName: StringConstructor;
+    /**
+     * customize indices for each row, works on columns with `type=index`
+     */
+    index: PropType<TableColumnCtx<DefaultRow>["index"]>;
+    /**
+     * the order of the sorting strategies used when sorting the data, works when `sortable` is `true`. Accepts an array, as the user clicks on the header, the column is sorted in order of the elements in the array
+     */
+    sortOrders: {
+        type: PropType<TableColumnCtx<DefaultRow>["sortOrders"]>;
+        default: () => (string | null)[];
+        validator: (val: unknown) => boolean;
+    };
+};
+/** 传递给底层 Element Plus 虚拟化选择器的扩展 Props。 */
+export interface Props {
+    label?: string;
+    value?: string;
+    disabled?: string;
+    options?: string;
+}
+/** Element Plus SelectV2 的透传 Props 定义。 */
+export declare const SelectV2Props: {
+    ariaLabel: StringConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import("element-plus/es/utils/vue/props/types.mjs").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+    /**
+     * whether creating new items is allowed. To use this, `filterable` must be true
+     */
+    allowCreate: BooleanConstructor;
+    /**
+     * autocomplete of select input
+     */
+    autocomplete: {
+        type: PropType<"none" | "both" | "inline" | "list">;
+        default: string;
+    };
+    /**
+     * for non-filterable Select, this prop decides if the option menu pops up when the input is focused
+     */
+    automaticDropdown: BooleanConstructor;
+    /**
+     * whether select can be cleared
+     */
+    clearable: BooleanConstructor;
+    /**
+     * custom clear icon
+     */
+    clearIcon: {
+        type: PropType<string | Component>;
+        default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    };
+    /**
+     * tooltip theme, built-in theme: `dark` / `light`
+     */
+    effect: {
+        type: PropType<string>;
+        default: string;
+    };
+    /**
+     * whether to collapse tags to a text when multiple selecting
+     */
+    collapseTags: BooleanConstructor;
+    /**
+     * whether show all selected tags when mouse hover text of collapse-tags. To use this, `collapse-tags` must be true
+     */
+    collapseTagsTooltip: BooleanConstructor;
+    /** collapse-tags tooltip configuration */
+    tagTooltip: {
+        type: PropType<import("element-plus/es/components/select-v2/src/defaults.mjs").TagTooltipProps>;
+        default: () => NonNullable<ElementPlusSelectV2Props["tagTooltip"]>;
+    };
+    /**
+     * The max tags number to be shown. To use this, `collapse-tags` must be true
+     */
+    maxCollapseTags: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     *
+     */
+    defaultFirstOption: BooleanConstructor;
+    /**
+     * is disabled
+     */
+    disabled: BooleanConstructor;
+    /**
+     *
+     */
+    estimatedOptionHeight: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    /**
+     * is filterable
+     */
+    filterable: BooleanConstructor;
+    /**
+     *
+     */
+    filterMethod: PropType<ElementPlusSelectV2Props["filterMethod"]>;
+    /**
+     * The height of the dropdown panel, 34px for each item
+     */
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * The height of the dropdown item
+     */
+    itemHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     *
+     */
+    id: StringConstructor;
+    /**
+     * whether Select is loading data from server
+     */
+    loading: BooleanConstructor;
+    /**
+     * displayed text while loading data from server, default is 'Loading'
+     */
+    loadingText: StringConstructor;
+    /**
+     * biding value
+     */
+    modelValue: {
+        type: PropType<ElSelectorModelValue>;
+    };
+    /**
+     * is multiple
+     */
+    multiple: BooleanConstructor;
+    /**
+     * maximum number of options user can select when multiple is true. No limit when set to 0
+     */
+    multipleLimit: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * the name attribute of select input
+     */
+    name: StringConstructor;
+    /**
+     * displayed text when there is no options, you can also use slot empty, the default is 'No Data'
+     */
+    noDataText: StringConstructor;
+    /**
+     * displayed text when no data matches the filtering query, you can also use slot `empty`, default is 'No matching data'
+     */
+    noMatchText: StringConstructor;
+    /**
+     * function that gets called when the input value changes. Its parameter is the current input value. To use this, `filterable` must be true
+     */
+    remoteMethod: PropType<ElementPlusSelectV2Props["remoteMethod"]>;
+    /**
+     * whether reserve the keyword after select filtered option.
+     */
+    reserveKeyword: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * data of the options, the key of `value` and `label` can be customize by `props`
+     */
+    options: {
+        type: PropType<import("element-plus/es/components/select-v2/src/select.types.mjs").OptionType[]>;
+    };
+    /**
+     * placeholder, the default is 'Please select'
+     */
+    placeholder: {
+        type: StringConstructor;
+    };
+    /**
+     * whether select dropdown is teleported to the body
+     */
+    teleported: import("element-plus/es/utils/vue/props/types.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    /**
+     * when select dropdown is inactive and `persistent` is `false`, select dropdown will be destroyed
+     */
+    persistent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * custom class name for Select's dropdown
+     */
+    popperClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    /** custom style for Select's dropdown */
+    popperStyle: import("element-plus/es/utils/vue/props/types.mjs").EpPropFinalized<(new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | ((new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | null)[], unknown, unknown, undefined, boolean>;
+    /**
+     * [popper.js](https://popper.js.org/docs/v2/) parameters
+     */
+    popperOptions: {
+        type: PropType<Partial<Options>>;
+        default: () => Partial<Options>;
+    };
+    /**
+     * whether search data from server
+     */
+    remote: BooleanConstructor;
+    /** debounce delay during remote search, in milliseconds */
+    debounce: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * size of component
+     */
+    size: {
+        readonly type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    /**
+     * configuration options, see the following table
+     */
+    props: {
+        type: PropType<Props>;
+        default: () => {
+            label: string;
+            value: string;
+            disabled: string;
+            options: string;
+        };
+    };
+    /**
+     * unique identity key name for value, required when value is an object
+     */
+    valueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Controls whether the scrollbar is always displayed
+     */
+    scrollbarAlwaysOn: BooleanConstructor;
+    /**
+     * whether to trigger form validation
+     */
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * offset of the dropdown
+     */
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** whether to show the suffix icon during remote search */
+    remoteShowSuffix: BooleanConstructor;
+    /**
+     * Determines whether the arrow is displayed
+     */
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * position of dropdown
+     */
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+    /**
+     * list of possible positions for dropdown
+     */
+    fallbackPlacements: {
+        type: PropType<Placement[]>;
+        default: string[];
+    };
+    /**
+     * tag type
+     */
+    tagType: {
+        default: string;
+        type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "primary" | "success" | "warning" | "info" | "danger", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    /**
+     * tag effect
+     */
+    tagEffect: {
+        default: string;
+        type: PropType<import("element-plus/es/utils/vue/props/types.mjs").EpPropMergeType<StringConstructor, "plain" | "dark" | "light", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    /**
+     * tabindex for input
+     */
+    tabindex: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    /**
+     * which element the select dropdown appends to
+     */
+    appendTo: StringConstructor;
+    /** whether the dropdown width follows the input width, or a fixed width */
+    fitInputWidth: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+        validator: (value: boolean | number) => boolean;
+    };
+    /** select suffix icon */
+    suffixIcon: {
+        type: PropType<string | Component>;
+        default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    };
+};
+export {};