import { At as onBeforeMount, C as vShow, Cn as withDirectives, Dt as mergeProps, Kn as ref, M as Fragment, Ot as nextTick, Qn as toRef, U as computed, W as createBaseVNode, Yn as shallowRef, ar as normalizeClass, et as createVNode, gn as watch, jt as onBeforeUnmount, sr as normalizeStyle } from "./vue.runtime.esm-bundler-BvoXUmaf.js";
import { _ as convertToUnit, et as SUPPORTS_INTERSECTION, l as propsFactory, n as genericComponent, s as getCurrentInstance, w as filterInputAttrs } from "./defineComponent-DB6xIcDy.js";
import { t as makeComponentProps } from "./component-DdiwBe6i.js";
import { t as useRender } from "./useRender-fVtVsZgv.js";
import { t as useBackgroundColor } from "./color-B6vuQruj.js";
import { n as useDimension, t as makeDimensionProps } from "./dimensions-BDdmuRdK.js";
import { n as useRounded, t as makeRoundedProps } from "./rounded-BuPGKRa9.js";
import { n as makeTransitionProps, t as MaybeTransition } from "./transition-DqoZ8fA1.js";
import "/Users/thackmaster/Development/routie2/frontend/node_modules/vuetify/lib/components/VImg/VImg.css";
import "/Users/thackmaster/Development/routie2/frontend/node_modules/vuetify/lib/components/VResponsive/VResponsive.css";
//#region node_modules/vuetify/lib/components/VResponsive/VResponsive.js
function useAspectStyles(props) {
	return { aspectStyles: computed(() => {
		const ratio = Number(props.aspectRatio);
		return ratio ? { paddingBottom: String(1 / ratio * 100) + "%" } : void 0;
	}) };
}
var makeVResponsiveProps = propsFactory({
	aspectRatio: [String, Number],
	contentClass: null,
	inline: Boolean,
	...makeComponentProps(),
	...makeDimensionProps()
}, "VResponsive");
var VResponsive = genericComponent()({
	name: "VResponsive",
	props: makeVResponsiveProps(),
	setup(props, { slots }) {
		const { aspectStyles } = useAspectStyles(props);
		const { dimensionStyles } = useDimension(props);
		useRender(() => createBaseVNode("div", {
			"class": normalizeClass([
				"v-responsive",
				{ "v-responsive--inline": props.inline },
				props.class
			]),
			"style": normalizeStyle([dimensionStyles.value, props.style])
		}, [
			createBaseVNode("div", {
				"class": "v-responsive__sizer",
				"style": normalizeStyle(aspectStyles.value)
			}, null),
			slots.additional?.(),
			slots.default && createBaseVNode("div", { "class": normalizeClass(["v-responsive__content", props.contentClass]) }, [slots.default()])
		]));
		return {};
	}
});
//#endregion
//#region node_modules/vuetify/lib/directives/intersect/index.js
function mounted(el, binding) {
	if (!SUPPORTS_INTERSECTION) return;
	const modifiers = binding.modifiers || {};
	const value = binding.value;
	const { handler, options } = typeof value === "object" ? value : {
		handler: value,
		options: {}
	};
	const observer = new IntersectionObserver((entries = [], observer) => {
		const _observe = el._observe?.[binding.instance.$.uid];
		if (!_observe) return;
		const isIntersecting = entries.some((entry) => entry.isIntersecting);
		if (handler && (!modifiers.quiet || _observe.init) && (!modifiers.once || isIntersecting || _observe.init)) handler(isIntersecting, entries, observer);
		if (isIntersecting && modifiers.once) unmounted(el, binding);
		else _observe.init = true;
	}, options);
	el._observe = Object(el._observe);
	el._observe[binding.instance.$.uid] = {
		init: false,
		observer
	};
	observer.observe(el);
}
function unmounted(el, binding) {
	const observe = el._observe?.[binding.instance.$.uid];
	if (!observe) return;
	observe.observer.unobserve(el);
	delete el._observe[binding.instance.$.uid];
}
var Intersect = {
	mounted,
	unmounted,
	updated: (el, binding) => {
		if (el._observe?.[binding.instance.$.uid]) {
			unmounted(el, binding);
			mounted(el, binding);
		}
	}
};
//#endregion
//#region node_modules/vuetify/lib/components/VImg/VImg.js
var makeVImgProps = propsFactory({
	absolute: Boolean,
	alt: String,
	cover: Boolean,
	color: String,
	draggable: {
		type: [Boolean, String],
		default: void 0
	},
	eager: Boolean,
	gradient: String,
	imageClass: null,
	lazySrc: String,
	options: {
		type: Object,
		default: () => ({
			root: void 0,
			rootMargin: void 0,
			threshold: void 0
		})
	},
	sizes: String,
	src: {
		type: [String, Object],
		default: ""
	},
	crossorigin: String,
	referrerpolicy: String,
	srcset: String,
	position: String,
	...makeVResponsiveProps(),
	...makeComponentProps(),
	...makeRoundedProps(),
	...makeTransitionProps()
}, "VImg");
var VImg = genericComponent()({
	name: "VImg",
	directives: { vIntersect: Intersect },
	inheritAttrs: false,
	props: makeVImgProps(),
	emits: {
		loadstart: (value) => true,
		load: (value) => true,
		error: (value) => true
	},
	setup(props, { attrs, emit, slots }) {
		const { backgroundColorClasses, backgroundColorStyles } = useBackgroundColor(() => props.color);
		const { roundedClasses } = useRounded(props);
		const vm = getCurrentInstance("VImg");
		const currentSrc = shallowRef("");
		const image = ref();
		const state = shallowRef(props.eager ? "loading" : "idle");
		const naturalWidth = shallowRef();
		const naturalHeight = shallowRef();
		const normalisedSrc = computed(() => {
			return props.src && typeof props.src === "object" ? {
				src: props.src.src,
				srcset: props.srcset || props.src.srcset,
				lazySrc: props.lazySrc || props.src.lazySrc,
				aspect: Number(props.aspectRatio || props.src.aspect || 0)
			} : {
				src: props.src,
				srcset: props.srcset,
				lazySrc: props.lazySrc,
				aspect: Number(props.aspectRatio || 0)
			};
		});
		const aspectRatio = computed(() => {
			return normalisedSrc.value.aspect || naturalWidth.value / naturalHeight.value || 0;
		});
		watch(() => props.src, () => {
			init(state.value !== "idle");
		});
		watch(aspectRatio, (val, oldVal) => {
			if (!val && oldVal && image.value) pollForSize(image.value);
		});
		onBeforeMount(() => init());
		function init(isIntersecting) {
			if (props.eager && isIntersecting) return;
			if (SUPPORTS_INTERSECTION && !isIntersecting && !props.eager) return;
			state.value = "loading";
			if (normalisedSrc.value.lazySrc) {
				const lazyImg = new Image();
				lazyImg.src = normalisedSrc.value.lazySrc;
				pollForSize(lazyImg, null);
			}
			if (!normalisedSrc.value.src) return;
			nextTick(() => {
				emit("loadstart", image.value?.currentSrc || normalisedSrc.value.src);
				setTimeout(() => {
					if (vm.isUnmounted) return;
					if (image.value?.complete) {
						if (!image.value.naturalWidth) onError();
						if (state.value === "error") return;
						if (!aspectRatio.value) pollForSize(image.value, null);
						if (state.value === "loading") onLoad();
					} else {
						if (!aspectRatio.value) pollForSize(image.value);
						getSrc();
					}
				});
			});
		}
		function onLoad() {
			if (vm.isUnmounted) return;
			getSrc();
			pollForSize(image.value);
			state.value = "loaded";
			emit("load", image.value?.currentSrc || normalisedSrc.value.src);
		}
		function onError() {
			if (vm.isUnmounted) return;
			state.value = "error";
			emit("error", image.value?.currentSrc || normalisedSrc.value.src);
		}
		function getSrc() {
			const img = image.value;
			if (img) currentSrc.value = img.currentSrc || img.src;
		}
		let timer = -1;
		onBeforeUnmount(() => {
			clearTimeout(timer);
		});
		function pollForSize(img, timeout = 100) {
			const poll = () => {
				clearTimeout(timer);
				if (vm.isUnmounted) return;
				const { naturalHeight: imgHeight, naturalWidth: imgWidth } = img;
				if (imgHeight || imgWidth) {
					naturalWidth.value = imgWidth;
					naturalHeight.value = imgHeight;
				} else if (!img.complete && state.value === "loading" && timeout != null) timer = window.setTimeout(poll, timeout);
				else if (img.currentSrc.endsWith(".svg") || img.currentSrc.startsWith("data:image/svg+xml")) {
					naturalWidth.value = 1;
					naturalHeight.value = 1;
				}
			};
			poll();
		}
		const containClasses = toRef(() => ({
			"v-img__img--cover": props.cover,
			"v-img__img--contain": !props.cover
		}));
		const __image = () => {
			if (!normalisedSrc.value.src || state.value === "idle") return null;
			const img = createBaseVNode("img", {
				"class": normalizeClass([
					"v-img__img",
					containClasses.value,
					props.imageClass
				]),
				"style": { objectPosition: props.position },
				"crossorigin": props.crossorigin,
				"src": normalisedSrc.value.src,
				"srcset": normalisedSrc.value.srcset,
				"alt": props.alt,
				"referrerpolicy": props.referrerpolicy,
				"draggable": props.draggable,
				"sizes": props.sizes,
				"ref": image,
				"onLoad": onLoad,
				"onError": onError
			}, null);
			const sources = slots.sources?.();
			return createVNode(MaybeTransition, {
				"transition": props.transition,
				"appear": true
			}, { default: () => [withDirectives(sources ? createBaseVNode("picture", { "class": "v-img__picture" }, [sources, img]) : img, [[vShow, state.value === "loaded"]])] });
		};
		const __preloadImage = () => createVNode(MaybeTransition, { "transition": props.transition }, { default: () => [normalisedSrc.value.lazySrc && state.value !== "loaded" && createBaseVNode("img", {
			"class": normalizeClass([
				"v-img__img",
				"v-img__img--preload",
				containClasses.value
			]),
			"style": { objectPosition: props.position },
			"crossorigin": props.crossorigin,
			"src": normalisedSrc.value.lazySrc,
			"alt": props.alt,
			"referrerpolicy": props.referrerpolicy,
			"draggable": props.draggable
		}, null)] });
		const __placeholder = () => {
			if (!slots.placeholder) return null;
			return createVNode(MaybeTransition, {
				"transition": props.transition,
				"appear": true
			}, { default: () => [(state.value === "loading" || state.value === "error" && !slots.error) && createBaseVNode("div", { "class": "v-img__placeholder" }, [slots.placeholder()])] });
		};
		const __error = () => {
			if (!slots.error) return null;
			return createVNode(MaybeTransition, {
				"transition": props.transition,
				"appear": true
			}, { default: () => [state.value === "error" && createBaseVNode("div", { "class": "v-img__error" }, [slots.error()])] });
		};
		const __gradient = () => {
			if (!props.gradient) return null;
			return createBaseVNode("div", {
				"class": "v-img__gradient",
				"style": { backgroundImage: `linear-gradient(${props.gradient})` }
			}, null);
		};
		const isBooted = shallowRef(false);
		{
			const stop = watch(aspectRatio, (val) => {
				if (val) {
					requestAnimationFrame(() => {
						requestAnimationFrame(() => {
							isBooted.value = true;
						});
					});
					stop();
				}
			});
		}
		useRender(() => {
			const responsiveProps = VResponsive.filterProps(props);
			const [rootAttrs, imageAttrs] = filterInputAttrs(attrs);
			return withDirectives(createVNode(VResponsive, mergeProps({
				"class": [
					"v-img",
					{
						"v-img--absolute": props.absolute,
						"v-img--booting": !isBooted.value,
						"v-img--fit-content": props.width === "fit-content"
					},
					backgroundColorClasses.value,
					roundedClasses.value,
					props.class
				],
				"style": [
					{ width: convertToUnit(props.width === "auto" ? naturalWidth.value : props.width) },
					backgroundColorStyles.value,
					props.style
				]
			}, responsiveProps, rootAttrs, {
				"aspectRatio": aspectRatio.value,
				"aria-label": props.alt,
				"role": props.alt ? "img" : void 0
			}), {
				additional: () => createBaseVNode(Fragment, null, [
					createVNode(__image, imageAttrs, null),
					createVNode(__preloadImage, null, null),
					createVNode(__gradient, null, null),
					createVNode(__placeholder, null, null),
					createVNode(__error, null, null)
				]),
				default: slots.default
			}), [[
				Intersect,
				{
					handler: init,
					options: props.options
				},
				null,
				{ once: true }
			]]);
		});
		return {
			currentSrc,
			image,
			state,
			naturalWidth,
			naturalHeight
		};
	}
});
//#endregion
export { Intersect as n, VImg as t };

//# sourceMappingURL=VImg-DaEUT7gG.js.map