2327 lines
67 KiB
JavaScript
2327 lines
67 KiB
JavaScript
import {
|
|
Comment,
|
|
Fragment,
|
|
camelize,
|
|
capitalize,
|
|
computed,
|
|
defineComponent,
|
|
effectScope,
|
|
getCurrentInstance,
|
|
h,
|
|
inject,
|
|
isVNode,
|
|
onScopeDispose,
|
|
provide,
|
|
reactive,
|
|
ref,
|
|
shallowRef,
|
|
toRaw,
|
|
toRefs,
|
|
unref,
|
|
warn,
|
|
watch,
|
|
watchEffect
|
|
} from "./chunk-TF6X5W6F.js";
|
|
|
|
// node_modules/vuetify/lib/util/globals.mjs
|
|
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;
|
|
|
|
// node_modules/vuetify/lib/util/helpers.mjs
|
|
function _classPrivateFieldInitSpec(e, t, a) {
|
|
_checkPrivateRedeclaration(e, t), t.set(e, a);
|
|
}
|
|
function _checkPrivateRedeclaration(e, t) {
|
|
if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
|
|
}
|
|
function _classPrivateFieldSet(s, a, r) {
|
|
return s.set(_assertClassBrand(s, a), r), r;
|
|
}
|
|
function _classPrivateFieldGet(s, a) {
|
|
return s.get(_assertClassBrand(s, a));
|
|
}
|
|
function _assertClassBrand(e, t, n) {
|
|
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
|
|
throw new TypeError("Private element is not present on this object");
|
|
}
|
|
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 deepEqual(a, b) {
|
|
if (a === b) return true;
|
|
if (a instanceof Date && b instanceof Date && a.getTime() !== b.getTime()) {
|
|
return false;
|
|
}
|
|
if (a !== Object(a) || b !== Object(b)) {
|
|
return false;
|
|
}
|
|
const props = Object.keys(a);
|
|
if (props.length !== Object.keys(b).length) {
|
|
return false;
|
|
}
|
|
return props.every((p) => deepEqual(a[p], b[p]));
|
|
}
|
|
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 value2 = property(item, fallback);
|
|
return typeof value2 === "undefined" ? fallback : value2;
|
|
}
|
|
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) {
|
|
let start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
|
|
return Array.from({
|
|
length
|
|
}, (v, k) => start + k);
|
|
}
|
|
function convertToUnit(str) {
|
|
let unit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "px";
|
|
if (str == null || str === "") {
|
|
return void 0;
|
|
} else if (isNaN(+str)) {
|
|
return String(str);
|
|
} else if (!isFinite(+str)) {
|
|
return void 0;
|
|
} else {
|
|
return `${Number(str)}${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 == null ? void 0 : el.nodeType) === Node.TEXT_NODE) {
|
|
return el.nextElementSibling;
|
|
}
|
|
return el;
|
|
}
|
|
return obj;
|
|
}
|
|
var keyCodes = 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.hasOwn(obj, key)) {
|
|
found[key] = obj[key];
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
function pickWithRest(obj, paths, exclude) {
|
|
const found = /* @__PURE__ */ Object.create(null);
|
|
const rest = /* @__PURE__ */ Object.create(null);
|
|
for (const key in obj) {
|
|
if (paths.some((path) => path instanceof RegExp ? path.test(key) : path === key) && !(exclude == null ? void 0 : 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);
|
|
}
|
|
function filterInputAttrs(attrs) {
|
|
const [events, props] = pickWithRest(attrs, [onRE]);
|
|
const inputEvents = omit(events, bubblingEvents);
|
|
const [rootAttrs, inputAttrs] = pickWithRest(props, ["class", "style", "id", /^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 = function() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
clearTimeout(timeoutId);
|
|
timeoutId = setTimeout(() => fn(...args), unref(delay));
|
|
};
|
|
wrap.clear = () => {
|
|
clearTimeout(timeoutId);
|
|
};
|
|
wrap.immediate = fn;
|
|
return wrap;
|
|
}
|
|
function clamp(value) {
|
|
let min = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
|
|
let max = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 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) {
|
|
let char = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "0";
|
|
return str + char.repeat(Math.max(0, length - str.length));
|
|
}
|
|
function padStart(str, length) {
|
|
let char = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "0";
|
|
return char.repeat(Math.max(0, length - str.length)) + str;
|
|
}
|
|
function chunk(str) {
|
|
let size = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
|
|
const chunked = [];
|
|
let index = 0;
|
|
while (index < str.length) {
|
|
chunked.push(str.substr(index, size));
|
|
index += size;
|
|
}
|
|
return chunked;
|
|
}
|
|
function humanReadableFileSize(bytes) {
|
|
let base = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 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() {
|
|
let source = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
|
let target = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
|
|
let arrayFn = arguments.length > 2 ? arguments[2] : void 0;
|
|
const out = {};
|
|
for (const key in source) {
|
|
out[key] = source[key];
|
|
}
|
|
for (const key in target) {
|
|
const sourceProperty = source[key];
|
|
const targetProperty = target[key];
|
|
if (isPlainObject(sourceProperty) && isPlainObject(targetProperty)) {
|
|
out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn);
|
|
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() {
|
|
let str = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
|
|
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.getOwnPropertySymbols(vnode.component.provides).includes(key)) {
|
|
return [vnode.component];
|
|
} else if (vnode.component.subTree) {
|
|
return findChildrenWithProvide(key, vnode.component.subTree).flat(1);
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
var _arr = /* @__PURE__ */ new WeakMap();
|
|
var _pointer = /* @__PURE__ */ new WeakMap();
|
|
var CircularBuffer = class {
|
|
constructor(size) {
|
|
_classPrivateFieldInitSpec(this, _arr, []);
|
|
_classPrivateFieldInitSpec(this, _pointer, 0);
|
|
this.size = size;
|
|
}
|
|
push(val) {
|
|
_classPrivateFieldGet(_arr, this)[_classPrivateFieldGet(_pointer, this)] = val;
|
|
_classPrivateFieldSet(_pointer, this, (_classPrivateFieldGet(_pointer, this) + 1) % this.size);
|
|
}
|
|
values() {
|
|
return _classPrivateFieldGet(_arr, this).slice(_classPrivateFieldGet(_pointer, this)).concat(_classPrivateFieldGet(_arr, this).slice(0, _classPrivateFieldGet(_pointer, this)));
|
|
}
|
|
};
|
|
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
|
|
};
|
|
}
|
|
function destructComputed(getter) {
|
|
const refs = reactive({});
|
|
const base = computed(getter);
|
|
watchEffect(() => {
|
|
for (const key in base.value) {
|
|
refs[key] = base.value[key];
|
|
}
|
|
}, {
|
|
flush: "sync"
|
|
});
|
|
return toRefs(refs);
|
|
}
|
|
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) {
|
|
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
args[_key2 - 1] = arguments[_key2];
|
|
}
|
|
if (Array.isArray(handler)) {
|
|
for (const h2 of handler) {
|
|
h2(...args);
|
|
}
|
|
} else if (typeof handler === "function") {
|
|
handler(...args);
|
|
}
|
|
}
|
|
function focusableChildren(el) {
|
|
let filterByTabIndex = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
|
|
const targets = ["button", "[href]", 'input:not([type="hidden"])', "select", "textarea", "[tabindex]"].map((s) => `${s}${filterByTabIndex ? ':not([tabindex="-1"])' : ""}:not([disabled])`).join(", ");
|
|
return [...el.querySelectorAll(targets)];
|
|
}
|
|
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 == null ? void 0 : condition(_el)) ?? true)) && idx < elements.length && idx >= 0);
|
|
return _el;
|
|
}
|
|
function focusChild(el, location) {
|
|
var _a, _b, _c, _d;
|
|
const focusable = focusableChildren(el);
|
|
if (!location) {
|
|
if (el === document.activeElement || !el.contains(document.activeElement)) {
|
|
(_a = focusable[0]) == null ? void 0 : _a.focus();
|
|
}
|
|
} else if (location === "first") {
|
|
(_b = focusable[0]) == null ? void 0 : _b.focus();
|
|
} else if (location === "last") {
|
|
(_c = focusable.at(-1)) == null ? void 0 : _c.focus();
|
|
} else if (typeof location === "number") {
|
|
(_d = focusable[location]) == null ? void 0 : _d.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() {
|
|
}
|
|
function matchesSelector(el, selector) {
|
|
const supportsSelector = IN_BROWSER && typeof CSS !== "undefined" && typeof CSS.supports !== "undefined" && CSS.supports(`selector(${selector})`);
|
|
if (!supportsSelector) 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";
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/getCurrentInstance.mjs
|
|
function getCurrentInstance2(name, message) {
|
|
const vm = getCurrentInstance();
|
|
if (!vm) {
|
|
throw new Error(`[Vuetify] ${name} ${message || "must be called from inside a setup function"}`);
|
|
}
|
|
return vm;
|
|
}
|
|
function getCurrentInstanceName() {
|
|
let name = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "composables";
|
|
const vm = getCurrentInstance2(name).type;
|
|
return toKebabCase((vm == null ? void 0 : vm.aliasName) || (vm == null ? void 0 : vm.name));
|
|
}
|
|
var _uid = 0;
|
|
var _map = /* @__PURE__ */ new WeakMap();
|
|
function getUid() {
|
|
const vm = getCurrentInstance2("getUid");
|
|
if (_map.has(vm)) return _map.get(vm);
|
|
else {
|
|
const uid = _uid++;
|
|
_map.set(vm, uid);
|
|
return uid;
|
|
}
|
|
}
|
|
getUid.reset = () => {
|
|
_uid = 0;
|
|
_map = /* @__PURE__ */ new WeakMap();
|
|
};
|
|
|
|
// node_modules/vuetify/lib/util/injectSelf.mjs
|
|
function injectSelf(key) {
|
|
let vm = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstance2("injectSelf");
|
|
const {
|
|
provides
|
|
} = vm;
|
|
if (provides && key in provides) {
|
|
return provides[key];
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/defaults.mjs
|
|
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(() => {
|
|
const disabled = unref(options == null ? void 0 : options.disabled);
|
|
if (disabled) return injectedDefaults.value;
|
|
const scoped = unref(options == null ? void 0 : options.scoped);
|
|
const reset = unref(options == null ? void 0 : options.reset);
|
|
const root = unref(options == null ? void 0 : 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) : properties;
|
|
});
|
|
provide(DefaultsSymbol, newDefaults);
|
|
return newDefaults;
|
|
}
|
|
function propIsDefined(vnode, prop) {
|
|
var _a, _b;
|
|
return typeof ((_a = vnode.props) == null ? void 0 : _a[prop]) !== "undefined" || typeof ((_b = vnode.props) == null ? void 0 : _b[toKebabCase(prop)]) !== "undefined";
|
|
}
|
|
function internalUseDefaults() {
|
|
let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
|
let name = arguments.length > 1 ? arguments[1] : void 0;
|
|
let defaults = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : injectDefaults();
|
|
const vm = getCurrentInstance2("useDefaults");
|
|
name = name ?? vm.type.name ?? vm.type.__name;
|
|
if (!name) {
|
|
throw new Error("[Vuetify] Could not determine component name");
|
|
}
|
|
const componentDefaults = computed(() => {
|
|
var _a;
|
|
return (_a = defaults.value) == null ? void 0 : _a[props._as ?? name];
|
|
});
|
|
const _props = new Proxy(props, {
|
|
get(target, prop) {
|
|
var _a, _b, _c, _d, _e, _f, _g;
|
|
const propValue = Reflect.get(target, prop);
|
|
if (prop === "class" || prop === "style") {
|
|
return [(_a = componentDefaults.value) == null ? void 0 : _a[prop], propValue].filter((v) => v != null);
|
|
} else if (typeof prop === "string" && !propIsDefined(vm.vnode, prop)) {
|
|
return ((_b = componentDefaults.value) == null ? void 0 : _b[prop]) !== void 0 ? (_c = componentDefaults.value) == null ? void 0 : _c[prop] : ((_e = (_d = defaults.value) == null ? void 0 : _d.global) == null ? void 0 : _e[prop]) !== void 0 ? (_g = (_f = defaults.value) == null ? void 0 : _f.global) == null ? void 0 : _g[prop] : propValue;
|
|
}
|
|
return propValue;
|
|
}
|
|
});
|
|
const _subcomponentDefaults = shallowRef();
|
|
watchEffect(() => {
|
|
if (componentDefaults.value) {
|
|
const subComponents = Object.entries(componentDefaults.value).filter((_ref) => {
|
|
let [key] = _ref;
|
|
return 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 == null ? void 0 : injected.value) ?? {}, _subcomponentDefaults.value) : injected == null ? void 0 : injected.value;
|
|
}));
|
|
}
|
|
return {
|
|
props: _props,
|
|
provideSubDefaults
|
|
};
|
|
}
|
|
function useDefaults() {
|
|
let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
|
|
let name = arguments.length > 1 ? arguments[1] : void 0;
|
|
const {
|
|
props: _props,
|
|
provideSubDefaults
|
|
} = internalUseDefaults(props, name);
|
|
provideSubDefaults();
|
|
return _props;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/console.mjs
|
|
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.`);
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/propsFactory.mjs
|
|
function propsFactory(props, source) {
|
|
return (defaults) => {
|
|
return Object.keys(props).reduce((obj, prop) => {
|
|
const isObjectDefinition = typeof props[prop] === "object" && props[prop] != null && !Array.isArray(props[prop]);
|
|
const definition = isObjectDefinition ? 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;
|
|
}, {});
|
|
};
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/defineComponent.mjs
|
|
function defineComponent2(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() {
|
|
let exposeDefaults = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
|
|
return (options) => (exposeDefaults ? defineComponent2 : defineComponent)(options);
|
|
}
|
|
function defineFunctionalComponent(props, render) {
|
|
render.props = props;
|
|
return render;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/anchor.mjs
|
|
var block = ["top", "bottom"];
|
|
var inline = ["start", "end", "left", "right"];
|
|
function parseAnchor(anchor, isRtl) {
|
|
let [side, align] = anchor.split(" ");
|
|
if (!align) {
|
|
align = includes(block, side) ? "start" : includes(inline, side) ? "top" : "center";
|
|
}
|
|
return {
|
|
side: toPhysical(side, isRtl),
|
|
align: toPhysical(align, isRtl)
|
|
};
|
|
}
|
|
function toPhysical(str, isRtl) {
|
|
if (str === "start") return isRtl ? "right" : "left";
|
|
if (str === "end") return isRtl ? "left" : "right";
|
|
return str;
|
|
}
|
|
function flipSide(anchor) {
|
|
return {
|
|
side: {
|
|
center: "center",
|
|
top: "bottom",
|
|
bottom: "top",
|
|
left: "right",
|
|
right: "left"
|
|
}[anchor.side],
|
|
align: anchor.align
|
|
};
|
|
}
|
|
function flipAlign(anchor) {
|
|
return {
|
|
side: anchor.side,
|
|
align: {
|
|
center: "center",
|
|
top: "bottom",
|
|
bottom: "top",
|
|
left: "right",
|
|
right: "left"
|
|
}[anchor.align]
|
|
};
|
|
}
|
|
function flipCorner(anchor) {
|
|
return {
|
|
side: anchor.align,
|
|
align: anchor.side
|
|
};
|
|
}
|
|
function getAxis(anchor) {
|
|
return includes(block, anchor.side) ? "y" : "x";
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/box.mjs
|
|
var Box = class {
|
|
constructor(_ref) {
|
|
let {
|
|
x,
|
|
y,
|
|
width,
|
|
height
|
|
} = _ref;
|
|
this.x = x;
|
|
this.y = y;
|
|
this.width = width;
|
|
this.height = height;
|
|
}
|
|
get top() {
|
|
return this.y;
|
|
}
|
|
get bottom() {
|
|
return this.y + this.height;
|
|
}
|
|
get left() {
|
|
return this.x;
|
|
}
|
|
get right() {
|
|
return this.x + this.width;
|
|
}
|
|
};
|
|
function getOverflow(a, b) {
|
|
return {
|
|
x: {
|
|
before: Math.max(0, b.left - a.left),
|
|
after: Math.max(0, a.right - b.right)
|
|
},
|
|
y: {
|
|
before: Math.max(0, b.top - a.top),
|
|
after: Math.max(0, a.bottom - b.bottom)
|
|
}
|
|
};
|
|
}
|
|
function getTargetBox(target) {
|
|
if (Array.isArray(target)) {
|
|
return new Box({
|
|
x: target[0],
|
|
y: target[1],
|
|
width: 0,
|
|
height: 0
|
|
});
|
|
} else {
|
|
return target.getBoundingClientRect();
|
|
}
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/animation.mjs
|
|
function nullifyTransforms(el) {
|
|
const rect = el.getBoundingClientRect();
|
|
const style = getComputedStyle(el);
|
|
const tx = style.transform;
|
|
if (tx) {
|
|
let ta, sx, sy, dx, dy;
|
|
if (tx.startsWith("matrix3d(")) {
|
|
ta = tx.slice(9, -1).split(/, /);
|
|
sx = +ta[0];
|
|
sy = +ta[5];
|
|
dx = +ta[12];
|
|
dy = +ta[13];
|
|
} else if (tx.startsWith("matrix(")) {
|
|
ta = tx.slice(7, -1).split(/, /);
|
|
sx = +ta[0];
|
|
sy = +ta[3];
|
|
dx = +ta[4];
|
|
dy = +ta[5];
|
|
} else {
|
|
return new Box(rect);
|
|
}
|
|
const to = style.transformOrigin;
|
|
const x = rect.x - dx - (1 - sx) * parseFloat(to);
|
|
const y = rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(" ") + 1));
|
|
const w = sx ? rect.width / sx : el.offsetWidth + 1;
|
|
const h2 = sy ? rect.height / sy : el.offsetHeight + 1;
|
|
return new Box({
|
|
x,
|
|
y,
|
|
width: w,
|
|
height: h2
|
|
});
|
|
} else {
|
|
return new Box(rect);
|
|
}
|
|
}
|
|
function animate(el, keyframes, options) {
|
|
if (typeof el.animate === "undefined") return {
|
|
finished: Promise.resolve()
|
|
};
|
|
let animation;
|
|
try {
|
|
animation = el.animate(keyframes, options);
|
|
} catch (err) {
|
|
return {
|
|
finished: Promise.resolve()
|
|
};
|
|
}
|
|
if (typeof animation.finished === "undefined") {
|
|
animation.finished = new Promise((resolve) => {
|
|
animation.onfinish = () => {
|
|
resolve(animation);
|
|
};
|
|
});
|
|
}
|
|
return animation;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/bindProps.mjs
|
|
var handlers = /* @__PURE__ */ new WeakMap();
|
|
function bindProps(el, props) {
|
|
Object.keys(props).forEach((k) => {
|
|
var _a;
|
|
if (isOn(k)) {
|
|
const name = eventName(k);
|
|
const handler = handlers.get(el);
|
|
if (props[k] == null) {
|
|
handler == null ? void 0 : handler.forEach((v) => {
|
|
const [n, fn] = v;
|
|
if (n === name) {
|
|
el.removeEventListener(name, fn);
|
|
handler.delete(v);
|
|
}
|
|
});
|
|
} else if (!handler || !((_a = [...handler]) == null ? void 0 : _a.some((v) => v[0] === name && v[1] === props[k]))) {
|
|
el.addEventListener(name, props[k]);
|
|
const _handler = handler || /* @__PURE__ */ new Set();
|
|
_handler.add([name, props[k]]);
|
|
if (!handlers.has(el)) handlers.set(el, _handler);
|
|
}
|
|
} else {
|
|
if (props[k] == null) {
|
|
el.removeAttribute(k);
|
|
} else {
|
|
el.setAttribute(k, props[k]);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function unbindProps(el, props) {
|
|
Object.keys(props).forEach((k) => {
|
|
if (isOn(k)) {
|
|
const name = eventName(k);
|
|
const handler = handlers.get(el);
|
|
handler == null ? void 0 : handler.forEach((v) => {
|
|
const [n, fn] = v;
|
|
if (n === name) {
|
|
el.removeEventListener(name, fn);
|
|
handler.delete(v);
|
|
}
|
|
});
|
|
} else {
|
|
el.removeAttribute(k);
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/color/APCA.mjs
|
|
var mainTRC = 2.4;
|
|
var Rco = 0.2126729;
|
|
var Gco = 0.7151522;
|
|
var Bco = 0.072175;
|
|
var normBG = 0.55;
|
|
var normTXT = 0.58;
|
|
var revTXT = 0.57;
|
|
var revBG = 0.62;
|
|
var blkThrs = 0.03;
|
|
var blkClmp = 1.45;
|
|
var deltaYmin = 5e-4;
|
|
var scaleBoW = 1.25;
|
|
var scaleWoB = 1.25;
|
|
var loConThresh = 0.078;
|
|
var loConFactor = 12.82051282051282;
|
|
var loConOffset = 0.06;
|
|
var loClip = 1e-3;
|
|
function APCAcontrast(text, background) {
|
|
const Rtxt = (text.r / 255) ** mainTRC;
|
|
const Gtxt = (text.g / 255) ** mainTRC;
|
|
const Btxt = (text.b / 255) ** mainTRC;
|
|
const Rbg = (background.r / 255) ** mainTRC;
|
|
const Gbg = (background.g / 255) ** mainTRC;
|
|
const Bbg = (background.b / 255) ** mainTRC;
|
|
let Ytxt = Rtxt * Rco + Gtxt * Gco + Btxt * Bco;
|
|
let Ybg = Rbg * Rco + Gbg * Gco + Bbg * Bco;
|
|
if (Ytxt <= blkThrs) Ytxt += (blkThrs - Ytxt) ** blkClmp;
|
|
if (Ybg <= blkThrs) Ybg += (blkThrs - Ybg) ** blkClmp;
|
|
if (Math.abs(Ybg - Ytxt) < deltaYmin) return 0;
|
|
let outputContrast;
|
|
if (Ybg > Ytxt) {
|
|
const SAPC = (Ybg ** normBG - Ytxt ** normTXT) * scaleBoW;
|
|
outputContrast = SAPC < loClip ? 0 : SAPC < loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC - loConOffset;
|
|
} else {
|
|
const SAPC = (Ybg ** revBG - Ytxt ** revTXT) * scaleWoB;
|
|
outputContrast = SAPC > -loClip ? 0 : SAPC > -loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC + loConOffset;
|
|
}
|
|
return outputContrast * 100;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/color/transformCIELAB.mjs
|
|
var delta = 0.20689655172413793;
|
|
var cielabForwardTransform = (t) => t > delta ** 3 ? Math.cbrt(t) : t / (3 * delta ** 2) + 4 / 29;
|
|
var cielabReverseTransform = (t) => t > delta ? t ** 3 : 3 * delta ** 2 * (t - 4 / 29);
|
|
function fromXYZ(xyz) {
|
|
const transform = cielabForwardTransform;
|
|
const transformedY = transform(xyz[1]);
|
|
return [116 * transformedY - 16, 500 * (transform(xyz[0] / 0.95047) - transformedY), 200 * (transformedY - transform(xyz[2] / 1.08883))];
|
|
}
|
|
function toXYZ(lab) {
|
|
const transform = cielabReverseTransform;
|
|
const Ln = (lab[0] + 16) / 116;
|
|
return [transform(Ln + lab[1] / 500) * 0.95047, transform(Ln), transform(Ln - lab[2] / 200) * 1.08883];
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/color/transformSRGB.mjs
|
|
var srgbForwardMatrix = [[3.2406, -1.5372, -0.4986], [-0.9689, 1.8758, 0.0415], [0.0557, -0.204, 1.057]];
|
|
var srgbForwardTransform = (C) => C <= 31308e-7 ? C * 12.92 : 1.055 * C ** (1 / 2.4) - 0.055;
|
|
var srgbReverseMatrix = [[0.4124, 0.3576, 0.1805], [0.2126, 0.7152, 0.0722], [0.0193, 0.1192, 0.9505]];
|
|
var srgbReverseTransform = (C) => C <= 0.04045 ? C / 12.92 : ((C + 0.055) / 1.055) ** 2.4;
|
|
function fromXYZ2(xyz) {
|
|
const rgb = Array(3);
|
|
const transform = srgbForwardTransform;
|
|
const matrix = srgbForwardMatrix;
|
|
for (let i = 0; i < 3; ++i) {
|
|
rgb[i] = Math.round(clamp(transform(matrix[i][0] * xyz[0] + matrix[i][1] * xyz[1] + matrix[i][2] * xyz[2])) * 255);
|
|
}
|
|
return {
|
|
r: rgb[0],
|
|
g: rgb[1],
|
|
b: rgb[2]
|
|
};
|
|
}
|
|
function toXYZ2(_ref) {
|
|
let {
|
|
r,
|
|
g,
|
|
b
|
|
} = _ref;
|
|
const xyz = [0, 0, 0];
|
|
const transform = srgbReverseTransform;
|
|
const matrix = srgbReverseMatrix;
|
|
r = transform(r / 255);
|
|
g = transform(g / 255);
|
|
b = transform(b / 255);
|
|
for (let i = 0; i < 3; ++i) {
|
|
xyz[i] = matrix[i][0] * r + matrix[i][1] * g + matrix[i][2] * b;
|
|
}
|
|
return xyz;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/colorUtils.mjs
|
|
function isCssColor(color) {
|
|
return !!color && /^(#|var\(--|(rgb|hsl)a?\()/.test(color);
|
|
}
|
|
function isParsableColor(color) {
|
|
return isCssColor(color) && !/^((rgb|hsl)a?\()?var\(--/.test(color);
|
|
}
|
|
var cssColorRe = /^(?<fn>(?:rgb|hsl)a?)\((?<values>.+)\)/;
|
|
var mappers = {
|
|
rgb: (r, g, b, a) => ({
|
|
r,
|
|
g,
|
|
b,
|
|
a
|
|
}),
|
|
rgba: (r, g, b, a) => ({
|
|
r,
|
|
g,
|
|
b,
|
|
a
|
|
}),
|
|
hsl: (h2, s, l, a) => HSLtoRGB({
|
|
h: h2,
|
|
s,
|
|
l,
|
|
a
|
|
}),
|
|
hsla: (h2, s, l, a) => HSLtoRGB({
|
|
h: h2,
|
|
s,
|
|
l,
|
|
a
|
|
}),
|
|
hsv: (h2, s, v, a) => HSVtoRGB({
|
|
h: h2,
|
|
s,
|
|
v,
|
|
a
|
|
}),
|
|
hsva: (h2, s, v, a) => HSVtoRGB({
|
|
h: h2,
|
|
s,
|
|
v,
|
|
a
|
|
})
|
|
};
|
|
function parseColor(color) {
|
|
if (typeof color === "number") {
|
|
if (isNaN(color) || color < 0 || color > 16777215) {
|
|
consoleWarn(`'${color}' is not a valid hex color`);
|
|
}
|
|
return {
|
|
r: (color & 16711680) >> 16,
|
|
g: (color & 65280) >> 8,
|
|
b: color & 255
|
|
};
|
|
} else if (typeof color === "string" && cssColorRe.test(color)) {
|
|
const {
|
|
groups
|
|
} = color.match(cssColorRe);
|
|
const {
|
|
fn,
|
|
values
|
|
} = groups;
|
|
const realValues = values.split(/,\s*/).map((v) => {
|
|
if (v.endsWith("%") && ["hsl", "hsla", "hsv", "hsva"].includes(fn)) {
|
|
return parseFloat(v) / 100;
|
|
} else {
|
|
return parseFloat(v);
|
|
}
|
|
});
|
|
return mappers[fn](...realValues);
|
|
} else if (typeof color === "string") {
|
|
let hex = color.startsWith("#") ? color.slice(1) : color;
|
|
if ([3, 4].includes(hex.length)) {
|
|
hex = hex.split("").map((char) => char + char).join("");
|
|
} else if (![6, 8].includes(hex.length)) {
|
|
consoleWarn(`'${color}' is not a valid hex(a) color`);
|
|
}
|
|
const int = parseInt(hex, 16);
|
|
if (isNaN(int) || int < 0 || int > 4294967295) {
|
|
consoleWarn(`'${color}' is not a valid hex(a) color`);
|
|
}
|
|
return HexToRGB(hex);
|
|
} else if (typeof color === "object") {
|
|
if (has(color, ["r", "g", "b"])) {
|
|
return color;
|
|
} else if (has(color, ["h", "s", "l"])) {
|
|
return HSVtoRGB(HSLtoHSV(color));
|
|
} else if (has(color, ["h", "s", "v"])) {
|
|
return HSVtoRGB(color);
|
|
}
|
|
}
|
|
throw new TypeError(`Invalid color: ${color == null ? color : String(color) || color.constructor.name}
|
|
Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
|
|
}
|
|
function HSVtoRGB(hsva) {
|
|
const {
|
|
h: h2,
|
|
s,
|
|
v,
|
|
a
|
|
} = hsva;
|
|
const f = (n) => {
|
|
const k = (n + h2 / 60) % 6;
|
|
return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
|
|
};
|
|
const rgb = [f(5), f(3), f(1)].map((v2) => Math.round(v2 * 255));
|
|
return {
|
|
r: rgb[0],
|
|
g: rgb[1],
|
|
b: rgb[2],
|
|
a
|
|
};
|
|
}
|
|
function HSLtoRGB(hsla) {
|
|
return HSVtoRGB(HSLtoHSV(hsla));
|
|
}
|
|
function RGBtoHSV(rgba) {
|
|
if (!rgba) return {
|
|
h: 0,
|
|
s: 1,
|
|
v: 1,
|
|
a: 1
|
|
};
|
|
const r = rgba.r / 255;
|
|
const g = rgba.g / 255;
|
|
const b = rgba.b / 255;
|
|
const max = Math.max(r, g, b);
|
|
const min = Math.min(r, g, b);
|
|
let h2 = 0;
|
|
if (max !== min) {
|
|
if (max === r) {
|
|
h2 = 60 * (0 + (g - b) / (max - min));
|
|
} else if (max === g) {
|
|
h2 = 60 * (2 + (b - r) / (max - min));
|
|
} else if (max === b) {
|
|
h2 = 60 * (4 + (r - g) / (max - min));
|
|
}
|
|
}
|
|
if (h2 < 0) h2 = h2 + 360;
|
|
const s = max === 0 ? 0 : (max - min) / max;
|
|
const hsv = [h2, s, max];
|
|
return {
|
|
h: hsv[0],
|
|
s: hsv[1],
|
|
v: hsv[2],
|
|
a: rgba.a
|
|
};
|
|
}
|
|
function HSVtoHSL(hsva) {
|
|
const {
|
|
h: h2,
|
|
s,
|
|
v,
|
|
a
|
|
} = hsva;
|
|
const l = v - v * s / 2;
|
|
const sprime = l === 1 || l === 0 ? 0 : (v - l) / Math.min(l, 1 - l);
|
|
return {
|
|
h: h2,
|
|
s: sprime,
|
|
l,
|
|
a
|
|
};
|
|
}
|
|
function HSLtoHSV(hsl) {
|
|
const {
|
|
h: h2,
|
|
s,
|
|
l,
|
|
a
|
|
} = hsl;
|
|
const v = l + s * Math.min(l, 1 - l);
|
|
const sprime = v === 0 ? 0 : 2 - 2 * l / v;
|
|
return {
|
|
h: h2,
|
|
s: sprime,
|
|
v,
|
|
a
|
|
};
|
|
}
|
|
function RGBtoCSS(_ref) {
|
|
let {
|
|
r,
|
|
g,
|
|
b,
|
|
a
|
|
} = _ref;
|
|
return a === void 0 ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${a})`;
|
|
}
|
|
function HSVtoCSS(hsva) {
|
|
return RGBtoCSS(HSVtoRGB(hsva));
|
|
}
|
|
function toHex(v) {
|
|
const h2 = Math.round(v).toString(16);
|
|
return ("00".substr(0, 2 - h2.length) + h2).toUpperCase();
|
|
}
|
|
function RGBtoHex(_ref2) {
|
|
let {
|
|
r,
|
|
g,
|
|
b,
|
|
a
|
|
} = _ref2;
|
|
return `#${[toHex(r), toHex(g), toHex(b), a !== void 0 ? toHex(Math.round(a * 255)) : ""].join("")}`;
|
|
}
|
|
function HexToRGB(hex) {
|
|
hex = parseHex(hex);
|
|
let [r, g, b, a] = chunk(hex, 2).map((c) => parseInt(c, 16));
|
|
a = a === void 0 ? a : a / 255;
|
|
return {
|
|
r,
|
|
g,
|
|
b,
|
|
a
|
|
};
|
|
}
|
|
function HexToHSV(hex) {
|
|
const rgb = HexToRGB(hex);
|
|
return RGBtoHSV(rgb);
|
|
}
|
|
function HSVtoHex(hsva) {
|
|
return RGBtoHex(HSVtoRGB(hsva));
|
|
}
|
|
function parseHex(hex) {
|
|
if (hex.startsWith("#")) {
|
|
hex = hex.slice(1);
|
|
}
|
|
hex = hex.replace(/([^0-9a-f])/gi, "F");
|
|
if (hex.length === 3 || hex.length === 4) {
|
|
hex = hex.split("").map((x) => x + x).join("");
|
|
}
|
|
if (hex.length !== 6) {
|
|
hex = padEnd(padEnd(hex, 6), 8, "F");
|
|
}
|
|
return hex;
|
|
}
|
|
function lighten(value, amount) {
|
|
const lab = fromXYZ(toXYZ2(value));
|
|
lab[0] = lab[0] + amount * 10;
|
|
return fromXYZ2(toXYZ(lab));
|
|
}
|
|
function darken(value, amount) {
|
|
const lab = fromXYZ(toXYZ2(value));
|
|
lab[0] = lab[0] - amount * 10;
|
|
return fromXYZ2(toXYZ(lab));
|
|
}
|
|
function getLuma(color) {
|
|
const rgb = parseColor(color);
|
|
return toXYZ2(rgb)[1];
|
|
}
|
|
function getContrast(first, second) {
|
|
const l1 = getLuma(first);
|
|
const l2 = getLuma(second);
|
|
const light = Math.max(l1, l2);
|
|
const dark = Math.min(l1, l2);
|
|
return (light + 0.05) / (dark + 0.05);
|
|
}
|
|
function getForeground(color) {
|
|
const blackContrast = Math.abs(APCAcontrast(parseColor(0), parseColor(color)));
|
|
const whiteContrast = Math.abs(APCAcontrast(parseColor(16777215), parseColor(color)));
|
|
return whiteContrast > Math.min(blackContrast, 50) ? "#fff" : "#000";
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/component.mjs
|
|
var makeComponentProps = propsFactory({
|
|
class: [String, Array, Object],
|
|
style: {
|
|
type: [String, Array, Object],
|
|
default: null
|
|
}
|
|
}, "component");
|
|
|
|
// node_modules/vuetify/lib/util/createSimpleFunctional.mjs
|
|
function createSimpleFunctional(klass) {
|
|
let tag = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "div";
|
|
let name = arguments.length > 2 ? arguments[2] : void 0;
|
|
return genericComponent()({
|
|
name: name ?? capitalize(camelize(klass.replace(/__/g, "-"))),
|
|
props: {
|
|
tag: {
|
|
type: String,
|
|
default: tag
|
|
},
|
|
...makeComponentProps()
|
|
},
|
|
setup(props, _ref) {
|
|
let {
|
|
slots
|
|
} = _ref;
|
|
return () => {
|
|
var _a;
|
|
return h(props.tag, {
|
|
class: [klass, props.class],
|
|
style: props.style
|
|
}, (_a = slots.default) == null ? void 0 : _a.call(slots));
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/dom.mjs
|
|
function attachedRoot(node) {
|
|
if (typeof node.getRootNode !== "function") {
|
|
while (node.parentNode) node = node.parentNode;
|
|
if (node !== document) return null;
|
|
return document;
|
|
}
|
|
const root = node.getRootNode();
|
|
if (root !== document && root.getRootNode({
|
|
composed: true
|
|
}) !== document) return null;
|
|
return root;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/easing.mjs
|
|
var standardEasing = "cubic-bezier(0.4, 0, 0.2, 1)";
|
|
var deceleratedEasing = "cubic-bezier(0.0, 0, 0.2, 1)";
|
|
var acceleratedEasing = "cubic-bezier(0.4, 0, 1, 1)";
|
|
|
|
// node_modules/vuetify/lib/util/events.mjs
|
|
function getPrefixedEventHandlers(attrs, suffix, getData) {
|
|
return Object.keys(attrs).filter((key) => isOn(key) && key.endsWith(suffix)).reduce((acc, key) => {
|
|
acc[key.slice(0, -suffix.length)] = (event) => attrs[key](event, getData(event));
|
|
return acc;
|
|
}, {});
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/getScrollParent.mjs
|
|
function getScrollParent(el) {
|
|
let includeHidden = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
|
|
while (el) {
|
|
if (includeHidden ? isPotentiallyScrollable(el) : hasScrollbar(el)) return el;
|
|
el = el.parentElement;
|
|
}
|
|
return document.scrollingElement;
|
|
}
|
|
function getScrollParents(el, stopAt) {
|
|
const elements = [];
|
|
if (stopAt && el && !stopAt.contains(el)) return elements;
|
|
while (el) {
|
|
if (hasScrollbar(el)) elements.push(el);
|
|
if (el === stopAt) break;
|
|
el = el.parentElement;
|
|
}
|
|
return elements;
|
|
}
|
|
function hasScrollbar(el) {
|
|
if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
|
|
const style = window.getComputedStyle(el);
|
|
return style.overflowY === "scroll" || style.overflowY === "auto" && el.scrollHeight > el.clientHeight;
|
|
}
|
|
function isPotentiallyScrollable(el) {
|
|
if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
|
|
const style = window.getComputedStyle(el);
|
|
return ["scroll", "auto"].includes(style.overflowY);
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/isFixedPosition.mjs
|
|
function isFixedPosition(el) {
|
|
while (el) {
|
|
if (window.getComputedStyle(el).position === "fixed") {
|
|
return true;
|
|
}
|
|
el = el.offsetParent;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/util/useRender.mjs
|
|
function useRender(render) {
|
|
const vm = getCurrentInstance2("useRender");
|
|
vm.render = render;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/toggleScope.mjs
|
|
function useToggleScope(source, fn) {
|
|
let scope;
|
|
function start() {
|
|
scope = effectScope();
|
|
scope.run(() => fn.length ? fn(() => {
|
|
scope == null ? void 0 : scope.stop();
|
|
start();
|
|
}) : fn());
|
|
}
|
|
watch(source, (active) => {
|
|
if (active && !scope) {
|
|
start();
|
|
} else if (!active) {
|
|
scope == null ? void 0 : scope.stop();
|
|
scope = void 0;
|
|
}
|
|
}, {
|
|
immediate: true
|
|
});
|
|
onScopeDispose(() => {
|
|
scope == null ? void 0 : scope.stop();
|
|
});
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/proxiedModel.mjs
|
|
function useProxiedModel(props, prop, defaultValue) {
|
|
let transformIn = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : (v) => v;
|
|
let transformOut = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : (v) => v;
|
|
const vm = getCurrentInstance2("useProxiedModel");
|
|
const internal = ref(props[prop] !== void 0 ? props[prop] : defaultValue);
|
|
const kebabProp = toKebabCase(prop);
|
|
const checkKebab = kebabProp !== prop;
|
|
const isControlled = checkKebab ? computed(() => {
|
|
var _a, _b, _c, _d;
|
|
void props[prop];
|
|
return !!((((_a = vm.vnode.props) == null ? void 0 : _a.hasOwnProperty(prop)) || ((_b = vm.vnode.props) == null ? void 0 : _b.hasOwnProperty(kebabProp))) && (((_c = vm.vnode.props) == null ? void 0 : _c.hasOwnProperty(`onUpdate:${prop}`)) || ((_d = vm.vnode.props) == null ? void 0 : _d.hasOwnProperty(`onUpdate:${kebabProp}`))));
|
|
}) : computed(() => {
|
|
var _a, _b;
|
|
void props[prop];
|
|
return !!(((_a = vm.vnode.props) == null ? void 0 : _a.hasOwnProperty(prop)) && ((_b = vm.vnode.props) == null ? void 0 : _b.hasOwnProperty(`onUpdate:${prop}`)));
|
|
});
|
|
useToggleScope(() => !isControlled.value, () => {
|
|
watch(() => props[prop], (val) => {
|
|
internal.value = val;
|
|
});
|
|
});
|
|
const model = computed({
|
|
get() {
|
|
const externalValue = props[prop];
|
|
return transformIn(isControlled.value ? externalValue : internal.value);
|
|
},
|
|
set(internalValue) {
|
|
const newValue = transformOut(internalValue);
|
|
const value = toRaw(isControlled.value ? props[prop] : internal.value);
|
|
if (value === newValue || transformIn(value) === internalValue) {
|
|
return;
|
|
}
|
|
internal.value = newValue;
|
|
vm == null ? void 0 : vm.emit(`update:${prop}`, newValue);
|
|
}
|
|
});
|
|
Object.defineProperty(model, "externalValue", {
|
|
get: () => isControlled.value ? props[prop] : internal.value
|
|
});
|
|
return model;
|
|
}
|
|
|
|
// node_modules/vuetify/lib/locale/en.mjs
|
|
var en_default = {
|
|
badge: "Badge",
|
|
open: "Open",
|
|
close: "Close",
|
|
dismiss: "Dismiss",
|
|
confirmEdit: {
|
|
ok: "OK",
|
|
cancel: "Cancel"
|
|
},
|
|
dataIterator: {
|
|
noResultsText: "No matching records found",
|
|
loadingText: "Loading items..."
|
|
},
|
|
dataTable: {
|
|
itemsPerPageText: "Rows per page:",
|
|
ariaLabel: {
|
|
sortDescending: "Sorted descending.",
|
|
sortAscending: "Sorted ascending.",
|
|
sortNone: "Not sorted.",
|
|
activateNone: "Activate to remove sorting.",
|
|
activateDescending: "Activate to sort descending.",
|
|
activateAscending: "Activate to sort ascending."
|
|
},
|
|
sortBy: "Sort by"
|
|
},
|
|
dataFooter: {
|
|
itemsPerPageText: "Items per page:",
|
|
itemsPerPageAll: "All",
|
|
nextPage: "Next page",
|
|
prevPage: "Previous page",
|
|
firstPage: "First page",
|
|
lastPage: "Last page",
|
|
pageText: "{0}-{1} of {2}"
|
|
},
|
|
dateRangeInput: {
|
|
divider: "to"
|
|
},
|
|
datePicker: {
|
|
itemsSelected: "{0} selected",
|
|
range: {
|
|
title: "Select dates",
|
|
header: "Enter dates"
|
|
},
|
|
title: "Select date",
|
|
header: "Enter date",
|
|
input: {
|
|
placeholder: "Enter date"
|
|
}
|
|
},
|
|
noDataText: "No data available",
|
|
carousel: {
|
|
prev: "Previous visual",
|
|
next: "Next visual",
|
|
ariaLabel: {
|
|
delimiter: "Carousel slide {0} of {1}"
|
|
}
|
|
},
|
|
calendar: {
|
|
moreEvents: "{0} more",
|
|
today: "Today"
|
|
},
|
|
input: {
|
|
clear: "Clear {0}",
|
|
prependAction: "{0} prepended action",
|
|
appendAction: "{0} appended action",
|
|
otp: "Please enter OTP character {0}"
|
|
},
|
|
fileInput: {
|
|
counter: "{0} files",
|
|
counterSize: "{0} files ({1} in total)"
|
|
},
|
|
fileUpload: {
|
|
title: "Drag and drop files here",
|
|
divider: "or",
|
|
browse: "Browse Files"
|
|
},
|
|
timePicker: {
|
|
am: "AM",
|
|
pm: "PM",
|
|
title: "Select Time"
|
|
},
|
|
pagination: {
|
|
ariaLabel: {
|
|
root: "Pagination Navigation",
|
|
next: "Next page",
|
|
previous: "Previous page",
|
|
page: "Go to page {0}",
|
|
currentPage: "Page {0}, Current page",
|
|
first: "First page",
|
|
last: "Last page"
|
|
}
|
|
},
|
|
stepper: {
|
|
next: "Next",
|
|
prev: "Previous"
|
|
},
|
|
rating: {
|
|
ariaLabel: {
|
|
item: "Rating {0} of {1}"
|
|
}
|
|
},
|
|
loading: "Loading...",
|
|
infiniteScroll: {
|
|
loadMore: "Load more",
|
|
empty: "No more"
|
|
}
|
|
};
|
|
|
|
// node_modules/vuetify/lib/locale/adapters/vuetify.mjs
|
|
var LANG_PREFIX = "$vuetify.";
|
|
var replace = (str, params) => {
|
|
return str.replace(/\{(\d+)\}/g, (match, index) => {
|
|
return String(params[+index]);
|
|
});
|
|
};
|
|
var createTranslateFunction = (current, fallback, messages) => {
|
|
return function(key) {
|
|
for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
params[_key - 1] = arguments[_key];
|
|
}
|
|
if (!key.startsWith(LANG_PREFIX)) {
|
|
return replace(key, params);
|
|
}
|
|
const shortKey = key.replace(LANG_PREFIX, "");
|
|
const currentLocale = current.value && messages.value[current.value];
|
|
const fallbackLocale = fallback.value && messages.value[fallback.value];
|
|
let str = getObjectValueByPath(currentLocale, shortKey, null);
|
|
if (!str) {
|
|
consoleWarn(`Translation key "${key}" not found in "${current.value}", trying fallback locale`);
|
|
str = getObjectValueByPath(fallbackLocale, shortKey, null);
|
|
}
|
|
if (!str) {
|
|
consoleError(`Translation key "${key}" not found in fallback`);
|
|
str = key;
|
|
}
|
|
if (typeof str !== "string") {
|
|
consoleError(`Translation key "${key}" has a non-string value`);
|
|
str = key;
|
|
}
|
|
return replace(str, params);
|
|
};
|
|
};
|
|
function createNumberFunction(current, fallback) {
|
|
return (value, options) => {
|
|
const numberFormat = new Intl.NumberFormat([current.value, fallback.value], options);
|
|
return numberFormat.format(value);
|
|
};
|
|
}
|
|
function useProvided(props, prop, provided) {
|
|
const internal = useProxiedModel(props, prop, props[prop] ?? provided.value);
|
|
internal.value = props[prop] ?? provided.value;
|
|
watch(provided, (v) => {
|
|
if (props[prop] == null) {
|
|
internal.value = provided.value;
|
|
}
|
|
});
|
|
return internal;
|
|
}
|
|
function createProvideFunction(state) {
|
|
return (props) => {
|
|
const current = useProvided(props, "locale", state.current);
|
|
const fallback = useProvided(props, "fallback", state.fallback);
|
|
const messages = useProvided(props, "messages", state.messages);
|
|
return {
|
|
name: "vuetify",
|
|
current,
|
|
fallback,
|
|
messages,
|
|
t: createTranslateFunction(current, fallback, messages),
|
|
n: createNumberFunction(current, fallback),
|
|
provide: createProvideFunction({
|
|
current,
|
|
fallback,
|
|
messages
|
|
})
|
|
};
|
|
};
|
|
}
|
|
function createVuetifyAdapter(options) {
|
|
const current = shallowRef((options == null ? void 0 : options.locale) ?? "en");
|
|
const fallback = shallowRef((options == null ? void 0 : options.fallback) ?? "en");
|
|
const messages = ref({
|
|
en: en_default,
|
|
...options == null ? void 0 : options.messages
|
|
});
|
|
return {
|
|
name: "vuetify",
|
|
current,
|
|
fallback,
|
|
messages,
|
|
t: createTranslateFunction(current, fallback, messages),
|
|
n: createNumberFunction(current, fallback),
|
|
provide: createProvideFunction({
|
|
current,
|
|
fallback,
|
|
messages
|
|
})
|
|
};
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/locale.mjs
|
|
var LocaleSymbol = Symbol.for("vuetify:locale");
|
|
function isLocaleInstance(obj) {
|
|
return obj.name != null;
|
|
}
|
|
function createLocale(options) {
|
|
const i18n = (options == null ? void 0 : options.adapter) && isLocaleInstance(options == null ? void 0 : options.adapter) ? options == null ? void 0 : options.adapter : createVuetifyAdapter(options);
|
|
const rtl = createRtl(i18n, options);
|
|
return {
|
|
...i18n,
|
|
...rtl
|
|
};
|
|
}
|
|
function useLocale() {
|
|
const locale = inject(LocaleSymbol);
|
|
if (!locale) throw new Error("[Vuetify] Could not find injected locale instance");
|
|
return locale;
|
|
}
|
|
function provideLocale(props) {
|
|
const locale = inject(LocaleSymbol);
|
|
if (!locale) throw new Error("[Vuetify] Could not find injected locale instance");
|
|
const i18n = locale.provide(props);
|
|
const rtl = provideRtl(i18n, locale.rtl, props);
|
|
const data = {
|
|
...i18n,
|
|
...rtl
|
|
};
|
|
provide(LocaleSymbol, data);
|
|
return data;
|
|
}
|
|
var RtlSymbol = Symbol.for("vuetify:rtl");
|
|
function genDefaults() {
|
|
return {
|
|
af: false,
|
|
ar: true,
|
|
bg: false,
|
|
ca: false,
|
|
ckb: false,
|
|
cs: false,
|
|
de: false,
|
|
el: false,
|
|
en: false,
|
|
es: false,
|
|
et: false,
|
|
fa: true,
|
|
fi: false,
|
|
fr: false,
|
|
hr: false,
|
|
hu: false,
|
|
he: true,
|
|
id: false,
|
|
it: false,
|
|
ja: false,
|
|
km: false,
|
|
ko: false,
|
|
lv: false,
|
|
lt: false,
|
|
nl: false,
|
|
no: false,
|
|
pl: false,
|
|
pt: false,
|
|
ro: false,
|
|
ru: false,
|
|
sk: false,
|
|
sl: false,
|
|
srCyrl: false,
|
|
srLatn: false,
|
|
sv: false,
|
|
th: false,
|
|
tr: false,
|
|
az: false,
|
|
uk: false,
|
|
vi: false,
|
|
zhHans: false,
|
|
zhHant: false
|
|
};
|
|
}
|
|
function createRtl(i18n, options) {
|
|
const rtl = ref((options == null ? void 0 : options.rtl) ?? genDefaults());
|
|
const isRtl = computed(() => rtl.value[i18n.current.value] ?? false);
|
|
return {
|
|
isRtl,
|
|
rtl,
|
|
rtlClasses: computed(() => `v-locale--is-${isRtl.value ? "rtl" : "ltr"}`)
|
|
};
|
|
}
|
|
function provideRtl(locale, rtl, props) {
|
|
const isRtl = computed(() => props.rtl ?? rtl.value[locale.current.value] ?? false);
|
|
return {
|
|
isRtl,
|
|
rtl,
|
|
rtlClasses: computed(() => `v-locale--is-${isRtl.value ? "rtl" : "ltr"}`)
|
|
};
|
|
}
|
|
function useRtl() {
|
|
const locale = inject(LocaleSymbol);
|
|
if (!locale) throw new Error("[Vuetify] Could not find injected rtl instance");
|
|
return {
|
|
isRtl: locale.isRtl,
|
|
rtlClasses: locale.rtlClasses
|
|
};
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/display.mjs
|
|
var breakpoints = ["sm", "md", "lg", "xl", "xxl"];
|
|
var DisplaySymbol = Symbol.for("vuetify:display");
|
|
var defaultDisplayOptions = {
|
|
mobileBreakpoint: "lg",
|
|
thresholds: {
|
|
xs: 0,
|
|
sm: 600,
|
|
md: 960,
|
|
lg: 1280,
|
|
xl: 1920,
|
|
xxl: 2560
|
|
}
|
|
};
|
|
var parseDisplayOptions = function() {
|
|
let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaultDisplayOptions;
|
|
return mergeDeep(defaultDisplayOptions, options);
|
|
};
|
|
function getClientWidth(ssr) {
|
|
return IN_BROWSER && !ssr ? window.innerWidth : typeof ssr === "object" && ssr.clientWidth || 0;
|
|
}
|
|
function getClientHeight(ssr) {
|
|
return IN_BROWSER && !ssr ? window.innerHeight : typeof ssr === "object" && ssr.clientHeight || 0;
|
|
}
|
|
function getPlatform(ssr) {
|
|
const userAgent = IN_BROWSER && !ssr ? window.navigator.userAgent : "ssr";
|
|
function match(regexp) {
|
|
return Boolean(userAgent.match(regexp));
|
|
}
|
|
const android = match(/android/i);
|
|
const ios = match(/iphone|ipad|ipod/i);
|
|
const cordova = match(/cordova/i);
|
|
const electron = match(/electron/i);
|
|
const chrome = match(/chrome/i);
|
|
const edge = match(/edge/i);
|
|
const firefox = match(/firefox/i);
|
|
const opera = match(/opera/i);
|
|
const win = match(/win/i);
|
|
const mac = match(/mac/i);
|
|
const linux = match(/linux/i);
|
|
return {
|
|
android,
|
|
ios,
|
|
cordova,
|
|
electron,
|
|
chrome,
|
|
edge,
|
|
firefox,
|
|
opera,
|
|
win,
|
|
mac,
|
|
linux,
|
|
touch: SUPPORTS_TOUCH,
|
|
ssr: userAgent === "ssr"
|
|
};
|
|
}
|
|
function createDisplay(options, ssr) {
|
|
const {
|
|
thresholds,
|
|
mobileBreakpoint
|
|
} = parseDisplayOptions(options);
|
|
const height = shallowRef(getClientHeight(ssr));
|
|
const platform = shallowRef(getPlatform(ssr));
|
|
const state = reactive({});
|
|
const width = shallowRef(getClientWidth(ssr));
|
|
function updateSize() {
|
|
height.value = getClientHeight();
|
|
width.value = getClientWidth();
|
|
}
|
|
function update() {
|
|
updateSize();
|
|
platform.value = getPlatform();
|
|
}
|
|
watchEffect(() => {
|
|
const xs = width.value < thresholds.sm;
|
|
const sm = width.value < thresholds.md && !xs;
|
|
const md = width.value < thresholds.lg && !(sm || xs);
|
|
const lg = width.value < thresholds.xl && !(md || sm || xs);
|
|
const xl = width.value < thresholds.xxl && !(lg || md || sm || xs);
|
|
const xxl = width.value >= thresholds.xxl;
|
|
const name = xs ? "xs" : sm ? "sm" : md ? "md" : lg ? "lg" : xl ? "xl" : "xxl";
|
|
const breakpointValue = typeof mobileBreakpoint === "number" ? mobileBreakpoint : thresholds[mobileBreakpoint];
|
|
const mobile = width.value < breakpointValue;
|
|
state.xs = xs;
|
|
state.sm = sm;
|
|
state.md = md;
|
|
state.lg = lg;
|
|
state.xl = xl;
|
|
state.xxl = xxl;
|
|
state.smAndUp = !xs;
|
|
state.mdAndUp = !(xs || sm);
|
|
state.lgAndUp = !(xs || sm || md);
|
|
state.xlAndUp = !(xs || sm || md || lg);
|
|
state.smAndDown = !(md || lg || xl || xxl);
|
|
state.mdAndDown = !(lg || xl || xxl);
|
|
state.lgAndDown = !(xl || xxl);
|
|
state.xlAndDown = !xxl;
|
|
state.name = name;
|
|
state.height = height.value;
|
|
state.width = width.value;
|
|
state.mobile = mobile;
|
|
state.mobileBreakpoint = mobileBreakpoint;
|
|
state.platform = platform.value;
|
|
state.thresholds = thresholds;
|
|
});
|
|
if (IN_BROWSER) {
|
|
window.addEventListener("resize", updateSize, {
|
|
passive: true
|
|
});
|
|
}
|
|
return {
|
|
...toRefs(state),
|
|
update,
|
|
ssr: !!ssr
|
|
};
|
|
}
|
|
var makeDisplayProps = propsFactory({
|
|
mobile: {
|
|
type: Boolean,
|
|
default: false
|
|
},
|
|
mobileBreakpoint: [Number, String]
|
|
}, "display");
|
|
function useDisplay() {
|
|
let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
|
|
mobile: null
|
|
};
|
|
let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
|
|
const display = inject(DisplaySymbol);
|
|
if (!display) throw new Error("Could not find Vuetify display injection");
|
|
const mobile = computed(() => {
|
|
if (props.mobile) {
|
|
return true;
|
|
} else if (typeof props.mobileBreakpoint === "number") {
|
|
return display.width.value < props.mobileBreakpoint;
|
|
} else if (props.mobileBreakpoint) {
|
|
return display.width.value < display.thresholds.value[props.mobileBreakpoint];
|
|
} else if (props.mobile === null) {
|
|
return display.mobile.value;
|
|
} else {
|
|
return false;
|
|
}
|
|
});
|
|
const displayClasses = computed(() => {
|
|
if (!name) return {};
|
|
return {
|
|
[`${name}--mobile`]: mobile.value
|
|
};
|
|
});
|
|
return {
|
|
...display,
|
|
displayClasses,
|
|
mobile
|
|
};
|
|
}
|
|
|
|
// node_modules/vuetify/lib/composables/theme.mjs
|
|
var ThemeSymbol = Symbol.for("vuetify:theme");
|
|
var makeThemeProps = propsFactory({
|
|
theme: String
|
|
}, "theme");
|
|
function genDefaults2() {
|
|
return {
|
|
defaultTheme: "light",
|
|
variations: {
|
|
colors: [],
|
|
lighten: 0,
|
|
darken: 0
|
|
},
|
|
themes: {
|
|
light: {
|
|
dark: false,
|
|
colors: {
|
|
background: "#FFFFFF",
|
|
surface: "#FFFFFF",
|
|
"surface-bright": "#FFFFFF",
|
|
"surface-light": "#EEEEEE",
|
|
"surface-variant": "#424242",
|
|
"on-surface-variant": "#EEEEEE",
|
|
primary: "#1867C0",
|
|
"primary-darken-1": "#1F5592",
|
|
secondary: "#48A9A6",
|
|
"secondary-darken-1": "#018786",
|
|
error: "#B00020",
|
|
info: "#2196F3",
|
|
success: "#4CAF50",
|
|
warning: "#FB8C00"
|
|
},
|
|
variables: {
|
|
"border-color": "#000000",
|
|
"border-opacity": 0.12,
|
|
"high-emphasis-opacity": 0.87,
|
|
"medium-emphasis-opacity": 0.6,
|
|
"disabled-opacity": 0.38,
|
|
"idle-opacity": 0.04,
|
|
"hover-opacity": 0.04,
|
|
"focus-opacity": 0.12,
|
|
"selected-opacity": 0.08,
|
|
"activated-opacity": 0.12,
|
|
"pressed-opacity": 0.12,
|
|
"dragged-opacity": 0.08,
|
|
"theme-kbd": "#212529",
|
|
"theme-on-kbd": "#FFFFFF",
|
|
"theme-code": "#F5F5F5",
|
|
"theme-on-code": "#000000"
|
|
}
|
|
},
|
|
dark: {
|
|
dark: true,
|
|
colors: {
|
|
background: "#121212",
|
|
surface: "#212121",
|
|
"surface-bright": "#ccbfd6",
|
|
"surface-light": "#424242",
|
|
"surface-variant": "#a3a3a3",
|
|
"on-surface-variant": "#424242",
|
|
primary: "#2196F3",
|
|
"primary-darken-1": "#277CC1",
|
|
secondary: "#54B6B2",
|
|
"secondary-darken-1": "#48A9A6",
|
|
error: "#CF6679",
|
|
info: "#2196F3",
|
|
success: "#4CAF50",
|
|
warning: "#FB8C00"
|
|
},
|
|
variables: {
|
|
"border-color": "#FFFFFF",
|
|
"border-opacity": 0.12,
|
|
"high-emphasis-opacity": 1,
|
|
"medium-emphasis-opacity": 0.7,
|
|
"disabled-opacity": 0.5,
|
|
"idle-opacity": 0.1,
|
|
"hover-opacity": 0.04,
|
|
"focus-opacity": 0.12,
|
|
"selected-opacity": 0.08,
|
|
"activated-opacity": 0.12,
|
|
"pressed-opacity": 0.16,
|
|
"dragged-opacity": 0.08,
|
|
"theme-kbd": "#212529",
|
|
"theme-on-kbd": "#FFFFFF",
|
|
"theme-code": "#343434",
|
|
"theme-on-code": "#CCCCCC"
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function parseThemeOptions() {
|
|
var _a, _b;
|
|
let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : genDefaults2();
|
|
const defaults = genDefaults2();
|
|
if (!options) return {
|
|
...defaults,
|
|
isDisabled: true
|
|
};
|
|
const themes = {};
|
|
for (const [key, theme] of Object.entries(options.themes ?? {})) {
|
|
const defaultTheme = theme.dark || key === "dark" ? (_a = defaults.themes) == null ? void 0 : _a.dark : (_b = defaults.themes) == null ? void 0 : _b.light;
|
|
themes[key] = mergeDeep(defaultTheme, theme);
|
|
}
|
|
return mergeDeep(defaults, {
|
|
...options,
|
|
themes
|
|
});
|
|
}
|
|
function createTheme(options) {
|
|
const parsedOptions = parseThemeOptions(options);
|
|
const name = ref(parsedOptions.defaultTheme);
|
|
const themes = ref(parsedOptions.themes);
|
|
const computedThemes = computed(() => {
|
|
const acc = {};
|
|
for (const [name2, original] of Object.entries(themes.value)) {
|
|
const theme = acc[name2] = {
|
|
...original,
|
|
colors: {
|
|
...original.colors
|
|
}
|
|
};
|
|
if (parsedOptions.variations) {
|
|
for (const name3 of parsedOptions.variations.colors) {
|
|
const color = theme.colors[name3];
|
|
if (!color) continue;
|
|
for (const variation of ["lighten", "darken"]) {
|
|
const fn = variation === "lighten" ? lighten : darken;
|
|
for (const amount of createRange(parsedOptions.variations[variation], 1)) {
|
|
theme.colors[`${name3}-${variation}-${amount}`] = RGBtoHex(fn(parseColor(color), amount));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (const color of Object.keys(theme.colors)) {
|
|
if (/^on-[a-z]/.test(color) || theme.colors[`on-${color}`]) continue;
|
|
const onColor = `on-${color}`;
|
|
const colorVal = parseColor(theme.colors[color]);
|
|
theme.colors[onColor] = getForeground(colorVal);
|
|
}
|
|
}
|
|
return acc;
|
|
});
|
|
const current = computed(() => computedThemes.value[name.value]);
|
|
const styles = computed(() => {
|
|
var _a;
|
|
const lines = [];
|
|
if ((_a = current.value) == null ? void 0 : _a.dark) {
|
|
createCssClass(lines, ":root", ["color-scheme: dark"]);
|
|
}
|
|
createCssClass(lines, ":root", genCssVariables(current.value));
|
|
for (const [themeName, theme] of Object.entries(computedThemes.value)) {
|
|
createCssClass(lines, `.v-theme--${themeName}`, [`color-scheme: ${theme.dark ? "dark" : "normal"}`, ...genCssVariables(theme)]);
|
|
}
|
|
const bgLines = [];
|
|
const fgLines = [];
|
|
const colors = new Set(Object.values(computedThemes.value).flatMap((theme) => Object.keys(theme.colors)));
|
|
for (const key of colors) {
|
|
if (/^on-[a-z]/.test(key)) {
|
|
createCssClass(fgLines, `.${key}`, [`color: rgb(var(--v-theme-${key})) !important`]);
|
|
} else {
|
|
createCssClass(bgLines, `.bg-${key}`, [`--v-theme-overlay-multiplier: var(--v-theme-${key}-overlay-multiplier)`, `background-color: rgb(var(--v-theme-${key})) !important`, `color: rgb(var(--v-theme-on-${key})) !important`]);
|
|
createCssClass(fgLines, `.text-${key}`, [`color: rgb(var(--v-theme-${key})) !important`]);
|
|
createCssClass(fgLines, `.border-${key}`, [`--v-border-color: var(--v-theme-${key})`]);
|
|
}
|
|
}
|
|
lines.push(...bgLines, ...fgLines);
|
|
return lines.map((str, i) => i === 0 ? str : ` ${str}`).join("");
|
|
});
|
|
function getHead() {
|
|
return {
|
|
style: [{
|
|
children: styles.value,
|
|
id: "vuetify-theme-stylesheet",
|
|
nonce: parsedOptions.cspNonce || false
|
|
}]
|
|
};
|
|
}
|
|
function install(app) {
|
|
if (parsedOptions.isDisabled) return;
|
|
const head = app._context.provides.usehead;
|
|
if (head) {
|
|
if (head.push) {
|
|
const entry = head.push(getHead);
|
|
if (IN_BROWSER) {
|
|
watch(styles, () => {
|
|
entry.patch(getHead);
|
|
});
|
|
}
|
|
} else {
|
|
if (IN_BROWSER) {
|
|
head.addHeadObjs(computed(getHead));
|
|
watchEffect(() => head.updateDOM());
|
|
} else {
|
|
head.addHeadObjs(getHead());
|
|
}
|
|
}
|
|
} else {
|
|
let updateStyles = function() {
|
|
if (typeof document !== "undefined" && !styleEl) {
|
|
const el = document.createElement("style");
|
|
el.type = "text/css";
|
|
el.id = "vuetify-theme-stylesheet";
|
|
if (parsedOptions.cspNonce) el.setAttribute("nonce", parsedOptions.cspNonce);
|
|
styleEl = el;
|
|
document.head.appendChild(styleEl);
|
|
}
|
|
if (styleEl) styleEl.innerHTML = styles.value;
|
|
};
|
|
let styleEl = IN_BROWSER ? document.getElementById("vuetify-theme-stylesheet") : null;
|
|
if (IN_BROWSER) {
|
|
watch(styles, updateStyles, {
|
|
immediate: true
|
|
});
|
|
} else {
|
|
updateStyles();
|
|
}
|
|
}
|
|
}
|
|
const themeClasses = computed(() => parsedOptions.isDisabled ? void 0 : `v-theme--${name.value}`);
|
|
return {
|
|
install,
|
|
isDisabled: parsedOptions.isDisabled,
|
|
name,
|
|
themes,
|
|
current,
|
|
computedThemes,
|
|
themeClasses,
|
|
styles,
|
|
global: {
|
|
name,
|
|
current
|
|
}
|
|
};
|
|
}
|
|
function provideTheme(props) {
|
|
getCurrentInstance2("provideTheme");
|
|
const theme = inject(ThemeSymbol, null);
|
|
if (!theme) throw new Error("Could not find Vuetify theme injection");
|
|
const name = computed(() => {
|
|
return props.theme ?? theme.name.value;
|
|
});
|
|
const current = computed(() => theme.themes.value[name.value]);
|
|
const themeClasses = computed(() => theme.isDisabled ? void 0 : `v-theme--${name.value}`);
|
|
const newTheme = {
|
|
...theme,
|
|
name,
|
|
current,
|
|
themeClasses
|
|
};
|
|
provide(ThemeSymbol, newTheme);
|
|
return newTheme;
|
|
}
|
|
function useTheme() {
|
|
getCurrentInstance2("useTheme");
|
|
const theme = inject(ThemeSymbol, null);
|
|
if (!theme) throw new Error("Could not find Vuetify theme injection");
|
|
return theme;
|
|
}
|
|
function createCssClass(lines, selector, content) {
|
|
lines.push(`${selector} {
|
|
`, ...content.map((line) => ` ${line};
|
|
`), "}\n");
|
|
}
|
|
function genCssVariables(theme) {
|
|
const lightOverlay = theme.dark ? 2 : 1;
|
|
const darkOverlay = theme.dark ? 1 : 2;
|
|
const variables = [];
|
|
for (const [key, value] of Object.entries(theme.colors)) {
|
|
const rgb = parseColor(value);
|
|
variables.push(`--v-theme-${key}: ${rgb.r},${rgb.g},${rgb.b}`);
|
|
if (!key.startsWith("on-")) {
|
|
variables.push(`--v-theme-${key}-overlay-multiplier: ${getLuma(value) > 0.18 ? lightOverlay : darkOverlay}`);
|
|
}
|
|
}
|
|
for (const [key, value] of Object.entries(theme.variables)) {
|
|
const color = typeof value === "string" && value.startsWith("#") ? parseColor(value) : void 0;
|
|
const rgb = color ? `${color.r}, ${color.g}, ${color.b}` : void 0;
|
|
variables.push(`--v-${key}: ${rgb ?? value}`);
|
|
}
|
|
return variables;
|
|
}
|
|
|
|
export {
|
|
useToggleScope,
|
|
IN_BROWSER,
|
|
SUPPORTS_INTERSECTION,
|
|
SUPPORTS_EYE_DROPPER,
|
|
deepEqual,
|
|
getObjectValueByPath,
|
|
getPropertyFromItem,
|
|
createRange,
|
|
convertToUnit,
|
|
isObject,
|
|
refElement,
|
|
keyCodes,
|
|
keyValues,
|
|
keys,
|
|
has,
|
|
pick,
|
|
pickWithRest,
|
|
omit,
|
|
isOn,
|
|
isComposingIgnoreKey,
|
|
filterInputAttrs,
|
|
wrapInArray,
|
|
debounce,
|
|
clamp,
|
|
getDecimals,
|
|
padStart,
|
|
humanReadableFileSize,
|
|
mergeDeep,
|
|
flattenFragments,
|
|
findChildrenWithProvide,
|
|
CircularBuffer,
|
|
getEventCoordinates,
|
|
destructComputed,
|
|
includes,
|
|
EventProp,
|
|
hasEvent,
|
|
callEvent,
|
|
focusableChildren,
|
|
getNextElement,
|
|
focusChild,
|
|
isEmpty,
|
|
noop,
|
|
matchesSelector,
|
|
ensureValidVNode,
|
|
defer,
|
|
isClickInsideElement,
|
|
templateRef,
|
|
checkPrintable,
|
|
isPrimitive,
|
|
parseAnchor,
|
|
toPhysical,
|
|
flipSide,
|
|
flipAlign,
|
|
flipCorner,
|
|
getAxis,
|
|
Box,
|
|
getOverflow,
|
|
getTargetBox,
|
|
nullifyTransforms,
|
|
animate,
|
|
bindProps,
|
|
unbindProps,
|
|
consoleWarn,
|
|
consoleError,
|
|
deprecate,
|
|
isCssColor,
|
|
isParsableColor,
|
|
parseColor,
|
|
HSVtoRGB,
|
|
RGBtoHSV,
|
|
HSVtoHSL,
|
|
HSLtoHSV,
|
|
RGBtoCSS,
|
|
HSVtoCSS,
|
|
HexToHSV,
|
|
HSVtoHex,
|
|
getContrast,
|
|
getForeground,
|
|
propsFactory,
|
|
makeComponentProps,
|
|
getCurrentInstance2 as getCurrentInstance,
|
|
getCurrentInstanceName,
|
|
getUid,
|
|
DefaultsSymbol,
|
|
createDefaults,
|
|
provideDefaults,
|
|
useDefaults,
|
|
defineComponent2 as defineComponent,
|
|
genericComponent,
|
|
defineFunctionalComponent,
|
|
createSimpleFunctional,
|
|
attachedRoot,
|
|
standardEasing,
|
|
deceleratedEasing,
|
|
acceleratedEasing,
|
|
getPrefixedEventHandlers,
|
|
getScrollParent,
|
|
getScrollParents,
|
|
hasScrollbar,
|
|
isFixedPosition,
|
|
useRender,
|
|
useProxiedModel,
|
|
LocaleSymbol,
|
|
createLocale,
|
|
useLocale,
|
|
provideLocale,
|
|
useRtl,
|
|
breakpoints,
|
|
DisplaySymbol,
|
|
createDisplay,
|
|
makeDisplayProps,
|
|
useDisplay,
|
|
ThemeSymbol,
|
|
makeThemeProps,
|
|
createTheme,
|
|
provideTheme,
|
|
useTheme
|
|
};
|
|
//# sourceMappingURL=chunk-OGLFEP4I.js.map
|