1443 lines
41 KiB
JavaScript
1443 lines
41 KiB
JavaScript
|
import {
|
||
|
|
Comment,
|
||
|
|
Fragment,
|
||
|
|
camelize,
|
||
|
|
capitalize,
|
||
|
|
computed,
|
||
|
|
defineComponent,
|
||
|
|
getCurrentInstance,
|
||
|
|
h,
|
||
|
|
inject,
|
||
|
|
isVNode,
|
||
|
|
provide,
|
||
|
|
reactive,
|
||
|
|
ref,
|
||
|
|
shallowRef,
|
||
|
|
toRefs,
|
||
|
|
unref,
|
||
|
|
warn,
|
||
|
|
watchEffect
|
||
|
|
} from "./chunk-PD2AWGJV.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(obj, privateMap, value) {
|
||
|
|
_checkPrivateRedeclaration(obj, privateMap);
|
||
|
|
privateMap.set(obj, value);
|
||
|
|
}
|
||
|
|
function _checkPrivateRedeclaration(obj, privateCollection) {
|
||
|
|
if (privateCollection.has(obj)) {
|
||
|
|
throw new TypeError("Cannot initialize the same private elements twice on an object");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _classPrivateFieldSet(receiver, privateMap, value) {
|
||
|
|
var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
|
||
|
|
_classApplyDescriptorSet(receiver, descriptor, value);
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
function _classApplyDescriptorSet(receiver, descriptor, value) {
|
||
|
|
if (descriptor.set) {
|
||
|
|
descriptor.set.call(receiver, value);
|
||
|
|
} else {
|
||
|
|
if (!descriptor.writable) {
|
||
|
|
throw new TypeError("attempted to set read only private field");
|
||
|
|
}
|
||
|
|
descriptor.value = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function _classPrivateFieldGet(receiver, privateMap) {
|
||
|
|
var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
|
||
|
|
return _classApplyDescriptorGet(receiver, descriptor);
|
||
|
|
}
|
||
|
|
function _classExtractFieldDescriptor(receiver, privateMap, action) {
|
||
|
|
if (!privateMap.has(receiver)) {
|
||
|
|
throw new TypeError("attempted to " + action + " private field on non-instance");
|
||
|
|
}
|
||
|
|
return privateMap.get(receiver);
|
||
|
|
}
|
||
|
|
function _classApplyDescriptorGet(receiver, descriptor) {
|
||
|
|
if (descriptor.get) {
|
||
|
|
return descriptor.get.call(receiver);
|
||
|
|
}
|
||
|
|
return descriptor.value;
|
||
|
|
}
|
||
|
|
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 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 has(obj, key) {
|
||
|
|
return key.every((k) => obj.hasOwnProperty(k));
|
||
|
|
}
|
||
|
|
function pick(obj, paths) {
|
||
|
|
const found = {};
|
||
|
|
const keys = new Set(Object.keys(obj));
|
||
|
|
for (const path of paths) {
|
||
|
|
if (keys.has(path)) {
|
||
|
|
found[path] = obj[path];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
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"];
|
||
|
|
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 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 (isObject(sourceProperty) && isObject(targetProperty)) {
|
||
|
|
out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (Array.isArray(sourceProperty) && Array.isArray(targetProperty) && arrayFn) {
|
||
|
|
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 (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, {
|
||
|
|
writable: true,
|
||
|
|
value: []
|
||
|
|
});
|
||
|
|
_classPrivateFieldInitSpec(this, _pointer, {
|
||
|
|
writable: true,
|
||
|
|
value: 0
|
||
|
|
});
|
||
|
|
this.size = size;
|
||
|
|
}
|
||
|
|
push(val) {
|
||
|
|
_classPrivateFieldGet(this, _arr)[_classPrivateFieldGet(this, _pointer)] = val;
|
||
|
|
_classPrivateFieldSet(this, _pointer, (_classPrivateFieldGet(this, _pointer) + 1) % this.size);
|
||
|
|
}
|
||
|
|
values() {
|
||
|
|
return _classPrivateFieldGet(this, _arr).slice(_classPrivateFieldGet(this, _pointer)).concat(_classPrivateFieldGet(this, _arr).slice(0, _classPrivateFieldGet(this, _pointer)));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
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 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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/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/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/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/composables/component.mjs
|
||
|
|
var makeComponentProps = propsFactory({
|
||
|
|
class: [String, Array],
|
||
|
|
style: {
|
||
|
|
type: [String, Array, Object],
|
||
|
|
default: null
|
||
|
|
}
|
||
|
|
}, "component");
|
||
|
|
|
||
|
|
// 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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/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/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/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/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/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;
|
||
|
|
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]) ?? ((_d = (_c = defaults.value) == null ? void 0 : _c.global) == null ? void 0 : _d[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;
|
||
|
|
}
|
||
|
|
|
||
|
|
export {
|
||
|
|
IN_BROWSER,
|
||
|
|
SUPPORTS_INTERSECTION,
|
||
|
|
SUPPORTS_TOUCH,
|
||
|
|
SUPPORTS_EYE_DROPPER,
|
||
|
|
deepEqual,
|
||
|
|
getObjectValueByPath,
|
||
|
|
getPropertyFromItem,
|
||
|
|
createRange,
|
||
|
|
convertToUnit,
|
||
|
|
isObject,
|
||
|
|
refElement,
|
||
|
|
keyCodes,
|
||
|
|
keyValues,
|
||
|
|
has,
|
||
|
|
pick,
|
||
|
|
omit,
|
||
|
|
isOn,
|
||
|
|
filterInputAttrs,
|
||
|
|
wrapInArray,
|
||
|
|
debounce,
|
||
|
|
clamp,
|
||
|
|
getDecimals,
|
||
|
|
padStart,
|
||
|
|
mergeDeep,
|
||
|
|
flattenFragments,
|
||
|
|
toKebabCase,
|
||
|
|
findChildrenWithProvide,
|
||
|
|
CircularBuffer,
|
||
|
|
getEventCoordinates,
|
||
|
|
destructComputed,
|
||
|
|
includes,
|
||
|
|
EventProp,
|
||
|
|
hasEvent,
|
||
|
|
callEvent,
|
||
|
|
focusableChildren,
|
||
|
|
getNextElement,
|
||
|
|
focusChild,
|
||
|
|
matchesSelector,
|
||
|
|
ensureValidVNode,
|
||
|
|
defer,
|
||
|
|
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,
|
||
|
|
RGBtoHex,
|
||
|
|
HexToHSV,
|
||
|
|
HSVtoHex,
|
||
|
|
lighten,
|
||
|
|
darken,
|
||
|
|
getLuma,
|
||
|
|
getContrast,
|
||
|
|
getForeground,
|
||
|
|
propsFactory,
|
||
|
|
makeComponentProps,
|
||
|
|
DefaultsSymbol,
|
||
|
|
createDefaults,
|
||
|
|
provideDefaults,
|
||
|
|
useDefaults,
|
||
|
|
defineComponent2 as defineComponent,
|
||
|
|
genericComponent,
|
||
|
|
createSimpleFunctional,
|
||
|
|
attachedRoot,
|
||
|
|
standardEasing,
|
||
|
|
deceleratedEasing,
|
||
|
|
acceleratedEasing,
|
||
|
|
getCurrentInstance2 as getCurrentInstance,
|
||
|
|
getCurrentInstanceName,
|
||
|
|
getUid,
|
||
|
|
getScrollParent,
|
||
|
|
getScrollParents,
|
||
|
|
hasScrollbar,
|
||
|
|
isFixedPosition,
|
||
|
|
useRender
|
||
|
|
};
|
||
|
|
//# sourceMappingURL=chunk-I4KGD5X4.js.map
|