import { Kn as ref, M as Fragment, O as Comment, Qn as toRef, U as computed, Ut as provide, Wn as reactive, Yn as shallowRef, _n as watchEffect, hn as warn, ir as capitalize, nr as unref, nt as defineComponent$1, rr as camelize, ut as getCurrentInstance$1, wt as isVNode, xt as inject } from "./vue.runtime.esm-bundler-BvoXUmaf.js";
//#region node_modules/vuetify/lib/util/console.js
function consoleWarn(message) {
warn(`Vuetify: ${message}`);
}
function consoleError(message) {
warn(`Vuetify error: ${message}`);
}
function deprecate(original, replacement) {
replacement = Array.isArray(replacement) ? replacement.slice(0, -1).map((s) => `'${s}'`).join(", ") + ` or '${replacement.at(-1)}'` : `'${replacement}'`;
warn(`[Vuetify UPGRADE] '${original}' is deprecated, use ${replacement} instead.`);
}
//#endregion
//#region node_modules/vuetify/lib/util/globals.js
var IN_BROWSER = typeof window !== "undefined";
var SUPPORTS_INTERSECTION = IN_BROWSER && "IntersectionObserver" in window;
var SUPPORTS_TOUCH = IN_BROWSER && ("ontouchstart" in window || window.navigator.maxTouchPoints > 0);
IN_BROWSER && "EyeDropper" in window;
var SUPPORTS_MATCH_MEDIA = IN_BROWSER && "matchMedia" in window && typeof window.matchMedia === "function";
var PREFERS_REDUCED_MOTION = () => SUPPORTS_MATCH_MEDIA && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
//#endregion
//#region node_modules/vuetify/lib/util/helpers.js
function getNestedValue(obj, path, fallback) {
const last = path.length - 1;
if (last < 0) return obj === void 0 ? fallback : obj;
for (let i = 0; i < last; i++) {
if (obj == null) return fallback;
obj = obj[path[i]];
}
if (obj == null) return fallback;
return obj[path[last]] === void 0 ? fallback : obj[path[last]];
}
function getObjectValueByPath(obj, path, fallback) {
if (obj == null || !path || typeof path !== "string") return fallback;
if (obj[path] !== void 0) return obj[path];
path = path.replace(/\[(\w+)\]/g, ".$1");
path = path.replace(/^\./, "");
return getNestedValue(obj, path.split("."), fallback);
}
function getPropertyFromItem(item, property, fallback) {
if (property === true) return item === void 0 ? fallback : item;
if (property == null || typeof property === "boolean") return fallback;
if (item !== Object(item)) {
if (typeof property !== "function") return fallback;
const value = property(item, fallback);
return typeof value === "undefined" ? fallback : value;
}
if (typeof property === "string") return getObjectValueByPath(item, property, fallback);
if (Array.isArray(property)) return getNestedValue(item, property, fallback);
if (typeof property !== "function") return fallback;
const value = property(item, fallback);
return typeof value === "undefined" ? fallback : value;
}
function createRange(length, start = 0) {
return Array.from({ length }, (v, k) => start + k);
}
function convertToUnit(str, unit = "px") {
if (str == null || str === "") return;
const num = Number(str);
if (isNaN(num)) return String(str);
else if (!isFinite(num)) return;
else return `${num}${unit}`;
}
function isObject(obj) {
return obj !== null && typeof obj === "object" && !Array.isArray(obj);
}
function isPlainObject(obj) {
let proto;
return obj !== null && typeof obj === "object" && ((proto = Object.getPrototypeOf(obj)) === Object.prototype || proto === null);
}
function refElement(obj) {
if (obj && "$el" in obj) {
const el = obj.$el;
if (el?.nodeType === Node.TEXT_NODE) return el.nextElementSibling;
return el;
}
return obj;
}
Object.freeze({
enter: 13,
tab: 9,
delete: 46,
esc: 27,
space: 32,
up: 38,
down: 40,
left: 37,
right: 39,
end: 35,
home: 36,
del: 46,
backspace: 8,
insert: 45,
pageup: 33,
pagedown: 34,
shift: 16
});
Object.freeze({
enter: "Enter",
tab: "Tab",
delete: "Delete",
esc: "Escape",
space: "Space",
up: "ArrowUp",
down: "ArrowDown",
left: "ArrowLeft",
right: "ArrowRight",
end: "End",
home: "Home",
del: "Delete",
backspace: "Backspace",
insert: "Insert",
pageup: "PageUp",
pagedown: "PageDown",
shift: "Shift"
});
function keys(o) {
return Object.keys(o);
}
function has(obj, key) {
return key.every((k) => obj.hasOwnProperty(k));
}
function pick(obj, paths) {
const found = {};
for (const key of paths) if (Object.prototype.hasOwnProperty.call(obj, key)) found[key] = obj[key];
return found;
}
function pickWithRest(obj, paths, exclude) {
const found = Object.create(null);
const rest = Object.create(null);
for (const key in obj) if (paths.some((path) => path instanceof RegExp ? path.test(key) : path === key) && !exclude?.some((path) => path === key)) found[key] = obj[key];
else rest[key] = obj[key];
return [found, rest];
}
function omit(obj, exclude) {
const clone = { ...obj };
exclude.forEach((prop) => delete clone[prop]);
return clone;
}
var onRE = /^on[^a-z]/;
var isOn = (key) => onRE.test(key);
var bubblingEvents = [
"onAfterscriptexecute",
"onAnimationcancel",
"onAnimationend",
"onAnimationiteration",
"onAnimationstart",
"onAuxclick",
"onBeforeinput",
"onBeforescriptexecute",
"onChange",
"onClick",
"onCompositionend",
"onCompositionstart",
"onCompositionupdate",
"onContextmenu",
"onCopy",
"onCut",
"onDblclick",
"onFocusin",
"onFocusout",
"onFullscreenchange",
"onFullscreenerror",
"onGesturechange",
"onGestureend",
"onGesturestart",
"onGotpointercapture",
"onInput",
"onKeydown",
"onKeypress",
"onKeyup",
"onLostpointercapture",
"onMousedown",
"onMousemove",
"onMouseout",
"onMouseover",
"onMouseup",
"onMousewheel",
"onPaste",
"onPointercancel",
"onPointerdown",
"onPointerenter",
"onPointerleave",
"onPointermove",
"onPointerout",
"onPointerover",
"onPointerup",
"onReset",
"onSelect",
"onSubmit",
"onTouchcancel",
"onTouchend",
"onTouchmove",
"onTouchstart",
"onTransitioncancel",
"onTransitionend",
"onTransitionrun",
"onTransitionstart",
"onWheel"
];
/**
* Filter attributes that should be applied to
* the root element of an input component. Remaining
* attributes should be passed to the element inside.
*/
function filterInputAttrs(attrs) {
const [events, props] = pickWithRest(attrs, [onRE]);
const inputEvents = omit(events, bubblingEvents);
const [rootAttrs, inputAttrs] = pickWithRest(props, [
"class",
"style",
"id",
"inert",
/^data-/
]);
Object.assign(rootAttrs, events);
Object.assign(inputAttrs, inputEvents);
return [rootAttrs, inputAttrs];
}
function wrapInArray(v) {
return v == null ? [] : Array.isArray(v) ? v : [v];
}
function debounce(fn, delay) {
let timeoutId = 0;
const wrap = (...args) => {
clearTimeout(timeoutId);
timeoutId = setTimeout(() => fn(...args), unref(delay));
};
wrap.clear = () => {
clearTimeout(timeoutId);
};
wrap.immediate = fn;
return wrap;
}
function clamp(value, min = 0, max = 1) {
return Math.max(min, Math.min(max, value));
}
function padEnd(str, length, char = "0") {
return str + char.repeat(Math.max(0, length - str.length));
}
function padStart(str, length, char = "0") {
return char.repeat(Math.max(0, length - str.length)) + str;
}
function chunk(str, size = 1) {
const chunked = [];
let index = 0;
while (index < str.length) {
chunked.push(str.substr(index, size));
index += size;
}
return chunked;
}
function mergeDeep(source = {}, target = {}, arrayFn, targetCondition) {
const out = {};
for (const key in source) out[key] = source[key];
for (const key in target) {
const targetProperty = target[key];
if (targetCondition && !targetCondition(key, targetProperty)) continue;
const sourceProperty = source[key];
if (isPlainObject(sourceProperty) && isPlainObject(targetProperty)) {
out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn, targetCondition);
continue;
}
if (arrayFn && Array.isArray(sourceProperty) && Array.isArray(targetProperty)) {
out[key] = arrayFn(sourceProperty, targetProperty);
continue;
}
out[key] = targetProperty;
}
return out;
}
function flattenFragments(nodes) {
return nodes.map((node) => {
if (node.type === Fragment) return flattenFragments(node.children);
else return node;
}).flat();
}
function toKebabCase(str = "") {
if (toKebabCase.cache.has(str)) return toKebabCase.cache.get(str);
const kebab = str.replace(/[^a-z]/gi, "-").replace(/\B([A-Z])/g, "-$1").toLowerCase();
toKebabCase.cache.set(str, kebab);
return kebab;
}
toKebabCase.cache = /* @__PURE__ */ new Map();
function findChildrenWithProvide(key, vnode) {
if (!vnode || typeof vnode !== "object") return [];
if (Array.isArray(vnode)) return vnode.map((child) => findChildrenWithProvide(key, child)).flat(1);
else if (vnode.suspense) return findChildrenWithProvide(key, vnode.ssContent);
else if (Array.isArray(vnode.children)) return vnode.children.map((child) => findChildrenWithProvide(key, child)).flat(1);
else if (vnode.component) {
if (Object.getOwnPropertyDescriptor(vnode.component.provides, key)) return [vnode.component];
else if (vnode.component.subTree) return findChildrenWithProvide(key, vnode.component.subTree).flat(1);
}
return [];
}
var CircularBuffer = class {
#arr = [];
#pointer = 0;
constructor(size) {
this.size = size;
}
get isFull() {
return this.#arr.length === this.size;
}
push(val) {
this.#arr[this.#pointer] = val;
this.#pointer = (this.#pointer + 1) % this.size;
}
values() {
return this.#arr.slice(this.#pointer).concat(this.#arr.slice(0, this.#pointer));
}
clear() {
this.#arr.length = 0;
this.#pointer = 0;
}
};
/**
* Convert a computed ref to a record of refs.
* The getter function must always return an object with the same keys.
*/
function destructComputed(getter) {
const refs = reactive({});
watchEffect(() => {
const base = getter();
for (const key in base) refs[key] = base[key];
}, { flush: "sync" });
const obj = {};
for (const key in refs) obj[key] = toRef(() => refs[key]);
return obj;
}
/** Array.includes but value can be any type */
function includes(arr, val) {
return arr.includes(val);
}
function eventName(propName) {
return propName[2].toLowerCase() + propName.slice(3);
}
var EventProp = () => [Function, Array];
function hasEvent(props, name) {
name = "on" + capitalize(name);
return !!(props[name] || props[`${name}Once`] || props[`${name}Capture`] || props[`${name}OnceCapture`] || props[`${name}CaptureOnce`]);
}
function callEvent(handler, ...args) {
if (Array.isArray(handler)) for (const h of handler) h(...args);
else if (typeof handler === "function") handler(...args);
}
function focusableChildren(el, filterByTabIndex = true) {
const targets = [
"button",
"[href]",
"input:not([type=\"hidden\"])",
"select",
"textarea",
"details:not(:has(> summary))",
"details > summary",
"[tabindex]",
"[contenteditable]:not([contenteditable=\"false\"])",
"audio[controls]",
"video[controls]"
].map((s) => `${s}${filterByTabIndex ? ":not([tabindex=\"-1\"])" : ""}:not([disabled], [inert])`).join(", ");
let elements;
try {
elements = [...el.querySelectorAll(targets)];
} catch (err) {
consoleError(String(err));
return [];
}
return elements.filter((x) => !x.closest("[inert]")).filter((x) => !!x.offsetParent || x.getClientRects().length > 0).filter((x) => !x.parentElement?.closest("details:not([open])") || x.tagName === "SUMMARY" && x.parentElement?.tagName === "DETAILS");
}
function getNextElement(elements, location, condition) {
let _el;
let idx = elements.indexOf(document.activeElement);
const inc = location === "next" ? 1 : -1;
do {
idx += inc;
_el = elements[idx];
} while ((!_el || _el.offsetParent == null || !(condition?.(_el) ?? true)) && idx < elements.length && idx >= 0);
return _el;
}
function focusChild(el, location) {
const focusable = focusableChildren(el);
if (location == null) {
if (el === document.activeElement || !el.contains(document.activeElement)) focusable[0]?.focus();
} else if (location === "first") focusable[0]?.focus();
else if (location === "last") focusable.at(-1)?.focus();
else if (typeof location === "number") focusable[location]?.focus();
else {
const _el = getNextElement(focusable, location);
if (_el) _el.focus();
else focusChild(el, location === "next" ? "first" : "last");
}
}
/** Returns null if the selector is not supported or we can't check */
function matchesSelector(el, selector) {
if (!(IN_BROWSER && typeof CSS !== "undefined" && typeof CSS.supports !== "undefined" && CSS.supports(`selector(${selector})`))) return null;
try {
return !!el && el.matches(selector);
} catch (err) {
return null;
}
}
function ensureValidVNode(vnodes) {
return vnodes.some((child) => {
if (!isVNode(child)) return true;
if (child.type === Comment) return false;
return child.type !== Fragment || ensureValidVNode(child.children);
}) ? vnodes : null;
}
function defer(timeout, cb) {
if (!IN_BROWSER || timeout === 0) {
cb();
return () => {};
}
const timeoutId = window.setTimeout(cb, timeout);
return () => window.clearTimeout(timeoutId);
}
function isClickInsideElement(event, targetDiv) {
const mouseX = event.clientX;
const mouseY = event.clientY;
const divRect = targetDiv.getBoundingClientRect();
const divLeft = divRect.left;
const divTop = divRect.top;
const divRight = divRect.right;
const divBottom = divRect.bottom;
return mouseX >= divLeft && mouseX <= divRight && mouseY >= divTop && mouseY <= divBottom;
}
function templateRef() {
const el = shallowRef();
const fn = (target) => {
el.value = target;
};
Object.defineProperty(fn, "value", {
enumerable: true,
get: () => el.value,
set: (val) => el.value = val
});
Object.defineProperty(fn, "el", {
enumerable: true,
get: () => refElement(el.value)
});
return fn;
}
function checkPrintable(e) {
const isPrintableChar = e.key.length === 1;
const noModifier = !e.ctrlKey && !e.metaKey && !e.altKey;
return isPrintableChar && noModifier;
}
function isPrimitive(value) {
return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
}
function camelizeProps(props) {
const out = {};
for (const prop in props) out[camelize(prop)] = props[prop];
return out;
}
function onlyDefinedProps(props) {
const booleanAttributes = ["checked", "disabled"];
return Object.fromEntries(Object.entries(props).filter(([key, v]) => booleanAttributes.includes(key) ? !!v : v !== void 0));
}
//#endregion
//#region node_modules/vuetify/lib/util/propsFactory.js
/**
* Creates a factory function for props definitions.
* This is used to define props in a composable then override
* default values in an implementing component.
*
* @example Simplified signature
* (props: Props) => (defaults?: Record) => Props
*
* @example Usage
* const makeProps = propsFactory({
* foo: String,
* })
*
* defineComponent({
* props: {
* ...makeProps({
* foo: 'a',
* }),
* },
* setup (props) {
* // would be "string | undefined", now "string" because a default has been provided
* props.foo
* },
* }
*/
function propsFactory(props, source) {
return (defaults) => {
return Object.keys(props).reduce((obj, prop) => {
const definition = typeof props[prop] === "object" && props[prop] != null && !Array.isArray(props[prop]) ? props[prop] : { type: props[prop] };
if (defaults && prop in defaults) obj[prop] = {
...definition,
default: defaults[prop]
};
else obj[prop] = definition;
if (source && !obj[prop].source) obj[prop].source = source;
return obj;
}, {});
};
}
/**
* Like `Partial` but doesn't care what the value is
*/
//#endregion
//#region node_modules/vuetify/lib/util/getCurrentInstance.js
function getCurrentInstance(name, message) {
const vm = getCurrentInstance$1();
if (!vm) throw new Error(`[Vuetify] ${name} ${message || "must be called from inside a setup function"}`);
return vm;
}
function getCurrentInstanceName(name = "composables") {
const vm = getCurrentInstance(name).type;
return toKebabCase(vm?.aliasName || vm?.name);
}
//#endregion
//#region node_modules/vuetify/lib/util/injectSelf.js
function injectSelf(key, vm = getCurrentInstance("injectSelf")) {
const { provides } = vm;
if (provides && key in provides) return provides[key];
}
//#endregion
//#region node_modules/vuetify/lib/composables/defaults.js
var DefaultsSymbol = Symbol.for("vuetify:defaults");
function createDefaults(options) {
return ref(options);
}
function injectDefaults() {
const defaults = inject(DefaultsSymbol);
if (!defaults) throw new Error("[Vuetify] Could not find defaults instance");
return defaults;
}
function provideDefaults(defaults, options) {
const injectedDefaults = injectDefaults();
const providedDefaults = ref(defaults);
const newDefaults = computed(() => {
if (unref(options?.disabled)) return injectedDefaults.value;
const scoped = unref(options?.scoped);
const reset = unref(options?.reset);
const root = unref(options?.root);
if (providedDefaults.value == null && !(scoped || reset || root)) return injectedDefaults.value;
let properties = mergeDeep(providedDefaults.value, { prev: injectedDefaults.value });
if (scoped) return properties;
if (reset || root) {
const len = Number(reset || Infinity);
for (let i = 0; i <= len; i++) {
if (!properties || !("prev" in properties)) break;
properties = properties.prev;
}
if (properties && typeof root === "string" && root in properties) properties = mergeDeep(mergeDeep(properties, { prev: properties }), properties[root]);
return properties;
}
return properties.prev ? mergeDeep(properties.prev, properties, void 0, (_, v) => v !== void 0) : properties;
});
provide(DefaultsSymbol, newDefaults);
return newDefaults;
}
function propIsDefined(vnode, prop) {
return vnode.props && (typeof vnode.props[prop] !== "undefined" || typeof vnode.props[toKebabCase(prop)] !== "undefined");
}
function internalUseDefaults(props = {}, name, defaults = injectDefaults()) {
const vm = getCurrentInstance("useDefaults");
name = name ?? vm.type.name ?? vm.type.__name;
if (!name) throw new Error("[Vuetify] Could not determine component name");
const componentDefaults = computed(() => defaults.value?.[props._as ?? name]);
const _props = new Proxy(props, { get(target, prop) {
const propValue = Reflect.get(target, prop);
if (prop === "class" || prop === "style") return [componentDefaults.value?.[prop], propValue].filter((v) => v != null);
if (propIsDefined(vm.vnode, prop)) return propValue;
const _componentDefault = componentDefaults.value?.[prop];
if (_componentDefault !== void 0) return _componentDefault;
const _globalDefault = defaults.value?.global?.[prop];
if (_globalDefault !== void 0) return _globalDefault;
return propValue;
} });
const _subcomponentDefaults = shallowRef();
watchEffect(() => {
if (componentDefaults.value) {
const subComponents = Object.entries(componentDefaults.value).filter(([key]) => key.startsWith(key[0].toUpperCase()));
_subcomponentDefaults.value = subComponents.length ? Object.fromEntries(subComponents) : void 0;
} else _subcomponentDefaults.value = void 0;
});
function provideSubDefaults() {
const injected = injectSelf(DefaultsSymbol, vm);
provide(DefaultsSymbol, computed(() => {
return _subcomponentDefaults.value ? mergeDeep(injected?.value ?? {}, _subcomponentDefaults.value) : injected?.value;
}));
}
return {
props: _props,
provideSubDefaults
};
}
function useDefaults(props = {}, name) {
const { props: _props, provideSubDefaults } = internalUseDefaults(props, name);
provideSubDefaults();
return _props;
}
//#endregion
//#region node_modules/vuetify/lib/util/defineComponent.js
function defineComponent(options) {
options._setup = options._setup ?? options.setup;
if (!options.name) {
consoleWarn("The component is missing an explicit name, unable to generate default prop value");
return options;
}
if (options._setup) {
options.props = propsFactory(options.props ?? {}, options.name)();
const propKeys = Object.keys(options.props).filter((key) => key !== "class" && key !== "style");
options.filterProps = function filterProps(props) {
return pick(props, propKeys);
};
options.props._as = String;
options.setup = function setup(props, ctx) {
const defaults = injectDefaults();
if (!defaults.value) return options._setup(props, ctx);
const { props: _props, provideSubDefaults } = internalUseDefaults(props, props._as ?? options.name, defaults);
const setupBindings = options._setup(_props, ctx);
provideSubDefaults();
return setupBindings;
};
}
return options;
}
function genericComponent(exposeDefaults = true) {
return (options) => (exposeDefaults ? defineComponent : defineComponent$1)(options);
}
//#endregion
export { PREFERS_REDUCED_MOTION as $, getObjectValueByPath as A, matchesSelector as B, eventName as C, focusChild as D, flattenFragments as E, isClickInsideElement as F, padStart as G, omit as H, isObject as I, refElement as J, pick as K, isOn as L, has as M, hasEvent as N, focusableChildren as O, includes as P, IN_BROWSER as Q, isPrimitive as R, ensureValidVNode as S, findChildrenWithProvide as T, onlyDefinedProps as U, mergeDeep as V, padEnd as W, toKebabCase as X, templateRef as Y, wrapInArray as Z, convertToUnit as _, provideDefaults as a, deprecate as at, defer as b, getCurrentInstanceName as c, EventProp as d, SUPPORTS_INTERSECTION as et, callEvent as f, clamp as g, chunk as h, createDefaults as i, consoleWarn as it, getPropertyFromItem as j, getNextElement as k, propsFactory as l, checkPrintable as m, genericComponent as n, SUPPORTS_TOUCH as nt, useDefaults as o, camelizeProps as p, pickWithRest as q, DefaultsSymbol as r, consoleError as rt, getCurrentInstance as s, defineComponent as t, SUPPORTS_MATCH_MEDIA as tt, CircularBuffer as u, createRange as v, filterInputAttrs as w, destructComputed as x, debounce as y, keys as z };
//# sourceMappingURL=defineComponent-DB6xIcDy.js.map