@v-c/image 0.0.1

package/dist/hooks/useRegisterImage.js

@@ -0,0 +1,24 @@
+import { usePreviewGroupContext } from "../context.js";
+import { onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+var uid = 0;
+function useRegisterImage(canPreview, data) {
+	uid += 1;
+	const id = shallowRef(String(uid));
+	const groupContext = usePreviewGroupContext();
+	const registerData = () => ({
+		data: data.value,
+		canPreview: canPreview.value
+	});
+	let unRegister;
+	onMounted(() => {
+		if (groupContext) unRegister = groupContext.register(id.value, registerData());
+	});
+	watch([canPreview, data], () => {
+		if (groupContext) groupContext.register(id.value, registerData());
+	}, { deep: true });
+	onBeforeUnmount(() => {
+		unRegister?.();
+	});
+	return id.value;
+}
+export { useRegisterImage as default };

package/dist/hooks/useStatus.cjs

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_util = require("../util.cjs");
+let vue = require("vue");
+function useStatus(options) {
+	const { src, isCustomPlaceholder, fallback } = options;
+	const status = (0, vue.shallowRef)(isCustomPlaceholder?.value ? "loading" : "normal");
+	const isLoaded = (0, vue.shallowRef)(false);
+	const isError = (0, vue.computed)(() => status.value === "error");
+	(0, vue.watchEffect)((onCleanup) => {
+		let isCurrentSrc = true;
+		require_util.isImageValid(src.value || "").then((isValid) => {
+			if (!isValid && isCurrentSrc) status.value = "error";
+		});
+		onCleanup(() => {
+			isCurrentSrc = false;
+		});
+	});
+	(0, vue.watch)(() => src.value, () => {
+		isLoaded.value = false;
+		if (isCustomPlaceholder?.value && !isLoaded.value) status.value = "loading";
+		else if (isError.value) status.value = "normal";
+	}, { immediate: true });
+	const onLoad = () => {
+		isLoaded.value = true;
+		status.value = "normal";
+	};
+	const getImgRef = (img) => {
+		isLoaded.value = false;
+		if (status.value === "loading" && img?.complete && (img.naturalWidth || img.naturalHeight)) {
+			isLoaded.value = true;
+			onLoad();
+		}
+	};
+	return [
+		getImgRef,
+		(0, vue.computed)(() => {
+			if (isError.value && fallback?.value) return { src: fallback.value };
+			return {
+				onLoad,
+				src: src.value
+			};
+		}),
+		status
+	];
+}
+exports.default = useStatus;

package/dist/hooks/useStatus.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+export type ImageStatus = 'normal' | 'error' | 'loading';
+export default function useStatus(options: {
+    src: Ref<string | undefined>;
+    isCustomPlaceholder?: Ref<boolean>;
+    fallback?: Ref<string | undefined>;
+}): readonly [(img?: HTMLImageElement | null) => void, import('vue').ComputedRef<{
+    src: string;
+    onLoad?: undefined;
+} | {
+    onLoad: () => void;
+    src: string | undefined;
+}>, import('vue').ShallowRef<ImageStatus, ImageStatus>];

package/dist/hooks/useStatus.js

@@ -0,0 +1,45 @@
+import { isImageValid } from "../util.js";
+import { computed, shallowRef, watch, watchEffect } from "vue";
+function useStatus(options) {
+	const { src, isCustomPlaceholder, fallback } = options;
+	const status = shallowRef(isCustomPlaceholder?.value ? "loading" : "normal");
+	const isLoaded = shallowRef(false);
+	const isError = computed(() => status.value === "error");
+	watchEffect((onCleanup) => {
+		let isCurrentSrc = true;
+		isImageValid(src.value || "").then((isValid) => {
+			if (!isValid && isCurrentSrc) status.value = "error";
+		});
+		onCleanup(() => {
+			isCurrentSrc = false;
+		});
+	});
+	watch(() => src.value, () => {
+		isLoaded.value = false;
+		if (isCustomPlaceholder?.value && !isLoaded.value) status.value = "loading";
+		else if (isError.value) status.value = "normal";
+	}, { immediate: true });
+	const onLoad = () => {
+		isLoaded.value = true;
+		status.value = "normal";
+	};
+	const getImgRef = (img) => {
+		isLoaded.value = false;
+		if (status.value === "loading" && img?.complete && (img.naturalWidth || img.naturalHeight)) {
+			isLoaded.value = true;
+			onLoad();
+		}
+	};
+	return [
+		getImgRef,
+		computed(() => {
+			if (isError.value && fallback?.value) return { src: fallback.value };
+			return {
+				onLoad,
+				src: src.value
+			};
+		}),
+		status
+	];
+}
+export { useStatus as default };

package/dist/hooks/useTouchEvent.cjs

@@ -0,0 +1,120 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_getFixScaleEleTransPosition = require("../getFixScaleEleTransPosition.cjs");
+let vue = require("vue");
+function getDistance(a, b) {
+	const x = a.x - b.x;
+	const y = a.y - b.y;
+	return Math.hypot(x, y);
+}
+function getCenter(oldPoint1, oldPoint2, newPoint1, newPoint2) {
+	const distance1 = getDistance(oldPoint1, newPoint1);
+	const distance2 = getDistance(oldPoint2, newPoint2);
+	if (distance1 === 0 && distance2 === 0) return [oldPoint1.x, oldPoint1.y];
+	const ratio = distance1 / (distance1 + distance2);
+	return [oldPoint1.x + ratio * (oldPoint2.x - oldPoint1.x), oldPoint1.y + ratio * (oldPoint2.y - oldPoint1.y)];
+}
+function useTouchEvent(imgRef, movable, open, minScale, transform, updateTransform, dispatchZoomChange) {
+	const isTouching = (0, vue.shallowRef)(false);
+	const touchPointInfo = (0, vue.shallowRef)({
+		point1: {
+			x: 0,
+			y: 0
+		},
+		point2: {
+			x: 0,
+			y: 0
+		},
+		eventType: "none"
+	});
+	const updateTouchPointInfo = (values) => {
+		touchPointInfo.value = {
+			...touchPointInfo.value,
+			...values
+		};
+	};
+	const onTouchStart = (event) => {
+		if (!movable.value) return;
+		event.stopPropagation();
+		isTouching.value = true;
+		const { touches = [] } = event;
+		const { x, y } = transform.value;
+		if (touches.length > 1) updateTouchPointInfo({
+			point1: {
+				x: touches[0].clientX,
+				y: touches[0].clientY
+			},
+			point2: {
+				x: touches[1].clientX,
+				y: touches[1].clientY
+			},
+			eventType: "touchZoom"
+		});
+		else updateTouchPointInfo({
+			point1: {
+				x: touches[0].clientX - x,
+				y: touches[0].clientY - y
+			},
+			eventType: "move"
+		});
+	};
+	const onTouchMove = (event) => {
+		const { touches = [] } = event;
+		const { point1, point2, eventType } = touchPointInfo.value;
+		if (touches.length > 1 && eventType === "touchZoom") {
+			const newPoint1 = {
+				x: touches[0].clientX,
+				y: touches[0].clientY
+			};
+			const newPoint2 = {
+				x: touches[1].clientX,
+				y: touches[1].clientY
+			};
+			const [centerX, centerY] = getCenter(point1, point2, newPoint1, newPoint2);
+			dispatchZoomChange(getDistance(newPoint1, newPoint2) / getDistance(point1, point2), "touchZoom", centerX, centerY, true);
+			updateTouchPointInfo({
+				point1: newPoint1,
+				point2: newPoint2,
+				eventType: "touchZoom"
+			});
+		} else if (eventType === "move") {
+			updateTransform({
+				x: touches[0].clientX - point1.x,
+				y: touches[0].clientY - point1.y
+			}, "move");
+			updateTouchPointInfo({ eventType: "move" });
+		}
+	};
+	const onTouchEnd = () => {
+		if (!open.value || !imgRef.value) return;
+		if (isTouching.value) isTouching.value = false;
+		updateTouchPointInfo({ eventType: "none" });
+		const { rotate, scale } = transform.value;
+		if (minScale.value > scale) return updateTransform({
+			x: 0,
+			y: 0,
+			scale: minScale.value
+		}, "touchZoom");
+		const width = imgRef.value.offsetWidth * scale;
+		const height = imgRef.value.offsetHeight * scale;
+		const { left, top } = imgRef.value.getBoundingClientRect() ?? {};
+		const isRotate = rotate % 180 !== 0;
+		const fixState = require_getFixScaleEleTransPosition.default(isRotate ? height : width, isRotate ? width : height, left, top);
+		if (fixState) updateTransform({ ...fixState }, "dragRebound");
+	};
+	(0, vue.watchEffect)((onCleanup) => {
+		const preventDefault = (e) => {
+			e.preventDefault();
+		};
+		if (open.value && movable.value) window.addEventListener("touchmove", preventDefault, { passive: false });
+		onCleanup(() => {
+			window.removeEventListener("touchmove", preventDefault);
+		});
+	});
+	return {
+		isTouching,
+		onTouchStart,
+		onTouchMove,
+		onTouchEnd
+	};
+}
+exports.default = useTouchEvent;

package/dist/hooks/useTouchEvent.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { DispatchZoomChangeFunc, TransformType, UpdateTransformFunc } from './useImageTransform.ts';
+export default function useTouchEvent(imgRef: Ref<HTMLImageElement>, movable: Ref<boolean>, open: Ref<boolean>, minScale: Ref<number>, transform: Ref<TransformType>, updateTransform: UpdateTransformFunc, dispatchZoomChange: DispatchZoomChangeFunc): {
+    isTouching: import('vue').ShallowRef<boolean, boolean>;
+    onTouchStart: (event: TouchEvent) => void;
+    onTouchMove: (event: TouchEvent) => void;
+    onTouchEnd: () => void;
+};

package/dist/hooks/useTouchEvent.js

@@ -0,0 +1,119 @@
+import getFixScaleEleTransPosition from "../getFixScaleEleTransPosition.js";
+import { shallowRef, watchEffect } from "vue";
+function getDistance(a, b) {
+	const x = a.x - b.x;
+	const y = a.y - b.y;
+	return Math.hypot(x, y);
+}
+function getCenter(oldPoint1, oldPoint2, newPoint1, newPoint2) {
+	const distance1 = getDistance(oldPoint1, newPoint1);
+	const distance2 = getDistance(oldPoint2, newPoint2);
+	if (distance1 === 0 && distance2 === 0) return [oldPoint1.x, oldPoint1.y];
+	const ratio = distance1 / (distance1 + distance2);
+	return [oldPoint1.x + ratio * (oldPoint2.x - oldPoint1.x), oldPoint1.y + ratio * (oldPoint2.y - oldPoint1.y)];
+}
+function useTouchEvent(imgRef, movable, open, minScale, transform, updateTransform, dispatchZoomChange) {
+	const isTouching = shallowRef(false);
+	const touchPointInfo = shallowRef({
+		point1: {
+			x: 0,
+			y: 0
+		},
+		point2: {
+			x: 0,
+			y: 0
+		},
+		eventType: "none"
+	});
+	const updateTouchPointInfo = (values) => {
+		touchPointInfo.value = {
+			...touchPointInfo.value,
+			...values
+		};
+	};
+	const onTouchStart = (event) => {
+		if (!movable.value) return;
+		event.stopPropagation();
+		isTouching.value = true;
+		const { touches = [] } = event;
+		const { x, y } = transform.value;
+		if (touches.length > 1) updateTouchPointInfo({
+			point1: {
+				x: touches[0].clientX,
+				y: touches[0].clientY
+			},
+			point2: {
+				x: touches[1].clientX,
+				y: touches[1].clientY
+			},
+			eventType: "touchZoom"
+		});
+		else updateTouchPointInfo({
+			point1: {
+				x: touches[0].clientX - x,
+				y: touches[0].clientY - y
+			},
+			eventType: "move"
+		});
+	};
+	const onTouchMove = (event) => {
+		const { touches = [] } = event;
+		const { point1, point2, eventType } = touchPointInfo.value;
+		if (touches.length > 1 && eventType === "touchZoom") {
+			const newPoint1 = {
+				x: touches[0].clientX,
+				y: touches[0].clientY
+			};
+			const newPoint2 = {
+				x: touches[1].clientX,
+				y: touches[1].clientY
+			};
+			const [centerX, centerY] = getCenter(point1, point2, newPoint1, newPoint2);
+			dispatchZoomChange(getDistance(newPoint1, newPoint2) / getDistance(point1, point2), "touchZoom", centerX, centerY, true);
+			updateTouchPointInfo({
+				point1: newPoint1,
+				point2: newPoint2,
+				eventType: "touchZoom"
+			});
+		} else if (eventType === "move") {
+			updateTransform({
+				x: touches[0].clientX - point1.x,
+				y: touches[0].clientY - point1.y
+			}, "move");
+			updateTouchPointInfo({ eventType: "move" });
+		}
+	};
+	const onTouchEnd = () => {
+		if (!open.value || !imgRef.value) return;
+		if (isTouching.value) isTouching.value = false;
+		updateTouchPointInfo({ eventType: "none" });
+		const { rotate, scale } = transform.value;
+		if (minScale.value > scale) return updateTransform({
+			x: 0,
+			y: 0,
+			scale: minScale.value
+		}, "touchZoom");
+		const width = imgRef.value.offsetWidth * scale;
+		const height = imgRef.value.offsetHeight * scale;
+		const { left, top } = imgRef.value.getBoundingClientRect() ?? {};
+		const isRotate = rotate % 180 !== 0;
+		const fixState = getFixScaleEleTransPosition(isRotate ? height : width, isRotate ? width : height, left, top);
+		if (fixState) updateTransform({ ...fixState }, "dragRebound");
+	};
+	watchEffect((onCleanup) => {
+		const preventDefault = (e) => {
+			e.preventDefault();
+		};
+		if (open.value && movable.value) window.addEventListener("touchmove", preventDefault, { passive: false });
+		onCleanup(() => {
+			window.removeEventListener("touchmove", preventDefault);
+		});
+	});
+	return {
+		isTouching,
+		onTouchStart,
+		onTouchMove,
+		onTouchEnd
+	};
+}
+export { useTouchEvent as default };

package/dist/index.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+const require_Image = require("./Image.cjs");
+const require_PreviewGroup = require("./PreviewGroup.cjs");
+var ExportImage = require_Image.default;
+ExportImage.PreviewGroup = require_PreviewGroup.default;
+var src_default = ExportImage;
+exports.PreviewGroup = require_PreviewGroup.default;
+exports.default = src_default;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { ImageProps, default as Image } from './Image';
+import { default as PreviewGroup } from './PreviewGroup';
+export * from './Image';
+export type { PreviewGroupProps } from './PreviewGroup';
+export { PreviewGroup };
+export type { ImageProps };
+type ImageType = typeof Image & {
+    PreviewGroup: typeof PreviewGroup;
+};
+declare const ExportImage: ImageType;
+export default ExportImage;

package/dist/index.js

@@ -0,0 +1,6 @@
+import Image_default from "./Image.js";
+import PreviewGroup_default from "./PreviewGroup.js";
+var ExportImage = Image_default;
+ExportImage.PreviewGroup = PreviewGroup_default;
+var src_default = ExportImage;
+export { PreviewGroup_default as PreviewGroup, src_default as default };

package/dist/interface.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Used for PreviewGroup passed image data
+ */
+export type ImageElementProps = Pick<HTMLImageElement, 'src' | 'crossOrigin' | 'decoding' | 'draggable' | 'loading' | 'referrerPolicy' | 'sizes' | 'srcset' | 'useMap' | 'alt'>;
+export interface PreviewImageElementProps {
+    data: ImageElementProps;
+    canPreview: boolean;
+}
+export type InternalItem = PreviewImageElementProps & {
+    id?: string;
+};
+export type RegisterImage = (id: string, data: PreviewImageElementProps) => VoidFunction;
+export type OnGroupPreview = (id: string, imageSrc: string, mouseX: number, mouseY: number) => void;

package/dist/portal/dist/Context.cjs

@@ -0,0 +1,12 @@
+let vue = require("vue");
+var QueueContextKey = Symbol("QueueContextKey");
+function useContextProvider(appendFunc) {
+	const queueCreate = appendFunc;
+	(0, vue.provide)(QueueContextKey, queueCreate);
+	return queueCreate;
+}
+function useContextState() {
+	return (0, vue.inject)(QueueContextKey, void 0);
+}
+exports.useContextProvider = useContextProvider;
+exports.useContextState = useContextState;

package/dist/portal/dist/Context.js

@@ -0,0 +1,11 @@
+import { inject, provide } from "vue";
+var QueueContextKey = Symbol("QueueContextKey");
+function useContextProvider(appendFunc) {
+	const queueCreate = appendFunc;
+	provide(QueueContextKey, queueCreate);
+	return queueCreate;
+}
+function useContextState() {
+	return inject(QueueContextKey, void 0);
+}
+export { useContextProvider, useContextState };

package/dist/portal/dist/Portal.cjs

@@ -0,0 +1,91 @@
+const require_index = require("../../util/dist/props-util/index.cjs");
+const require_warning = require("../../util/dist/warning.cjs");
+require("../../util/dist/index.cjs");
+const require_Context = require("./Context.cjs");
+const require_canUseDom = require("../../util/dist/Dom/canUseDom.cjs");
+const require_useDom = require("./useDom.cjs");
+const require_useScrollLocker = require("./useScrollLocker.cjs");
+let vue = require("vue");
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !(0, vue.isVNode)(s);
+}
+function getPortalContainer(getContainer) {
+	if (getContainer === false) return false;
+	if (!require_canUseDom.canUseDom() || !getContainer) return null;
+	if (typeof getContainer === "string") return document.querySelector(getContainer);
+	if (typeof getContainer === "function") return getContainer();
+	return getContainer;
+}
+var Portal_default = /* @__PURE__ */ (0, vue.defineComponent)((props, { slots, expose }) => {
+	const shouldRender = (0, vue.shallowRef)(props.open);
+	const mergedRender = (0, vue.computed)(() => shouldRender.value || props.open);
+	if (process.env.NODE_ENV !== "production") require_warning.warning_default(require_canUseDom.canUseDom() || !open, `Portal only work in client side. Please call 'useEffect' to show Portal instead default render in SSR.`);
+	(0, vue.watch)([() => props.open, () => props.autoDestroy], () => {
+		if (props.autoDestroy || props.open) shouldRender.value = props.open;
+	});
+	const innerContainer = (0, vue.shallowRef)(getPortalContainer(props.getContainer));
+	(0, vue.onMounted)(() => {
+		innerContainer.value = getPortalContainer(props.getContainer) ?? null;
+	});
+	(0, vue.watch)(() => props.getContainer, () => {
+		innerContainer.value = getPortalContainer(props.getContainer) ?? null;
+	});
+	const [defaultContainer, queueCreate] = require_useDom.useDom((0, vue.computed)(() => !!(mergedRender.value && !innerContainer.value)), props.debug);
+	require_Context.useContextProvider(queueCreate);
+	const mergedContainer = (0, vue.computed)(() => innerContainer.value ?? defaultContainer);
+	require_useScrollLocker.useScrollLocker((0, vue.computed)(() => !!(props.autoLock && props.open && require_canUseDom.canUseDom() && (mergedContainer.value === defaultContainer || mergedContainer.value === document.body))));
+	const elementEl = (0, vue.shallowRef)();
+	const setRef = (el) => {
+		elementEl.value = el;
+	};
+	expose({ elementEl });
+	return () => {
+		if (!mergedRender.value || !require_canUseDom.canUseDom() || innerContainer.value === void 0) return null;
+		const renderInline = mergedContainer.value === false;
+		const reffedChildren = require_index.filterEmpty(slots.default?.() ?? []);
+		if (renderInline) return reffedChildren;
+		else {
+			const child = reffedChildren.length === 1 ? (0, vue.isVNode)(reffedChildren[0]) ? (0, vue.createVNode)(reffedChildren[0], { ref: setRef }) : reffedChildren[0] : reffedChildren;
+			return (0, vue.createVNode)(vue.Teleport, { "to": mergedContainer.value }, _isSlot(child) ? child : { default: () => [child] });
+		}
+	};
+}, {
+	props: /* @__PURE__ */ (0, vue.mergeDefaults)({
+		getContainer: {
+			type: [
+				String,
+				Function,
+				Boolean
+			],
+			required: false,
+			skipCheck: true,
+			default: void 0
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		autoDestroy: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		autoLock: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		debug: {
+			type: String,
+			required: false,
+			default: void 0
+		}
+	}, {
+		autoDestroy: true,
+		getContainer: void 0
+	}),
+	name: "Portal",
+	inheritAttrs: false
+});
+exports.Portal_default = Portal_default;

package/dist/portal/dist/Portal.js

@@ -0,0 +1,91 @@
+import { filterEmpty } from "../../util/dist/props-util/index.js";
+import { warning_default } from "../../util/dist/warning.js";
+import "../../util/dist/index.js";
+import { useContextProvider } from "./Context.js";
+import { canUseDom } from "../../util/dist/Dom/canUseDom.js";
+import { useDom } from "./useDom.js";
+import { useScrollLocker } from "./useScrollLocker.js";
+import { Teleport, computed, createVNode, defineComponent, isVNode, mergeDefaults, onMounted, shallowRef, watch } from "vue";
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+function getPortalContainer(getContainer) {
+	if (getContainer === false) return false;
+	if (!canUseDom() || !getContainer) return null;
+	if (typeof getContainer === "string") return document.querySelector(getContainer);
+	if (typeof getContainer === "function") return getContainer();
+	return getContainer;
+}
+var Portal_default = /* @__PURE__ */ defineComponent((props, { slots, expose }) => {
+	const shouldRender = shallowRef(props.open);
+	const mergedRender = computed(() => shouldRender.value || props.open);
+	if (process.env.NODE_ENV !== "production") warning_default(canUseDom() || !open, `Portal only work in client side. Please call 'useEffect' to show Portal instead default render in SSR.`);
+	watch([() => props.open, () => props.autoDestroy], () => {
+		if (props.autoDestroy || props.open) shouldRender.value = props.open;
+	});
+	const innerContainer = shallowRef(getPortalContainer(props.getContainer));
+	onMounted(() => {
+		innerContainer.value = getPortalContainer(props.getContainer) ?? null;
+	});
+	watch(() => props.getContainer, () => {
+		innerContainer.value = getPortalContainer(props.getContainer) ?? null;
+	});
+	const [defaultContainer, queueCreate] = useDom(computed(() => !!(mergedRender.value && !innerContainer.value)), props.debug);
+	useContextProvider(queueCreate);
+	const mergedContainer = computed(() => innerContainer.value ?? defaultContainer);
+	useScrollLocker(computed(() => !!(props.autoLock && props.open && canUseDom() && (mergedContainer.value === defaultContainer || mergedContainer.value === document.body))));
+	const elementEl = shallowRef();
+	const setRef = (el) => {
+		elementEl.value = el;
+	};
+	expose({ elementEl });
+	return () => {
+		if (!mergedRender.value || !canUseDom() || innerContainer.value === void 0) return null;
+		const renderInline = mergedContainer.value === false;
+		const reffedChildren = filterEmpty(slots.default?.() ?? []);
+		if (renderInline) return reffedChildren;
+		else {
+			const child = reffedChildren.length === 1 ? isVNode(reffedChildren[0]) ? createVNode(reffedChildren[0], { ref: setRef }) : reffedChildren[0] : reffedChildren;
+			return createVNode(Teleport, { "to": mergedContainer.value }, _isSlot(child) ? child : { default: () => [child] });
+		}
+	};
+}, {
+	props: /* @__PURE__ */ mergeDefaults({
+		getContainer: {
+			type: [
+				String,
+				Function,
+				Boolean
+			],
+			required: false,
+			skipCheck: true,
+			default: void 0
+		},
+		open: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		autoDestroy: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		autoLock: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		debug: {
+			type: String,
+			required: false,
+			default: void 0
+		}
+	}, {
+		autoDestroy: true,
+		getContainer: void 0
+	}),
+	name: "Portal",
+	inheritAttrs: false
+});
+export { Portal_default };

package/dist/portal/dist/index.cjs

@@ -0,0 +1,3 @@
+const require_Portal = require("./Portal.cjs");
+var src_default = require_Portal.Portal_default;
+exports.src_default = src_default;

package/dist/portal/dist/index.js

@@ -0,0 +1,3 @@
+import { Portal_default } from "./Portal.js";
+var src_default = Portal_default;
+export { src_default };