@eonova/v3-directives 1.0.6

package/dist/index.js

@@ -0,0 +1,1156 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+// src/directive/v-backtop/index.ts
+var vBackTop = {
+  mounted(el, binding) {
+    const target = binding.arg ? document.getElementById(binding.arg) : window;
+    el.addEventListener("click", () => {
+      target.scrollTo({
+        behavior: "smooth",
+        top: 0
+      });
+    });
+    const handleScroll2 = () => {
+      const isScrolledUp = target.scrollTop < binding.value;
+      el.style.visibility = isScrolledUp ? "hidden" : "unset";
+    };
+    if (target.scrollTop < binding.value)
+      el.style.visibility = "hidden";
+    target.addEventListener("scroll", handleScroll2);
+  },
+  unmounted(el, binding) {
+    const target = binding.arg ? document.getElementById(binding.arg) : window;
+    const handleScroll2 = () => {
+      const isScrolledUp = target.scrollTop < binding.value;
+      el.style.visibility = isScrolledUp ? "hidden" : "unset";
+    };
+    target.removeEventListener("scroll", handleScroll2);
+    el.removeEventListener("click", handleScroll2);
+  },
+  updated(el, binding) {
+    const target = binding.arg ? document.getElementById(binding.arg) : window;
+    const handleScroll2 = () => {
+      const isScrolledUp = target.scrollTop < binding.value;
+      el.style.visibility = isScrolledUp ? "hidden" : "unset";
+    };
+    if (binding.value !== void 0)
+      target.addEventListener("scroll", handleScroll2);
+    else
+      target.removeEventListener("scroll", handleScroll2);
+  }
+};
+var v_backtop_default = vBackTop;
+
+// src/directive/v-clickOutside/index.ts
+var elMapToHandlers = /* @__PURE__ */ new WeakMap();
+function addEventListener(el, binding) {
+  const handler2 = (e) => {
+    if (el.contains(e.target))
+      return;
+    const { value } = binding;
+    value();
+  };
+  window.addEventListener("click", handler2);
+  elMapToHandlers.set(el, handler2);
+}
+var vClickOut = {
+  beforeUnmount(el) {
+    if (elMapToHandlers.has(el)) {
+      const handler2 = elMapToHandlers.get(el);
+      handler2 && window.removeEventListener("click", handler2);
+      elMapToHandlers.delete(el);
+    }
+  },
+  mounted(el, binding) {
+    addEventListener(el, binding);
+  },
+  updated(el, binding) {
+    if (elMapToHandlers.has(el)) {
+      const handler2 = elMapToHandlers.get(el);
+      handler2 && window.removeEventListener("click", handler2);
+      elMapToHandlers.delete(el);
+    }
+    addEventListener(el, binding);
+  }
+};
+var v_clickOutside_default = vClickOut;
+
+// src/directive/v-copy/index.ts
+function addEventListener2(el, binding) {
+  const { value } = binding;
+  el.setAttribute("copyValue", String(value));
+  const copyHandler = () => {
+    navigator.clipboard.writeText(el.getAttribute("copyValue") || "").then(() => {
+      window.alert("\u590D\u5236\u6210\u529F\uFF01");
+    }).catch(() => {
+      window.alert("\u590D\u5236\u5931\u8D25\uFF01");
+    });
+  };
+  el.addEventListener("click", copyHandler);
+}
+var vCopy = {
+  mounted(el, binding) {
+    addEventListener2(el, binding);
+  },
+  updated(el, binding) {
+    const { value } = binding;
+    el.setAttribute("copyValue", String(value));
+  }
+};
+var v_copy_default = vCopy;
+
+// src/utils/isBoolean.ts
+function isBoolean(x) {
+  return typeof x === "boolean";
+}
+
+// src/utils/isFunction.ts
+function isFunction_default(value) {
+  return typeof value === "function";
+}
+
+// src/utils/loadingSvg.ts
+var loadingSvg_default = `
+<svg width="57" height="57" viewBox="0 0 57 57" xmlns="http://www.w3.org/2000/svg" stroke="#fff">
+    <g fill="none" fill-rule="evenodd">
+        <g transform="translate(1 1)" stroke-width="2">
+            <circle cx="5" cy="50" r="5">
+                <animate attributeName="cy"
+                     begin="0s" dur="2.2s"
+                     values="50;5;50;50"
+                     calcMode="linear"
+                     repeatCount="indefinite" />
+                <animate attributeName="cx"
+                     begin="0s" dur="2.2s"
+                     values="5;27;49;5"
+                     calcMode="linear"
+                     repeatCount="indefinite" />
+            </circle>
+            <circle cx="27" cy="5" r="5">
+                <animate attributeName="cy"
+                     begin="0s" dur="2.2s"
+                     from="5" to="5"
+                     values="5;50;50;5"
+                     calcMode="linear"
+                     repeatCount="indefinite" />
+                <animate attributeName="cx"
+                     begin="0s" dur="2.2s"
+                     from="27" to="27"
+                     values="27;49;5;27"
+                     calcMode="linear"
+                     repeatCount="indefinite" />
+            </circle>
+            <circle cx="49" cy="50" r="5">
+                <animate attributeName="cy"
+                     begin="0s" dur="2.2s"
+                     values="50;50;5;50"
+                     calcMode="linear"
+                     repeatCount="indefinite" />
+                <animate attributeName="cx"
+                     from="49" to="49"
+                     begin="0s" dur="2.2s"
+                     values="49;5;27;49"
+                     calcMode="linear"
+                     repeatCount="indefinite" />
+            </circle>
+        </g>
+    </g>
+</svg>
+`;
+
+// src/directive/v-debounce/index.ts
+var elMapToHandlers2 = /* @__PURE__ */ new WeakMap();
+var elMapToEventName = /* @__PURE__ */ new WeakMap();
+function addEventListener3(el, binding) {
+  const { arg, value } = binding;
+  if (!isFunction_default(value))
+    return;
+  const delay = arg ? Number(arg.split("-")[1]) : 300;
+  const eventName = arg ? arg.split("-")[0] : "click";
+  let timer;
+  const handler2 = () => {
+    if (timer === void 0) {
+      timer = window.setTimeout(() => {
+        value();
+        timer = void 0;
+      }, delay);
+    } else {
+      window.clearTimeout(timer);
+      timer = window.setTimeout(() => {
+        value();
+        timer = void 0;
+      }, delay);
+    }
+  };
+  elMapToHandlers2.set(el, handler2);
+  elMapToEventName.set(el, eventName);
+  el.addEventListener(eventName, handler2);
+}
+var vDebounce = {
+  beforeUnmount(el) {
+    elMapToHandlers2.delete(el);
+    elMapToEventName.delete(el);
+  },
+  mounted(el, binding) {
+    addEventListener3(el, binding);
+  },
+  updated(el, binding) {
+    if (elMapToHandlers2.has(el)) {
+      const eventName = elMapToEventName.get(el);
+      const handler2 = elMapToHandlers2.get(el);
+      handler2 && eventName && el.removeEventListener(eventName, handler2);
+      elMapToHandlers2.delete(el);
+      elMapToEventName.delete(el);
+    }
+    addEventListener3(el, binding);
+  }
+};
+var v_debounce_default = vDebounce;
+
+// src/directive/v-doubleClick/index.ts
+var elMapToHandlers3 = /* @__PURE__ */ new WeakMap();
+function addEventListener4(el, binding) {
+  const { arg, value } = binding;
+  if (!isFunction_default(value))
+    return;
+  let clickCount = 0;
+  let time = 0;
+  const handler2 = () => {
+    clickCount++;
+    const now = (/* @__PURE__ */ new Date()).getTime();
+    if (clickCount === 1) {
+      time = now;
+      setTimeout(
+        () => {
+          clickCount = 0;
+          time = 0;
+        },
+        arg ? Number(arg) : 300
+      );
+    }
+    if (clickCount === 2) {
+      if (now - time < (arg ? Number(arg) : 300))
+        value();
+      clickCount = 0;
+      time = 0;
+    }
+  };
+  elMapToHandlers3.set(el, handler2);
+  el.addEventListener("click", handler2);
+}
+var vDoubleClick = {
+  beforeUnmount(el) {
+    elMapToHandlers3.delete(el);
+  },
+  mounted(el, binding) {
+    addEventListener4(el, binding);
+  },
+  updated(el, binding) {
+    if (elMapToHandlers3.has(el)) {
+      const handler2 = elMapToHandlers3.get(el);
+      handler2 && el.removeEventListener("click", handler2);
+      elMapToHandlers3.delete(el);
+    }
+    addEventListener4(el, binding);
+  }
+};
+var v_doubleClick_default = vDoubleClick;
+
+// src/directive/v-draggable/index.ts
+var vDraggable = {
+  mounted(el) {
+    let startX = 0;
+    let startY = 0;
+    let offsetXX = 0;
+    let offsetYY = 0;
+    let endX = 0;
+    let endY = 0;
+    el.style.cursor = "move";
+    const transformValue = window.getComputedStyle(el).transform.split(",").map((item) => Number.parseInt(item)).slice(4, 6);
+    if (transformValue.length > 1) {
+      endX = transformValue[0];
+      endY = transformValue[1];
+    }
+    const handler2 = (e) => {
+      const { clientX, clientY } = e;
+      const offsetX = clientX - startX + endX;
+      const offsetY = clientY - startY + endY;
+      offsetXX = offsetX;
+      offsetYY = offsetY;
+      el.style.transform = `translate(${offsetX}px, ${offsetY}px)`;
+    };
+    el.addEventListener("mousedown", (e) => {
+      const { clientX, clientY } = e;
+      startX = clientX;
+      startY = clientY;
+      window.addEventListener("mousemove", handler2);
+    });
+    el.addEventListener("mouseup", () => {
+      endX = offsetXX;
+      endY = offsetYY;
+      window.removeEventListener("mousemove", handler2);
+    });
+  }
+};
+var v_draggable_default = vDraggable;
+
+// src/directive/v-ellipsis/index.ts
+function handler(el, binding) {
+  el.style.overflow = "hidden";
+  el.style.textOverflow = "ellipsis";
+  const { arg } = binding;
+  if (arg) {
+    el.style.display = "-webkit-box";
+    el.style.webkitLineClamp = String(Number(arg));
+    el.style.webkitBoxOrient = "vertical";
+  } else {
+    el.style.whiteSpace = "nowrap";
+  }
+  el.setAttribute("title", el.textContent);
+}
+var vEllipsis = {
+  mounted(el, binding) {
+    handler(el, binding);
+  },
+  updated(el, binding) {
+    handler(el, binding);
+  }
+};
+var v_ellipsis_default = vEllipsis;
+
+// src/directive/v-emoji/index.ts
+var vEmoji = {
+  mounted(el, _binding, _vnode) {
+    const handleInput = (event) => {
+      const inputElement = event.target;
+      const value = inputElement.value;
+      const newValue = value.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]|\uD83C[\uDC00-\uDFFF]|\uD83D[\uDC00-\uDE4F\uDE80-\uDEFF]|[\u2600-\u27FF]/g, "");
+      if (newValue !== value) {
+        inputElement.value = newValue;
+        inputElement.dispatchEvent(new Event("input", { bubbles: true }));
+      }
+    };
+    el.addEventListener("input", handleInput);
+    el.$destroy = () => {
+      el.removeEventListener("input", handleInput);
+      delete el.$destroy;
+    };
+  },
+  unmounted(el) {
+    if (el.$destroy)
+      el.$destroy();
+  }
+};
+var v_emoji_default = vEmoji;
+var originalContent = "";
+var emptyState = "";
+function insertEmptyState(el, content, img) {
+  const image = img ? `<img src="${img}" style="width: 90%; border-radius: 5px;" />` : "";
+  emptyState = `
+    <div style="position: absolute; top: 0; left: 0; z-index: 9999; background: #fff; display: flex; justify-content: center; align-items: center; height: ${el.offsetHeight}px; width: ${el.offsetWidth}px; border-radius: 5px;">
+      <div style="display: flex; justify-content: center; align-items: center; flex-direction: column;">
+        ${image}
+        <div style="color: #000">${content}</div>
+      </div>
+    </div>
+  `;
+  el.innerHTML = emptyState;
+}
+var vEmpty = {
+  beforeMount(el, _binding) {
+    originalContent = el.innerHTML;
+  },
+  mounted(el, binding) {
+    el.style.position = el.style.position || "relative";
+    const { content = "\u6682\u65E0\u6570\u636E", img, visible } = binding.value;
+    const insertContent = () => {
+      el.innerHTML = originalContent;
+    };
+    const handleVisibilityChange = () => {
+      const isVisible = vue.isRef(visible) ? visible.value : visible;
+      if (isVisible)
+        insertEmptyState(el, content, img);
+      else
+        insertContent();
+    };
+    if (vue.isRef(visible))
+      vue.watch(visible, handleVisibilityChange);
+    handleVisibilityChange();
+  },
+  updated(el, binding) {
+    const { visible } = binding.value;
+    const isVisible = vue.isRef(visible) ? visible.value : visible;
+    if (!isVisible)
+      el.innerHTML = originalContent.trim();
+    else
+      el.innerHTML = emptyState;
+  }
+};
+var v_empty_default = vEmpty;
+
+// src/directive/v-flicker/index.ts
+var style = null;
+var animationStr = `
+@keyframes v-flicker {
+  0% {
+    opacity: 0;
+  }
+  50% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+  }
+}
+`;
+var vFlicker = {
+  mounted(el) {
+    if (style === null) {
+      style = document.createElement("style");
+      style.innerHTML = animationStr;
+      document.head.appendChild(style);
+    }
+    el.style.animation = "v-flicker 1s infinite";
+  }
+};
+var v_flicker_default = vFlicker;
+
+// src/directive/v-focus/index.ts
+var vFocus = {
+  mounted(el) {
+    el.focus && el.focus();
+  },
+  updated(el) {
+    el.focus && el.focus();
+  }
+};
+var v_focus_default = vFocus;
+
+// src/directive/v-highlight/index.ts
+var vHighlight = {
+  mounted(el, binding) {
+    const { arg } = binding;
+    el.style.backgroundColor = arg || "rgba(255, 255, 0, .8)";
+  }
+};
+var v_highlight_default = vHighlight;
+
+// src/directive/v-hover/index.ts
+var elMapToHandlers4 = /* @__PURE__ */ new WeakMap();
+function addEventListener5(el, binding) {
+  const { value } = binding;
+  if (isFunction_default(value)) {
+    el.addEventListener("mouseenter", value);
+    elMapToHandlers4.set(el, value);
+  }
+}
+var vHover = {
+  beforeUnmount(el) {
+    elMapToHandlers4.delete(el);
+  },
+  mounted(el, binding) {
+    addEventListener5(el, binding);
+  },
+  updated(el, binding) {
+    if (elMapToHandlers4.has(el)) {
+      const handler2 = elMapToHandlers4.get(el);
+      handler2 && el.removeEventListener("mouseenter", handler2);
+      elMapToHandlers4.delete(el);
+    }
+    addEventListener5(el, binding);
+  }
+};
+var v_hover_default = vHover;
+
+// src/directive/v-input/index.ts
+function trigger(el, type) {
+  const e = document.createEvent("HTMLEvents");
+  e.initEvent(type, true, true);
+  el.dispatchEvent(e);
+}
+var vInput = {
+  mounted(el, binding) {
+    const _type = binding.arg;
+    const restrict = binding.value || 10;
+    const types = ["number", "decimal", "customize"];
+    if (!_type || !types.includes(_type))
+      return console.log(`\u4F7F\u7528v-input\u6307\u4EE4\u9700\u8981\u9009\u62E9\u7279\u5B9A\u529F\u80FD\uFF1Av-input:type="restrictValue";  type = ${types.join("/")}.`);
+    el.$handler = (el2) => {
+      switch (_type) {
+        case "number":
+          el2.value = el2.value.replace(/[^\d]/, "");
+          break;
+        case "decimal":
+          el2.value = el2.value.replace(/[^\d.]/g, "");
+          el2.value = el2.value.replace(/\.{2,}/g, ".");
+          el2.value = el2.value.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");
+          const regexPattern = new RegExp(`^(-)*(\\d+)\\.(\\d{0,${restrict}}).*$`);
+          el2.value = el2.value.replace(regexPattern, "$1$2.$3");
+          !el2.value.includes(".") && el2.value !== "" && (el2.value = Number.parseFloat(el2.value));
+          el2.value.includes(".") && el2.value.length === 1 && (el2.value = "");
+          break;
+        case "customize":
+          const rule = restrict && new RegExp(restrict);
+          el2.value = el2.value.replace(rule, "");
+          break;
+      }
+      trigger(el2, "input");
+    };
+    el.$handler(el);
+  },
+  updated(el) {
+    el.$handler && el.$handler(el);
+  }
+};
+var v_input_default = vInput;
+
+// src/directive/v-lazyImg/index.ts
+var options;
+var callback = (entries) => {
+  entries.forEach((entry) => {
+    if (entry.isIntersecting) {
+      const img = entry.target;
+      if (img.src !== img.dataset.src)
+        img.src = img.dataset.src || "";
+    }
+  });
+};
+var observer = null;
+var observerHandler = (el, binding) => {
+  if (el.tagName !== "IMG")
+    return;
+  const { value } = binding;
+  el.setAttribute("data-src", String(value));
+  observer?.observe(el);
+};
+var vImgLazyLoad = {
+  beforeUnmount(el) {
+    if (observer)
+      observer.unobserve(el);
+  },
+  mounted(el, binding) {
+    if (observer === null)
+      observer = new IntersectionObserver(callback, options);
+    observerHandler(el, binding);
+  },
+  updated(el, binding) {
+    observerHandler(el, binding);
+  }
+};
+var v_lazyImg_default = vImgLazyLoad;
+
+// src/directive/v-loading/index.ts
+var elMapToMaskElement = /* @__PURE__ */ new WeakMap();
+var elMapToHasChangedPosition = /* @__PURE__ */ new WeakMap();
+function appendChild(el) {
+  const loadingWrapper = document.createElement("div");
+  const maskElement = document.createElement("div");
+  maskElement.style.position = "absolute";
+  maskElement.style.top = "0";
+  maskElement.style.left = "0";
+  maskElement.style.right = "0";
+  maskElement.style.bottom = "0";
+  maskElement.style.zIndex = "9999";
+  maskElement.style.backgroundColor = "rgba(0, 0, 0, 0.5)";
+  maskElement.style.pointerEvents = "none";
+  loadingWrapper.style.position = "absolute";
+  loadingWrapper.style.top = "50%";
+  loadingWrapper.style.left = "50%";
+  loadingWrapper.style.transform = "translate(-50%, -50%)";
+  loadingWrapper.style.pointerEvents = "none";
+  loadingWrapper.innerHTML = loadingSvg_default;
+  if (el.style.position === "static" || el.style.position === "") {
+    elMapToHasChangedPosition.set(el, true);
+    el.style.position = "relative";
+  }
+  maskElement.appendChild(loadingWrapper);
+  elMapToMaskElement.set(el, maskElement);
+  el.appendChild(maskElement);
+}
+var vLoading = {
+  beforeUnmount(el) {
+    elMapToMaskElement.delete(el);
+    elMapToHasChangedPosition.delete(el);
+  },
+  mounted(el, binding) {
+    const { value } = binding;
+    if (!isBoolean(value))
+      return;
+    if (!value)
+      return;
+    appendChild(el);
+  },
+  updated(el, binding) {
+    const { value } = binding;
+    const hasMaskElement = elMapToMaskElement.has(el);
+    const hasChangedPosition = elMapToHasChangedPosition.has(el);
+    if (value && hasMaskElement)
+      return;
+    if (value && !hasMaskElement)
+      appendChild(el);
+    if ((!value || !isBoolean(value)) && !hasMaskElement)
+      return;
+    if ((!value || !isBoolean(value)) && hasMaskElement) {
+      if (hasChangedPosition) {
+        el.style.position = "static";
+        elMapToHasChangedPosition.delete(el);
+      }
+      const maskElement = elMapToMaskElement.get(el);
+      maskElement && el.removeChild(maskElement);
+      elMapToMaskElement.delete(el);
+    }
+  }
+};
+var v_loading_default = vLoading;
+
+// src/directive/v-longpress/index.ts
+var elMapToMouseDownHandlers = /* @__PURE__ */ new WeakMap();
+var elMapToMouseUpHandlers = /* @__PURE__ */ new WeakMap();
+function addEventListener6(el, binding) {
+  const { arg, value } = binding;
+  if (!isFunction_default(value))
+    return;
+  let timer;
+  const pressHandler = () => {
+    timer = window.setTimeout(value, arg ? Number(arg) : 300);
+  };
+  const clearTimeoutHandler = () => {
+    clearTimeout(timer);
+  };
+  el.addEventListener("mousedown", pressHandler);
+  el.addEventListener("mouseup", clearTimeoutHandler);
+  elMapToMouseDownHandlers.set(el, pressHandler);
+  elMapToMouseUpHandlers.set(el, clearTimeoutHandler);
+}
+var vLongPress = {
+  beforeUnmount(el) {
+    elMapToMouseDownHandlers.delete(el);
+    elMapToMouseUpHandlers.delete(el);
+  },
+  mounted(el, binding) {
+    addEventListener6(el, binding);
+  },
+  updated(el, binding) {
+    if (elMapToMouseDownHandlers.has(el)) {
+      const pressHandler = elMapToMouseDownHandlers.get(el);
+      pressHandler && el.removeEventListener("mousedown", pressHandler);
+      elMapToMouseDownHandlers.delete(el);
+    }
+    if (elMapToMouseUpHandlers.has(el)) {
+      const pressHandler = elMapToMouseDownHandlers.get(el);
+      pressHandler && el.removeEventListener("mouseup", pressHandler);
+      elMapToMouseUpHandlers.delete(el);
+    }
+    addEventListener6(el, binding);
+  }
+};
+var v_longpress_default = vLongPress;
+
+// src/directive/v-money/index.ts
+function setInnerHTML(el, binding) {
+  const { value } = binding;
+  const parts = String(value).split(".");
+  const moneyReverse = Array.from(parts[0]).reverse();
+  const moneyArray = [];
+  for (let i = 0; i < moneyReverse.length; i++) {
+    if (i % 3 === 0 && i !== 0)
+      moneyArray.push(",");
+    moneyArray.push(moneyReverse[i]);
+  }
+  const moneyString = moneyArray.reverse().join("");
+  if (parts.length > 1)
+    el.innerHTML = `${moneyString}.${parts[1]}`;
+  else
+    el.innerHTML = moneyString;
+}
+var vMoney = {
+  mounted(el, binding) {
+    setInnerHTML(el, binding);
+  },
+  updated(el, binding) {
+    setInnerHTML(el, binding);
+  }
+};
+var v_money_default = vMoney;
+
+// src/directive/v-onOnce/index.ts
+var elMapToHandlers5 = /* @__PURE__ */ new WeakMap();
+var elMapToEventName2 = /* @__PURE__ */ new WeakMap();
+function addEventListener7(el, binding) {
+  const { arg, value } = binding;
+  if (!isFunction_default(value))
+    return;
+  const eventName = arg || "click";
+  const handler2 = () => {
+    value();
+    el.removeEventListener(eventName, handler2);
+  };
+  elMapToHandlers5.set(el, handler2);
+  elMapToEventName2.set(el, eventName);
+  el.addEventListener(eventName, handler2);
+}
+var vOnOnce = {
+  beforeUnmount(el) {
+    elMapToHandlers5.delete(el);
+    elMapToEventName2.delete(el);
+  },
+  mounted(el, binding) {
+    addEventListener7(el, binding);
+  },
+  updated(el, binding) {
+    if (elMapToHandlers5.has(el)) {
+      const eventName = elMapToEventName2.get(el);
+      const handler2 = elMapToHandlers5.get(el);
+      handler2 && eventName && el.removeEventListener(eventName, handler2);
+      elMapToHandlers5.delete(el);
+      elMapToEventName2.delete(el);
+    }
+    addEventListener7(el, binding);
+  }
+};
+var v_onOnce_default = vOnOnce;
+
+// src/directive/v-permission/index.ts
+var vPermission = {
+  mounted(el, binding) {
+    let permission = "add;del";
+    let permissionList = [];
+    permissionList = permission.split(";");
+    let inValue;
+    if (typeof binding.value === "string") {
+      inValue = binding.value;
+    } else if (Array.isArray(binding.value)) {
+      inValue = binding.value.join(";");
+    } else {
+      console.log("\u6570\u636E\u683C\u5F0F\u4E0D\u6B63\u786E\uFF0C\u8BF7\u8F93\u5165\u5B57\u7B26\u4E32\uFF08\u4EE5\u5206\u53F7\u5206\u9694\uFF09\u6216\u6570\u7EC4");
+    }
+    let passText = inValue;
+    let passTextArr = [];
+    if (!passText)
+      passText = "";
+    passTextArr = passText.split(";");
+    let flag = false;
+    for (let i = 0; i < passTextArr.length; i++) {
+      if (permissionList.includes(passTextArr[i])) {
+        flag = true;
+        break;
+      }
+    }
+    if (!flag)
+      el.parentNode && el.parentNode.removeChild(el);
+  }
+};
+var v_permission_default = vPermission;
+
+// src/directive/v-resize/index.ts
+function createYElement(type) {
+  const Element = document.createElement("div");
+  Element.style.position = "absolute";
+  if (type === "top")
+    Element.style.top = "0";
+  else
+    Element.style.bottom = "0";
+  Element.style.left = "0";
+  Element.style.right = "0";
+  Element.style.height = "5px";
+  Element.style.backgroundColor = "#1890ff";
+  Element.style.zIndex = "1";
+  Element.style.cursor = "ns-resize";
+  Element.style.display = "none";
+  return Element;
+}
+function createXElement(type) {
+  const Element = document.createElement("div");
+  Element.style.position = "absolute";
+  Element.style.top = "5px";
+  if (type === "left")
+    Element.style.left = "0";
+  else
+    Element.style.right = "0";
+  Element.style.bottom = "5px";
+  Element.style.width = "5px";
+  Element.style.backgroundColor = "#1890ff";
+  Element.style.zIndex = "1";
+  Element.style.cursor = "ew-resize";
+  Element.style.display = "none";
+  Element.style.transition = "all 0.3s";
+  return Element;
+}
+var vResize = {
+  mounted(el) {
+    const position = el.style.position;
+    if (position === "static" || position === "")
+      el.style.position = "relative";
+    const topElement = createYElement("top");
+    const bottomElement = createYElement("bottom");
+    const leftElement = createXElement("left");
+    const rightElement = createXElement("right");
+    const Y = [topElement, bottomElement];
+    const X = [leftElement, rightElement];
+    const all = [...Y, ...X];
+    Y.forEach((element) => {
+      element.addEventListener("mousedown", (e) => {
+        e.stopPropagation();
+        const startY = e.clientY;
+        const style2 = window.getComputedStyle(el);
+        const height = style2.height;
+        const windowMouseMoveHandler = (e2) => {
+          const offsetY = e2.clientY - startY;
+          el.style.height = `${Number.parseInt(height, 10) + offsetY}px`;
+        };
+        const windowMouseUpHandler = () => {
+          window.removeEventListener("mousemove", windowMouseMoveHandler);
+          window.removeEventListener("mouseup", windowMouseUpHandler);
+        };
+        window.addEventListener("mousemove", windowMouseMoveHandler);
+        window.addEventListener("mouseup", windowMouseUpHandler);
+      });
+    });
+    X.forEach((element) => {
+      element.addEventListener("mousedown", (e) => {
+        e.stopPropagation();
+        const startX = e.clientX;
+        const style2 = window.getComputedStyle(el);
+        const width = style2.width;
+        const windowMouseMoveHandler = (e2) => {
+          const offsetX = e2.clientX - startX;
+          el.style.width = `${Number.parseInt(width, 10) + offsetX}px`;
+        };
+        const windowMouseUpHandler = () => {
+          window.removeEventListener("mousemove", windowMouseMoveHandler);
+          window.removeEventListener("mouseup", windowMouseUpHandler);
+        };
+        window.addEventListener("mousemove", windowMouseMoveHandler);
+        window.addEventListener("mouseup", windowMouseUpHandler);
+      });
+    });
+    el.addEventListener("click", () => {
+      all.forEach((element) => {
+        element.style.display = "block";
+      });
+    });
+    const handler2 = (e) => {
+      if (el.contains(e.target))
+        return;
+      all.forEach((element) => {
+        element.style.display = "none";
+      });
+    };
+    window.addEventListener("click", handler2);
+    el.appendChild(topElement);
+    el.appendChild(bottomElement);
+    el.appendChild(leftElement);
+    el.appendChild(rightElement);
+  }
+};
+var v_resize_default = vResize;
+
+// src/directive/v-ripple/index.ts
+var Ripple = {
+  mounted(el, binding) {
+    const props = {
+      event: "mousedown",
+      transition: 600
+    };
+    setProps(Object.keys(binding.modifiers), props);
+    el.addEventListener(props.event, (event) => {
+      rippler(event, el, binding.value);
+    });
+    const bg = binding.value || Ripple.color || "rgba(0, 0, 0, 0.35)";
+    const zIndex = Ripple.zIndex || "9999";
+    function rippler(event, el2) {
+      const target = el2;
+      const targetBorder = Number.parseInt(getComputedStyle(target).borderWidth.replace("px", ""));
+      const rect = target.getBoundingClientRect();
+      const left = rect.left;
+      const top = rect.top;
+      const width = target.offsetWidth;
+      const height = target.offsetHeight;
+      const dx = event.clientX - left;
+      const dy = event.clientY - top;
+      const maxX = Math.max(dx, width - dx);
+      const maxY = Math.max(dy, height - dy);
+      const style2 = window.getComputedStyle(target);
+      const radius = Math.sqrt(maxX * maxX + maxY * maxY);
+      const border = targetBorder > 0 ? targetBorder : 0;
+      const ripple = document.createElement("div");
+      const rippleContainer = document.createElement("div");
+      rippleContainer.className = "ripple-container";
+      ripple.className = "ripple";
+      ripple.style.marginTop = "0px";
+      ripple.style.marginLeft = "0px";
+      ripple.style.width = "1px";
+      ripple.style.height = "1px";
+      ripple.style.transition = `all ${props.transition}ms cubic-bezier(0.4, 0, 0.2, 1)`;
+      ripple.style.borderRadius = "50%";
+      ripple.style.pointerEvents = "none";
+      ripple.style.position = "relative";
+      ripple.style.zIndex = zIndex;
+      ripple.style.backgroundColor = bg;
+      rippleContainer.style.position = "absolute";
+      rippleContainer.style.left = `${0 - border}px`;
+      rippleContainer.style.top = `${0 - border}px`;
+      rippleContainer.style.height = "0";
+      rippleContainer.style.width = "0";
+      rippleContainer.style.pointerEvents = "none";
+      rippleContainer.style.overflow = "hidden";
+      const storedTargetPosition = target.style.position.length > 0 ? target.style.position : getComputedStyle(target).position;
+      if (storedTargetPosition !== "relative")
+        target.style.position = "relative";
+      rippleContainer.appendChild(ripple);
+      target.appendChild(rippleContainer);
+      ripple.style.marginLeft = `${dx}px`;
+      ripple.style.marginTop = `${dy}px`;
+      rippleContainer.style.width = `${width}px`;
+      rippleContainer.style.height = `${height}px`;
+      rippleContainer.style.borderTopLeftRadius = style2.borderTopLeftRadius;
+      rippleContainer.style.borderTopRightRadius = style2.borderTopRightRadius;
+      rippleContainer.style.borderBottomLeftRadius = style2.borderBottomLeftRadius;
+      rippleContainer.style.borderBottomRightRadius = style2.borderBottomRightRadius;
+      rippleContainer.style.direction = "ltr";
+      setTimeout(() => {
+        ripple.style.width = `${radius * 2}px`;
+        ripple.style.height = `${radius * 2}px`;
+        ripple.style.marginLeft = `${dx - radius}px`;
+        ripple.style.marginTop = `${dy - radius}px`;
+      }, 0);
+      function clearRipple() {
+        setTimeout(() => {
+          ripple.style.backgroundColor = "rgba(0, 0, 0, 0)";
+        }, 250);
+        setTimeout(() => {
+          rippleContainer.parentNode.removeChild(rippleContainer);
+        }, 850);
+        el2.removeEventListener("mouseup", clearRipple, false);
+        setTimeout(() => {
+          let clearPosition = true;
+          for (let i = 0; i < target.childNodes.length; i++) {
+            if (target.childNodes[i].className === "ripple-container")
+              clearPosition = false;
+          }
+          if (clearPosition) {
+            if (storedTargetPosition !== "static")
+              target.style.position = storedTargetPosition;
+            else
+              target.style.position = "";
+          }
+        }, props.transition + 250);
+      }
+      if (event.type === "mousedown")
+        el2.addEventListener("mouseup", clearRipple, false);
+      else
+        clearRipple();
+    }
+  }
+};
+function setProps(modifiers, props) {
+  modifiers.forEach((item) => {
+    if (Number.isNaN(Number(item)))
+      props.event = item;
+    else
+      props.transition = item;
+  });
+}
+var v_ripple_default = Ripple;
+
+// src/directive/v-slideIn/index.ts
+var DISTANCE = 100;
+var ANIMATIONTIME = 500;
+var distance = null;
+var animationtime = null;
+var map = /* @__PURE__ */ new WeakMap();
+function isBelowViewport(el) {
+  const rect = el.getBoundingClientRect();
+  return rect.top - (distance || DISTANCE) > window.innerHeight;
+}
+function handleScroll() {
+  const elements = document.querySelectorAll("[v-slideIn]");
+  elements.forEach((el) => {
+    if (isBelowViewport(el))
+      return;
+    const animation = map.get(el);
+    if (animation && !el.hasAttribute("v-slideIn-played")) {
+      animation.play();
+      el.removeAttribute("v-slideIn");
+      el.setAttribute("v-slideIn-played", "");
+    }
+  });
+}
+var vSlideIn = {
+  mounted(el, binding) {
+    if (binding.value) {
+      distance = binding.value.px;
+      animationtime = binding.value.time;
+    }
+    if (!isBelowViewport(el))
+      return;
+    const animation = el.animate(
+      [
+        {
+          opacity: 0,
+          transform: `translateY(${distance || DISTANCE}px)`
+        },
+        {
+          opacity: 1,
+          transform: `translateY(0px)`
+        }
+      ],
+      {
+        duration: animationtime || ANIMATIONTIME,
+        easing: "ease-in-out",
+        fill: "forwards"
+      }
+    );
+    animation.pause();
+    map.set(el, animation);
+    el.setAttribute("v-slideIn", "");
+    window.addEventListener("scroll", handleScroll);
+  },
+  unmounted(el) {
+    map.delete(el);
+    window.removeEventListener("scroll", handleScroll);
+  }
+};
+var v_slideIn_default = vSlideIn;
+
+// src/directive/v-throttle/index.ts
+var elMapToHandlers6 = /* @__PURE__ */ new WeakMap();
+var elMapToEventName3 = /* @__PURE__ */ new WeakMap();
+function addEventListener8(el, binding) {
+  const { arg, value } = binding;
+  if (!isFunction_default(value))
+    return;
+  const delay = arg ? Number(arg.split("-")[1]) : 300;
+  const eventName = arg ? arg.split("-")[0] : "click";
+  let lastExecTime = 0;
+  const handler2 = () => {
+    const currentTime = Date.now();
+    if (currentTime - lastExecTime < delay)
+      return;
+    lastExecTime = currentTime;
+    value();
+  };
+  const existingHandler = elMapToHandlers6.get(el);
+  if (existingHandler)
+    el.removeEventListener(eventName, existingHandler);
+  elMapToHandlers6.set(el, handler2);
+  elMapToEventName3.set(el, eventName);
+  el.addEventListener(eventName, handler2);
+}
+var vThrottle = {
+  beforeUnmount(el) {
+    if (elMapToHandlers6.has(el)) {
+      const eventName = elMapToEventName3.get(el);
+      const handler2 = elMapToHandlers6.get(el);
+      handler2 && eventName && el.removeEventListener(eventName, handler2);
+      elMapToHandlers6.delete(el);
+      elMapToEventName3.delete(el);
+    }
+  },
+  mounted(el, binding) {
+    addEventListener8(el, binding);
+  },
+  updated(el, binding) {
+    if (elMapToHandlers6.has(el)) {
+      const eventName = elMapToEventName3.get(el);
+      const handler2 = elMapToHandlers6.get(el);
+      handler2 && eventName && el.removeEventListener(eventName, handler2);
+      elMapToHandlers6.delete(el);
+      elMapToEventName3.delete(el);
+    }
+    addEventListener8(el, binding);
+  }
+};
+var v_throttle_default = vThrottle;
+
+// src/directive/v-waterMarker/index.ts
+var addWaterMarker = (str, parentNode, font, textColor) => {
+  const can = document.createElement("canvas");
+  parentNode.appendChild(can);
+  can.width = 200;
+  can.height = 150;
+  can.style.display = "none";
+  const cans = can.getContext("2d");
+  cans.rotate(-20 * Math.PI / 180);
+  cans.font = font || "16px Microsoft JhengHei";
+  cans.fillStyle = textColor || "rgba(180, 180, 180, 0.3)";
+  cans.textAlign = "left";
+  cans.textBaseline = "Middle";
+  cans.fillText(str, can.width / 10, can.height / 2);
+  parentNode.style.backgroundImage = `url(${can.toDataURL("image/png")})`;
+};
+var waterMarker = {
+  mounted(el, binding) {
+    addWaterMarker(binding.value.text, el, binding.value.font, binding.value.textColor);
+  }
+};
+var v_waterMarker_default = waterMarker;
+
+// src/index.ts
+var directives = {
+  backtop: v_backtop_default,
+  clickOutside: v_clickOutside_default,
+  copy: v_copy_default,
+  debounce: v_debounce_default,
+  doubleClick: v_doubleClick_default,
+  draggable: v_draggable_default,
+  ellipsis: v_ellipsis_default,
+  emoji: v_emoji_default,
+  empty: v_empty_default,
+  flicker: v_flicker_default,
+  focus: v_focus_default,
+  highlight: v_highlight_default,
+  hover: v_hover_default,
+  input: v_input_default,
+  lazyImg: v_lazyImg_default,
+  loading: v_loading_default,
+  longpress: v_longpress_default,
+  money: v_money_default,
+  onOnce: v_onOnce_default,
+  permission: v_permission_default,
+  resize: v_resize_default,
+  ripple: v_ripple_default,
+  slideIn: v_slideIn_default,
+  throttle: v_throttle_default,
+  waterMarker: v_waterMarker_default
+};
+var src_default = {
+  install(app) {
+    Object.keys(directives).forEach((key) => {
+      app.directive(key, directives[key]);
+    });
+  }
+};
+
+exports.default = src_default;
+exports.vBacktop = v_backtop_default;
+exports.vClickOutside = v_clickOutside_default;
+exports.vCopy = v_copy_default;
+exports.vDebounce = v_debounce_default;
+exports.vDoubleClick = v_doubleClick_default;
+exports.vDraggable = v_draggable_default;
+exports.vEllipsis = v_ellipsis_default;
+exports.vEmoji = v_emoji_default;
+exports.vEmpty = v_empty_default;
+exports.vFlicker = v_flicker_default;
+exports.vFocus = v_focus_default;
+exports.vHighlight = v_highlight_default;
+exports.vHover = v_hover_default;
+exports.vInput = v_input_default;
+exports.vLazyImg = v_lazyImg_default;
+exports.vLoading = v_loading_default;
+exports.vLongpress = v_longpress_default;
+exports.vMoney = v_money_default;
+exports.vOnOnce = v_onOnce_default;
+exports.vPermission = v_permission_default;
+exports.vResize = v_resize_default;
+exports.vRipple = v_ripple_default;
+exports.vSlideIn = v_slideIn_default;
+exports.vThrottle = v_throttle_default;
+exports.vWaterMarker = v_waterMarker_default;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map