jchomaz/Vulture
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Tracking de l'application VApp (IHM du jeu)

Browse Source
This commit is contained in:
Jérémy CHOMAZ
2025-05-11 18:04:12 +02:00
commit 89e9db9b62
17763 changed files with 3718499 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
VApp/node_modules/vuetify/lib/util/anchor.mjs generated vendored Normal file
View File

@ -0,0 +1,54 @@
// Utilities
import { includes } from "./helpers.mjs";
const block = ['top', 'bottom'];
const inline = ['start', 'end', 'left', 'right'];
/** Parse a raw anchor string into an object */
export 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)
};
}
export function toPhysical(str, isRtl) {
if (str === 'start') return isRtl ? 'right' : 'left';
if (str === 'end') return isRtl ? 'left' : 'right';
return str;
}
export function flipSide(anchor) {
return {
side: {
center: 'center',
top: 'bottom',
bottom: 'top',
left: 'right',
right: 'left'
}[anchor.side],
align: anchor.align
};
}
export function flipAlign(anchor) {
return {
side: anchor.side,
align: {
center: 'center',
top: 'bottom',
bottom: 'top',
left: 'right',
right: 'left'
}[anchor.align]
};
}
export function flipCorner(anchor) {
return {
side: anchor.align,
align: anchor.side
};
}
export function getAxis(anchor) {
return includes(block, anchor.side) ? 'y' : 'x';
}
//# sourceMappingURL=anchor.mjs.map

1
VApp/node_modules/vuetify/lib/util/anchor.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"anchor.mjs","names":["includes","block","inline","parseAnchor","anchor","isRtl","side","align","split","toPhysical","str","flipSide","center","top","bottom","left","right","flipAlign","flipCorner","getAxis"],"sources":["../../src/util/anchor.ts"],"sourcesContent":["// Utilities\nimport { includes } from '@/util/helpers'\n\nconst block = ['top', 'bottom'] as const\nconst inline = ['start', 'end', 'left', 'right'] as const\ntype Tblock = typeof block[number]\ntype Tinline = typeof inline[number]\nexport type Anchor =\n | Tblock\n | Tinline\n | 'center'\n | 'center center'\n | `${Tblock} ${Tinline | 'center'}`\n | `${Tinline} ${Tblock | 'center'}`\nexport type ParsedAnchor =\n | { side: 'center', align: 'center' }\n | { side: Tblock, align: 'left' | 'right' | 'center' }\n | { side: 'left' | 'right', align: Tblock | 'center' }\n\n/** Parse a raw anchor string into an object */\nexport function parseAnchor (anchor: Anchor, isRtl: boolean) {\n let [side, align] = anchor.split(' ') as [Tblock | Tinline | 'center', Tblock | Tinline | 'center' | undefined]\n if (!align) {\n align =\n includes(block, side) ? 'start'\n : includes(inline, side) ? 'top'\n : 'center'\n }\n\n return {\n side: toPhysical(side, isRtl),\n align: toPhysical(align, isRtl),\n } as ParsedAnchor\n}\n\nexport function toPhysical (str: 'center' | Tblock | Tinline, isRtl: boolean) {\n if (str === 'start') return isRtl ? 'right' : 'left'\n if (str === 'end') return isRtl ? 'left' : 'right'\n return str\n}\n\nexport function flipSide (anchor: ParsedAnchor) {\n return {\n side: {\n center: 'center',\n top: 'bottom',\n bottom: 'top',\n left: 'right',\n right: 'left',\n }[anchor.side],\n align: anchor.align,\n } as ParsedAnchor\n}\n\nexport function flipAlign (anchor: ParsedAnchor) {\n return {\n side: anchor.side,\n align: {\n center: 'center',\n top: 'bottom',\n bottom: 'top',\n left: 'right',\n right: 'left',\n }[anchor.align],\n } as ParsedAnchor\n}\n\nexport function flipCorner (anchor: ParsedAnchor) {\n return {\n side: anchor.align,\n align: anchor.side,\n } as ParsedAnchor\n}\n\nexport function getAxis (anchor: ParsedAnchor) {\n return includes(block, anchor.side) ? 'y' : 'x'\n}\n"],"mappings":"AAAA;AAAA,SACSA,QAAQ;AAEjB,MAAMC,KAAK,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAU;AACxC,MAAMC,MAAM,GAAG,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAU;AAezD;AACA,OAAO,SAASC,WAAWA,CAAEC,MAAc,EAAEC,KAAc,EAAE;EAC3D,IAAI,CAACC,IAAI,EAAEC,KAAK,CAAC,GAAGH,MAAM,CAACI,KAAK,CAAC,GAAG,CAA2E;EAC/G,IAAI,CAACD,KAAK,EAAE;IACVA,KAAK,GACHP,QAAQ,CAACC,KAAK,EAAEK,IAAI,CAAC,GAAG,OAAO,GAC7BN,QAAQ,CAACE,MAAM,EAAEI,IAAI,CAAC,GAAG,KAAK,GAC9B,QAAQ;EACd;EAEA,OAAO;IACLA,IAAI,EAAEG,UAAU,CAACH,IAAI,EAAED,KAAK,CAAC;IAC7BE,KAAK,EAAEE,UAAU,CAACF,KAAK,EAAEF,KAAK;EAChC,CAAC;AACH;AAEA,OAAO,SAASI,UAAUA,CAAEC,GAAgC,EAAEL,KAAc,EAAE;EAC5E,IAAIK,GAAG,KAAK,OAAO,EAAE,OAAOL,KAAK,GAAG,OAAO,GAAG,MAAM;EACpD,IAAIK,GAAG,KAAK,KAAK,EAAE,OAAOL,KAAK,GAAG,MAAM,GAAG,OAAO;EAClD,OAAOK,GAAG;AACZ;AAEA,OAAO,SAASC,QAAQA,CAAEP,MAAoB,EAAE;EAC9C,OAAO;IACLE,IAAI,EAAE;MACJM,MAAM,EAAE,QAAQ;MAChBC,GAAG,EAAE,QAAQ;MACbC,MAAM,EAAE,KAAK;MACbC,IAAI,EAAE,OAAO;MACbC,KAAK,EAAE;IACT,CAAC,CAACZ,MAAM,CAACE,IAAI,CAAC;IACdC,KAAK,EAAEH,MAAM,CAACG;EAChB,CAAC;AACH;AAEA,OAAO,SAASU,SAASA,CAAEb,MAAoB,EAAE;EAC/C,OAAO;IACLE,IAAI,EAAEF,MAAM,CAACE,IAAI;IACjBC,KAAK,EAAE;MACLK,MAAM,EAAE,QAAQ;MAChBC,GAAG,EAAE,QAAQ;MACbC,MAAM,EAAE,KAAK;MACbC,IAAI,EAAE,OAAO;MACbC,KAAK,EAAE;IACT,CAAC,CAACZ,MAAM,CAACG,KAAK;EAChB,CAAC;AACH;AAEA,OAAO,SAASW,UAAUA,CAAEd,MAAoB,EAAE;EAChD,OAAO;IACLE,IAAI,EAAEF,MAAM,CAACG,KAAK;IAClBA,KAAK,EAAEH,MAAM,CAACE;EAChB,CAAC;AACH;AAEA,OAAO,SAASa,OAAOA,CAAEf,MAAoB,EAAE;EAC7C,OAAOJ,QAAQ,CAACC,KAAK,EAAEG,MAAM,CAACE,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG;AACjD"}

61
VApp/node_modules/vuetify/lib/util/animation.mjs generated vendored Normal file
View File

@ -0,0 +1,61 @@
// Utilities
import { Box } from "./box.mjs";
/** @see https://stackoverflow.com/a/57876601/2074736 */
export 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 h = sy ? rect.height / sy : el.offsetHeight + 1;
return new Box({
x,
y,
width: w,
height: h
});
} else {
return new Box(rect);
}
}
export 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;
}
//# sourceMappingURL=animation.mjs.map

1
VApp/node_modules/vuetify/lib/util/animation.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"animation.mjs","names":["Box","nullifyTransforms","el","rect","getBoundingClientRect","style","getComputedStyle","tx","transform","ta","sx","sy","dx","dy","startsWith","slice","split","to","transformOrigin","x","parseFloat","y","indexOf","w","width","offsetWidth","h","height","offsetHeight","animate","keyframes","options","finished","Promise","resolve","animation","err","onfinish"],"sources":["../../src/util/animation.ts"],"sourcesContent":["// Utilities\nimport { Box } from '@/util/box'\n\n/** @see https://stackoverflow.com/a/57876601/2074736 */\nexport function nullifyTransforms (el: HTMLElement): Box {\n const rect = el.getBoundingClientRect()\n const style = getComputedStyle(el)\n const tx = style.transform\n\n if (tx) {\n let ta, sx, sy, dx, dy\n if (tx.startsWith('matrix3d(')) {\n ta = tx.slice(9, -1).split(/, /)\n sx = +ta[0]\n sy = +ta[5]\n dx = +ta[12]\n dy = +ta[13]\n } else if (tx.startsWith('matrix(')) {\n ta = tx.slice(7, -1).split(/, /)\n sx = +ta[0]\n sy = +ta[3]\n dx = +ta[4]\n dy = +ta[5]\n } else {\n return new Box(rect)\n }\n\n const to = style.transformOrigin\n const x = rect.x - dx - (1 - sx) * parseFloat(to)\n const y = rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(' ') + 1))\n const w = sx ? rect.width / sx : el.offsetWidth + 1\n const h = sy ? rect.height / sy : el.offsetHeight + 1\n\n return new Box({ x, y, width: w, height: h })\n } else {\n return new Box(rect)\n }\n}\n\nexport function animate (\n el: Element,\n keyframes: Keyframe[] | PropertyIndexedKeyframes | null,\n options?: number | KeyframeAnimationOptions\n) {\n if (typeof el.animate === 'undefined') return { finished: Promise.resolve() }\n\n let animation: Animation\n try {\n animation = el.animate(keyframes, options)\n } catch (err) {\n return { finished: Promise.resolve() }\n }\n\n if (typeof animation.finished === 'undefined') {\n (animation as any).finished = new Promise(resolve => {\n animation.onfinish = () => {\n resolve(animation)\n }\n })\n }\n\n return animation\n}\n"],"mappings":"AAAA;AAAA,SACSA,GAAG;AAEZ;AACA,OAAO,SAASC,iBAAiBA,CAAEC,EAAe,EAAO;EACvD,MAAMC,IAAI,GAAGD,EAAE,CAACE,qBAAqB,CAAC,CAAC;EACvC,MAAMC,KAAK,GAAGC,gBAAgB,CAACJ,EAAE,CAAC;EAClC,MAAMK,EAAE,GAAGF,KAAK,CAACG,SAAS;EAE1B,IAAID,EAAE,EAAE;IACN,IAAIE,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAEC,EAAE,EAAEC,EAAE;IACtB,IAAIN,EAAE,CAACO,UAAU,CAAC,WAAW,CAAC,EAAE;MAC9BL,EAAE,GAAGF,EAAE,CAACQ,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAACC,KAAK,CAAC,IAAI,CAAC;MAChCN,EAAE,GAAG,CAACD,EAAE,CAAC,CAAC,CAAC;MACXE,EAAE,GAAG,CAACF,EAAE,CAAC,CAAC,CAAC;MACXG,EAAE,GAAG,CAACH,EAAE,CAAC,EAAE,CAAC;MACZI,EAAE,GAAG,CAACJ,EAAE,CAAC,EAAE,CAAC;IACd,CAAC,MAAM,IAAIF,EAAE,CAACO,UAAU,CAAC,SAAS,CAAC,EAAE;MACnCL,EAAE,GAAGF,EAAE,CAACQ,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAACC,KAAK,CAAC,IAAI,CAAC;MAChCN,EAAE,GAAG,CAACD,EAAE,CAAC,CAAC,CAAC;MACXE,EAAE,GAAG,CAACF,EAAE,CAAC,CAAC,CAAC;MACXG,EAAE,GAAG,CAACH,EAAE,CAAC,CAAC,CAAC;MACXI,EAAE,GAAG,CAACJ,EAAE,CAAC,CAAC,CAAC;IACb,CAAC,MAAM;MACL,OAAO,IAAIT,GAAG,CAACG,IAAI,CAAC;IACtB;IAEA,MAAMc,EAAE,GAAGZ,KAAK,CAACa,eAAe;IAChC,MAAMC,CAAC,GAAGhB,IAAI,CAACgB,CAAC,GAAGP,EAAE,GAAG,CAAC,CAAC,GAAGF,EAAE,IAAIU,UAAU,CAACH,EAAE,CAAC;IACjD,MAAMI,CAAC,GAAGlB,IAAI,CAACkB,CAAC,GAAGR,EAAE,GAAG,CAAC,CAAC,GAAGF,EAAE,IAAIS,UAAU,CAACH,EAAE,CAACF,KAAK,CAACE,EAAE,CAACK,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5E,MAAMC,CAAC,GAAGb,EAAE,GAAGP,IAAI,CAACqB,KAAK,GAAGd,EAAE,GAAGR,EAAE,CAACuB,WAAW,GAAG,CAAC;IACnD,MAAMC,CAAC,GAAGf,EAAE,GAAGR,IAAI,CAACwB,MAAM,GAAGhB,EAAE,GAAGT,EAAE,CAAC0B,YAAY,GAAG,CAAC;IAErD,OAAO,IAAI5B,GAAG,CAAC;MAAEmB,CAAC;MAAEE,CAAC;MAAEG,KAAK,EAAED,CAAC;MAAEI,MAAM,EAAED;IAAE,CAAC,CAAC;EAC/C,CAAC,MAAM;IACL,OAAO,IAAI1B,GAAG,CAACG,IAAI,CAAC;EACtB;AACF;AAEA,OAAO,SAAS0B,OAAOA,CACrB3B,EAAW,EACX4B,SAAuD,EACvDC,OAA2C,EAC3C;EACA,IAAI,OAAO7B,EAAE,CAAC2B,OAAO,KAAK,WAAW,EAAE,OAAO;IAAEG,QAAQ,EAAEC,OAAO,CAACC,OAAO,CAAC;EAAE,CAAC;EAE7E,IAAIC,SAAoB;EACxB,IAAI;IACFA,SAAS,GAAGjC,EAAE,CAAC2B,OAAO,CAACC,SAAS,EAAEC,OAAO,CAAC;EAC5C,CAAC,CAAC,OAAOK,GAAG,EAAE;IACZ,OAAO;MAAEJ,QAAQ,EAAEC,OAAO,CAACC,OAAO,CAAC;IAAE,CAAC;EACxC;EAEA,IAAI,OAAOC,SAAS,CAACH,QAAQ,KAAK,WAAW,EAAE;IAC5CG,SAAS,CAASH,QAAQ,GAAG,IAAIC,OAAO,CAACC,OAAO,IAAI;MACnDC,SAAS,CAACE,QAAQ,GAAG,MAAM;QACzBH,OAAO,CAACC,SAAS,CAAC;MACpB,CAAC;IACH,CAAC,CAAC;EACJ;EAEA,OAAOA,SAAS;AAClB"}

49
VApp/node_modules/vuetify/lib/util/bindProps.mjs generated vendored Normal file
View File

@ -0,0 +1,49 @@
// Utilities
import { eventName, isOn } from "./helpers.mjs";
const handlers = new WeakMap();
export function bindProps(el, props) {
Object.keys(props).forEach(k => {
if (isOn(k)) {
const name = eventName(k);
const handler = handlers.get(el);
if (props[k] == null) {
handler?.forEach(v => {
const [n, fn] = v;
if (n === name) {
el.removeEventListener(name, fn);
handler.delete(v);
}
});
} else if (!handler || ![...handler]?.some(v => v[0] === name && v[1] === props[k])) {
el.addEventListener(name, props[k]);
const _handler = handler || 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]);
}
}
});
}
export function unbindProps(el, props) {
Object.keys(props).forEach(k => {
if (isOn(k)) {
const name = eventName(k);
const handler = handlers.get(el);
handler?.forEach(v => {
const [n, fn] = v;
if (n === name) {
el.removeEventListener(name, fn);
handler.delete(v);
}
});
} else {
el.removeAttribute(k);
}
});
}
//# sourceMappingURL=bindProps.mjs.map

1
VApp/node_modules/vuetify/lib/util/bindProps.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"bindProps.mjs","names":["eventName","isOn","handlers","WeakMap","bindProps","el","props","Object","keys","forEach","k","name","handler","get","v","n","fn","removeEventListener","delete","some","addEventListener","_handler","Set","add","has","set","removeAttribute","setAttribute","unbindProps"],"sources":["../../src/util/bindProps.ts"],"sourcesContent":["// Utilities\nimport { eventName, isOn } from '@/util/helpers'\n\nconst handlers = new WeakMap<HTMLElement, Set<[string, () => void]>>()\n\nexport function bindProps (el: HTMLElement, props: Record<string, any>) {\n Object.keys(props).forEach(k => {\n if (isOn(k)) {\n const name = eventName(k)\n const handler = handlers.get(el)\n if (props[k] == null) {\n handler?.forEach(v => {\n const [n, fn] = v\n if (n === name) {\n el.removeEventListener(name, fn)\n handler.delete(v)\n }\n })\n } else if (!handler || ![...handler]?.some(v => v[0] === name && v[1] === props[k])) {\n el.addEventListener(name, props[k])\n const _handler = handler || new Set()\n _handler.add([name, props[k]])\n if (!handlers.has(el)) handlers.set(el, _handler)\n }\n } else {\n if (props[k] == null) {\n el.removeAttribute(k)\n } else {\n el.setAttribute(k, props[k])\n }\n }\n })\n}\n\nexport function unbindProps (el: HTMLElement, props: Record<string, any>) {\n Object.keys(props).forEach(k => {\n if (isOn(k)) {\n const name = eventName(k)\n const handler = handlers.get(el)\n handler?.forEach(v => {\n const [n, fn] = v\n if (n === name) {\n el.removeEventListener(name, fn)\n handler.delete(v)\n }\n })\n } else {\n el.removeAttribute(k)\n }\n })\n}\n"],"mappings":"AAAA;AAAA,SACSA,SAAS,EAAEC,IAAI;AAExB,MAAMC,QAAQ,GAAG,IAAIC,OAAO,CAAyC,CAAC;AAEtE,OAAO,SAASC,SAASA,CAAEC,EAAe,EAAEC,KAA0B,EAAE;EACtEC,MAAM,CAACC,IAAI,CAACF,KAAK,CAAC,CAACG,OAAO,CAACC,CAAC,IAAI;IAC9B,IAAIT,IAAI,CAACS,CAAC,CAAC,EAAE;MACX,MAAMC,IAAI,GAAGX,SAAS,CAACU,CAAC,CAAC;MACzB,MAAME,OAAO,GAAGV,QAAQ,CAACW,GAAG,CAACR,EAAE,CAAC;MAChC,IAAIC,KAAK,CAACI,CAAC,CAAC,IAAI,IAAI,EAAE;QACpBE,OAAO,EAAEH,OAAO,CAACK,CAAC,IAAI;UACpB,MAAM,CAACC,CAAC,EAAEC,EAAE,CAAC,GAAGF,CAAC;UACjB,IAAIC,CAAC,KAAKJ,IAAI,EAAE;YACdN,EAAE,CAACY,mBAAmB,CAACN,IAAI,EAAEK,EAAE,CAAC;YAChCJ,OAAO,CAACM,MAAM,CAACJ,CAAC,CAAC;UACnB;QACF,CAAC,CAAC;MACJ,CAAC,MAAM,IAAI,CAACF,OAAO,IAAI,CAAC,CAAC,GAAGA,OAAO,CAAC,EAAEO,IAAI,CAACL,CAAC,IAAIA,CAAC,CAAC,CAAC,CAAC,KAAKH,IAAI,IAAIG,CAAC,CAAC,CAAC,CAAC,KAAKR,KAAK,CAACI,CAAC,CAAC,CAAC,EAAE;QACnFL,EAAE,CAACe,gBAAgB,CAACT,IAAI,EAAEL,KAAK,CAACI,CAAC,CAAC,CAAC;QACnC,MAAMW,QAAQ,GAAGT,OAAO,IAAI,IAAIU,GAAG,CAAC,CAAC;QACrCD,QAAQ,CAACE,GAAG,CAAC,CAACZ,IAAI,EAAEL,KAAK,CAACI,CAAC,CAAC,CAAC,CAAC;QAC9B,IAAI,CAACR,QAAQ,CAACsB,GAAG,CAACnB,EAAE,CAAC,EAAEH,QAAQ,CAACuB,GAAG,CAACpB,EAAE,EAAEgB,QAAQ,CAAC;MACnD;IACF,CAAC,MAAM;MACL,IAAIf,KAAK,CAACI,CAAC,CAAC,IAAI,IAAI,EAAE;QACpBL,EAAE,CAACqB,eAAe,CAAChB,CAAC,CAAC;MACvB,CAAC,MAAM;QACLL,EAAE,CAACsB,YAAY,CAACjB,CAAC,EAAEJ,KAAK,CAACI,CAAC,CAAC,CAAC;MAC9B;IACF;EACF,CAAC,CAAC;AACJ;AAEA,OAAO,SAASkB,WAAWA,CAAEvB,EAAe,EAAEC,KAA0B,EAAE;EACxEC,MAAM,CAACC,IAAI,CAACF,KAAK,CAAC,CAACG,OAAO,CAACC,CAAC,IAAI;IAC9B,IAAIT,IAAI,CAACS,CAAC,CAAC,EAAE;MACX,MAAMC,IAAI,GAAGX,SAAS,CAACU,CAAC,CAAC;MACzB,MAAME,OAAO,GAAGV,QAAQ,CAACW,GAAG,CAACR,EAAE,CAAC;MAChCO,OAAO,EAAEH,OAAO,CAACK,CAAC,IAAI;QACpB,MAAM,CAACC,CAAC,EAAEC,EAAE,CAAC,GAAGF,CAAC;QACjB,IAAIC,CAAC,KAAKJ,IAAI,EAAE;UACdN,EAAE,CAACY,mBAAmB,CAACN,IAAI,EAAEK,EAAE,CAAC;UAChCJ,OAAO,CAACM,MAAM,CAACJ,CAAC,CAAC;QACnB;MACF,CAAC,CAAC;IACJ,CAAC,MAAM;MACLT,EAAE,CAACqB,eAAe,CAAChB,CAAC,CAAC;IACvB;EACF,CAAC,CAAC;AACJ"}

51
VApp/node_modules/vuetify/lib/util/box.mjs generated vendored Normal file
View File

@ -0,0 +1,51 @@
export class Box {
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;
}
}
export 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)
}
};
}
export function getTargetBox(target) {
if (Array.isArray(target)) {
return new Box({
x: target[0],
y: target[1],
width: 0,
height: 0
});
} else {
return target.getBoundingClientRect();
}
}
//# sourceMappingURL=box.mjs.map

1
VApp/node_modules/vuetify/lib/util/box.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"box.mjs","names":["Box","constructor","_ref","x","y","width","height","top","bottom","left","right","getOverflow","a","b","before","Math","max","after","getTargetBox","target","Array","isArray","getBoundingClientRect"],"sources":["../../src/util/box.ts"],"sourcesContent":["export class Box {\n x: number\n y: number\n width: number\n height: number\n\n constructor ({ x, y, width, height }: {\n x: number\n y: number\n width: number\n height: number\n }) {\n this.x = x\n this.y = y\n this.width = width\n this.height = height\n }\n\n get top () { return this.y }\n get bottom () { return this.y + this.height }\n get left () { return this.x }\n get right () { return this.x + this.width }\n}\n\nexport function getOverflow (a: Box, b: Box) {\n return {\n x: {\n before: Math.max(0, b.left - a.left),\n after: Math.max(0, a.right - b.right),\n },\n y: {\n before: Math.max(0, b.top - a.top),\n after: Math.max(0, a.bottom - b.bottom),\n },\n }\n}\n\nexport function getTargetBox (target: HTMLElement | [x: number, y: number]) {\n if (Array.isArray(target)) {\n return new Box({\n x: target[0],\n y: target[1],\n width: 0,\n height: 0,\n })\n } else {\n return target.getBoundingClientRect()\n }\n}\n"],"mappings":"AAAA,OAAO,MAAMA,GAAG,CAAC;EAMfC,WAAWA,CAAAC,IAAA,EAKR;IAAA,IALU;MAAEC,CAAC;MAAEC,CAAC;MAAEC,KAAK;MAAEC;IAK5B,CAAC,GAAAJ,IAAA;IACC,IAAI,CAACC,CAAC,GAAGA,CAAC;IACV,IAAI,CAACC,CAAC,GAAGA,CAAC;IACV,IAAI,CAACC,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACC,MAAM,GAAGA,MAAM;EACtB;EAEA,IAAIC,GAAGA,CAAA,EAAI;IAAE,OAAO,IAAI,CAACH,CAAC;EAAC;EAC3B,IAAII,MAAMA,CAAA,EAAI;IAAE,OAAO,IAAI,CAACJ,CAAC,GAAG,IAAI,CAACE,MAAM;EAAC;EAC5C,IAAIG,IAAIA,CAAA,EAAI;IAAE,OAAO,IAAI,CAACN,CAAC;EAAC;EAC5B,IAAIO,KAAKA,CAAA,EAAI;IAAE,OAAO,IAAI,CAACP,CAAC,GAAG,IAAI,CAACE,KAAK;EAAC;AAC5C;AAEA,OAAO,SAASM,WAAWA,CAAEC,CAAM,EAAEC,CAAM,EAAE;EAC3C,OAAO;IACLV,CAAC,EAAE;MACDW,MAAM,EAAEC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEH,CAAC,CAACJ,IAAI,GAAGG,CAAC,CAACH,IAAI,CAAC;MACpCQ,KAAK,EAAEF,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEJ,CAAC,CAACF,KAAK,GAAGG,CAAC,CAACH,KAAK;IACtC,CAAC;IACDN,CAAC,EAAE;MACDU,MAAM,EAAEC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEH,CAAC,CAACN,GAAG,GAAGK,CAAC,CAACL,GAAG,CAAC;MAClCU,KAAK,EAAEF,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEJ,CAAC,CAACJ,MAAM,GAAGK,CAAC,CAACL,MAAM;IACxC;EACF,CAAC;AACH;AAEA,OAAO,SAASU,YAAYA,CAAEC,MAA4C,EAAE;EAC1E,IAAIC,KAAK,CAACC,OAAO,CAACF,MAAM,CAAC,EAAE;IACzB,OAAO,IAAInB,GAAG,CAAC;MACbG,CAAC,EAAEgB,MAAM,CAAC,CAAC,CAAC;MACZf,CAAC,EAAEe,MAAM,CAAC,CAAC,CAAC;MACZd,KAAK,EAAE,CAAC;MACRC,MAAM,EAAE;IACV,CAAC,CAAC;EACJ,CAAC,MAAM;IACL,OAAOa,MAAM,CAACG,qBAAqB,CAAC,CAAC;EACvC;AACF"}

88
VApp/node_modules/vuetify/lib/util/color/APCA.mjs generated vendored Normal file
View File

@ -0,0 +1,88 @@
/**
* WCAG 3.0 APCA perceptual contrast algorithm from https://github.com/Myndex/SAPC-APCA
* @licence https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document
* @see https://www.w3.org/WAI/GL/task-forces/silver/wiki/Visual_Contrast_of_Text_Subgroup
*/
// Types
// MAGICAL NUMBERS
// sRGB Conversion to Relative Luminance (Y)
// Transfer Curve (aka "Gamma") for sRGB linearization
// Simple power curve vs piecewise described in docs
// Essentially, 2.4 best models actual display
// characteristics in combination with the total method
const mainTRC = 2.4;
const Rco = 0.2126729; // sRGB Red Coefficient (from matrix)
const Gco = 0.7151522; // sRGB Green Coefficient (from matrix)
const Bco = 0.0721750; // sRGB Blue Coefficient (from matrix)
// For Finding Raw SAPC Contrast from Relative Luminance (Y)
// Constants for SAPC Power Curve Exponents
// One pair for normal text, and one for reverse
// These are the "beating heart" of SAPC
const normBG = 0.55;
const normTXT = 0.58;
const revTXT = 0.57;
const revBG = 0.62;
// For Clamping and Scaling Values
const blkThrs = 0.03; // Level that triggers the soft black clamp
const blkClmp = 1.45; // Exponent for the soft black clamp curve
const deltaYmin = 0.0005; // Lint trap
const scaleBoW = 1.25; // Scaling for dark text on light
const scaleWoB = 1.25; // Scaling for light text on dark
const loConThresh = 0.078; // Threshold for new simple offset scale
const loConFactor = 12.82051282051282; // = 1/0.078,
const loConOffset = 0.06; // The simple offset
const loClip = 0.001; // Output clip (lint trap #2)
export function APCAcontrast(text, background) {
// Linearize sRGB
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;
// Apply the standard coefficients and sum to Y
let Ytxt = Rtxt * Rco + Gtxt * Gco + Btxt * Bco;
let Ybg = Rbg * Rco + Gbg * Gco + Bbg * Bco;
// Soft clamp Y when near black.
// Now clamping all colors to prevent crossover errors
if (Ytxt <= blkThrs) Ytxt += (blkThrs - Ytxt) ** blkClmp;
if (Ybg <= blkThrs) Ybg += (blkThrs - Ybg) ** blkClmp;
// Return 0 Early for extremely low ∆Y (lint trap #1)
if (Math.abs(Ybg - Ytxt) < deltaYmin) return 0.0;
// SAPC CONTRAST
let outputContrast; // For weighted final values
if (Ybg > Ytxt) {
// For normal polarity, black text on white
// Calculate the SAPC contrast value and scale
const SAPC = (Ybg ** normBG - Ytxt ** normTXT) * scaleBoW;
// NEW! SAPC SmoothScale™
// Low Contrast Smooth Scale Rollout to prevent polarity reversal
// and also a low clip for very low contrasts (lint trap #2)
// much of this is for very low contrasts, less than 10
// therefore for most reversing needs, only loConOffset is important
outputContrast = SAPC < loClip ? 0.0 : SAPC < loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC - loConOffset;
} else {
// For reverse polarity, light text on dark
// WoB should always return negative value.
const SAPC = (Ybg ** revBG - Ytxt ** revTXT) * scaleWoB;
outputContrast = SAPC > -loClip ? 0.0 : SAPC > -loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC + loConOffset;
}
return outputContrast * 100;
}
//# sourceMappingURL=APCA.mjs.map

1
VApp/node_modules/vuetify/lib/util/color/APCA.mjs.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

17
VApp/node_modules/vuetify/lib/util/color/transformCIELAB.mjs generated vendored Normal file
View File

@ -0,0 +1,17 @@
// Types
const delta = 0.20689655172413793; // 6÷29
const cielabForwardTransform = t => t > delta ** 3 ? Math.cbrt(t) : t / (3 * delta ** 2) + 4 / 29;
const cielabReverseTransform = t => t > delta ? t ** 3 : 3 * delta ** 2 * (t - 4 / 29);
export 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))];
}
export 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];
}
//# sourceMappingURL=transformCIELAB.mjs.map

1
VApp/node_modules/vuetify/lib/util/color/transformCIELAB.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"transformCIELAB.mjs","names":["delta","cielabForwardTransform","t","Math","cbrt","cielabReverseTransform","fromXYZ","xyz","transform","transformedY","toXYZ","lab","Ln"],"sources":["../../../src/util/color/transformCIELAB.ts"],"sourcesContent":["// Types\nimport type { LAB, XYZ } from '../colorUtils'\n\nconst delta = 0.20689655172413793 // 6÷29\n\nconst cielabForwardTransform = (t: number): number => (\n t > delta ** 3\n ? Math.cbrt(t)\n : (t / (3 * delta ** 2)) + 4 / 29\n)\n\nconst cielabReverseTransform = (t: number): number => (\n t > delta\n ? t ** 3\n : (3 * delta ** 2) * (t - 4 / 29)\n)\n\nexport function fromXYZ (xyz: XYZ): LAB {\n const transform = cielabForwardTransform\n const transformedY = transform(xyz[1])\n\n return [\n 116 * transformedY - 16,\n 500 * (transform(xyz[0] / 0.95047) - transformedY),\n 200 * (transformedY - transform(xyz[2] / 1.08883)),\n ]\n}\n\nexport function toXYZ (lab: LAB): XYZ {\n const transform = cielabReverseTransform\n const Ln = (lab[0] + 16) / 116\n return [\n transform(Ln + lab[1] / 500) * 0.95047,\n transform(Ln),\n transform(Ln - lab[2] / 200) * 1.08883,\n ]\n}\n"],"mappings":"AAAA;;AAGA,MAAMA,KAAK,GAAG,mBAAmB,EAAC;;AAElC,MAAMC,sBAAsB,GAAIC,CAAS,IACvCA,CAAC,GAAGF,KAAK,IAAI,CAAC,GACVG,IAAI,CAACC,IAAI,CAACF,CAAC,CAAC,GACXA,CAAC,IAAI,CAAC,GAAGF,KAAK,IAAI,CAAC,CAAC,GAAI,CAAC,GAAG,EAClC;AAED,MAAMK,sBAAsB,GAAIH,CAAS,IACvCA,CAAC,GAAGF,KAAK,GACLE,CAAC,IAAI,CAAC,GACL,CAAC,GAAGF,KAAK,IAAI,CAAC,IAAKE,CAAC,GAAG,CAAC,GAAG,EAAE,CACnC;AAED,OAAO,SAASI,OAAOA,CAAEC,GAAQ,EAAO;EACtC,MAAMC,SAAS,GAAGP,sBAAsB;EACxC,MAAMQ,YAAY,GAAGD,SAAS,CAACD,GAAG,CAAC,CAAC,CAAC,CAAC;EAEtC,OAAO,CACL,GAAG,GAAGE,YAAY,GAAG,EAAE,EACvB,GAAG,IAAID,SAAS,CAACD,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,GAAGE,YAAY,CAAC,EAClD,GAAG,IAAIA,YAAY,GAAGD,SAAS,CAACD,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CACnD;AACH;AAEA,OAAO,SAASG,KAAKA,CAAEC,GAAQ,EAAO;EACpC,MAAMH,SAAS,GAAGH,sBAAsB;EACxC,MAAMO,EAAE,GAAG,CAACD,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,GAAG;EAC9B,OAAO,CACLH,SAAS,CAACI,EAAE,GAAGD,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,OAAO,EACtCH,SAAS,CAACI,EAAE,CAAC,EACbJ,SAAS,CAACI,EAAE,GAAGD,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,OAAO,CACvC;AACH"}

51
VApp/node_modules/vuetify/lib/util/color/transformSRGB.mjs generated vendored Normal file
View File

@ -0,0 +1,51 @@
// Utilities
import { clamp } from "../helpers.mjs"; // Types
// For converting XYZ to sRGB
const srgbForwardMatrix = [[3.2406, -1.5372, -0.4986], [-0.9689, 1.8758, 0.0415], [0.0557, -0.2040, 1.0570]];
// Forward gamma adjust
const srgbForwardTransform = C => C <= 0.0031308 ? C * 12.92 : 1.055 * C ** (1 / 2.4) - 0.055;
// For converting sRGB to XYZ
const srgbReverseMatrix = [[0.4124, 0.3576, 0.1805], [0.2126, 0.7152, 0.0722], [0.0193, 0.1192, 0.9505]];
// Reverse gamma adjust
const srgbReverseTransform = C => C <= 0.04045 ? C / 12.92 : ((C + 0.055) / 1.055) ** 2.4;
export function fromXYZ(xyz) {
const rgb = Array(3);
const transform = srgbForwardTransform;
const matrix = srgbForwardMatrix;
// Matrix transform, then gamma adjustment
for (let i = 0; i < 3; ++i) {
// Rescale back to [0, 255]
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]
};
}
export function toXYZ(_ref) {
let {
r,
g,
b
} = _ref;
const xyz = [0, 0, 0];
const transform = srgbReverseTransform;
const matrix = srgbReverseMatrix;
// Rescale from [0, 255] to [0, 1] then adjust sRGB gamma to linear RGB
r = transform(r / 255);
g = transform(g / 255);
b = transform(b / 255);
// Matrix color space transform
for (let i = 0; i < 3; ++i) {
xyz[i] = matrix[i][0] * r + matrix[i][1] * g + matrix[i][2] * b;
}
return xyz;
}
//# sourceMappingURL=transformSRGB.mjs.map

1
VApp/node_modules/vuetify/lib/util/color/transformSRGB.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"transformSRGB.mjs","names":["clamp","srgbForwardMatrix","srgbForwardTransform","C","srgbReverseMatrix","srgbReverseTransform","fromXYZ","xyz","rgb","Array","transform","matrix","i","Math","round","r","g","b","toXYZ","_ref"],"sources":["../../../src/util/color/transformSRGB.ts"],"sourcesContent":["// Utilities\nimport { clamp } from '@/util/helpers'\n\n// Types\nimport type { RGB, XYZ } from '../colorUtils'\n\n// For converting XYZ to sRGB\nconst srgbForwardMatrix = [\n [3.2406, -1.5372, -0.4986],\n [-0.9689, 1.8758, 0.0415],\n [0.0557, -0.2040, 1.0570],\n]\n\n// Forward gamma adjust\nconst srgbForwardTransform = (C: number): number => (\n C <= 0.0031308\n ? C * 12.92\n : 1.055 * C ** (1 / 2.4) - 0.055\n)\n\n// For converting sRGB to XYZ\nconst srgbReverseMatrix = [\n [0.4124, 0.3576, 0.1805],\n [0.2126, 0.7152, 0.0722],\n [0.0193, 0.1192, 0.9505],\n]\n\n// Reverse gamma adjust\nconst srgbReverseTransform = (C: number): number => (\n C <= 0.04045\n ? C / 12.92\n : ((C + 0.055) / 1.055) ** 2.4\n)\n\nexport function fromXYZ (xyz: XYZ): RGB {\n const rgb = Array(3)\n const transform = srgbForwardTransform\n const matrix = srgbForwardMatrix\n\n // Matrix transform, then gamma adjustment\n for (let i = 0; i < 3; ++i) {\n // Rescale back to [0, 255]\n rgb[i] = Math.round(clamp(transform(\n matrix[i][0] * xyz[0] +\n matrix[i][1] * xyz[1] +\n matrix[i][2] * xyz[2]\n )) * 255)\n }\n\n return {\n r: rgb[0],\n g: rgb[1],\n b: rgb[2],\n }\n}\n\nexport function toXYZ ({ r, g, b }: RGB): XYZ {\n const xyz: XYZ = [0, 0, 0]\n const transform = srgbReverseTransform\n const matrix = srgbReverseMatrix\n\n // Rescale from [0, 255] to [0, 1] then adjust sRGB gamma to linear RGB\n r = transform(r / 255)\n g = transform(g / 255)\n b = transform(b / 255)\n\n // Matrix color space transform\n for (let i = 0; i < 3; ++i) {\n xyz[i] = matrix[i][0] * r + matrix[i][1] * g + matrix[i][2] * b\n }\n\n return xyz\n}\n"],"mappings":"AAAA;AAAA,SACSA,KAAK,0BAEd;AAGA;AACA,MAAMC,iBAAiB,GAAG,CACxB,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,EAC1B,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACzB,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAC1B;;AAED;AACA,MAAMC,oBAAoB,GAAIC,CAAS,IACrCA,CAAC,IAAI,SAAS,GACVA,CAAC,GAAG,KAAK,GACT,KAAK,GAAGA,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,GAAG,KAC9B;;AAED;AACA,MAAMC,iBAAiB,GAAG,CACxB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CACzB;;AAED;AACA,MAAMC,oBAAoB,GAAIF,CAAS,IACrCA,CAAC,IAAI,OAAO,GACRA,CAAC,GAAG,KAAK,GACT,CAAC,CAACA,CAAC,GAAG,KAAK,IAAI,KAAK,KAAK,GAC9B;AAED,OAAO,SAASG,OAAOA,CAAEC,GAAQ,EAAO;EACtC,MAAMC,GAAG,GAAGC,KAAK,CAAC,CAAC,CAAC;EACpB,MAAMC,SAAS,GAAGR,oBAAoB;EACtC,MAAMS,MAAM,GAAGV,iBAAiB;;EAEhC;EACA,KAAK,IAAIW,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAE,EAAEA,CAAC,EAAE;IAC1B;IACAJ,GAAG,CAACI,CAAC,CAAC,GAAGC,IAAI,CAACC,KAAK,CAACd,KAAK,CAACU,SAAS,CACjCC,MAAM,CAACC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAGL,GAAG,CAAC,CAAC,CAAC,GACrBI,MAAM,CAACC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAGL,GAAG,CAAC,CAAC,CAAC,GACrBI,MAAM,CAACC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAGL,GAAG,CAAC,CAAC,CACtB,CAAC,CAAC,GAAG,GAAG,CAAC;EACX;EAEA,OAAO;IACLQ,CAAC,EAAEP,GAAG,CAAC,CAAC,CAAC;IACTQ,CAAC,EAAER,GAAG,CAAC,CAAC,CAAC;IACTS,CAAC,EAAET,GAAG,CAAC,CAAC;EACV,CAAC;AACH;AAEA,OAAO,SAASU,KAAKA,CAAAC,IAAA,EAAyB;EAAA,IAAvB;IAAEJ,CAAC;IAAEC,CAAC;IAAEC;EAAO,CAAC,GAAAE,IAAA;EACrC,MAAMZ,GAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;EAC1B,MAAMG,SAAS,GAAGL,oBAAoB;EACtC,MAAMM,MAAM,GAAGP,iBAAiB;;EAEhC;EACAW,CAAC,GAAGL,SAAS,CAACK,CAAC,GAAG,GAAG,CAAC;EACtBC,CAAC,GAAGN,SAAS,CAACM,CAAC,GAAG,GAAG,CAAC;EACtBC,CAAC,GAAGP,SAAS,CAACO,CAAC,GAAG,GAAG,CAAC;;EAEtB;EACA,KAAK,IAAIL,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAG,CAAC,EAAE,EAAEA,CAAC,EAAE;IAC1BL,GAAG,CAACK,CAAC,CAAC,GAAGD,MAAM,CAACC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAGG,CAAC,GAAGJ,MAAM,CAACC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAGI,CAAC,GAAGL,MAAM,CAACC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAGK,CAAC;EACjE;EAEA,OAAOV,GAAG;AACZ"}

319
VApp/node_modules/vuetify/lib/util/colorUtils.mjs generated vendored Normal file
View File

@ -0,0 +1,319 @@
// Utilities
import { APCAcontrast } from "./color/APCA.mjs";
import { consoleWarn } from "./console.mjs";
import { chunk, has, padEnd } from "./helpers.mjs";
import * as CIELAB from "./color/transformCIELAB.mjs";
import * as sRGB from "./color/transformSRGB.mjs"; // Types
export function isCssColor(color) {
return !!color && /^(#|var\(--|(rgb|hsl)a?\()/.test(color);
}
export function isParsableColor(color) {
return isCssColor(color) && !/^((rgb|hsl)a?\()?var\(--/.test(color);
}
const cssColorRe = /^(?<fn>(?:rgb|hsl)a?)\((?<values>.+)\)/;
const mappers = {
rgb: (r, g, b, a) => ({
r,
g,
b,
a
}),
rgba: (r, g, b, a) => ({
r,
g,
b,
a
}),
hsl: (h, s, l, a) => HSLtoRGB({
h,
s,
l,
a
}),
hsla: (h, s, l, a) => HSLtoRGB({
h,
s,
l,
a
}),
hsv: (h, s, v, a) => HSVtoRGB({
h,
s,
v,
a
}),
hsva: (h, s, v, a) => HSVtoRGB({
h,
s,
v,
a
})
};
export function parseColor(color) {
if (typeof color === 'number') {
if (isNaN(color) || color < 0 || color > 0xFFFFFF) {
// int can't have opacity
consoleWarn(`'${color}' is not a valid hex color`);
}
return {
r: (color & 0xFF0000) >> 16,
g: (color & 0xFF00) >> 8,
b: color & 0xFF
};
} 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 > 0xFFFFFFFF) {
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}\nExpected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
}
export function RGBToInt(color) {
return (color.r << 16) + (color.g << 8) + color.b;
}
export function classToHex(color, colors, currentTheme) {
const [colorName, colorModifier] = color.toString().trim().replace('-', '').split(' ', 2);
let hexColor = '';
if (colorName && colorName in colors) {
if (colorModifier && colorModifier in colors[colorName]) {
hexColor = colors[colorName][colorModifier];
} else if ('base' in colors[colorName]) {
hexColor = colors[colorName].base;
}
} else if (colorName && colorName in currentTheme) {
hexColor = currentTheme[colorName];
}
return hexColor;
}
/** Converts HSVA to RGBA. Based on formula from https://en.wikipedia.org/wiki/HSL_and_HSV */
export function HSVtoRGB(hsva) {
const {
h,
s,
v,
a
} = hsva;
const f = n => {
const k = (n + h / 60) % 6;
return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
};
const rgb = [f(5), f(3), f(1)].map(v => Math.round(v * 255));
return {
r: rgb[0],
g: rgb[1],
b: rgb[2],
a
};
}
export function HSLtoRGB(hsla) {
return HSVtoRGB(HSLtoHSV(hsla));
}
/** Converts RGBA to HSVA. Based on formula from https://en.wikipedia.org/wiki/HSL_and_HSV */
export 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 h = 0;
if (max !== min) {
if (max === r) {
h = 60 * (0 + (g - b) / (max - min));
} else if (max === g) {
h = 60 * (2 + (b - r) / (max - min));
} else if (max === b) {
h = 60 * (4 + (r - g) / (max - min));
}
}
if (h < 0) h = h + 360;
const s = max === 0 ? 0 : (max - min) / max;
const hsv = [h, s, max];
return {
h: hsv[0],
s: hsv[1],
v: hsv[2],
a: rgba.a
};
}
export function HSVtoHSL(hsva) {
const {
h,
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,
s: sprime,
l,
a
};
}
export function HSLtoHSV(hsl) {
const {
h,
s,
l,
a
} = hsl;
const v = l + s * Math.min(l, 1 - l);
const sprime = v === 0 ? 0 : 2 - 2 * l / v;
return {
h,
s: sprime,
v,
a
};
}
export function RGBtoCSS(_ref) {
let {
r,
g,
b,
a
} = _ref;
return a === undefined ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${a})`;
}
export function HSVtoCSS(hsva) {
return RGBtoCSS(HSVtoRGB(hsva));
}
function toHex(v) {
const h = Math.round(v).toString(16);
return ('00'.substr(0, 2 - h.length) + h).toUpperCase();
}
export function RGBtoHex(_ref2) {
let {
r,
g,
b,
a
} = _ref2;
return `#${[toHex(r), toHex(g), toHex(b), a !== undefined ? toHex(Math.round(a * 255)) : ''].join('')}`;
}
export function HexToRGB(hex) {
hex = parseHex(hex);
let [r, g, b, a] = chunk(hex, 2).map(c => parseInt(c, 16));
a = a === undefined ? a : a / 255;
return {
r,
g,
b,
a
};
}
export function HexToHSV(hex) {
const rgb = HexToRGB(hex);
return RGBtoHSV(rgb);
}
export function HSVtoHex(hsva) {
return RGBtoHex(HSVtoRGB(hsva));
}
export 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;
}
export function parseGradient(gradient, colors, currentTheme) {
return gradient.replace(/([a-z]+(\s[a-z]+-[1-5])?)(?=$|,)/gi, x => {
return classToHex(x, colors, currentTheme) || x;
}).replace(/(rgba\()#[0-9a-f]+(?=,)/gi, x => {
return 'rgba(' + Object.values(HexToRGB(parseHex(x.replace(/rgba\(/, '')))).slice(0, 3).join(',');
});
}
export function lighten(value, amount) {
const lab = CIELAB.fromXYZ(sRGB.toXYZ(value));
lab[0] = lab[0] + amount * 10;
return sRGB.fromXYZ(CIELAB.toXYZ(lab));
}
export function darken(value, amount) {
const lab = CIELAB.fromXYZ(sRGB.toXYZ(value));
lab[0] = lab[0] - amount * 10;
return sRGB.fromXYZ(CIELAB.toXYZ(lab));
}
/**
* Calculate the relative luminance of a given color
* @see https://www.w3.org/TR/WCAG20/#relativeluminancedef
*/
export function getLuma(color) {
const rgb = parseColor(color);
return sRGB.toXYZ(rgb)[1];
}
/**
* Returns the contrast ratio (1-21) between two colors.
* @see https://www.w3.org/TR/WCAG20/#contrast-ratiodef
*/
export 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);
}
export function getForeground(color) {
const blackContrast = Math.abs(APCAcontrast(parseColor(0), parseColor(color)));
const whiteContrast = Math.abs(APCAcontrast(parseColor(0xffffff), parseColor(color)));
// TODO: warn about poor color selections
// const contrastAsText = Math.abs(APCAcontrast(colorVal, colorToInt(theme.colors.background)))
// const minContrast = Math.max(blackContrast, whiteContrast)
// if (minContrast < 60) {
// consoleInfo(`${key} theme color ${color} has poor contrast (${minContrast.toFixed()}%)`)
// } else if (contrastAsText < 60 && !['background', 'surface'].includes(color)) {
// consoleInfo(`${key} theme color ${color} has poor contrast as text (${contrastAsText.toFixed()}%)`)
// }
// Prefer white text if both have an acceptable contrast ratio
return whiteContrast > Math.min(blackContrast, 50) ? '#fff' : '#000';
}
//# sourceMappingURL=colorUtils.mjs.map

1
VApp/node_modules/vuetify/lib/util/colorUtils.mjs.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

598
VApp/node_modules/vuetify/lib/util/colors.d.mts generated vendored Normal file
View File

@ -0,0 +1,598 @@
declare const red: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const pink: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const purple: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const deepPurple: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const indigo: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const blue: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const lightBlue: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const cyan: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const teal: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const green: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const lightGreen: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const lime: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const yellow: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const amber: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const orange: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const deepOrange: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
declare const brown: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
};
declare const blueGrey: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
};
declare const grey: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
};
declare const shades: {
black: string;
white: string;
transparent: string;
};
declare const _default: {
red: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
pink: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
purple: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
deepPurple: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
indigo: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
blue: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
lightBlue: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
cyan: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
teal: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
green: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
lightGreen: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
lime: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
yellow: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
amber: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
orange: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
deepOrange: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
accent1: string;
accent2: string;
accent3: string;
accent4: string;
};
brown: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
};
blueGrey: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
};
grey: {
base: string;
lighten5: string;
lighten4: string;
lighten3: string;
lighten2: string;
lighten1: string;
darken1: string;
darken2: string;
darken3: string;
darken4: string;
};
shades: {
black: string;
white: string;
transparent: string;
};
};
export { amber, blue, blueGrey, brown, cyan, deepOrange, deepPurple, _default as default, green, grey, indigo, lightBlue, lightGreen, lime, orange, pink, purple, red, shades, teal, yellow };

320
VApp/node_modules/vuetify/lib/util/colors.mjs generated vendored Normal file
View File

@ -0,0 +1,320 @@
export const red = {
base: '#f44336',
lighten5: '#ffebee',
lighten4: '#ffcdd2',
lighten3: '#ef9a9a',
lighten2: '#e57373',
lighten1: '#ef5350',
darken1: '#e53935',
darken2: '#d32f2f',
darken3: '#c62828',
darken4: '#b71c1c',
accent1: '#ff8a80',
accent2: '#ff5252',
accent3: '#ff1744',
accent4: '#d50000'
};
export const pink = {
base: '#e91e63',
lighten5: '#fce4ec',
lighten4: '#f8bbd0',
lighten3: '#f48fb1',
lighten2: '#f06292',
lighten1: '#ec407a',
darken1: '#d81b60',
darken2: '#c2185b',
darken3: '#ad1457',
darken4: '#880e4f',
accent1: '#ff80ab',
accent2: '#ff4081',
accent3: '#f50057',
accent4: '#c51162'
};
export const purple = {
base: '#9c27b0',
lighten5: '#f3e5f5',
lighten4: '#e1bee7',
lighten3: '#ce93d8',
lighten2: '#ba68c8',
lighten1: '#ab47bc',
darken1: '#8e24aa',
darken2: '#7b1fa2',
darken3: '#6a1b9a',
darken4: '#4a148c',
accent1: '#ea80fc',
accent2: '#e040fb',
accent3: '#d500f9',
accent4: '#aa00ff'
};
export const deepPurple = {
base: '#673ab7',
lighten5: '#ede7f6',
lighten4: '#d1c4e9',
lighten3: '#b39ddb',
lighten2: '#9575cd',
lighten1: '#7e57c2',
darken1: '#5e35b1',
darken2: '#512da8',
darken3: '#4527a0',
darken4: '#311b92',
accent1: '#b388ff',
accent2: '#7c4dff',
accent3: '#651fff',
accent4: '#6200ea'
};
export const indigo = {
base: '#3f51b5',
lighten5: '#e8eaf6',
lighten4: '#c5cae9',
lighten3: '#9fa8da',
lighten2: '#7986cb',
lighten1: '#5c6bc0',
darken1: '#3949ab',
darken2: '#303f9f',
darken3: '#283593',
darken4: '#1a237e',
accent1: '#8c9eff',
accent2: '#536dfe',
accent3: '#3d5afe',
accent4: '#304ffe'
};
export const blue = {
base: '#2196f3',
lighten5: '#e3f2fd',
lighten4: '#bbdefb',
lighten3: '#90caf9',
lighten2: '#64b5f6',
lighten1: '#42a5f5',
darken1: '#1e88e5',
darken2: '#1976d2',
darken3: '#1565c0',
darken4: '#0d47a1',
accent1: '#82b1ff',
accent2: '#448aff',
accent3: '#2979ff',
accent4: '#2962ff'
};
export const lightBlue = {
base: '#03a9f4',
lighten5: '#e1f5fe',
lighten4: '#b3e5fc',
lighten3: '#81d4fa',
lighten2: '#4fc3f7',
lighten1: '#29b6f6',
darken1: '#039be5',
darken2: '#0288d1',
darken3: '#0277bd',
darken4: '#01579b',
accent1: '#80d8ff',
accent2: '#40c4ff',
accent3: '#00b0ff',
accent4: '#0091ea'
};
export const cyan = {
base: '#00bcd4',
lighten5: '#e0f7fa',
lighten4: '#b2ebf2',
lighten3: '#80deea',
lighten2: '#4dd0e1',
lighten1: '#26c6da',
darken1: '#00acc1',
darken2: '#0097a7',
darken3: '#00838f',
darken4: '#006064',
accent1: '#84ffff',
accent2: '#18ffff',
accent3: '#00e5ff',
accent4: '#00b8d4'
};
export const teal = {
base: '#009688',
lighten5: '#e0f2f1',
lighten4: '#b2dfdb',
lighten3: '#80cbc4',
lighten2: '#4db6ac',
lighten1: '#26a69a',
darken1: '#00897b',
darken2: '#00796b',
darken3: '#00695c',
darken4: '#004d40',
accent1: '#a7ffeb',
accent2: '#64ffda',
accent3: '#1de9b6',
accent4: '#00bfa5'
};
export const green = {
base: '#4caf50',
lighten5: '#e8f5e9',
lighten4: '#c8e6c9',
lighten3: '#a5d6a7',
lighten2: '#81c784',
lighten1: '#66bb6a',
darken1: '#43a047',
darken2: '#388e3c',
darken3: '#2e7d32',
darken4: '#1b5e20',
accent1: '#b9f6ca',
accent2: '#69f0ae',
accent3: '#00e676',
accent4: '#00c853'
};
export const lightGreen = {
base: '#8bc34a',
lighten5: '#f1f8e9',
lighten4: '#dcedc8',
lighten3: '#c5e1a5',
lighten2: '#aed581',
lighten1: '#9ccc65',
darken1: '#7cb342',
darken2: '#689f38',
darken3: '#558b2f',
darken4: '#33691e',
accent1: '#ccff90',
accent2: '#b2ff59',
accent3: '#76ff03',
accent4: '#64dd17'
};
export const lime = {
base: '#cddc39',
lighten5: '#f9fbe7',
lighten4: '#f0f4c3',
lighten3: '#e6ee9c',
lighten2: '#dce775',
lighten1: '#d4e157',
darken1: '#c0ca33',
darken2: '#afb42b',
darken3: '#9e9d24',
darken4: '#827717',
accent1: '#f4ff81',
accent2: '#eeff41',
accent3: '#c6ff00',
accent4: '#aeea00'
};
export const yellow = {
base: '#ffeb3b',
lighten5: '#fffde7',
lighten4: '#fff9c4',
lighten3: '#fff59d',
lighten2: '#fff176',
lighten1: '#ffee58',
darken1: '#fdd835',
darken2: '#fbc02d',
darken3: '#f9a825',
darken4: '#f57f17',
accent1: '#ffff8d',
accent2: '#ffff00',
accent3: '#ffea00',
accent4: '#ffd600'
};
export const amber = {
base: '#ffc107',
lighten5: '#fff8e1',
lighten4: '#ffecb3',
lighten3: '#ffe082',
lighten2: '#ffd54f',
lighten1: '#ffca28',
darken1: '#ffb300',
darken2: '#ffa000',
darken3: '#ff8f00',
darken4: '#ff6f00',
accent1: '#ffe57f',
accent2: '#ffd740',
accent3: '#ffc400',
accent4: '#ffab00'
};
export const orange = {
base: '#ff9800',
lighten5: '#fff3e0',
lighten4: '#ffe0b2',
lighten3: '#ffcc80',
lighten2: '#ffb74d',
lighten1: '#ffa726',
darken1: '#fb8c00',
darken2: '#f57c00',
darken3: '#ef6c00',
darken4: '#e65100',
accent1: '#ffd180',
accent2: '#ffab40',
accent3: '#ff9100',
accent4: '#ff6d00'
};
export const deepOrange = {
base: '#ff5722',
lighten5: '#fbe9e7',
lighten4: '#ffccbc',
lighten3: '#ffab91',
lighten2: '#ff8a65',
lighten1: '#ff7043',
darken1: '#f4511e',
darken2: '#e64a19',
darken3: '#d84315',
darken4: '#bf360c',
accent1: '#ff9e80',
accent2: '#ff6e40',
accent3: '#ff3d00',
accent4: '#dd2c00'
};
export const brown = {
base: '#795548',
lighten5: '#efebe9',
lighten4: '#d7ccc8',
lighten3: '#bcaaa4',
lighten2: '#a1887f',
lighten1: '#8d6e63',
darken1: '#6d4c41',
darken2: '#5d4037',
darken3: '#4e342e',
darken4: '#3e2723'
};
export const blueGrey = {
base: '#607d8b',
lighten5: '#eceff1',
lighten4: '#cfd8dc',
lighten3: '#b0bec5',
lighten2: '#90a4ae',
lighten1: '#78909c',
darken1: '#546e7a',
darken2: '#455a64',
darken3: '#37474f',
darken4: '#263238'
};
export const grey = {
base: '#9e9e9e',
lighten5: '#fafafa',
lighten4: '#f5f5f5',
lighten3: '#eeeeee',
lighten2: '#e0e0e0',
lighten1: '#bdbdbd',
darken1: '#757575',
darken2: '#616161',
darken3: '#424242',
darken4: '#212121'
};
export const shades = {
black: '#000000',
white: '#ffffff',
transparent: '#ffffff00'
};
export default {
red,
pink,
purple,
deepPurple,
indigo,
blue,
lightBlue,
cyan,
teal,
green,
lightGreen,
lime,
yellow,
amber,
orange,
deepOrange,
brown,
blueGrey,
grey,
shades
};
//# sourceMappingURL=colors.mjs.map

1
VApp/node_modules/vuetify/lib/util/colors.mjs.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

21
VApp/node_modules/vuetify/lib/util/console.mjs generated vendored Normal file
View File

@ -0,0 +1,21 @@
/* eslint-disable no-console */
// Utilities
import { warn } from 'vue';
export function consoleWarn(message) {
warn(`Vuetify: ${message}`);
}
export function consoleError(message) {
warn(`Vuetify error: ${message}`);
}
export 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.`);
}
export function breaking(original, replacement) {
// warn(`[Vuetify BREAKING] '${original}' has been removed, use '${replacement}' instead. For more information, see the upgrade guide https://github.com/vuetifyjs/vuetify/releases/tag/v2.0.0#user-content-upgrade-guide`)
}
export function removed(original) {
// warn(`[Vuetify REMOVED] '${original}' has been removed. You can safely omit it.`)
}
//# sourceMappingURL=console.mjs.map

1
VApp/node_modules/vuetify/lib/util/console.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"console.mjs","names":["warn","consoleWarn","message","consoleError","deprecate","original","replacement","Array","isArray","slice","map","s","join","at","breaking","removed"],"sources":["../../src/util/console.ts"],"sourcesContent":["/* eslint-disable no-console */\n\n// Utilities\nimport { warn } from 'vue'\n\nexport function consoleWarn (message: string): void {\n warn(`Vuetify: ${message}`)\n}\n\nexport function consoleError (message: string): void {\n warn(`Vuetify error: ${message}`)\n}\n\nexport function deprecate (original: string, replacement: string | string[]) {\n replacement = Array.isArray(replacement)\n ? replacement.slice(0, -1).map(s => `'${s}'`).join(', ') + ` or '${replacement.at(-1)}'`\n : `'${replacement}'`\n warn(`[Vuetify UPGRADE] '${original}' is deprecated, use ${replacement} instead.`)\n}\nexport function breaking (original: string, replacement: string) {\n // warn(`[Vuetify BREAKING] '${original}' has been removed, use '${replacement}' instead. For more information, see the upgrade guide https://github.com/vuetifyjs/vuetify/releases/tag/v2.0.0#user-content-upgrade-guide`)\n}\nexport function removed (original: string) {\n // warn(`[Vuetify REMOVED] '${original}' has been removed. You can safely omit it.`)\n}\n"],"mappings":"AAAA;;AAEA;AACA,SAASA,IAAI,QAAQ,KAAK;AAE1B,OAAO,SAASC,WAAWA,CAAEC,OAAe,EAAQ;EAClDF,IAAI,CAAE,YAAWE,OAAQ,EAAC,CAAC;AAC7B;AAEA,OAAO,SAASC,YAAYA,CAAED,OAAe,EAAQ;EACnDF,IAAI,CAAE,kBAAiBE,OAAQ,EAAC,CAAC;AACnC;AAEA,OAAO,SAASE,SAASA,CAAEC,QAAgB,EAAEC,WAA8B,EAAE;EAC3EA,WAAW,GAAGC,KAAK,CAACC,OAAO,CAACF,WAAW,CAAC,GACpCA,WAAW,CAACG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAACC,GAAG,CAACC,CAAC,IAAK,IAAGA,CAAE,GAAE,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC,GAAI,QAAON,WAAW,CAACO,EAAE,CAAC,CAAC,CAAC,CAAE,GAAE,GACrF,IAAGP,WAAY,GAAE;EACtBN,IAAI,CAAE,sBAAqBK,QAAS,wBAAuBC,WAAY,WAAU,CAAC;AACpF;AACA,OAAO,SAASQ,QAAQA,CAAET,QAAgB,EAAEC,WAAmB,EAAE;EAC/D;AAAA;AAEF,OAAO,SAASS,OAAOA,CAAEV,QAAgB,EAAE;EACzC;AAAA"}

30
VApp/node_modules/vuetify/lib/util/createSimpleFunctional.mjs generated vendored Normal file
View File

@ -0,0 +1,30 @@
// Composables
import { makeComponentProps } from "../composables/component.mjs"; // Utilities
import { camelize, capitalize, h } from 'vue';
import { genericComponent } from "./defineComponent.mjs";
export function createSimpleFunctional(klass) {
let tag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'div';
let name = arguments.length > 2 ? arguments[2] : undefined;
return genericComponent()({
name: name ?? capitalize(camelize(klass.replace(/__/g, '-'))),
props: {
tag: {
type: String,
default: tag
},
...makeComponentProps()
},
setup(props, _ref) {
let {
slots
} = _ref;
return () => {
return h(props.tag, {
class: [klass, props.class],
style: props.style
}, slots.default?.());
};
}
});
}
//# sourceMappingURL=createSimpleFunctional.mjs.map

1
VApp/node_modules/vuetify/lib/util/createSimpleFunctional.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"createSimpleFunctional.mjs","names":["makeComponentProps","camelize","capitalize","h","genericComponent","createSimpleFunctional","klass","tag","arguments","length","undefined","name","replace","props","type","String","default","setup","_ref","slots","class","style"],"sources":["../../src/util/createSimpleFunctional.ts"],"sourcesContent":["// Composables\nimport { makeComponentProps } from '@/composables/component'\n\n// Utilities\nimport { camelize, capitalize, h } from 'vue'\nimport { genericComponent } from './defineComponent'\n\nexport function createSimpleFunctional (\n klass: string,\n tag = 'div',\n name?: string\n) {\n return genericComponent()({\n name: name ?? capitalize(camelize(klass.replace(/__/g, '-'))),\n\n props: {\n tag: {\n type: String,\n default: tag,\n },\n\n ...makeComponentProps(),\n },\n\n setup (props, { slots }) {\n return () => {\n return h(props.tag, {\n class: [klass, props.class],\n style: props.style,\n }, slots.default?.())\n }\n },\n })\n}\n"],"mappings":"AAAA;AAAA,SACSA,kBAAkB,wCAE3B;AACA,SAASC,QAAQ,EAAEC,UAAU,EAAEC,CAAC,QAAQ,KAAK;AAAA,SACpCC,gBAAgB;AAEzB,OAAO,SAASC,sBAAsBA,CACpCC,KAAa,EAGb;EAAA,IAFAC,GAAG,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,KAAK;EAAA,IACXG,IAAa,GAAAH,SAAA,CAAAC,MAAA,OAAAD,SAAA,MAAAE,SAAA;EAEb,OAAON,gBAAgB,CAAC,CAAC,CAAC;IACxBO,IAAI,EAAEA,IAAI,IAAIT,UAAU,CAACD,QAAQ,CAACK,KAAK,CAACM,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;IAE7DC,KAAK,EAAE;MACLN,GAAG,EAAE;QACHO,IAAI,EAAEC,MAAM;QACZC,OAAO,EAAET;MACX,CAAC;MAED,GAAGP,kBAAkB,CAAC;IACxB,CAAC;IAEDiB,KAAKA,CAAEJ,KAAK,EAAAK,IAAA,EAAa;MAAA,IAAX;QAAEC;MAAM,CAAC,GAAAD,IAAA;MACrB,OAAO,MAAM;QACX,OAAOf,CAAC,CAACU,KAAK,CAACN,GAAG,EAAE;UAClBa,KAAK,EAAE,CAACd,KAAK,EAAEO,KAAK,CAACO,KAAK,CAAC;UAC3BC,KAAK,EAAER,KAAK,CAACQ;QACf,CAAC,EAAEF,KAAK,CAACH,OAAO,GAAG,CAAC,CAAC;MACvB,CAAC;IACH;EACF,CAAC,CAAC;AACJ"}

58
VApp/node_modules/vuetify/lib/util/defineComponent.mjs generated vendored Normal file
View File

@ -0,0 +1,58 @@
// Composables
import { injectDefaults, internalUseDefaults } from "../composables/defaults.mjs"; // Utilities
import { defineComponent as _defineComponent // eslint-disable-line no-restricted-imports
} from 'vue';
import { consoleWarn } from "./console.mjs";
import { pick } from "./helpers.mjs";
import { propsFactory } from "./propsFactory.mjs"; // Types
// No props
// Object Props
// Implementation
export function defineComponent(options) {
options._setup = options._setup ?? options.setup;
if (!options.name) {
consoleWarn('The component is missing an explicit name, unable to generate default prop value');
return options;
}
if (options._setup) {
options.props = propsFactory(options.props ?? {}, options.name)();
const propKeys = Object.keys(options.props).filter(key => key !== 'class' && key !== 'style');
options.filterProps = function filterProps(props) {
return pick(props, propKeys);
};
options.props._as = String;
options.setup = function setup(props, ctx) {
const defaults = injectDefaults();
// Skip props proxy if defaults are not provided
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;
}
// No argument - simple default slot
// Generic constructor argument - generic props and slots
// Slots argument - simple slots
// Implementation
export function genericComponent() {
let exposeDefaults = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
return options => (exposeDefaults ? defineComponent : _defineComponent)(options);
}
export function defineFunctionalComponent(props, render) {
render.props = props;
return render;
}
// Adds a filterProps method to the component options
//# sourceMappingURL=defineComponent.mjs.map

1
VApp/node_modules/vuetify/lib/util/defineComponent.mjs.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

24
VApp/node_modules/vuetify/lib/util/dom.mjs generated vendored Normal file
View File

@ -0,0 +1,24 @@
/**
* Returns:
* - 'null' if the node is not attached to the DOM
* - the root node (HTMLDocument | ShadowRoot) otherwise
*/
export function attachedRoot(node) {
/* istanbul ignore next */
if (typeof node.getRootNode !== 'function') {
// Shadow DOM not supported (IE11), lets find the root of this node
while (node.parentNode) node = node.parentNode;
// The root parent is the document if the node is attached to the DOM
if (node !== document) return null;
return document;
}
const root = node.getRootNode();
// The composed root node is the document if the node is attached to the DOM
if (root !== document && root.getRootNode({
composed: true
}) !== document) return null;
return root;
}
//# sourceMappingURL=dom.mjs.map

1
VApp/node_modules/vuetify/lib/util/dom.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"dom.mjs","names":["attachedRoot","node","getRootNode","parentNode","document","root","composed"],"sources":["../../src/util/dom.ts"],"sourcesContent":["/**\n * Returns:\n * - 'null' if the node is not attached to the DOM\n * - the root node (HTMLDocument | ShadowRoot) otherwise\n */\nexport function attachedRoot (node: Node): null | HTMLDocument | ShadowRoot {\n /* istanbul ignore next */\n if (typeof node.getRootNode !== 'function') {\n // Shadow DOM not supported (IE11), lets find the root of this node\n while (node.parentNode) node = node.parentNode\n\n // The root parent is the document if the node is attached to the DOM\n if (node !== document) return null\n\n return document\n }\n\n const root = node.getRootNode()\n\n // The composed root node is the document if the node is attached to the DOM\n if (root !== document && root.getRootNode({ composed: true }) !== document) return null\n\n return root as HTMLDocument | ShadowRoot\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,YAAYA,CAAEC,IAAU,EAAoC;EAC1E;EACA,IAAI,OAAOA,IAAI,CAACC,WAAW,KAAK,UAAU,EAAE;IAC1C;IACA,OAAOD,IAAI,CAACE,UAAU,EAAEF,IAAI,GAAGA,IAAI,CAACE,UAAU;;IAE9C;IACA,IAAIF,IAAI,KAAKG,QAAQ,EAAE,OAAO,IAAI;IAElC,OAAOA,QAAQ;EACjB;EAEA,MAAMC,IAAI,GAAGJ,IAAI,CAACC,WAAW,CAAC,CAAC;;EAE/B;EACA,IAAIG,IAAI,KAAKD,QAAQ,IAAIC,IAAI,CAACH,WAAW,CAAC;IAAEI,QAAQ,EAAE;EAAK,CAAC,CAAC,KAAKF,QAAQ,EAAE,OAAO,IAAI;EAEvF,OAAOC,IAAI;AACb"}

4
VApp/node_modules/vuetify/lib/util/easing.mjs generated vendored Normal file
View File

@ -0,0 +1,4 @@
export const standardEasing = 'cubic-bezier(0.4, 0, 0.2, 1)';
export const deceleratedEasing = 'cubic-bezier(0.0, 0, 0.2, 1)'; // Entering
export const acceleratedEasing = 'cubic-bezier(0.4, 0, 1, 1)'; // Leaving
//# sourceMappingURL=easing.mjs.map

1
VApp/node_modules/vuetify/lib/util/easing.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"easing.mjs","names":["standardEasing","deceleratedEasing","acceleratedEasing"],"sources":["../../src/util/easing.ts"],"sourcesContent":["export const standardEasing = 'cubic-bezier(0.4, 0, 0.2, 1)'\nexport const deceleratedEasing = 'cubic-bezier(0.0, 0, 0.2, 1)' // Entering\nexport const acceleratedEasing = 'cubic-bezier(0.4, 0, 1, 1)' // Leaving\n"],"mappings":"AAAA,OAAO,MAAMA,cAAc,GAAG,8BAA8B;AAC5D,OAAO,MAAMC,iBAAiB,GAAG,8BAA8B,EAAC;AAChE,OAAO,MAAMC,iBAAiB,GAAG,4BAA4B,EAAC"}

9
VApp/node_modules/vuetify/lib/util/events.mjs generated vendored Normal file
View File

@ -0,0 +1,9 @@
// Utilities
import { isOn } from "./helpers.mjs";
export 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;
}, {});
}
//# sourceMappingURL=events.mjs.map

1
VApp/node_modules/vuetify/lib/util/events.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"events.mjs","names":["isOn","getPrefixedEventHandlers","attrs","suffix","getData","Object","keys","filter","key","endsWith","reduce","acc","slice","length","event"],"sources":["../../src/util/events.ts"],"sourcesContent":["// Utilities\nimport { isOn } from '@/util/helpers'\n\ntype EventHandler = (event: Event) => any\n\nexport function getPrefixedEventHandlers<T extends `:${string}`> (\n attrs: Record<string, any>,\n suffix: T,\n getData: EventHandler\n): Record<`${string}${T}`, EventHandler> {\n return Object.keys(attrs)\n .filter(key => isOn(key) && key.endsWith(suffix))\n .reduce((acc: any, key) => {\n acc[key.slice(0, -suffix.length)] = (event: Event) => attrs[key](event, getData(event))\n return acc\n }, {} as Record<`${string}${T}`, EventHandler>)\n}\n"],"mappings":"AAAA;AAAA,SACSA,IAAI;AAIb,OAAO,SAASC,wBAAwBA,CACtCC,KAA0B,EAC1BC,MAAS,EACTC,OAAqB,EACkB;EACvC,OAAOC,MAAM,CAACC,IAAI,CAACJ,KAAK,CAAC,CACtBK,MAAM,CAACC,GAAG,IAAIR,IAAI,CAACQ,GAAG,CAAC,IAAIA,GAAG,CAACC,QAAQ,CAACN,MAAM,CAAC,CAAC,CAChDO,MAAM,CAAC,CAACC,GAAQ,EAAEH,GAAG,KAAK;IACzBG,GAAG,CAACH,GAAG,CAACI,KAAK,CAAC,CAAC,EAAE,CAACT,MAAM,CAACU,MAAM,CAAC,CAAC,GAAIC,KAAY,IAAKZ,KAAK,CAACM,GAAG,CAAC,CAACM,KAAK,EAAEV,OAAO,CAACU,KAAK,CAAC,CAAC;IACvF,OAAOH,GAAG;EACZ,CAAC,EAAE,CAAC,CAA0C,CAAC;AACnD"}

30
VApp/node_modules/vuetify/lib/util/getCurrentInstance.mjs generated vendored Normal file
View File

@ -0,0 +1,30 @@
// Utilities
import { getCurrentInstance as _getCurrentInstance } from 'vue';
import { toKebabCase } from "./helpers.mjs"; // Types
export function getCurrentInstance(name, message) {
const vm = _getCurrentInstance();
if (!vm) {
throw new Error(`[Vuetify] ${name} ${message || 'must be called from inside a setup function'}`);
}
return vm;
}
export function getCurrentInstanceName() {
let name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'composables';
const vm = getCurrentInstance(name).type;
return toKebabCase(vm?.aliasName || vm?.name);
}
let _uid = 0;
let _map = new WeakMap();
export function getUid() {
const vm = getCurrentInstance('getUid');
if (_map.has(vm)) return _map.get(vm);else {
const uid = _uid++;
_map.set(vm, uid);
return uid;
}
}
getUid.reset = () => {
_uid = 0;
_map = new WeakMap();
};
//# sourceMappingURL=getCurrentInstance.mjs.map

1
VApp/node_modules/vuetify/lib/util/getCurrentInstance.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"getCurrentInstance.mjs","names":["getCurrentInstance","_getCurrentInstance","toKebabCase","name","message","vm","Error","getCurrentInstanceName","arguments","length","undefined","type","aliasName","_uid","_map","WeakMap","getUid","has","get","uid","set","reset"],"sources":["../../src/util/getCurrentInstance.ts"],"sourcesContent":["// Utilities\nimport { getCurrentInstance as _getCurrentInstance } from 'vue'\nimport { toKebabCase } from '@/util/helpers'\n\n// Types\nimport type { ComponentInternalInstance } from 'vue'\n\nexport function getCurrentInstance (name: string, message?: string) {\n const vm = _getCurrentInstance()\n\n if (!vm) {\n throw new Error(`[Vuetify] ${name} ${message || 'must be called from inside a setup function'}`)\n }\n\n return vm\n}\n\nexport function getCurrentInstanceName (name = 'composables') {\n const vm = getCurrentInstance(name).type\n\n return toKebabCase(vm?.aliasName || vm?.name)\n}\n\nlet _uid = 0\nlet _map = new WeakMap<ComponentInternalInstance, number>()\nexport function getUid () {\n const vm = getCurrentInstance('getUid')\n\n if (_map.has(vm)) return _map.get(vm)!\n else {\n const uid = _uid++\n _map.set(vm, uid)\n return uid\n }\n}\ngetUid.reset = () => {\n _uid = 0\n _map = new WeakMap()\n}\n"],"mappings":"AAAA;AACA,SAASA,kBAAkB,IAAIC,mBAAmB,QAAQ,KAAK;AAAA,SACtDC,WAAW,yBAEpB;AAGA,OAAO,SAASF,kBAAkBA,CAAEG,IAAY,EAAEC,OAAgB,EAAE;EAClE,MAAMC,EAAE,GAAGJ,mBAAmB,CAAC,CAAC;EAEhC,IAAI,CAACI,EAAE,EAAE;IACP,MAAM,IAAIC,KAAK,CAAE,aAAYH,IAAK,IAAGC,OAAO,IAAI,6CAA8C,EAAC,CAAC;EAClG;EAEA,OAAOC,EAAE;AACX;AAEA,OAAO,SAASE,sBAAsBA,CAAA,EAAwB;EAAA,IAAtBJ,IAAI,GAAAK,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,aAAa;EAC1D,MAAMH,EAAE,GAAGL,kBAAkB,CAACG,IAAI,CAAC,CAACQ,IAAI;EAExC,OAAOT,WAAW,CAACG,EAAE,EAAEO,SAAS,IAAIP,EAAE,EAAEF,IAAI,CAAC;AAC/C;AAEA,IAAIU,IAAI,GAAG,CAAC;AACZ,IAAIC,IAAI,GAAG,IAAIC,OAAO,CAAoC,CAAC;AAC3D,OAAO,SAASC,MAAMA,CAAA,EAAI;EACxB,MAAMX,EAAE,GAAGL,kBAAkB,CAAC,QAAQ,CAAC;EAEvC,IAAIc,IAAI,CAACG,GAAG,CAACZ,EAAE,CAAC,EAAE,OAAOS,IAAI,CAACI,GAAG,CAACb,EAAE,CAAC,CAAC,KACjC;IACH,MAAMc,GAAG,GAAGN,IAAI,EAAE;IAClBC,IAAI,CAACM,GAAG,CAACf,EAAE,EAAEc,GAAG,CAAC;IACjB,OAAOA,GAAG;EACZ;AACF;AACAH,MAAM,CAACK,KAAK,GAAG,MAAM;EACnBR,IAAI,GAAG,CAAC;EACRC,IAAI,GAAG,IAAIC,OAAO,CAAC,CAAC;AACtB,CAAC"}

29
VApp/node_modules/vuetify/lib/util/getScrollParent.mjs generated vendored Normal file
View File

@ -0,0 +1,29 @@
export function getScrollParent(el) {
let includeHidden = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
while (el) {
if (includeHidden ? isPotentiallyScrollable(el) : hasScrollbar(el)) return el;
el = el.parentElement;
}
return document.scrollingElement;
}
export 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;
}
export 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);
}
//# sourceMappingURL=getScrollParent.mjs.map

1
VApp/node_modules/vuetify/lib/util/getScrollParent.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"getScrollParent.mjs","names":["getScrollParent","el","includeHidden","arguments","length","undefined","isPotentiallyScrollable","hasScrollbar","parentElement","document","scrollingElement","getScrollParents","stopAt","elements","contains","push","nodeType","Node","ELEMENT_NODE","style","window","getComputedStyle","overflowY","scrollHeight","clientHeight","includes"],"sources":["../../src/util/getScrollParent.ts"],"sourcesContent":["export function getScrollParent (el?: HTMLElement, includeHidden = false) {\n while (el) {\n if (includeHidden ? isPotentiallyScrollable(el) : hasScrollbar(el)) return el\n el = el.parentElement!\n }\n\n return document.scrollingElement as HTMLElement\n}\n\nexport function getScrollParents (el?: Element | null, stopAt?: Element | null) {\n const elements: HTMLElement[] = []\n\n if (stopAt && el && !stopAt.contains(el)) return elements\n\n while (el) {\n if (hasScrollbar(el)) elements.push(el as HTMLElement)\n if (el === stopAt) break\n el = el.parentElement!\n }\n\n return elements\n}\n\nexport function hasScrollbar (el?: Element | null) {\n if (!el || el.nodeType !== Node.ELEMENT_NODE) return false\n\n const style = window.getComputedStyle(el)\n return style.overflowY === 'scroll' || (style.overflowY === 'auto' && el.scrollHeight > el.clientHeight)\n}\n\nfunction isPotentiallyScrollable (el?: Element | null) {\n if (!el || el.nodeType !== Node.ELEMENT_NODE) return false\n\n const style = window.getComputedStyle(el)\n return ['scroll', 'auto'].includes(style.overflowY)\n}\n"],"mappings":"AAAA,OAAO,SAASA,eAAeA,CAAEC,EAAgB,EAAyB;EAAA,IAAvBC,aAAa,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,KAAK;EACtE,OAAOF,EAAE,EAAE;IACT,IAAIC,aAAa,GAAGI,uBAAuB,CAACL,EAAE,CAAC,GAAGM,YAAY,CAACN,EAAE,CAAC,EAAE,OAAOA,EAAE;IAC7EA,EAAE,GAAGA,EAAE,CAACO,aAAc;EACxB;EAEA,OAAOC,QAAQ,CAACC,gBAAgB;AAClC;AAEA,OAAO,SAASC,gBAAgBA,CAAEV,EAAmB,EAAEW,MAAuB,EAAE;EAC9E,MAAMC,QAAuB,GAAG,EAAE;EAElC,IAAID,MAAM,IAAIX,EAAE,IAAI,CAACW,MAAM,CAACE,QAAQ,CAACb,EAAE,CAAC,EAAE,OAAOY,QAAQ;EAEzD,OAAOZ,EAAE,EAAE;IACT,IAAIM,YAAY,CAACN,EAAE,CAAC,EAAEY,QAAQ,CAACE,IAAI,CAACd,EAAiB,CAAC;IACtD,IAAIA,EAAE,KAAKW,MAAM,EAAE;IACnBX,EAAE,GAAGA,EAAE,CAACO,aAAc;EACxB;EAEA,OAAOK,QAAQ;AACjB;AAEA,OAAO,SAASN,YAAYA,CAAEN,EAAmB,EAAE;EACjD,IAAI,CAACA,EAAE,IAAIA,EAAE,CAACe,QAAQ,KAAKC,IAAI,CAACC,YAAY,EAAE,OAAO,KAAK;EAE1D,MAAMC,KAAK,GAAGC,MAAM,CAACC,gBAAgB,CAACpB,EAAE,CAAC;EACzC,OAAOkB,KAAK,CAACG,SAAS,KAAK,QAAQ,IAAKH,KAAK,CAACG,SAAS,KAAK,MAAM,IAAIrB,EAAE,CAACsB,YAAY,GAAGtB,EAAE,CAACuB,YAAa;AAC1G;AAEA,SAASlB,uBAAuBA,CAAEL,EAAmB,EAAE;EACrD,IAAI,CAACA,EAAE,IAAIA,EAAE,CAACe,QAAQ,KAAKC,IAAI,CAACC,YAAY,EAAE,OAAO,KAAK;EAE1D,MAAMC,KAAK,GAAGC,MAAM,CAACC,gBAAgB,CAACpB,EAAE,CAAC;EACzC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,CAACwB,QAAQ,CAACN,KAAK,CAACG,SAAS,CAAC;AACrD"}

5
VApp/node_modules/vuetify/lib/util/globals.mjs generated vendored Normal file
View File

@ -0,0 +1,5 @@
export const IN_BROWSER = typeof window !== 'undefined';
export const SUPPORTS_INTERSECTION = IN_BROWSER && 'IntersectionObserver' in window;
export const SUPPORTS_TOUCH = IN_BROWSER && ('ontouchstart' in window || window.navigator.maxTouchPoints > 0);
export const SUPPORTS_EYE_DROPPER = IN_BROWSER && 'EyeDropper' in window;
//# sourceMappingURL=globals.mjs.map

1
VApp/node_modules/vuetify/lib/util/globals.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"globals.mjs","names":["IN_BROWSER","window","SUPPORTS_INTERSECTION","SUPPORTS_TOUCH","navigator","maxTouchPoints","SUPPORTS_EYE_DROPPER"],"sources":["../../src/util/globals.ts"],"sourcesContent":["export const IN_BROWSER = typeof window !== 'undefined'\nexport const SUPPORTS_INTERSECTION = IN_BROWSER && 'IntersectionObserver' in window\nexport const SUPPORTS_TOUCH = IN_BROWSER && ('ontouchstart' in window || window.navigator.maxTouchPoints > 0)\nexport const SUPPORTS_EYE_DROPPER = IN_BROWSER && 'EyeDropper' in window\n"],"mappings":"AAAA,OAAO,MAAMA,UAAU,GAAG,OAAOC,MAAM,KAAK,WAAW;AACvD,OAAO,MAAMC,qBAAqB,GAAGF,UAAU,IAAI,sBAAsB,IAAIC,MAAM;AACnF,OAAO,MAAME,cAAc,GAAGH,UAAU,KAAK,cAAc,IAAIC,MAAM,IAAIA,MAAM,CAACG,SAAS,CAACC,cAAc,GAAG,CAAC,CAAC;AAC7G,OAAO,MAAMC,oBAAoB,GAAGN,UAAU,IAAI,YAAY,IAAIC,MAAM"}

494
VApp/node_modules/vuetify/lib/util/helpers.mjs generated vendored Normal file
View File

@ -0,0 +1,494 @@
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; }
// Utilities
import { capitalize, Comment, computed, Fragment, isVNode, reactive, toRefs, unref, watchEffect } from 'vue';
import { IN_BROWSER } from "./globals.mjs"; // Types
export function getNestedValue(obj, path, fallback) {
const last = path.length - 1;
if (last < 0) return obj === undefined ? 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]] === undefined ? fallback : obj[path[last]];
}
export function deepEqual(a, b) {
if (a === b) return true;
if (a instanceof Date && b instanceof Date && a.getTime() !== b.getTime()) {
// If the values are Date, compare them as timestamps
return false;
}
if (a !== Object(a) || b !== Object(b)) {
// If the values aren't objects, they were already checked for equality
return false;
}
const props = Object.keys(a);
if (props.length !== Object.keys(b).length) {
// Different number of props, don't bother to check
return false;
}
return props.every(p => deepEqual(a[p], b[p]));
}
export function getObjectValueByPath(obj, path, fallback) {
// credit: http://stackoverflow.com/questions/6491463/accessing-nested-javascript-objects-with-string-key#comment55278413_6491621
if (obj == null || !path || typeof path !== 'string') return fallback;
if (obj[path] !== undefined) return obj[path];
path = path.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties
path = path.replace(/^\./, ''); // strip a leading dot
return getNestedValue(obj, path.split('.'), fallback);
}
export function getPropertyFromItem(item, property, fallback) {
if (property === true) return item === undefined ? fallback : item;
if (property == null || typeof property === 'boolean') return fallback;
if (item !== Object(item)) {
if (typeof property !== 'function') return fallback;
const value = property(item, fallback);
return typeof value === 'undefined' ? fallback : value;
}
if (typeof property === 'string') return getObjectValueByPath(item, property, fallback);
if (Array.isArray(property)) return getNestedValue(item, property, fallback);
if (typeof property !== 'function') return fallback;
const value = property(item, fallback);
return typeof value === 'undefined' ? fallback : value;
}
export function createRange(length) {
let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
return Array.from({
length
}, (v, k) => start + k);
}
export function getZIndex(el) {
if (!el || el.nodeType !== Node.ELEMENT_NODE) return 0;
const index = +window.getComputedStyle(el).getPropertyValue('z-index');
if (!index) return getZIndex(el.parentNode);
return index;
}
export function convertToUnit(str) {
let unit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'px';
if (str == null || str === '') {
return undefined;
} else if (isNaN(+str)) {
return String(str);
} else if (!isFinite(+str)) {
return undefined;
} else {
return `${Number(str)}${unit}`;
}
}
export function isObject(obj) {
return obj !== null && typeof obj === 'object' && !Array.isArray(obj);
}
export function refElement(obj) {
if (obj && '$el' in obj) {
const el = obj.$el;
if (el?.nodeType === Node.TEXT_NODE) {
// Multi-root component, use the first element
return el.nextElementSibling;
}
return el;
}
return obj;
}
// KeyboardEvent.keyCode aliases
export const 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
});
export const 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'
});
export function keys(o) {
return Object.keys(o);
}
export function has(obj, key) {
return key.every(k => obj.hasOwnProperty(k));
}
// Array of keys
export 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;
}
// Array of keys
// Array of keys or RegExp to test keys against
export function pickWithRest(obj, paths, exclude) {
const found = Object.create(null);
const rest = Object.create(null);
for (const key in obj) {
if (paths.some(path => path instanceof RegExp ? path.test(key) : path === key) && !exclude?.some(path => path === key)) {
found[key] = obj[key];
} else {
rest[key] = obj[key];
}
}
return [found, rest];
}
export function omit(obj, exclude) {
const clone = {
...obj
};
exclude.forEach(prop => delete clone[prop]);
return clone;
}
export function only(obj, include) {
const clone = {};
include.forEach(prop => clone[prop] = obj[prop]);
return clone;
}
const onRE = /^on[^a-z]/;
export const isOn = key => onRE.test(key);
const 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'];
const compositionIgnoreKeys = ['ArrowUp', 'ArrowDown', 'ArrowRight', 'ArrowLeft', 'Enter', 'Escape', 'Tab', ' '];
export function isComposingIgnoreKey(e) {
return e.isComposing && compositionIgnoreKeys.includes(e.key);
}
/**
* Filter attributes that should be applied to
* the root element of an input component. Remaining
* attributes should be passed to the <input> element inside.
*/
export 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];
}
/**
* Returns the set difference of B and A, i.e. the set of elements in B but not in A
*/
export function arrayDiff(a, b) {
const diff = [];
for (let i = 0; i < b.length; i++) {
if (!a.includes(b[i])) diff.push(b[i]);
}
return diff;
}
export function wrapInArray(v) {
return v == null ? [] : Array.isArray(v) ? v : [v];
}
export function defaultFilter(value, search, item) {
return value != null && search != null && typeof value !== 'boolean' && value.toString().toLocaleLowerCase().indexOf(search.toLocaleLowerCase()) !== -1;
}
export 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;
}
export function throttle(fn, limit) {
let throttling = false;
return function () {
if (!throttling) {
throttling = true;
setTimeout(() => throttling = false, limit);
return fn(...arguments);
}
};
}
export function clamp(value) {
let min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
let max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
return Math.max(min, Math.min(max, value));
}
export function getDecimals(value) {
const trimmedStr = value.toString().trim();
return trimmedStr.includes('.') ? trimmedStr.length - trimmedStr.indexOf('.') - 1 : 0;
}
export function padEnd(str, length) {
let char = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
return str + char.repeat(Math.max(0, length - str.length));
}
export function padStart(str, length) {
let char = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
return char.repeat(Math.max(0, length - str.length)) + str;
}
export function chunk(str) {
let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
const chunked = [];
let index = 0;
while (index < str.length) {
chunked.push(str.substr(index, size));
index += size;
}
return chunked;
}
export function chunkArray(array) {
let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
return Array.from({
length: Math.ceil(array.length / size)
}, (v, i) => array.slice(i * size, i * size + size));
}
export function humanReadableFileSize(bytes) {
let base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
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`;
}
export function mergeDeep() {
let source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
let arrayFn = arguments.length > 2 ? arguments[2] : undefined;
const out = {};
for (const key in source) {
out[key] = source[key];
}
for (const key in target) {
const sourceProperty = source[key];
const targetProperty = target[key];
// Only continue deep merging if
// both properties are objects
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;
}
export function flattenFragments(nodes) {
return nodes.map(node => {
if (node.type === Fragment) {
return flattenFragments(node.children);
} else {
return node;
}
}).flat();
}
export function toKebabCase() {
let str = arguments.length > 0 && arguments[0] !== undefined ? 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 = new Map();
export 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();
export class CircularBuffer {
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)));
}
}
export 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
};
}
// Only allow a single return type
/**
* Convert a computed ref to a record of refs.
* The getter function must always return an object with the same keys.
*/
export 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);
}
/** Array.includes but value can be any type */
export function includes(arr, val) {
return arr.includes(val);
}
export function eventName(propName) {
return propName[2].toLowerCase() + propName.slice(3);
}
export const EventProp = () => [Function, Array];
export function hasEvent(props, name) {
name = 'on' + capitalize(name);
return !!(props[name] || props[`${name}Once`] || props[`${name}Capture`] || props[`${name}OnceCapture`] || props[`${name}CaptureOnce`]);
}
export 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 h of handler) {
h(...args);
}
} else if (typeof handler === 'function') {
handler(...args);
}
}
export function focusableChildren(el) {
let filterByTabIndex = arguments.length > 1 && arguments[1] !== undefined ? 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)];
}
export function getNextElement(elements, location, condition) {
let _el;
let idx = elements.indexOf(document.activeElement);
const inc = location === 'next' ? 1 : -1;
do {
idx += inc;
_el = elements[idx];
} while ((!_el || _el.offsetParent == null || !(condition?.(_el) ?? true)) && idx < elements.length && idx >= 0);
return _el;
}
export function focusChild(el, location) {
const focusable = focusableChildren(el);
if (!location) {
if (el === document.activeElement || !el.contains(document.activeElement)) {
focusable[0]?.focus();
}
} else if (location === 'first') {
focusable[0]?.focus();
} else if (location === 'last') {
focusable.at(-1)?.focus();
} else if (typeof location === 'number') {
focusable[location]?.focus();
} else {
const _el = getNextElement(focusable, location);
if (_el) _el.focus();else focusChild(el, location === 'next' ? 'first' : 'last');
}
}
export function isEmpty(val) {
return val === null || val === undefined || typeof val === 'string' && val.trim() === '';
}
export function noop() {}
/** Returns null if the selector is not supported or we can't check */
export 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;
}
}
export 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;
}
export function defer(timeout, cb) {
if (!IN_BROWSER || timeout === 0) {
cb();
return () => {};
}
const timeoutId = window.setTimeout(cb, timeout);
return () => window.clearTimeout(timeoutId);
}
//# sourceMappingURL=helpers.mjs.map

1
VApp/node_modules/vuetify/lib/util/helpers.mjs.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

19
VApp/node_modules/vuetify/lib/util/index.mjs generated vendored Normal file
View File

@ -0,0 +1,19 @@
export * from "./anchor.mjs";
export * from "./animation.mjs";
export * from "./bindProps.mjs";
export * from "./colorUtils.mjs";
export * from "./console.mjs";
export * from "./createSimpleFunctional.mjs";
export * from "./defineComponent.mjs";
export * from "./dom.mjs";
export * from "./easing.mjs";
export * from "./events.mjs";
export * from "./getCurrentInstance.mjs";
export * from "./getScrollParent.mjs";
export * from "./globals.mjs";
export * from "./helpers.mjs";
export * from "./injectSelf.mjs";
export * from "./isFixedPosition.mjs";
export * from "./propsFactory.mjs";
export * from "./useRender.mjs";
//# sourceMappingURL=index.mjs.map

1
VApp/node_modules/vuetify/lib/util/index.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.mjs","names":[],"sources":["../../src/util/index.ts"],"sourcesContent":["export * from './anchor'\nexport * from './animation'\nexport * from './bindProps'\nexport * from './colorUtils'\nexport * from './console'\nexport * from './createSimpleFunctional'\nexport * from './defineComponent'\nexport * from './dom'\nexport * from './easing'\nexport * from './events'\nexport * from './getCurrentInstance'\nexport * from './getScrollParent'\nexport * from './globals'\nexport * from './helpers'\nexport * from './injectSelf'\nexport * from './isFixedPosition'\nexport * from './propsFactory'\nexport * from './useRender'\n"],"mappings":""}

14
VApp/node_modules/vuetify/lib/util/injectSelf.mjs generated vendored Normal file
View File

@ -0,0 +1,14 @@
// Utilities
import { getCurrentInstance } from "./getCurrentInstance.mjs"; // Types
export function injectSelf(key) {
let vm = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getCurrentInstance('injectSelf');
const {
provides
} = vm;
if (provides && key in provides) {
// TS doesn't allow symbol as index type
return provides[key];
}
return undefined;
}
//# sourceMappingURL=injectSelf.mjs.map

1
VApp/node_modules/vuetify/lib/util/injectSelf.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"injectSelf.mjs","names":["getCurrentInstance","injectSelf","key","vm","arguments","length","undefined","provides"],"sources":["../../src/util/injectSelf.ts"],"sourcesContent":["// Utilities\nimport { getCurrentInstance } from '@/util/getCurrentInstance'\n\n// Types\nimport type { ComponentInternalInstance, InjectionKey } from 'vue'\n\nexport function injectSelf<T>(key: InjectionKey<T> | string, vm?: ComponentInternalInstance): T | undefined\nexport function injectSelf (key: InjectionKey<any> | string, vm = getCurrentInstance('injectSelf')) {\n const { provides } = vm\n\n if (provides && (key as string | symbol) in provides) {\n // TS doesn't allow symbol as index type\n return provides[key as string]\n }\n return undefined\n}\n"],"mappings":"AAAA;AAAA,SACSA,kBAAkB,oCAE3B;AAIA,OAAO,SAASC,UAAUA,CAAEC,GAA+B,EAAyC;EAAA,IAAvCC,EAAE,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAGJ,kBAAkB,CAAC,YAAY,CAAC;EAChG,MAAM;IAAEO;EAAS,CAAC,GAAGJ,EAAE;EAEvB,IAAII,QAAQ,IAAKL,GAAG,IAAwBK,QAAQ,EAAE;IACpD;IACA,OAAOA,QAAQ,CAACL,GAAG,CAAW;EAChC;EACA,OAAOI,SAAS;AAClB"}

10
VApp/node_modules/vuetify/lib/util/isFixedPosition.mjs generated vendored Normal file
View File

@ -0,0 +1,10 @@
export function isFixedPosition(el) {
while (el) {
if (window.getComputedStyle(el).position === 'fixed') {
return true;
}
el = el.offsetParent;
}
return false;
}
//# sourceMappingURL=isFixedPosition.mjs.map

1
VApp/node_modules/vuetify/lib/util/isFixedPosition.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"isFixedPosition.mjs","names":["isFixedPosition","el","window","getComputedStyle","position","offsetParent"],"sources":["../../src/util/isFixedPosition.ts"],"sourcesContent":["export function isFixedPosition (el?: HTMLElement) {\n while (el) {\n if (window.getComputedStyle(el).position === 'fixed') {\n return true\n }\n el = el.offsetParent as HTMLElement\n }\n return false\n}\n"],"mappings":"AAAA,OAAO,SAASA,eAAeA,CAAEC,EAAgB,EAAE;EACjD,OAAOA,EAAE,EAAE;IACT,IAAIC,MAAM,CAACC,gBAAgB,CAACF,EAAE,CAAC,CAACG,QAAQ,KAAK,OAAO,EAAE;MACpD,OAAO,IAAI;IACb;IACAH,EAAE,GAAGA,EAAE,CAACI,YAA2B;EACrC;EACA,OAAO,KAAK;AACd"}

58
VApp/node_modules/vuetify/lib/util/propsFactory.mjs generated vendored Normal file
View File

@ -0,0 +1,58 @@
// Types
// eslint-disable-line vue/prefer-import-from-vue
/**
* Creates a factory function for props definitions.
* This is used to define props in a composable then override
* default values in an implementing component.
*
* @example Simplified signature
* (props: Props) => (defaults?: Record<keyof props, any>) => Props
*
* @example Usage
* const makeProps = propsFactory({
* foo: String,
* })
*
* defineComponent({
* props: {
* ...makeProps({
* foo: 'a',
* }),
* },
* setup (props) {
* // would be "string | undefined", now "string" because a default has been provided
* props.foo
* },
* }
*/
export 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;
}, {});
};
}
/**
* Like `Partial<T>` but doesn't care what the value is
*/
// Copied from Vue
//# sourceMappingURL=propsFactory.mjs.map

1
VApp/node_modules/vuetify/lib/util/propsFactory.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"propsFactory.mjs","names":["propsFactory","props","source","defaults","Object","keys","reduce","obj","prop","isObjectDefinition","Array","isArray","definition","type","default"],"sources":["../../src/util/propsFactory.ts"],"sourcesContent":["// Types\nimport type { IfAny } from '@vue/shared' // eslint-disable-line vue/prefer-import-from-vue\nimport type { ComponentObjectPropsOptions, Prop, PropType } from 'vue'\n\n/**\n * Creates a factory function for props definitions.\n * This is used to define props in a composable then override\n * default values in an implementing component.\n *\n * @example Simplified signature\n * (props: Props) => (defaults?: Record<keyof props, any>) => Props\n *\n * @example Usage\n * const makeProps = propsFactory({\n * foo: String,\n * })\n *\n * defineComponent({\n * props: {\n * ...makeProps({\n * foo: 'a',\n * }),\n * },\n * setup (props) {\n * // would be \"string | undefined\", now \"string\" because a default has been provided\n * props.foo\n * },\n * }\n */\n\nexport function propsFactory<\n PropsOptions extends ComponentObjectPropsOptions\n> (props: PropsOptions, source: string) {\n return <Defaults extends PartialKeys<PropsOptions> = {}>(\n defaults?: Defaults\n ): AppendDefault<PropsOptions, Defaults> => {\n return Object.keys(props).reduce<any>((obj, prop) => {\n const isObjectDefinition = typeof props[prop] === 'object' && props[prop] != null && !Array.isArray(props[prop])\n const definition = isObjectDefinition ? props[prop] : { type: props[prop] }\n\n if (defaults && prop in defaults) {\n obj[prop] = {\n ...definition,\n default: defaults[prop],\n }\n } else {\n obj[prop] = definition\n }\n\n if (source && !obj[prop].source) {\n obj[prop].source = source\n }\n\n return obj\n }, {})\n }\n}\n\ntype AppendDefault<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {\n [P in keyof T]-?: unknown extends D[P]\n ? T[P]\n : T[P] extends Record<string, unknown>\n ? Omit<T[P], 'type' | 'default'> & {\n type: PropType<MergeDefault<T[P], D[P]>>\n default: MergeDefault<T[P], D[P]>\n }\n : {\n type: PropType<MergeDefault<T[P], D[P]>>\n default: MergeDefault<T[P], D[P]>\n }\n}\n\ntype MergeDefault<T, D> = unknown extends D ? InferPropType<T> : (NonNullable<InferPropType<T>> | D)\n\n/**\n * Like `Partial<T>` but doesn't care what the value is\n */\ntype PartialKeys<T> = { [P in keyof T]?: unknown }\n\n// Copied from Vue\ntype InferPropType<T> = [T] extends [null]\n ? any // null & true would fail to infer\n : [T] extends [{ type: null | true }]\n // As TS issue https://github.com/Microsoft/TypeScript/issues/14829\n // somehow `ObjectConstructor` when inferred from { (): T } becomes `any`\n // `BooleanConstructor` when inferred from PropConstructor(with PropMethod) becomes `Boolean`\n ? any\n : [T] extends [ObjectConstructor | { type: ObjectConstructor }]\n ? Record<string, any>\n : [T] extends [BooleanConstructor | { type: BooleanConstructor }]\n ? boolean\n : [T] extends [DateConstructor | { type: DateConstructor }]\n ? Date\n : [T] extends [(infer U)[] | { type: (infer U)[] }]\n ? U extends DateConstructor\n ? Date | InferPropType<U>\n : InferPropType<U>\n : [T] extends [Prop<infer V, infer D>]\n ? unknown extends V\n ? IfAny<V, V, D>\n : V\n : T\n"],"mappings":"AAAA;AACyC;;AAGzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO,SAASA,YAAYA,CAEzBC,KAAmB,EAAEC,MAAc,EAAE;EACtC,OACEC,QAAmB,IACuB;IAC1C,OAAOC,MAAM,CAACC,IAAI,CAACJ,KAAK,CAAC,CAACK,MAAM,CAAM,CAACC,GAAG,EAAEC,IAAI,KAAK;MACnD,MAAMC,kBAAkB,GAAG,OAAOR,KAAK,CAACO,IAAI,CAAC,KAAK,QAAQ,IAAIP,KAAK,CAACO,IAAI,CAAC,IAAI,IAAI,IAAI,CAACE,KAAK,CAACC,OAAO,CAACV,KAAK,CAACO,IAAI,CAAC,CAAC;MAChH,MAAMI,UAAU,GAAGH,kBAAkB,GAAGR,KAAK,CAACO,IAAI,CAAC,GAAG;QAAEK,IAAI,EAAEZ,KAAK,CAACO,IAAI;MAAE,CAAC;MAE3E,IAAIL,QAAQ,IAAIK,IAAI,IAAIL,QAAQ,EAAE;QAChCI,GAAG,CAACC,IAAI,CAAC,GAAG;UACV,GAAGI,UAAU;UACbE,OAAO,EAAEX,QAAQ,CAACK,IAAI;QACxB,CAAC;MACH,CAAC,MAAM;QACLD,GAAG,CAACC,IAAI,CAAC,GAAGI,UAAU;MACxB;MAEA,IAAIV,MAAM,IAAI,CAACK,GAAG,CAACC,IAAI,CAAC,CAACN,MAAM,EAAE;QAC/BK,GAAG,CAACC,IAAI,CAAC,CAACN,MAAM,GAAGA,MAAM;MAC3B;MAEA,OAAOK,GAAG;IACZ,CAAC,EAAE,CAAC,CAAC,CAAC;EACR,CAAC;AACH;;AAkBA;AACA;AACA;;AAGA"}

7
VApp/node_modules/vuetify/lib/util/useRender.mjs generated vendored Normal file
View File

@ -0,0 +1,7 @@
// Utilities
import { getCurrentInstance } from "./getCurrentInstance.mjs"; // Types
export function useRender(render) {
const vm = getCurrentInstance('useRender');
vm.render = render;
}
//# sourceMappingURL=useRender.mjs.map

1
VApp/node_modules/vuetify/lib/util/useRender.mjs.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"useRender.mjs","names":["getCurrentInstance","useRender","render","vm"],"sources":["../../src/util/useRender.ts"],"sourcesContent":["// Utilities\nimport { getCurrentInstance } from './getCurrentInstance'\n\n// Types\nimport type { VNode } from 'vue'\n\nexport function useRender (render: () => VNode): void {\n const vm = getCurrentInstance('useRender') as any\n vm.render = render\n}\n"],"mappings":"AAAA;AAAA,SACSA,kBAAkB,oCAE3B;AAGA,OAAO,SAASC,SAASA,CAAEC,MAAmB,EAAQ;EACpD,MAAMC,EAAE,GAAGH,kBAAkB,CAAC,WAAW,CAAQ;EACjDG,EAAE,CAACD,MAAM,GAAGA,MAAM;AACpB"}