@jskit-ai/assistant-core 0.1.165 → 0.1.166

package/examples/conversation/node_modules/.vite/deps/defineComponent-DK6LSjDW.js

@@ -0,0 +1,710 @@
+import { Fn as isProxy, In as isReactive, Kn as ref, M as Fragment, O as Comment, Qn as toRef, Rn as isRef, U as computed, Ut as provide, Wn as reactive, Yn as shallowRef, Zn as toRaw, _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-YcakWsDn.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);
+var SUPPORTS_EYE_DROPPER = 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
+});
+var keyValues = 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"
+];
+var compositionIgnoreKeys = [
+	"ArrowUp",
+	"ArrowDown",
+	"ArrowRight",
+	"ArrowLeft",
+	"Enter",
+	"Escape",
+	"Tab",
+	" "
+];
+function isComposingIgnoreKey(e) {
+	return e.isComposing && compositionIgnoreKeys.includes(e.key);
+}
+/**
+* Filter attributes that should be applied to
+* the root element of an input component. Remaining
+* attributes should be passed to the <input> 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 getDecimals(value) {
+	const trimmedStr = value.toString().trim();
+	return trimmedStr.includes(".") ? trimmedStr.length - trimmedStr.indexOf(".") - 1 : 0;
+}
+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 humanReadableFileSize(bytes, base = 1e3) {
+	if (bytes < base) return `${bytes} B`;
+	const prefix = base === 1024 ? [
+		"Ki",
+		"Mi",
+		"Gi"
+	] : [
+		"k",
+		"M",
+		"G"
+	];
+	let unit = -1;
+	while (Math.abs(bytes) >= base && unit < prefix.length - 1) {
+		bytes /= base;
+		++unit;
+	}
+	return `${bytes.toFixed(1)} ${prefix[unit]}B`;
+}
+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;
+	}
+};
+function getEventCoordinates(e) {
+	if ("touches" in e) return {
+		clientX: e.touches[0].clientX,
+		clientY: e.touches[0].clientY
+	};
+	return {
+		clientX: e.clientX,
+		clientY: e.clientY
+	};
+}
+/**
+* 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");
+	}
+}
+function isEmpty(val) {
+	return val === null || val === void 0 || typeof val === "string" && val.trim() === "";
+}
+function noop() {}
+/** 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 renderSlot(slot, props, fallback) {
+	return slot?.(props) ?? fallback?.(props);
+}
+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 escapeForRegex(sign) {
+	return "\\^$*+?.()|{}[]".includes(sign) ? `\\${sign}` : sign;
+}
+function extractNumber(text, decimalDigitsLimit, decimalSeparator) {
+	const onlyValidCharacters = new RegExp(`[\\d\\-${escapeForRegex(decimalSeparator)}]`);
+	const cleanText = text.split("").filter((x) => onlyValidCharacters.test(x)).filter((x, i, all) => i === 0 && /[-]/.test(x) || x === decimalSeparator && i === all.indexOf(x) || /\d/.test(x)).join("");
+	if (decimalDigitsLimit === 0) return cleanText.split(decimalSeparator)[0];
+	const decimalPart = new RegExp(`${escapeForRegex(decimalSeparator)}\\d`);
+	if (decimalDigitsLimit !== null && decimalPart.test(cleanText)) {
+		const parts = cleanText.split(decimalSeparator);
+		return [parts[0], parts[1].substring(0, decimalDigitsLimit)].join(decimalSeparator);
+	}
+	return cleanText;
+}
+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));
+}
+function deepToRaw(value) {
+	const objectIterator = (input) => {
+		if (Array.isArray(input)) return input.map((item) => objectIterator(item));
+		if (isRef(input) || isReactive(input) || isProxy(input)) return objectIterator(toRaw(input));
+		if (isPlainObject(input)) return Object.keys(input).reduce((acc, key) => {
+			acc[key] = objectIterator(input[key]);
+			return acc;
+		}, {});
+		return input;
+	};
+	return objectIterator(value);
+}
+//#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<keyof props, any>) => 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<T>` 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);
+}
+function defineFunctionalComponent(props, render) {
+	render.props = props;
+	return render;
+}
+//#endregion
+export { omit as $, flattenFragments as A, humanReadableFileSize as B, destructComputed as C, extractNumber as D, eventName as E, getNextElement as F, isObject as G, isClickInsideElement as H, getObjectValueByPath as I, keyValues as J, isOn as K, getPropertyFromItem as L, focusableChildren as M, getDecimals as N, filterInputAttrs as O, getEventCoordinates as P, noop as Q, has as R, defer as S, escapeForRegex as T, isComposingIgnoreKey as U, includes as V, isEmpty as W, matchesSelector as X, keys as Y, mergeDeep as Z, clamp as _, consoleWarn as _t, createDefaults as a, refElement as at, debounce as b, getCurrentInstance as c, toKebabCase as ct, CircularBuffer as d, PREFERS_REDUCED_MOTION as dt, onlyDefinedProps as et, EventProp as f, SUPPORTS_EYE_DROPPER as ft, chunk as g, consoleError as gt, checkPrintable as h, SUPPORTS_TOUCH as ht, DefaultsSymbol as i, pickWithRest as it, focusChild as j, findChildrenWithProvide as k, getCurrentInstanceName as l, wrapInArray as lt, camelizeProps as m, SUPPORTS_MATCH_MEDIA as mt, defineFunctionalComponent as n, padStart as nt, provideDefaults as o, renderSlot as ot, callEvent as p, SUPPORTS_INTERSECTION as pt, isPrimitive as q, genericComponent as r, pick as rt, useDefaults as s, templateRef as st, defineComponent as t, padEnd as tt, propsFactory as u, IN_BROWSER as ut, convertToUnit as v, deprecate as vt, ensureValidVNode as w, deepToRaw as x, createRange as y, hasEvent as z };