ep-craft 0.1.7 → 0.1.9

package/dist/node_modules/element-plus/es/components/table/src/table-column/defaults.js

@@ -0,0 +1,163 @@
+const r = {
+  /**
+  * @description 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: String,
+    default: "default"
+  },
+  /**
+  * @description column label
+  */
+  label: String,
+  /**
+  * @description class name of cells in the column
+  */
+  className: String,
+  /**
+  * @description class name of the label of this column
+  */
+  labelClassName: String,
+  /**
+  * @description
+  */
+  property: String,
+  /**
+  * @description field name. You can also use its alias: `property`
+  */
+  prop: String,
+  /**
+  * @description column width
+  */
+  width: {
+    type: [String, Number],
+    default: ""
+  },
+  /**
+  * @description 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: [String, Number],
+    default: ""
+  },
+  /**
+  * @description render function for table header of this column
+  */
+  renderHeader: Function,
+  /**
+  * @description 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: [Boolean, String],
+    default: !1
+  },
+  /**
+  * @description sorting method, works when `sortable` is `true`. Should return a number, just like Array.sort
+  */
+  sortMethod: Function,
+  /**
+  * @description 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: [
+    String,
+    Function,
+    Array
+  ],
+  /**
+  * @description whether column width can be resized, works when `border` of `el-table` is `true`
+  */
+  resizable: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description column's key. If you need to use the filter-change event, you need this attribute to identify which column is being filtered
+  */
+  columnKey: String,
+  /**
+  * @description alignment, the value should be 'left' \/ 'center' \/ 'right'
+  */
+  align: String,
+  /**
+  * @description 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: String,
+  /**
+  * @description whether to hide extra content and show them in a tooltip when hovering on the cell
+  */
+  showOverflowTooltip: {
+    type: [Boolean, Object],
+    default: void 0
+  },
+  /**
+  * @description function that formats cell tooltip content, works when `show-overflow-tooltip` is `true`
+  */
+  tooltipFormatter: Function,
+  /**
+  * @description whether column is fixed at left / right. Will be fixed at left if `true`
+  */
+  fixed: [Boolean, String],
+  /**
+  * @description function that formats cell content
+  */
+  formatter: Function,
+  /**
+  * @description function that determines if a certain row can be selected, works when `type` is 'selection'
+  */
+  selectable: Function,
+  /**
+  * @description whether to reserve selection after data refreshing, works when `type` is 'selection'. Note that `row-key` is required for this to work
+  */
+  reserveSelection: Boolean,
+  /**
+  * @description 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: Function,
+  /**
+  * @description filter value for selected data, might be useful when table header is rendered with `render-header`
+  */
+  filteredValue: Array,
+  /**
+  * @description an array of data filtering options. For each element in this array, `text` and `value` are required
+  */
+  filters: Array,
+  /**
+  * @description placement for the filter dropdown
+  */
+  filterPlacement: String,
+  /**
+  * @description whether data filtering supports multiple options
+  */
+  filterMultiple: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description className for the filter dropdown
+  */
+  filterClassName: String,
+  /**
+  * @description customize indices for each row, works on columns with `type=index`
+  */
+  index: [Number, Function],
+  /**
+  * @description 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: Array,
+    default: () => [
+      "ascending",
+      "descending",
+      null
+    ],
+    validator: (e) => e.every((t) => [
+      "ascending",
+      "descending",
+      null
+    ].includes(t))
+  }
+};
+export {
+  r as default,
+  r as tableColumnProps
+};

package/dist/node_modules/element-plus/es/components/table/src/table-column/index.js

@@ -0,0 +1,5 @@
+import a from "./index2.js";
+var t = a;
+export {
+  t as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-column/index.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,97 @@
+import { isUndefined as b } from "../../../../utils/types.js";
+import { useGlobalConfig as A } from "../../../config-provider/src/hooks/use-global-config.js";
+import { createTableColumnId as E, mergeOptions as W, compose as k } from "../util.js";
+import R from "./defaults.js";
+import { cellStarts as D } from "../config.js";
+import G from "./watcher-helper.js";
+import H from "./render-helper.js";
+import { defineComponent as K, useSlots as U, getCurrentInstance as V, ref as z, computed as $, onBeforeMount as j, onMounted as q, onBeforeUnmount as J, openBlock as L, createBlock as Q, Fragment as X, h as w } from "vue";
+import { isArray as x, isString as Y } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+var ie = /* @__PURE__ */ K({
+  name: "ElTableColumn",
+  __name: "index",
+  props: R,
+  setup(y) {
+    const l = y, c = U(), u = V(), d = A("table"), i = z({}), m = $(() => {
+      let e = u.parent;
+      for (; e && !e.tableId; ) e = e.parent;
+      return e;
+    }), { registerNormalWatchers: I, registerComplexWatchers: _ } = G(m, l), { columnId: f, isSubColumn: p, realHeaderAlign: O, columnOrTableParent: C, setColumnWidth: T, setColumnForcedProps: F, setColumnRenders: M, getPropsData: N, getColumnElIndex: P, realAlign: S, updateColumnOrder: h } = H(l, c, m), r = C.value;
+    f.value = E("tableId" in r ? r.tableId : r.columnId), j(() => {
+      var g, v;
+      p.value = m.value !== r;
+      const e = l.type || "default", a = l.sortable === "" ? !0 : l.sortable, s = e === "selection" ? !1 : b(l.showOverflowTooltip) ? r.props.showOverflowTooltip ?? ((g = d.value) == null ? void 0 : g.showOverflowTooltip) : l.showOverflowTooltip, n = b(l.tooltipFormatter) ? r.props.tooltipFormatter ?? ((v = d.value) == null ? void 0 : v.tooltipFormatter) : l.tooltipFormatter, t = {
+        ...D[e],
+        id: f.value,
+        type: e,
+        property: l.prop || l.property,
+        align: S,
+        headerAlign: O,
+        showOverflowTooltip: s,
+        tooltipFormatter: n,
+        filterable: l.filters || l.filterMethod,
+        filteredValue: [],
+        filterPlacement: "",
+        filterClassName: "",
+        isColumnGroup: !1,
+        isSubColumn: !1,
+        filterOpened: !1,
+        sortable: a,
+        index: l.index,
+        rawColumnKey: u.vnode.key
+      };
+      let o = N([
+        "columnKey",
+        "label",
+        "className",
+        "labelClassName",
+        "type",
+        "renderHeader",
+        "formatter",
+        "fixed",
+        "resizable"
+      ], [
+        "sortMethod",
+        "sortBy",
+        "sortOrders"
+      ], ["selectable", "reserveSelection"], [
+        "filterMethod",
+        "filters",
+        "filterMultiple",
+        "filterOpened",
+        "filteredValue",
+        "filterPlacement",
+        "filterClassName"
+      ]);
+      o = W(t, o), o = k(M, T, F)(o), i.value = o, I(), _();
+    }), q(() => {
+      var n, t;
+      const e = C.value, a = p.value ? (n = e.vnode.el) == null ? void 0 : n.children : (t = e.refs.hiddenColumns) == null ? void 0 : t.children, s = () => P(a || [], u.vnode.el);
+      i.value.getColumnIndex = s, s() > -1 && m.value.store.commit("insertColumn", i.value, p.value ? "columnConfig" in e && e.columnConfig.value : null, h);
+    }), J(() => {
+      const e = i.value.getColumnIndex;
+      (e ? e() : -1) > -1 && m.value.store.commit("removeColumn", i.value, p.value ? "columnConfig" in r && r.columnConfig.value : null, h);
+    }), u.columnId = f.value, u.columnConfig = i;
+    const B = () => {
+      var e, a;
+      try {
+        const s = (e = c.default) == null ? void 0 : e.call(c, {
+          row: {},
+          column: {},
+          $index: -1
+        }), n = [];
+        if (x(s))
+          for (const t of s) ((a = t.type) == null ? void 0 : a.name) === "ElTableColumn" || t.shapeFlag & 2 ? n.push(t) : t.type === X && x(t.children) && t.children.forEach((o) => {
+            (o == null ? void 0 : o.patchFlag) !== 1024 && !Y(o == null ? void 0 : o.children) && n.push(o);
+          });
+        return w("div", n);
+      } catch {
+        return w("div", []);
+      }
+    };
+    return (e, a) => (L(), Q(B));
+  }
+});
+export {
+  ie as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-column/index2.js

@@ -0,0 +1,5 @@
+import e from "./index.vue_vue_type_script_setup_true_lang.js";
+var _ = e;
+export {
+  _ as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-column/render-helper.js

@@ -0,0 +1,84 @@
+import { isUndefined as x } from "../../../../utils/types.js";
+import { debugWarn as F } from "../../../../utils/error.js";
+import { useNamespace as V } from "../../../../hooks/use-namespace/index.js";
+import { parseWidth as k, parseMinWidth as H, ensureValidVNode as S } from "../util.js";
+import { defaultRenderCell as j, treeCellPrefix as M, cellForced as U, getDefaultClassName as q } from "../config.js";
+import { getCurrentInstance as z, ref as d, watchEffect as b, computed as W, h as C, Fragment as B, createTextVNode as G, renderSlot as y, Comment as J, unref as N } from "vue";
+import { isArray as I } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+function ae(l, a, h) {
+  const i = z(), w = d(""), E = d(!1), o = d(), m = d(), g = V("table");
+  b(() => {
+    o.value = l.align ? `is-${l.align}` : null, o.value;
+  }), b(() => {
+    m.value = l.headerAlign ? `is-${l.headerAlign}` : o.value, m.value;
+  });
+  const $ = W(() => {
+    let e = i.vnode.vParent || i.parent;
+    for (; e && !e.tableId && !e.columnId; ) e = e.vnode.vParent || e.parent;
+    return e;
+  }), O = W(() => {
+    const { store: e } = i.parent;
+    if (!e) return !1;
+    const { treeData: r } = e.states, t = r.value;
+    return t && Object.keys(t).length > 0;
+  }), v = d(k(l.width)), p = d(H(l.minWidth)), P = (e) => (v.value && (e.width = v.value), p.value && (e.minWidth = p.value), !v.value && p.value && (e.width = void 0), e.minWidth || (e.minWidth = 80), e.realWidth = Number(x(e.width) ? e.minWidth : e.width), e), A = (e) => {
+    const r = e.type, t = U[r] || {};
+    Object.keys(t).forEach((s) => {
+      const u = t[s];
+      s !== "className" && !x(u) && (e[s] = u);
+    });
+    const n = q(r);
+    if (n) {
+      const s = `${N(g.namespace)}-${n}`;
+      e.className = e.className ? `${e.className} ${s}` : s;
+    }
+    return e;
+  }, R = (e) => {
+    I(e) ? e.forEach((t) => r(t)) : r(e);
+    function r(t) {
+      var n;
+      ((n = t == null ? void 0 : t.type) == null ? void 0 : n.name) === "ElTableColumn" && (t.vParent = i);
+    }
+  };
+  return {
+    columnId: w,
+    realAlign: o,
+    isSubColumn: E,
+    realHeaderAlign: m,
+    columnOrTableParent: $,
+    setColumnWidth: P,
+    setColumnForcedProps: A,
+    setColumnRenders: (e) => {
+      l.renderHeader ? F("TableColumn", "Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.") : e.type !== "selection" && (e.renderHeader = (t) => {
+        if (i.columnConfig.value.label, a.header) {
+          const n = a.header(t);
+          if (S(n)) return C(B, n);
+        }
+        return G(e.label);
+      }), a["filter-icon"] && (e.renderFilterIcon = (t) => y(a, "filter-icon", t)), a.expand && (e.renderExpand = (t) => y(a, "expand", t));
+      let r = e.renderCell;
+      return e.type === "expand" ? (e.renderCell = (t) => C("div", { class: "cell" }, [r(t)]), h.value.renderExpanded = (t) => a.default ? a.default(t) : a.default) : (r = r || j, e.renderCell = (t) => {
+        let n = null;
+        if (a.default) {
+          const f = a.default(t);
+          n = f.some((D) => D.type !== J) ? f : r(t);
+        } else n = r(t);
+        const { columns: s } = h.value.store.states, u = s.value.findIndex((f) => f.type === "default"), T = M(t, O.value && t.cellIndex === u), c = {
+          class: "cell",
+          style: {}
+        };
+        return e.showOverflowTooltip && (c.class = `${c.class} ${N(g.namespace)}-tooltip`, c.style = { width: `${(t.column.realWidth || Number(t.column.width)) - 1}px` }), R(n), C("div", c, [T, n]);
+      }), e;
+    },
+    getPropsData: (...e) => e.reduce((r, t) => (I(t) && t.forEach((n) => {
+      r[n] = l[n];
+    }), r), {}),
+    getColumnElIndex: (e, r) => Array.prototype.indexOf.call(e, r),
+    updateColumnOrder: () => {
+      h.value.store.commit("updateColumnOrder", i.columnConfig.value);
+    }
+  };
+}
+export {
+  ae as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-column/watcher-helper.js

@@ -0,0 +1,69 @@
+import { isUndefined as p } from "../../../../utils/types.js";
+import { hasOwn as f } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { useGlobalConfig as v } from "../../../config-provider/src/hooks/use-global-config.js";
+import { parseWidth as g, parseMinWidth as C } from "../util.js";
+import { getCurrentInstance as w, watch as u } from "vue";
+function d(r, i) {
+  return r.reduce((l, c) => (l[c] = c, l), i);
+}
+function M(r, i) {
+  const l = w();
+  return {
+    registerComplexWatchers: () => {
+      const m = ["fixed"], s = {
+        realWidth: "width",
+        realMinWidth: "minWidth"
+      }, n = d(m, s);
+      Object.keys(n).forEach((a) => {
+        const o = s[a];
+        f(i, o) && u(() => i[o], (e) => {
+          let t = e;
+          o === "width" && a === "realWidth" && (t = g(e)), o === "minWidth" && a === "realMinWidth" && (t = C(e)), l.columnConfig.value[o] = t, l.columnConfig.value[a] = t;
+          const h = o === "fixed";
+          r.value.store.scheduleLayout(h);
+        });
+      });
+    },
+    registerNormalWatchers: () => {
+      const m = [
+        "label",
+        "filters",
+        "filterMultiple",
+        "filteredValue",
+        "sortable",
+        "index",
+        "formatter",
+        "className",
+        "labelClassName",
+        "filterClassName",
+        "showOverflowTooltip",
+        "tooltipFormatter",
+        "resizable"
+      ], s = ["showOverflowTooltip"], n = {
+        property: "prop",
+        align: "realAlign",
+        headerAlign: "realHeaderAlign"
+      }, a = d(m, n);
+      Object.keys(a).forEach((e) => {
+        const t = n[e];
+        f(i, t) && u(() => i[t], (h) => {
+          l.columnConfig.value[e] = h, (e === "filters" || e === "filterMethod") && (l.columnConfig.value.filterable = !!(l.columnConfig.value.filters || l.columnConfig.value.filterMethod));
+        });
+      }), s.forEach((e) => {
+        f(r.value.props, e) && u(() => r.value.props[e], (t) => {
+          l.columnConfig.value.type !== "selection" && p(i[e]) && (l.columnConfig.value[e] = t);
+        });
+      });
+      const o = v("table");
+      o.value && f(o.value, "showOverflowTooltip") && u(() => {
+        var e;
+        return (e = o.value) == null ? void 0 : e.showOverflowTooltip;
+      }, (e) => {
+        l.columnConfig.value.type !== "selection" && (!p(i.showOverflowTooltip) || !p(r.value.props.showOverflowTooltip) || (l.columnConfig.value.showOverflowTooltip = e));
+      });
+    }
+  };
+}
+export {
+  M as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-footer/index.js

@@ -0,0 +1,75 @@
+import { useNamespace as h } from "../../../../hooks/use-namespace/index.js";
+import y from "../layout-observer.js";
+import { TABLE_INJECTION_KEY as C } from "../tokens.js";
+import g from "./style-helper.js";
+import { defineComponent as S, h as l, inject as E } from "vue";
+var _ = S({
+  name: "ElTableFooter",
+  props: {
+    fixed: {
+      type: String,
+      default: ""
+    },
+    store: {
+      required: !0,
+      type: Object
+    },
+    summaryMethod: Function,
+    sumText: String,
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: () => ({
+        prop: "",
+        order: ""
+      })
+    }
+  },
+  setup(o) {
+    const m = E(C), p = h("table"), { getCellClasses: n, getCellStyles: i, columns: u } = g(o), { onScrollableChange: s, onColumnsChange: t } = y(m);
+    return {
+      ns: p,
+      onScrollableChange: s,
+      onColumnsChange: t,
+      getCellClasses: n,
+      getCellStyles: i,
+      columns: u
+    };
+  },
+  render() {
+    const { columns: o, getCellStyles: m, getCellClasses: p, summaryMethod: n, sumText: i } = this, u = this.store.states.data.value;
+    let s = [];
+    return n ? s = n({
+      columns: o,
+      data: u
+    }) : o.forEach((t, e) => {
+      if (e === 0) {
+        s[e] = i;
+        return;
+      }
+      const c = u.map((r) => Number(r[t.property])), f = [];
+      let b = !0;
+      c.forEach((r) => {
+        if (!Number.isNaN(+r)) {
+          b = !1;
+          const a = `${r}`.split(".")[1];
+          f.push(a ? a.length : 0);
+        }
+      });
+      const d = Math.max.apply(null, f);
+      b ? s[e] = "" : s[e] = c.reduce((r, a) => {
+        const N = Number(a);
+        return Number.isNaN(+N) ? r : Number.parseFloat((r + a).toFixed(Math.min(d, 20)));
+      }, 0);
+    }), l(l("tfoot", [l("tr", {}, [...o.map((t, e) => l("td", {
+      key: e,
+      colspan: t.colSpan,
+      rowspan: t.rowSpan,
+      class: p(o, e),
+      style: m(t, e)
+    }, [l("div", { class: ["cell", t.labelClassName] }, [s[e]])]))])]));
+  }
+});
+export {
+  _ as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-footer/mapState-helper.js

@@ -0,0 +1,17 @@
+import { TABLE_INJECTION_KEY as n } from "../tokens.js";
+import { inject as l, computed as e } from "vue";
+function m() {
+  var u;
+  const t = (u = l(n)) == null ? void 0 : u.store;
+  return {
+    leftFixedLeafCount: e(() => (t == null ? void 0 : t.states.fixedLeafColumnsLength.value) ?? 0),
+    rightFixedLeafCount: e(() => (t == null ? void 0 : t.states.rightFixedColumns.value.length) ?? 0),
+    columnsCount: e(() => (t == null ? void 0 : t.states.columns.value.length) ?? 0),
+    leftFixedCount: e(() => (t == null ? void 0 : t.states.fixedColumns.value.length) ?? 0),
+    rightFixedCount: e(() => (t == null ? void 0 : t.states.rightFixedColumns.value.length) ?? 0),
+    columns: e(() => (t == null ? void 0 : t.states.columns.value) ?? [])
+  };
+}
+export {
+  m as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-footer/style-helper.js

@@ -0,0 +1,26 @@
+import { useNamespace as r } from "../../../../hooks/use-namespace/index.js";
+import { getFixedColumnOffset as c, ensurePosition as n, getFixedColumnsClass as u } from "../util.js";
+import f from "./mapState-helper.js";
+function x(a) {
+  const { columns: i } = f(), t = r("table");
+  return {
+    getCellClasses: (l, s) => {
+      const e = l[s], o = [
+        t.e("cell"),
+        e.id,
+        e.align,
+        e.labelClassName,
+        ...u(t.b(), s, e.fixed, a.store)
+      ];
+      return e.className && o.push(e.className), e.children || o.push(t.is("leaf")), o;
+    },
+    getCellStyles: (l, s) => {
+      const e = c(s, l.fixed, a.store);
+      return n(e, "left"), n(e, "right"), e;
+    },
+    columns: i
+  };
+}
+export {
+  x as default
+};

package/dist/node_modules/element-plus/es/components/table/src/table-header/event-helper.js

@@ -0,0 +1,101 @@
+import { isElement as q } from "../../../../utils/types.js";
+import { hasClass as b, removeClass as w, addClass as A } from "../../../../utils/dom/style.js";
+import { TABLE_INJECTION_KEY as D } from "../tokens.js";
+import { getCurrentInstance as H, inject as O, ref as x } from "vue";
+import X from "../../../../../../lodash-es/isNull.js";
+import { isClient as P } from "../../../../../../@vueuse/shared/dist/index.js";
+function U(v, E) {
+  const y = H(), l = O(D), M = (t) => {
+    t.stopPropagation();
+  }, z = (t, e) => {
+    !e.filters && e.sortable ? k(t, e, !1) : e.filterable && !e.sortable && M(t), l == null || l.emit("header-click", e, t);
+  }, S = (t, e) => {
+    l == null || l.emit("header-contextmenu", e, t);
+  }, m = x(null), g = x(!1), h = x(), T = (t, e) => {
+    var n, r, u;
+    if (P && !(e.children && e.children.length > 0) && m.value && v.border && m.value.id === e.id) {
+      g.value = !0;
+      const s = l;
+      E("set-drag-visible", !0);
+      const o = (n = s == null ? void 0 : s.vnode.el) == null ? void 0 : n.getBoundingClientRect().left, d = (u = (r = y == null ? void 0 : y.vnode) == null ? void 0 : r.el) == null ? void 0 : u.querySelector(`th.${e.id}`), i = d.getBoundingClientRect(), a = i.left - o + 30;
+      A(d, "noclick"), h.value = {
+        startMouseLeft: t.clientX,
+        startLeft: i.right - o,
+        startColumnLeft: i.left - o,
+        tableLeft: o
+      };
+      const c = s == null ? void 0 : s.refs.resizeProxy;
+      c.style.left = `${h.value.startLeft}px`, document.onselectstart = function() {
+        return !1;
+      }, document.ondragstart = function() {
+        return !1;
+      };
+      const f = (L) => {
+        const p = L.clientX - h.value.startMouseLeft, I = h.value.startLeft + p;
+        c.style.left = `${Math.max(a, I)}px`;
+      }, C = () => {
+        if (g.value) {
+          const { startColumnLeft: L, startLeft: p } = h.value;
+          e.width = e.realWidth = Number.parseInt(c.style.left, 10) - L, s == null || s.emit("header-dragend", e.width, p - L, e, t), requestAnimationFrame(() => {
+            v.store.scheduleLayout(!1, !0);
+          }), document.body.style.cursor = "", g.value = !1, m.value = null, h.value = void 0, E("set-drag-visible", !1);
+        }
+        document.removeEventListener("mousemove", f), document.removeEventListener("mouseup", C), document.onselectstart = null, document.ondragstart = null, setTimeout(() => {
+          w(d, "noclick");
+        }, 0);
+      };
+      document.addEventListener("mousemove", f), document.addEventListener("mouseup", C);
+    }
+  }, N = (t, e) => {
+    var c;
+    if (!v.border || e.children && e.children.length > 0) return;
+    const n = t.target, r = q(n) ? n.closest("th") : null;
+    if (!r) return;
+    const u = b(r, "is-sortable");
+    if (u) {
+      const f = g.value ? "col-resize" : "";
+      r.style.cursor = f;
+      const C = r.querySelector(".caret-wrapper");
+      C && (C.style.cursor = f);
+    }
+    if (!e.resizable || g.value) {
+      m.value = null;
+      return;
+    }
+    const s = r.getBoundingClientRect(), o = ((c = r.parentNode) == null ? void 0 : c.lastElementChild) === r, d = v.allowDragLastColumn || !o, i = s.width > 12 && s.right - t.clientX < 8 && d, a = i ? "col-resize" : "";
+    document.body.style.cursor = a, m.value = i ? e : null, u && (r.style.cursor = a);
+  }, R = () => {
+    !P || g.value || (document.body.style.cursor = "");
+  }, B = ({ order: t, sortOrders: e }) => {
+    if (t === "") return e[0];
+    const n = e.indexOf(t || null);
+    return e[n > e.length - 2 ? 0 : n + 1];
+  }, k = (t, e, n) => {
+    var c;
+    t.stopPropagation();
+    const r = e.order === n ? null : n || B(e), u = (c = t.target) == null ? void 0 : c.closest("th");
+    if (u && b(u, "noclick")) {
+      w(u, "noclick");
+      return;
+    }
+    if (!e.sortable) return;
+    const s = t.currentTarget;
+    if (["ascending", "descending"].some((f) => b(s, f) && !e.sortOrders.includes(f))) return;
+    const o = v.store.states;
+    let d = o.sortProp.value, i;
+    const a = o.sortingColumn.value;
+    (a !== e || a === e && X(a.order)) && (a && (a.order = null), o.sortingColumn.value = e, d = e.property ?? null), r ? i = e.order = r : i = e.order = null, o.sortProp.value = d, o.sortOrder.value = i, l == null || l.store.commit("changeSortCondition");
+  };
+  return {
+    handleHeaderClick: z,
+    handleHeaderContextMenu: S,
+    handleMouseDown: T,
+    handleMouseMove: N,
+    handleMouseOut: R,
+    handleSortClick: k,
+    handleFilterClick: M
+  };
+}
+export {
+  U as default
+};