import { U as computed, ar as normalizeClass, et as createVNode, ir as capitalize, pt as h, sr as normalizeStyle } from "./vue.runtime.esm-bundler-BvoXUmaf.js";
import { _ as convertToUnit, at as deprecate, l as propsFactory, n as genericComponent, z as keys } from "./defineComponent-DB6xIcDy.js";
import { t as makeComponentProps } from "./component-DdiwBe6i.js";
import { t as createSimpleFunctional } from "./createSimpleFunctional-Cqw8cOWQ.js";
import { t as useRender } from "./useRender-fVtVsZgv.js";
import { i as useRtl } from "./locale-DDGMqzqb.js";
import { n as breakpoints } from "./display-DKaCj-_K.js";
import { t as makeTagProps } from "./tag-C_KkCPzB.js";
import { n as useDimension, t as makeDimensionProps } from "./dimensions-BDdmuRdK.js";
import { t as makeDensityProps } from "./density-CpKZ5PhP.js";
import "/Users/thackmaster/Development/routie2/frontend/node_modules/vuetify/lib/components/VGrid/VContainer.css";
import "/Users/thackmaster/Development/routie2/frontend/node_modules/vuetify/lib/components/VGrid/VGrid.css";
import "/Users/thackmaster/Development/routie2/frontend/node_modules/vuetify/lib/components/VGrid/VSpacer.css";
//#region node_modules/vuetify/lib/components/VGrid/VContainer.js
var makeVContainerProps = propsFactory({
	fluid: {
		type: Boolean,
		default: false
	},
	...makeComponentProps(),
	...makeDimensionProps(),
	...makeTagProps()
}, "VContainer");
var VContainer = genericComponent()({
	name: "VContainer",
	props: makeVContainerProps(),
	setup(props, { slots }) {
		const { rtlClasses } = useRtl();
		const { dimensionStyles } = useDimension(props);
		useRender(() => createVNode(props.tag, {
			"class": normalizeClass([
				"v-container",
				{ "v-container--fluid": props.fluid },
				rtlClasses.value,
				props.class
			]),
			"style": normalizeStyle([dimensionStyles.value, props.style])
		}, slots));
		return {};
	}
});
//#endregion
//#region node_modules/vuetify/lib/components/VGrid/VCol.js
var breakpointProps = breakpoints.reduce((props, val) => {
	props[val] = {
		type: [
			Boolean,
			String,
			Number
		],
		default: false
	};
	return props;
}, {});
var offsetProps = breakpoints.reduce((props, val) => {
	const offsetKey = "offset" + capitalize(val);
	props[offsetKey] = {
		type: [String, Number],
		default: null
	};
	return props;
}, {});
var propMap$1 = {
	col: keys(breakpointProps),
	offset: keys(offsetProps),
	order: [
		"order",
		"orderSm",
		"orderMd",
		"orderLg",
		"orderXl",
		"orderXxl"
	]
};
function parseCols(val) {
	if (typeof val === "string" && val.includes("/")) {
		const [cols, size] = val.split("/");
		return {
			cols: Number(cols),
			size: Number(size)
		};
	}
	return { cols: val };
}
function parseBreakpoint(type, prop, val) {
	if (val == null || val === false) return {};
	const { cols, size } = parseCols(val);
	const breakpoint = prop.replace(type, "").toLowerCase();
	if (type === "offset") return {
		className: `v-col--offset-${breakpoint}-${cols}`,
		variables: [{ [`--v-col-offset-base-${breakpoint}`]: size }]
	};
	else if (type === "order") return { className: `order-${breakpoint}-${cols}` };
	return {
		className: cols === "" || cols === true ? `v-col--${breakpoint}` : `v-col--cols-${breakpoint}-${cols}`,
		variables: [{ [`--v-col-size-base-${breakpoint}`]: size }]
	};
}
var ALIGN_SELF_VALUES = [
	"auto",
	"start",
	"end",
	"center",
	"baseline",
	"stretch"
];
var alignSelfValidator = (str) => ALIGN_SELF_VALUES.includes(str);
var makeVColProps = propsFactory({
	cols: {
		type: [
			Boolean,
			String,
			Number
		],
		default: false
	},
	...breakpointProps,
	offset: {
		type: [String, Number],
		default: null
	},
	...offsetProps,
	/** @deprecated use order-* class instead */
	order: {
		type: [String, Number],
		default: null
	},
	/** @deprecated use order-sm-* class instead */
	orderSm: {
		type: [String, Number],
		default: null
	},
	/** @deprecated use order-md-* class instead */
	orderMd: {
		type: [String, Number],
		default: null
	},
	/** @deprecated use order-lg-* class instead */
	orderLg: {
		type: [String, Number],
		default: null
	},
	/** @deprecated use order-xl-* class instead */
	orderXl: {
		type: [String, Number],
		default: null
	},
	/** @deprecated use order-xxl-* class instead */
	orderXxl: {
		type: [String, Number],
		default: null
	},
	/** @deprecated use align-self-* class instead */
	alignSelf: {
		type: String,
		default: null,
		validator: alignSelfValidator
	},
	...makeComponentProps(),
	...makeTagProps()
}, "VCol");
var VCol = genericComponent()({
	name: "VCol",
	props: makeVColProps(),
	setup(props, { slots }) {
		const sizeBaseOverride = computed(() => parseCols(props.cols).size);
		const offsetBaseOverride = computed(() => parseCols(props.offset).size);
		const responsive = computed(() => {
			const classList = ["v-col"];
			const variablesList = [];
			let type;
			for (type in propMap$1) propMap$1[type].forEach((prop) => {
				const value = props[prop];
				const { className, variables } = parseBreakpoint(type, prop, value);
				if (className) classList.push(className);
				if (variables) variablesList.push(...variables);
			});
			const { cols } = parseCols(props.cols);
			const { cols: offset } = parseCols(props.offset);
			classList.push({
				[`v-col--cols-${cols}`]: cols,
				[`v-col--offset-${offset}`]: offset,
				[`order-${props.order}`]: props.order,
				[`align-self-${props.alignSelf}`]: props.alignSelf
			});
			return {
				classes: classList,
				variables: variablesList
			};
		});
		return () => h(props.tag, {
			class: [responsive.value.classes, props.class],
			style: [
				{ "--v-col-size-base": sizeBaseOverride.value },
				{ "--v-col-offset-base": offsetBaseOverride.value },
				responsive.value.variables,
				props.style
			]
		}, slots.default?.());
	}
});
//#endregion
//#region node_modules/vuetify/lib/components/VGrid/VRow.js
var ALIGNMENT = [
	"start",
	"end",
	"center"
];
var SPACE = [
	"space-between",
	"space-around",
	"space-evenly"
];
var ALIGN_VALUES = [
	...ALIGNMENT,
	"baseline",
	"stretch"
];
var alignValidator = (str) => ALIGN_VALUES.includes(str);
var JUSTIFY_VALUES = [...ALIGNMENT, ...SPACE];
var justifyValidator = (str) => JUSTIFY_VALUES.includes(str);
var ALIGN_CONTENT_VALUES = [
	...ALIGNMENT,
	...SPACE,
	"stretch"
];
var alignContentValidator = (str) => ALIGN_CONTENT_VALUES.includes(str);
var propMap = {
	align: [
		"align",
		"alignSm",
		"alignMd",
		"alignLg",
		"alignXl",
		"alignXxl"
	],
	justify: [
		"justify",
		"justifySm",
		"justifyMd",
		"justifyLg",
		"justifyXl",
		"justifyXxl"
	],
	alignContent: [
		"alignContent",
		"alignContentSm",
		"alignContentMd",
		"alignContentLg",
		"alignContentXl",
		"alignContentXxl"
	]
};
var classMap = {
	align: "align",
	justify: "justify",
	alignContent: "align-content"
};
function breakpointClass(type, prop, val) {
	let className = classMap[type];
	if (val == null) return;
	if (prop) {
		const breakpoint = prop.replace(type, "");
		className += `-${breakpoint}`;
	}
	className += `-${val}`;
	return className.toLowerCase();
}
var makeVRowProps = propsFactory({
	/** @deprecated use density="compact" instead */
	dense: Boolean,
	/** @deprecated use align-* class instead */
	align: {
		type: String,
		default: null,
		validator: alignValidator
	},
	/** @deprecated use align-sm-* class instead */
	alignSm: {
		type: String,
		default: null,
		validator: alignValidator
	},
	/** @deprecated use align-md-* class instead */
	alignMd: {
		type: String,
		default: null,
		validator: alignValidator
	},
	/** @deprecated use align-lg-* class instead */
	alignLg: {
		type: String,
		default: null,
		validator: alignValidator
	},
	/** @deprecated use align-xl-* class instead */
	alignXl: {
		type: String,
		default: null,
		validator: alignValidator
	},
	/** @deprecated use align-xxl-* class instead */
	alignXxl: {
		type: String,
		default: null,
		validator: alignValidator
	},
	/** @deprecated use justify-* class instead */
	justify: {
		type: String,
		default: null,
		validator: justifyValidator
	},
	/** @deprecated use justify-sm-* class instead */
	justifySm: {
		type: String,
		default: null,
		validator: justifyValidator
	},
	/** @deprecated use justify-md-* class instead */
	justifyMd: {
		type: String,
		default: null,
		validator: justifyValidator
	},
	/** @deprecated use justify-lg-* class instead */
	justifyLg: {
		type: String,
		default: null,
		validator: justifyValidator
	},
	/** @deprecated use justify-xl-* class instead */
	justifyXl: {
		type: String,
		default: null,
		validator: justifyValidator
	},
	/** @deprecated use justify-xxl-* class instead */
	justifyXxl: {
		type: String,
		default: null,
		validator: justifyValidator
	},
	/** @deprecated use align-content-* class instead */
	alignContent: {
		type: String,
		default: null,
		validator: alignContentValidator
	},
	/** @deprecated use align-content-sm-* class instead */
	alignContentSm: {
		type: String,
		default: null,
		validator: alignContentValidator
	},
	/** @deprecated use align-content-md-* class instead */
	alignContentMd: {
		type: String,
		default: null,
		validator: alignContentValidator
	},
	/** @deprecated use align-content-lg-* class instead */
	alignContentLg: {
		type: String,
		default: null,
		validator: alignContentValidator
	},
	/** @deprecated use align-content-xl-* class instead */
	alignContentXl: {
		type: String,
		default: null,
		validator: alignContentValidator
	},
	/** @deprecated use align-content-xxl-* class instead */
	alignContentXxl: {
		type: String,
		default: null,
		validator: alignContentValidator
	},
	noGutters: Boolean,
	gap: [
		Number,
		String,
		Array
	],
	size: [Number, String],
	...makeComponentProps(),
	...makeDensityProps(),
	...makeTagProps()
}, "VRow");
var VRow = genericComponent()({
	name: "VRow",
	props: makeVRowProps(),
	setup(props, { slots }) {
		if (props.dense) deprecate("dense", "density=\"comfortable\"");
		const classes = computed(() => {
			const classList = [];
			let type;
			for (type in propMap) propMap[type].forEach((prop) => {
				const value = props[prop];
				const className = breakpointClass(type, prop, value);
				if (className) classList.push(className);
			});
			classList.push({
				"v-row--no-gutters": props.noGutters,
				"v-row--density-default": props.density === "default" && !props.noGutters && !props.dense,
				"v-row--density-compact": props.density === "compact",
				"v-row--density-comfortable": props.density === "comfortable" || props.dense,
				[`align-${props.align}`]: props.align,
				[`justify-${props.justify}`]: props.justify,
				[`align-content-${props.alignContent}`]: props.alignContent
			});
			return classList;
		});
		const horizontalGap = computed(() => {
			return Array.isArray(props.gap) ? convertToUnit(props.gap[0] || 0) : convertToUnit(props.gap);
		});
		const verticalGap = computed(() => {
			return Array.isArray(props.gap) ? convertToUnit(props.gap[1] || 0) : horizontalGap.value;
		});
		return () => h(props.tag, {
			class: [
				"v-row",
				classes.value,
				props.class
			],
			style: [{
				"--v-col-gap-x": horizontalGap.value,
				"--v-col-gap-y": verticalGap.value,
				"--v-row-columns": props.size
			}, props.style]
		}, slots.default?.());
	}
});
//#endregion
//#region node_modules/vuetify/lib/components/VGrid/VSpacer.js
var VSpacer = createSimpleFunctional("v-spacer", "div", "VSpacer");
//#endregion
export { VCol, VContainer, VRow, VSpacer };

//# sourceMappingURL=vuetify_components_VGrid.js.map