easybill-ui 1.4.1 → 1.4.2

package/dist/components/CurdTable/src/STableItemFormatter.vue.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from 'vue';
+import { ColumnItem } from './types';
+declare const _default: import('vue').DefineComponent<{
+    schema: {
+        type: PropType<ColumnItem<Record<string, unknown>>>;
+        default(): {
+            options: never[];
+        };
+    };
+    row: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    index: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    schema: {
+        type: PropType<ColumnItem<Record<string, unknown>>>;
+        default(): {
+            options: never[];
+        };
+    };
+    row: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    index: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+}>>, {
+    index: number;
+    row: Record<string, any>;
+    schema: ColumnItem<Record<string, unknown>>;
+}, {}>;
+export default _default;

package/dist/components/CurdTable/src/STableItemFormatter.vue.js

@@ -0,0 +1,34 @@
+import { defineComponent as m, ref as n, computed as p, isReactive as s, isRef as l, isVNode as u, watchEffect as f, createBlock as i, createElementBlock as d, openBlock as a, resolveDynamicComponent as h, Fragment as w, createTextVNode as y, toDisplayString as v } from "vue";
+const b = /* @__PURE__ */ m({
+  __name: "STableItemFormatter",
+  props: {
+    schema: {
+      type: Object,
+      default() {
+        return { options: [] };
+      }
+    },
+    row: {
+      type: Object,
+      default: () => ({})
+    },
+    index: {
+      type: Number,
+      default: () => 0
+    }
+  },
+  setup(c) {
+    const e = c, o = n(e.schema.formatter ? e.schema.formatter(e.row, e.row.column, e.row[e.schema.prop], e.index) : e.row[e.schema.prop]), r = p(() => {
+      const t = o.value;
+      return t !== null && t !== "" && typeof t == "object" && (s(t) || l(t) || u(t) || t.setup) ? t : null;
+    });
+    return f(() => {
+      o.value = e.schema.formatter ? e.schema.formatter(e.row, e.row.column, e.row[e.schema.prop], e.index) : e.row[e.schema.prop];
+    }), (t, x) => r.value ? (a(), i(h(r.value), { key: 0 })) : (a(), d(w, { key: 1 }, [
+      y(v(o.value), 1)
+    ], 64));
+  }
+});
+export {
+  b as default
+};

package/dist/components/CurdTable/src/STableItemFormatter.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableItemFormatter.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/STableItemHeader.vue.d.ts

@@ -0,0 +1,16 @@
+import { PropType } from 'vue';
+import { ColumnItem } from './types';
+declare const _default: import('vue').DefineComponent<{
+    schemaItem: {
+        type: PropType<ColumnItem<Record<string, unknown>>>;
+        default: () => {};
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    schemaItem: {
+        type: PropType<ColumnItem<Record<string, unknown>>>;
+        default: () => {};
+    };
+}>>, {
+    schemaItem: ColumnItem<Record<string, unknown>>;
+}, {}>;
+export default _default;

package/dist/components/CurdTable/src/STableItemHeader.vue.js

@@ -0,0 +1,24 @@
+import { defineComponent as c, computed as r, createElementBlock as n, openBlock as s, Fragment as l, createElementVNode as i, createVNode as p, toDisplayString as h } from "vue";
+import u from "./STableItemHeaderTooltip.vue.js";
+const d = { class: "tit" }, b = /* @__PURE__ */ c({
+  __name: "STableItemHeader",
+  props: {
+    schemaItem: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(a) {
+    const e = a, o = r(() => {
+      var t;
+      return typeof e.schemaItem.header != "string" ? (t = e.schemaItem.header) == null ? void 0 : t.tooltip : "";
+    }), m = r(() => e.schemaItem.header ? typeof e.schemaItem.header == "string" ? e.schemaItem.header : typeof e.schemaItem.header == "object" ? e.schemaItem.header.title || e.schemaItem.label : "" : e.schemaItem.label);
+    return (t, f) => (s(), n(l, null, [
+      i("span", d, h(m.value), 1),
+      p(u, { tooltip: o.value }, null, 8, ["tooltip"])
+    ], 64));
+  }
+});
+export {
+  b as default
+};

package/dist/components/CurdTable/src/STableItemHeader.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableItemHeader.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/STableItemHeaderTooltip.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import('vue').DefineComponent<{
+    tooltip: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: string;
+    };
+}, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    tooltip: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: string;
+    };
+}>>, {
+    tooltip: string | Record<string, any>;
+}, {}>;
+export default _default;

package/dist/components/CurdTable/src/STableItemHeaderTooltip.vue.js

@@ -0,0 +1,48 @@
+import { defineComponent as _, resolveComponent as n, createBlock as a, createCommentVNode as u, openBlock as f, normalizeProps as m, mergeProps as d, withCtx as e, createVNode as r, unref as b, createElementVNode as y } from "vue";
+import { Warning as g } from "@element-plus/icons-vue";
+const C = ["innerHTML"], j = /* @__PURE__ */ _({
+  __name: "STableItemHeaderTooltip",
+  props: {
+    tooltip: {
+      type: [String, Object],
+      default: ""
+    }
+  },
+  setup(l) {
+    const o = l, p = () => {
+      const t = o.tooltip;
+      return t ? typeof t == "string" ? t : typeof t == "object" ? t.content : "" : "";
+    };
+    return (t, T) => {
+      const i = n("el-icon"), c = n("el-button"), s = n("el-tooltip");
+      return o.tooltip ? (f(), a(s, m(d({ key: 0 }, typeof o.tooltip == "object" ? o.tooltip : {})), {
+        content: e(() => [
+          y("div", {
+            innerHTML: p()
+          }, null, 8, C)
+        ]),
+        default: e(() => [
+          r(c, {
+            class: "tooltip",
+            type: "info",
+            link: ""
+          }, {
+            default: e(() => [
+              r(i, null, {
+                default: e(() => [
+                  r(b(g))
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 16)) : u("", !0);
+    };
+  }
+});
+export {
+  j as default
+};

package/dist/components/CurdTable/src/STableItemHeaderTooltip.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableItemHeaderTooltip.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/STableMenu.vue.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import('vue').DefineComponent<{
+    filterVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    openColumnControl: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    operation: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    filterVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onOperation?: ((...args: any[]) => any) | undefined;
+}, {
+    filterVisible: boolean;
+}, {}>;
+export default _default;

package/dist/components/CurdTable/src/STableMenu.vue.js

@@ -0,0 +1,120 @@
+import { defineComponent as L, computed as N, ref as f, resolveComponent as a, createElementBlock as s, openBlock as o, createVNode as u, Fragment as v, renderList as y, createBlock as r, withCtx as n, resolveDynamicComponent as C, createElementVNode as O, normalizeStyle as Q, toDisplayString as $ } from "vue";
+import { Refresh as F, Search as G, ScaleToOriginal as M, Download as R, Operation as U } from "@element-plus/icons-vue";
+import { useGlobalConfig as j } from "../../../utils/hooks/useGlobalConfig.js";
+import { useLocale as q } from "../../../utils/hooks/useLocal.js";
+import A from "./STableColumnControl.vue.js";
+const H = { class: "table-menu" }, Y = /* @__PURE__ */ L({
+  __name: "STableMenu",
+  props: {
+    filterVisible: {
+      type: Boolean,
+      default: !0
+    }
+  },
+  emits: ["operation"],
+  setup(k, { expose: g, emit: w }) {
+    const m = w, S = k, { t: e } = q(), h = j(), x = N(() => [
+      { label: e("el.table.refresh"), value: "refresh", icon: F },
+      { label: S.filterVisible ? e("el.table.collapseQuery") : e("el.table.expandQuery"), value: "searchToggle", icon: G },
+      {
+        label: e("el.table.density"),
+        icon: M,
+        value: "size",
+        options: [
+          { label: e("el.table.default"), value: "default" },
+          { label: e("el.table.medium"), value: "medium" },
+          { label: e("el.table.small"), value: "small" }
+        ]
+      },
+      { label: e("el.table.exportData"), value: "export", icon: R },
+      // { label: "打印", value: "print", icon: "Printer" },
+      { label: e("el.table.columnSet"), value: "operation", icon: U }
+    ]), c = f(!1), z = (t) => {
+      m("operation", t.value), t.value == "operation" && (c.value = !0);
+    }, p = f(h.value.size || "default"), B = (t) => {
+      p.value = t, m("operation", "size", t);
+    };
+    return g({ openColumnControl: () => {
+      c.value = !0;
+    } }), (t, d) => {
+      const _ = a("el-icon"), b = a("el-button"), D = a("el-dropdown-item"), V = a("el-dropdown-menu"), T = a("el-dropdown"), E = a("el-tooltip");
+      return o(), s("div", H, [
+        (o(!0), s(v, null, y(x.value, (l) => (o(), r(E, {
+          key: l.label,
+          content: l.label,
+          placement: "top"
+        }, {
+          default: n(() => [
+            l.options ? (o(), r(T, {
+              key: 0,
+              trigger: "click",
+              class: "table-menu-item",
+              onCommand: B
+            }, {
+              dropdown: n(() => [
+                u(V, null, {
+                  default: n(() => [
+                    (o(!0), s(v, null, y(l.options, (i) => (o(), r(D, {
+                      key: i.value,
+                      command: i.value
+                    }, {
+                      default: n(() => [
+                        O("span", {
+                          style: Q({ color: p.value == i.value ? "var(--el-color-primary)" : "" })
+                        }, $(i.label), 5)
+                      ]),
+                      _: 2
+                    }, 1032, ["command"]))), 128))
+                  ]),
+                  _: 2
+                }, 1024)
+              ]),
+              default: n(() => [
+                u(b, {
+                  type: "info",
+                  link: "",
+                  class: "table-menu-item"
+                }, {
+                  default: n(() => [
+                    u(_, null, {
+                      default: n(() => [
+                        (o(), r(C(l.icon)))
+                      ]),
+                      _: 2
+                    }, 1024)
+                  ]),
+                  _: 2
+                }, 1024)
+              ]),
+              _: 2
+            }, 1024)) : (o(), r(b, {
+              key: 1,
+              type: "info",
+              link: "",
+              class: "table-menu-item",
+              onClick: (i) => z(l)
+            }, {
+              default: n(() => [
+                u(_, null, {
+                  default: n(() => [
+                    (o(), r(C(l.icon)))
+                  ]),
+                  _: 2
+                }, 1024)
+              ]),
+              _: 2
+            }, 1032, ["onClick"]))
+          ]),
+          _: 2
+        }, 1032, ["content"]))), 128)),
+        u(A, {
+          visible: c.value,
+          "onUpdate:visible": d[0] || (d[0] = (l) => c.value = l)
+        }, null, 8, ["visible"])
+      ]);
+    };
+  }
+});
+export {
+  Y as default
+};

package/dist/components/CurdTable/src/STableMenu.vue2.js

@@ -0,0 +1,4 @@
+import f from "./STableMenu.vue.js";
+export {
+  f as default
+};

package/dist/components/CurdTable/src/hooks/useColumnHook.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from 'vue';
+import { ParamsItem } from '../../../TableFilter';
+import { ColumnItem } from '../types';
+export declare function useColumnHook<T>(): {
+    tableColumns: Ref<Array<ColumnItem<T>>>;
+    selectParams: Ref<ParamsItem[]>;
+    initColumn: (propsColumns: ColumnItem<T>[]) => Promise<void>;
+};
+export declare function getFilterFromColumn<T>(a: ColumnItem<T>): ParamsItem;

package/dist/components/CurdTable/src/hooks/useColumnHook.js

@@ -0,0 +1,45 @@
+import { shallowRef as a, provide as u, ref as m } from "vue";
+import { deepClone as f } from "../../utils/common.js";
+function v() {
+  const n = a([]);
+  u("columns", n);
+  const c = (p) => {
+    const r = [], s = (o) => {
+      for (const i in o) {
+        const e = f(o[i]);
+        if (e.children && e.children.length) {
+          s(e.children);
+          continue;
+        }
+        e.filter && r.push(d(e));
+      }
+    };
+    return s(p), r;
+  }, t = m([]);
+  u("selectParams", t);
+  async function l(p) {
+    const r = f(p);
+    n.value = r;
+    const s = async (o) => {
+      for (let i = 0; i < o.length; i++) {
+        const e = o[i];
+        e.children && e.children.length ? s(e.children) : e.asyncOptions && (e.options = await e.asyncOptions());
+      }
+    };
+    s(n.value), t.value = c(n.value).sort((o, i) => (i.sortIndex || 0) - (o.sortIndex || 0));
+  }
+  return {
+    tableColumns: n,
+    selectParams: t,
+    initColumn: l
+  };
+}
+function d(n) {
+  var l;
+  const c = ((l = n.filter) == null ? void 0 : l.options) || n.options, t = f(n.filter);
+  return t.prop || (t.prop = n.prop), typeof t.label > "u" && (t.label = n.label), !t.options && c && (t.options = c), !t.asyncOptions && n.asyncOptions && (t.asyncOptions = n.asyncOptions), !t.eventObject && n.eventObject && (t.eventObject = n.eventObject), t;
+}
+export {
+  d as getFilterFromColumn,
+  v as useColumnHook
+};

package/dist/components/CurdTable/src/types.d.ts

@@ -0,0 +1,178 @@
+import { TableProps } from 'element-plus/es/components/table';
+import { OptionItem } from '../../ConstantStatus';
+import { Fields, FormItem as FormItemType, TooltipProps } from '../../CurdForm';
+import { ParamsItem } from '../../TableFilter';
+import { EventObject, FormSchema } from './../../CurdForm/src/types';
+import { VNode } from 'vue';
+import { FormDialogOptions } from '../../FormDialog/src/types';
+export type MaybePromise<T> = T | Promise<T>;
+export type DefaultTableRow = Record<PropertyKey, any>;
+type ElementTableProps<T> = Omit<TableProps<T & DefaultTableRow>, "data" | "rowKey">;
+export interface CurdTableProps<T = DefaultTableRow> extends Partial<ElementTableProps<T>> {
+    rowKey?: string | ((row: T) => string);
+    data?: T[];
+    columns: ColumnItem<T>[];
+    pageOptions?: {
+        pageIndex?: number;
+        pageSize?: number;
+        total?: number;
+    } & Fields;
+    option?: Partial<PropOption>;
+    fetchData?: (opt: FeachDataParam) => Promise<{
+        total?: number;
+        list?: T[];
+    } | void>;
+    fetchCreate?: (formModel: Fields) => MaybePromise<void | boolean>;
+    fetchEdit?: (formModel: Fields, row: T, index?: number) => MaybePromise<void | boolean>;
+    fetchRemove?: (row: T, index: number) => Promise<void>;
+}
+export interface ColumnItemCtx<T> extends Partial<TableColumnCtx<T>> {
+    prop: string;
+    label: string;
+    type?: string;
+    hidden?: boolean | ((item: ColumnItemCtx<T>, query: Fields) => boolean);
+    neverShow?: boolean;
+    children?: ColumnItem<T>[];
+    options?: Array<OptionItem>;
+    asyncOptions?: () => Promise<OptionItem[]>;
+    eventObject?: EventObject;
+    form?: Partial<FormItemType> | ((column: ColumnItemCtx<T>, row: T, query: Fields) => Partial<FormItemType>);
+    filter?: ColumnItemFilter;
+    empty?: string | unknown;
+    detail?: ColumnItemDetail;
+    value?: unknown;
+    copy?: boolean;
+    vHtml?: boolean;
+    header?: string | TableColumnHeader;
+    headerComponent?: string | VNode;
+}
+interface TableColumnCtx<T> {
+    className: string;
+    labelClassName: string;
+    property: string;
+    prop: string;
+    width: string | number;
+    minWidth: string | number;
+    renderHeader: (data: unknown) => VNode;
+    sortable: boolean | string;
+    sortMethod: (a: T, b: T) => number;
+    sortBy: string | ((row: T, index: number) => string) | string[];
+    resizable: boolean;
+    columnKey: string;
+    rawColumnKey: string;
+    align: string;
+    headerAlign: string;
+    showTooltipWhenOverflow: boolean;
+    showOverflowTooltip: boolean;
+    fixed: boolean | string;
+    formatter: (row: T, column: ColumnItemCtx<T>, cellValue: unknown, index: number) => VNode | string;
+    selectable: (row: T, index: number) => boolean;
+    reserveSelection: boolean;
+    filterMethod: FilterMethods<T>;
+    filteredValue: string[];
+    filters: Filters;
+    filterPlacement: string;
+    filterMultiple: boolean;
+    index: number | ((index: number) => number);
+    sortOrders: ("ascending" | "descending" | null)[];
+    renderCell: (data: unknown) => void;
+    colSpan: number;
+    rowSpan: number;
+    level: number;
+    filterable: boolean | FilterMethods<T> | Filters;
+    order: string;
+    isColumnGroup: boolean;
+    isSubColumn: boolean;
+    columns: ColumnItemCtx<T>[];
+    getColumnIndex: () => number;
+    no: number;
+    filterOpened?: boolean;
+}
+type FilterMethods<T> = (value: unknown, row: T, column: ColumnItemCtx<T>) => void;
+type Filters = {
+    text: string;
+    value: string;
+}[];
+export type ColumnItem<T = DefaultTableRow> = ColumnItemCtx<T>;
+export interface TableColumnHeader {
+    title?: string;
+    tooltip?: string | Partial<TooltipProps>;
+}
+export interface PropOption {
+    operationWidth: number;
+    operationBtnTitle: string;
+    hideMenu: boolean;
+    hideMenuAdd: boolean;
+    hideMenuRight: boolean;
+    hideOperation: boolean;
+    hideOperationEdit: boolean;
+    hideOperationDetail: boolean;
+    hideOperationDelete: boolean;
+    hidePage: boolean;
+    excelTitle: string;
+    selectionProps: Fields;
+    downloadMod: boolean | {
+        excludes?: string[];
+    };
+    pageProps: Fields;
+    filterVisible: boolean;
+    customActivatedFetch: boolean;
+    autoload: boolean;
+    menuEvent: Partial<Record<MenuEventKey, () => void>>;
+    filterAttrs: Partial<FormSchema>;
+    formAttrs: FormAttrs;
+    editOptions: FormDialogOptions;
+    createOptions: FormDialogOptions;
+}
+export type MenuEventKey = "refresh" | "searchToggle" | "size" | "export" | "operation";
+export type FormAttrs = Partial<FormSchema> & {
+    width?: string | number;
+};
+export interface ColumnItemFilter extends Partial<ParamsItem> {
+    inner?: boolean;
+}
+export interface ColumnItemDetail {
+    label?: string;
+    span?: number;
+    value?: unknown;
+}
+export interface TableAttr {
+    size?: string;
+}
+export interface TableListQuery {
+    pageIndex: number;
+    pageSize: number;
+    [key: string]: unknown;
+}
+export interface FeachDataParam {
+    listQuery: TableListQuery;
+}
+export interface FetchDataOpt {
+    showLoading?: boolean;
+    query?: Fields;
+    resetPageIndex?: boolean;
+}
+export interface CurdTableRowSlotScope<T = DefaultTableRow> extends Fields {
+    row: T;
+    $index: number;
+    column?: unknown;
+    index?: number;
+}
+export interface CurdTablePageSlotScope extends Fields {
+    listQuery: TableListQuery;
+    total: number;
+}
+export interface CurdTableSlotScope<T = DefaultTableRow> extends CurdTableRowSlotScope<T>, CurdTablePageSlotScope {
+}
+export interface CurdTableSlots<T = DefaultTableRow> {
+    [name: string]: ((scope: CurdTableSlotScope<T>) => unknown) | undefined;
+    default?: () => unknown;
+    empty?: () => unknown;
+    menuLeft?: () => unknown;
+    menuRight?: () => unknown;
+    operation?: (scope: CurdTableRowSlotScope<T>) => unknown;
+    operationBtn?: (scope: CurdTableRowSlotScope<T>) => unknown;
+    pageLeft?: () => unknown;
+    pageRight?: (scope: CurdTablePageSlotScope) => unknown;
+}
+export {};

package/dist/components/CurdTable/utils/common.d.ts

@@ -0,0 +1,5 @@
+export declare function deepClone<T extends Array<T> | unknown>(sourceData: T): T;
+/**
+ * 复制
+ */
+export declare function copy(value: string): void;

package/dist/components/CurdTable/utils/common.js

@@ -0,0 +1,18 @@
+function o(n) {
+  if (Array.isArray(n))
+    return n.map((e) => o(e));
+  if (typeof n != "object" || n === null || n instanceof Function || n instanceof Date || n instanceof File || n instanceof Symbol)
+    return n;
+  const i = {};
+  for (const e in n)
+    (typeof n[e] == "object" || n[e] instanceof Date || n[e] instanceof File) && n[e] !== null ? i[e] = o(n[e]) : i[e] = n[e];
+  return i;
+}
+function t(n) {
+  const i = document.createElement("input");
+  i.value = n, document.body.appendChild(i), i.select(), document.execCommand("Copy"), document.body.removeChild(i);
+}
+export {
+  t as copy,
+  o as deepClone
+};

package/dist/components/CurdTable/utils/tabelToExcel.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 导出excel
+ */
+export declare function exportExcel(data: (string | number)[][], worksheetName: string, filename?: string): void;

package/dist/components/CurdTable/utils/tabelToExcel.js

@@ -0,0 +1,23 @@
+function m(s, r, e) {
+  e || (e = r), d(s, r, e);
+}
+const d = /* @__PURE__ */ function() {
+  const s = "data:application/vnd.ms-excel;base64,", r = '<html xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel"xmlns="http://www.w3.org/TR/REC-html40"><head><meta charset="UTF-8"><!--[if gte mso 9]><xml><x:ExcelWorkbook><x:ExcelWorksheets><x:ExcelWorksheet><x:Name>{worksheet}</x:Name><x:WorksheetOptions><x:DisplayGridlines/></x:WorksheetOptions></x:ExcelWorksheet></x:ExcelWorksheets></x:ExcelWorkbook></xml><![endif]--> <style type="text/css">.excelTable {border-collapse:collapse; border:thin solid #999; }  .excelTable th {  border: thin solid #999; padding:20px; text-align: center; border-top: thin solid #999; background-color: #E6E6E6; } .excelTable td{ border:thin solid #999; padding:2px 5px; text-align: left; } .excelTable .text-right{text-align:right;}</style></head><body ><table class="excelTable">{table}</table></body></html>', e = function(t) {
+    const n = new TextEncoder().encode(t);
+    return btoa(String.fromCharCode.apply(null, Array.from(n)));
+  }, i = function(t, l) {
+    return t.replace(/{(\w+)}/g, function(n, a) {
+      return l[a];
+    });
+  };
+  return function(t, l, n) {
+    const a = t.map((x) => `<tr>${x.map((o) => "<td class='" + (typeof o == "number" ? "text-right" : "") + "' style='" + (typeof o != "number" ? "mso-number-format:\\@;" : "") + "'>" + (o ?? "") + "</td>").join("")}</tr>`).join("");
+    setTimeout(() => {
+      const x = { worksheet: l || "Worksheet", table: a }, c = document.createElement("a");
+      c.href = s + e(i(r, x)), c.download = n, c.click();
+    });
+  };
+}();
+export {
+  m as exportExcel
+};