ep-craft 0.1.7 → 0.1.9

package/dist/node_modules/element-plus/es/components/virtual-list/src/components/dynamic-size-list.js

@@ -0,0 +1,94 @@
+import { throwError as E } from "../../../../utils/error.js";
+import { AUTO_ALIGNMENT as d, CENTERED_ALIGNMENT as I, START_ALIGNMENT as x } from "../defaults.js";
+import { isHorizontal as S } from "../utils.js";
+import y from "../builders/build-list.js";
+const T = "ElDynamicSizeList", z = (e, s, t) => {
+  const { itemSize: i } = e, { items: o, lastVisitedIndex: n } = t;
+  if (s > n) {
+    let r = 0;
+    if (n >= 0) {
+      const a = o[n];
+      r = a.offset + a.size;
+    }
+    for (let a = n + 1; a <= s; a++) {
+      const m = i(a);
+      o[a] = {
+        offset: r,
+        size: m
+      }, r += m;
+    }
+    t.lastVisitedIndex = s;
+  }
+  return o[s];
+}, L = (e, s, t) => {
+  const { items: i, lastVisitedIndex: o } = s;
+  return (o > 0 ? i[o].offset : 0) >= t ? l(e, s, 0, o, t) : N(e, s, Math.max(0, o), t);
+}, l = (e, s, t, i, o) => {
+  for (; t <= i; ) {
+    const n = t + Math.floor((i - t) / 2), r = z(e, n, s).offset;
+    if (r === o) return n;
+    r < o ? t = n + 1 : r > o && (i = n - 1);
+  }
+  return Math.max(0, t - 1);
+}, N = (e, s, t, i) => {
+  const { total: o } = e;
+  let n = 1;
+  for (; t < o && z(e, t, s).offset < i; )
+    t += n, n *= 2;
+  return l(e, s, Math.floor(t / 2), Math.min(t, o - 1), i);
+}, M = ({ total: e }, { items: s, estimatedItemSize: t, lastVisitedIndex: i }) => {
+  let o = 0;
+  if (i >= e && (i = e - 1), i >= 0) {
+    const r = s[i];
+    o = r.offset + r.size;
+  }
+  const n = (e - i - 1) * t;
+  return o + n;
+}, D = y({
+  name: "ElDynamicSizeList",
+  getItemOffset: (e, s, t) => z(e, s, t).offset,
+  getItemSize: (e, s, { items: t }) => t[s].size,
+  getEstimatedTotalSize: M,
+  getOffset: (e, s, t, i, o) => {
+    const { height: n, layout: r, width: a } = e, m = S(r) ? a : n, u = z(e, s, o), h = M(e, o), c = Math.max(0, Math.min(h - m, u.offset)), f = Math.max(0, u.offset - m + u.size);
+    switch (t === "smart" && (i >= f - m && i <= c + m ? t = d : t = I), t) {
+      case x:
+        return c;
+      case "end":
+        return f;
+      case I:
+        return Math.round(f + (c - f) / 2);
+      case d:
+      default:
+        return i >= f && i <= c ? i : i < f ? f : c;
+    }
+  },
+  getStartIndexForOffset: (e, s, t) => L(e, t, s),
+  getStopIndexForStartIndex: (e, s, t, i) => {
+    const { height: o, total: n, layout: r, width: a } = e, m = S(r) ? a : o, u = z(e, s, i), h = t + m;
+    let c = u.offset + u.size, f = s;
+    for (; f < n - 1 && c < h; )
+      f++, c += z(e, f, i).size;
+    return f;
+  },
+  initCache({ estimatedItemSize: e = 50 }, s) {
+    const t = {
+      items: {},
+      estimatedItemSize: e,
+      lastVisitedIndex: -1
+    };
+    return t.clearCacheAfterIndex = (i, o = !0) => {
+      var n, r;
+      t.lastVisitedIndex = Math.min(t.lastVisitedIndex, i - 1), (n = s.exposed) == null || n.getItemStyleCache(-1), o && ((r = s.proxy) == null || r.$forceUpdate());
+    }, t;
+  },
+  clearCache: !1,
+  validateProps: ({ itemSize: e }) => {
+    typeof e != "function" && E(T, `
+          itemSize is required as function, but the given value was ${typeof e}
+        `);
+  }
+});
+export {
+  D as default
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/components/fixed-size-grid.js

@@ -0,0 +1,74 @@
+import { isNumber as x } from "../../../../utils/types.js";
+import { throwError as O } from "../../../../utils/error.js";
+import { AUTO_ALIGNMENT as M, CENTERED_ALIGNMENT as d, START_ALIGNMENT as E } from "../defaults.js";
+import C from "../builders/build-grid.js";
+const l = "ElFixedSizeGrid", R = C({
+  name: "ElFixedSizeGrid",
+  getColumnPosition: ({ columnWidth: t }, e) => [t, e * t],
+  getRowPosition: ({ rowHeight: t }, e) => [t, e * t],
+  getEstimatedTotalHeight: ({ totalRow: t, rowHeight: e }) => e * t,
+  getEstimatedTotalWidth: ({ totalColumn: t, columnWidth: e }) => e * t,
+  getColumnOffset: ({ totalColumn: t, columnWidth: e, width: r }, m, n, s, u, c) => {
+    r = Number(r);
+    const o = Math.max(0, t * e - r), f = Math.min(o, m * e), a = Math.max(0, m * e - r + c + e);
+    switch (n === "smart" && (s >= a - r && s <= f + r ? n = M : n = d), n) {
+      case E:
+        return f;
+      case "end":
+        return a;
+      case d: {
+        const i = Math.round(a + (f - a) / 2);
+        return i < Math.ceil(r / 2) ? 0 : i > o + Math.floor(r / 2) ? o : i;
+      }
+      case M:
+      default:
+        return s >= a && s <= f ? s : a > f || s < a ? a : f;
+    }
+  },
+  getRowOffset: ({ rowHeight: t, height: e, totalRow: r }, m, n, s, u, c) => {
+    e = Number(e);
+    const o = Math.max(0, r * t - e), f = Math.min(o, m * t), a = Math.max(0, m * t - e + c + t);
+    switch (n === "smart" && (s >= a - e && s <= f + e ? n = M : n = d), n) {
+      case E:
+        return f;
+      case "end":
+        return a;
+      case d: {
+        const i = Math.round(a + (f - a) / 2);
+        return i < Math.ceil(e / 2) ? 0 : i > o + Math.floor(e / 2) ? o : i;
+      }
+      case M:
+      default:
+        return s >= a && s <= f ? s : a > f || s < a ? a : f;
+    }
+  },
+  getColumnStartIndexForOffset: ({ columnWidth: t, totalColumn: e }, r) => Math.max(0, Math.min(e - 1, Math.floor(r / t))),
+  getColumnStopIndexForStartIndex: ({ columnWidth: t, totalColumn: e, width: r }, m, n) => {
+    const s = m * t, u = Math.ceil((r + n - s) / t);
+    return Math.max(0, Math.min(e - 1, m + u - 1));
+  },
+  getRowStartIndexForOffset: ({ rowHeight: t, totalRow: e }, r) => Math.max(0, Math.min(e - 1, Math.floor(r / t))),
+  getRowStopIndexForStartIndex: ({ rowHeight: t, totalRow: e, height: r }, m, n) => {
+    const s = m * t, u = Math.ceil((r + n - s) / t);
+    return Math.max(0, Math.min(e - 1, m + u - 1));
+  },
+  /**
+  * Fixed size grid does not need this cache
+  * Using any to bypass it, TODO: Using type inference to fix this.
+  */
+  initCache: () => {
+  },
+  clearCache: !0,
+  validateProps: ({ columnWidth: t, rowHeight: e }) => {
+    x(t) || O(l, `
+          "columnWidth" must be passed as number,
+            instead ${typeof t} was given.
+        `), x(e) || O(l, `
+          "columnWidth" must be passed as number,
+            instead ${typeof e} was given.
+        `);
+  }
+});
+export {
+  R as default
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/components/fixed-size-list.js

@@ -0,0 +1,51 @@
+import { isString as E } from "../../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { throwError as x } from "../../../../utils/error.js";
+import { AUTO_ALIGNMENT as M, CENTERED_ALIGNMENT as d, START_ALIGNMENT as I } from "../defaults.js";
+import { isHorizontal as l } from "../utils.js";
+import p from "../builders/build-list.js";
+const z = p({
+  name: "ElFixedSizeList",
+  getItemOffset: ({ itemSize: t }, e) => e * t,
+  getItemSize: ({ itemSize: t }) => t,
+  getEstimatedTotalSize: ({ total: t, itemSize: e }) => e * t,
+  getOffset: ({ height: t, total: e, itemSize: a, layout: h, width: u }, n, s, i) => {
+    const r = l(h) ? u : t;
+    E(r) && x("[ElVirtualList]", `
+        You should set
+          width/height
+        to number when your layout is
+          horizontal/vertical
+      `);
+    const m = Math.max(0, e * a - r), f = Math.min(m, n * a), o = Math.max(0, (n + 1) * a - r);
+    switch (s === "smart" && (i >= o - r && i <= f + r ? s = M : s = d), s) {
+      case I:
+        return f;
+      case "end":
+        return o;
+      case d: {
+        const c = Math.round(o + (f - o) / 2);
+        return c < Math.ceil(r / 2) ? 0 : c > m + Math.floor(r / 2) ? m : c;
+      }
+      case M:
+      default:
+        return i >= o && i <= f ? i : i < o ? o : f;
+    }
+  },
+  getStartIndexForOffset: ({ total: t, itemSize: e }, a) => Math.max(0, Math.min(t - 1, Math.floor(a / e))),
+  getStopIndexForStartIndex: ({ height: t, total: e, itemSize: a, layout: h, width: u }, n, s) => {
+    const i = n * a, r = l(h) ? u : t, m = Math.ceil((r + s - i) / a);
+    return Math.max(0, Math.min(e - 1, n + m - 1));
+  },
+  /**
+  * Fixed size list does not need this cache
+  * Using any to bypass it, TODO: Using type inference to fix this.
+  */
+  initCache() {
+  },
+  clearCache: !0,
+  validateProps() {
+  }
+});
+export {
+  z as default
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/components/scrollbar.js

@@ -0,0 +1,95 @@
+import { cAF as A, rAF as I } from "../../../../utils/raf.js";
+import { useNamespace as E } from "../../../../hooks/use-namespace/index.js";
+import { BAR_MAP as P } from "../../../scrollbar/src/util.js";
+import { ScrollbarDirKey as k } from "../defaults.js";
+import { virtualizedScrollbarProps as C } from "../props.js";
+import { renderThumbStyle as F } from "../utils.js";
+import { defineComponent as N, computed as o, ref as x, reactive as _, unref as m, watch as G, onBeforeUnmount as O, h as p, withModifiers as V } from "vue";
+const j = N({
+  name: "ElVirtualScrollBar",
+  props: C,
+  emits: [
+    "scroll",
+    "start-move",
+    "stop-move"
+  ],
+  setup(t, { emit: u }) {
+    const g = o(() => t.startGap + t.endGap), z = E("virtual-scrollbar"), L = E("scrollbar"), d = x(), r = x();
+    let b = null, f = null;
+    const a = _({
+      isDragging: !1,
+      traveled: 0
+    }), n = o(() => P[t.layout]), s = o(() => t.clientSize - m(g)), R = o(() => ({
+      position: "absolute",
+      width: `${t.layout === "horizontal" ? s.value : t.scrollbarSize}px`,
+      height: `${t.layout === "horizontal" ? t.scrollbarSize : s.value}px`,
+      [k[t.layout]]: "2px",
+      right: "2px",
+      bottom: "2px",
+      borderRadius: "4px"
+    })), h = o(() => {
+      const e = t.ratio;
+      if (e >= 100) return Number.POSITIVE_INFINITY;
+      if (e >= 50) return e * s.value / 100;
+      const l = s.value / 3;
+      return Math.floor(Math.min(Math.max(e * s.value / 100, 20), l));
+    }), B = o(() => {
+      if (!Number.isFinite(h.value)) return { display: "none" };
+      const e = `${h.value}px`;
+      return F({
+        bar: n.value,
+        size: e,
+        move: a.traveled
+      }, t.layout);
+    }), i = o(() => Math.ceil(t.clientSize - h.value - m(g))), D = () => {
+      window.addEventListener("mousemove", v), window.addEventListener("mouseup", c);
+      const e = m(r);
+      e && (f = document.onselectstart, document.onselectstart = () => !1, e.addEventListener("touchmove", v, { passive: !0 }), e.addEventListener("touchend", c));
+    }, S = () => {
+      window.removeEventListener("mousemove", v), window.removeEventListener("mouseup", c), document.onselectstart = f, f = null;
+      const e = m(r);
+      e && (e.removeEventListener("touchmove", v), e.removeEventListener("touchend", c));
+    }, M = (e) => {
+      e.stopImmediatePropagation(), !(e.ctrlKey || [1, 2].includes(e.button)) && (a.isDragging = !0, a[n.value.axis] = e.currentTarget[n.value.offset] - (e[n.value.client] - e.currentTarget.getBoundingClientRect()[n.value.direction]), u("start-move"), D());
+    }, c = () => {
+      a.isDragging = !1, a[n.value.axis] = 0, u("stop-move"), S();
+    }, v = (e) => {
+      const { isDragging: l } = a;
+      if (!l || !r.value || !d.value) return;
+      const w = a[n.value.axis];
+      if (!w) return;
+      A(b);
+      const y = (d.value.getBoundingClientRect()[n.value.direction] - e[n.value.client]) * -1 - (r.value[n.value.offset] - w);
+      b = I(() => {
+        a.traveled = Math.max(0, Math.min(y, i.value)), u("scroll", y, i.value);
+      });
+    }, T = (e) => {
+      const l = Math.abs(e.target.getBoundingClientRect()[n.value.direction] - e[n.value.client]) - r.value[n.value.offset] / 2;
+      a.traveled = Math.max(0, Math.min(l, i.value)), u("scroll", l, i.value);
+    };
+    return G(() => t.scrollFrom, (e) => {
+      a.isDragging || (a.traveled = Math.ceil(e * i.value));
+    }), O(() => {
+      S();
+    }), () => p("div", {
+      role: "presentation",
+      ref: d,
+      class: [
+        z.b(),
+        t.class,
+        (t.alwaysOn || a.isDragging) && "always-on"
+      ],
+      style: R.value,
+      onMousedown: V(T, ["stop", "prevent"]),
+      onTouchstartPrevent: M
+    }, p("div", {
+      ref: r,
+      class: L.e("thumb"),
+      style: B.value,
+      onMousedown: M
+    }, []));
+  }
+});
+export {
+  j as default
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/defaults.js

@@ -0,0 +1,20 @@
+const n = "itemRendered", c = "scroll", e = "end-reached", s = "forward", E = "backward", T = "auto", _ = "start", R = "center", t = "horizontal", o = "vertical", r = "negative", A = "positive-ascending", a = "positive-descending", i = {
+  [t]: "left",
+  [o]: "top"
+};
+export {
+  T as AUTO_ALIGNMENT,
+  E as BACKWARD,
+  R as CENTERED_ALIGNMENT,
+  e as END_REACHED_EVT,
+  s as FORWARD,
+  t as HORIZONTAL,
+  n as ITEM_RENDER_EVT,
+  r as RTL_OFFSET_NAG,
+  A as RTL_OFFSET_POS_ASC,
+  a as RTL_OFFSET_POS_DESC,
+  c as SCROLL_EVT,
+  _ as START_ALIGNMENT,
+  i as ScrollbarDirKey,
+  o as VERTICAL
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/hooks/use-cache.js

@@ -0,0 +1,13 @@
+import { getCurrentInstance as r, computed as t } from "vue";
+import m from "../../../../../../memoize-one/dist/memoize-one.esm.js";
+import p from "../../../../../../lodash-es/memoize.js";
+const f = () => {
+  const o = r().proxy.$props;
+  return t(() => {
+    const e = (n, c, s) => ({});
+    return o.perfMode ? p(e) : m(e);
+  });
+};
+export {
+  f as useCache
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/hooks/use-grid-touch.js

@@ -0,0 +1,27 @@
+import { cAF as n, rAF as L } from "../../../../utils/raf.js";
+import { useEventListener as i } from "../../../../../../@vueuse/core/dist/index.js";
+import { ref as m, unref as v } from "vue";
+const F = (a, r, f, p, T, d, S) => {
+  const e = m(0), l = m(0);
+  let u, o = 0, c = 0;
+  const s = (t) => {
+    n(u), e.value = t.touches[0].clientX, l.value = t.touches[0].clientY, o = 0, c = 0;
+  }, h = (t) => {
+    t.preventDefault(), n(u), o += e.value - t.touches[0].clientX, c += l.value - t.touches[0].clientY, e.value = t.touches[0].clientX, l.value = t.touches[0].clientY, u = L(() => {
+      const X = p.value - v(d), Y = T.value - v(S);
+      f({
+        scrollLeft: Math.min(r.value.scrollLeft + o, X),
+        scrollTop: Math.min(r.value.scrollTop + c, Y)
+      }), o = 0, c = 0;
+    });
+  };
+  return i(a, "touchstart", s, { passive: !0 }), i(a, "touchmove", h, { passive: !1 }), {
+    touchStartX: e,
+    touchStartY: l,
+    handleTouchStart: s,
+    handleTouchMove: h
+  };
+};
+export {
+  F as useGridTouch
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/hooks/use-grid-wheel.js

@@ -0,0 +1,25 @@
+import { cAF as i, rAF as v } from "../../../../utils/raf.js";
+const m = ({ atXEndEdge: s, atXStartEdge: d, atYEndEdge: u, atYStartEdge: h }, o) => {
+  let r = null, a = 0, n = 0;
+  const f = (e, t) => {
+    const l = e < 0 && d.value || e > 0 && s.value, c = t < 0 && h.value || t > 0 && u.value;
+    return l || c;
+  };
+  return {
+    hasReachedEdge: f,
+    onWheel: (e) => {
+      i(r);
+      let t = e.deltaX, l = e.deltaY;
+      if (Math.abs(t) > Math.abs(l) ? l = 0 : t = 0, e.shiftKey && l !== 0 && (t = l, l = 0), f(t, l)) {
+        e.deltaX !== 0 && t === 0 && e.preventDefault();
+        return;
+      }
+      a += t, n += l, e.preventDefault(), r = v(() => {
+        o(a, n), a = 0, n = 0;
+      });
+    }
+  };
+};
+export {
+  m as useGridWheel
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/hooks/use-wheel.js

@@ -0,0 +1,21 @@
+import { isFirefox as h } from "../../../../utils/browser.js";
+import { cAF as c, rAF as d } from "../../../../utils/raf.js";
+const F = ({ atEndEdge: f, atStartEdge: s, layout: i }, u) => {
+  let o, r = 0;
+  const a = (e) => e < 0 && s.value || e > 0 && f.value;
+  return {
+    hasReachedEdge: a,
+    onWheel: (e) => {
+      c(o);
+      let { deltaX: n, deltaY: t } = e;
+      e.shiftKey && t !== 0 && (n = t, t = 0);
+      const l = i.value === "horizontal" ? n : t;
+      a(l) || (r += l, !h() && l !== 0 && e.preventDefault(), o = d(() => {
+        u(r), r = 0;
+      }));
+    }
+  };
+};
+export {
+  F as default
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/props.js

@@ -0,0 +1,151 @@
+import { buildProps as l, definePropType as t, buildProp as e } from "../../../utils/vue/props/runtime.js";
+import { mutable as b } from "../../../utils/typescript.js";
+import { VERTICAL as f } from "./defaults.js";
+const i = e({
+  type: t([Number, Function]),
+  required: !0
+}), o = e({ type: Number }), a = e({
+  type: Number,
+  default: 2
+}), S = e({
+  type: String,
+  values: ["ltr", "rtl"],
+  default: "ltr"
+}), n = e({
+  type: Number,
+  default: 0
+}), r = e({
+  type: Number,
+  required: !0
+}), d = e({
+  type: String,
+  values: ["horizontal", "vertical"],
+  default: f
+}), s = l({
+  className: {
+    type: String,
+    default: ""
+  },
+  containerElement: {
+    type: t([String, Object]),
+    default: "div"
+  },
+  data: {
+    type: t(Array),
+    default: () => b([])
+  },
+  /**
+  * @description controls the horizontal direction.
+  */
+  direction: S,
+  height: {
+    type: [String, Number],
+    required: !0
+  },
+  innerElement: {
+    type: [String, Object],
+    default: "div"
+  },
+  innerProps: {
+    type: t(Object),
+    default: () => ({})
+  },
+  style: {
+    type: t([
+      Object,
+      String,
+      Array,
+      Boolean
+    ]),
+    default: void 0
+  },
+  useIsScrolling: Boolean,
+  width: {
+    type: [Number, String],
+    required: !1
+  },
+  innerWidth: {
+    type: [Number, String],
+    required: !1
+  },
+  perfMode: {
+    type: Boolean,
+    default: !0
+  },
+  scrollbarAlwaysOn: Boolean
+}), v = l({
+  /**
+  * @description describes how many items should be pre rendered to the head
+  * and the tail of the window
+  */
+  cache: a,
+  estimatedItemSize: o,
+  /**
+  * @description controls the list's orientation
+  */
+  layout: d,
+  initScrollOffset: n,
+  /**
+  * @description describes the total number of the list.
+  */
+  total: r,
+  itemSize: i,
+  ...s
+}), u = {
+  type: Number,
+  default: 6
+}, c = {
+  type: Number,
+  default: 0
+}, p = {
+  type: Number,
+  default: 2
+}, z = l({
+  columnCache: a,
+  columnWidth: i,
+  estimatedColumnWidth: o,
+  estimatedRowHeight: o,
+  initScrollLeft: n,
+  initScrollTop: n,
+  itemKey: {
+    type: t(Function),
+    default: ({ columnIndex: m, rowIndex: y }) => `${y}:${m}`
+  },
+  rowCache: a,
+  rowHeight: i,
+  totalColumn: r,
+  totalRow: r,
+  hScrollbarSize: u,
+  vScrollbarSize: u,
+  scrollbarStartGap: c,
+  scrollbarEndGap: p,
+  role: String,
+  ...s
+}), q = l({
+  alwaysOn: Boolean,
+  class: String,
+  layout: d,
+  total: r,
+  ratio: {
+    type: Number,
+    required: !0
+  },
+  clientSize: {
+    type: Number,
+    required: !0
+  },
+  scrollFrom: {
+    type: Number,
+    required: !0
+  },
+  scrollbarSize: u,
+  startGap: c,
+  endGap: p,
+  visible: Boolean
+});
+export {
+  z as virtualizedGridProps,
+  v as virtualizedListProps,
+  s as virtualizedProps,
+  q as virtualizedScrollbarProps
+};

package/dist/node_modules/element-plus/es/components/virtual-list/src/utils.js

@@ -0,0 +1,23 @@
+import { FORWARD as s, BACKWARD as c, RTL_OFFSET_POS_DESC as d, RTL_OFFSET_NAG as h, RTL_OFFSET_POS_ASC as f } from "./defaults.js";
+const a = (t, e) => t < e ? s : c, p = (t) => t === "ltr" || t === "rtl" || t === "horizontal", m = (t) => t === "rtl";
+let o = null;
+function S(t = !1) {
+  if (o === null || t) {
+    const e = document.createElement("div"), n = e.style;
+    n.width = "50px", n.height = "50px", n.overflow = "scroll", n.direction = "rtl";
+    const r = document.createElement("div"), l = r.style;
+    return l.width = "100px", l.height = "100px", e.appendChild(r), document.body.appendChild(e), e.scrollLeft > 0 ? o = d : (e.scrollLeft = 1, e.scrollLeft === 0 ? o = h : o = f), document.body.removeChild(e), o;
+  }
+  return o;
+}
+function T({ move: t, size: e, bar: n }, r) {
+  const l = {}, i = `translate${n.axis}(${t}px)`;
+  return l[n.size] = e, l.transform = i, r === "horizontal" ? l.height = "100%" : l.width = "100%", l;
+}
+export {
+  S as getRTLOffsetType,
+  a as getScrollDir,
+  p as isHorizontal,
+  m as isRTL,
+  T as renderThumbStyle
+};

package/dist/node_modules/element-plus/es/components/watermark/index.js

@@ -0,0 +1,7 @@
+import { withInstall as t } from "../../utils/vue/install.js";
+import r from "./src/watermark2.js";
+const o = t(r);
+export {
+  o as ElWatermark,
+  o as default
+};

package/dist/node_modules/element-plus/es/components/watermark/src/useClips.js

@@ -0,0 +1,68 @@
+import { isArray as V } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+const Z = {
+  left: [0, 0.5],
+  start: [0, 0.5],
+  center: [0.5, 0],
+  right: [1, -0.5],
+  end: [1, -0.5]
+};
+function R(T, s, h = 1) {
+  const t = document.createElement("canvas"), i = t.getContext("2d"), o = T * h, l = s * h;
+  return t.setAttribute("width", `${o}px`), t.setAttribute("height", `${l}px`), i.save(), [
+    i,
+    t,
+    o,
+    l
+  ];
+}
+function et() {
+  function T(s, h, t, i, o, l, X, _, F) {
+    const [e, O, r, m] = R(i, o, t);
+    let w = 0;
+    if (s instanceof HTMLImageElement) e.drawImage(s, 0, 0, r, m);
+    else {
+      const { color: n, fontSize: a, fontStyle: C, fontWeight: I, fontFamily: J, textAlign: y, textBaseline: N } = l, P = Number(a) * t;
+      e.font = `${C} normal ${I} ${P}px/${o}px ${J}`, e.fillStyle = n, e.textAlign = y, e.textBaseline = N;
+      const c = V(s) ? s : [s];
+      if (N !== "top" && c[0]) {
+        const W = e.measureText(c[0]);
+        e.textBaseline = "top";
+        const E = e.measureText(c[0]);
+        w = W.actualBoundingBoxAscent - E.actualBoundingBoxAscent;
+      }
+      c == null || c.forEach((W, E) => {
+        const [K, Q] = Z[y];
+        e.fillText(W ?? "", r * K + F * Q, E * (P + l.fontGap * t));
+      });
+    }
+    const f = Math.PI / 180 * Number(h), z = Math.max(i, o), [v, Y, x] = R(z, z, t);
+    v.translate(x / 2, x / 2), v.rotate(f), r > 0 && m > 0 && v.drawImage(O, -r / 2, -m / 2);
+    function D(n, a) {
+      return [n * Math.cos(f) - a * Math.sin(f), n * Math.sin(f) + a * Math.cos(f)];
+    }
+    let p = 0, B = 0, d = 0, $ = 0;
+    const M = r / 2, A = m / 2;
+    [
+      [0 - M, 0 - A],
+      [0 + M, 0 - A],
+      [0 + M, 0 + A],
+      [0 - M, 0 + A]
+    ].forEach(([n, a]) => {
+      const [C, I] = D(n, a);
+      p = Math.min(p, C), B = Math.max(B, C), d = Math.min(d, I), $ = Math.max($, I);
+    });
+    const U = p + x / 2, j = d + x / 2, u = B - p, g = $ - d, b = X * t, H = _ * t, G = (u + b) * 2, L = g + H, [k, q] = R(G, L);
+    function S(n = 0, a = 0) {
+      k.drawImage(Y, U, j, u, g, n, a + w, u, g);
+    }
+    return S(), S(u + b, -g / 2 - H / 2), S(u + b, +g / 2 + H / 2), [
+      q.toDataURL(),
+      G / t,
+      L / t
+    ];
+  }
+  return T;
+}
+export {
+  et as default
+};