@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/virtual-list/VirtualList.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,275 @@
+import { addUnit } from "../_util/index.js";
+import { useVirtualRange } from "../_util/hooks/useVirtualRange.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderList, renderSlot, resolveDynamicComponent, shallowRef, unref, watch, withCtx } from "vue";
+// src/virtual-list/VirtualList.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["data-index"];
+var _hoisted_2 = {
+	key: 1,
+	class: "am-virtual-list-footer"
+};
+var FALLBACK_VIEWPORT_ITEMS = 12;
+var REACH_END_THRESHOLD = 40;
+var SETTLE_WINDOW = 400;
+var VirtualList_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmVirtualList",
+	inheritAttrs: false,
+	__name: "VirtualList",
+	props: {
+		data: { default: () => [] },
+		height: {},
+		itemHeight: { default: 44 },
+		itemKey: {},
+		virtual: {
+			type: Boolean,
+			default: true
+		},
+		fixed: {
+			type: Boolean,
+			default: false
+		},
+		overscan: { default: 4 },
+		component: { default: "div" },
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: [
+		"scroll",
+		"visibleChange",
+		"reachEnd"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		/** viewport used before the container is measured (SSR, jsdom, display: none) */
+		const rootRef = ref();
+		const headerRef = ref();
+		const scrollTop = ref(0);
+		const viewportHeight = ref(0);
+		const headerHeight = ref(0);
+		function getKey(item, index) {
+			const { itemKey } = props;
+			if (typeof itemKey === "function") return itemKey(item, index);
+			if (typeof itemKey === "string" && item !== null && typeof item === "object" && item[itemKey] !== void 0) return item[itemKey];
+			return index;
+		}
+		const keys = computed(() => props.data.map(getKey));
+		const measured = /* @__PURE__ */ new Map();
+		/** bumped whenever a measured height changes, so the offsets recompute */
+		const measureVersion = ref(0);
+		const range = useVirtualRange({
+			count: () => props.data.length,
+			size: () => {
+				if (props.fixed) return props.itemHeight;
+				measureVersion.value;
+				const list = keys.value;
+				const estimate = props.itemHeight;
+				return (index) => measured.get(list[index]) ?? estimate;
+			},
+			scrollOffset: () => scrollTop.value - headerHeight.value,
+			viewportSize: () => {
+				if (viewportHeight.value > 0) return viewportHeight.value;
+				return typeof props.height === "number" ? props.height : props.itemHeight * FALLBACK_VIEWPORT_ITEMS;
+			},
+			overscan: () => props.overscan,
+			enabled: () => props.virtual
+		});
+		const visibleItems = computed(() => {
+			const start = range.start.value;
+			return props.data.slice(start, range.end.value).map((item, i) => ({
+				item,
+				index: start + i,
+				key: keys.value[start + i]
+			}));
+		});
+		watch(() => [range.start.value, range.end.value], ([start, end]) => emit("visibleChange", start, end));
+		watch(keys, (list) => {
+			if (!measured.size) return;
+			const alive = new Set(list);
+			measured.forEach((_, key) => {
+				if (!alive.has(key)) measured.delete(key);
+			});
+		});
+		let resizeObserver;
+		const elementKeys = /* @__PURE__ */ new WeakMap();
+		const itemElements = shallowRef(/* @__PURE__ */ new Map());
+		function setHeight(key, height) {
+			if (height > 0 && measured.get(key) !== height) {
+				measured.set(key, height);
+				measureVersion.value++;
+			}
+		}
+		function setItemRef(el, key) {
+			const map = itemElements.value;
+			const prev = map.get(key);
+			const node = el;
+			if (prev && prev !== node) {
+				resizeObserver?.unobserve(prev);
+				map.delete(key);
+			}
+			if (node && prev !== node) {
+				map.set(key, node);
+				elementKeys.set(node, key);
+				if (!props.fixed) {
+					resizeObserver?.observe(node);
+					setHeight(key, node.offsetHeight);
+				}
+			}
+		}
+		function measureViewport() {
+			const el = rootRef.value;
+			if (!el) return;
+			viewportHeight.value = el.clientHeight;
+			headerHeight.value = headerRef.value?.offsetHeight ?? 0;
+		}
+		onMounted(() => {
+			if (typeof ResizeObserver !== "undefined") {
+				resizeObserver = new ResizeObserver((entries) => {
+					entries.forEach((entry) => {
+						const target = entry.target;
+						if (target === rootRef.value || target === headerRef.value) {
+							measureViewport();
+							return;
+						}
+						const key = elementKeys.get(target);
+						if (key !== void 0) setHeight(key, target.offsetHeight);
+					});
+				});
+				if (rootRef.value) resizeObserver.observe(rootRef.value);
+				if (headerRef.value) resizeObserver.observe(headerRef.value);
+				if (!props.fixed) itemElements.value.forEach((el) => resizeObserver.observe(el));
+			}
+			measureViewport();
+		});
+		onBeforeUnmount(() => {
+			resizeObserver?.disconnect();
+			resizeObserver = void 0;
+		});
+		let reachedEnd = false;
+		function onScroll(event) {
+			const el = rootRef.value;
+			if (!el) return;
+			scrollTop.value = el.scrollTop;
+			emit("scroll", event);
+			const atEnd = el.scrollTop + el.clientHeight >= el.scrollHeight - REACH_END_THRESHOLD;
+			if (atEnd && !reachedEnd) emit("reachEnd");
+			reachedEnd = atEnd;
+		}
+		watch(() => props.data.length, () => {
+			reachedEnd = false;
+		});
+		/**
+		* In measured mode an index-based scroll is computed from estimates first; while the real
+		* heights come in, the target is re-applied so it lands exactly. A newer scrollTo() or a
+		* user gesture cancels the pending settle.
+		*/
+		let settle;
+		function cancelSettle() {
+			settle = void 0;
+		}
+		watch(measureVersion, () => {
+			if (!settle) return;
+			if (Date.now() > settle.until) {
+				settle = void 0;
+				return;
+			}
+			settle.apply();
+		});
+		function scrollTo(target) {
+			const el = rootRef.value;
+			cancelSettle();
+			if (!el) return;
+			if (typeof target === "number") {
+				el.scrollTop = target;
+				scrollTop.value = target;
+				return;
+			}
+			let index = target.index;
+			if (index === void 0 && target.key !== void 0) index = keys.value.indexOf(target.key);
+			if (index === void 0 || index < 0) return;
+			const align = target.align ?? "start";
+			const offset = target.offset ?? 0;
+			let first = true;
+			const apply = () => {
+				const viewport = el.clientHeight || viewportHeight.value;
+				const itemTop = headerHeight.value + range.offsetOf(index);
+				const itemSize = range.sizeOf(index);
+				let top = itemTop - offset;
+				if (align === "center") top = itemTop - (viewport - itemSize) / 2;
+				else if (align === "end") top = itemTop + itemSize - viewport + offset;
+				else if (align === "auto") {
+					const current = el.scrollTop;
+					if (itemTop >= current && itemTop + itemSize <= current + viewport) return;
+					top = itemTop < current ? itemTop - offset : itemTop + itemSize - viewport + offset;
+				}
+				top = Math.max(top, 0);
+				if (first && target.behavior && typeof el.scrollTo === "function") el.scrollTo({
+					top,
+					behavior: target.behavior
+				});
+				else el.scrollTop = top;
+				first = false;
+				scrollTop.value = top;
+			};
+			apply();
+			if (!props.fixed && props.virtual) settle = {
+				apply,
+				until: Date.now() + SETTLE_WINDOW
+			};
+		}
+		__expose({
+			scrollTo,
+			getScrollTop: () => rootRef.value?.scrollTop ?? 0,
+			/** the scroll container */
+			nativeElement: rootRef
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: ["am-virtual-list", [__props.rootClass, __props.classes?.root]],
+				style: [{ height: unref(addUnit)(__props.height) }, __props.styles?.root],
+				onScrollPassive: onScroll,
+				onTouchstartPassive: cancelSettle,
+				onWheelPassive: cancelSettle
+			}), [
+				_ctx.$slots.header ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					ref_key: "headerRef",
+					ref: headerRef,
+					class: "am-virtual-list-header"
+				}, [renderSlot(_ctx.$slots, "header")], 512)) : createCommentVNode("", true),
+				createElementVNode("div", {
+					class: normalizeClass(["am-virtual-list-holder", __props.classes?.holder]),
+					style: normalizeStyle([__props.virtual ? { height: `${unref(range).totalSize.value}px` } : void 0, __props.styles?.holder])
+				}, [(openBlock(), createBlock(resolveDynamicComponent(__props.component), {
+					class: normalizeClass(["am-virtual-list-inner", __props.classes?.list]),
+					style: normalizeStyle([__props.virtual ? { transform: `translate3d(0, ${unref(range).offsetBefore.value}px, 0)` } : void 0, __props.styles?.list])
+				}, {
+					default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(visibleItems.value, (entry) => {
+						return openBlock(), createElementBlock("div", {
+							key: entry.key,
+							ref_for: true,
+							ref: (el) => setItemRef(el, entry.key),
+							class: normalizeClass(["am-virtual-list-item", [{
+								"am-virtual-list-item-first": entry.index === 0,
+								"am-virtual-list-item-last": entry.index === __props.data.length - 1
+							}, __props.classes?.item]]),
+							style: normalizeStyle([__props.fixed ? { height: `${__props.itemHeight}px` } : void 0, __props.styles?.item]),
+							"data-index": entry.index
+						}, [renderSlot(_ctx.$slots, "default", {
+							item: entry.item,
+							index: entry.index
+						})], 14, _hoisted_1);
+					}), 128))]),
+					_: 3
+				}, 8, ["class", "style"]))], 6),
+				_ctx.$slots.footer ? (openBlock(), createElementBlock("div", _hoisted_2, [renderSlot(_ctx.$slots, "footer")])) : createCommentVNode("", true)
+			], 16);
+		};
+	}
+});
+export { VirtualList_vue_vue_type_script_setup_true_lang_default as default };

package/dist/virtual-list/index.d.ts

@@ -0,0 +1,70 @@
+export type * from './interface';
+declare const VirtualList: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").VirtualListProps> & Readonly<{
+        onScroll?: ((event: Event) => any) | undefined;
+        onVisibleChange?: ((start: number, end: number) => any) | undefined;
+        onReachEnd?: (() => any) | undefined;
+    }>, {
+        scrollTo: (target: number | import("./interface").VirtualListScrollToConfig) => void;
+        getScrollTop: () => number;
+        nativeElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        scroll: (event: Event) => any;
+        visibleChange: (start: number, end: number) => any;
+        reachEnd: () => any;
+    }, import("vue").PublicProps, {
+        data: any[];
+        fixed: boolean;
+        component: string;
+        itemHeight: number;
+        virtual: boolean;
+        overscan: number;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").VirtualListProps> & Readonly<{
+        onScroll?: ((event: Event) => any) | undefined;
+        onVisibleChange?: ((start: number, end: number) => any) | undefined;
+        onReachEnd?: (() => any) | undefined;
+    }>, {
+        scrollTo: (target: number | import("./interface").VirtualListScrollToConfig) => void;
+        getScrollTop: () => number;
+        nativeElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    }, {}, {}, {}, {
+        data: any[];
+        fixed: boolean;
+        component: string;
+        itemHeight: number;
+        virtual: boolean;
+        overscan: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").VirtualListProps> & Readonly<{
+    onScroll?: ((event: Event) => any) | undefined;
+    onVisibleChange?: ((start: number, end: number) => any) | undefined;
+    onReachEnd?: (() => any) | undefined;
+}>, {
+    scrollTo: (target: number | import("./interface").VirtualListScrollToConfig) => void;
+    getScrollTop: () => number;
+    nativeElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    scroll: (event: Event) => any;
+    visibleChange: (start: number, end: number) => any;
+    reachEnd: () => any;
+}, string, {
+    data: any[];
+    fixed: boolean;
+    component: string;
+    itemHeight: number;
+    virtual: boolean;
+    overscan: number;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").VirtualListSlots;
+}), object>;
+export default VirtualList;

package/dist/virtual-list/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import VirtualList_default from "./VirtualList.js";
+// src/virtual-list/index.ts
+var VirtualList = withInstall(VirtualList_default, "AmVirtualList");
+export { VirtualList as default };

package/dist/virtual-list/interface.d.ts

@@ -0,0 +1,68 @@
+import type { CSSProperties } from 'vue';
+import type { Key, Numeric } from '../_util/type';
+export type VirtualListItemKey = string | ((item: any, index: number) => Key);
+export interface VirtualListScrollToConfig {
+    /** scroll to the item at this index */
+    index?: number;
+    /** scroll to the item with this key */
+    key?: Key;
+    /** where the item lands in the viewport. Default `'start'`. */
+    align?: 'start' | 'center' | 'end' | 'auto';
+    /** extra distance kept before the item */
+    offset?: number;
+    behavior?: ScrollBehavior;
+}
+export interface VirtualListProps {
+    /** the full data source */
+    data?: any[];
+    /** height of the scroll container. Without it the list grows with its content (set a height / max-height by css). */
+    height?: Numeric;
+    /** item height in px. Exact when `fixed`, otherwise the estimate used before an item is measured. */
+    itemHeight?: number;
+    /** field name (or getter) of the unique key of an item. Default: the index. */
+    itemKey?: VirtualListItemKey;
+    /** `false` renders every item (keeps the same DOM structure and API) */
+    virtual?: boolean;
+    /** every item is exactly `itemHeight` tall: skips measuring, cheapest mode */
+    fixed?: boolean;
+    /** extra items rendered before / after the viewport */
+    overscan?: number;
+    /** tag of the inner list element */
+    component?: string;
+    rootClass?: string;
+    classes?: {
+        root?: string;
+        holder?: string;
+        list?: string;
+        item?: string;
+    };
+    styles?: {
+        root?: CSSProperties;
+        holder?: CSSProperties;
+        list?: CSSProperties;
+        item?: CSSProperties;
+    };
+}
+export interface VirtualListEmits {
+    scroll: [event: Event];
+    /** rendered window changed: `[start, end)` */
+    visibleChange: [start: number, end: number];
+    /** scrolled within `threshold` of the end, handy for loading more */
+    reachEnd: [];
+}
+export interface VirtualListSlots {
+    default?: (ctx: {
+        item: any;
+        index: number;
+    }) => any;
+    /** rendered inside the scroll container before the items (scrolls with them) */
+    header?: () => any;
+    /** rendered inside the scroll container after the items */
+    footer?: () => any;
+}
+export interface VirtualListExpose {
+    scrollTo: (target: number | VirtualListScrollToConfig) => void;
+    /** the scroll container */
+    nativeElement: HTMLElement | undefined;
+    getScrollTop: () => number;
+}

package/dist/virtual-list/style/index.css

@@ -0,0 +1,23 @@
+.am-virtual-list {
+  position: relative;
+  box-sizing: border-box;
+  overflow-x: hidden;
+  overflow-y: auto;
+  -webkit-overflow-scrolling: touch;
+  overscroll-behavior: contain;
+}
+
+.am-virtual-list-holder {
+  position: relative;
+  overflow: hidden;
+}
+
+.am-virtual-list-inner {
+  will-change: transform;
+}
+
+.am-virtual-list-item {
+  box-sizing: border-box;
+  /* a child margin must not collapse out of the measured box */
+  display: flow-root;
+}

package/dist/watermark/Watermark.js

@@ -0,0 +1,4 @@
+import Watermark_vue_vue_type_script_setup_true_lang_default from "./Watermark.vue_vue_type_script_setup_true_lang.js";
+// src/watermark/Watermark.vue
+var Watermark_default = Watermark_vue_vue_type_script_setup_true_lang_default;
+export { Watermark_default as default };

package/dist/watermark/Watermark.vue.d.ts

@@ -0,0 +1,25 @@
+import type { WatermarkProps, WatermarkSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = WatermarkSlots;
+declare function render(): void;
+declare const __VLS_base: import("vue").DefineComponent<WatermarkProps, {
+    /** Re-draws the watermark, e.g. after switching the theme with a class on `<html>`. */
+    render: typeof render;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    remove: () => any;
+}, string, import("vue").PublicProps, Readonly<WatermarkProps> & Readonly<{
+    onRemove?: (() => any) | undefined;
+}>, {
+    zIndex: number;
+    rotate: number;
+    gap: [number, number];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/watermark/Watermark.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,184 @@
+import { cancelRaf, raf } from "../_util/index.js";
+import { useConfig } from "../config-provider/context.js";
+import { getCanvasContext, getClips, getLayerStyle, getMarkSize } from "./utils.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { createElementBlock, defineComponent, mergeProps, onBeforeUnmount, onMounted, openBlock, ref, renderSlot, watch } from "vue";
+// src/watermark/Watermark.vue?vue&type=script&setup=true&lang.ts
+var FALLBACK_COLOR = "rgba(0, 0, 0, 0.15)";
+var Watermark_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmWatermark",
+	inheritAttrs: false,
+	__name: "Watermark",
+	props: {
+		zIndex: { default: 9 },
+		rotate: { default: -22 },
+		width: {},
+		height: {},
+		image: {},
+		content: {},
+		font: {},
+		gap: { default: () => [100, 100] },
+		offset: {},
+		fullPage: { type: Boolean },
+		rootClass: {}
+	},
+	emits: ["remove"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const config = useConfig();
+		const rootRef = ref();
+		let layer;
+		let observer;
+		let rafId = -1;
+		let renderId = 0;
+		function resolveFont() {
+			const font = props.font ?? {};
+			let color = font.color;
+			if (!color && layer) color = getComputedStyle(layer).color;
+			return {
+				color: color || FALLBACK_COLOR,
+				fontSize: font.fontSize ?? 16,
+				fontWeight: font.fontWeight ?? "normal",
+				fontStyle: font.fontStyle ?? "normal",
+				fontFamily: font.fontFamily ?? "sans-serif",
+				textAlign: font.textAlign ?? "center"
+			};
+		}
+		function withoutObserver(fn) {
+			observer?.disconnect();
+			fn();
+			if (observer && rootRef.value) observer.observe(rootRef.value, {
+				childList: true,
+				subtree: true,
+				attributes: true,
+				attributeFilter: ["style", "class"]
+			});
+		}
+		function ensureLayer() {
+			const root = rootRef.value;
+			if (!root) return void 0;
+			if (!layer) {
+				layer = document.createElement("div");
+				layer.setAttribute("aria-hidden", "true");
+			}
+			if (layer.parentElement !== root) root.append(layer);
+			return layer;
+		}
+		function applyLayer(base64Url, markWidth) {
+			const el = ensureLayer();
+			if (!el) return;
+			const style = {
+				"z-index": String(props.zIndex),
+				"position": props.fullPage ? "fixed" : "absolute",
+				"left": "0",
+				"top": "0",
+				"width": "100%",
+				"height": "100%",
+				"pointer-events": "none",
+				"background-repeat": "repeat",
+				...getLayerStyle(props.gap, props.offset),
+				"background-image": `url('${base64Url}')`,
+				"background-size": `${Math.floor(markWidth)}px`,
+				"visibility": "visible",
+				"opacity": "1"
+			};
+			el.className = "am-watermark-layer";
+			el.setAttribute("style", Object.keys(style).map((key) => `${key}: ${style[key]} !important;`).join(" "));
+		}
+		function removeLayer() {
+			withoutObserver(() => {
+				layer?.remove();
+				layer = void 0;
+			});
+		}
+		function render() {
+			if (!rootRef.value) return;
+			const id = ++renderId;
+			const ctx = getCanvasContext();
+			if (!ctx) return;
+			withoutObserver(() => {
+				ensureLayer();
+				if (layer) layer.className = "am-watermark-layer";
+			});
+			const font = resolveFont();
+			const ratio = window.devicePixelRatio || 1;
+			const [gapX, gapY] = props.gap;
+			const [markWidth, markHeight] = getMarkSize(ctx, {
+				width: props.width,
+				height: props.height,
+				image: props.image,
+				content: props.content,
+				font
+			});
+			const draw = (content) => {
+				if (id !== renderId) return;
+				const clips = getClips(content, props.rotate, ratio, markWidth, markHeight, font, gapX, gapY);
+				if (!clips) return;
+				withoutObserver(() => applyLayer(clips[0], clips[1]));
+			};
+			if (props.image) {
+				const img = new Image();
+				img.onload = () => draw(img);
+				img.onerror = () => draw(props.content ?? "");
+				img.crossOrigin = "anonymous";
+				img.referrerPolicy = "no-referrer";
+				img.src = props.image;
+			} else if (props.content !== void 0 && props.content !== "") draw(props.content);
+			else removeLayer();
+		}
+		function scheduleRender() {
+			cancelRaf(rafId);
+			rafId = raf(render);
+		}
+		function onMutate(mutations) {
+			if (mutations.some((mutation) => {
+				if (mutation.type === "childList") return Array.from(mutation.removedNodes).includes(layer);
+				return mutation.type === "attributes" && mutation.target === layer;
+			})) {
+				emit("remove");
+				render();
+			}
+		}
+		onMounted(() => {
+			if (typeof MutationObserver !== "undefined") observer = new MutationObserver(onMutate);
+			render();
+		});
+		onBeforeUnmount(() => {
+			cancelRaf(rafId);
+			renderId++;
+			observer?.disconnect();
+			observer = void 0;
+			layer?.remove();
+			layer = void 0;
+		});
+		watch(() => [
+			props.zIndex,
+			props.rotate,
+			props.width,
+			props.height,
+			props.image,
+			props.content,
+			props.font,
+			props.gap,
+			props.offset,
+			props.fullPage,
+			config.theme.value
+		], scheduleRender, {
+			deep: true,
+			flush: "post"
+		});
+		__expose({ 
+		/** Re-draws the watermark, e.g. after switching the theme with a class on `<html>`. */
+render });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, {
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: ["am-watermark", [{ "am-watermark-full-page": __props.fullPage }, __props.rootClass]]
+			}), [renderSlot(_ctx.$slots, "default")], 16);
+		};
+	}
+});
+export { Watermark_vue_vue_type_script_setup_true_lang_default as default };