giime 1.1.5 → 1.1.6

package/lib/utils/src/watermark/index.js

@@ -0,0 +1,777 @@
+'use strict';
+
+var vue = require('vue');
+var core = require('@vueuse/core');
+var Cookies = require('js-cookie');
+var index$1 = require('../../../hooks/store/useLogin/index.js');
+var index = require('../../../hooks/store/userCenter/useCurrentUser/index.js');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const GIIME_WATERMARK_GLOBAL_SYMBOL = Symbol.for("__giime.watermark.singleton__");
+const WATERMARK_MESSAGE_TYPES = {
+  PING: "giime-watermark:ping",
+  PONG: "giime-watermark:pong",
+  SUPPRESS: "giime-watermark:suppress"
+};
+const WATERMARK_DOM_CONSTANTS = {
+  CONTAINER_ID: "__giime_watermark__",
+  CONTAINER_CLASS: "giime-watermark-container",
+  LEGACY_ITEM_CLASS: "mask_div",
+  ROOT_ATTR: "data-giime-watermark"
+};
+const sanitizeUserId = (raw) => {
+  if (raw === void 0 || raw === null) {
+    return "";
+  }
+  const str = String(raw).trim();
+  if (!str || str === "undefined" || str === "null" || str === "NaN") {
+    return "";
+  }
+  return str;
+};
+let storeVerifiedUserId = "";
+const resolveWatermarkUserId = (config) => {
+  if (config?.getUserId) {
+    try {
+      const customId = sanitizeUserId(config.getUserId());
+      if (customId) {
+        return customId;
+      }
+    } catch {
+    }
+  }
+  const explicitId = sanitizeUserId(config?.userId);
+  if (explicitId) {
+    return explicitId;
+  }
+  if (storeVerifiedUserId) {
+    return storeVerifiedUserId;
+  }
+  return sanitizeUserId(Cookies.get("sso_user_id"));
+};
+const formatWatermarkDate = (date = /* @__PURE__ */ new Date()) => {
+  const year = date.getFullYear();
+  const monthNum = date.getMonth() + 1;
+  const dayNum = date.getDate();
+  const month = monthNum < 10 ? `0${monthNum}` : String(monthNum);
+  const day = dayNum < 10 ? `0${dayNum}` : String(dayNum);
+  return `${year}\u5E74${month}\u6708${day}\u65E5`;
+};
+const buildWatermarkText = (config, resolvedUserId, dateStr = formatWatermarkDate()) => {
+  const userId = resolvedUserId !== void 0 ? sanitizeUserId(resolvedUserId) : resolveWatermarkUserId(config);
+  const prefix = config.prefix || "\u5409\u5BA2\u5370";
+  if (typeof config.text === "function") {
+    return config.text({ userId, date: dateStr, prefix });
+  }
+  if (typeof config.text === "string" && config.text.trim()) {
+    return config.text.trim();
+  }
+  return userId ? `${prefix}-${userId}-${dateStr}` : `${prefix}-${dateStr}`;
+};
+const isInIframe = (win) => {
+  const targetWin = win ?? (typeof window !== "undefined" ? window : void 0);
+  if (!targetWin) {
+    return false;
+  }
+  try {
+    return targetWin.self !== targetWin.top;
+  } catch {
+    return true;
+  }
+};
+const inspectSameOriginAncestors = (win) => {
+  const targetWin = win ?? (typeof window !== "undefined" ? window : void 0);
+  if (!targetWin || !isInIframe(targetWin)) {
+    return { hasWatermark: false, allAncestorsAccessible: true };
+  }
+  let current = targetWin;
+  let depth = 0;
+  let allAncestorsAccessible = true;
+  while (current && depth < 15) {
+    depth++;
+    let parentWin = null;
+    try {
+      parentWin = current.parent;
+    } catch {
+      allAncestorsAccessible = false;
+      break;
+    }
+    if (!parentWin || parentWin === current) {
+      break;
+    }
+    try {
+      const anyParent = parentWin;
+      if (anyParent.__GIIME_WATERMARK_ACTIVE__ === true) {
+        return { hasWatermark: true, allAncestorsAccessible };
+      }
+      const parentDoc = parentWin.document;
+      if (parentDoc) {
+        if (parentDoc.getElementById(WATERMARK_DOM_CONSTANTS.CONTAINER_ID) || parentDoc.documentElement?.getAttribute(WATERMARK_DOM_CONSTANTS.ROOT_ATTR) === "active" || parentDoc.querySelector(`.${WATERMARK_DOM_CONSTANTS.LEGACY_ITEM_CLASS}`)) {
+          return { hasWatermark: true, allAncestorsAccessible };
+        }
+      } else {
+        allAncestorsAccessible = false;
+      }
+    } catch {
+      allAncestorsAccessible = false;
+    }
+    try {
+      if (parentWin === targetWin.top) {
+        break;
+      }
+    } catch {
+      allAncestorsAccessible = false;
+      break;
+    }
+    current = parentWin;
+  }
+  return { hasWatermark: false, allAncestorsAccessible };
+};
+const hasSameOriginAncestorWatermark = (win) => {
+  return inspectSameOriginAncestors(win).hasWatermark;
+};
+const shouldRenderWatermark = (strategy = "ancestor-detect", win) => {
+  const targetWin = win ?? (typeof window !== "undefined" ? window : void 0);
+  if (!targetWin || typeof document === "undefined") {
+    return { shouldRender: false, inIframe: false, needsAsyncDetect: false, reason: "ssr" };
+  }
+  if (strategy === "never") {
+    return { shouldRender: false, inIframe: isInIframe(targetWin), needsAsyncDetect: false, reason: "disabled" };
+  }
+  const inIframe = isInIframe(targetWin);
+  if (strategy === "always") {
+    return {
+      shouldRender: true,
+      inIframe,
+      needsAsyncDetect: false,
+      reason: inIframe ? "rendered-forced" : "rendered-top"
+    };
+  }
+  if (!inIframe) {
+    return {
+      shouldRender: true,
+      inIframe: false,
+      needsAsyncDetect: false,
+      reason: "rendered-top"
+    };
+  }
+  if (strategy === "top-only") {
+    return {
+      shouldRender: false,
+      inIframe: true,
+      needsAsyncDetect: false,
+      reason: "suppressed-in-iframe"
+    };
+  }
+  const { hasWatermark, allAncestorsAccessible } = inspectSameOriginAncestors(targetWin);
+  if (hasWatermark) {
+    return {
+      shouldRender: false,
+      inIframe: true,
+      needsAsyncDetect: false,
+      reason: "suppressed-by-ancestor"
+    };
+  }
+  return {
+    shouldRender: true,
+    inIframe: true,
+    needsAsyncDetect: !allAncestorsAccessible,
+    reason: "rendered-fallback"
+  };
+};
+const broadcastSuppressToChildFrames = (text) => {
+  if (typeof document === "undefined") {
+    return;
+  }
+  try {
+    const iframes = document.querySelectorAll("iframe");
+    const message = {
+      type: WATERMARK_MESSAGE_TYPES.SUPPRESS,
+      active: true,
+      text
+    };
+    iframes.forEach((iframe) => {
+      try {
+        iframe.contentWindow?.postMessage(message, "*");
+      } catch {
+      }
+    });
+  } catch {
+  }
+};
+const detectAncestorWatermarkAsync = (timeoutMs = 120) => {
+  if (typeof window === "undefined" || !isInIframe(window)) {
+    return Promise.resolve(false);
+  }
+  const { hasWatermark, allAncestorsAccessible } = inspectSameOriginAncestors(window);
+  if (hasWatermark) {
+    return Promise.resolve(true);
+  }
+  if (allAncestorsAccessible) {
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (hasAncestor) => {
+      if (settled) return;
+      settled = true;
+      window.removeEventListener("message", onMessage);
+      clearTimeout(timer);
+      resolve(hasAncestor);
+    };
+    const onMessage = (event) => {
+      const data = event?.data;
+      if (data && typeof data === "object" && (data.type === WATERMARK_MESSAGE_TYPES.PONG || data.type === WATERMARK_MESSAGE_TYPES.SUPPRESS) && data.active !== false) {
+        finish(true);
+      }
+    };
+    window.addEventListener("message", onMessage);
+    const timer = setTimeout(() => finish(false), Math.max(20, timeoutMs));
+    const pingPayload = { type: WATERMARK_MESSAGE_TYPES.PING, timestamp: Date.now() };
+    try {
+      window.parent?.postMessage(pingPayload, "*");
+    } catch {
+    }
+    try {
+      if (window.top && window.top !== window.parent) {
+        window.top.postMessage(pingPayload, "*");
+      }
+    } catch {
+    }
+  });
+};
+const normalizeWatermarkOptions = (options = {}, base) => {
+  return {
+    enabled: options.enabled ?? base?.enabled ?? true,
+    iframeStrategy: options.iframeStrategy ?? base?.iframeStrategy ?? "ancestor-detect",
+    detectTimeoutMs: options.detectTimeoutMs ?? base?.detectTimeoutMs ?? 120,
+    prefix: options.prefix ?? base?.prefix ?? "\u5409\u5BA2\u5370",
+    userId: options.userId !== void 0 ? options.userId : base?.userId,
+    getUserId: options.getUserId ?? base?.getUserId,
+    text: options.text ?? base?.text,
+    x: options.x ?? base?.x ?? 20,
+    y: options.y ?? base?.y ?? 20,
+    rows: options.rows ?? base?.rows ?? 20,
+    cols: options.cols ?? base?.cols ?? 20,
+    xSpace: options.xSpace ?? base?.xSpace ?? 100,
+    ySpace: options.ySpace ?? base?.ySpace ?? 50,
+    color: options.color ?? base?.color ?? "#aaa",
+    alpha: options.alpha ?? base?.alpha ?? 0.1,
+    fontSize: options.fontSize ?? base?.fontSize ?? "15px",
+    font: options.font ?? base?.font ?? "\u5FAE\u8F6F\u96C5\u9ED1",
+    width: options.width ?? base?.width ?? 210,
+    height: options.height ?? base?.height ?? 80,
+    angle: options.angle ?? base?.angle ?? 20,
+    zIndex: options.zIndex ?? base?.zIndex ?? 9999,
+    antiTamper: options.antiTamper ?? base?.antiTamper ?? true,
+    watchResize: options.watchResize ?? base?.watchResize ?? true,
+    cleanLegacyMask: options.cleanLegacyMask ?? base?.cleanLegacyMask ?? true
+  };
+};
+const calculateWatermarkGrid = (config, viewportWidth, viewportHeight) => {
+  const cutWidth = viewportWidth * 0.015;
+  const pageWidth = Math.max(320, viewportWidth - cutWidth);
+  const pageHeight = Math.max(viewportHeight + 450, window.innerHeight ? window.innerHeight - 40 : 720);
+  let cols = config.cols;
+  let xSpace = config.xSpace;
+  let rows = config.rows;
+  let ySpace = config.ySpace;
+  const totalConfigWidth = Math.trunc(config.x + config.width * cols + xSpace * (cols - 1));
+  if (cols === 0 || totalConfigWidth > pageWidth) {
+    cols = Math.max(1, Math.trunc((pageWidth - config.x + xSpace) / (config.width + xSpace)));
+    xSpace = cols > 1 ? Math.max(0, Math.trunc((pageWidth - config.x - config.width * cols) / (cols - 1))) : 0;
+  }
+  const totalConfigHeight = Math.trunc(config.y + config.height * rows + ySpace * (rows - 1));
+  if (rows === 0 || totalConfigHeight > pageHeight) {
+    rows = Math.max(1, Math.trunc((ySpace + pageHeight - config.y) / (config.height + ySpace)));
+    ySpace = rows > 1 ? Math.max(0, Math.trunc((pageHeight - config.y - config.height * rows) / (rows - 1))) : 0;
+  }
+  return { cols, rows, xSpace, ySpace };
+};
+const removeLegacyBodyMasks = () => {
+  if (typeof document === "undefined" || !document.body) {
+    return;
+  }
+  const legacyNodes = document.body.querySelectorAll(`:scope > .${WATERMARK_DOM_CONSTANTS.LEGACY_ITEM_CLASS}`);
+  legacyNodes.forEach((node) => {
+    node.parentNode?.removeChild(node);
+  });
+};
+class GiimeWatermark {
+  constructor(options) {
+    __publicField(this, "config");
+    __publicField(this, "state");
+    __publicField(this, "containerEl", null);
+    __publicField(this, "mutationObserver", null);
+    __publicField(this, "resizeTimer", null);
+    __publicField(this, "isRenderingInternal", false);
+    __publicField(this, "listenersAttached", false);
+    __publicField(this, "domReadyListenerAttached", false);
+    __publicField(this, "handleWindowResize", () => {
+      if (!this.state.active || !this.config.watchResize) {
+        return;
+      }
+      if (this.resizeTimer) {
+        clearTimeout(this.resizeTimer);
+      }
+      this.resizeTimer = setTimeout(() => {
+        this.render();
+      }, 150);
+    });
+    __publicField(this, "handleWindowMessage", (event) => {
+      const data = event?.data;
+      if (!data || typeof data !== "object") {
+        return;
+      }
+      if (data.type === WATERMARK_MESSAGE_TYPES.PING && this.state.active) {
+        try {
+          const sourceWin = event.source;
+          sourceWin?.postMessage(
+            {
+              type: WATERMARK_MESSAGE_TYPES.PONG,
+              active: true,
+              text: this.state.text
+            },
+            "*"
+          );
+        } catch {
+        }
+        return;
+      }
+      if ((data.type === WATERMARK_MESSAGE_TYPES.SUPPRESS || data.type === WATERMARK_MESSAGE_TYPES.PONG) && data.active !== false && isInIframe() && this.config.iframeStrategy !== "always") {
+        this.suppressWatermark("suppressed-by-ancestor");
+      }
+    });
+    this.config = normalizeWatermarkOptions(options);
+    this.state = {
+      inIframe: isInIframe(),
+      active: false,
+      reason: "disabled",
+      text: "",
+      userId: "",
+      rows: 0,
+      cols: 0
+    };
+    this.bootstrap();
+  }
+  bootstrap() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      this.state.reason = "ssr";
+      return;
+    }
+    this.attachGlobalListeners();
+    if (!this.config.enabled) {
+      this.suppressWatermark("disabled");
+      return;
+    }
+    const decision = shouldRenderWatermark(this.config.iframeStrategy);
+    this.state.inIframe = decision.inIframe;
+    if (!decision.shouldRender) {
+      this.suppressWatermark(
+        decision.reason
+      );
+      return;
+    }
+    if (this.config.iframeStrategy === "ancestor-detect" && decision.inIframe && decision.needsAsyncDetect) {
+      detectAncestorWatermarkAsync(this.config.detectTimeoutMs).then((hasAncestor) => {
+        if (!this.config.enabled) {
+          return;
+        }
+        if (hasAncestor) {
+          this.suppressWatermark("suppressed-by-ancestor");
+        } else {
+          this.activateWatermark("rendered-fallback");
+        }
+      });
+      return;
+    }
+    this.activateWatermark(decision.reason);
+  }
+  activateWatermark(reason) {
+    this.state.reason = reason;
+    this.state.active = true;
+    if (typeof window !== "undefined") {
+      window.__GIIME_WATERMARK_ACTIVE__ = true;
+    }
+    if (typeof document !== "undefined" && document.documentElement) {
+      document.documentElement.setAttribute(WATERMARK_DOM_CONSTANTS.ROOT_ATTR, "active");
+    }
+    if (typeof document !== "undefined" && !document.body) {
+      if (!this.domReadyListenerAttached) {
+        this.domReadyListenerAttached = true;
+        window.addEventListener(
+          "DOMContentLoaded",
+          () => {
+            this.domReadyListenerAttached = false;
+            if (this.state.active) {
+              this.render();
+            }
+          },
+          { once: true }
+        );
+      }
+      return;
+    }
+    this.render();
+  }
+  suppressWatermark(reason) {
+    this.state.active = false;
+    this.state.reason = reason;
+    this.state.rows = 0;
+    this.state.cols = 0;
+    this.stopMutationObserver();
+    if (typeof window !== "undefined") {
+      window.__GIIME_WATERMARK_ACTIVE__ = false;
+    }
+    if (typeof document !== "undefined") {
+      document.documentElement?.setAttribute(WATERMARK_DOM_CONSTANTS.ROOT_ATTR, reason);
+      if (this.config.cleanLegacyMask) {
+        removeLegacyBodyMasks();
+      }
+      const existing = document.getElementById(WATERMARK_DOM_CONSTANTS.CONTAINER_ID);
+      existing?.parentNode?.removeChild(existing);
+    }
+    this.containerEl = null;
+  }
+  render() {
+    if (typeof window === "undefined" || typeof document === "undefined" || !document.body) {
+      return;
+    }
+    if (!this.state.active) {
+      return;
+    }
+    this.isRenderingInternal = true;
+    this.stopMutationObserver();
+    try {
+      if (this.config.cleanLegacyMask) {
+        removeLegacyBodyMasks();
+      }
+      const resolvedUserId = resolveWatermarkUserId(this.config);
+      const dateStr = formatWatermarkDate();
+      const watermarkText = buildWatermarkText(this.config, resolvedUserId, dateStr);
+      this.state.userId = resolvedUserId;
+      this.state.text = watermarkText;
+      const viewportWidth = Math.max(
+        window.innerWidth || 0,
+        document.documentElement?.clientWidth || 0,
+        document.body.clientWidth || 0,
+        1024
+      );
+      const viewportHeight = Math.max(
+        window.innerHeight || 0,
+        document.documentElement?.clientHeight || 0,
+        768
+      );
+      const { cols, rows, xSpace, ySpace } = calculateWatermarkGrid(this.config, viewportWidth, viewportHeight);
+      this.state.cols = cols;
+      this.state.rows = rows;
+      let container = document.getElementById(WATERMARK_DOM_CONSTANTS.CONTAINER_ID);
+      if (!container) {
+        container = document.createElement("div");
+        container.id = WATERMARK_DOM_CONSTANTS.CONTAINER_ID;
+        container.className = WATERMARK_DOM_CONSTANTS.CONTAINER_CLASS;
+        container.setAttribute("data-giime-watermark-container", "true");
+        container.setAttribute("aria-hidden", "true");
+        document.body.appendChild(container);
+      }
+      container.setAttribute(
+        "style",
+        [
+          "position: fixed !important",
+          "top: 0px !important",
+          "left: 0px !important",
+          "width: 100vw !important",
+          "height: 100vh !important",
+          "overflow: hidden !important",
+          "pointer-events: none !important",
+          "user-select: none !important",
+          "-webkit-user-select: none !important",
+          `z-index: ${this.config.zIndex} !important`,
+          "display: block !important",
+          "visibility: visible !important",
+          "opacity: 1 !important",
+          "background: transparent !important"
+        ].join("; ")
+      );
+      const fragment = document.createDocumentFragment();
+      const rotateStr = `rotate(-${this.config.angle}deg)`;
+      for (let i = 0; i < rows; i++) {
+        const y = this.config.y + (ySpace + this.config.height) * i;
+        for (let j = 0; j < cols; j++) {
+          const x = this.config.x + (this.config.width + xSpace) * j;
+          const maskDiv = document.createElement("div");
+          maskDiv.id = `mask_div${i}${j}`;
+          maskDiv.className = WATERMARK_DOM_CONSTANTS.LEGACY_ITEM_CLASS;
+          maskDiv.appendChild(document.createTextNode(watermarkText));
+          maskDiv.style.webkitTransform = rotateStr;
+          maskDiv.style.MozTransform = rotateStr;
+          maskDiv.style.msTransform = rotateStr;
+          maskDiv.style.OTransform = rotateStr;
+          maskDiv.style.transform = rotateStr;
+          maskDiv.style.visibility = "";
+          maskDiv.style.position = "absolute";
+          maskDiv.style.left = `${x}px`;
+          maskDiv.style.top = `${y}px`;
+          maskDiv.style.overflow = "hidden";
+          maskDiv.style.zIndex = String(this.config.zIndex);
+          maskDiv.style.pointerEvents = "none";
+          maskDiv.style.opacity = String(this.config.alpha);
+          maskDiv.style.fontSize = this.config.fontSize;
+          maskDiv.style.fontFamily = /^['"]/.test(this.config.font) || this.config.font.includes(",") ? this.config.font : `"${this.config.font}"`;
+          maskDiv.style.color = this.config.color;
+          maskDiv.style.textAlign = "center";
+          maskDiv.style.width = `${this.config.width}px`;
+          maskDiv.style.height = `${this.config.height}px`;
+          maskDiv.style.display = "block";
+          fragment.appendChild(maskDiv);
+        }
+      }
+      container.innerHTML = "";
+      container.appendChild(fragment);
+      this.containerEl = container;
+      broadcastSuppressToChildFrames(watermarkText);
+    } finally {
+      this.isRenderingInternal = false;
+      if (this.config.antiTamper && this.state.active) {
+        this.startMutationObserver();
+      }
+    }
+  }
+  startMutationObserver() {
+    if (typeof MutationObserver === "undefined" || typeof document === "undefined" || !document.body || this.mutationObserver) {
+      return;
+    }
+    this.mutationObserver = new MutationObserver((mutations) => {
+      if (this.isRenderingInternal || !this.state.active) {
+        return;
+      }
+      let needRestore = false;
+      for (const mutation of mutations) {
+        if (mutation.type === "childList") {
+          const added = Array.from(mutation.addedNodes);
+          for (const node of added) {
+            const el = node;
+            if (el?.tagName === "IFRAME") {
+              el.addEventListener(
+                "load",
+                () => {
+                  if (this.state.active) {
+                    broadcastSuppressToChildFrames(this.state.text);
+                  }
+                },
+                { once: true }
+              );
+            }
+          }
+          const removed = Array.from(mutation.removedNodes);
+          if (removed.some(
+            (node) => node === this.containerEl || node?.id === WATERMARK_DOM_CONSTANTS.CONTAINER_ID || node?.classList?.contains(WATERMARK_DOM_CONSTANTS.LEGACY_ITEM_CLASS)
+          )) {
+            needRestore = true;
+            break;
+          }
+        }
+        if (mutation.type === "attributes") {
+          const targetEl = mutation.target;
+          if (targetEl === this.containerEl || targetEl?.id === WATERMARK_DOM_CONSTANTS.CONTAINER_ID || targetEl?.classList?.contains(WATERMARK_DOM_CONSTANTS.LEGACY_ITEM_CLASS)) {
+            needRestore = true;
+            break;
+          }
+        }
+      }
+      if (needRestore) {
+        this.render();
+      }
+    });
+    this.mutationObserver.observe(document.body, { childList: true });
+    if (this.containerEl) {
+      this.mutationObserver.observe(this.containerEl, {
+        attributes: true,
+        attributeFilter: ["style", "class", "id", "hidden"],
+        childList: true,
+        subtree: true
+      });
+    }
+  }
+  stopMutationObserver() {
+    if (this.mutationObserver) {
+      this.mutationObserver.disconnect();
+      this.mutationObserver = null;
+    }
+  }
+  attachGlobalListeners() {
+    if (this.listenersAttached || typeof window === "undefined") {
+      return;
+    }
+    this.listenersAttached = true;
+    window.addEventListener("resize", this.handleWindowResize, { passive: true });
+    window.addEventListener("message", this.handleWindowMessage);
+  }
+  detachGlobalListeners() {
+    if (!this.listenersAttached || typeof window === "undefined") {
+      return;
+    }
+    this.listenersAttached = false;
+    window.removeEventListener("resize", this.handleWindowResize);
+    window.removeEventListener("message", this.handleWindowMessage);
+  }
+  updateConfig(options = {}) {
+    this.config = normalizeWatermarkOptions(options, this.config);
+    this.bootstrap();
+    return this;
+  }
+  setUserId(userId) {
+    this.config.userId = userId;
+    return this.refresh();
+  }
+  refresh() {
+    if (this.state.active) {
+      this.render();
+    } else {
+      this.bootstrap();
+    }
+    return this;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  destroy() {
+    this.stopMutationObserver();
+    if (this.resizeTimer) {
+      clearTimeout(this.resizeTimer);
+      this.resizeTimer = null;
+    }
+    this.detachGlobalListeners();
+    this.suppressWatermark("disabled");
+    storeVerifiedUserId = "";
+    currentUserStoreBound = false;
+    const g = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : null;
+    if (g && g[GIIME_WATERMARK_GLOBAL_SYMBOL] === this) {
+      delete g[GIIME_WATERMARK_GLOBAL_SYMBOL];
+    }
+    if (typeof window !== "undefined" && window.__GIIME_WATERMARK__ === this) {
+      delete window.__GIIME_WATERMARK__;
+    }
+  }
+}
+const getWatermarkInstance = () => {
+  const g = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : null;
+  if (!g) {
+    return null;
+  }
+  return g[GIIME_WATERMARK_GLOBAL_SYMBOL] || null;
+};
+let currentUserStoreBound = false;
+const autoIdentifyWatermarkUser = async (instance) => {
+  if (currentUserStoreBound) {
+    return;
+  }
+  try {
+    const currentUserStore = index.useCurrentUserStore();
+    const loginStore = index$1.useLoginStore();
+    currentUserStoreBound = true;
+    const hasToken = Boolean(Cookies.get("token") || loginStore.userToken);
+    if (hasToken && !currentUserStore.userInfo?.id && !currentUserStore.isLoading) {
+      currentUserStore.getUserInfo().catch(() => {
+      });
+    }
+    loginStore.onLoginResult(() => {
+      if (!currentUserStore.isLoading) {
+        currentUserStore.getUserInfo().catch(() => {
+        });
+      }
+    });
+    vue.watch(
+      () => currentUserStore.userInfo?.id,
+      (newId) => {
+        const cleanId = sanitizeUserId(newId);
+        if (cleanId && cleanId !== storeVerifiedUserId) {
+          storeVerifiedUserId = cleanId;
+          if (cleanId !== instance.getState().userId) {
+            instance.refresh();
+          }
+        }
+      },
+      { immediate: true }
+    );
+    await core.until(() => currentUserStore.userInfo?.id).toBeTruthy();
+    const finalId = sanitizeUserId(currentUserStore.userInfo?.id);
+    if (finalId && finalId !== storeVerifiedUserId) {
+      storeVerifiedUserId = finalId;
+      if (finalId !== instance.getState().userId) {
+        instance.refresh();
+      }
+    }
+  } catch {
+  }
+};
+const initWatermark = (options) => {
+  const g = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : {};
+  let instance = g[GIIME_WATERMARK_GLOBAL_SYMBOL];
+  if (!instance) {
+    instance = new GiimeWatermark(options);
+    g[GIIME_WATERMARK_GLOBAL_SYMBOL] = instance;
+    if (typeof window !== "undefined") {
+      window.__GIIME_WATERMARK__ = instance;
+    }
+  } else if (options && Object.keys(options).length > 0) {
+    instance.updateConfig(options);
+  } else {
+    instance.refresh();
+  }
+  Promise.resolve().then(() => {
+    if (instance) {
+      autoIdentifyWatermarkUser(instance);
+    }
+  });
+  return instance;
+};
+const createWatermark = initWatermark;
+const destroyWatermark = () => {
+  getWatermarkInstance()?.destroy();
+};
+const useWatermark = (options) => {
+  return initWatermark(options);
+};
+const Watermark = {
+  init: initWatermark,
+  create: createWatermark,
+  getInstance: getWatermarkInstance,
+  destroy: destroyWatermark,
+  setUserId(userId) {
+    return initWatermark({ userId });
+  },
+  refresh() {
+    return getWatermarkInstance()?.refresh() ?? initWatermark();
+  },
+  getState() {
+    return getWatermarkInstance()?.getState() ?? null;
+  },
+  isInIframe,
+  shouldRenderWatermark
+};
+
+exports.GIIME_WATERMARK_GLOBAL_SYMBOL = GIIME_WATERMARK_GLOBAL_SYMBOL;
+exports.GiimeWatermark = GiimeWatermark;
+exports.WATERMARK_DOM_CONSTANTS = WATERMARK_DOM_CONSTANTS;
+exports.WATERMARK_MESSAGE_TYPES = WATERMARK_MESSAGE_TYPES;
+exports.Watermark = Watermark;
+exports.buildWatermarkText = buildWatermarkText;
+exports.createWatermark = createWatermark;
+exports.destroyWatermark = destroyWatermark;
+exports.formatWatermarkDate = formatWatermarkDate;
+exports.getWatermarkInstance = getWatermarkInstance;
+exports.hasSameOriginAncestorWatermark = hasSameOriginAncestorWatermark;
+exports.initWatermark = initWatermark;
+exports.inspectSameOriginAncestors = inspectSameOriginAncestors;
+exports.isInIframe = isInIframe;
+exports.resolveWatermarkUserId = resolveWatermarkUserId;
+exports.sanitizeUserId = sanitizeUserId;
+exports.shouldRenderWatermark = shouldRenderWatermark;
+exports.useWatermark = useWatermark;
+//# sourceMappingURL=index.js.map