// ==UserScript==
// @name WaniKani Reviews Plus
// @namespace http://tampermonkey.net/
// @version 1.07
// @license MIT
// @description try to take over the world!
// @author You
// @match https://www.wanikani.com/*
// @icon https://www.google.com/s2/favicons?sz=64&domain=wanikani.com
// @grant none
// ==/UserScript==
(function polyfill() {
const relList = document.createElement("link").relList;
if (relList && relList.supports && relList.supports("modulepreload")) {
return;
}
for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
processPreload(link);
}
new MutationObserver((mutations) => {
for (const mutation of mutations) {
if (mutation.type !== "childList") {
continue;
}
for (const node of mutation.addedNodes) {
if (node.tagName === "LINK" && node.rel === "modulepreload")
processPreload(node);
}
}
}).observe(document, { childList: true, subtree: true });
function getFetchOpts(link) {
const fetchOpts = {};
if (link.integrity) fetchOpts.integrity = link.integrity;
if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
if (link.crossOrigin === "use-credentials")
fetchOpts.credentials = "include";
else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
else fetchOpts.credentials = "same-origin";
return fetchOpts;
}
function processPreload(link) {
if (link.ep)
return;
link.ep = true;
const fetchOpts = getFetchOpts(link);
fetch(link.href, fetchOpts);
}
})();
/**
* @vue/shared v3.5.10
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function makeMap(str) {
const map = /* @__PURE__ */ Object.create(null);
for (const key of str.split(",")) map[key] = 1;
return (val) => val in map;
}
const EMPTY_OBJ = {};
const EMPTY_ARR = [];
const NOOP = () => {
};
const NO = () => false;
const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
const isModelListener = (key) => key.startsWith("onUpdate:");
const extend = Object.assign;
const remove = (arr, el) => {
const i = arr.indexOf(el);
if (i > -1) {
arr.splice(i, 1);
}
};
const hasOwnProperty$b = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty$b.call(val, key);
const isArray$6 = Array.isArray;
const isMap$2 = (val) => toTypeString(val) === "[object Map]";
const isSet$2 = (val) => toTypeString(val) === "[object Set]";
const isFunction$4 = (val) => typeof val === "function";
const isString$1 = (val) => typeof val === "string";
const isSymbol = (val) => typeof val === "symbol";
const isObject$7 = (val) => val !== null && typeof val === "object";
const isPromise = (val) => {
return (isObject$7(val) || isFunction$4(val)) && isFunction$4(val.then) && isFunction$4(val.catch);
};
const objectToString$2 = Object.prototype.toString;
const toTypeString = (value) => objectToString$2.call(value);
const toRawType = (value) => {
return toTypeString(value).slice(8, -1);
};
const isPlainObject$1 = (val) => toTypeString(val) === "[object Object]";
const isIntegerKey = (key) => isString$1(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
const isReservedProp = /* @__PURE__ */ makeMap(
// the leading comma is intentional so empty string "" is also included
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
);
const cacheStringFunction = (fn) => {
const cache = /* @__PURE__ */ Object.create(null);
return (str) => {
const hit = cache[str];
return hit || (cache[str] = fn(str));
};
};
const camelizeRE = /-(\w)/g;
const camelize = cacheStringFunction(
(str) => {
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
}
);
const hyphenateRE = /\B([A-Z])/g;
const hyphenate = cacheStringFunction(
(str) => str.replace(hyphenateRE, "-$1").toLowerCase()
);
const capitalize = cacheStringFunction((str) => {
return str.charAt(0).toUpperCase() + str.slice(1);
});
const toHandlerKey = cacheStringFunction(
(str) => {
const s = str ? `on${capitalize(str)}` : ``;
return s;
}
);
const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
const invokeArrayFns = (fns, ...arg) => {
for (let i = 0; i < fns.length; i++) {
fns[i](...arg);
}
};
const def = (obj, key, value, writable = false) => {
Object.defineProperty(obj, key, {
configurable: true,
enumerable: false,
writable,
value
});
};
const looseToNumber = (val) => {
const n = parseFloat(val);
return isNaN(n) ? val : n;
};
const toNumber = (val) => {
const n = isString$1(val) ? Number(val) : NaN;
return isNaN(n) ? val : n;
};
let _globalThis;
const getGlobalThis = () => {
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
};
function normalizeStyle(value) {
if (isArray$6(value)) {
const res = {};
for (let i = 0; i < value.length; i++) {
const item = value[i];
const normalized = isString$1(item) ? parseStringStyle(item) : normalizeStyle(item);
if (normalized) {
for (const key in normalized) {
res[key] = normalized[key];
}
}
}
return res;
} else if (isString$1(value) || isObject$7(value)) {
return value;
}
}
const listDelimiterRE = /;(?![^(]*\))/g;
const propertyDelimiterRE = /:([^]+)/;
const styleCommentRE = /\/\*[^]*?\*\//g;
function parseStringStyle(cssText) {
const ret = {};
cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
if (item) {
const tmp = item.split(propertyDelimiterRE);
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
}
});
return ret;
}
function normalizeClass(value) {
let res = "";
if (isString$1(value)) {
res = value;
} else if (isArray$6(value)) {
for (let i = 0; i < value.length; i++) {
const normalized = normalizeClass(value[i]);
if (normalized) {
res += normalized + " ";
}
}
} else if (isObject$7(value)) {
for (const name in value) {
if (value[name]) {
res += name + " ";
}
}
}
return res.trim();
}
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
function includeBooleanAttr(value) {
return !!value || value === "";
}
const isRef$1 = (val) => {
return !!(val && val["__v_isRef"] === true);
};
const toDisplayString = (val) => {
return isString$1(val) ? val : val == null ? "" : isArray$6(val) || isObject$7(val) && (val.toString === objectToString$2 || !isFunction$4(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
};
const replacer = (_key, val) => {
if (isRef$1(val)) {
return replacer(_key, val.value);
} else if (isMap$2(val)) {
return {
[`Map(${val.size})`]: [...val.entries()].reduce(
(entries, [key, val2], i) => {
entries[stringifySymbol(key, i) + " =>"] = val2;
return entries;
},
{}
)
};
} else if (isSet$2(val)) {
return {
[`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
};
} else if (isSymbol(val)) {
return stringifySymbol(val);
} else if (isObject$7(val) && !isArray$6(val) && !isPlainObject$1(val)) {
return String(val);
}
return val;
};
const stringifySymbol = (v, i = "") => {
var _a;
return (
// Symbol.description in es2019+ so we need to cast here to pass
// the lib: es2016 check
isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
);
};
/**
* @vue/reactivity v3.5.10
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
let activeEffectScope;
class EffectScope {
constructor(detached = false) {
this.detached = detached;
this._active = true;
this.effects = [];
this.cleanups = [];
this._isPaused = false;
this.parent = activeEffectScope;
if (!detached && activeEffectScope) {
this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
this
) - 1;
}
}
get active() {
return this._active;
}
pause() {
if (this._active) {
this._isPaused = true;
let i, l;
if (this.scopes) {
for (i = 0, l = this.scopes.length; i < l; i++) {
this.scopes[i].pause();
}
}
for (i = 0, l = this.effects.length; i < l; i++) {
this.effects[i].pause();
}
}
}
/**
* Resumes the effect scope, including all child scopes and effects.
*/
resume() {
if (this._active) {
if (this._isPaused) {
this._isPaused = false;
let i, l;
if (this.scopes) {
for (i = 0, l = this.scopes.length; i < l; i++) {
this.scopes[i].resume();
}
}
for (i = 0, l = this.effects.length; i < l; i++) {
this.effects[i].resume();
}
}
}
}
run(fn) {
if (this._active) {
const currentEffectScope = activeEffectScope;
try {
activeEffectScope = this;
return fn();
} finally {
activeEffectScope = currentEffectScope;
}
}
}
/**
* This should only be called on non-detached scopes
* @internal
*/
on() {
activeEffectScope = this;
}
/**
* This should only be called on non-detached scopes
* @internal
*/
off() {
activeEffectScope = this.parent;
}
stop(fromParent) {
if (this._active) {
let i, l;
for (i = 0, l = this.effects.length; i < l; i++) {
this.effects[i].stop();
}
for (i = 0, l = this.cleanups.length; i < l; i++) {
this.cleanups[i]();
}
if (this.scopes) {
for (i = 0, l = this.scopes.length; i < l; i++) {
this.scopes[i].stop(true);
}
}
if (!this.detached && this.parent && !fromParent) {
const last = this.parent.scopes.pop();
if (last && last !== this) {
this.parent.scopes[this.index] = last;
last.index = this.index;
}
}
this.parent = void 0;
this._active = false;
}
}
}
function effectScope(detached) {
return new EffectScope(detached);
}
function getCurrentScope() {
return activeEffectScope;
}
function onScopeDispose(fn, failSilently = false) {
if (activeEffectScope) {
activeEffectScope.cleanups.push(fn);
}
}
let activeSub;
const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
class ReactiveEffect {
constructor(fn) {
this.fn = fn;
this.deps = void 0;
this.depsTail = void 0;
this.flags = 1 | 4;
this.next = void 0;
this.cleanup = void 0;
this.scheduler = void 0;
if (activeEffectScope && activeEffectScope.active) {
activeEffectScope.effects.push(this);
}
}
pause() {
this.flags |= 64;
}
resume() {
if (this.flags & 64) {
this.flags &= ~64;
if (pausedQueueEffects.has(this)) {
pausedQueueEffects.delete(this);
this.trigger();
}
}
}
/**
* @internal
*/
notify() {
if (this.flags & 2 && !(this.flags & 32)) {
return;
}
if (!(this.flags & 8)) {
batch(this);
}
}
run() {
if (!(this.flags & 1)) {
return this.fn();
}
this.flags |= 2;
cleanupEffect(this);
prepareDeps(this);
const prevEffect = activeSub;
const prevShouldTrack = shouldTrack;
activeSub = this;
shouldTrack = true;
try {
return this.fn();
} finally {
cleanupDeps(this);
activeSub = prevEffect;
shouldTrack = prevShouldTrack;
this.flags &= ~2;
}
}
stop() {
if (this.flags & 1) {
for (let link = this.deps; link; link = link.nextDep) {
removeSub(link);
}
this.deps = this.depsTail = void 0;
cleanupEffect(this);
this.onStop && this.onStop();
this.flags &= ~1;
}
}
trigger() {
if (this.flags & 64) {
pausedQueueEffects.add(this);
} else if (this.scheduler) {
this.scheduler();
} else {
this.runIfDirty();
}
}
/**
* @internal
*/
runIfDirty() {
if (isDirty(this)) {
this.run();
}
}
get dirty() {
return isDirty(this);
}
}
let batchDepth = 0;
let batchedSub;
function batch(sub) {
sub.flags |= 8;
sub.next = batchedSub;
batchedSub = sub;
}
function startBatch() {
batchDepth++;
}
function endBatch() {
if (--batchDepth > 0) {
return;
}
let error;
while (batchedSub) {
let e = batchedSub;
let next;
while (e) {
if (!(e.flags & 1)) {
e.flags &= ~8;
}
e = e.next;
}
e = batchedSub;
batchedSub = void 0;
while (e) {
next = e.next;
e.next = void 0;
e.flags &= ~8;
if (e.flags & 1) {
try {
;
e.trigger();
} catch (err) {
if (!error) error = err;
}
}
e = next;
}
}
if (error) throw error;
}
function prepareDeps(sub) {
for (let link = sub.deps; link; link = link.nextDep) {
link.version = -1;
link.prevActiveLink = link.dep.activeLink;
link.dep.activeLink = link;
}
}
function cleanupDeps(sub) {
let head;
let tail = sub.depsTail;
let link = tail;
while (link) {
const prev = link.prevDep;
if (link.version === -1) {
if (link === tail) tail = prev;
removeSub(link);
removeDep(link);
} else {
head = link;
}
link.dep.activeLink = link.prevActiveLink;
link.prevActiveLink = void 0;
link = prev;
}
sub.deps = head;
sub.depsTail = tail;
}
function isDirty(sub) {
for (let link = sub.deps; link; link = link.nextDep) {
if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
return true;
}
}
if (sub._dirty) {
return true;
}
return false;
}
function refreshComputed(computed2) {
if (computed2.flags & 4 && !(computed2.flags & 16)) {
return;
}
computed2.flags &= ~16;
if (computed2.globalVersion === globalVersion) {
return;
}
computed2.globalVersion = globalVersion;
const dep = computed2.dep;
computed2.flags |= 2;
if (dep.version > 0 && !computed2.isSSR && computed2.deps && !isDirty(computed2)) {
computed2.flags &= ~2;
return;
}
const prevSub = activeSub;
const prevShouldTrack = shouldTrack;
activeSub = computed2;
shouldTrack = true;
try {
prepareDeps(computed2);
const value = computed2.fn(computed2._value);
if (dep.version === 0 || hasChanged(value, computed2._value)) {
computed2._value = value;
dep.version++;
}
} catch (err) {
dep.version++;
throw err;
} finally {
activeSub = prevSub;
shouldTrack = prevShouldTrack;
cleanupDeps(computed2);
computed2.flags &= ~2;
}
}
function removeSub(link, soft = false) {
const { dep, prevSub, nextSub } = link;
if (prevSub) {
prevSub.nextSub = nextSub;
link.prevSub = void 0;
}
if (nextSub) {
nextSub.prevSub = prevSub;
link.nextSub = void 0;
}
if (dep.subs === link) {
dep.subs = prevSub;
}
if (!dep.subs && dep.computed) {
dep.computed.flags &= ~4;
for (let l = dep.computed.deps; l; l = l.nextDep) {
removeSub(l, true);
}
}
if (!soft && !--dep.sc && dep.map) {
dep.map.delete(dep.key);
}
}
function removeDep(link) {
const { prevDep, nextDep } = link;
if (prevDep) {
prevDep.nextDep = nextDep;
link.prevDep = void 0;
}
if (nextDep) {
nextDep.prevDep = prevDep;
link.nextDep = void 0;
}
}
let shouldTrack = true;
const trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function resetTracking() {
const last = trackStack.pop();
shouldTrack = last === void 0 ? true : last;
}
function cleanupEffect(e) {
const { cleanup } = e;
e.cleanup = void 0;
if (cleanup) {
const prevSub = activeSub;
activeSub = void 0;
try {
cleanup();
} finally {
activeSub = prevSub;
}
}
}
let globalVersion = 0;
class Link {
constructor(sub, dep) {
this.sub = sub;
this.dep = dep;
this.version = dep.version;
this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
}
}
class Dep {
constructor(computed2) {
this.computed = computed2;
this.version = 0;
this.activeLink = void 0;
this.subs = void 0;
this.target = void 0;
this.map = void 0;
this.key = void 0;
this.sc = 0;
}
track(debugInfo) {
if (!activeSub || !shouldTrack || activeSub === this.computed) {
return;
}
let link = this.activeLink;
if (link === void 0 || link.sub !== activeSub) {
link = this.activeLink = new Link(activeSub, this);
if (!activeSub.deps) {
activeSub.deps = activeSub.depsTail = link;
} else {
link.prevDep = activeSub.depsTail;
activeSub.depsTail.nextDep = link;
activeSub.depsTail = link;
}
addSub(link);
} else if (link.version === -1) {
link.version = this.version;
if (link.nextDep) {
const next = link.nextDep;
next.prevDep = link.prevDep;
if (link.prevDep) {
link.prevDep.nextDep = next;
}
link.prevDep = activeSub.depsTail;
link.nextDep = void 0;
activeSub.depsTail.nextDep = link;
activeSub.depsTail = link;
if (activeSub.deps === link) {
activeSub.deps = next;
}
}
}
return link;
}
trigger(debugInfo) {
this.version++;
globalVersion++;
this.notify(debugInfo);
}
notify(debugInfo) {
startBatch();
try {
if (false) ;
for (let link = this.subs; link; link = link.prevSub) {
if (link.sub.notify()) {
;
link.sub.dep.notify();
}
}
} finally {
endBatch();
}
}
}
function addSub(link) {
link.dep.sc++;
if (link.sub.flags & 4) {
const computed2 = link.dep.computed;
if (computed2 && !link.dep.subs) {
computed2.flags |= 4 | 16;
for (let l = computed2.deps; l; l = l.nextDep) {
addSub(l);
}
}
const currentTail = link.dep.subs;
if (currentTail !== link) {
link.prevSub = currentTail;
if (currentTail) currentTail.nextSub = link;
}
link.dep.subs = link;
}
}
const targetMap = /* @__PURE__ */ new WeakMap();
const ITERATE_KEY = Symbol(
""
);
const MAP_KEY_ITERATE_KEY = Symbol(
""
);
const ARRAY_ITERATE_KEY = Symbol(
""
);
function track(target, type, key) {
if (shouldTrack && activeSub) {
let depsMap = targetMap.get(target);
if (!depsMap) {
targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
}
let dep = depsMap.get(key);
if (!dep) {
depsMap.set(key, dep = new Dep());
dep.target = target;
dep.map = depsMap;
dep.key = key;
}
{
dep.track();
}
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) {
globalVersion++;
return;
}
const run = (dep) => {
if (dep) {
{
dep.trigger();
}
}
};
startBatch();
if (type === "clear") {
depsMap.forEach(run);
} else {
const targetIsArray = isArray$6(target);
const isArrayIndex = targetIsArray && isIntegerKey(key);
if (targetIsArray && key === "length") {
const newLength = Number(newValue);
depsMap.forEach((dep, key2) => {
if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
run(dep);
}
});
} else {
if (key !== void 0) {
run(depsMap.get(key));
}
if (isArrayIndex) {
run(depsMap.get(ARRAY_ITERATE_KEY));
}
switch (type) {
case "add":
if (!targetIsArray) {
run(depsMap.get(ITERATE_KEY));
if (isMap$2(target)) {
run(depsMap.get(MAP_KEY_ITERATE_KEY));
}
} else if (isArrayIndex) {
run(depsMap.get("length"));
}
break;
case "delete":
if (!targetIsArray) {
run(depsMap.get(ITERATE_KEY));
if (isMap$2(target)) {
run(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set":
if (isMap$2(target)) {
run(depsMap.get(ITERATE_KEY));
}
break;
}
}
}
endBatch();
}
function getDepFromReactive(object, key) {
const depMap = targetMap.get(object);
return depMap && depMap.get(key);
}
function reactiveReadArray(array) {
const raw = toRaw(array);
if (raw === array) return raw;
track(raw, "iterate", ARRAY_ITERATE_KEY);
return isShallow(array) ? raw : raw.map(toReactive);
}
function shallowReadArray(arr) {
track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
return arr;
}
const arrayInstrumentations = {
__proto__: null,
[Symbol.iterator]() {
return iterator(this, Symbol.iterator, toReactive);
},
concat(...args) {
return reactiveReadArray(this).concat(
...args.map((x) => isArray$6(x) ? reactiveReadArray(x) : x)
);
},
entries() {
return iterator(this, "entries", (value) => {
value[1] = toReactive(value[1]);
return value;
});
},
every(fn, thisArg) {
return apply(this, "every", fn, thisArg, void 0, arguments);
},
filter(fn, thisArg) {
return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
},
find(fn, thisArg) {
return apply(this, "find", fn, thisArg, toReactive, arguments);
},
findIndex(fn, thisArg) {
return apply(this, "findIndex", fn, thisArg, void 0, arguments);
},
findLast(fn, thisArg) {
return apply(this, "findLast", fn, thisArg, toReactive, arguments);
},
findLastIndex(fn, thisArg) {
return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
},
// flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
forEach(fn, thisArg) {
return apply(this, "forEach", fn, thisArg, void 0, arguments);
},
includes(...args) {
return searchProxy(this, "includes", args);
},
indexOf(...args) {
return searchProxy(this, "indexOf", args);
},
join(separator) {
return reactiveReadArray(this).join(separator);
},
// keys() iterator only reads `length`, no optimisation required
lastIndexOf(...args) {
return searchProxy(this, "lastIndexOf", args);
},
map(fn, thisArg) {
return apply(this, "map", fn, thisArg, void 0, arguments);
},
pop() {
return noTracking(this, "pop");
},
push(...args) {
return noTracking(this, "push", args);
},
reduce(fn, ...args) {
return reduce(this, "reduce", fn, args);
},
reduceRight(fn, ...args) {
return reduce(this, "reduceRight", fn, args);
},
shift() {
return noTracking(this, "shift");
},
// slice could use ARRAY_ITERATE but also seems to beg for range tracking
some(fn, thisArg) {
return apply(this, "some", fn, thisArg, void 0, arguments);
},
splice(...args) {
return noTracking(this, "splice", args);
},
toReversed() {
return reactiveReadArray(this).toReversed();
},
toSorted(comparer) {
return reactiveReadArray(this).toSorted(comparer);
},
toSpliced(...args) {
return reactiveReadArray(this).toSpliced(...args);
},
unshift(...args) {
return noTracking(this, "unshift", args);
},
values() {
return iterator(this, "values", toReactive);
}
};
function iterator(self2, method, wrapValue) {
const arr = shallowReadArray(self2);
const iter = arr[method]();
if (arr !== self2 && !isShallow(self2)) {
iter._next = iter.next;
iter.next = () => {
const result = iter._next();
if (result.value) {
result.value = wrapValue(result.value);
}
return result;
};
}
return iter;
}
const arrayProto$1 = Array.prototype;
function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
const arr = shallowReadArray(self2);
const needsWrap = arr !== self2 && !isShallow(self2);
const methodFn = arr[method];
if (methodFn !== arrayProto$1[method]) {
const result2 = methodFn.apply(self2, args);
return needsWrap ? toReactive(result2) : result2;
}
let wrappedFn = fn;
if (arr !== self2) {
if (needsWrap) {
wrappedFn = function(item, index2) {
return fn.call(this, toReactive(item), index2, self2);
};
} else if (fn.length > 2) {
wrappedFn = function(item, index2) {
return fn.call(this, item, index2, self2);
};
}
}
const result = methodFn.call(arr, wrappedFn, thisArg);
return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
}
function reduce(self2, method, fn, args) {
const arr = shallowReadArray(self2);
let wrappedFn = fn;
if (arr !== self2) {
if (!isShallow(self2)) {
wrappedFn = function(acc, item, index2) {
return fn.call(this, acc, toReactive(item), index2, self2);
};
} else if (fn.length > 3) {
wrappedFn = function(acc, item, index2) {
return fn.call(this, acc, item, index2, self2);
};
}
}
return arr[method](wrappedFn, ...args);
}
function searchProxy(self2, method, args) {
const arr = toRaw(self2);
track(arr, "iterate", ARRAY_ITERATE_KEY);
const res = arr[method](...args);
if ((res === -1 || res === false) && isProxy(args[0])) {
args[0] = toRaw(args[0]);
return arr[method](...args);
}
return res;
}
function noTracking(self2, method, args = []) {
pauseTracking();
startBatch();
const res = toRaw(self2)[method].apply(self2, args);
endBatch();
resetTracking();
return res;
}
const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
const builtInSymbols = new Set(
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
);
function hasOwnProperty$a(key) {
if (!isSymbol(key)) key = String(key);
const obj = toRaw(this);
track(obj, "has", key);
return obj.hasOwnProperty(key);
}
class BaseReactiveHandler {
constructor(_isReadonly = false, _isShallow = false) {
this._isReadonly = _isReadonly;
this._isShallow = _isShallow;
}
get(target, key, receiver) {
const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_isShallow") {
return isShallow2;
} else if (key === "__v_raw") {
if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
// this means the receiver is a user proxy of the reactive proxy
Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
return target;
}
return;
}
const targetIsArray = isArray$6(target);
if (!isReadonly2) {
let fn;
if (targetIsArray && (fn = arrayInstrumentations[key])) {
return fn;
}
if (key === "hasOwnProperty") {
return hasOwnProperty$a;
}
}
const res = Reflect.get(
target,
key,
// if this is a proxy wrapping a ref, return methods using the raw ref
// as receiver so that we don't have to call `toRaw` on the ref in all
// its class methods
isRef(target) ? target : receiver
);
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
return res;
}
if (!isReadonly2) {
track(target, "get", key);
}
if (isShallow2) {
return res;
}
if (isRef(res)) {
return targetIsArray && isIntegerKey(key) ? res : res.value;
}
if (isObject$7(res)) {
return isReadonly2 ? readonly(res) : reactive(res);
}
return res;
}
}
class MutableReactiveHandler extends BaseReactiveHandler {
constructor(isShallow2 = false) {
super(false, isShallow2);
}
set(target, key, value, receiver) {
let oldValue = target[key];
if (!this._isShallow) {
const isOldValueReadonly = isReadonly(oldValue);
if (!isShallow(value) && !isReadonly(value)) {
oldValue = toRaw(oldValue);
value = toRaw(value);
}
if (!isArray$6(target) && isRef(oldValue) && !isRef(value)) {
if (isOldValueReadonly) {
return false;
} else {
oldValue.value = value;
return true;
}
}
}
const hadKey = isArray$6(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
const result = Reflect.set(
target,
key,
value,
isRef(target) ? target : receiver
);
if (target === toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value);
}
}
return result;
}
deleteProperty(target, key) {
const hadKey = hasOwn(target, key);
target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
trigger(target, "delete", key, void 0);
}
return result;
}
has(target, key) {
const result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has", key);
}
return result;
}
ownKeys(target) {
track(
target,
"iterate",
isArray$6(target) ? "length" : ITERATE_KEY
);
return Reflect.ownKeys(target);
}
}
class ReadonlyReactiveHandler extends BaseReactiveHandler {
constructor(isShallow2 = false) {
super(true, isShallow2);
}
set(target, key) {
return true;
}
deleteProperty(target, key) {
return true;
}
}
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, isReadonly2 = false, isShallow2 = false) {
target = target["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (!isReadonly2) {
if (hasChanged(key, rawKey)) {
track(rawTarget, "get", key);
}
track(rawTarget, "get", rawKey);
}
const { has: has2 } = getProto(rawTarget);
const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
if (has2.call(rawTarget, key)) {
return wrap(target.get(key));
} else if (has2.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
} else if (target !== rawTarget) {
target.get(key);
}
}
function has(key, isReadonly2 = false) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (!isReadonly2) {
if (hasChanged(key, rawKey)) {
track(rawTarget, "has", key);
}
track(rawTarget, "has", rawKey);
}
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
}
function size(target, isReadonly2 = false) {
target = target["__v_raw"];
!isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
return Reflect.get(target, "size", target);
}
function add(value, _isShallow = false) {
if (!_isShallow && !isShallow(value) && !isReadonly(value)) {
value = toRaw(value);
}
const target = toRaw(this);
const proto = getProto(target);
const hadKey = proto.has.call(target, value);
if (!hadKey) {
target.add(value);
trigger(target, "add", value, value);
}
return this;
}
function set$1(key, value, _isShallow = false) {
if (!_isShallow && !isShallow(value) && !isReadonly(value)) {
value = toRaw(value);
}
const target = toRaw(this);
const { has: has2, get: get2 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
}
const oldValue = get2.call(target, key);
target.set(key, value);
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value);
}
return this;
}
function deleteEntry(key) {
const target = toRaw(this);
const { has: has2, get: get2 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
}
get2 ? get2.call(target, key) : void 0;
const result = target.delete(key);
if (hadKey) {
trigger(target, "delete", key, void 0);
}
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
const result = target.clear();
if (hadItems) {
trigger(target, "clear", void 0, void 0);
}
return result;
}
function createForEach(isReadonly2, isShallow2) {
return function forEach(callback, thisArg) {
const observed = this;
const target = observed["__v_raw"];
const rawTarget = toRaw(target);
const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
!isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
return target.forEach((value, key) => {
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly2, isShallow2) {
return function(...args) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const targetIsMap = isMap$2(rawTarget);
const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
const isKeyOnly = method === "keys" && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
!isReadonly2 && track(
rawTarget,
"iterate",
isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
);
return {
// iterator protocol
next() {
const { value, done } = innerIterator.next();
return done ? { value, done } : {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done
};
},
// iterable protocol
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(type) {
return function(...args) {
return type === "delete" ? false : type === "clear" ? void 0 : this;
};
}
function createInstrumentations() {
const mutableInstrumentations2 = {
get(key) {
return get$1(this, key);
},
get size() {
return size(this);
},
has,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, false)
};
const shallowInstrumentations2 = {
get(key) {
return get$1(this, key, false, true);
},
get size() {
return size(this);
},
has,
add(value) {
return add.call(this, value, true);
},
set(key, value) {
return set$1.call(this, key, value, true);
},
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations2 = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has.call(this, key, true);
},
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, false)
};
const shallowReadonlyInstrumentations2 = {
get(key) {
return get$1(this, key, true, true);
},
get size() {
return size(this, true);
},
has(key) {
return has.call(this, key, true);
},
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, true)
};
const iteratorMethods = [
"keys",
"values",
"entries",
Symbol.iterator
];
iteratorMethods.forEach((method) => {
mutableInstrumentations2[method] = createIterableMethod(method, false, false);
readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
shallowInstrumentations2[method] = createIterableMethod(method, false, true);
shallowReadonlyInstrumentations2[method] = createIterableMethod(
method,
true,
true
);
});
return [
mutableInstrumentations2,
readonlyInstrumentations2,
shallowInstrumentations2,
shallowReadonlyInstrumentations2
];
}
const [
mutableInstrumentations,
readonlyInstrumentations,
shallowInstrumentations,
shallowReadonlyInstrumentations
] = /* @__PURE__ */ createInstrumentations();
function createInstrumentationGetter(isReadonly2, shallow) {
const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_raw") {
return target;
}
return Reflect.get(
hasOwn(instrumentations, key) && key in target ? instrumentations : target,
key,
receiver
);
};
}
const mutableCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(true, false)
};
const shallowReadonlyCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(true, true)
};
const reactiveMap = /* @__PURE__ */ new WeakMap();
const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
const readonlyMap = /* @__PURE__ */ new WeakMap();
const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case "Object":
case "Array":
return 1;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2;
default:
return 0;
}
}
function getTargetType(value) {
return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
}
function reactive(target) {
if (isReadonly(target)) {
return target;
}
return createReactiveObject(
target,
false,
mutableHandlers,
mutableCollectionHandlers,
reactiveMap
);
}
function shallowReactive(target) {
return createReactiveObject(
target,
false,
shallowReactiveHandlers,
shallowCollectionHandlers,
shallowReactiveMap
);
}
function readonly(target) {
return createReactiveObject(
target,
true,
readonlyHandlers,
readonlyCollectionHandlers,
readonlyMap
);
}
function shallowReadonly(target) {
return createReactiveObject(
target,
true,
shallowReadonlyHandlers,
shallowReadonlyCollectionHandlers,
shallowReadonlyMap
);
}
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
if (!isObject$7(target)) {
return target;
}
if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
return target;
}
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
const targetType = getTargetType(target);
if (targetType === 0) {
return target;
}
const proxy = new Proxy(
target,
targetType === 2 ? collectionHandlers : baseHandlers
);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value["__v_raw"]);
}
return !!(value && value["__v_isReactive"]);
}
function isReadonly(value) {
return !!(value && value["__v_isReadonly"]);
}
function isShallow(value) {
return !!(value && value["__v_isShallow"]);
}
function isProxy(value) {
return value ? !!value["__v_raw"] : false;
}
function toRaw(observed) {
const raw = observed && observed["__v_raw"];
return raw ? toRaw(raw) : observed;
}
function markRaw(value) {
if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
def(value, "__v_skip", true);
}
return value;
}
const toReactive = (value) => isObject$7(value) ? reactive(value) : value;
const toReadonly = (value) => isObject$7(value) ? readonly(value) : value;
function isRef(r) {
return r ? r["__v_isRef"] === true : false;
}
function ref(value) {
return createRef(value, false);
}
function shallowRef(value) {
return createRef(value, true);
}
function createRef(rawValue, shallow) {
if (isRef(rawValue)) {
return rawValue;
}
return new RefImpl(rawValue, shallow);
}
class RefImpl {
constructor(value, isShallow2) {
this.dep = new Dep();
this["__v_isRef"] = true;
this["__v_isShallow"] = false;
this._rawValue = isShallow2 ? value : toRaw(value);
this._value = isShallow2 ? value : toReactive(value);
this["__v_isShallow"] = isShallow2;
}
get value() {
{
this.dep.track();
}
return this._value;
}
set value(newValue) {
const oldValue = this._rawValue;
const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
newValue = useDirectValue ? newValue : toRaw(newValue);
if (hasChanged(newValue, oldValue)) {
this._rawValue = newValue;
this._value = useDirectValue ? newValue : toReactive(newValue);
{
this.dep.trigger();
}
}
}
}
function unref(ref2) {
return isRef(ref2) ? ref2.value : ref2;
}
const shallowUnwrapHandlers = {
get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
} else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
function toRefs(object) {
const ret = isArray$6(object) ? new Array(object.length) : {};
for (const key in object) {
ret[key] = propertyToRef(object, key);
}
return ret;
}
class ObjectRefImpl {
constructor(_object, _key, _defaultValue) {
this._object = _object;
this._key = _key;
this._defaultValue = _defaultValue;
this["__v_isRef"] = true;
this._value = void 0;
}
get value() {
const val = this._object[this._key];
return this._value = val === void 0 ? this._defaultValue : val;
}
set value(newVal) {
this._object[this._key] = newVal;
}
get dep() {
return getDepFromReactive(toRaw(this._object), this._key);
}
}
function propertyToRef(source, key, defaultValue) {
const val = source[key];
return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
}
class ComputedRefImpl {
constructor(fn, setter, isSSR) {
this.fn = fn;
this.setter = setter;
this._value = void 0;
this.dep = new Dep(this);
this.__v_isRef = true;
this.deps = void 0;
this.depsTail = void 0;
this.flags = 16;
this.globalVersion = globalVersion - 1;
this.next = void 0;
this.effect = this;
this["__v_isReadonly"] = !setter;
this.isSSR = isSSR;
}
/**
* @internal
*/
notify() {
this.flags |= 16;
if (!(this.flags & 8) && // avoid infinite self recursion
activeSub !== this) {
batch(this);
return true;
}
}
get value() {
const link = this.dep.track();
refreshComputed(this);
if (link) {
link.version = this.dep.version;
}
return this._value;
}
set value(newValue) {
if (this.setter) {
this.setter(newValue);
}
}
}
function computed$1(getterOrOptions, debugOptions, isSSR = false) {
let getter;
let setter;
if (isFunction$4(getterOrOptions)) {
getter = getterOrOptions;
} else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
const cRef = new ComputedRefImpl(getter, setter, isSSR);
return cRef;
}
const INITIAL_WATCHER_VALUE = {};
const cleanupMap = /* @__PURE__ */ new WeakMap();
let activeWatcher = void 0;
function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
if (owner) {
let cleanups = cleanupMap.get(owner);
if (!cleanups) cleanupMap.set(owner, cleanups = []);
cleanups.push(cleanupFn);
}
}
function watch$1(source, cb, options = EMPTY_OBJ) {
const { immediate, deep, once, scheduler, augmentJob, call } = options;
const reactiveGetter = (source2) => {
if (deep) return source2;
if (isShallow(source2) || deep === false || deep === 0)
return traverse(source2, 1);
return traverse(source2);
};
let effect2;
let getter;
let cleanup;
let boundCleanup;
let forceTrigger = false;
let isMultiSource = false;
if (isRef(source)) {
getter = () => source.value;
forceTrigger = isShallow(source);
} else if (isReactive(source)) {
getter = () => reactiveGetter(source);
forceTrigger = true;
} else if (isArray$6(source)) {
isMultiSource = true;
forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
getter = () => source.map((s) => {
if (isRef(s)) {
return s.value;
} else if (isReactive(s)) {
return reactiveGetter(s);
} else if (isFunction$4(s)) {
return call ? call(s, 2) : s();
} else ;
});
} else if (isFunction$4(source)) {
if (cb) {
getter = call ? () => call(source, 2) : source;
} else {
getter = () => {
if (cleanup) {
pauseTracking();
try {
cleanup();
} finally {
resetTracking();
}
}
const currentEffect = activeWatcher;
activeWatcher = effect2;
try {
return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
} finally {
activeWatcher = currentEffect;
}
};
}
} else {
getter = NOOP;
}
if (cb && deep) {
const baseGetter = getter;
const depth = deep === true ? Infinity : deep;
getter = () => traverse(baseGetter(), depth);
}
const scope = getCurrentScope();
const watchHandle = () => {
effect2.stop();
if (scope) {
remove(scope.effects, effect2);
}
};
if (once && cb) {
const _cb = cb;
cb = (...args) => {
_cb(...args);
watchHandle();
};
}
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
const job = (immediateFirstRun) => {
if (!(effect2.flags & 1) || !effect2.dirty && !immediateFirstRun) {
return;
}
if (cb) {
const newValue = effect2.run();
if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
if (cleanup) {
cleanup();
}
const currentWatcher = activeWatcher;
activeWatcher = effect2;
try {
const args = [
newValue,
// pass undefined as the old value when it's changed for the first time
oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
boundCleanup
];
call ? call(cb, 3, args) : (
// @ts-expect-error
cb(...args)
);
oldValue = newValue;
} finally {
activeWatcher = currentWatcher;
}
}
} else {
effect2.run();
}
};
if (augmentJob) {
augmentJob(job);
}
effect2 = new ReactiveEffect(getter);
effect2.scheduler = scheduler ? () => scheduler(job, false) : job;
boundCleanup = (fn) => onWatcherCleanup(fn, false, effect2);
cleanup = effect2.onStop = () => {
const cleanups = cleanupMap.get(effect2);
if (cleanups) {
if (call) {
call(cleanups, 4);
} else {
for (const cleanup2 of cleanups) cleanup2();
}
cleanupMap.delete(effect2);
}
};
if (cb) {
if (immediate) {
job(true);
} else {
oldValue = effect2.run();
}
} else if (scheduler) {
scheduler(job.bind(null, true), true);
} else {
effect2.run();
}
watchHandle.pause = effect2.pause.bind(effect2);
watchHandle.resume = effect2.resume.bind(effect2);
watchHandle.stop = watchHandle;
return watchHandle;
}
function traverse(value, depth = Infinity, seen) {
if (depth <= 0 || !isObject$7(value) || value["__v_skip"]) {
return value;
}
seen = seen || /* @__PURE__ */ new Set();
if (seen.has(value)) {
return value;
}
seen.add(value);
depth--;
if (isRef(value)) {
traverse(value.value, depth, seen);
} else if (isArray$6(value)) {
for (let i = 0; i < value.length; i++) {
traverse(value[i], depth, seen);
}
} else if (isSet$2(value) || isMap$2(value)) {
value.forEach((v) => {
traverse(v, depth, seen);
});
} else if (isPlainObject$1(value)) {
for (const key in value) {
traverse(value[key], depth, seen);
}
for (const key of Object.getOwnPropertySymbols(value)) {
if (Object.prototype.propertyIsEnumerable.call(value, key)) {
traverse(value[key], depth, seen);
}
}
}
return value;
}
/**
* @vue/runtime-core v3.5.10
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
const stack = [];
let isWarning = false;
function warn$1(msg, ...args) {
if (isWarning) return;
isWarning = true;
pauseTracking();
const instance = stack.length ? stack[stack.length - 1].component : null;
const appWarnHandler = instance && instance.appContext.config.warnHandler;
const trace = getComponentTrace();
if (appWarnHandler) {
callWithErrorHandling(
appWarnHandler,
instance,
11,
[
// eslint-disable-next-line no-restricted-syntax
msg + args.map((a) => {
var _a, _b;
return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
}).join(""),
instance && instance.proxy,
trace.map(
({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
).join("\n"),
trace
]
);
} else {
const warnArgs = [`[Vue warn]: ${msg}`, ...args];
if (trace.length && // avoid spamming console during tests
true) {
warnArgs.push(`
`, ...formatTrace(trace));
}
console.warn(...warnArgs);
}
resetTracking();
isWarning = false;
}
function getComponentTrace() {
let currentVNode = stack[stack.length - 1];
if (!currentVNode) {
return [];
}
const normalizedStack = [];
while (currentVNode) {
const last = normalizedStack[0];
if (last && last.vnode === currentVNode) {
last.recurseCount++;
} else {
normalizedStack.push({
vnode: currentVNode,
recurseCount: 0
});
}
const parentInstance = currentVNode.component && currentVNode.component.parent;
currentVNode = parentInstance && parentInstance.vnode;
}
return normalizedStack;
}
function formatTrace(trace) {
const logs = [];
trace.forEach((entry, i) => {
logs.push(...i === 0 ? [] : [`
`], ...formatTraceEntry(entry));
});
return logs;
}
function formatTraceEntry({ vnode, recurseCount }) {
const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
const isRoot = vnode.component ? vnode.component.parent == null : false;
const open = ` at <${formatComponentName(
vnode.component,
vnode.type,
isRoot
)}`;
const close2 = `>` + postfix;
return vnode.props ? [open, ...formatProps(vnode.props), close2] : [open + close2];
}
function formatProps(props) {
const res = [];
const keys2 = Object.keys(props);
keys2.slice(0, 3).forEach((key) => {
res.push(...formatProp(key, props[key]));
});
if (keys2.length > 3) {
res.push(` ...`);
}
return res;
}
function formatProp(key, value, raw) {
if (isString$1(value)) {
value = JSON.stringify(value);
return raw ? value : [`${key}=${value}`];
} else if (typeof value === "number" || typeof value === "boolean" || value == null) {
return raw ? value : [`${key}=${value}`];
} else if (isRef(value)) {
value = formatProp(key, toRaw(value.value), true);
return raw ? value : [`${key}=Ref<`, value, `>`];
} else if (isFunction$4(value)) {
return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
} else {
value = toRaw(value);
return raw ? value : [`${key}=`, value];
}
}
function callWithErrorHandling(fn, instance, type, args) {
try {
return args ? fn(...args) : fn();
} catch (err) {
handleError(err, instance, type);
}
}
function callWithAsyncErrorHandling(fn, instance, type, args) {
if (isFunction$4(fn)) {
const res = callWithErrorHandling(fn, instance, type, args);
if (res && isPromise(res)) {
res.catch((err) => {
handleError(err, instance, type);
});
}
return res;
}
if (isArray$6(fn)) {
const values = [];
for (let i = 0; i < fn.length; i++) {
values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
}
return values;
}
}
function handleError(err, instance, type, throwInDev = true) {
const contextVNode = instance ? instance.vnode : null;
const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
if (instance) {
let cur = instance.parent;
const exposedInstance = instance.proxy;
const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
while (cur) {
const errorCapturedHooks = cur.ec;
if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
return;
}
}
}
cur = cur.parent;
}
if (errorHandler) {
pauseTracking();
callWithErrorHandling(errorHandler, null, 10, [
err,
exposedInstance,
errorInfo
]);
resetTracking();
return;
}
}
logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
}
function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
if (throwInProd) {
throw err;
} else {
console.error(err);
}
}
let isFlushing = false;
let isFlushPending = false;
const queue = [];
let flushIndex = 0;
const pendingPostFlushCbs = [];
let activePostFlushCbs = null;
let postFlushIndex = 0;
const resolvedPromise = /* @__PURE__ */ Promise.resolve();
let currentFlushPromise = null;
function nextTick(fn) {
const p2 = currentFlushPromise || resolvedPromise;
return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
}
function findInsertionIndex$1(id) {
let start = isFlushing ? flushIndex + 1 : 0;
let end = queue.length;
while (start < end) {
const middle = start + end >>> 1;
const middleJob = queue[middle];
const middleJobId = getId(middleJob);
if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
start = middle + 1;
} else {
end = middle;
}
}
return start;
}
function queueJob(job) {
if (!(job.flags & 1)) {
const jobId = getId(job);
const lastJob = queue[queue.length - 1];
if (!lastJob || // fast path when the job id is larger than the tail
!(job.flags & 2) && jobId >= getId(lastJob)) {
queue.push(job);
} else {
queue.splice(findInsertionIndex$1(jobId), 0, job);
}
job.flags |= 1;
queueFlush();
}
}
function queueFlush() {
if (!isFlushing && !isFlushPending) {
isFlushPending = true;
currentFlushPromise = resolvedPromise.then(flushJobs);
}
}
function queuePostFlushCb(cb) {
if (!isArray$6(cb)) {
if (activePostFlushCbs && cb.id === -1) {
activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
} else if (!(cb.flags & 1)) {
pendingPostFlushCbs.push(cb);
cb.flags |= 1;
}
} else {
pendingPostFlushCbs.push(...cb);
}
queueFlush();
}
function flushPreFlushCbs(instance, seen, i = isFlushing ? flushIndex + 1 : 0) {
for (; i < queue.length; i++) {
const cb = queue[i];
if (cb && cb.flags & 2) {
if (instance && cb.id !== instance.uid) {
continue;
}
queue.splice(i, 1);
i--;
if (cb.flags & 4) {
cb.flags &= ~1;
}
cb();
if (!(cb.flags & 4)) {
cb.flags &= ~1;
}
}
}
}
function flushPostFlushCbs(seen) {
if (pendingPostFlushCbs.length) {
const deduped = [...new Set(pendingPostFlushCbs)].sort(
(a, b) => getId(a) - getId(b)
);
pendingPostFlushCbs.length = 0;
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
const cb = activePostFlushCbs[postFlushIndex];
if (cb.flags & 4) {
cb.flags &= ~1;
}
if (!(cb.flags & 8)) cb();
cb.flags &= ~1;
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
function flushJobs(seen) {
isFlushPending = false;
isFlushing = true;
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job && !(job.flags & 8)) {
if (false) ;
if (job.flags & 4) {
job.flags &= ~1;
}
callWithErrorHandling(
job,
job.i,
job.i ? 15 : 14
);
if (!(job.flags & 4)) {
job.flags &= ~1;
}
}
}
} finally {
for (; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job) {
job.flags &= ~1;
}
}
flushIndex = 0;
queue.length = 0;
flushPostFlushCbs();
isFlushing = false;
currentFlushPromise = null;
if (queue.length || pendingPostFlushCbs.length) {
flushJobs();
}
}
}
let currentRenderingInstance = null;
let currentScopeId = null;
function setCurrentRenderingInstance(instance) {
const prev = currentRenderingInstance;
currentRenderingInstance = instance;
currentScopeId = instance && instance.type.__scopeId || null;
return prev;
}
function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
if (!ctx) return fn;
if (fn._n) {
return fn;
}
const renderFnWithContext = (...args) => {
if (renderFnWithContext._d) {
setBlockTracking(-1);
}
const prevInstance = setCurrentRenderingInstance(ctx);
let res;
try {
res = fn(...args);
} finally {
setCurrentRenderingInstance(prevInstance);
if (renderFnWithContext._d) {
setBlockTracking(1);
}
}
return res;
};
renderFnWithContext._n = true;
renderFnWithContext._c = true;
renderFnWithContext._d = true;
return renderFnWithContext;
}
function withDirectives(vnode, directives) {
if (currentRenderingInstance === null) {
return vnode;
}
const instance = getComponentPublicInstance(currentRenderingInstance);
const bindings = vnode.dirs || (vnode.dirs = []);
for (let i = 0; i < directives.length; i++) {
let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
if (dir) {
if (isFunction$4(dir)) {
dir = {
mounted: dir,
updated: dir
};
}
if (dir.deep) {
traverse(value);
}
bindings.push({
dir,
instance,
value,
oldValue: void 0,
arg,
modifiers
});
}
}
return vnode;
}
function invokeDirectiveHook(vnode, prevVNode, instance, name) {
const bindings = vnode.dirs;
const oldBindings = prevVNode && prevVNode.dirs;
for (let i = 0; i < bindings.length; i++) {
const binding = bindings[i];
if (oldBindings) {
binding.oldValue = oldBindings[i].value;
}
let hook = binding.dir[name];
if (hook) {
pauseTracking();
callWithAsyncErrorHandling(hook, instance, 8, [
vnode.el,
binding,
vnode,
prevVNode
]);
resetTracking();
}
}
}
const TeleportEndKey = Symbol("_vte");
const isTeleport = (type) => type.__isTeleport;
const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
const isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
const resolveTarget = (props, select) => {
const targetSelector = props && props.to;
if (isString$1(targetSelector)) {
if (!select) {
return null;
} else {
const target = select(targetSelector);
return target;
}
} else {
return targetSelector;
}
};
const TeleportImpl = {
name: "Teleport",
__isTeleport: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
const {
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
o: { insert, querySelector, createText, createComment }
} = internals;
const disabled2 = isTeleportDisabled(n2.props);
let { shapeFlag, children, dynamicChildren } = n2;
if (n1 == null) {
const placeholder = n2.el = createText("");
const mainAnchor = n2.anchor = createText("");
insert(placeholder, container, anchor);
insert(mainAnchor, container, anchor);
const mount = (container2, anchor2) => {
if (shapeFlag & 16) {
if (parentComponent && parentComponent.isCE) {
parentComponent.ce._teleportTarget = container2;
}
mountChildren(
children,
container2,
anchor2,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
};
const mountToTarget = () => {
const target = n2.target = resolveTarget(n2.props, querySelector);
const targetAnchor = prepareAnchor(target, n2, createText, insert);
if (target) {
if (namespace !== "svg" && isTargetSVG(target)) {
namespace = "svg";
} else if (namespace !== "mathml" && isTargetMathML(target)) {
namespace = "mathml";
}
if (!disabled2) {
mount(target, targetAnchor);
updateCssVars(n2);
}
}
};
if (disabled2) {
mount(container, mainAnchor);
updateCssVars(n2);
}
if (isTeleportDeferred(n2.props)) {
queuePostRenderEffect(mountToTarget, parentSuspense);
} else {
mountToTarget();
}
} else {
n2.el = n1.el;
n2.targetStart = n1.targetStart;
const mainAnchor = n2.anchor = n1.anchor;
const target = n2.target = n1.target;
const targetAnchor = n2.targetAnchor = n1.targetAnchor;
const wasDisabled = isTeleportDisabled(n1.props);
const currentContainer = wasDisabled ? container : target;
const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
if (namespace === "svg" || isTargetSVG(target)) {
namespace = "svg";
} else if (namespace === "mathml" || isTargetMathML(target)) {
namespace = "mathml";
}
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
currentContainer,
parentComponent,
parentSuspense,
namespace,
slotScopeIds
);
traverseStaticChildren(n1, n2, true);
} else if (!optimized) {
patchChildren(
n1,
n2,
currentContainer,
currentAnchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
false
);
}
if (disabled2) {
if (!wasDisabled) {
moveTeleport(
n2,
container,
mainAnchor,
internals,
1
);
} else {
if (n2.props && n1.props && n2.props.to !== n1.props.to) {
n2.props.to = n1.props.to;
}
}
} else {
if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
const nextTarget = n2.target = resolveTarget(
n2.props,
querySelector
);
if (nextTarget) {
moveTeleport(
n2,
nextTarget,
null,
internals,
0
);
}
} else if (wasDisabled) {
moveTeleport(
n2,
target,
targetAnchor,
internals,
1
);
}
}
updateCssVars(n2);
}
},
remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
const {
shapeFlag,
children,
anchor,
targetStart,
targetAnchor,
target,
props
} = vnode;
if (target) {
hostRemove(targetStart);
hostRemove(targetAnchor);
}
doRemove && hostRemove(anchor);
if (shapeFlag & 16) {
const shouldRemove = doRemove || !isTeleportDisabled(props);
for (let i = 0; i < children.length; i++) {
const child = children[i];
unmount(
child,
parentComponent,
parentSuspense,
shouldRemove,
!!child.dynamicChildren
);
}
}
},
move: moveTeleport,
hydrate: hydrateTeleport
};
function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
if (moveType === 0) {
insert(vnode.targetAnchor, container, parentAnchor);
}
const { el, anchor, shapeFlag, children, props } = vnode;
const isReorder = moveType === 2;
if (isReorder) {
insert(el, container, parentAnchor);
}
if (!isReorder || isTeleportDisabled(props)) {
if (shapeFlag & 16) {
for (let i = 0; i < children.length; i++) {
move(
children[i],
container,
parentAnchor,
2
);
}
}
}
if (isReorder) {
insert(anchor, container, parentAnchor);
}
}
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
o: { nextSibling, parentNode, querySelector, insert, createText }
}, hydrateChildren) {
const target = vnode.target = resolveTarget(
vnode.props,
querySelector
);
if (target) {
const targetNode = target._lpa || target.firstChild;
if (vnode.shapeFlag & 16) {
if (isTeleportDisabled(vnode.props)) {
vnode.anchor = hydrateChildren(
nextSibling(node),
vnode,
parentNode(node),
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
vnode.targetStart = targetNode;
vnode.targetAnchor = targetNode && nextSibling(targetNode);
} else {
vnode.anchor = nextSibling(node);
let targetAnchor = targetNode;
while (targetAnchor) {
if (targetAnchor && targetAnchor.nodeType === 8) {
if (targetAnchor.data === "teleport start anchor") {
vnode.targetStart = targetAnchor;
} else if (targetAnchor.data === "teleport anchor") {
vnode.targetAnchor = targetAnchor;
target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
break;
}
}
targetAnchor = nextSibling(targetAnchor);
}
if (!vnode.targetAnchor) {
prepareAnchor(target, vnode, createText, insert);
}
hydrateChildren(
targetNode && nextSibling(targetNode),
vnode,
target,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
}
updateCssVars(vnode);
}
return vnode.anchor && nextSibling(vnode.anchor);
}
const Teleport = TeleportImpl;
function updateCssVars(vnode) {
const ctx = vnode.ctx;
if (ctx && ctx.ut) {
let node = vnode.targetStart;
while (node && node !== vnode.targetAnchor) {
if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
node = node.nextSibling;
}
ctx.ut();
}
}
function prepareAnchor(target, vnode, createText, insert) {
const targetStart = vnode.targetStart = createText("");
const targetAnchor = vnode.targetAnchor = createText("");
targetStart[TeleportEndKey] = targetAnchor;
if (target) {
insert(targetStart, target);
insert(targetAnchor, target);
}
return targetAnchor;
}
const leaveCbKey = Symbol("_leaveCb");
const enterCbKey = Symbol("_enterCb");
function useTransitionState() {
const state = {
isMounted: false,
isLeaving: false,
isUnmounting: false,
leavingVNodes: /* @__PURE__ */ new Map()
};
onMounted(() => {
state.isMounted = true;
});
onBeforeUnmount(() => {
state.isUnmounting = true;
});
return state;
}
const TransitionHookValidator = [Function, Array];
const BaseTransitionPropsValidators = {
mode: String,
appear: Boolean,
persisted: Boolean,
// enter
onBeforeEnter: TransitionHookValidator,
onEnter: TransitionHookValidator,
onAfterEnter: TransitionHookValidator,
onEnterCancelled: TransitionHookValidator,
// leave
onBeforeLeave: TransitionHookValidator,
onLeave: TransitionHookValidator,
onAfterLeave: TransitionHookValidator,
onLeaveCancelled: TransitionHookValidator,
// appear
onBeforeAppear: TransitionHookValidator,
onAppear: TransitionHookValidator,
onAfterAppear: TransitionHookValidator,
onAppearCancelled: TransitionHookValidator
};
const recursiveGetSubtree = (instance) => {
const subTree = instance.subTree;
return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
};
const BaseTransitionImpl = {
name: `BaseTransition`,
props: BaseTransitionPropsValidators,
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
return () => {
const children = slots.default && getTransitionRawChildren(slots.default(), true);
if (!children || !children.length) {
return;
}
const child = findNonCommentChild(children);
const rawProps = toRaw(props);
const { mode } = rawProps;
if (state.isLeaving) {
return emptyPlaceholder(child);
}
const innerChild = getInnerChild$1(child);
if (!innerChild) {
return emptyPlaceholder(child);
}
let enterHooks = resolveTransitionHooks(
innerChild,
rawProps,
state,
instance,
// #11061, ensure enterHooks is fresh after clone
(hooks) => enterHooks = hooks
);
if (innerChild.type !== Comment) {
setTransitionHooks(innerChild, enterHooks);
}
const oldChild = instance.subTree;
const oldInnerChild = oldChild && getInnerChild$1(oldChild);
if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {
const leavingHooks = resolveTransitionHooks(
oldInnerChild,
rawProps,
state,
instance
);
setTransitionHooks(oldInnerChild, leavingHooks);
if (mode === "out-in" && innerChild.type !== Comment) {
state.isLeaving = true;
leavingHooks.afterLeave = () => {
state.isLeaving = false;
if (!(instance.job.flags & 8)) {
instance.update();
}
delete leavingHooks.afterLeave;
};
return emptyPlaceholder(child);
} else if (mode === "in-out" && innerChild.type !== Comment) {
leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
const leavingVNodesCache = getLeavingNodesForType(
state,
oldInnerChild
);
leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
el[leaveCbKey] = () => {
earlyRemove();
el[leaveCbKey] = void 0;
delete enterHooks.delayedLeave;
};
enterHooks.delayedLeave = delayedLeave;
};
}
}
return child;
};
}
};
function findNonCommentChild(children) {
let child = children[0];
if (children.length > 1) {
for (const c of children) {
if (c.type !== Comment) {
child = c;
break;
}
}
}
return child;
}
const BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
const { leavingVNodes } = state;
let leavingVNodesCache = leavingVNodes.get(vnode.type);
if (!leavingVNodesCache) {
leavingVNodesCache = /* @__PURE__ */ Object.create(null);
leavingVNodes.set(vnode.type, leavingVNodesCache);
}
return leavingVNodesCache;
}
function resolveTransitionHooks(vnode, props, state, instance, postClone) {
const {
appear,
mode,
persisted = false,
onBeforeEnter,
onEnter: onEnter2,
onAfterEnter,
onEnterCancelled,
onBeforeLeave,
onLeave: onLeave2,
onAfterLeave: onAfterLeave2,
onLeaveCancelled,
onBeforeAppear,
onAppear,
onAfterAppear,
onAppearCancelled
} = props;
const key = String(vnode.key);
const leavingVNodesCache = getLeavingNodesForType(state, vnode);
const callHook2 = (hook, args) => {
hook && callWithAsyncErrorHandling(
hook,
instance,
9,
args
);
};
const callAsyncHook = (hook, args) => {
const done = args[1];
callHook2(hook, args);
if (isArray$6(hook)) {
if (hook.every((hook2) => hook2.length <= 1)) done();
} else if (hook.length <= 1) {
done();
}
};
const hooks = {
mode,
persisted,
beforeEnter(el) {
let hook = onBeforeEnter;
if (!state.isMounted) {
if (appear) {
hook = onBeforeAppear || onBeforeEnter;
} else {
return;
}
}
if (el[leaveCbKey]) {
el[leaveCbKey](
true
/* cancelled */
);
}
const leavingVNode = leavingVNodesCache[key];
if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
leavingVNode.el[leaveCbKey]();
}
callHook2(hook, [el]);
},
enter(el) {
let hook = onEnter2;
let afterHook = onAfterEnter;
let cancelHook = onEnterCancelled;
if (!state.isMounted) {
if (appear) {
hook = onAppear || onEnter2;
afterHook = onAfterAppear || onAfterEnter;
cancelHook = onAppearCancelled || onEnterCancelled;
} else {
return;
}
}
let called = false;
const done = el[enterCbKey] = (cancelled) => {
if (called) return;
called = true;
if (cancelled) {
callHook2(cancelHook, [el]);
} else {
callHook2(afterHook, [el]);
}
if (hooks.delayedLeave) {
hooks.delayedLeave();
}
el[enterCbKey] = void 0;
};
if (hook) {
callAsyncHook(hook, [el, done]);
} else {
done();
}
},
leave(el, remove22) {
const key2 = String(vnode.key);
if (el[enterCbKey]) {
el[enterCbKey](
true
/* cancelled */
);
}
if (state.isUnmounting) {
return remove22();
}
callHook2(onBeforeLeave, [el]);
let called = false;
const done = el[leaveCbKey] = (cancelled) => {
if (called) return;
called = true;
remove22();
if (cancelled) {
callHook2(onLeaveCancelled, [el]);
} else {
callHook2(onAfterLeave2, [el]);
}
el[leaveCbKey] = void 0;
if (leavingVNodesCache[key2] === vnode) {
delete leavingVNodesCache[key2];
}
};
leavingVNodesCache[key2] = vnode;
if (onLeave2) {
callAsyncHook(onLeave2, [el, done]);
} else {
done();
}
},
clone(vnode2) {
const hooks2 = resolveTransitionHooks(
vnode2,
props,
state,
instance,
postClone
);
if (postClone) postClone(hooks2);
return hooks2;
}
};
return hooks;
}
function emptyPlaceholder(vnode) {
if (isKeepAlive(vnode)) {
vnode = cloneVNode(vnode);
vnode.children = null;
return vnode;
}
}
function getInnerChild$1(vnode) {
if (!isKeepAlive(vnode)) {
if (isTeleport(vnode.type) && vnode.children) {
return findNonCommentChild(vnode.children);
}
return vnode;
}
const { shapeFlag, children } = vnode;
if (children) {
if (shapeFlag & 16) {
return children[0];
}
if (shapeFlag & 32 && isFunction$4(children.default)) {
return children.default();
}
}
}
function setTransitionHooks(vnode, hooks) {
if (vnode.shapeFlag & 6 && vnode.component) {
vnode.transition = hooks;
setTransitionHooks(vnode.component.subTree, hooks);
} else if (vnode.shapeFlag & 128) {
vnode.ssContent.transition = hooks.clone(vnode.ssContent);
vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
} else {
vnode.transition = hooks;
}
}
function getTransitionRawChildren(children, keepComment = false, parentKey) {
let ret = [];
let keyedFragmentCount = 0;
for (let i = 0; i < children.length; i++) {
let child = children[i];
const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
if (child.type === Fragment) {
if (child.patchFlag & 128) keyedFragmentCount++;
ret = ret.concat(
getTransitionRawChildren(child.children, keepComment, key)
);
} else if (keepComment || child.type !== Comment) {
ret.push(key != null ? cloneVNode(child, { key }) : child);
}
}
if (keyedFragmentCount > 1) {
for (let i = 0; i < ret.length; i++) {
ret[i].patchFlag = -2;
}
}
return ret;
}
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineComponent(options, extraOptions) {
return isFunction$4(options) ? (
// #8236: extend call and options.name access are considered side-effects
// by Rollup, so we have to wrap it in a pure-annotated IIFE.
/* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
) : options;
}
function markAsyncBoundary(instance) {
instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0];
}
function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
if (isArray$6(rawRef)) {
rawRef.forEach(
(r, i) => setRef(
r,
oldRawRef && (isArray$6(oldRawRef) ? oldRawRef[i] : oldRawRef),
parentSuspense,
vnode,
isUnmount
)
);
return;
}
if (isAsyncWrapper(vnode) && !isUnmount) {
return;
}
const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
const value = isUnmount ? null : refValue;
const { i: owner, r: ref3 } = rawRef;
const oldRef = oldRawRef && oldRawRef.r;
const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
const setupState = owner.setupState;
const rawSetupState = toRaw(setupState);
const canSetSetupRef = setupState === EMPTY_OBJ ? () => false : (key) => {
return hasOwn(rawSetupState, key);
};
if (oldRef != null && oldRef !== ref3) {
if (isString$1(oldRef)) {
refs[oldRef] = null;
if (canSetSetupRef(oldRef)) {
setupState[oldRef] = null;
}
} else if (isRef(oldRef)) {
oldRef.value = null;
}
}
if (isFunction$4(ref3)) {
callWithErrorHandling(ref3, owner, 12, [value, refs]);
} else {
const _isString = isString$1(ref3);
const _isRef = isRef(ref3);
if (_isString || _isRef) {
const doSet = () => {
if (rawRef.f) {
const existing = _isString ? canSetSetupRef(ref3) ? setupState[ref3] : refs[ref3] : ref3.value;
if (isUnmount) {
isArray$6(existing) && remove(existing, refValue);
} else {
if (!isArray$6(existing)) {
if (_isString) {
refs[ref3] = [refValue];
if (canSetSetupRef(ref3)) {
setupState[ref3] = refs[ref3];
}
} else {
ref3.value = [refValue];
if (rawRef.k) refs[rawRef.k] = ref3.value;
}
} else if (!existing.includes(refValue)) {
existing.push(refValue);
}
}
} else if (_isString) {
refs[ref3] = value;
if (canSetSetupRef(ref3)) {
setupState[ref3] = value;
}
} else if (_isRef) {
ref3.value = value;
if (rawRef.k) refs[rawRef.k] = value;
} else ;
};
if (value) {
doSet.id = -1;
queuePostRenderEffect(doSet, parentSuspense);
} else {
doSet();
}
}
}
}
const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
function onActivated(hook, target) {
registerKeepAliveHook(hook, "a", target);
}
function onDeactivated(hook, target) {
registerKeepAliveHook(hook, "da", target);
}
function registerKeepAliveHook(hook, type, target = currentInstance) {
const wrappedHook = hook.__wdc || (hook.__wdc = () => {
let current = target;
while (current) {
if (current.isDeactivated) {
return;
}
current = current.parent;
}
return hook();
});
injectHook(type, wrappedHook, target);
if (target) {
let current = target.parent;
while (current && current.parent) {
if (isKeepAlive(current.parent.vnode)) {
injectToKeepAliveRoot(wrappedHook, type, target, current);
}
current = current.parent;
}
}
}
function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
const injected = injectHook(
type,
hook,
keepAliveRoot,
true
/* prepend */
);
onUnmounted(() => {
remove(keepAliveRoot[type], injected);
}, target);
}
function injectHook(type, hook, target = currentInstance, prepend = false) {
if (target) {
const hooks = target[type] || (target[type] = []);
const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
pauseTracking();
const reset = setCurrentInstance(target);
const res = callWithAsyncErrorHandling(hook, target, type, args);
reset();
resetTracking();
return res;
});
if (prepend) {
hooks.unshift(wrappedHook);
} else {
hooks.push(wrappedHook);
}
return wrappedHook;
}
}
const createHook = (lifecycle) => (hook, target = currentInstance) => {
if (!isInSSRComponentSetup || lifecycle === "sp") {
injectHook(lifecycle, (...args) => hook(...args), target);
}
};
const onBeforeMount = createHook("bm");
const onMounted = createHook("m");
const onBeforeUpdate = createHook(
"bu"
);
const onUpdated = createHook("u");
const onBeforeUnmount = createHook(
"bum"
);
const onUnmounted = createHook("um");
const onServerPrefetch = createHook(
"sp"
);
const onRenderTriggered = createHook("rtg");
const onRenderTracked = createHook("rtc");
function onErrorCaptured(hook, target = currentInstance) {
injectHook("ec", hook, target);
}
const COMPONENTS = "components";
const DIRECTIVES = "directives";
function resolveComponent(name, maybeSelfReference) {
return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
}
const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
function resolveDynamicComponent(component) {
if (isString$1(component)) {
return resolveAsset(COMPONENTS, component, false) || component;
} else {
return component || NULL_DYNAMIC_COMPONENT;
}
}
function resolveDirective(name) {
return resolveAsset(DIRECTIVES, name);
}
function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
const instance = currentRenderingInstance || currentInstance;
if (instance) {
const Component = instance.type;
if (type === COMPONENTS) {
const selfName = getComponentName(
Component,
false
);
if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
return Component;
}
}
const res = (
// local registration
// check instance[type] first which is resolved for options API
resolve$1(instance[type] || Component[type], name) || // global registration
resolve$1(instance.appContext[type], name)
);
if (!res && maybeSelfReference) {
return Component;
}
return res;
}
}
function resolve$1(registry, name) {
return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
}
function renderList(source, renderItem, cache, index2) {
let ret;
const cached = cache;
const sourceIsArray = isArray$6(source);
if (sourceIsArray || isString$1(source)) {
const sourceIsReactiveArray = sourceIsArray && isReactive(source);
let needsWrap = false;
if (sourceIsReactiveArray) {
needsWrap = !isShallow(source);
source = shallowReadArray(source);
}
ret = new Array(source.length);
for (let i = 0, l = source.length; i < l; i++) {
ret[i] = renderItem(
needsWrap ? toReactive(source[i]) : source[i],
i,
void 0,
cached
);
}
} else if (typeof source === "number") {
ret = new Array(source);
for (let i = 0; i < source; i++) {
ret[i] = renderItem(i + 1, i, void 0, cached);
}
} else if (isObject$7(source)) {
if (source[Symbol.iterator]) {
ret = Array.from(
source,
(item, i) => renderItem(item, i, void 0, cached)
);
} else {
const keys2 = Object.keys(source);
ret = new Array(keys2.length);
for (let i = 0, l = keys2.length; i < l; i++) {
const key = keys2[i];
ret[i] = renderItem(source[key], key, i, cached);
}
}
} else {
ret = [];
}
return ret;
}
function renderSlot(slots, name, props = {}, fallback, noSlotted) {
if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
if (name !== "default") props.name = name;
return openBlock(), createBlock(
Fragment,
null,
[createVNode("slot", props, fallback && fallback())],
64
);
}
let slot = slots[name];
if (slot && slot._c) {
slot._d = false;
}
openBlock();
const validSlotContent = slot && ensureValidVNode(slot(props));
const rendered = createBlock(
Fragment,
{
key: (props.key || // slot content array of a dynamic conditional slot may have a branch
// key attached in the `createSlots` helper, respect that
validSlotContent && validSlotContent.key || `_${name}`) + // #7256 force differentiate fallback content from actual content
(!validSlotContent && fallback ? "_fb" : "")
},
validSlotContent || (fallback ? fallback() : []),
validSlotContent && slots._ === 1 ? 64 : -2
);
if (rendered.scopeId) {
rendered.slotScopeIds = [rendered.scopeId + "-s"];
}
if (slot && slot._c) {
slot._d = true;
}
return rendered;
}
function ensureValidVNode(vnodes) {
return vnodes.some((child) => {
if (!isVNode(child)) return true;
if (child.type === Comment) return false;
if (child.type === Fragment && !ensureValidVNode(child.children))
return false;
return true;
}) ? vnodes : null;
}
const getPublicInstance = (i) => {
if (!i) return null;
if (isStatefulComponent(i)) return getComponentPublicInstance(i);
return getPublicInstance(i.parent);
};
const publicPropertiesMap = (
// Move PURE marker to new line to workaround compiler discarding it
// due to type annotation
/* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
$: (i) => i,
$el: (i) => i.vnode.el,
$data: (i) => i.data,
$props: (i) => i.props,
$attrs: (i) => i.attrs,
$slots: (i) => i.slots,
$refs: (i) => i.refs,
$parent: (i) => getPublicInstance(i.parent),
$root: (i) => getPublicInstance(i.root),
$host: (i) => i.ce,
$emit: (i) => i.emit,
$options: (i) => resolveMergedOptions(i),
$forceUpdate: (i) => i.f || (i.f = () => {
queueJob(i.update);
}),
$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
$watch: (i) => instanceWatch.bind(i)
})
);
const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
const PublicInstanceProxyHandlers = {
get({ _: instance }, key) {
if (key === "__v_skip") {
return true;
}
const { ctx, setupState, data: data4, props, accessCache, type, appContext } = instance;
let normalizedProps;
if (key[0] !== "$") {
const n = accessCache[key];
if (n !== void 0) {
switch (n) {
case 1:
return setupState[key];
case 2:
return data4[key];
case 4:
return ctx[key];
case 3:
return props[key];
}
} else if (hasSetupBinding(setupState, key)) {
accessCache[key] = 1;
return setupState[key];
} else if (data4 !== EMPTY_OBJ && hasOwn(data4, key)) {
accessCache[key] = 2;
return data4[key];
} else if (
// only cache other properties when instance has declared (thus stable)
// props
(normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
) {
accessCache[key] = 3;
return props[key];
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4;
return ctx[key];
} else if (shouldCacheAccess) {
accessCache[key] = 0;
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
if (publicGetter) {
if (key === "$attrs") {
track(instance.attrs, "get", "");
}
return publicGetter(instance);
} else if (
// css module (injected by vue-loader)
(cssModule = type.__cssModules) && (cssModule = cssModule[key])
) {
return cssModule;
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4;
return ctx[key];
} else if (
// global properties
globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
) {
{
return globalProperties[key];
}
} else ;
},
set({ _: instance }, key, value) {
const { data: data4, setupState, ctx } = instance;
if (hasSetupBinding(setupState, key)) {
setupState[key] = value;
return true;
} else if (data4 !== EMPTY_OBJ && hasOwn(data4, key)) {
data4[key] = value;
return true;
} else if (hasOwn(instance.props, key)) {
return false;
}
if (key[0] === "$" && key.slice(1) in instance) {
return false;
} else {
{
ctx[key] = value;
}
}
return true;
},
has({
_: { data: data4, setupState, accessCache, ctx, appContext, propsOptions }
}, key) {
let normalizedProps;
return !!accessCache[key] || data4 !== EMPTY_OBJ && hasOwn(data4, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
},
defineProperty(target, key, descriptor) {
if (descriptor.get != null) {
target._.accessCache[key] = 0;
} else if (hasOwn(descriptor, "value")) {
this.set(target, key, descriptor.value, null);
}
return Reflect.defineProperty(target, key, descriptor);
}
};
function normalizePropsOrEmits(props) {
return isArray$6(props) ? props.reduce(
(normalized, p2) => (normalized[p2] = null, normalized),
{}
) : props;
}
let shouldCacheAccess = true;
function applyOptions(instance) {
const options = resolveMergedOptions(instance);
const publicThis = instance.proxy;
const ctx = instance.ctx;
shouldCacheAccess = false;
if (options.beforeCreate) {
callHook$1(options.beforeCreate, instance, "bc");
}
const {
// state
data: dataOptions,
computed: computedOptions,
methods,
watch: watchOptions,
provide: provideOptions,
inject: injectOptions,
// lifecycle
created: created2,
beforeMount: beforeMount2,
mounted: mounted6,
beforeUpdate: beforeUpdate2,
updated: updated3,
activated,
deactivated,
beforeDestroy,
beforeUnmount: beforeUnmount3,
destroyed,
unmounted: unmounted4,
render: render2,
renderTracked,
renderTriggered,
errorCaptured,
serverPrefetch,
// public API
expose,
inheritAttrs,
// assets
components,
directives,
filters
} = options;
const checkDuplicateProperties = null;
if (injectOptions) {
resolveInjections(injectOptions, ctx, checkDuplicateProperties);
}
if (methods) {
for (const key in methods) {
const methodHandler = methods[key];
if (isFunction$4(methodHandler)) {
{
ctx[key] = methodHandler.bind(publicThis);
}
}
}
}
if (dataOptions) {
const data4 = dataOptions.call(publicThis, publicThis);
if (!isObject$7(data4)) ;
else {
instance.data = reactive(data4);
}
}
shouldCacheAccess = true;
if (computedOptions) {
for (const key in computedOptions) {
const opt = computedOptions[key];
const get2 = isFunction$4(opt) ? opt.bind(publicThis, publicThis) : isFunction$4(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
const set2 = !isFunction$4(opt) && isFunction$4(opt.set) ? opt.set.bind(publicThis) : NOOP;
const c = computed({
get: get2,
set: set2
});
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => c.value,
set: (v) => c.value = v
});
}
}
if (watchOptions) {
for (const key in watchOptions) {
createWatcher(watchOptions[key], ctx, publicThis, key);
}
}
if (provideOptions) {
const provides = isFunction$4(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
Reflect.ownKeys(provides).forEach((key) => {
provide(key, provides[key]);
});
}
if (created2) {
callHook$1(created2, instance, "c");
}
function registerLifecycleHook(register, hook) {
if (isArray$6(hook)) {
hook.forEach((_hook3) => register(_hook3.bind(publicThis)));
} else if (hook) {
register(hook.bind(publicThis));
}
}
registerLifecycleHook(onBeforeMount, beforeMount2);
registerLifecycleHook(onMounted, mounted6);
registerLifecycleHook(onBeforeUpdate, beforeUpdate2);
registerLifecycleHook(onUpdated, updated3);
registerLifecycleHook(onActivated, activated);
registerLifecycleHook(onDeactivated, deactivated);
registerLifecycleHook(onErrorCaptured, errorCaptured);
registerLifecycleHook(onRenderTracked, renderTracked);
registerLifecycleHook(onRenderTriggered, renderTriggered);
registerLifecycleHook(onBeforeUnmount, beforeUnmount3);
registerLifecycleHook(onUnmounted, unmounted4);
registerLifecycleHook(onServerPrefetch, serverPrefetch);
if (isArray$6(expose)) {
if (expose.length) {
const exposed = instance.exposed || (instance.exposed = {});
expose.forEach((key) => {
Object.defineProperty(exposed, key, {
get: () => publicThis[key],
set: (val) => publicThis[key] = val
});
});
} else if (!instance.exposed) {
instance.exposed = {};
}
}
if (render2 && instance.render === NOOP) {
instance.render = render2;
}
if (inheritAttrs != null) {
instance.inheritAttrs = inheritAttrs;
}
if (components) instance.components = components;
if (directives) instance.directives = directives;
if (serverPrefetch) {
markAsyncBoundary(instance);
}
}
function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
if (isArray$6(injectOptions)) {
injectOptions = normalizeInject(injectOptions);
}
for (const key in injectOptions) {
const opt = injectOptions[key];
let injected;
if (isObject$7(opt)) {
if ("default" in opt) {
injected = inject(
opt.from || key,
opt.default,
true
);
} else {
injected = inject(opt.from || key);
}
} else {
injected = inject(opt);
}
if (isRef(injected)) {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => injected.value,
set: (v) => injected.value = v
});
} else {
ctx[key] = injected;
}
}
}
function callHook$1(hook, instance, type) {
callWithAsyncErrorHandling(
isArray$6(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy),
instance,
type
);
}
function createWatcher(raw, ctx, publicThis, key) {
let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
if (isString$1(raw)) {
const handler5 = ctx[raw];
if (isFunction$4(handler5)) {
{
watch(getter, handler5);
}
}
} else if (isFunction$4(raw)) {
{
watch(getter, raw.bind(publicThis));
}
} else if (isObject$7(raw)) {
if (isArray$6(raw)) {
raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
} else {
const handler5 = isFunction$4(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
if (isFunction$4(handler5)) {
watch(getter, handler5, raw);
}
}
} else ;
}
function resolveMergedOptions(instance) {
const base = instance.type;
const { mixins, extends: extendsOptions } = base;
const {
mixins: globalMixins,
optionsCache: cache,
config: { optionMergeStrategies }
} = instance.appContext;
const cached = cache.get(base);
let resolved;
if (cached) {
resolved = cached;
} else if (!globalMixins.length && !mixins && !extendsOptions) {
{
resolved = base;
}
} else {
resolved = {};
if (globalMixins.length) {
globalMixins.forEach(
(m) => mergeOptions$1(resolved, m, optionMergeStrategies, true)
);
}
mergeOptions$1(resolved, base, optionMergeStrategies);
}
if (isObject$7(base)) {
cache.set(base, resolved);
}
return resolved;
}
function mergeOptions$1(to, from, strats, asMixin = false) {
const { mixins, extends: extendsOptions } = from;
if (extendsOptions) {
mergeOptions$1(to, extendsOptions, strats, true);
}
if (mixins) {
mixins.forEach(
(m) => mergeOptions$1(to, m, strats, true)
);
}
for (const key in from) {
if (asMixin && key === "expose") ;
else {
const strat = internalOptionMergeStrats[key] || strats && strats[key];
to[key] = strat ? strat(to[key], from[key]) : from[key];
}
}
return to;
}
const internalOptionMergeStrats = {
data: mergeDataFn,
props: mergeEmitsOrPropsOptions,
emits: mergeEmitsOrPropsOptions,
// objects
methods: mergeObjectOptions,
computed: mergeObjectOptions,
// lifecycle
beforeCreate: mergeAsArray,
created: mergeAsArray,
beforeMount: mergeAsArray,
mounted: mergeAsArray,
beforeUpdate: mergeAsArray,
updated: mergeAsArray,
beforeDestroy: mergeAsArray,
beforeUnmount: mergeAsArray,
destroyed: mergeAsArray,
unmounted: mergeAsArray,
activated: mergeAsArray,
deactivated: mergeAsArray,
errorCaptured: mergeAsArray,
serverPrefetch: mergeAsArray,
// assets
components: mergeObjectOptions,
directives: mergeObjectOptions,
// watch
watch: mergeWatchOptions,
// provide / inject
provide: mergeDataFn,
inject: mergeInject
};
function mergeDataFn(to, from) {
if (!from) {
return to;
}
if (!to) {
return from;
}
return function mergedDataFn() {
return extend(
isFunction$4(to) ? to.call(this, this) : to,
isFunction$4(from) ? from.call(this, this) : from
);
};
}
function mergeInject(to, from) {
return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
}
function normalizeInject(raw) {
if (isArray$6(raw)) {
const res = {};
for (let i = 0; i < raw.length; i++) {
res[raw[i]] = raw[i];
}
return res;
}
return raw;
}
function mergeAsArray(to, from) {
return to ? [...new Set([].concat(to, from))] : from;
}
function mergeObjectOptions(to, from) {
return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
}
function mergeEmitsOrPropsOptions(to, from) {
if (to) {
if (isArray$6(to) && isArray$6(from)) {
return [.../* @__PURE__ */ new Set([...to, ...from])];
}
return extend(
/* @__PURE__ */ Object.create(null),
normalizePropsOrEmits(to),
normalizePropsOrEmits(from != null ? from : {})
);
} else {
return from;
}
}
function mergeWatchOptions(to, from) {
if (!to) return from;
if (!from) return to;
const merged = extend(/* @__PURE__ */ Object.create(null), to);
for (const key in from) {
merged[key] = mergeAsArray(to[key], from[key]);
}
return merged;
}
function createAppContext() {
return {
app: null,
config: {
isNativeTag: NO,
performance: false,
globalProperties: {},
optionMergeStrategies: {},
errorHandler: void 0,
warnHandler: void 0,
compilerOptions: {}
},
mixins: [],
components: {},
directives: {},
provides: /* @__PURE__ */ Object.create(null),
optionsCache: /* @__PURE__ */ new WeakMap(),
propsCache: /* @__PURE__ */ new WeakMap(),
emitsCache: /* @__PURE__ */ new WeakMap()
};
}
let uid$1 = 0;
function createAppAPI(render2, hydrate) {
return function createApp2(rootComponent, rootProps = null) {
if (!isFunction$4(rootComponent)) {
rootComponent = extend({}, rootComponent);
}
if (rootProps != null && !isObject$7(rootProps)) {
rootProps = null;
}
const context = createAppContext();
const installedPlugins = /* @__PURE__ */ new WeakSet();
const pluginCleanupFns = [];
let isMounted = false;
const app2 = context.app = {
_uid: uid$1++,
_component: rootComponent,
_props: rootProps,
_container: null,
_context: context,
_instance: null,
version,
get config() {
return context.config;
},
set config(v) {
},
use(plugin, ...options) {
if (installedPlugins.has(plugin)) ;
else if (plugin && isFunction$4(plugin.install)) {
installedPlugins.add(plugin);
plugin.install(app2, ...options);
} else if (isFunction$4(plugin)) {
installedPlugins.add(plugin);
plugin(app2, ...options);
} else ;
return app2;
},
mixin(mixin) {
{
if (!context.mixins.includes(mixin)) {
context.mixins.push(mixin);
}
}
return app2;
},
component(name, component) {
if (!component) {
return context.components[name];
}
context.components[name] = component;
return app2;
},
directive(name, directive) {
if (!directive) {
return context.directives[name];
}
context.directives[name] = directive;
return app2;
},
mount(rootContainer, isHydrate, namespace) {
if (!isMounted) {
const vnode = app2._ceVNode || createVNode(rootComponent, rootProps);
vnode.appContext = context;
if (namespace === true) {
namespace = "svg";
} else if (namespace === false) {
namespace = void 0;
}
if (isHydrate && hydrate) {
hydrate(vnode, rootContainer);
} else {
render2(vnode, rootContainer, namespace);
}
isMounted = true;
app2._container = rootContainer;
rootContainer.__vue_app__ = app2;
return getComponentPublicInstance(vnode.component);
}
},
onUnmount(cleanupFn) {
pluginCleanupFns.push(cleanupFn);
},
unmount() {
if (isMounted) {
callWithAsyncErrorHandling(
pluginCleanupFns,
app2._instance,
16
);
render2(null, app2._container);
delete app2._container.__vue_app__;
}
},
provide(key, value) {
context.provides[key] = value;
return app2;
},
runWithContext(fn) {
const lastApp = currentApp;
currentApp = app2;
try {
return fn();
} finally {
currentApp = lastApp;
}
}
};
return app2;
};
}
let currentApp = null;
function provide(key, value) {
if (!currentInstance) ;
else {
let provides = currentInstance.provides;
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
if (parentProvides === provides) {
provides = currentInstance.provides = Object.create(parentProvides);
}
provides[key] = value;
}
}
function inject(key, defaultValue, treatDefaultAsFactory = false) {
const instance = currentInstance || currentRenderingInstance;
if (instance || currentApp) {
const provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
if (provides && key in provides) {
return provides[key];
} else if (arguments.length > 1) {
return treatDefaultAsFactory && isFunction$4(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
} else ;
}
}
function hasInjectionContext() {
return !!(currentInstance || currentRenderingInstance || currentApp);
}
const internalObjectProto = {};
const createInternalObject = () => Object.create(internalObjectProto);
const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
function initProps(instance, rawProps, isStateful, isSSR = false) {
const props = {};
const attrs2 = createInternalObject();
instance.propsDefaults = /* @__PURE__ */ Object.create(null);
setFullProps(instance, rawProps, props, attrs2);
for (const key in instance.propsOptions[0]) {
if (!(key in props)) {
props[key] = void 0;
}
}
if (isStateful) {
instance.props = isSSR ? props : shallowReactive(props);
} else {
if (!instance.type.props) {
instance.props = attrs2;
} else {
instance.props = props;
}
}
instance.attrs = attrs2;
}
function updateProps(instance, rawProps, rawPrevProps, optimized) {
const {
props,
attrs: attrs2,
vnode: { patchFlag }
} = instance;
const rawCurrentProps = toRaw(props);
const [options] = instance.propsOptions;
let hasAttrsChanged = false;
if (
// always force full diff in dev
// - #1942 if hmr is enabled with sfc component
// - vite#872 non-sfc component used by sfc component
(optimized || patchFlag > 0) && !(patchFlag & 16)
) {
if (patchFlag & 8) {
const propsToUpdate = instance.vnode.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
let key = propsToUpdate[i];
if (isEmitListener(instance.emitsOptions, key)) {
continue;
}
const value = rawProps[key];
if (options) {
if (hasOwn(attrs2, key)) {
if (value !== attrs2[key]) {
attrs2[key] = value;
hasAttrsChanged = true;
}
} else {
const camelizedKey = camelize(key);
props[camelizedKey] = resolvePropValue(
options,
rawCurrentProps,
camelizedKey,
value,
instance,
false
);
}
} else {
if (value !== attrs2[key]) {
attrs2[key] = value;
hasAttrsChanged = true;
}
}
}
}
} else {
if (setFullProps(instance, rawProps, props, attrs2)) {
hasAttrsChanged = true;
}
let kebabKey;
for (const key in rawCurrentProps) {
if (!rawProps || // for camelCase
!hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
// and converted to camelCase (#955)
((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
if (options) {
if (rawPrevProps && // for camelCase
(rawPrevProps[key] !== void 0 || // for kebab-case
rawPrevProps[kebabKey] !== void 0)) {
props[key] = resolvePropValue(
options,
rawCurrentProps,
key,
void 0,
instance,
true
);
}
} else {
delete props[key];
}
}
}
if (attrs2 !== rawCurrentProps) {
for (const key in attrs2) {
if (!rawProps || !hasOwn(rawProps, key) && true) {
delete attrs2[key];
hasAttrsChanged = true;
}
}
}
}
if (hasAttrsChanged) {
trigger(instance.attrs, "set", "");
}
}
function setFullProps(instance, rawProps, props, attrs2) {
const [options, needCastKeys] = instance.propsOptions;
let hasAttrsChanged = false;
let rawCastValues;
if (rawProps) {
for (let key in rawProps) {
if (isReservedProp(key)) {
continue;
}
const value = rawProps[key];
let camelKey;
if (options && hasOwn(options, camelKey = camelize(key))) {
if (!needCastKeys || !needCastKeys.includes(camelKey)) {
props[camelKey] = value;
} else {
(rawCastValues || (rawCastValues = {}))[camelKey] = value;
}
} else if (!isEmitListener(instance.emitsOptions, key)) {
if (!(key in attrs2) || value !== attrs2[key]) {
attrs2[key] = value;
hasAttrsChanged = true;
}
}
}
}
if (needCastKeys) {
const rawCurrentProps = toRaw(props);
const castValues = rawCastValues || EMPTY_OBJ;
for (let i = 0; i < needCastKeys.length; i++) {
const key = needCastKeys[i];
props[key] = resolvePropValue(
options,
rawCurrentProps,
key,
castValues[key],
instance,
!hasOwn(castValues, key)
);
}
}
return hasAttrsChanged;
}
function resolvePropValue(options, props, key, value, instance, isAbsent) {
const opt = options[key];
if (opt != null) {
const hasDefault = hasOwn(opt, "default");
if (hasDefault && value === void 0) {
const defaultValue = opt.default;
if (opt.type !== Function && !opt.skipFactory && isFunction$4(defaultValue)) {
const { propsDefaults } = instance;
if (key in propsDefaults) {
value = propsDefaults[key];
} else {
const reset = setCurrentInstance(instance);
value = propsDefaults[key] = defaultValue.call(
null,
props
);
reset();
}
} else {
value = defaultValue;
}
if (instance.ce) {
instance.ce._setProp(key, value);
}
}
if (opt[
0
/* shouldCast */
]) {
if (isAbsent && !hasDefault) {
value = false;
} else if (opt[
1
/* shouldCastTrue */
] && (value === "" || value === hyphenate(key))) {
value = true;
}
}
}
return value;
}
const mixinPropsCache = /* @__PURE__ */ new WeakMap();
function normalizePropsOptions(comp, appContext, asMixin = false) {
const cache = asMixin ? mixinPropsCache : appContext.propsCache;
const cached = cache.get(comp);
if (cached) {
return cached;
}
const raw = comp.props;
const normalized = {};
const needCastKeys = [];
let hasExtends = false;
if (!isFunction$4(comp)) {
const extendProps = (raw2) => {
hasExtends = true;
const [props, keys2] = normalizePropsOptions(raw2, appContext, true);
extend(normalized, props);
if (keys2) needCastKeys.push(...keys2);
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendProps);
}
if (comp.extends) {
extendProps(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendProps);
}
}
if (!raw && !hasExtends) {
if (isObject$7(comp)) {
cache.set(comp, EMPTY_ARR);
}
return EMPTY_ARR;
}
if (isArray$6(raw)) {
for (let i = 0; i < raw.length; i++) {
const normalizedKey = camelize(raw[i]);
if (validatePropName(normalizedKey)) {
normalized[normalizedKey] = EMPTY_OBJ;
}
}
} else if (raw) {
for (const key in raw) {
const normalizedKey = camelize(key);
if (validatePropName(normalizedKey)) {
const opt = raw[key];
const prop = normalized[normalizedKey] = isArray$6(opt) || isFunction$4(opt) ? { type: opt } : extend({}, opt);
const propType = prop.type;
let shouldCast = false;
let shouldCastTrue = true;
if (isArray$6(propType)) {
for (let index2 = 0; index2 < propType.length; ++index2) {
const type = propType[index2];
const typeName = isFunction$4(type) && type.name;
if (typeName === "Boolean") {
shouldCast = true;
break;
} else if (typeName === "String") {
shouldCastTrue = false;
}
}
} else {
shouldCast = isFunction$4(propType) && propType.name === "Boolean";
}
prop[
0
/* shouldCast */
] = shouldCast;
prop[
1
/* shouldCastTrue */
] = shouldCastTrue;
if (shouldCast || hasOwn(prop, "default")) {
needCastKeys.push(normalizedKey);
}
}
}
}
const res = [normalized, needCastKeys];
if (isObject$7(comp)) {
cache.set(comp, res);
}
return res;
}
function validatePropName(key) {
if (key[0] !== "$" && !isReservedProp(key)) {
return true;
}
return false;
}
const isInternalKey = (key) => key[0] === "_" || key === "$stable";
const normalizeSlotValue = (value) => isArray$6(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
const normalizeSlot$1 = (key, rawSlot, ctx) => {
if (rawSlot._n) {
return rawSlot;
}
const normalized = withCtx((...args) => {
if (false) ;
return normalizeSlotValue(rawSlot(...args));
}, ctx);
normalized._c = false;
return normalized;
};
const normalizeObjectSlots = (rawSlots, slots, instance) => {
const ctx = rawSlots._ctx;
for (const key in rawSlots) {
if (isInternalKey(key)) continue;
const value = rawSlots[key];
if (isFunction$4(value)) {
slots[key] = normalizeSlot$1(key, value, ctx);
} else if (value != null) {
const normalized = normalizeSlotValue(value);
slots[key] = () => normalized;
}
}
};
const normalizeVNodeSlots = (instance, children) => {
const normalized = normalizeSlotValue(children);
instance.slots.default = () => normalized;
};
const assignSlots = (slots, children, optimized) => {
for (const key in children) {
if (optimized || key !== "_") {
slots[key] = children[key];
}
}
};
const initSlots = (instance, children, optimized) => {
const slots = instance.slots = createInternalObject();
if (instance.vnode.shapeFlag & 32) {
const type = children._;
if (type) {
assignSlots(slots, children, optimized);
if (optimized) {
def(slots, "_", type, true);
}
} else {
normalizeObjectSlots(children, slots);
}
} else if (children) {
normalizeVNodeSlots(instance, children);
}
};
const updateSlots = (instance, children, optimized) => {
const { vnode, slots } = instance;
let needDeletionCheck = true;
let deletionComparisonTarget = EMPTY_OBJ;
if (vnode.shapeFlag & 32) {
const type = children._;
if (type) {
if (optimized && type === 1) {
needDeletionCheck = false;
} else {
assignSlots(slots, children, optimized);
}
} else {
needDeletionCheck = !children.$stable;
normalizeObjectSlots(children, slots);
}
deletionComparisonTarget = children;
} else if (children) {
normalizeVNodeSlots(instance, children);
deletionComparisonTarget = { default: 1 };
}
if (needDeletionCheck) {
for (const key in slots) {
if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
delete slots[key];
}
}
}
};
const queuePostRenderEffect = queueEffectWithSuspense;
function createRenderer(options) {
return baseCreateRenderer(options);
}
function baseCreateRenderer(options, createHydrationFns) {
const target = getGlobalThis();
target.__VUE__ = true;
const {
insert: hostInsert,
remove: hostRemove,
patchProp: hostPatchProp,
createElement: hostCreateElement,
createText: hostCreateText,
createComment: hostCreateComment,
setText: hostSetText,
setElementText: hostSetElementText,
parentNode: hostParentNode,
nextSibling: hostNextSibling,
setScopeId: hostSetScopeId = NOOP,
insertStaticContent: hostInsertStaticContent
} = options;
const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
if (n1 === n2) {
return;
}
if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1);
unmount(n1, parentComponent, parentSuspense, true);
n1 = null;
}
if (n2.patchFlag === -2) {
optimized = false;
n2.dynamicChildren = null;
}
const { type, ref: ref3, shapeFlag } = n2;
switch (type) {
case Text:
processText(n1, n2, container, anchor);
break;
case Comment:
processCommentNode(n1, n2, container, anchor);
break;
case Static:
if (n1 == null) {
mountStaticNode(n2, container, anchor, namespace);
}
break;
case Fragment:
processFragment(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
break;
default:
if (shapeFlag & 1) {
processElement(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else if (shapeFlag & 6) {
processComponent(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else if (shapeFlag & 64) {
type.process(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
internals
);
} else if (shapeFlag & 128) {
type.process(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
internals
);
} else ;
}
if (ref3 != null && parentComponent) {
setRef(ref3, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
}
};
const processText = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(
n2.el = hostCreateText(n2.children),
container,
anchor
);
} else {
const el = n2.el = n1.el;
if (n2.children !== n1.children) {
hostSetText(el, n2.children);
}
}
};
const processCommentNode = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(
n2.el = hostCreateComment(n2.children || ""),
container,
anchor
);
} else {
n2.el = n1.el;
}
};
const mountStaticNode = (n2, container, anchor, namespace) => {
[n2.el, n2.anchor] = hostInsertStaticContent(
n2.children,
container,
anchor,
namespace,
n2.el,
n2.anchor
);
};
const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostInsert(el, container, nextSibling);
el = next;
}
hostInsert(anchor, container, nextSibling);
};
const removeStaticNode = ({ el, anchor }) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostRemove(el);
el = next;
}
hostRemove(anchor);
};
const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
if (n2.type === "svg") {
namespace = "svg";
} else if (n2.type === "math") {
namespace = "mathml";
}
if (n1 == null) {
mountElement(
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
patchElement(
n1,
n2,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
};
const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
let el;
let vnodeHook;
const { props, shapeFlag, transition, dirs } = vnode;
el = vnode.el = hostCreateElement(
vnode.type,
namespace,
props && props.is,
props
);
if (shapeFlag & 8) {
hostSetElementText(el, vnode.children);
} else if (shapeFlag & 16) {
mountChildren(
vnode.children,
el,
null,
parentComponent,
parentSuspense,
resolveChildrenNamespace(vnode, namespace),
slotScopeIds,
optimized
);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
if (props) {
for (const key in props) {
if (key !== "value" && !isReservedProp(key)) {
hostPatchProp(el, key, null, props[key], namespace, parentComponent);
}
}
if ("value" in props) {
hostPatchProp(el, "value", null, props.value, namespace);
}
if (vnodeHook = props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
const needCallTransitionHooks = needTransition(parentSuspense, transition);
if (needCallTransitionHooks) {
transition.beforeEnter(el);
}
hostInsert(el, container, anchor);
if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
};
const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
if (scopeId) {
hostSetScopeId(el, scopeId);
}
if (slotScopeIds) {
for (let i = 0; i < slotScopeIds.length; i++) {
hostSetScopeId(el, slotScopeIds[i]);
}
}
if (parentComponent) {
let subTree = parentComponent.subTree;
if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
const parentVNode = parentComponent.vnode;
setScopeId(
el,
parentVNode,
parentVNode.scopeId,
parentVNode.slotScopeIds,
parentComponent.parent
);
}
}
};
const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
for (let i = start; i < children.length; i++) {
const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
patch(
null,
child,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
};
const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
const el = n2.el = n1.el;
let { patchFlag, dynamicChildren, dirs } = n2;
patchFlag |= n1.patchFlag & 16;
const oldProps = n1.props || EMPTY_OBJ;
const newProps = n2.props || EMPTY_OBJ;
let vnodeHook;
parentComponent && toggleRecurse(parentComponent, false);
if (vnodeHook = newProps.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
}
if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
}
parentComponent && toggleRecurse(parentComponent, true);
if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) {
hostSetElementText(el, "");
}
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
el,
parentComponent,
parentSuspense,
resolveChildrenNamespace(n2, namespace),
slotScopeIds
);
} else if (!optimized) {
patchChildren(
n1,
n2,
el,
null,
parentComponent,
parentSuspense,
resolveChildrenNamespace(n2, namespace),
slotScopeIds,
false
);
}
if (patchFlag > 0) {
if (patchFlag & 16) {
patchProps(el, oldProps, newProps, parentComponent, namespace);
} else {
if (patchFlag & 2) {
if (oldProps.class !== newProps.class) {
hostPatchProp(el, "class", null, newProps.class, namespace);
}
}
if (patchFlag & 4) {
hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
}
if (patchFlag & 8) {
const propsToUpdate = n2.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
const key = propsToUpdate[i];
const prev = oldProps[key];
const next = newProps[key];
if (next !== prev || key === "value") {
hostPatchProp(el, key, prev, next, namespace, parentComponent);
}
}
}
}
if (patchFlag & 1) {
if (n1.children !== n2.children) {
hostSetElementText(el, n2.children);
}
}
} else if (!optimized && dynamicChildren == null) {
patchProps(el, oldProps, newProps, parentComponent, namespace);
}
if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
}, parentSuspense);
}
};
const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
for (let i = 0; i < newChildren.length; i++) {
const oldVNode = oldChildren[i];
const newVNode = newChildren[i];
const container = (
// oldVNode may be an errored async setup() component inside Suspense
// which will not have a mounted element
oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
// of the Fragment itself so it can move its children.
(oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
// which also requires the correct parent container
!isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
// In other cases, the parent container is not actually used so we
// just pass the block element here to avoid a DOM parentNode call.
fallbackContainer
)
);
patch(
oldVNode,
newVNode,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
true
);
}
};
const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
if (oldProps !== newProps) {
if (oldProps !== EMPTY_OBJ) {
for (const key in oldProps) {
if (!isReservedProp(key) && !(key in newProps)) {
hostPatchProp(
el,
key,
oldProps[key],
null,
namespace,
parentComponent
);
}
}
}
for (const key in newProps) {
if (isReservedProp(key)) continue;
const next = newProps[key];
const prev = oldProps[key];
if (next !== prev && key !== "value") {
hostPatchProp(el, key, prev, next, namespace, parentComponent);
}
}
if ("value" in newProps) {
hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
}
}
};
const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
if (n1 == null) {
hostInsert(fragmentStartAnchor, container, anchor);
hostInsert(fragmentEndAnchor, container, anchor);
mountChildren(
// #10007
// such fragment like `<></>` will be compiled into
// a fragment which doesn't have a children.
// In this case fallback to an empty array
n2.children || [],
container,
fragmentEndAnchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
// of renderSlot() with no valid children
n1.dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
container,
parentComponent,
parentSuspense,
namespace,
slotScopeIds
);
if (
// #2080 if the stable fragment has a key, it's a <template v-for> that may
// get moved around. Make sure all root level vnodes inherit el.
// #2134 or if it's a component root, it may also get moved around
// as the component is being moved.
n2.key != null || parentComponent && n2 === parentComponent.subTree
) {
traverseStaticChildren(
n1,
n2,
true
/* shallow */
);
}
} else {
patchChildren(
n1,
n2,
container,
fragmentEndAnchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
}
};
const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
n2.slotScopeIds = slotScopeIds;
if (n1 == null) {
if (n2.shapeFlag & 512) {
parentComponent.ctx.activate(
n2,
container,
anchor,
namespace,
optimized
);
} else {
mountComponent(
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
optimized
);
}
} else {
updateComponent(n1, n2, optimized);
}
};
const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
const instance = initialVNode.component = createComponentInstance(
initialVNode,
parentComponent,
parentSuspense
);
if (isKeepAlive(initialVNode)) {
instance.ctx.renderer = internals;
}
{
setupComponent(instance, false, optimized);
}
if (instance.asyncDep) {
parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
if (!initialVNode.el) {
const placeholder = instance.subTree = createVNode(Comment);
processCommentNode(null, placeholder, container, anchor);
}
} else {
setupRenderEffect(
instance,
initialVNode,
container,
anchor,
parentSuspense,
namespace,
optimized
);
}
};
const updateComponent = (n1, n2, optimized) => {
const instance = n2.component = n1.component;
if (shouldUpdateComponent(n1, n2, optimized)) {
if (instance.asyncDep && !instance.asyncResolved) {
updateComponentPreRender(instance, n2, optimized);
return;
} else {
instance.next = n2;
instance.update();
}
} else {
n2.el = n1.el;
instance.vnode = n2;
}
};
const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
const componentUpdateFn = () => {
if (!instance.isMounted) {
let vnodeHook;
const { el, props } = initialVNode;
const { bm, m, parent, root: root7, type } = instance;
const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
toggleRecurse(instance, false);
if (bm) {
invokeArrayFns(bm);
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}
toggleRecurse(instance, true);
if (el && hydrateNode) {
const hydrateSubTree = () => {
instance.subTree = renderComponentRoot(instance);
hydrateNode(
el,
instance.subTree,
instance,
parentSuspense,
null
);
};
if (isAsyncWrapperVNode && type.__asyncHydrate) {
type.__asyncHydrate(
el,
instance,
hydrateSubTree
);
} else {
hydrateSubTree();
}
} else {
if (root7.ce) {
root7.ce._injectChildStyle(type);
}
const subTree = instance.subTree = renderComponentRoot(instance);
patch(
null,
subTree,
container,
anchor,
instance,
parentSuspense,
namespace
);
initialVNode.el = subTree.el;
}
if (m) {
queuePostRenderEffect(m, parentSuspense);
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
const scopedInitialVNode = initialVNode;
queuePostRenderEffect(
() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
parentSuspense
);
}
if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
instance.a && queuePostRenderEffect(instance.a, parentSuspense);
}
instance.isMounted = true;
initialVNode = container = anchor = null;
} else {
let { next, bu, u, parent, vnode } = instance;
{
const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
if (nonHydratedAsyncRoot) {
if (next) {
next.el = vnode.el;
updateComponentPreRender(instance, next, optimized);
}
nonHydratedAsyncRoot.asyncDep.then(() => {
if (!instance.isUnmounted) {
componentUpdateFn();
}
});
return;
}
}
let originNext = next;
let vnodeHook;
toggleRecurse(instance, false);
if (next) {
next.el = vnode.el;
updateComponentPreRender(instance, next, optimized);
} else {
next = vnode;
}
if (bu) {
invokeArrayFns(bu);
}
if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parent, next, vnode);
}
toggleRecurse(instance, true);
const nextTree = renderComponentRoot(instance);
const prevTree = instance.subTree;
instance.subTree = nextTree;
patch(
prevTree,
nextTree,
// parent may have changed if it's in a teleport
hostParentNode(prevTree.el),
// anchor may have changed if it's in a fragment
getNextHostNode(prevTree),
instance,
parentSuspense,
namespace
);
next.el = nextTree.el;
if (originNext === null) {
updateHOCHostEl(instance, nextTree.el);
}
if (u) {
queuePostRenderEffect(u, parentSuspense);
}
if (vnodeHook = next.props && next.props.onVnodeUpdated) {
queuePostRenderEffect(
() => invokeVNodeHook(vnodeHook, parent, next, vnode),
parentSuspense
);
}
}
};
instance.scope.on();
const effect2 = instance.effect = new ReactiveEffect(componentUpdateFn);
instance.scope.off();
const update = instance.update = effect2.run.bind(effect2);
const job = instance.job = effect2.runIfDirty.bind(effect2);
job.i = instance;
job.id = instance.uid;
effect2.scheduler = () => queueJob(job);
toggleRecurse(instance, true);
update();
};
const updateComponentPreRender = (instance, nextVNode, optimized) => {
nextVNode.component = instance;
const prevProps = instance.vnode.props;
instance.vnode = nextVNode;
instance.next = null;
updateProps(instance, nextVNode.props, prevProps, optimized);
updateSlots(instance, nextVNode.children, optimized);
pauseTracking();
flushPreFlushCbs(instance);
resetTracking();
};
const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
const c1 = n1 && n1.children;
const prevShapeFlag = n1 ? n1.shapeFlag : 0;
const c2 = n2.children;
const { patchFlag, shapeFlag } = n2;
if (patchFlag > 0) {
if (patchFlag & 128) {
patchKeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
return;
} else if (patchFlag & 256) {
patchUnkeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
return;
}
}
if (shapeFlag & 8) {
if (prevShapeFlag & 16) {
unmountChildren(c1, parentComponent, parentSuspense);
}
if (c2 !== c1) {
hostSetElementText(container, c2);
}
} else {
if (prevShapeFlag & 16) {
if (shapeFlag & 16) {
patchKeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
unmountChildren(c1, parentComponent, parentSuspense, true);
}
} else {
if (prevShapeFlag & 8) {
hostSetElementText(container, "");
}
if (shapeFlag & 16) {
mountChildren(
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
}
}
};
const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
c1 = c1 || EMPTY_ARR;
c2 = c2 || EMPTY_ARR;
const oldLength = c1.length;
const newLength = c2.length;
const commonLength = Math.min(oldLength, newLength);
let i;
for (i = 0; i < commonLength; i++) {
const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
patch(
c1[i],
nextChild,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
if (oldLength > newLength) {
unmountChildren(
c1,
parentComponent,
parentSuspense,
true,
false,
commonLength
);
} else {
mountChildren(
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
commonLength
);
}
};
const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
let i = 0;
const l2 = c2.length;
let e1 = c1.length - 1;
let e2 = l2 - 1;
while (i <= e1 && i <= e2) {
const n1 = c1[i];
const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
if (isSameVNodeType(n1, n2)) {
patch(
n1,
n2,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
break;
}
i++;
}
while (i <= e1 && i <= e2) {
const n1 = c1[e1];
const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
if (isSameVNodeType(n1, n2)) {
patch(
n1,
n2,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
break;
}
e1--;
e2--;
}
if (i > e1) {
if (i <= e2) {
const nextPos = e2 + 1;
const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
while (i <= e2) {
patch(
null,
c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
i++;
}
}
} else if (i > e2) {
while (i <= e1) {
unmount(c1[i], parentComponent, parentSuspense, true);
i++;
}
} else {
const s1 = i;
const s2 = i;
const keyToNewIndexMap = /* @__PURE__ */ new Map();
for (i = s2; i <= e2; i++) {
const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
if (nextChild.key != null) {
keyToNewIndexMap.set(nextChild.key, i);
}
}
let j;
let patched = 0;
const toBePatched = e2 - s2 + 1;
let moved = false;
let maxNewIndexSoFar = 0;
const newIndexToOldIndexMap = new Array(toBePatched);
for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
for (i = s1; i <= e1; i++) {
const prevChild = c1[i];
if (patched >= toBePatched) {
unmount(prevChild, parentComponent, parentSuspense, true);
continue;
}
let newIndex;
if (prevChild.key != null) {
newIndex = keyToNewIndexMap.get(prevChild.key);
} else {
for (j = s2; j <= e2; j++) {
if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
newIndex = j;
break;
}
}
}
if (newIndex === void 0) {
unmount(prevChild, parentComponent, parentSuspense, true);
} else {
newIndexToOldIndexMap[newIndex - s2] = i + 1;
if (newIndex >= maxNewIndexSoFar) {
maxNewIndexSoFar = newIndex;
} else {
moved = true;
}
patch(
prevChild,
c2[newIndex],
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
patched++;
}
}
const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
j = increasingNewIndexSequence.length - 1;
for (i = toBePatched - 1; i >= 0; i--) {
const nextIndex = s2 + i;
const nextChild = c2[nextIndex];
const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
if (newIndexToOldIndexMap[i] === 0) {
patch(
null,
nextChild,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else if (moved) {
if (j < 0 || i !== increasingNewIndexSequence[j]) {
move(nextChild, container, anchor, 2);
} else {
j--;
}
}
}
}
};
const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
const { el, type, transition, children, shapeFlag } = vnode;
if (shapeFlag & 6) {
move(vnode.component.subTree, container, anchor, moveType);
return;
}
if (shapeFlag & 128) {
vnode.suspense.move(container, anchor, moveType);
return;
}
if (shapeFlag & 64) {
type.move(vnode, container, anchor, internals);
return;
}
if (type === Fragment) {
hostInsert(el, container, anchor);
for (let i = 0; i < children.length; i++) {
move(children[i], container, anchor, moveType);
}
hostInsert(vnode.anchor, container, anchor);
return;
}
if (type === Static) {
moveStaticNode(vnode, container, anchor);
return;
}
const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
if (needTransition2) {
if (moveType === 0) {
transition.beforeEnter(el);
hostInsert(el, container, anchor);
queuePostRenderEffect(() => transition.enter(el), parentSuspense);
} else {
const { leave, delayLeave, afterLeave } = transition;
const remove222 = () => hostInsert(el, container, anchor);
const performLeave = () => {
leave(el, () => {
remove222();
afterLeave && afterLeave();
});
};
if (delayLeave) {
delayLeave(el, remove222, performLeave);
} else {
performLeave();
}
}
} else {
hostInsert(el, container, anchor);
}
};
const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
const {
type,
props,
ref: ref3,
children,
dynamicChildren,
shapeFlag,
patchFlag,
dirs,
cacheIndex
} = vnode;
if (patchFlag === -2) {
optimized = false;
}
if (ref3 != null) {
setRef(ref3, null, parentSuspense, vnode, true);
}
if (cacheIndex != null) {
parentComponent.renderCache[cacheIndex] = void 0;
}
if (shapeFlag & 256) {
parentComponent.ctx.deactivate(vnode);
return;
}
const shouldInvokeDirs = shapeFlag & 1 && dirs;
const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
let vnodeHook;
if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
if (shapeFlag & 6) {
unmountComponent(vnode.component, parentSuspense, doRemove);
} else {
if (shapeFlag & 128) {
vnode.suspense.unmount(parentSuspense, doRemove);
return;
}
if (shouldInvokeDirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
}
if (shapeFlag & 64) {
vnode.type.remove(
vnode,
parentComponent,
parentSuspense,
internals,
doRemove
);
} else if (dynamicChildren && // #5154
// when v-once is used inside a block, setBlockTracking(-1) marks the
// parent block with hasOnce: true
// so that it doesn't take the fast path during unmount - otherwise
// components nested in v-once are never unmounted.
!dynamicChildren.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments
(type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
unmountChildren(
dynamicChildren,
parentComponent,
parentSuspense,
false,
true
);
} else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
unmountChildren(children, parentComponent, parentSuspense);
}
if (doRemove) {
remove22(vnode);
}
}
if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
}, parentSuspense);
}
};
const remove22 = (vnode) => {
const { type, el, anchor, transition } = vnode;
if (type === Fragment) {
{
removeFragment(el, anchor);
}
return;
}
if (type === Static) {
removeStaticNode(vnode);
return;
}
const performRemove = () => {
hostRemove(el);
if (transition && !transition.persisted && transition.afterLeave) {
transition.afterLeave();
}
};
if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
const { leave, delayLeave } = transition;
const performLeave = () => leave(el, performRemove);
if (delayLeave) {
delayLeave(vnode.el, performRemove, performLeave);
} else {
performLeave();
}
} else {
performRemove();
}
};
const removeFragment = (cur, end) => {
let next;
while (cur !== end) {
next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(end);
};
const unmountComponent = (instance, parentSuspense, doRemove) => {
const { bum, scope, job, subTree, um, m, a } = instance;
invalidateMount(m);
invalidateMount(a);
if (bum) {
invokeArrayFns(bum);
}
scope.stop();
if (job) {
job.flags |= 8;
unmount(subTree, instance, parentSuspense, doRemove);
}
if (um) {
queuePostRenderEffect(um, parentSuspense);
}
queuePostRenderEffect(() => {
instance.isUnmounted = true;
}, parentSuspense);
if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
parentSuspense.deps--;
if (parentSuspense.deps === 0) {
parentSuspense.resolve();
}
}
};
const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
for (let i = start; i < children.length; i++) {
unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
}
};
const getNextHostNode = (vnode) => {
if (vnode.shapeFlag & 6) {
return getNextHostNode(vnode.component.subTree);
}
if (vnode.shapeFlag & 128) {
return vnode.suspense.next();
}
const el = hostNextSibling(vnode.anchor || vnode.el);
const teleportEnd = el && el[TeleportEndKey];
return teleportEnd ? hostNextSibling(teleportEnd) : el;
};
let isFlushing2 = false;
const render2 = (vnode, container, namespace) => {
if (vnode == null) {
if (container._vnode) {
unmount(container._vnode, null, null, true);
}
} else {
patch(
container._vnode || null,
vnode,
container,
null,
null,
null,
namespace
);
}
container._vnode = vnode;
if (!isFlushing2) {
isFlushing2 = true;
flushPreFlushCbs();
flushPostFlushCbs();
isFlushing2 = false;
}
};
const internals = {
p: patch,
um: unmount,
m: move,
r: remove22,
mt: mountComponent,
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
n: getNextHostNode,
o: options
};
let hydrate;
let hydrateNode;
return {
render: render2,
hydrate,
createApp: createAppAPI(render2, hydrate)
};
}
function resolveChildrenNamespace({ type, props }, currentNamespace) {
return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
}
function toggleRecurse({ effect: effect2, job }, allowed) {
if (allowed) {
effect2.flags |= 32;
job.flags |= 4;
} else {
effect2.flags &= ~32;
job.flags &= ~4;
}
}
function needTransition(parentSuspense, transition) {
return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
}
function traverseStaticChildren(n1, n2, shallow = false) {
const ch1 = n1.children;
const ch2 = n2.children;
if (isArray$6(ch1) && isArray$6(ch2)) {
for (let i = 0; i < ch1.length; i++) {
const c1 = ch1[i];
let c2 = ch2[i];
if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
c2 = ch2[i] = cloneIfMounted(ch2[i]);
c2.el = c1.el;
}
if (!shallow && c2.patchFlag !== -2)
traverseStaticChildren(c1, c2);
}
if (c2.type === Text) {
c2.el = c1.el;
}
}
}
}
function getSequence(arr) {
const p2 = arr.slice();
const result = [0];
let i, j, u, v, c;
const len = arr.length;
for (i = 0; i < len; i++) {
const arrI = arr[i];
if (arrI !== 0) {
j = result[result.length - 1];
if (arr[j] < arrI) {
p2[i] = j;
result.push(i);
continue;
}
u = 0;
v = result.length - 1;
while (u < v) {
c = u + v >> 1;
if (arr[result[c]] < arrI) {
u = c + 1;
} else {
v = c;
}
}
if (arrI < arr[result[u]]) {
if (u > 0) {
p2[i] = result[u - 1];
}
result[u] = i;
}
}
}
u = result.length;
v = result[u - 1];
while (u-- > 0) {
result[u] = v;
v = p2[v];
}
return result;
}
function locateNonHydratedAsyncRoot(instance) {
const subComponent = instance.subTree.component;
if (subComponent) {
if (subComponent.asyncDep && !subComponent.asyncResolved) {
return subComponent;
} else {
return locateNonHydratedAsyncRoot(subComponent);
}
}
}
function invalidateMount(hooks) {
if (hooks) {
for (let i = 0; i < hooks.length; i++)
hooks[i].flags |= 8;
}
}
const ssrContextKey = Symbol.for("v-scx");
const useSSRContext = () => {
{
const ctx = inject(ssrContextKey);
return ctx;
}
};
function watch(source, cb, options) {
return doWatch(source, cb, options);
}
function doWatch(source, cb, options = EMPTY_OBJ) {
const { immediate, deep, flush, once } = options;
const baseWatchOptions = extend({}, options);
let ssrCleanup;
if (isInSSRComponentSetup) {
if (flush === "sync") {
const ctx = useSSRContext();
ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
} else if (!cb || immediate) {
baseWatchOptions.once = true;
} else {
const watchStopHandle = () => {
};
watchStopHandle.stop = NOOP;
watchStopHandle.resume = NOOP;
watchStopHandle.pause = NOOP;
return watchStopHandle;
}
}
const instance = currentInstance;
baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
let isPre = false;
if (flush === "post") {
baseWatchOptions.scheduler = (job) => {
queuePostRenderEffect(job, instance && instance.suspense);
};
} else if (flush !== "sync") {
isPre = true;
baseWatchOptions.scheduler = (job, isFirstRun) => {
if (isFirstRun) {
job();
} else {
queueJob(job);
}
};
}
baseWatchOptions.augmentJob = (job) => {
if (cb) {
job.flags |= 4;
}
if (isPre) {
job.flags |= 2;
if (instance) {
job.id = instance.uid;
job.i = instance;
}
}
};
const watchHandle = watch$1(source, cb, baseWatchOptions);
if (ssrCleanup) ssrCleanup.push(watchHandle);
return watchHandle;
}
function instanceWatch(source, value, options) {
const publicThis = this.proxy;
const getter = isString$1(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
let cb;
if (isFunction$4(value)) {
cb = value;
} else {
cb = value.handler;
options = value;
}
const reset = setCurrentInstance(this);
const res = doWatch(getter, cb.bind(publicThis), options);
reset();
return res;
}
function createPathGetter(ctx, path) {
const segments = path.split(".");
return () => {
let cur = ctx;
for (let i = 0; i < segments.length && cur; i++) {
cur = cur[segments[i]];
}
return cur;
};
}
const getModelModifiers = (props, modelName) => {
return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize(modelName)}Modifiers`] || props[`${hyphenate(modelName)}Modifiers`];
};
function emit(instance, event, ...rawArgs) {
if (instance.isUnmounted) return;
const props = instance.vnode.props || EMPTY_OBJ;
let args = rawArgs;
const isModelListener2 = event.startsWith("update:");
const modifiers = isModelListener2 && getModelModifiers(props, event.slice(7));
if (modifiers) {
if (modifiers.trim) {
args = rawArgs.map((a) => isString$1(a) ? a.trim() : a);
}
if (modifiers.number) {
args = rawArgs.map(looseToNumber);
}
}
let handlerName;
let handler5 = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
props[handlerName = toHandlerKey(camelize(event))];
if (!handler5 && isModelListener2) {
handler5 = props[handlerName = toHandlerKey(hyphenate(event))];
}
if (handler5) {
callWithAsyncErrorHandling(
handler5,
instance,
6,
args
);
}
const onceHandler = props[handlerName + `Once`];
if (onceHandler) {
if (!instance.emitted) {
instance.emitted = {};
} else if (instance.emitted[handlerName]) {
return;
}
instance.emitted[handlerName] = true;
callWithAsyncErrorHandling(
onceHandler,
instance,
6,
args
);
}
}
function normalizeEmitsOptions(comp, appContext, asMixin = false) {
const cache = appContext.emitsCache;
const cached = cache.get(comp);
if (cached !== void 0) {
return cached;
}
const raw = comp.emits;
let normalized = {};
let hasExtends = false;
if (!isFunction$4(comp)) {
const extendEmits = (raw2) => {
const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
if (normalizedFromExtend) {
hasExtends = true;
extend(normalized, normalizedFromExtend);
}
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendEmits);
}
if (comp.extends) {
extendEmits(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendEmits);
}
}
if (!raw && !hasExtends) {
if (isObject$7(comp)) {
cache.set(comp, null);
}
return null;
}
if (isArray$6(raw)) {
raw.forEach((key) => normalized[key] = null);
} else {
extend(normalized, raw);
}
if (isObject$7(comp)) {
cache.set(comp, normalized);
}
return normalized;
}
function isEmitListener(options, key) {
if (!options || !isOn(key)) {
return false;
}
key = key.slice(2).replace(/Once$/, "");
return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
}
function markAttrsAccessed() {
}
function renderComponentRoot(instance) {
const {
type: Component,
vnode,
proxy,
withProxy,
propsOptions: [propsOptions],
slots,
attrs: attrs2,
emit: emit2,
render: render2,
renderCache,
props,
data: data4,
setupState,
ctx,
inheritAttrs
} = instance;
const prev = setCurrentRenderingInstance(instance);
let result;
let fallthroughAttrs;
try {
if (vnode.shapeFlag & 4) {
const proxyToUse = withProxy || proxy;
const thisProxy = false ? new Proxy(proxyToUse, {
get(target, key, receiver) {
warn$1(
`Property '${String(
key
)}' was accessed via 'this'. Avoid using 'this' in templates.`
);
return Reflect.get(target, key, receiver);
}
}) : proxyToUse;
result = normalizeVNode(
render2.call(
thisProxy,
proxyToUse,
renderCache,
false ? shallowReadonly(props) : props,
setupState,
data4,
ctx
)
);
fallthroughAttrs = attrs2;
} else {
const render22 = Component;
if (false) ;
result = normalizeVNode(
render22.length > 1 ? render22(
false ? shallowReadonly(props) : props,
false ? {
get attrs() {
markAttrsAccessed();
return shallowReadonly(attrs2);
},
slots,
emit: emit2
} : { attrs: attrs2, slots, emit: emit2 }
) : render22(
false ? shallowReadonly(props) : props,
null
)
);
fallthroughAttrs = Component.props ? attrs2 : getFunctionalFallthrough(attrs2);
}
} catch (err) {
blockStack.length = 0;
handleError(err, instance, 1);
result = createVNode(Comment);
}
let root7 = result;
if (fallthroughAttrs && inheritAttrs !== false) {
const keys2 = Object.keys(fallthroughAttrs);
const { shapeFlag } = root7;
if (keys2.length) {
if (shapeFlag & (1 | 6)) {
if (propsOptions && keys2.some(isModelListener)) {
fallthroughAttrs = filterModelListeners(
fallthroughAttrs,
propsOptions
);
}
root7 = cloneVNode(root7, fallthroughAttrs, false, true);
}
}
}
if (vnode.dirs) {
root7 = cloneVNode(root7, null, false, true);
root7.dirs = root7.dirs ? root7.dirs.concat(vnode.dirs) : vnode.dirs;
}
if (vnode.transition) {
setTransitionHooks(root7, vnode.transition);
}
{
result = root7;
}
setCurrentRenderingInstance(prev);
return result;
}
const getFunctionalFallthrough = (attrs2) => {
let res;
for (const key in attrs2) {
if (key === "class" || key === "style" || isOn(key)) {
(res || (res = {}))[key] = attrs2[key];
}
}
return res;
};
const filterModelListeners = (attrs2, props) => {
const res = {};
for (const key in attrs2) {
if (!isModelListener(key) || !(key.slice(9) in props)) {
res[key] = attrs2[key];
}
}
return res;
};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
const { props: prevProps, children: prevChildren, component } = prevVNode;
const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
const emits = component.emitsOptions;
if (nextVNode.dirs || nextVNode.transition) {
return true;
}
if (optimized && patchFlag >= 0) {
if (patchFlag & 1024) {
return true;
}
if (patchFlag & 16) {
if (!prevProps) {
return !!nextProps;
}
return hasPropsChanged(prevProps, nextProps, emits);
} else if (patchFlag & 8) {
const dynamicProps = nextVNode.dynamicProps;
for (let i = 0; i < dynamicProps.length; i++) {
const key = dynamicProps[i];
if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
return true;
}
}
}
} else {
if (prevChildren || nextChildren) {
if (!nextChildren || !nextChildren.$stable) {
return true;
}
}
if (prevProps === nextProps) {
return false;
}
if (!prevProps) {
return !!nextProps;
}
if (!nextProps) {
return true;
}
return hasPropsChanged(prevProps, nextProps, emits);
}
return false;
}
function hasPropsChanged(prevProps, nextProps, emitsOptions) {
const nextKeys = Object.keys(nextProps);
if (nextKeys.length !== Object.keys(prevProps).length) {
return true;
}
for (let i = 0; i < nextKeys.length; i++) {
const key = nextKeys[i];
if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
return true;
}
}
return false;
}
function updateHOCHostEl({ vnode, parent }, el) {
while (parent) {
const root7 = parent.subTree;
if (root7.suspense && root7.suspense.activeBranch === vnode) {
root7.el = vnode.el;
}
if (root7 === vnode) {
(vnode = parent.vnode).el = el;
parent = parent.parent;
} else {
break;
}
}
}
const isSuspense = (type) => type.__isSuspense;
function queueEffectWithSuspense(fn, suspense) {
if (suspense && suspense.pendingBranch) {
if (isArray$6(fn)) {
suspense.effects.push(...fn);
} else {
suspense.effects.push(fn);
}
} else {
queuePostFlushCb(fn);
}
}
const Fragment = Symbol.for("v-fgt");
const Text = Symbol.for("v-txt");
const Comment = Symbol.for("v-cmt");
const Static = Symbol.for("v-stc");
const blockStack = [];
let currentBlock = null;
function openBlock(disableTracking = false) {
blockStack.push(currentBlock = disableTracking ? null : []);
}
function closeBlock() {
blockStack.pop();
currentBlock = blockStack[blockStack.length - 1] || null;
}
let isBlockTreeEnabled = 1;
function setBlockTracking(value) {
isBlockTreeEnabled += value;
if (value < 0 && currentBlock) {
currentBlock.hasOnce = true;
}
}
function setupBlock(vnode) {
vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
closeBlock();
if (isBlockTreeEnabled > 0 && currentBlock) {
currentBlock.push(vnode);
}
return vnode;
}
function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
return setupBlock(
createBaseVNode(
type,
props,
children,
patchFlag,
dynamicProps,
shapeFlag,
true
)
);
}
function createBlock(type, props, children, patchFlag, dynamicProps) {
return setupBlock(
createVNode(
type,
props,
children,
patchFlag,
dynamicProps,
true
)
);
}
function isVNode(value) {
return value ? value.__v_isVNode === true : false;
}
function isSameVNodeType(n1, n2) {
return n1.type === n2.type && n1.key === n2.key;
}
const normalizeKey = ({ key }) => key != null ? key : null;
const normalizeRef = ({
ref: ref3,
ref_key,
ref_for
}) => {
if (typeof ref3 === "number") {
ref3 = "" + ref3;
}
return ref3 != null ? isString$1(ref3) || isRef(ref3) || isFunction$4(ref3) ? { i: currentRenderingInstance, r: ref3, k: ref_key, f: !!ref_for } : ref3 : null;
};
function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
const vnode = {
__v_isVNode: true,
__v_skip: true,
type,
props,
key: props && normalizeKey(props),
ref: props && normalizeRef(props),
scopeId: currentScopeId,
slotScopeIds: null,
children,
component: null,
suspense: null,
ssContent: null,
ssFallback: null,
dirs: null,
transition: null,
el: null,
anchor: null,
target: null,
targetStart: null,
targetAnchor: null,
staticCount: 0,
shapeFlag,
patchFlag,
dynamicProps,
dynamicChildren: null,
appContext: null,
ctx: currentRenderingInstance
};
if (needFullChildrenNormalization) {
normalizeChildren(vnode, children);
if (shapeFlag & 128) {
type.normalize(vnode);
}
} else if (children) {
vnode.shapeFlag |= isString$1(children) ? 8 : 16;
}
if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
!isBlockNode && // has current parent block
currentBlock && // presence of a patch flag indicates this node needs patching on updates.
// component nodes also should always be patched, because even if the
// component doesn't need to update, it needs to persist the instance on to
// the next vnode so that it can be properly unmounted later.
(vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
// vnode should not be considered dynamic due to handler caching.
vnode.patchFlag !== 32) {
currentBlock.push(vnode);
}
return vnode;
}
const createVNode = _createVNode;
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
if (!type || type === NULL_DYNAMIC_COMPONENT) {
type = Comment;
}
if (isVNode(type)) {
const cloned = cloneVNode(
type,
props,
true
/* mergeRef: true */
);
if (children) {
normalizeChildren(cloned, children);
}
if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
if (cloned.shapeFlag & 6) {
currentBlock[currentBlock.indexOf(type)] = cloned;
} else {
currentBlock.push(cloned);
}
}
cloned.patchFlag = -2;
return cloned;
}
if (isClassComponent(type)) {
type = type.__vccOpts;
}
if (props) {
props = guardReactiveProps(props);
let { class: klass, style } = props;
if (klass && !isString$1(klass)) {
props.class = normalizeClass(klass);
}
if (isObject$7(style)) {
if (isProxy(style) && !isArray$6(style)) {
style = extend({}, style);
}
props.style = normalizeStyle(style);
}
}
const shapeFlag = isString$1(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject$7(type) ? 4 : isFunction$4(type) ? 2 : 0;
return createBaseVNode(
type,
props,
children,
patchFlag,
dynamicProps,
shapeFlag,
isBlockNode,
true
);
}
function guardReactiveProps(props) {
if (!props) return null;
return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
}
function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
const { props, ref: ref3, patchFlag, children, transition } = vnode;
const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
const cloned = {
__v_isVNode: true,
__v_skip: true,
type: vnode.type,
props: mergedProps,
key: mergedProps && normalizeKey(mergedProps),
ref: extraProps && extraProps.ref ? (
// #2078 in the case of <component :is="vnode" ref="extra"/>
// if the vnode itself already has a ref, cloneVNode will need to merge
// the refs so the single vnode can be set on multiple refs
mergeRef && ref3 ? isArray$6(ref3) ? ref3.concat(normalizeRef(extraProps)) : [ref3, normalizeRef(extraProps)] : normalizeRef(extraProps)
) : ref3,
scopeId: vnode.scopeId,
slotScopeIds: vnode.slotScopeIds,
children,
target: vnode.target,
targetStart: vnode.targetStart,
targetAnchor: vnode.targetAnchor,
staticCount: vnode.staticCount,
shapeFlag: vnode.shapeFlag,
// if the vnode is cloned with extra props, we can no longer assume its
// existing patch flag to be reliable and need to add the FULL_PROPS flag.
// note: preserve flag for fragments since they use the flag for children
// fast paths only.
patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
dynamicProps: vnode.dynamicProps,
dynamicChildren: vnode.dynamicChildren,
appContext: vnode.appContext,
dirs: vnode.dirs,
transition,
// These should technically only be non-null on mounted VNodes. However,
// they *should* be copied for kept-alive vnodes. So we just always copy
// them since them being non-null during a mount doesn't affect the logic as
// they will simply be overwritten.
component: vnode.component,
suspense: vnode.suspense,
ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
el: vnode.el,
anchor: vnode.anchor,
ctx: vnode.ctx,
ce: vnode.ce
};
if (transition && cloneTransition) {
setTransitionHooks(
cloned,
transition.clone(cloned)
);
}
return cloned;
}
function createTextVNode(text = " ", flag = 0) {
return createVNode(Text, null, text, flag);
}
function createCommentVNode(text = "", asBlock = false) {
return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
}
function normalizeVNode(child) {
if (child == null || typeof child === "boolean") {
return createVNode(Comment);
} else if (isArray$6(child)) {
return createVNode(
Fragment,
null,
// #3666, avoid reference pollution when reusing vnode
child.slice()
);
} else if (isVNode(child)) {
return cloneIfMounted(child);
} else {
return createVNode(Text, null, String(child));
}
}
function cloneIfMounted(child) {
return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
}
function normalizeChildren(vnode, children) {
let type = 0;
const { shapeFlag } = vnode;
if (children == null) {
children = null;
} else if (isArray$6(children)) {
type = 16;
} else if (typeof children === "object") {
if (shapeFlag & (1 | 64)) {
const slot = children.default;
if (slot) {
slot._c && (slot._d = false);
normalizeChildren(vnode, slot());
slot._c && (slot._d = true);
}
return;
} else {
type = 32;
const slotFlag = children._;
if (!slotFlag && !isInternalObject(children)) {
children._ctx = currentRenderingInstance;
} else if (slotFlag === 3 && currentRenderingInstance) {
if (currentRenderingInstance.slots._ === 1) {
children._ = 1;
} else {
children._ = 2;
vnode.patchFlag |= 1024;
}
}
}
} else if (isFunction$4(children)) {
children = { default: children, _ctx: currentRenderingInstance };
type = 32;
} else {
children = String(children);
if (shapeFlag & 64) {
type = 16;
children = [createTextVNode(children)];
} else {
type = 8;
}
}
vnode.children = children;
vnode.shapeFlag |= type;
}
function mergeProps(...args) {
const ret = {};
for (let i = 0; i < args.length; i++) {
const toMerge = args[i];
for (const key in toMerge) {
if (key === "class") {
if (ret.class !== toMerge.class) {
ret.class = normalizeClass([ret.class, toMerge.class]);
}
} else if (key === "style") {
ret.style = normalizeStyle([ret.style, toMerge.style]);
} else if (isOn(key)) {
const existing = ret[key];
const incoming = toMerge[key];
if (incoming && existing !== incoming && !(isArray$6(existing) && existing.includes(incoming))) {
ret[key] = existing ? [].concat(existing, incoming) : incoming;
}
} else if (key !== "") {
ret[key] = toMerge[key];
}
}
}
return ret;
}
function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
callWithAsyncErrorHandling(hook, instance, 7, [
vnode,
prevVNode
]);
}
const emptyAppContext = createAppContext();
let uid = 0;
function createComponentInstance(vnode, parent, suspense) {
const type = vnode.type;
const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
const instance = {
uid: uid++,
vnode,
type,
parent,
appContext,
root: null,
// to be immediately set
next: null,
subTree: null,
// will be set synchronously right after creation
effect: null,
update: null,
// will be set synchronously right after creation
job: null,
scope: new EffectScope(
true
/* detached */
),
render: null,
proxy: null,
exposed: null,
exposeProxy: null,
withProxy: null,
provides: parent ? parent.provides : Object.create(appContext.provides),
ids: parent ? parent.ids : ["", 0, 0],
accessCache: null,
renderCache: [],
// local resolved assets
components: null,
directives: null,
// resolved props and emits options
propsOptions: normalizePropsOptions(type, appContext),
emitsOptions: normalizeEmitsOptions(type, appContext),
// emit
emit: null,
// to be set immediately
emitted: null,
// props default value
propsDefaults: EMPTY_OBJ,
// inheritAttrs
inheritAttrs: type.inheritAttrs,
// state
ctx: EMPTY_OBJ,
data: EMPTY_OBJ,
props: EMPTY_OBJ,
attrs: EMPTY_OBJ,
slots: EMPTY_OBJ,
refs: EMPTY_OBJ,
setupState: EMPTY_OBJ,
setupContext: null,
// suspense related
suspense,
suspenseId: suspense ? suspense.pendingId : 0,
asyncDep: null,
asyncResolved: false,
// lifecycle hooks
// not using enums here because it results in computed properties
isMounted: false,
isUnmounted: false,
isDeactivated: false,
bc: null,
c: null,
bm: null,
m: null,
bu: null,
u: null,
um: null,
bum: null,
da: null,
a: null,
rtg: null,
rtc: null,
ec: null,
sp: null
};
{
instance.ctx = { _: instance };
}
instance.root = parent ? parent.root : instance;
instance.emit = emit.bind(null, instance);
if (vnode.ce) {
vnode.ce(instance);
}
return instance;
}
let currentInstance = null;
const getCurrentInstance = () => currentInstance || currentRenderingInstance;
let internalSetCurrentInstance;
let setInSSRSetupState;
{
const g = getGlobalThis();
const registerGlobalSetter = (key, setter) => {
let setters;
if (!(setters = g[key])) setters = g[key] = [];
setters.push(setter);
return (v) => {
if (setters.length > 1) setters.forEach((set2) => set2(v));
else setters[0](v);
};
};
internalSetCurrentInstance = registerGlobalSetter(
`__VUE_INSTANCE_SETTERS__`,
(v) => currentInstance = v
);
setInSSRSetupState = registerGlobalSetter(
`__VUE_SSR_SETTERS__`,
(v) => isInSSRComponentSetup = v
);
}
const setCurrentInstance = (instance) => {
const prev = currentInstance;
internalSetCurrentInstance(instance);
instance.scope.on();
return () => {
instance.scope.off();
internalSetCurrentInstance(prev);
};
};
const unsetCurrentInstance = () => {
currentInstance && currentInstance.scope.off();
internalSetCurrentInstance(null);
};
function isStatefulComponent(instance) {
return instance.vnode.shapeFlag & 4;
}
let isInSSRComponentSetup = false;
function setupComponent(instance, isSSR = false, optimized = false) {
isSSR && setInSSRSetupState(isSSR);
const { props, children } = instance.vnode;
const isStateful = isStatefulComponent(instance);
initProps(instance, props, isStateful, isSSR);
initSlots(instance, children, optimized);
const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
isSSR && setInSSRSetupState(false);
return setupResult;
}
function setupStatefulComponent(instance, isSSR) {
const Component = instance.type;
instance.accessCache = /* @__PURE__ */ Object.create(null);
instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
const { setup: setup2 } = Component;
if (setup2) {
const setupContext = instance.setupContext = setup2.length > 1 ? createSetupContext(instance) : null;
const reset = setCurrentInstance(instance);
pauseTracking();
const setupResult = callWithErrorHandling(
setup2,
instance,
0,
[
instance.props,
setupContext
]
);
resetTracking();
reset();
if (isPromise(setupResult)) {
if (!isAsyncWrapper(instance)) markAsyncBoundary(instance);
setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
if (isSSR) {
return setupResult.then((resolvedResult) => {
handleSetupResult(instance, resolvedResult, isSSR);
}).catch((e) => {
handleError(e, instance, 0);
});
} else {
instance.asyncDep = setupResult;
}
} else {
handleSetupResult(instance, setupResult, isSSR);
}
} else {
finishComponentSetup(instance, isSSR);
}
}
function handleSetupResult(instance, setupResult, isSSR) {
if (isFunction$4(setupResult)) {
if (instance.type.__ssrInlineRender) {
instance.ssrRender = setupResult;
} else {
instance.render = setupResult;
}
} else if (isObject$7(setupResult)) {
instance.setupState = proxyRefs(setupResult);
} else ;
finishComponentSetup(instance, isSSR);
}
let compile;
function finishComponentSetup(instance, isSSR, skipOptions) {
const Component = instance.type;
if (!instance.render) {
if (!isSSR && compile && !Component.render) {
const template = Component.template || resolveMergedOptions(instance).template;
if (template) {
const { isCustomElement, compilerOptions } = instance.appContext.config;
const { delimiters, compilerOptions: componentCompilerOptions } = Component;
const finalCompilerOptions = extend(
extend(
{
isCustomElement,
delimiters
},
compilerOptions
),
componentCompilerOptions
);
Component.render = compile(template, finalCompilerOptions);
}
}
instance.render = Component.render || NOOP;
}
{
const reset = setCurrentInstance(instance);
pauseTracking();
try {
applyOptions(instance);
} finally {
resetTracking();
reset();
}
}
}
const attrsProxyHandlers = {
get(target, key) {
track(target, "get", "");
return target[key];
}
};
function createSetupContext(instance) {
const expose = (exposed) => {
instance.exposed = exposed || {};
};
{
return {
attrs: new Proxy(instance.attrs, attrsProxyHandlers),
slots: instance.slots,
emit: instance.emit,
expose
};
}
}
function getComponentPublicInstance(instance) {
if (instance.exposed) {
return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
get(target, key) {
if (key in target) {
return target[key];
} else if (key in publicPropertiesMap) {
return publicPropertiesMap[key](instance);
}
},
has(target, key) {
return key in target || key in publicPropertiesMap;
}
}));
} else {
return instance.proxy;
}
}
const classifyRE = /(?:^|[-_])(\w)/g;
const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
function getComponentName(Component, includeInferred = true) {
return isFunction$4(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
}
function formatComponentName(instance, Component, isRoot = false) {
let name = getComponentName(Component);
if (!name && Component.__file) {
const match = Component.__file.match(/([^/\\]+)\.\w+$/);
if (match) {
name = match[1];
}
}
if (!name && instance && instance.parent) {
const inferFromRegistry = (registry) => {
for (const key in registry) {
if (registry[key] === Component) {
return key;
}
}
};
name = inferFromRegistry(
instance.components || instance.parent.type.components
) || inferFromRegistry(instance.appContext.components);
}
return name ? classify(name) : isRoot ? `App` : `Anonymous`;
}
function isClassComponent(value) {
return isFunction$4(value) && "__vccOpts" in value;
}
const computed = (getterOrOptions, debugOptions) => {
const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
return c;
};
function h(type, propsOrChildren, children) {
const l = arguments.length;
if (l === 2) {
if (isObject$7(propsOrChildren) && !isArray$6(propsOrChildren)) {
if (isVNode(propsOrChildren)) {
return createVNode(type, null, [propsOrChildren]);
}
return createVNode(type, propsOrChildren);
} else {
return createVNode(type, null, propsOrChildren);
}
} else {
if (l > 3) {
children = Array.prototype.slice.call(arguments, 2);
} else if (l === 3 && isVNode(children)) {
children = [children];
}
return createVNode(type, propsOrChildren, children);
}
}
const version = "3.5.10";
/**
* @vue/runtime-dom v3.5.10
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
let policy = void 0;
const tt = typeof window !== "undefined" && window.trustedTypes;
if (tt) {
try {
policy = /* @__PURE__ */ tt.createPolicy("vue", {
createHTML: (val) => val
});
} catch (e) {
}
}
const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
const svgNS = "http://www.w3.org/2000/svg";
const mathmlNS = "http://www.w3.org/1998/Math/MathML";
const doc = typeof document !== "undefined" ? document : null;
const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
const nodeOps = {
insert: (child, parent, anchor) => {
parent.insertBefore(child, anchor || null);
},
remove: (child) => {
const parent = child.parentNode;
if (parent) {
parent.removeChild(child);
}
},
createElement: (tag, namespace, is, props) => {
const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
if (tag === "select" && props && props.multiple != null) {
el.setAttribute("multiple", props.multiple);
}
return el;
},
createText: (text) => doc.createTextNode(text),
createComment: (text) => doc.createComment(text),
setText: (node, text) => {
node.nodeValue = text;
},
setElementText: (el, text) => {
el.textContent = text;
},
parentNode: (node) => node.parentNode,
nextSibling: (node) => node.nextSibling,
querySelector: (selector) => doc.querySelector(selector),
setScopeId(el, id) {
el.setAttribute(id, "");
},
// __UNSAFE__
// Reason: innerHTML.
// Static content here can only come from compiled templates.
// As long as the user only uses trusted templates, this is safe.
insertStaticContent(content, parent, anchor, namespace, start, end) {
const before = anchor ? anchor.previousSibling : parent.lastChild;
if (start && (start === end || start.nextSibling)) {
while (true) {
parent.insertBefore(start.cloneNode(true), anchor);
if (start === end || !(start = start.nextSibling)) break;
}
} else {
templateContainer.innerHTML = unsafeToTrustedHTML(
namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content
);
const template = templateContainer.content;
if (namespace === "svg" || namespace === "mathml") {
const wrapper = template.firstChild;
while (wrapper.firstChild) {
template.appendChild(wrapper.firstChild);
}
template.removeChild(wrapper);
}
parent.insertBefore(template, anchor);
}
return [
// first
before ? before.nextSibling : parent.firstChild,
// last
anchor ? anchor.previousSibling : parent.lastChild
];
}
};
const TRANSITION = "transition";
const ANIMATION = "animation";
const vtcKey = Symbol("_vtc");
const DOMTransitionPropsValidators = {
name: String,
type: String,
css: {
type: Boolean,
default: true
},
duration: [String, Number, Object],
enterFromClass: String,
enterActiveClass: String,
enterToClass: String,
appearFromClass: String,
appearActiveClass: String,
appearToClass: String,
leaveFromClass: String,
leaveActiveClass: String,
leaveToClass: String
};
const TransitionPropsValidators = /* @__PURE__ */ extend(
{},
BaseTransitionPropsValidators,
DOMTransitionPropsValidators
);
const decorate$1 = (t) => {
t.displayName = "Transition";
t.props = TransitionPropsValidators;
return t;
};
const Transition = /* @__PURE__ */ decorate$1(
(props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots)
);
const callHook = (hook, args = []) => {
if (isArray$6(hook)) {
hook.forEach((h2) => h2(...args));
} else if (hook) {
hook(...args);
}
};
const hasExplicitCallback = (hook) => {
return hook ? isArray$6(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
};
function resolveTransitionProps(rawProps) {
const baseProps = {};
for (const key in rawProps) {
if (!(key in DOMTransitionPropsValidators)) {
baseProps[key] = rawProps[key];
}
}
if (rawProps.css === false) {
return baseProps;
}
const {
name = "v",
type,
duration,
enterFromClass = `${name}-enter-from`,
enterActiveClass = `${name}-enter-active`,
enterToClass = `${name}-enter-to`,
appearFromClass = enterFromClass,
appearActiveClass = enterActiveClass,
appearToClass = enterToClass,
leaveFromClass = `${name}-leave-from`,
leaveActiveClass = `${name}-leave-active`,
leaveToClass = `${name}-leave-to`
} = rawProps;
const durations = normalizeDuration(duration);
const enterDuration = durations && durations[0];
const leaveDuration = durations && durations[1];
const {
onBeforeEnter,
onEnter: onEnter2,
onEnterCancelled,
onLeave: onLeave2,
onLeaveCancelled,
onBeforeAppear = onBeforeEnter,
onAppear = onEnter2,
onAppearCancelled = onEnterCancelled
} = baseProps;
const finishEnter = (el, isAppear, done) => {
removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
done && done();
};
const finishLeave = (el, done) => {
el._isLeaving = false;
removeTransitionClass(el, leaveFromClass);
removeTransitionClass(el, leaveToClass);
removeTransitionClass(el, leaveActiveClass);
done && done();
};
const makeEnterHook = (isAppear) => {
return (el, done) => {
const hook = isAppear ? onAppear : onEnter2;
const resolve2 = () => finishEnter(el, isAppear, done);
callHook(hook, [el, resolve2]);
nextFrame(() => {
removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
addTransitionClass(el, isAppear ? appearToClass : enterToClass);
if (!hasExplicitCallback(hook)) {
whenTransitionEnds(el, type, enterDuration, resolve2);
}
});
};
};
return extend(baseProps, {
onBeforeEnter(el) {
callHook(onBeforeEnter, [el]);
addTransitionClass(el, enterFromClass);
addTransitionClass(el, enterActiveClass);
},
onBeforeAppear(el) {
callHook(onBeforeAppear, [el]);
addTransitionClass(el, appearFromClass);
addTransitionClass(el, appearActiveClass);
},
onEnter: makeEnterHook(false),
onAppear: makeEnterHook(true),
onLeave(el, done) {
el._isLeaving = true;
const resolve2 = () => finishLeave(el, done);
addTransitionClass(el, leaveFromClass);
addTransitionClass(el, leaveActiveClass);
forceReflow();
nextFrame(() => {
if (!el._isLeaving) {
return;
}
removeTransitionClass(el, leaveFromClass);
addTransitionClass(el, leaveToClass);
if (!hasExplicitCallback(onLeave2)) {
whenTransitionEnds(el, type, leaveDuration, resolve2);
}
});
callHook(onLeave2, [el, resolve2]);
},
onEnterCancelled(el) {
finishEnter(el, false);
callHook(onEnterCancelled, [el]);
},
onAppearCancelled(el) {
finishEnter(el, true);
callHook(onAppearCancelled, [el]);
},
onLeaveCancelled(el) {
finishLeave(el);
callHook(onLeaveCancelled, [el]);
}
});
}
function normalizeDuration(duration) {
if (duration == null) {
return null;
} else if (isObject$7(duration)) {
return [NumberOf(duration.enter), NumberOf(duration.leave)];
} else {
const n = NumberOf(duration);
return [n, n];
}
}
function NumberOf(val) {
const res = toNumber(val);
return res;
}
function addTransitionClass(el, cls) {
cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
(el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
}
function removeTransitionClass(el, cls) {
cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
const _vtc = el[vtcKey];
if (_vtc) {
_vtc.delete(cls);
if (!_vtc.size) {
el[vtcKey] = void 0;
}
}
}
function nextFrame(cb) {
requestAnimationFrame(() => {
requestAnimationFrame(cb);
});
}
let endId = 0;
function whenTransitionEnds(el, expectedType, explicitTimeout, resolve2) {
const id = el._endId = ++endId;
const resolveIfNotStale = () => {
if (id === el._endId) {
resolve2();
}
};
if (explicitTimeout != null) {
return setTimeout(resolveIfNotStale, explicitTimeout);
}
const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
if (!type) {
return resolve2();
}
const endEvent = type + "end";
let ended = 0;
const end = () => {
el.removeEventListener(endEvent, onEnd);
resolveIfNotStale();
};
const onEnd = (e) => {
if (e.target === el && ++ended >= propCount) {
end();
}
};
setTimeout(() => {
if (ended < propCount) {
end();
}
}, timeout + 1);
el.addEventListener(endEvent, onEnd);
}
function getTransitionInfo(el, expectedType) {
const styles = window.getComputedStyle(el);
const getStyleProperties = (key) => (styles[key] || "").split(", ");
const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
const animationTimeout = getTimeout(animationDelays, animationDurations);
let type = null;
let timeout = 0;
let propCount = 0;
if (expectedType === TRANSITION) {
if (transitionTimeout > 0) {
type = TRANSITION;
timeout = transitionTimeout;
propCount = transitionDurations.length;
}
} else if (expectedType === ANIMATION) {
if (animationTimeout > 0) {
type = ANIMATION;
timeout = animationTimeout;
propCount = animationDurations.length;
}
} else {
timeout = Math.max(transitionTimeout, animationTimeout);
type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
}
const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
getStyleProperties(`${TRANSITION}Property`).toString()
);
return {
type,
timeout,
propCount,
hasTransform
};
}
function getTimeout(delays, durations) {
while (delays.length < durations.length) {
delays = delays.concat(delays);
}
return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
}
function toMs(s) {
if (s === "auto") return 0;
return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
}
function forceReflow() {
return document.body.offsetHeight;
}
function patchClass(el, value, isSVG) {
const transitionClasses = el[vtcKey];
if (transitionClasses) {
value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
}
if (value == null) {
el.removeAttribute("class");
} else if (isSVG) {
el.setAttribute("class", value);
} else {
el.className = value;
}
}
const vShowOriginalDisplay = Symbol("_vod");
const vShowHidden = Symbol("_vsh");
const vShow = {
beforeMount(el, { value }, { transition }) {
el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
if (transition && value) {
transition.beforeEnter(el);
} else {
setDisplay(el, value);
}
},
mounted(el, { value }, { transition }) {
if (transition && value) {
transition.enter(el);
}
},
updated(el, { value, oldValue }, { transition }) {
if (!value === !oldValue) return;
if (transition) {
if (value) {
transition.beforeEnter(el);
setDisplay(el, true);
transition.enter(el);
} else {
transition.leave(el, () => {
setDisplay(el, false);
});
}
} else {
setDisplay(el, value);
}
},
beforeUnmount(el, { value }) {
setDisplay(el, value);
}
};
function setDisplay(el, value) {
el.style.display = value ? el[vShowOriginalDisplay] : "none";
el[vShowHidden] = !value;
}
const CSS_VAR_TEXT = Symbol("");
const displayRE = /(^|;)\s*display\s*:/;
function patchStyle(el, prev, next) {
const style = el.style;
const isCssString = isString$1(next);
let hasControlledDisplay = false;
if (next && !isCssString) {
if (prev) {
if (!isString$1(prev)) {
for (const key in prev) {
if (next[key] == null) {
setStyle(style, key, "");
}
}
} else {
for (const prevStyle of prev.split(";")) {
const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim();
if (next[key] == null) {
setStyle(style, key, "");
}
}
}
}
for (const key in next) {
if (key === "display") {
hasControlledDisplay = true;
}
setStyle(style, key, next[key]);
}
} else {
if (isCssString) {
if (prev !== next) {
const cssVarText = style[CSS_VAR_TEXT];
if (cssVarText) {
next += ";" + cssVarText;
}
style.cssText = next;
hasControlledDisplay = displayRE.test(next);
}
} else if (prev) {
el.removeAttribute("style");
}
}
if (vShowOriginalDisplay in el) {
el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
if (el[vShowHidden]) {
style.display = "none";
}
}
}
const importantRE = /\s*!important$/;
function setStyle(style, name, val) {
if (isArray$6(val)) {
val.forEach((v) => setStyle(style, name, v));
} else {
if (val == null) val = "";
if (name.startsWith("--")) {
style.setProperty(name, val);
} else {
const prefixed = autoPrefix(style, name);
if (importantRE.test(val)) {
style.setProperty(
hyphenate(prefixed),
val.replace(importantRE, ""),
"important"
);
} else {
style[prefixed] = val;
}
}
}
}
const prefixes = ["Webkit", "Moz", "ms"];
const prefixCache = {};
function autoPrefix(style, rawName) {
const cached = prefixCache[rawName];
if (cached) {
return cached;
}
let name = camelize(rawName);
if (name !== "filter" && name in style) {
return prefixCache[rawName] = name;
}
name = capitalize(name);
for (let i = 0; i < prefixes.length; i++) {
const prefixed = prefixes[i] + name;
if (prefixed in style) {
return prefixCache[rawName] = prefixed;
}
}
return rawName;
}
const xlinkNS = "http://www.w3.org/1999/xlink";
function patchAttr(el, key, value, isSVG, instance, isBoolean = isSpecialBooleanAttr(key)) {
if (isSVG && key.startsWith("xlink:")) {
if (value == null) {
el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
} else {
el.setAttributeNS(xlinkNS, key, value);
}
} else {
if (value == null || isBoolean && !includeBooleanAttr(value)) {
el.removeAttribute(key);
} else {
el.setAttribute(
key,
isBoolean ? "" : isSymbol(value) ? String(value) : value
);
}
}
}
function patchDOMProp(el, key, value, parentComponent) {
if (key === "innerHTML" || key === "textContent") {
if (value != null) {
el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
}
return;
}
const tag = el.tagName;
if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
!tag.includes("-")) {
const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
const newValue = value == null ? (
// #11647: value should be set as empty string for null and undefined,
// but <input type="checkbox"> should be set as 'on'.
el.type === "checkbox" ? "on" : ""
) : String(value);
if (oldValue !== newValue || !("_value" in el)) {
el.value = newValue;
}
if (value == null) {
el.removeAttribute(key);
}
el._value = value;
return;
}
let needRemove = false;
if (value === "" || value == null) {
const type = typeof el[key];
if (type === "boolean") {
value = includeBooleanAttr(value);
} else if (value == null && type === "string") {
value = "";
needRemove = true;
} else if (type === "number") {
value = 0;
needRemove = true;
}
}
try {
el[key] = value;
} catch (e) {
}
needRemove && el.removeAttribute(key);
}
function addEventListener(el, event, handler5, options) {
el.addEventListener(event, handler5, options);
}
function removeEventListener(el, event, handler5, options) {
el.removeEventListener(event, handler5, options);
}
const veiKey = Symbol("_vei");
function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
const invokers = el[veiKey] || (el[veiKey] = {});
const existingInvoker = invokers[rawName];
if (nextValue && existingInvoker) {
existingInvoker.value = nextValue;
} else {
const [name, options] = parseName(rawName);
if (nextValue) {
const invoker = invokers[rawName] = createInvoker(
nextValue,
instance
);
addEventListener(el, name, invoker, options);
} else if (existingInvoker) {
removeEventListener(el, name, existingInvoker, options);
invokers[rawName] = void 0;
}
}
}
const optionsModifierRE = /(?:Once|Passive|Capture)$/;
function parseName(name) {
let options;
if (optionsModifierRE.test(name)) {
options = {};
let m;
while (m = name.match(optionsModifierRE)) {
name = name.slice(0, name.length - m[0].length);
options[m[0].toLowerCase()] = true;
}
}
const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
return [event, options];
}
let cachedNow = 0;
const p = /* @__PURE__ */ Promise.resolve();
const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
function createInvoker(initialValue, instance) {
const invoker = (e) => {
if (!e._vts) {
e._vts = Date.now();
} else if (e._vts <= invoker.attached) {
return;
}
callWithAsyncErrorHandling(
patchStopImmediatePropagation(e, invoker.value),
instance,
5,
[e]
);
};
invoker.value = initialValue;
invoker.attached = getNow();
return invoker;
}
function patchStopImmediatePropagation(e, value) {
if (isArray$6(value)) {
const originalStop = e.stopImmediatePropagation;
e.stopImmediatePropagation = () => {
originalStop.call(e);
e._stopped = true;
};
return value.map(
(fn) => (e2) => !e2._stopped && fn && fn(e2)
);
} else {
return value;
}
}
const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // lowercase letter
key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
const isSVG = namespace === "svg";
if (key === "class") {
patchClass(el, nextValue, isSVG);
} else if (key === "style") {
patchStyle(el, prevValue, nextValue);
} else if (isOn(key)) {
if (!isModelListener(key)) {
patchEvent(el, key, prevValue, nextValue, parentComponent);
}
} else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
patchDOMProp(el, key, nextValue);
if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) {
patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
}
} else if (
// #11081 force set props for possible async custom element
el._isVueCE && (/[A-Z]/.test(key) || !isString$1(nextValue))
) {
patchDOMProp(el, camelize(key), nextValue);
} else {
if (key === "true-value") {
el._trueValue = nextValue;
} else if (key === "false-value") {
el._falseValue = nextValue;
}
patchAttr(el, key, nextValue, isSVG);
}
};
function shouldSetAsProp(el, key, value, isSVG) {
if (isSVG) {
if (key === "innerHTML" || key === "textContent") {
return true;
}
if (key in el && isNativeOn(key) && isFunction$4(value)) {
return true;
}
return false;
}
if (key === "spellcheck" || key === "draggable" || key === "translate") {
return false;
}
if (key === "form") {
return false;
}
if (key === "list" && el.tagName === "INPUT") {
return false;
}
if (key === "type" && el.tagName === "TEXTAREA") {
return false;
}
if (key === "width" || key === "height") {
const tag = el.tagName;
if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") {
return false;
}
}
if (isNativeOn(key) && isString$1(value)) {
return false;
}
return key in el;
}
const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
let renderer;
function ensureRenderer() {
return renderer || (renderer = createRenderer(rendererOptions));
}
const createApp = (...args) => {
const app2 = ensureRenderer().createApp(...args);
const { mount } = app2;
app2.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (!container) return;
const component = app2._component;
if (!isFunction$4(component) && !component.render && !component.template) {
component.template = container.innerHTML;
}
if (container.nodeType === 1) {
container.textContent = "";
}
const proxy = mount(container, false, resolveRootNamespace(container));
if (container instanceof Element) {
container.removeAttribute("v-cloak");
container.setAttribute("data-v-app", "");
}
return proxy;
};
return app2;
};
function resolveRootNamespace(container) {
if (container instanceof SVGElement) {
return "svg";
}
if (typeof MathMLElement === "function" && container instanceof MathMLElement) {
return "mathml";
}
}
function normalizeContainer(container) {
if (isString$1(container)) {
const res = document.querySelector(container);
return res;
}
return container;
}
var isVue2 = false;
/*!
* pinia v2.2.2
* (c) 2024 Eduardo San Martin Morote
* @license MIT
*/
let activePinia;
const setActivePinia = (pinia2) => activePinia = pinia2;
const piniaSymbol = (
/* istanbul ignore next */
Symbol()
);
function isPlainObject(o) {
return o && typeof o === "object" && Object.prototype.toString.call(o) === "[object Object]" && typeof o.toJSON !== "function";
}
var MutationType;
(function(MutationType2) {
MutationType2["direct"] = "direct";
MutationType2["patchObject"] = "patch object";
MutationType2["patchFunction"] = "patch function";
})(MutationType || (MutationType = {}));
function createPinia() {
const scope = effectScope(true);
const state = scope.run(() => ref({}));
let _p = [];
let toBeInstalled = [];
const pinia2 = markRaw({
install(app2) {
setActivePinia(pinia2);
{
pinia2._a = app2;
app2.provide(piniaSymbol, pinia2);
app2.config.globalProperties.$pinia = pinia2;
toBeInstalled.forEach((plugin) => _p.push(plugin));
toBeInstalled = [];
}
},
use(plugin) {
if (!this._a && !isVue2) {
toBeInstalled.push(plugin);
} else {
_p.push(plugin);
}
return this;
},
_p,
// it's actually undefined here
// @ts-expect-error
_a: null,
_e: scope,
_s: /* @__PURE__ */ new Map(),
state
});
return pinia2;
}
const noop$1 = () => {
};
function addSubscription(subscriptions, callback, detached, onCleanup = noop$1) {
subscriptions.push(callback);
const removeSubscription = () => {
const idx = subscriptions.indexOf(callback);
if (idx > -1) {
subscriptions.splice(idx, 1);
onCleanup();
}
};
if (!detached && getCurrentScope()) {
onScopeDispose(removeSubscription);
}
return removeSubscription;
}
function triggerSubscriptions(subscriptions, ...args) {
subscriptions.slice().forEach((callback) => {
callback(...args);
});
}
const fallbackRunWithContext = (fn) => fn();
const ACTION_MARKER = Symbol();
const ACTION_NAME = Symbol();
function mergeReactiveObjects(target, patchToApply) {
if (target instanceof Map && patchToApply instanceof Map) {
patchToApply.forEach((value, key) => target.set(key, value));
} else if (target instanceof Set && patchToApply instanceof Set) {
patchToApply.forEach(target.add, target);
}
for (const key in patchToApply) {
if (!patchToApply.hasOwnProperty(key))
continue;
const subPatch = patchToApply[key];
const targetValue = target[key];
if (isPlainObject(targetValue) && isPlainObject(subPatch) && target.hasOwnProperty(key) && !isRef(subPatch) && !isReactive(subPatch)) {
target[key] = mergeReactiveObjects(targetValue, subPatch);
} else {
target[key] = subPatch;
}
}
return target;
}
const skipHydrateSymbol = (
/* istanbul ignore next */
Symbol()
);
function shouldHydrate(obj) {
return !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
}
const { assign: assign$1 } = Object;
function isComputed(o) {
return !!(isRef(o) && o.effect);
}
function createOptionsStore(id, options, pinia2, hot) {
const { state, actions, getters } = options;
const initialState = pinia2.state.value[id];
let store;
function setup2() {
if (!initialState && true) {
{
pinia2.state.value[id] = state ? state() : {};
}
}
const localState = toRefs(pinia2.state.value[id]);
return assign$1(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
computedGetters[name] = markRaw(computed(() => {
setActivePinia(pinia2);
const store2 = pinia2._s.get(id);
return getters[name].call(store2, store2);
}));
return computedGetters;
}, {}));
}
store = createSetupStore(id, setup2, options, pinia2, hot, true);
return store;
}
function createSetupStore($id, setup2, options = {}, pinia2, hot, isOptionsStore) {
let scope;
const optionsForPlugin = assign$1({ actions: {} }, options);
const $subscribeOptions = { deep: true };
let isListening;
let isSyncListening;
let subscriptions = [];
let actionSubscriptions = [];
let debuggerEvents;
const initialState = pinia2.state.value[$id];
if (!isOptionsStore && !initialState && true) {
{
pinia2.state.value[$id] = {};
}
}
ref({});
let activeListener;
function $patch(partialStateOrMutator) {
let subscriptionMutation;
isListening = isSyncListening = false;
if (typeof partialStateOrMutator === "function") {
partialStateOrMutator(pinia2.state.value[$id]);
subscriptionMutation = {
type: MutationType.patchFunction,
storeId: $id,
events: debuggerEvents
};
} else {
mergeReactiveObjects(pinia2.state.value[$id], partialStateOrMutator);
subscriptionMutation = {
type: MutationType.patchObject,
payload: partialStateOrMutator,
storeId: $id,
events: debuggerEvents
};
}
const myListenerId = activeListener = Symbol();
nextTick().then(() => {
if (activeListener === myListenerId) {
isListening = true;
}
});
isSyncListening = true;
triggerSubscriptions(subscriptions, subscriptionMutation, pinia2.state.value[$id]);
}
const $reset = isOptionsStore ? function $reset2() {
const { state } = options;
const newState = state ? state() : {};
this.$patch(($state) => {
assign$1($state, newState);
});
} : (
/* istanbul ignore next */
noop$1
);
function $dispose() {
scope.stop();
subscriptions = [];
actionSubscriptions = [];
pinia2._s.delete($id);
}
const action = (fn, name = "") => {
if (ACTION_MARKER in fn) {
fn[ACTION_NAME] = name;
return fn;
}
const wrappedAction = function() {
setActivePinia(pinia2);
const args = Array.from(arguments);
const afterCallbackList = [];
const onErrorCallbackList = [];
function after(callback) {
afterCallbackList.push(callback);
}
function onError(callback) {
onErrorCallbackList.push(callback);
}
triggerSubscriptions(actionSubscriptions, {
args,
name: wrappedAction[ACTION_NAME],
store,
after,
onError
});
let ret;
try {
ret = fn.apply(this && this.$id === $id ? this : store, args);
} catch (error) {
triggerSubscriptions(onErrorCallbackList, error);
throw error;
}
if (ret instanceof Promise) {
return ret.then((value) => {
triggerSubscriptions(afterCallbackList, value);
return value;
}).catch((error) => {
triggerSubscriptions(onErrorCallbackList, error);
return Promise.reject(error);
});
}
triggerSubscriptions(afterCallbackList, ret);
return ret;
};
wrappedAction[ACTION_MARKER] = true;
wrappedAction[ACTION_NAME] = name;
return wrappedAction;
};
const partialStore = {
_p: pinia2,
// _s: scope,
$id,
$onAction: addSubscription.bind(null, actionSubscriptions),
$patch,
$reset,
$subscribe(callback, options2 = {}) {
const removeSubscription = addSubscription(subscriptions, callback, options2.detached, () => stopWatcher());
const stopWatcher = scope.run(() => watch(() => pinia2.state.value[$id], (state) => {
if (options2.flush === "sync" ? isSyncListening : isListening) {
callback({
storeId: $id,
type: MutationType.direct,
events: debuggerEvents
}, state);
}
}, assign$1({}, $subscribeOptions, options2)));
return removeSubscription;
},
$dispose
};
const store = reactive(partialStore);
pinia2._s.set($id, store);
const runWithContext = pinia2._a && pinia2._a.runWithContext || fallbackRunWithContext;
const setupStore = runWithContext(() => pinia2._e.run(() => (scope = effectScope()).run(() => setup2({ action }))));
for (const key in setupStore) {
const prop = setupStore[key];
if (isRef(prop) && !isComputed(prop) || isReactive(prop)) {
if (!isOptionsStore) {
if (initialState && shouldHydrate(prop)) {
if (isRef(prop)) {
prop.value = initialState[key];
} else {
mergeReactiveObjects(prop, initialState[key]);
}
}
{
pinia2.state.value[$id][key] = prop;
}
}
} else if (typeof prop === "function") {
const actionValue = action(prop, key);
{
setupStore[key] = actionValue;
}
optionsForPlugin.actions[key] = prop;
} else ;
}
{
assign$1(store, setupStore);
assign$1(toRaw(store), setupStore);
}
Object.defineProperty(store, "$state", {
get: () => pinia2.state.value[$id],
set: (state) => {
$patch(($state) => {
assign$1($state, state);
});
}
});
pinia2._p.forEach((extender) => {
{
assign$1(store, scope.run(() => extender({
store,
app: pinia2._a,
pinia: pinia2,
options: optionsForPlugin
})));
}
});
if (initialState && isOptionsStore && options.hydrate) {
options.hydrate(store.$state, initialState);
}
isListening = true;
isSyncListening = true;
return store;
}
// @__NO_SIDE_EFFECTS__
function defineStore(idOrOptions, setup2, setupOptions) {
let id;
let options;
const isSetupStore = typeof setup2 === "function";
if (typeof idOrOptions === "string") {
id = idOrOptions;
options = isSetupStore ? setupOptions : setup2;
} else {
options = idOrOptions;
id = idOrOptions.id;
}
function useStore(pinia2, hot) {
const hasContext = hasInjectionContext();
pinia2 = // in test mode, ignore the argument provided as we can always retrieve a
// pinia instance with getActivePinia()
pinia2 || (hasContext ? inject(piniaSymbol, null) : null);
if (pinia2)
setActivePinia(pinia2);
pinia2 = activePinia;
if (!pinia2._s.has(id)) {
if (isSetupStore) {
createSetupStore(id, setup2, options, pinia2);
} else {
createOptionsStore(id, options, pinia2);
}
}
const store = pinia2._s.get(id);
return store;
}
useStore.$id = id;
return useStore;
}
var __defProp$1 = Object.defineProperty;
var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$1 = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
if (__getOwnPropSymbols$1)
for (var prop of __getOwnPropSymbols$1(b)) {
if (__propIsEnum$1.call(b, prop))
__defNormalProp$1(a, prop, b[prop]);
}
return a;
};
function isEmpty(value) {
return value === null || value === void 0 || value === "" || Array.isArray(value) && value.length === 0 || !(value instanceof Date) && typeof value === "object" && Object.keys(value).length === 0;
}
function isFunction$3(value) {
return !!(value && value.constructor && value.call && value.apply);
}
function isNotEmpty(value) {
return !isEmpty(value);
}
function isObject$6(value, empty = true) {
return value instanceof Object && value.constructor === Object && (empty || Object.keys(value).length !== 0);
}
function resolve(obj, ...params) {
return isFunction$3(obj) ? obj(...params) : obj;
}
function isString(value, empty = true) {
return typeof value === "string" && (empty || value !== "");
}
function toFlatCase(str) {
return isString(str) ? str.replace(/(-|_)/g, "").toLowerCase() : str;
}
function getKeyValue(obj, key = "", params = {}) {
const fKeys = toFlatCase(key).split(".");
const fKey = fKeys.shift();
return fKey ? isObject$6(obj) ? getKeyValue(resolve(obj[Object.keys(obj).find((k) => toFlatCase(k) === fKey) || ""], params), fKeys.join("."), params) : void 0 : resolve(obj, params);
}
function isArray$5(value, empty = true) {
return Array.isArray(value) && (empty || value.length !== 0);
}
function isNumber(value) {
return isNotEmpty(value) && !isNaN(value);
}
function matchRegex(str, regex) {
if (regex) {
const match = regex.test(str);
regex.lastIndex = 0;
return match;
}
return false;
}
function mergeKeys(...args) {
const _mergeKeys = (target = {}, source = {}) => {
const mergedObj = __spreadValues$1({}, target);
Object.keys(source).forEach((key) => {
if (isObject$6(source[key]) && key in target && isObject$6(target[key])) {
mergedObj[key] = _mergeKeys(target[key], source[key]);
} else {
mergedObj[key] = source[key];
}
});
return mergedObj;
};
return args.reduce((acc, obj, i) => i === 0 ? obj : _mergeKeys(acc, obj), {});
}
function minifyCSS(css3) {
return css3 ? css3.replace(/\/\*(?:(?!\*\/)[\s\S])*\*\/|[\r\n\t]+/g, "").replace(/ {2,}/g, " ").replace(/ ([{:}]) /g, "$1").replace(/([;,]) /g, "$1").replace(/ !/g, "!").replace(/: /g, ":") : css3;
}
function toCapitalCase(str) {
return isString(str, false) ? str[0].toUpperCase() + str.slice(1) : str;
}
function toKebabCase(str) {
return isString(str) ? str.replace(/(_)/g, "-").replace(/[A-Z]/g, (c, i) => i === 0 ? c : "-" + c.toLowerCase()).toLowerCase() : str;
}
function toTokenKey(str) {
return isString(str) ? str.replace(/[A-Z]/g, (c, i) => i === 0 ? c : "." + c.toLowerCase()).toLowerCase() : str;
}
function EventBus() {
const allHandlers = /* @__PURE__ */ new Map();
return {
on(type, handler5) {
let handlers = allHandlers.get(type);
if (!handlers) handlers = [handler5];
else handlers.push(handler5);
allHandlers.set(type, handlers);
return this;
},
off(type, handler5) {
let handlers = allHandlers.get(type);
if (handlers) {
handlers.splice(handlers.indexOf(handler5) >>> 0, 1);
}
return this;
},
emit(type, evt) {
let handlers = allHandlers.get(type);
if (handlers) {
handlers.slice().map((handler5) => {
handler5(evt);
});
}
},
clear() {
allHandlers.clear();
}
};
}
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
function definePreset(...presets) {
return mergeKeys(...presets);
}
var ThemeService = EventBus();
var service_default = ThemeService;
function merge(value1, value2) {
if (isArray$5(value1)) {
value1.push(...value2 || []);
} else if (isObject$6(value1)) {
Object.assign(value1, value2);
}
}
function toValue(value) {
return isObject$6(value) && value.hasOwnProperty("value") && value.hasOwnProperty("type") ? value.value : value;
}
function toUnit(value, variable = "") {
const excludedProperties = ["opacity", "z-index", "line-height", "font-weight", "flex", "flex-grow", "flex-shrink", "order"];
if (!excludedProperties.some((property) => variable.endsWith(property))) {
const val = `${value}`.trim();
const valArr = val.split(" ");
return valArr.map((v) => isNumber(v) ? `${v}px` : v).join(" ");
}
return value;
}
function toNormalizePrefix(prefix) {
return prefix.replaceAll(/ /g, "").replace(/[^\w]/g, "-");
}
function toNormalizeVariable(prefix = "", variable = "") {
return toNormalizePrefix(`${isString(prefix, false) && isString(variable, false) ? `${prefix}-` : prefix}${variable}`);
}
function getVariableName(prefix = "", variable = "") {
return `--${toNormalizeVariable(prefix, variable)}`;
}
function getVariableValue(value, variable = "", prefix = "", excludedKeyRegexes = [], fallback) {
if (isString(value)) {
const regex = /{([^}]*)}/g;
const val = value.trim();
if (matchRegex(val, regex)) {
const _val = val.replaceAll(regex, (v) => {
const path = v.replace(/{|}/g, "");
const keys2 = path.split(".").filter((_v) => !excludedKeyRegexes.some((_r) => matchRegex(_v, _r)));
return `var(${getVariableName(prefix, toKebabCase(keys2.join("-")))}${isNotEmpty(fallback) ? `, ${fallback}` : ""})`;
});
const calculationRegex = /(\d+\s+[\+\-\*\/]\s+\d+)/g;
const cleanedVarRegex = /var\([^)]+\)/g;
return matchRegex(_val.replace(cleanedVarRegex, "0"), calculationRegex) ? `calc(${_val})` : _val;
}
return toUnit(val, variable);
} else if (isNumber(value)) {
return toUnit(value, variable);
}
return void 0;
}
function setProperty(properties, key, value) {
if (isString(key, false)) {
properties.push(`${key}:${value};`);
}
}
function getRule(selector, properties) {
if (selector) {
return `${selector}{${properties}}`;
}
return "";
}
var $dt = (tokenPath) => {
var _a;
const theme9 = config_default.getTheme();
const variable = dtwt(theme9, tokenPath, void 0, "variable");
const name = (_a = variable == null ? void 0 : variable.match(/--[\w-]+/g)) == null ? void 0 : _a[0];
const value = dtwt(theme9, tokenPath, void 0, "value");
return {
name,
variable,
value
};
};
var dt = (...args) => {
return dtwt(config_default.getTheme(), ...args);
};
var dtwt = (theme9 = {}, tokenPath, fallback, type) => {
if (tokenPath) {
const { variable: VARIABLE, options: OPTIONS } = config_default.defaults || {};
const { prefix, transform } = (theme9 == null ? void 0 : theme9.options) || OPTIONS || {};
const regex = /{([^}]*)}/g;
const token = matchRegex(tokenPath, regex) ? tokenPath : `{${tokenPath}}`;
const isStrictTransform = type === "value" || isEmpty(type) && transform === "strict";
return isStrictTransform ? config_default.getTokenValue(tokenPath) : getVariableValue(token, void 0, prefix, [VARIABLE.excludedKeyRegex], fallback);
}
return "";
};
function toVariables_default(theme9, options = {}) {
const VARIABLE = config_default.defaults.variable;
const { prefix = VARIABLE.prefix, selector = VARIABLE.selector, excludedKeyRegex = VARIABLE.excludedKeyRegex } = options;
const _toVariables = (_theme, _prefix = "") => {
return Object.entries(_theme).reduce(
(acc, [key, value]) => {
const px = matchRegex(key, excludedKeyRegex) ? toNormalizeVariable(_prefix) : toNormalizeVariable(_prefix, toKebabCase(key));
const v = toValue(value);
if (isObject$6(v)) {
const { variables: variables2, tokens: tokens2 } = _toVariables(v, px);
merge(acc["tokens"], tokens2);
merge(acc["variables"], variables2);
} else {
acc["tokens"].push((prefix ? px.replace(`${prefix}-`, "") : px).replaceAll("-", "."));
setProperty(acc["variables"], getVariableName(px), getVariableValue(v, px, prefix, [excludedKeyRegex]));
}
return acc;
},
{ variables: [], tokens: [] }
);
};
const { variables, tokens } = _toVariables(theme9, prefix);
return {
value: variables,
tokens,
declarations: variables.join(""),
css: getRule(selector, variables.join(""))
};
}
var themeUtils_default = {
regex: {
rules: {
class: {
pattern: /^\.([a-zA-Z][\w-]*)$/,
resolve(value) {
return { type: "class", selector: value, matched: this.pattern.test(value.trim()) };
}
},
attr: {
pattern: /^\[(.*)\]$/,
resolve(value) {
return { type: "attr", selector: `:root${value}`, matched: this.pattern.test(value.trim()) };
}
},
media: {
pattern: /^@media (.*)$/,
resolve(value) {
return { type: "media", selector: `${value}{:root{[CSS]}}`, matched: this.pattern.test(value.trim()) };
}
},
system: {
pattern: /^system$/,
resolve(value) {
return { type: "system", selector: "@media (prefers-color-scheme: dark){:root{[CSS]}}", matched: this.pattern.test(value.trim()) };
}
},
custom: {
resolve(value) {
return { type: "custom", selector: value, matched: true };
}
}
},
resolve(value) {
const rules = Object.keys(this.rules).filter((k) => k !== "custom").map((r) => this.rules[r]);
return [value].flat().map((v) => {
var _a;
return (_a = rules.map((r) => r.resolve(v)).find((rr) => rr.matched)) != null ? _a : this.rules.custom.resolve(v);
});
}
},
_toVariables(theme9, options) {
return toVariables_default(theme9, { prefix: options == null ? void 0 : options.prefix });
},
getCommon({ name = "", theme: theme9 = {}, params, set: set2, defaults }) {
var _e, _f, _g, _h, _i, _j, _k;
const { preset, options } = theme9;
let primitive_css, primitive_tokens, semantic_css, semantic_tokens, global_css, global_tokens, style;
if (isNotEmpty(preset) && options.transform !== "strict") {
const { primitive, semantic, extend: extend4 } = preset;
const _a = semantic || {}, { colorScheme } = _a, sRest = __objRest(_a, ["colorScheme"]);
const _b = extend4 || {}, { colorScheme: eColorScheme } = _b, eRest = __objRest(_b, ["colorScheme"]);
const _c = colorScheme || {}, { dark } = _c, csRest = __objRest(_c, ["dark"]);
const _d = eColorScheme || {}, { dark: eDark } = _d, ecsRest = __objRest(_d, ["dark"]);
const prim_var = isNotEmpty(primitive) ? this._toVariables({ primitive }, options) : {};
const sRest_var = isNotEmpty(sRest) ? this._toVariables({ semantic: sRest }, options) : {};
const csRest_var = isNotEmpty(csRest) ? this._toVariables({ light: csRest }, options) : {};
const csDark_var = isNotEmpty(dark) ? this._toVariables({ dark }, options) : {};
const eRest_var = isNotEmpty(eRest) ? this._toVariables({ semantic: eRest }, options) : {};
const ecsRest_var = isNotEmpty(ecsRest) ? this._toVariables({ light: ecsRest }, options) : {};
const ecsDark_var = isNotEmpty(eDark) ? this._toVariables({ dark: eDark }, options) : {};
const [prim_css, prim_tokens] = [(_e = prim_var.declarations) != null ? _e : "", prim_var.tokens];
const [sRest_css, sRest_tokens] = [(_f = sRest_var.declarations) != null ? _f : "", sRest_var.tokens || []];
const [csRest_css, csRest_tokens] = [(_g = csRest_var.declarations) != null ? _g : "", csRest_var.tokens || []];
const [csDark_css, csDark_tokens] = [(_h = csDark_var.declarations) != null ? _h : "", csDark_var.tokens || []];
const [eRest_css, eRest_tokens] = [(_i = eRest_var.declarations) != null ? _i : "", eRest_var.tokens || []];
const [ecsRest_css, ecsRest_tokens] = [(_j = ecsRest_var.declarations) != null ? _j : "", ecsRest_var.tokens || []];
const [ecsDark_css, ecsDark_tokens] = [(_k = ecsDark_var.declarations) != null ? _k : "", ecsDark_var.tokens || []];
primitive_css = this.transformCSS(name, prim_css, "light", "variable", options, set2, defaults);
primitive_tokens = prim_tokens;
const semantic_light_css = this.transformCSS(name, `${sRest_css}${csRest_css}`, "light", "variable", options, set2, defaults);
const semantic_dark_css = this.transformCSS(name, `${csDark_css}`, "dark", "variable", options, set2, defaults);
semantic_css = `${semantic_light_css}${semantic_dark_css}`;
semantic_tokens = [.../* @__PURE__ */ new Set([...sRest_tokens, ...csRest_tokens, ...csDark_tokens])];
const global_light_css = this.transformCSS(name, `${eRest_css}${ecsRest_css}color-scheme:light`, "light", "variable", options, set2, defaults);
const global_dark_css = this.transformCSS(name, `${ecsDark_css}color-scheme:dark`, "dark", "variable", options, set2, defaults);
global_css = `${global_light_css}${global_dark_css}`;
global_tokens = [.../* @__PURE__ */ new Set([...eRest_tokens, ...ecsRest_tokens, ...ecsDark_tokens])];
style = resolve(preset.css, { dt });
}
return {
primitive: {
css: primitive_css,
tokens: primitive_tokens
},
semantic: {
css: semantic_css,
tokens: semantic_tokens
},
global: {
css: global_css,
tokens: global_tokens
},
style
};
},
getPreset({ name = "", preset = {}, options, params, set: set2, defaults, selector }) {
var _e, _f, _g;
let p_css, p_tokens, p_style;
if (isNotEmpty(preset) && options.transform !== "strict") {
const _name = name.replace("-directive", "");
const _a = preset, { colorScheme, extend: extend4, css: css22 } = _a, vRest = __objRest(_a, ["colorScheme", "extend", "css"]);
const _b = extend4 || {}, { colorScheme: eColorScheme } = _b, evRest = __objRest(_b, ["colorScheme"]);
const _c = colorScheme || {}, { dark } = _c, csRest = __objRest(_c, ["dark"]);
const _d = eColorScheme || {}, { dark: ecsDark } = _d, ecsRest = __objRest(_d, ["dark"]);
const vRest_var = isNotEmpty(vRest) ? this._toVariables({ [_name]: __spreadValues(__spreadValues({}, vRest), evRest) }, options) : {};
const csRest_var = isNotEmpty(csRest) ? this._toVariables({ [_name]: __spreadValues(__spreadValues({}, csRest), ecsRest) }, options) : {};
const csDark_var = isNotEmpty(dark) ? this._toVariables({ [_name]: __spreadValues(__spreadValues({}, dark), ecsDark) }, options) : {};
const [vRest_css, vRest_tokens] = [(_e = vRest_var.declarations) != null ? _e : "", vRest_var.tokens || []];
const [csRest_css, csRest_tokens] = [(_f = csRest_var.declarations) != null ? _f : "", csRest_var.tokens || []];
const [csDark_css, csDark_tokens] = [(_g = csDark_var.declarations) != null ? _g : "", csDark_var.tokens || []];
const light_variable_css = this.transformCSS(_name, `${vRest_css}${csRest_css}`, "light", "variable", options, set2, defaults, selector);
const dark_variable_css = this.transformCSS(_name, csDark_css, "dark", "variable", options, set2, defaults, selector);
p_css = `${light_variable_css}${dark_variable_css}`;
p_tokens = [.../* @__PURE__ */ new Set([...vRest_tokens, ...csRest_tokens, ...csDark_tokens])];
p_style = resolve(css22, { dt });
}
return {
css: p_css,
tokens: p_tokens,
style: p_style
};
},
getPresetC({ name = "", theme: theme9 = {}, params, set: set2, defaults }) {
var _a;
const { preset, options } = theme9;
const cPreset = (_a = preset == null ? void 0 : preset.components) == null ? void 0 : _a[name];
return this.getPreset({ name, preset: cPreset, options, params, set: set2, defaults });
},
getPresetD({ name = "", theme: theme9 = {}, params, set: set2, defaults }) {
var _a;
const dName = name.replace("-directive", "");
const { preset, options } = theme9;
const dPreset = (_a = preset == null ? void 0 : preset.directives) == null ? void 0 : _a[dName];
return this.getPreset({ name: dName, preset: dPreset, options, params, set: set2, defaults });
},
applyDarkColorScheme(options) {
return !(options.darkModeSelector === "none" || options.darkModeSelector === false);
},
getColorSchemeOption(options, defaults) {
var _a;
return this.applyDarkColorScheme(options) ? this.regex.resolve(options.darkModeSelector === true ? defaults.options.darkModeSelector : (_a = options.darkModeSelector) != null ? _a : defaults.options.darkModeSelector) : [];
},
getLayerOrder(name, options = {}, params, defaults) {
const { cssLayer } = options;
if (cssLayer) {
const order = resolve(cssLayer.order || "primeui", params);
return `@layer ${order}`;
}
return "";
},
getCommonStyleSheet({ name = "", theme: theme9 = {}, params, props = {}, set: set2, defaults }) {
const common = this.getCommon({ name, theme: theme9, params, set: set2, defaults });
const _props = Object.entries(props).reduce((acc, [k, v]) => acc.push(`${k}="${v}"`) && acc, []).join(" ");
return Object.entries(common || {}).reduce((acc, [key, value]) => {
if (value == null ? void 0 : value.css) {
const _css = minifyCSS(value == null ? void 0 : value.css);
const id = `${key}-variables`;
acc.push(`<style type="text/css" data-primevue-style-id="${id}" ${_props}>${_css}</style>`);
}
return acc;
}, []).join("");
},
getStyleSheet({ name = "", theme: theme9 = {}, params, props = {}, set: set2, defaults }) {
var _a;
const options = { name, theme: theme9, params, set: set2, defaults };
const preset_css = (_a = name.includes("-directive") ? this.getPresetD(options) : this.getPresetC(options)) == null ? void 0 : _a.css;
const _props = Object.entries(props).reduce((acc, [k, v]) => acc.push(`${k}="${v}"`) && acc, []).join(" ");
return preset_css ? `<style type="text/css" data-primevue-style-id="${name}-variables" ${_props}>${minifyCSS(preset_css)}</style>` : "";
},
createTokens(obj = {}, defaults, parentKey = "", parentPath = "", tokens = {}) {
Object.entries(obj).forEach(([key, value]) => {
const currentKey = matchRegex(key, defaults.variable.excludedKeyRegex) ? parentKey : parentKey ? `${parentKey}.${toTokenKey(key)}` : toTokenKey(key);
const currentPath = parentPath ? `${parentPath}.${key}` : key;
if (isObject$6(value)) {
this.createTokens(value, defaults, currentKey, currentPath, tokens);
} else {
tokens[currentKey] || (tokens[currentKey] = {
paths: [],
computed(colorScheme, tokenPathMap = {}) {
var _a, _b;
if (this.paths.length === 1) {
return (_a = this.paths[0]) == null ? void 0 : _a.computed(this.paths[0].scheme, tokenPathMap["binding"]);
} else if (colorScheme && colorScheme !== "none") {
return (_b = this.paths.find((p2) => p2.scheme === colorScheme)) == null ? void 0 : _b.computed(colorScheme, tokenPathMap["binding"]);
}
return this.paths.map((p2) => p2.computed(p2.scheme, tokenPathMap[p2.scheme]));
}
});
tokens[currentKey].paths.push({
path: currentPath,
value,
scheme: currentPath.includes("colorScheme.light") ? "light" : currentPath.includes("colorScheme.dark") ? "dark" : "none",
computed(colorScheme, tokenPathMap = {}) {
const regex = /{([^}]*)}/g;
let computedValue = value;
tokenPathMap["name"] = this.path;
tokenPathMap["binding"] || (tokenPathMap["binding"] = {});
if (matchRegex(value, regex)) {
const val = value.trim();
const _val = val.replaceAll(regex, (v) => {
var _a;
const path = v.replace(/{|}/g, "");
const computed2 = (_a = tokens[path]) == null ? void 0 : _a.computed(colorScheme, tokenPathMap);
return isArray$5(computed2) && computed2.length === 2 ? `light-dark(${computed2[0].value},${computed2[1].value})` : computed2 == null ? void 0 : computed2.value;
});
const calculationRegex = /(\d+\w*\s+[\+\-\*\/]\s+\d+\w*)/g;
const cleanedVarRegex = /var\([^)]+\)/g;
computedValue = matchRegex(_val.replace(cleanedVarRegex, "0"), calculationRegex) ? `calc(${_val})` : _val;
}
isEmpty(tokenPathMap["binding"]) && delete tokenPathMap["binding"];
return {
colorScheme,
path: this.path,
paths: tokenPathMap,
value: computedValue.includes("undefined") ? void 0 : computedValue
};
}
});
}
});
return tokens;
},
getTokenValue(tokens, path, defaults) {
var _a;
const normalizePath = (str) => {
const strArr = str.split(".");
return strArr.filter((s) => !matchRegex(s.toLowerCase(), defaults.variable.excludedKeyRegex)).join(".");
};
const token = normalizePath(path);
const colorScheme = path.includes("colorScheme.light") ? "light" : path.includes("colorScheme.dark") ? "dark" : void 0;
const computedValues = [(_a = tokens[token]) == null ? void 0 : _a.computed(colorScheme)].flat().filter((computed2) => computed2);
return computedValues.length === 1 ? computedValues[0].value : computedValues.reduce((acc = {}, computed2) => {
const _a2 = computed2, { colorScheme: cs } = _a2, rest = __objRest(_a2, ["colorScheme"]);
acc[cs] = rest;
return acc;
}, void 0);
},
getSelectorRule(selector1, selector2, type, css22) {
return type === "class" || type === "attr" ? getRule(isNotEmpty(selector2) ? `${selector1}${selector2},${selector1} ${selector2}` : selector1, css22) : getRule(selector1, isNotEmpty(selector2) ? getRule(selector2, css22) : css22);
},
transformCSS(name, css22, mode, type, options = {}, set2, defaults, selector) {
if (isNotEmpty(css22)) {
const { cssLayer } = options;
if (type !== "style") {
const colorSchemeOption = this.getColorSchemeOption(options, defaults);
css22 = mode === "dark" ? colorSchemeOption.reduce((acc, { type: type2, selector: _selector }) => {
if (isNotEmpty(_selector)) {
acc += _selector.includes("[CSS]") ? _selector.replace("[CSS]", css22) : this.getSelectorRule(_selector, selector, type2, css22);
}
return acc;
}, "") : getRule(selector != null ? selector : ":root", css22);
}
if (cssLayer) {
const layerOptions = {
name: "primeui",
order: "primeui"
};
isObject$6(cssLayer) && (layerOptions.name = resolve(cssLayer.name, { name, type }));
if (isNotEmpty(layerOptions.name)) {
css22 = getRule(`@layer ${layerOptions.name}`, css22);
set2 == null ? void 0 : set2.layerNames(layerOptions.name);
}
}
return css22;
}
return "";
}
};
var config_default = {
defaults: {
variable: {
prefix: "p",
selector: ":root",
excludedKeyRegex: /^(primitive|semantic|components|directives|variables|colorscheme|light|dark|common|root|states|extend|css)$/gi
},
options: {
prefix: "p",
darkModeSelector: "system",
cssLayer: false
}
},
_theme: void 0,
_layerNames: /* @__PURE__ */ new Set(),
_loadedStyleNames: /* @__PURE__ */ new Set(),
_loadingStyles: /* @__PURE__ */ new Set(),
_tokens: {},
update(newValues = {}) {
const { theme: theme9 } = newValues;
if (theme9) {
this._theme = __spreadProps(__spreadValues({}, theme9), {
options: __spreadValues(__spreadValues({}, this.defaults.options), theme9.options)
});
this._tokens = themeUtils_default.createTokens(this.preset, this.defaults);
this.clearLoadedStyleNames();
}
},
get theme() {
return this._theme;
},
get preset() {
var _a;
return ((_a = this.theme) == null ? void 0 : _a.preset) || {};
},
get options() {
var _a;
return ((_a = this.theme) == null ? void 0 : _a.options) || {};
},
get tokens() {
return this._tokens;
},
getTheme() {
return this.theme;
},
setTheme(newValue) {
this.update({ theme: newValue });
service_default.emit("theme:change", newValue);
},
getPreset() {
return this.preset;
},
setPreset(newValue) {
this._theme = __spreadProps(__spreadValues({}, this.theme), { preset: newValue });
this._tokens = themeUtils_default.createTokens(newValue, this.defaults);
this.clearLoadedStyleNames();
service_default.emit("preset:change", newValue);
service_default.emit("theme:change", this.theme);
},
getOptions() {
return this.options;
},
setOptions(newValue) {
this._theme = __spreadProps(__spreadValues({}, this.theme), { options: newValue });
this.clearLoadedStyleNames();
service_default.emit("options:change", newValue);
service_default.emit("theme:change", this.theme);
},
getLayerNames() {
return [...this._layerNames];
},
setLayerNames(layerName) {
this._layerNames.add(layerName);
},
getLoadedStyleNames() {
return this._loadedStyleNames;
},
isStyleNameLoaded(name) {
return this._loadedStyleNames.has(name);
},
setLoadedStyleName(name) {
this._loadedStyleNames.add(name);
},
deleteLoadedStyleName(name) {
this._loadedStyleNames.delete(name);
},
clearLoadedStyleNames() {
this._loadedStyleNames.clear();
},
getTokenValue(tokenPath) {
return themeUtils_default.getTokenValue(this.tokens, tokenPath, this.defaults);
},
getCommon(name = "", params) {
return themeUtils_default.getCommon({ name, theme: this.theme, params, defaults: this.defaults, set: { layerNames: this.setLayerNames.bind(this) } });
},
getComponent(name = "", params) {
const options = { name, theme: this.theme, params, defaults: this.defaults, set: { layerNames: this.setLayerNames.bind(this) } };
return themeUtils_default.getPresetC(options);
},
getDirective(name = "", params) {
const options = { name, theme: this.theme, params, defaults: this.defaults, set: { layerNames: this.setLayerNames.bind(this) } };
return themeUtils_default.getPresetD(options);
},
getCustomPreset(name = "", preset, selector, params) {
const options = { name, preset, options: this.options, selector, params, defaults: this.defaults, set: { layerNames: this.setLayerNames.bind(this) } };
return themeUtils_default.getPreset(options);
},
getLayerOrderCSS(name = "") {
return themeUtils_default.getLayerOrder(name, this.options, { names: this.getLayerNames() }, this.defaults);
},
transformCSS(name = "", css22, type = "style", mode) {
return themeUtils_default.transformCSS(name, css22, mode, type, this.options, { layerNames: this.setLayerNames.bind(this) }, this.defaults);
},
getCommonStyleSheet(name = "", params, props = {}) {
return themeUtils_default.getCommonStyleSheet({ name, theme: this.theme, params, props, defaults: this.defaults, set: { layerNames: this.setLayerNames.bind(this) } });
},
getStyleSheet(name, params, props = {}) {
return themeUtils_default.getStyleSheet({ name, theme: this.theme, params, props, defaults: this.defaults, set: { layerNames: this.setLayerNames.bind(this) } });
},
onStyleMounted(name) {
this._loadingStyles.add(name);
},
onStyleUpdated(name) {
this._loadingStyles.add(name);
},
onStyleLoaded(event, { name }) {
if (this._loadingStyles.size) {
this._loadingStyles.delete(name);
service_default.emit(`theme:${name}:load`, event);
!this._loadingStyles.size && service_default.emit("theme:load");
}
}
};
function hasClass(element, className) {
if (element) {
if (element.classList) return element.classList.contains(className);
else return new RegExp("(^| )" + className + "( |$)", "gi").test(element.className);
}
return false;
}
function addClass(element, className) {
if (element && className) {
const fn = (_className) => {
if (!hasClass(element, _className)) {
if (element.classList) element.classList.add(_className);
else element.className += " " + _className;
}
};
[className].flat().filter(Boolean).forEach((_classNames) => _classNames.split(" ").forEach(fn));
}
}
function getCSSVariableByRegex(variableRegex) {
for (const sheet of document == null ? void 0 : document.styleSheets) {
try {
for (const rule of sheet == null ? void 0 : sheet.cssRules) {
for (const property of rule == null ? void 0 : rule.style) {
if (variableRegex.test(property)) {
return { name: property, value: rule.style.getPropertyValue(property).trim() };
}
}
}
} catch (e) {
}
}
return null;
}
function removeClass(element, className) {
if (element && className) {
const fn = (_className) => {
if (element.classList) element.classList.remove(_className);
else element.className = element.className.replace(new RegExp("(^|\\b)" + _className.split(" ").join("|") + "(\\b|$)", "gi"), " ");
};
[className].flat().filter(Boolean).forEach((_classNames) => _classNames.split(" ").forEach(fn));
}
}
function getHiddenElementDimensions(element) {
let dimensions = { width: 0, height: 0 };
if (element) {
element.style.visibility = "hidden";
element.style.display = "block";
dimensions.width = element.offsetWidth;
dimensions.height = element.offsetHeight;
element.style.display = "none";
element.style.visibility = "visible";
}
return dimensions;
}
function getViewport() {
let win = window, d = document, e = d.documentElement, g = d.getElementsByTagName("body")[0], w = win.innerWidth || e.clientWidth || g.clientWidth, h2 = win.innerHeight || e.clientHeight || g.clientHeight;
return { width: w, height: h2 };
}
function getWindowScrollLeft() {
let doc2 = document.documentElement;
return (window.pageXOffset || doc2.scrollLeft) - (doc2.clientLeft || 0);
}
function getWindowScrollTop() {
let doc2 = document.documentElement;
return (window.pageYOffset || doc2.scrollTop) - (doc2.clientTop || 0);
}
function absolutePosition(element, target, gutter = true) {
var _a, _b, _c, _d;
if (element) {
const elementDimensions = element.offsetParent ? { width: element.offsetWidth, height: element.offsetHeight } : getHiddenElementDimensions(element);
const elementOuterHeight = elementDimensions.height;
const elementOuterWidth = elementDimensions.width;
const targetOuterHeight = target.offsetHeight;
const targetOuterWidth = target.offsetWidth;
const targetOffset = target.getBoundingClientRect();
const windowScrollTop = getWindowScrollTop();
const windowScrollLeft = getWindowScrollLeft();
const viewport = getViewport();
let top, left, origin = "top";
if (targetOffset.top + targetOuterHeight + elementOuterHeight > viewport.height) {
top = targetOffset.top + windowScrollTop - elementOuterHeight;
origin = "bottom";
if (top < 0) {
top = windowScrollTop;
}
} else {
top = targetOuterHeight + targetOffset.top + windowScrollTop;
}
if (targetOffset.left + elementOuterWidth > viewport.width) left = Math.max(0, targetOffset.left + windowScrollLeft + targetOuterWidth - elementOuterWidth);
else left = targetOffset.left + windowScrollLeft;
element.style.top = top + "px";
element.style.left = left + "px";
element.style.transformOrigin = origin;
gutter && (element.style.marginTop = origin === "bottom" ? `calc(${(_b = (_a = getCSSVariableByRegex(/-anchor-gutter$/)) == null ? void 0 : _a.value) != null ? _b : "2px"} * -1)` : (_d = (_c = getCSSVariableByRegex(/-anchor-gutter$/)) == null ? void 0 : _c.value) != null ? _d : "");
}
}
function addStyle(element, style) {
if (element) {
if (typeof style === "string") {
element.style.cssText = style;
} else {
Object.entries(style || {}).forEach(([key, value]) => element.style[key] = value);
}
}
}
function getOuterWidth(element, margin) {
if (element instanceof HTMLElement) {
let width = element.offsetWidth;
return width;
}
return 0;
}
function isElement(element) {
return typeof HTMLElement === "object" ? element instanceof HTMLElement : element && typeof element === "object" && element !== null && element.nodeType === 1 && typeof element.nodeName === "string";
}
function setAttributes(element, attributes = {}) {
if (isElement(element)) {
const computedStyles = (rule, value) => {
var _a, _b;
const styles = ((_a = element == null ? void 0 : element.$attrs) == null ? void 0 : _a[rule]) ? [(_b = element == null ? void 0 : element.$attrs) == null ? void 0 : _b[rule]] : [];
return [value].flat().reduce((cv, v) => {
if (v !== null && v !== void 0) {
const type = typeof v;
if (type === "string" || type === "number") {
cv.push(v);
} else if (type === "object") {
const _cv = Array.isArray(v) ? computedStyles(rule, v) : Object.entries(v).map(([_k, _v]) => rule === "style" && (!!_v || _v === 0) ? `${_k.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase()}:${_v}` : !!_v ? _k : void 0);
cv = _cv.length ? cv.concat(_cv.filter((c) => !!c)) : cv;
}
}
return cv;
}, styles);
};
Object.entries(attributes).forEach(([key, value]) => {
if (value !== void 0 && value !== null) {
const matchedEvent = key.match(/^on(.+)/);
if (matchedEvent) {
element.addEventListener(matchedEvent[1].toLowerCase(), value);
} else if (key === "p-bind") {
setAttributes(element, value);
} else {
value = key === "class" ? [...new Set(computedStyles("class", value))].join(" ").trim() : key === "style" ? computedStyles("style", value).join(";").trim() : value;
(element.$attrs = element.$attrs || {}) && (element.$attrs[key] = value);
element.setAttribute(key, value);
}
}
});
}
}
function createElement(type, attributes = {}, ...children) {
{
const element = document.createElement(type);
setAttributes(element, attributes);
element.append(...children);
return element;
}
}
function find(element, selector) {
return isElement(element) ? Array.from(element.querySelectorAll(selector)) : [];
}
function findSingle(element, selector) {
return isElement(element) ? element.matches(selector) ? element : element.querySelector(selector) : null;
}
function focus(element, options) {
element && document.activeElement !== element && element.focus(options);
}
function getAttribute(element, name) {
if (isElement(element)) {
const value = element.getAttribute(name);
if (!isNaN(value)) {
return +value;
}
if (value === "true" || value === "false") {
return value === "true";
}
return value;
}
return void 0;
}
function getFocusableElements(element, selector = "") {
let focusableElements = find(
element,
`button:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
[href][clientHeight][clientWidth]:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
input:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
select:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
textarea:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
[tabIndex]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
[contenteditable]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector}`
);
let visibleFocusableElements = [];
for (let focusableElement of focusableElements) {
if (getComputedStyle(focusableElement).display != "none" && getComputedStyle(focusableElement).visibility != "hidden") visibleFocusableElements.push(focusableElement);
}
return visibleFocusableElements;
}
function getFirstFocusableElement(element, selector) {
const focusableElements = getFocusableElements(element, selector);
return focusableElements.length > 0 ? focusableElements[0] : null;
}
function getHeight(element) {
if (element) {
let height = element.offsetHeight;
let style = getComputedStyle(element);
height -= parseFloat(style.paddingTop) + parseFloat(style.paddingBottom) + parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);
return height;
}
return 0;
}
function getParentNode(element) {
if (element) {
let parent = element.parentNode;
if (parent && parent instanceof ShadowRoot && parent.host) {
parent = parent.host;
}
return parent;
}
return null;
}
function getLastFocusableElement(element, selector) {
const focusableElements = getFocusableElements(element, selector);
return focusableElements.length > 0 ? focusableElements[focusableElements.length - 1] : null;
}
function getOffset(element) {
if (element) {
let rect = element.getBoundingClientRect();
return {
top: rect.top + (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
left: rect.left + (window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0)
};
}
return {
top: "auto",
left: "auto"
};
}
function getOuterHeight(element, margin) {
if (element) {
let height = element.offsetHeight;
return height;
}
return 0;
}
function getParents(element, parents = []) {
const parent = getParentNode(element);
return parent === null ? parents : getParents(parent, parents.concat([parent]));
}
function getScrollableParents(element) {
let scrollableParents = [];
if (element) {
let parents = getParents(element);
const overflowRegex = /(auto|scroll)/;
const overflowCheck = (node) => {
try {
let styleDeclaration = window["getComputedStyle"](node, null);
return overflowRegex.test(styleDeclaration.getPropertyValue("overflow")) || overflowRegex.test(styleDeclaration.getPropertyValue("overflowX")) || overflowRegex.test(styleDeclaration.getPropertyValue("overflowY"));
} catch (err) {
return false;
}
};
for (let parent of parents) {
let scrollSelectors = parent.nodeType === 1 && parent.dataset["scrollselectors"];
if (scrollSelectors) {
let selectors = scrollSelectors.split(",");
for (let selector of selectors) {
let el = findSingle(parent, selector);
if (el && overflowCheck(el)) {
scrollableParents.push(el);
}
}
}
if (parent.nodeType !== 9 && overflowCheck(parent)) {
scrollableParents.push(parent);
}
}
}
return scrollableParents;
}
function isExist(element) {
return !!(element !== null && typeof element !== "undefined" && element.nodeName && getParentNode(element));
}
function getWidth(element) {
if (element) {
let width = element.offsetWidth;
let style = getComputedStyle(element);
width -= parseFloat(style.paddingLeft) + parseFloat(style.paddingRight) + parseFloat(style.borderLeftWidth) + parseFloat(style.borderRightWidth);
return width;
}
return 0;
}
function isClient() {
return !!(typeof window !== "undefined" && window.document && window.document.createElement);
}
function isFocusableElement(element, selector = "") {
return isElement(element) ? element.matches(`button:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
[href][clientHeight][clientWidth]:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
input:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
select:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
textarea:not([tabindex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
[tabIndex]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector},
[contenteditable]:not([tabIndex = "-1"]):not([disabled]):not([style*="display:none"]):not([hidden])${selector}`) : false;
}
function isTouchDevice() {
return "ontouchstart" in window || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
}
function setAttribute(element, attribute = "", value) {
if (isElement(element) && value !== null && value !== void 0) {
element.setAttribute(attribute, value);
}
}
var lastIds = {};
function uuid(prefix = "pui_id_") {
if (!lastIds.hasOwnProperty(prefix)) {
lastIds[prefix] = 0;
}
lastIds[prefix]++;
return `${prefix}${lastIds[prefix]}`;
}
function handler() {
let zIndexes = [];
const generateZIndex = (key, autoZIndex, baseZIndex = 999) => {
const lastZIndex = getLastZIndex(key, autoZIndex, baseZIndex);
const newZIndex = lastZIndex.value + (lastZIndex.key === key ? 0 : baseZIndex) + 1;
zIndexes.push({ key, value: newZIndex });
return newZIndex;
};
const revertZIndex = (zIndex) => {
zIndexes = zIndexes.filter((obj) => obj.value !== zIndex);
};
const getCurrentZIndex = (key, autoZIndex) => {
return getLastZIndex(key).value;
};
const getLastZIndex = (key, autoZIndex, baseZIndex = 0) => {
return [...zIndexes].reverse().find((obj) => true) || { key, value: baseZIndex };
};
const getZIndex = (element) => {
return element ? parseInt(element.style.zIndex, 10) || 0 : 0;
};
return {
get: getZIndex,
set: (key, element, baseZIndex) => {
if (element) {
element.style.zIndex = String(generateZIndex(key, true, baseZIndex));
}
},
clear: (element) => {
if (element) {
revertZIndex(getZIndex(element));
element.style.zIndex = "";
}
},
getCurrent: (key) => getCurrentZIndex(key)
};
}
var ZIndex = handler();
var FilterMatchMode = {
STARTS_WITH: "startsWith",
CONTAINS: "contains",
NOT_CONTAINS: "notContains",
ENDS_WITH: "endsWith",
EQUALS: "equals",
NOT_EQUALS: "notEquals",
IN: "in",
LESS_THAN: "lt",
LESS_THAN_OR_EQUAL_TO: "lte",
GREATER_THAN: "gt",
GREATER_THAN_OR_EQUAL_TO: "gte",
BETWEEN: "between",
DATE_IS: "dateIs",
DATE_IS_NOT: "dateIsNot",
DATE_BEFORE: "dateBefore",
DATE_AFTER: "dateAfter"
};
function _typeof$a(o) {
"@babel/helpers - typeof";
return _typeof$a = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$a(o);
}
function ownKeys$8(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$8(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$8(Object(t), true).forEach(function(r2) {
_defineProperty$b(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$8(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$b(e, r, t) {
return (r = _toPropertyKey$a(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$a(t) {
var i = _toPrimitive$a(t, "string");
return "symbol" == _typeof$a(i) ? i : i + "";
}
function _toPrimitive$a(t, r) {
if ("object" != _typeof$a(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$a(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function tryOnMounted(fn) {
var sync = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
if (getCurrentInstance()) onMounted(fn);
else if (sync) fn();
else nextTick(fn);
}
var _id = 0;
function useStyle(css3) {
var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var isLoaded = ref(false);
var cssRef = ref(css3);
var styleRef = ref(null);
var defaultDocument = isClient() ? window.document : void 0;
var _options$document = options.document, document2 = _options$document === void 0 ? defaultDocument : _options$document, _options$immediate = options.immediate, immediate = _options$immediate === void 0 ? true : _options$immediate, _options$manual = options.manual, manual = _options$manual === void 0 ? false : _options$manual, _options$name = options.name, name = _options$name === void 0 ? "style_".concat(++_id) : _options$name, _options$id = options.id, id = _options$id === void 0 ? void 0 : _options$id, _options$media = options.media, media = _options$media === void 0 ? void 0 : _options$media, _options$nonce = options.nonce, nonce = _options$nonce === void 0 ? void 0 : _options$nonce, _options$first = options.first, first = _options$first === void 0 ? false : _options$first, _options$onMounted = options.onMounted, onStyleMounted = _options$onMounted === void 0 ? void 0 : _options$onMounted, _options$onUpdated = options.onUpdated, onStyleUpdated = _options$onUpdated === void 0 ? void 0 : _options$onUpdated, _options$onLoad = options.onLoad, onStyleLoaded = _options$onLoad === void 0 ? void 0 : _options$onLoad, _options$props = options.props, props = _options$props === void 0 ? {} : _options$props;
var stop = function stop2() {
};
var load2 = function load3(_css) {
var _props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
if (!document2) return;
var _styleProps = _objectSpread$8(_objectSpread$8({}, props), _props);
var _name = _styleProps.name || name, _id2 = _styleProps.id || id, _nonce = _styleProps.nonce || nonce;
styleRef.value = document2.querySelector('style[data-primevue-style-id="'.concat(_name, '"]')) || document2.getElementById(_id2) || document2.createElement("style");
if (!styleRef.value.isConnected) {
cssRef.value = _css || css3;
setAttributes(styleRef.value, {
type: "text/css",
id: _id2,
media,
nonce: _nonce
});
first ? document2.head.prepend(styleRef.value) : document2.head.appendChild(styleRef.value);
setAttribute(styleRef.value, "data-primevue-style-id", _name);
setAttributes(styleRef.value, _styleProps);
styleRef.value.onload = function(event) {
return onStyleLoaded === null || onStyleLoaded === void 0 ? void 0 : onStyleLoaded(event, {
name: _name
});
};
onStyleMounted === null || onStyleMounted === void 0 || onStyleMounted(_name);
}
if (isLoaded.value) return;
stop = watch(cssRef, function(value) {
styleRef.value.textContent = value;
onStyleUpdated === null || onStyleUpdated === void 0 || onStyleUpdated(_name);
}, {
immediate: true
});
isLoaded.value = true;
};
var unload = function unload2() {
if (!document2 || !isLoaded.value) return;
stop();
isExist(styleRef.value) && document2.head.removeChild(styleRef.value);
isLoaded.value = false;
};
if (immediate && !manual) tryOnMounted(load2);
return {
id,
name,
el: styleRef,
css: cssRef,
unload,
load: load2,
isLoaded: readonly(isLoaded)
};
}
function _typeof$9(o) {
"@babel/helpers - typeof";
return _typeof$9 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$9(o);
}
function _slicedToArray$2(r, e) {
return _arrayWithHoles$2(r) || _iterableToArrayLimit$2(r, e) || _unsupportedIterableToArray$3(r, e) || _nonIterableRest$2();
}
function _nonIterableRest$2() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray$3(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray$3(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$3(r, a) : void 0;
}
}
function _arrayLikeToArray$3(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _iterableToArrayLimit$2(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e, n, i, u, a = [], f = true, o = false;
try {
if (i = (t = t.call(r)).next, 0 === l) ;
else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
} catch (r2) {
o = true, n = r2;
} finally {
try {
if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _arrayWithHoles$2(r) {
if (Array.isArray(r)) return r;
}
function ownKeys$7(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$7(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$7(Object(t), true).forEach(function(r2) {
_defineProperty$a(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$7(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$a(e, r, t) {
return (r = _toPropertyKey$9(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$9(t) {
var i = _toPrimitive$9(t, "string");
return "symbol" == _typeof$9(i) ? i : i + "";
}
function _toPrimitive$9(t, r) {
if ("object" != _typeof$9(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$9(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var theme$6 = function theme(_ref) {
var dt2 = _ref.dt;
return "\n* {\n box-sizing: border-box;\n}\n\n/* Non vue overlay animations */\n.p-connected-overlay {\n opacity: 0;\n transform: scaleY(0.8);\n transition: transform 0.12s cubic-bezier(0, 0, 0.2, 1),\n opacity 0.12s cubic-bezier(0, 0, 0.2, 1);\n}\n\n.p-connected-overlay-visible {\n opacity: 1;\n transform: scaleY(1);\n}\n\n.p-connected-overlay-hidden {\n opacity: 0;\n transform: scaleY(1);\n transition: opacity 0.1s linear;\n}\n\n/* Vue based overlay animations */\n.p-connected-overlay-enter-from {\n opacity: 0;\n transform: scaleY(0.8);\n}\n\n.p-connected-overlay-leave-to {\n opacity: 0;\n}\n\n.p-connected-overlay-enter-active {\n transition: transform 0.12s cubic-bezier(0, 0, 0.2, 1),\n opacity 0.12s cubic-bezier(0, 0, 0.2, 1);\n}\n\n.p-connected-overlay-leave-active {\n transition: opacity 0.1s linear;\n}\n\n/* Toggleable Content */\n.p-toggleable-content-enter-from,\n.p-toggleable-content-leave-to {\n max-height: 0;\n}\n\n.p-toggleable-content-enter-to,\n.p-toggleable-content-leave-from {\n max-height: 1000px;\n}\n\n.p-toggleable-content-leave-active {\n overflow: hidden;\n transition: max-height 0.45s cubic-bezier(0, 1, 0, 1);\n}\n\n.p-toggleable-content-enter-active {\n overflow: hidden;\n transition: max-height 1s ease-in-out;\n}\n\n.p-disabled,\n.p-disabled * {\n cursor: default;\n pointer-events: none;\n user-select: none;\n}\n\n.p-disabled,\n.p-component:disabled {\n opacity: ".concat(dt2("disabled.opacity"), ";\n}\n\n.pi {\n font-size: ").concat(dt2("icon.size"), ";\n}\n\n.p-icon {\n width: ").concat(dt2("icon.size"), ";\n height: ").concat(dt2("icon.size"), ";\n}\n\n.p-overlay-mask {\n background: ").concat(dt2("mask.background"), ";\n color: ").concat(dt2("mask.color"), ";\n position: fixed;\n top: 0;\n left: 0;\n width: 100%;\n height: 100%;\n}\n\n.p-overlay-mask-enter {\n animation: p-overlay-mask-enter-animation ").concat(dt2("mask.transition.duration"), " forwards;\n}\n\n.p-overlay-mask-leave {\n animation: p-overlay-mask-leave-animation ").concat(dt2("mask.transition.duration"), " forwards;\n}\n\n@keyframes p-overlay-mask-enter-animation {\n from {\n background: transparent;\n }\n to {\n background: ").concat(dt2("mask.background"), ";\n }\n}\n@keyframes p-overlay-mask-leave-animation {\n from {\n background: ").concat(dt2("mask.background"), ";\n }\n to {\n background: transparent;\n }\n}\n");
};
var css$1 = function css(_ref2) {
var dt2 = _ref2.dt;
return "\n.p-hidden-accessible {\n border: 0;\n clip: rect(0 0 0 0);\n height: 1px;\n margin: -1px;\n overflow: hidden;\n padding: 0;\n position: absolute;\n width: 1px;\n}\n\n.p-hidden-accessible input,\n.p-hidden-accessible select {\n transform: scale(0);\n}\n\n.p-overflow-hidden {\n overflow: hidden;\n padding-right: ".concat(dt2("scrollbar.width"), ";\n}\n");
};
var classes$6 = {};
var inlineStyles$1 = {};
var BaseStyle = {
name: "base",
css: css$1,
theme: theme$6,
classes: classes$6,
inlineStyles: inlineStyles$1,
load: function load(style) {
var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var transform = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : function(cs) {
return cs;
};
var computedStyle = transform(resolve(style, {
dt
}));
return isNotEmpty(computedStyle) ? useStyle(minifyCSS(computedStyle), _objectSpread$7({
name: this.name
}, options)) : {};
},
loadCSS: function loadCSS() {
var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
return this.load(this.css, options);
},
loadTheme: function loadTheme() {
var _this = this;
var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var style = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
return this.load(this.theme, options, function() {
var computedStyle = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
return config_default.transformCSS(options.name || _this.name, "".concat(computedStyle).concat(style));
});
},
getCommonTheme: function getCommonTheme(params) {
return config_default.getCommon(this.name, params);
},
getComponentTheme: function getComponentTheme(params) {
return config_default.getComponent(this.name, params);
},
getDirectiveTheme: function getDirectiveTheme(params) {
return config_default.getDirective(this.name, params);
},
getPresetTheme: function getPresetTheme(preset, selector, params) {
return config_default.getCustomPreset(this.name, preset, selector, params);
},
getLayerOrderThemeCSS: function getLayerOrderThemeCSS() {
return config_default.getLayerOrderCSS(this.name);
},
getStyleSheet: function getStyleSheet() {
var extendedCSS = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
if (this.css) {
var _css = resolve(this.css, {
dt
}) || "";
var _style = minifyCSS("".concat(_css).concat(extendedCSS));
var _props = Object.entries(props).reduce(function(acc, _ref3) {
var _ref4 = _slicedToArray$2(_ref3, 2), k = _ref4[0], v = _ref4[1];
return acc.push("".concat(k, '="').concat(v, '"')) && acc;
}, []).join(" ");
return isNotEmpty(_style) ? '<style type="text/css" data-primevue-style-id="'.concat(this.name, '" ').concat(_props, ">").concat(_style, "</style>") : "";
}
return "";
},
getCommonThemeStyleSheet: function getCommonThemeStyleSheet(params) {
var props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
return config_default.getCommonStyleSheet(this.name, params, props);
},
getThemeStyleSheet: function getThemeStyleSheet(params) {
var props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var css3 = [config_default.getStyleSheet(this.name, params, props)];
if (this.theme) {
var name = this.name === "base" ? "global-style" : "".concat(this.name, "-style");
var _css = resolve(this.theme, {
dt
});
var _style = minifyCSS(config_default.transformCSS(name, _css));
var _props = Object.entries(props).reduce(function(acc, _ref5) {
var _ref6 = _slicedToArray$2(_ref5, 2), k = _ref6[0], v = _ref6[1];
return acc.push("".concat(k, '="').concat(v, '"')) && acc;
}, []).join(" ");
isNotEmpty(_style) && css3.push('<style type="text/css" data-primevue-style-id="'.concat(name, '" ').concat(_props, ">").concat(_style, "</style>"));
}
return css3.join("");
},
extend: function extend2(style) {
return _objectSpread$7(_objectSpread$7({}, this), {}, {
css: void 0,
theme: void 0
}, style);
}
};
var PrimeVueService = EventBus();
function _typeof$8(o) {
"@babel/helpers - typeof";
return _typeof$8 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$8(o);
}
function ownKeys$6(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$6(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$6(Object(t), true).forEach(function(r2) {
_defineProperty$9(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$6(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$9(e, r, t) {
return (r = _toPropertyKey$8(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$8(t) {
var i = _toPrimitive$8(t, "string");
return "symbol" == _typeof$8(i) ? i : i + "";
}
function _toPrimitive$8(t, r) {
if ("object" != _typeof$8(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$8(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var defaultOptions = {
ripple: false,
inputStyle: null,
inputVariant: null,
locale: {
startsWith: "Starts with",
contains: "Contains",
notContains: "Not contains",
endsWith: "Ends with",
equals: "Equals",
notEquals: "Not equals",
noFilter: "No Filter",
lt: "Less than",
lte: "Less than or equal to",
gt: "Greater than",
gte: "Greater than or equal to",
dateIs: "Date is",
dateIsNot: "Date is not",
dateBefore: "Date is before",
dateAfter: "Date is after",
clear: "Clear",
apply: "Apply",
matchAll: "Match All",
matchAny: "Match Any",
addRule: "Add Rule",
removeRule: "Remove Rule",
accept: "Yes",
reject: "No",
choose: "Choose",
upload: "Upload",
cancel: "Cancel",
completed: "Completed",
pending: "Pending",
fileSizeTypes: ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"],
dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
chooseYear: "Choose Year",
chooseMonth: "Choose Month",
chooseDate: "Choose Date",
prevDecade: "Previous Decade",
nextDecade: "Next Decade",
prevYear: "Previous Year",
nextYear: "Next Year",
prevMonth: "Previous Month",
nextMonth: "Next Month",
prevHour: "Previous Hour",
nextHour: "Next Hour",
prevMinute: "Previous Minute",
nextMinute: "Next Minute",
prevSecond: "Previous Second",
nextSecond: "Next Second",
am: "am",
pm: "pm",
today: "Today",
weekHeader: "Wk",
firstDayOfWeek: 0,
showMonthAfterYear: false,
dateFormat: "mm/dd/yy",
weak: "Weak",
medium: "Medium",
strong: "Strong",
passwordPrompt: "Enter a password",
emptyFilterMessage: "No results found",
searchMessage: "{0} results are available",
selectionMessage: "{0} items selected",
emptySelectionMessage: "No selected item",
emptySearchMessage: "No results found",
fileChosenMessage: "{0} files",
noFileChosenMessage: "No file chosen",
emptyMessage: "No available options",
aria: {
trueLabel: "True",
falseLabel: "False",
nullLabel: "Not Selected",
star: "1 star",
stars: "{star} stars",
selectAll: "All items selected",
unselectAll: "All items unselected",
close: "Close",
previous: "Previous",
next: "Next",
navigation: "Navigation",
scrollTop: "Scroll Top",
moveTop: "Move Top",
moveUp: "Move Up",
moveDown: "Move Down",
moveBottom: "Move Bottom",
moveToTarget: "Move to Target",
moveToSource: "Move to Source",
moveAllToTarget: "Move All to Target",
moveAllToSource: "Move All to Source",
pageLabel: "Page {page}",
firstPageLabel: "First Page",
lastPageLabel: "Last Page",
nextPageLabel: "Next Page",
prevPageLabel: "Previous Page",
rowsPerPageLabel: "Rows per page",
jumpToPageDropdownLabel: "Jump to Page Dropdown",
jumpToPageInputLabel: "Jump to Page Input",
selectRow: "Row Selected",
unselectRow: "Row Unselected",
expandRow: "Row Expanded",
collapseRow: "Row Collapsed",
showFilterMenu: "Show Filter Menu",
hideFilterMenu: "Hide Filter Menu",
filterOperator: "Filter Operator",
filterConstraint: "Filter Constraint",
editRow: "Row Edit",
saveEdit: "Save Edit",
cancelEdit: "Cancel Edit",
listView: "List View",
gridView: "Grid View",
slide: "Slide",
slideNumber: "{slideNumber}",
zoomImage: "Zoom Image",
zoomIn: "Zoom In",
zoomOut: "Zoom Out",
rotateRight: "Rotate Right",
rotateLeft: "Rotate Left",
listLabel: "Option List"
}
},
filterMatchModeOptions: {
text: [FilterMatchMode.STARTS_WITH, FilterMatchMode.CONTAINS, FilterMatchMode.NOT_CONTAINS, FilterMatchMode.ENDS_WITH, FilterMatchMode.EQUALS, FilterMatchMode.NOT_EQUALS],
numeric: [FilterMatchMode.EQUALS, FilterMatchMode.NOT_EQUALS, FilterMatchMode.LESS_THAN, FilterMatchMode.LESS_THAN_OR_EQUAL_TO, FilterMatchMode.GREATER_THAN, FilterMatchMode.GREATER_THAN_OR_EQUAL_TO],
date: [FilterMatchMode.DATE_IS, FilterMatchMode.DATE_IS_NOT, FilterMatchMode.DATE_BEFORE, FilterMatchMode.DATE_AFTER]
},
zIndex: {
modal: 1100,
overlay: 1e3,
menu: 1e3,
tooltip: 1100
},
theme: void 0,
unstyled: false,
pt: void 0,
ptOptions: {
mergeSections: true,
mergeProps: false
},
csp: {
nonce: void 0
}
};
var PrimeVueSymbol = Symbol();
function setup(app2, options) {
var PrimeVue2 = {
config: reactive(options)
};
app2.config.globalProperties.$primevue = PrimeVue2;
app2.provide(PrimeVueSymbol, PrimeVue2);
clearConfig();
setupConfig(app2, PrimeVue2);
return PrimeVue2;
}
var stopWatchers = [];
function clearConfig() {
service_default.clear();
stopWatchers.forEach(function(fn) {
return fn === null || fn === void 0 ? void 0 : fn();
});
stopWatchers = [];
}
function setupConfig(app2, PrimeVue2) {
var isThemeChanged = ref(false);
var loadCommonTheme = function loadCommonTheme2() {
var _PrimeVue$config;
if (((_PrimeVue$config = PrimeVue2.config) === null || _PrimeVue$config === void 0 ? void 0 : _PrimeVue$config.theme) === "none") return;
if (!config_default.isStyleNameLoaded("common")) {
var _BaseStyle$getCommonT, _PrimeVue$config2;
var _ref = ((_BaseStyle$getCommonT = BaseStyle.getCommonTheme) === null || _BaseStyle$getCommonT === void 0 ? void 0 : _BaseStyle$getCommonT.call(BaseStyle)) || {}, primitive = _ref.primitive, semantic = _ref.semantic, global2 = _ref.global, style = _ref.style;
var styleOptions = {
nonce: (_PrimeVue$config2 = PrimeVue2.config) === null || _PrimeVue$config2 === void 0 || (_PrimeVue$config2 = _PrimeVue$config2.csp) === null || _PrimeVue$config2 === void 0 ? void 0 : _PrimeVue$config2.nonce
};
BaseStyle.load(primitive === null || primitive === void 0 ? void 0 : primitive.css, _objectSpread$6({
name: "primitive-variables"
}, styleOptions));
BaseStyle.load(semantic === null || semantic === void 0 ? void 0 : semantic.css, _objectSpread$6({
name: "semantic-variables"
}, styleOptions));
BaseStyle.load(global2 === null || global2 === void 0 ? void 0 : global2.css, _objectSpread$6({
name: "global-variables"
}, styleOptions));
BaseStyle.loadTheme(_objectSpread$6({
name: "global-style"
}, styleOptions), style);
config_default.setLoadedStyleName("common");
}
};
service_default.on("theme:change", function(newTheme) {
if (!isThemeChanged.value) {
app2.config.globalProperties.$primevue.config.theme = newTheme;
isThemeChanged.value = true;
}
});
var stopConfigWatcher = watch(PrimeVue2.config, function(newValue, oldValue) {
PrimeVueService.emit("config:change", {
newValue,
oldValue
});
}, {
immediate: true,
deep: true
});
var stopRippleWatcher = watch(function() {
return PrimeVue2.config.ripple;
}, function(newValue, oldValue) {
PrimeVueService.emit("config:ripple:change", {
newValue,
oldValue
});
}, {
immediate: true,
deep: true
});
var stopThemeWatcher = watch(function() {
return PrimeVue2.config.theme;
}, function(newValue, oldValue) {
if (!isThemeChanged.value) {
config_default.setTheme(newValue);
}
if (!PrimeVue2.config.unstyled) {
loadCommonTheme();
}
isThemeChanged.value = false;
PrimeVueService.emit("config:theme:change", {
newValue,
oldValue
});
}, {
immediate: true,
deep: true
});
var stopUnstyledWatcher = watch(function() {
return PrimeVue2.config.unstyled;
}, function(newValue, oldValue) {
if (!newValue && PrimeVue2.config.theme) {
loadCommonTheme();
}
PrimeVueService.emit("config:unstyled:change", {
newValue,
oldValue
});
}, {
immediate: true,
deep: true
});
stopWatchers.push(stopConfigWatcher);
stopWatchers.push(stopRippleWatcher);
stopWatchers.push(stopThemeWatcher);
stopWatchers.push(stopUnstyledWatcher);
}
var PrimeVue = {
install: function install(app2, options) {
var configOptions = mergeKeys(defaultOptions, options);
setup(app2, configOptions);
}
};
var index$1o = {
root: {
transitionDuration: "{transition.duration}"
},
panel: {
borderWidth: "0 0 1px 0",
borderColor: "{content.border.color}"
},
header: {
color: "{text.muted.color}",
hoverColor: "{text.color}",
activeColor: "{text.color}",
padding: "1.125rem",
fontWeight: "600",
borderRadius: "0",
borderWidth: "0",
borderColor: "{content.border.color}",
background: "{content.background}",
hoverBackground: "{content.background}",
activeBackground: "{content.background}",
activeHoverBackground: "{content.background}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
toggleIcon: {
color: "{text.muted.color}",
hoverColor: "{text.color}",
activeColor: "{text.color}",
activeHoverColor: "{text.color}"
},
first: {
topBorderRadius: "{content.border.radius}",
borderWidth: "0"
},
last: {
bottomBorderRadius: "{content.border.radius}",
activeBottomBorderRadius: "0"
}
},
content: {
borderWidth: "0",
borderColor: "{content.border.color}",
background: "{content.background}",
color: "{text.color}",
padding: "0 1.125rem 1.125rem 1.125rem"
}
};
var index$1n = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledHoverBackground: "{form.field.filled.hover.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
overlay: {
background: "{overlay.select.background}",
borderColor: "{overlay.select.border.color}",
borderRadius: "{overlay.select.border.radius}",
color: "{overlay.select.color}",
shadow: "{overlay.select.shadow}"
},
list: {
padding: "{list.padding}",
gap: "{list.gap}"
},
option: {
focusBackground: "{list.option.focus.background}",
selectedBackground: "{list.option.selected.background}",
selectedFocusBackground: "{list.option.selected.focus.background}",
color: "{list.option.color}",
focusColor: "{list.option.focus.color}",
selectedColor: "{list.option.selected.color}",
selectedFocusColor: "{list.option.selected.focus.color}",
padding: "{list.option.padding}",
borderRadius: "{list.option.border.radius}"
},
optionGroup: {
background: "{list.option.group.background}",
color: "{list.option.group.color}",
fontWeight: "{list.option.group.font.weight}",
padding: "{list.option.group.padding}"
},
dropdown: {
width: "2.5rem",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.border.color}",
activeBorderColor: "{form.field.border.color}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
chip: {
borderRadius: "{border.radius.sm}"
},
emptyMessage: {
padding: "{list.option.padding}"
},
colorScheme: {
light: {
dropdown: {
background: "{surface.100}",
hoverBackground: "{surface.200}",
activeBackground: "{surface.300}",
color: "{surface.600}",
hoverColor: "{surface.700}",
activeColor: "{surface.800}"
}
},
dark: {
dropdown: {
background: "{surface.800}",
hoverBackground: "{surface.700}",
activeBackground: "{surface.600}",
color: "{surface.300}",
hoverColor: "{surface.200}",
activeColor: "{surface.100}"
}
}
}
};
var index$1m = {
root: {
width: "2rem",
height: "2rem",
fontSize: "1rem",
background: "{content.border.color}",
borderRadius: "{content.border.radius}"
},
group: {
borderColor: "{content.background}",
offset: "-1rem"
},
lg: {
width: "3rem",
height: "3rem",
fontSize: "1.5rem"
},
xl: {
width: "4rem",
height: "4rem",
fontSize: "2rem"
}
};
var index$1l = {
root: {
borderRadius: "{border.radius.md}",
padding: "0 0.5rem",
fontSize: "0.75rem",
fontWeight: "700",
minWidth: "1.5rem",
height: "1.5rem"
},
dot: {
size: "0.5rem"
},
sm: {
fontSize: "0.625rem",
minWidth: "1.25rem",
height: "1.25rem"
},
lg: {
fontSize: "0.875rem",
minWidth: "1.75rem",
height: "1.75rem"
},
xl: {
fontSize: "1rem",
minWidth: "2rem",
height: "2rem"
},
colorScheme: {
light: {
primary: {
background: "{primary.color}",
color: "{primary.contrast.color}"
},
secondary: {
background: "{surface.100}",
color: "{surface.600}"
},
success: {
background: "{green.500}",
color: "{surface.0}"
},
info: {
background: "{sky.500}",
color: "{surface.0}"
},
warn: {
background: "{orange.500}",
color: "{surface.0}"
},
danger: {
background: "{red.500}",
color: "{surface.0}"
},
contrast: {
background: "{surface.950}",
color: "{surface.0}"
}
},
dark: {
primary: {
background: "{primary.color}",
color: "{primary.contrast.color}"
},
secondary: {
background: "{surface.800}",
color: "{surface.300}"
},
success: {
background: "{green.400}",
color: "{green.950}"
},
info: {
background: "{sky.400}",
color: "{sky.950}"
},
warn: {
background: "{orange.400}",
color: "{orange.950}"
},
danger: {
background: "{red.400}",
color: "{red.950}"
},
contrast: {
background: "{surface.0}",
color: "{surface.950}"
}
}
}
};
var index$1k = {
primitive: {
borderRadius: {
none: "0",
xs: "2px",
sm: "4px",
md: "6px",
lg: "8px",
xl: "12px"
},
emerald: {
50: "#ecfdf5",
100: "#d1fae5",
200: "#a7f3d0",
300: "#6ee7b7",
400: "#34d399",
500: "#10b981",
600: "#059669",
700: "#047857",
800: "#065f46",
900: "#064e3b",
950: "#022c22"
},
green: {
50: "#f0fdf4",
100: "#dcfce7",
200: "#bbf7d0",
300: "#86efac",
400: "#4ade80",
500: "#22c55e",
600: "#16a34a",
700: "#15803d",
800: "#166534",
900: "#14532d",
950: "#052e16"
},
lime: {
50: "#f7fee7",
100: "#ecfccb",
200: "#d9f99d",
300: "#bef264",
400: "#a3e635",
500: "#84cc16",
600: "#65a30d",
700: "#4d7c0f",
800: "#3f6212",
900: "#365314",
950: "#1a2e05"
},
red: {
50: "#fef2f2",
100: "#fee2e2",
200: "#fecaca",
300: "#fca5a5",
400: "#f87171",
500: "#ef4444",
600: "#dc2626",
700: "#b91c1c",
800: "#991b1b",
900: "#7f1d1d",
950: "#450a0a"
},
orange: {
50: "#fff7ed",
100: "#ffedd5",
200: "#fed7aa",
300: "#fdba74",
400: "#fb923c",
500: "#f97316",
600: "#ea580c",
700: "#c2410c",
800: "#9a3412",
900: "#7c2d12",
950: "#431407"
},
amber: {
50: "#fffbeb",
100: "#fef3c7",
200: "#fde68a",
300: "#fcd34d",
400: "#fbbf24",
500: "#f59e0b",
600: "#d97706",
700: "#b45309",
800: "#92400e",
900: "#78350f",
950: "#451a03"
},
yellow: {
50: "#fefce8",
100: "#fef9c3",
200: "#fef08a",
300: "#fde047",
400: "#facc15",
500: "#eab308",
600: "#ca8a04",
700: "#a16207",
800: "#854d0e",
900: "#713f12",
950: "#422006"
},
teal: {
50: "#f0fdfa",
100: "#ccfbf1",
200: "#99f6e4",
300: "#5eead4",
400: "#2dd4bf",
500: "#14b8a6",
600: "#0d9488",
700: "#0f766e",
800: "#115e59",
900: "#134e4a",
950: "#042f2e"
},
cyan: {
50: "#ecfeff",
100: "#cffafe",
200: "#a5f3fc",
300: "#67e8f9",
400: "#22d3ee",
500: "#06b6d4",
600: "#0891b2",
700: "#0e7490",
800: "#155e75",
900: "#164e63",
950: "#083344"
},
sky: {
50: "#f0f9ff",
100: "#e0f2fe",
200: "#bae6fd",
300: "#7dd3fc",
400: "#38bdf8",
500: "#0ea5e9",
600: "#0284c7",
700: "#0369a1",
800: "#075985",
900: "#0c4a6e",
950: "#082f49"
},
blue: {
50: "#eff6ff",
100: "#dbeafe",
200: "#bfdbfe",
300: "#93c5fd",
400: "#60a5fa",
500: "#3b82f6",
600: "#2563eb",
700: "#1d4ed8",
800: "#1e40af",
900: "#1e3a8a",
950: "#172554"
},
indigo: {
50: "#eef2ff",
100: "#e0e7ff",
200: "#c7d2fe",
300: "#a5b4fc",
400: "#818cf8",
500: "#6366f1",
600: "#4f46e5",
700: "#4338ca",
800: "#3730a3",
900: "#312e81",
950: "#1e1b4b"
},
violet: {
50: "#f5f3ff",
100: "#ede9fe",
200: "#ddd6fe",
300: "#c4b5fd",
400: "#a78bfa",
500: "#8b5cf6",
600: "#7c3aed",
700: "#6d28d9",
800: "#5b21b6",
900: "#4c1d95",
950: "#2e1065"
},
purple: {
50: "#faf5ff",
100: "#f3e8ff",
200: "#e9d5ff",
300: "#d8b4fe",
400: "#c084fc",
500: "#a855f7",
600: "#9333ea",
700: "#7e22ce",
800: "#6b21a8",
900: "#581c87",
950: "#3b0764"
},
fuchsia: {
50: "#fdf4ff",
100: "#fae8ff",
200: "#f5d0fe",
300: "#f0abfc",
400: "#e879f9",
500: "#d946ef",
600: "#c026d3",
700: "#a21caf",
800: "#86198f",
900: "#701a75",
950: "#4a044e"
},
pink: {
50: "#fdf2f8",
100: "#fce7f3",
200: "#fbcfe8",
300: "#f9a8d4",
400: "#f472b6",
500: "#ec4899",
600: "#db2777",
700: "#be185d",
800: "#9d174d",
900: "#831843",
950: "#500724"
},
rose: {
50: "#fff1f2",
100: "#ffe4e6",
200: "#fecdd3",
300: "#fda4af",
400: "#fb7185",
500: "#f43f5e",
600: "#e11d48",
700: "#be123c",
800: "#9f1239",
900: "#881337",
950: "#4c0519"
},
slate: {
50: "#f8fafc",
100: "#f1f5f9",
200: "#e2e8f0",
300: "#cbd5e1",
400: "#94a3b8",
500: "#64748b",
600: "#475569",
700: "#334155",
800: "#1e293b",
900: "#0f172a",
950: "#020617"
},
gray: {
50: "#f9fafb",
100: "#f3f4f6",
200: "#e5e7eb",
300: "#d1d5db",
400: "#9ca3af",
500: "#6b7280",
600: "#4b5563",
700: "#374151",
800: "#1f2937",
900: "#111827",
950: "#030712"
},
zinc: {
50: "#fafafa",
100: "#f4f4f5",
200: "#e4e4e7",
300: "#d4d4d8",
400: "#a1a1aa",
500: "#71717a",
600: "#52525b",
700: "#3f3f46",
800: "#27272a",
900: "#18181b",
950: "#09090b"
},
neutral: {
50: "#fafafa",
100: "#f5f5f5",
200: "#e5e5e5",
300: "#d4d4d4",
400: "#a3a3a3",
500: "#737373",
600: "#525252",
700: "#404040",
800: "#262626",
900: "#171717",
950: "#0a0a0a"
},
stone: {
50: "#fafaf9",
100: "#f5f5f4",
200: "#e7e5e4",
300: "#d6d3d1",
400: "#a8a29e",
500: "#78716c",
600: "#57534e",
700: "#44403c",
800: "#292524",
900: "#1c1917",
950: "#0c0a09"
}
},
semantic: {
transitionDuration: "0.2s",
focusRing: {
width: "1px",
style: "solid",
color: "{primary.color}",
offset: "2px",
shadow: "none"
},
disabledOpacity: "0.6",
iconSize: "1rem",
anchorGutter: "2px",
primary: {
50: "{emerald.50}",
100: "{emerald.100}",
200: "{emerald.200}",
300: "{emerald.300}",
400: "{emerald.400}",
500: "{emerald.500}",
600: "{emerald.600}",
700: "{emerald.700}",
800: "{emerald.800}",
900: "{emerald.900}",
950: "{emerald.950}"
},
formField: {
paddingX: "0.75rem",
paddingY: "0.5rem",
borderRadius: "{border.radius.md}",
focusRing: {
width: "0",
style: "none",
color: "transparent",
offset: "0",
shadow: "none"
},
transitionDuration: "{transition.duration}"
},
list: {
padding: "0.25rem 0.25rem",
gap: "2px",
header: {
padding: "0.5rem 1rem 0.25rem 1rem"
},
option: {
padding: "0.5rem 0.75rem",
borderRadius: "{border.radius.sm}"
},
optionGroup: {
padding: "0.5rem 0.75rem",
fontWeight: "600"
}
},
content: {
borderRadius: "{border.radius.md}"
},
mask: {
transitionDuration: "0.15s"
},
navigation: {
list: {
padding: "0.25rem 0.25rem",
gap: "2px"
},
item: {
padding: "0.5rem 0.75rem",
borderRadius: "{border.radius.sm}",
gap: "0.5rem"
},
submenuLabel: {
padding: "0.5rem 0.75rem",
fontWeight: "600"
},
submenuIcon: {
size: "0.875rem"
}
},
overlay: {
select: {
borderRadius: "{border.radius.md}",
shadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)"
},
popover: {
borderRadius: "{border.radius.md}",
padding: "0.75rem",
shadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)"
},
modal: {
borderRadius: "{border.radius.xl}",
padding: "1.25rem",
shadow: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)"
},
navigation: {
shadow: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)"
}
},
colorScheme: {
light: {
surface: {
0: "#ffffff",
50: "{slate.50}",
100: "{slate.100}",
200: "{slate.200}",
300: "{slate.300}",
400: "{slate.400}",
500: "{slate.500}",
600: "{slate.600}",
700: "{slate.700}",
800: "{slate.800}",
900: "{slate.900}",
950: "{slate.950}"
},
primary: {
color: "{primary.500}",
contrastColor: "#ffffff",
hoverColor: "{primary.600}",
activeColor: "{primary.700}"
},
highlight: {
background: "{primary.50}",
focusBackground: "{primary.100}",
color: "{primary.700}",
focusColor: "{primary.800}"
},
mask: {
background: "rgba(0,0,0,0.4)",
color: "{surface.200}"
},
formField: {
background: "{surface.0}",
disabledBackground: "{surface.200}",
filledBackground: "{surface.50}",
filledHoverBackground: "{surface.50}",
filledFocusBackground: "{surface.50}",
borderColor: "{surface.300}",
hoverBorderColor: "{surface.400}",
focusBorderColor: "{primary.color}",
invalidBorderColor: "{red.400}",
color: "{surface.700}",
disabledColor: "{surface.500}",
placeholderColor: "{surface.500}",
floatLabelColor: "{surface.500}",
floatLabelFocusColor: "{primary.600}",
floatLabelActiveColor: "{surface.500}",
floatLabelInvalidColor: "{red.400}",
iconColor: "{surface.400}",
shadow: "0 0 #0000, 0 0 #0000, 0 1px 2px 0 rgba(18, 18, 23, 0.05)"
},
text: {
color: "{surface.700}",
hoverColor: "{surface.800}",
mutedColor: "{surface.500}",
hoverMutedColor: "{surface.600}"
},
content: {
background: "{surface.0}",
hoverBackground: "{surface.100}",
borderColor: "{surface.200}",
color: "{text.color}",
hoverColor: "{text.hover.color}"
},
overlay: {
select: {
background: "{surface.0}",
borderColor: "{surface.200}",
color: "{text.color}"
},
popover: {
background: "{surface.0}",
borderColor: "{surface.200}",
color: "{text.color}"
},
modal: {
background: "{surface.0}",
borderColor: "{surface.200}",
color: "{text.color}"
}
},
list: {
option: {
focusBackground: "{surface.100}",
selectedBackground: "{highlight.background}",
selectedFocusBackground: "{highlight.focus.background}",
color: "{text.color}",
focusColor: "{text.hover.color}",
selectedColor: "{highlight.color}",
selectedFocusColor: "{highlight.focus.color}",
icon: {
color: "{surface.400}",
focusColor: "{surface.500}"
}
},
optionGroup: {
background: "transparent",
color: "{text.muted.color}"
}
},
navigation: {
item: {
focusBackground: "{surface.100}",
activeBackground: "{surface.100}",
color: "{text.color}",
focusColor: "{text.hover.color}",
activeColor: "{text.hover.color}",
icon: {
color: "{surface.400}",
focusColor: "{surface.500}",
activeColor: "{surface.500}"
}
},
submenuLabel: {
background: "transparent",
color: "{text.muted.color}"
},
submenuIcon: {
color: "{surface.400}",
focusColor: "{surface.500}",
activeColor: "{surface.500}"
}
}
},
dark: {
surface: {
0: "#ffffff",
50: "{zinc.50}",
100: "{zinc.100}",
200: "{zinc.200}",
300: "{zinc.300}",
400: "{zinc.400}",
500: "{zinc.500}",
600: "{zinc.600}",
700: "{zinc.700}",
800: "{zinc.800}",
900: "{zinc.900}",
950: "{zinc.950}"
},
primary: {
color: "{primary.400}",
contrastColor: "{surface.900}",
hoverColor: "{primary.300}",
activeColor: "{primary.200}"
},
highlight: {
background: "color-mix(in srgb, {primary.400}, transparent 84%)",
focusBackground: "color-mix(in srgb, {primary.400}, transparent 76%)",
color: "rgba(255,255,255,.87)",
focusColor: "rgba(255,255,255,.87)"
},
mask: {
background: "rgba(0,0,0,0.6)",
color: "{surface.200}"
},
formField: {
background: "{surface.950}",
disabledBackground: "{surface.700}",
filledBackground: "{surface.800}",
filledHoverBackground: "{surface.800}",
filledFocusBackground: "{surface.800}",
borderColor: "{surface.700}",
hoverBorderColor: "{surface.600}",
focusBorderColor: "{primary.color}",
invalidBorderColor: "{red.300}",
color: "{surface.0}",
disabledColor: "{surface.400}",
placeholderColor: "{surface.400}",
floatLabelColor: "{surface.400}",
floatLabelFocusColor: "{primary.color}",
floatLabelActiveColor: "{surface.400}",
floatLabelInvalidColor: "{red.300}",
iconColor: "{surface.400}",
shadow: "0 0 #0000, 0 0 #0000, 0 1px 2px 0 rgba(18, 18, 23, 0.05)"
},
text: {
color: "{surface.0}",
hoverColor: "{surface.0}",
mutedColor: "{surface.400}",
hoverMutedColor: "{surface.300}"
},
content: {
background: "{surface.900}",
hoverBackground: "{surface.800}",
borderColor: "{surface.700}",
color: "{text.color}",
hoverColor: "{text.hover.color}"
},
overlay: {
select: {
background: "{surface.900}",
borderColor: "{surface.700}",
color: "{text.color}"
},
popover: {
background: "{surface.900}",
borderColor: "{surface.700}",
color: "{text.color}"
},
modal: {
background: "{surface.900}",
borderColor: "{surface.700}",
color: "{text.color}"
}
},
list: {
option: {
focusBackground: "{surface.800}",
selectedBackground: "{highlight.background}",
selectedFocusBackground: "{highlight.focus.background}",
color: "{text.color}",
focusColor: "{text.hover.color}",
selectedColor: "{highlight.color}",
selectedFocusColor: "{highlight.focus.color}",
icon: {
color: "{surface.500}",
focusColor: "{surface.400}"
}
},
optionGroup: {
background: "transparent",
color: "{text.muted.color}"
}
},
navigation: {
item: {
focusBackground: "{surface.800}",
activeBackground: "{surface.800}",
color: "{text.color}",
focusColor: "{text.hover.color}",
activeColor: "{text.hover.color}",
icon: {
color: "{surface.500}",
focusColor: "{surface.400}",
activeColor: "{surface.400}"
}
},
submenuLabel: {
background: "transparent",
color: "{text.muted.color}"
},
submenuIcon: {
color: "{surface.500}",
focusColor: "{surface.400}",
activeColor: "{surface.400}"
}
}
}
}
}
};
var index$1j = {
root: {
borderRadius: "{content.border.radius}"
}
};
var index$1i = {
root: {
padding: "1rem",
background: "{content.background}",
gap: "0.5rem",
transitionDuration: "{transition.duration}"
},
item: {
color: "{text.muted.color}",
hoverColor: "{text.color}",
borderRadius: "{content.border.radius}",
gap: "{navigation.item.gap}",
icon: {
color: "{navigation.item.icon.color}",
hoverColor: "{navigation.item.icon.focus.color}"
},
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
separator: {
color: "{navigation.item.icon.color}"
}
};
var index$1h = {
root: {
borderRadius: "{form.field.border.radius}",
roundedBorderRadius: "2rem",
gap: "0.5rem",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
iconOnlyWidth: "2.5rem",
sm: {
fontSize: "0.875rem",
paddingX: "0.625rem",
paddingY: "0.375rem"
},
lg: {
fontSize: "1.125rem",
paddingX: "0.875rem",
paddingY: "0.625rem"
},
label: {
fontWeight: "500"
},
raisedShadow: "0 3px 1px -2px rgba(0, 0, 0, 0.2), 0 2px 2px 0 rgba(0, 0, 0, 0.14), 0 1px 5px 0 rgba(0, 0, 0, 0.12)",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
offset: "{focus.ring.offset}"
},
badgeSize: "1rem",
transitionDuration: "{form.field.transition.duration}"
},
colorScheme: {
light: {
root: {
primary: {
background: "{primary.color}",
hoverBackground: "{primary.hover.color}",
activeBackground: "{primary.active.color}",
borderColor: "{primary.color}",
hoverBorderColor: "{primary.hover.color}",
activeBorderColor: "{primary.active.color}",
color: "{primary.contrast.color}",
hoverColor: "{primary.contrast.color}",
activeColor: "{primary.contrast.color}",
focusRing: {
color: "{primary.color}",
shadow: "none"
}
},
secondary: {
background: "{surface.100}",
hoverBackground: "{surface.200}",
activeBackground: "{surface.300}",
borderColor: "{surface.100}",
hoverBorderColor: "{surface.200}",
activeBorderColor: "{surface.300}",
color: "{surface.600}",
hoverColor: "{surface.700}",
activeColor: "{surface.800}",
focusRing: {
color: "{surface.600}",
shadow: "none"
}
},
info: {
background: "{sky.500}",
hoverBackground: "{sky.600}",
activeBackground: "{sky.700}",
borderColor: "{sky.500}",
hoverBorderColor: "{sky.600}",
activeBorderColor: "{sky.700}",
color: "#ffffff",
hoverColor: "#ffffff",
activeColor: "#ffffff",
focusRing: {
color: "{sky.500}",
shadow: "none"
}
},
success: {
background: "{green.500}",
hoverBackground: "{green.600}",
activeBackground: "{green.700}",
borderColor: "{green.500}",
hoverBorderColor: "{green.600}",
activeBorderColor: "{green.700}",
color: "#ffffff",
hoverColor: "#ffffff",
activeColor: "#ffffff",
focusRing: {
color: "{green.500}",
shadow: "none"
}
},
warn: {
background: "{orange.500}",
hoverBackground: "{orange.600}",
activeBackground: "{orange.700}",
borderColor: "{orange.500}",
hoverBorderColor: "{orange.600}",
activeBorderColor: "{orange.700}",
color: "#ffffff",
hoverColor: "#ffffff",
activeColor: "#ffffff",
focusRing: {
color: "{orange.500}",
shadow: "none"
}
},
help: {
background: "{purple.500}",
hoverBackground: "{purple.600}",
activeBackground: "{purple.700}",
borderColor: "{purple.500}",
hoverBorderColor: "{purple.600}",
activeBorderColor: "{purple.700}",
color: "#ffffff",
hoverColor: "#ffffff",
activeColor: "#ffffff",
focusRing: {
color: "{purple.500}",
shadow: "none"
}
},
danger: {
background: "{red.500}",
hoverBackground: "{red.600}",
activeBackground: "{red.700}",
borderColor: "{red.500}",
hoverBorderColor: "{red.600}",
activeBorderColor: "{red.700}",
color: "#ffffff",
hoverColor: "#ffffff",
activeColor: "#ffffff",
focusRing: {
color: "{red.500}",
shadow: "none"
}
},
contrast: {
background: "{surface.950}",
hoverBackground: "{surface.900}",
activeBackground: "{surface.800}",
borderColor: "{surface.950}",
hoverBorderColor: "{surface.900}",
activeBorderColor: "{surface.800}",
color: "{surface.0}",
hoverColor: "{surface.0}",
activeColor: "{surface.0}",
focusRing: {
color: "{surface.950}",
shadow: "none"
}
}
},
outlined: {
primary: {
hoverBackground: "{primary.50}",
activeBackground: "{primary.100}",
borderColor: "{primary.200}",
color: "{primary.color}"
},
secondary: {
hoverBackground: "{surface.50}",
activeBackground: "{surface.100}",
borderColor: "{surface.200}",
color: "{surface.500}"
},
success: {
hoverBackground: "{green.50}",
activeBackground: "{green.100}",
borderColor: "{green.200}",
color: "{green.500}"
},
info: {
hoverBackground: "{sky.50}",
activeBackground: "{sky.100}",
borderColor: "{sky.200}",
color: "{sky.500}"
},
warn: {
hoverBackground: "{orange.50}",
activeBackground: "{orange.100}",
borderColor: "{orange.200}",
color: "{orange.500}"
},
help: {
hoverBackground: "{purple.50}",
activeBackground: "{purple.100}",
borderColor: "{purple.200}",
color: "{purple.500}"
},
danger: {
hoverBackground: "{red.50}",
activeBackground: "{red.100}",
borderColor: "{red.200}",
color: "{red.500}"
},
contrast: {
hoverBackground: "{surface.50}",
activeBackground: "{surface.100}",
borderColor: "{surface.700}",
color: "{surface.950}"
},
plain: {
hoverBackground: "{surface.50}",
activeBackground: "{surface.100}",
borderColor: "{surface.200}",
color: "{surface.700}"
}
},
text: {
primary: {
hoverBackground: "{primary.50}",
activeBackground: "{primary.100}",
color: "{primary.color}"
},
secondary: {
hoverBackground: "{surface.50}",
activeBackground: "{surface.100}",
color: "{surface.500}"
},
success: {
hoverBackground: "{green.50}",
activeBackground: "{green.100}",
color: "{green.500}"
},
info: {
hoverBackground: "{sky.50}",
activeBackground: "{sky.100}",
color: "{sky.500}"
},
warn: {
hoverBackground: "{orange.50}",
activeBackground: "{orange.100}",
color: "{orange.500}"
},
help: {
hoverBackground: "{purple.50}",
activeBackground: "{purple.100}",
color: "{purple.500}"
},
danger: {
hoverBackground: "{red.50}",
activeBackground: "{red.100}",
color: "{red.500}"
},
plain: {
hoverBackground: "{surface.50}",
activeBackground: "{surface.100}",
color: "{surface.700}"
}
},
link: {
color: "{primary.color}",
hoverColor: "{primary.color}",
activeColor: "{primary.color}"
}
},
dark: {
root: {
primary: {
background: "{primary.color}",
hoverBackground: "{primary.hover.color}",
activeBackground: "{primary.active.color}",
borderColor: "{primary.color}",
hoverBorderColor: "{primary.hover.color}",
activeBorderColor: "{primary.active.color}",
color: "{primary.contrast.color}",
hoverColor: "{primary.contrast.color}",
activeColor: "{primary.contrast.color}",
focusRing: {
color: "{primary.color}",
shadow: "none"
}
},
secondary: {
background: "{surface.800}",
hoverBackground: "{surface.700}",
activeBackground: "{surface.600}",
borderColor: "{surface.800}",
hoverBorderColor: "{surface.700}",
activeBorderColor: "{surface.600}",
color: "{surface.300}",
hoverColor: "{surface.200}",
activeColor: "{surface.100}",
focusRing: {
color: "{surface.300}",
shadow: "none"
}
},
info: {
background: "{sky.400}",
hoverBackground: "{sky.300}",
activeBackground: "{sky.200}",
borderColor: "{sky.400}",
hoverBorderColor: "{sky.300}",
activeBorderColor: "{sky.200}",
color: "{sky.950}",
hoverColor: "{sky.950}",
activeColor: "{sky.950}",
focusRing: {
color: "{sky.400}",
shadow: "none"
}
},
success: {
background: "{green.400}",
hoverBackground: "{green.300}",
activeBackground: "{green.200}",
borderColor: "{green.400}",
hoverBorderColor: "{green.300}",
activeBorderColor: "{green.200}",
color: "{green.950}",
hoverColor: "{green.950}",
activeColor: "{green.950}",
focusRing: {
color: "{green.400}",
shadow: "none"
}
},
warn: {
background: "{orange.400}",
hoverBackground: "{orange.300}",
activeBackground: "{orange.200}",
borderColor: "{orange.400}",
hoverBorderColor: "{orange.300}",
activeBorderColor: "{orange.200}",
color: "{orange.950}",
hoverColor: "{orange.950}",
activeColor: "{orange.950}",
focusRing: {
color: "{orange.400}",
shadow: "none"
}
},
help: {
background: "{purple.400}",
hoverBackground: "{purple.300}",
activeBackground: "{purple.200}",
borderColor: "{purple.400}",
hoverBorderColor: "{purple.300}",
activeBorderColor: "{purple.200}",
color: "{purple.950}",
hoverColor: "{purple.950}",
activeColor: "{purple.950}",
focusRing: {
color: "{purple.400}",
shadow: "none"
}
},
danger: {
background: "{red.400}",
hoverBackground: "{red.300}",
activeBackground: "{red.200}",
borderColor: "{red.400}",
hoverBorderColor: "{red.300}",
activeBorderColor: "{red.200}",
color: "{red.950}",
hoverColor: "{red.950}",
activeColor: "{red.950}",
focusRing: {
color: "{red.400}",
shadow: "none"
}
},
contrast: {
background: "{surface.0}",
hoverBackground: "{surface.100}",
activeBackground: "{surface.200}",
borderColor: "{surface.0}",
hoverBorderColor: "{surface.100}",
activeBorderColor: "{surface.200}",
color: "{surface.950}",
hoverColor: "{surface.950}",
activeColor: "{surface.950}",
focusRing: {
color: "{surface.0}",
shadow: "none"
}
}
},
outlined: {
primary: {
hoverBackground: "color-mix(in srgb, {primary.color}, transparent 96%)",
activeBackground: "color-mix(in srgb, {primary.color}, transparent 84%)",
borderColor: "{primary.700}",
color: "{primary.color}"
},
secondary: {
hoverBackground: "rgba(255,255,255,0.04)",
activeBackground: "rgba(255,255,255,0.16)",
borderColor: "{surface.700}",
color: "{surface.400}"
},
success: {
hoverBackground: "color-mix(in srgb, {green.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {green.400}, transparent 84%)",
borderColor: "{green.700}",
color: "{green.400}"
},
info: {
hoverBackground: "color-mix(in srgb, {sky.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {sky.400}, transparent 84%)",
borderColor: "{sky.700}",
color: "{sky.400}"
},
warn: {
hoverBackground: "color-mix(in srgb, {orange.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {orange.400}, transparent 84%)",
borderColor: "{orange.700}",
color: "{orange.400}"
},
help: {
hoverBackground: "color-mix(in srgb, {purple.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {purple.400}, transparent 84%)",
borderColor: "{purple.700}",
color: "{purple.400}"
},
danger: {
hoverBackground: "color-mix(in srgb, {red.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {red.400}, transparent 84%)",
borderColor: "{red.700}",
color: "{red.400}"
},
contrast: {
hoverBackground: "{surface.800}",
activeBackground: "{surface.700}",
borderColor: "{surface.500}",
color: "{surface.0}"
},
plain: {
hoverBackground: "{surface.800}",
activeBackground: "{surface.700}",
borderColor: "{surface.600}",
color: "{surface.0}"
}
},
text: {
primary: {
hoverBackground: "color-mix(in srgb, {primary.color}, transparent 96%)",
activeBackground: "color-mix(in srgb, {primary.color}, transparent 84%)",
color: "{primary.color}"
},
secondary: {
hoverBackground: "{surface.800}",
activeBackground: "{surface.700}",
color: "{surface.400}"
},
success: {
hoverBackground: "color-mix(in srgb, {green.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {green.400}, transparent 84%)",
color: "{green.400}"
},
info: {
hoverBackground: "color-mix(in srgb, {sky.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {sky.400}, transparent 84%)",
color: "{sky.400}"
},
warn: {
hoverBackground: "color-mix(in srgb, {orange.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {orange.400}, transparent 84%)",
color: "{orange.400}"
},
help: {
hoverBackground: "color-mix(in srgb, {purple.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {purple.400}, transparent 84%)",
color: "{purple.400}"
},
danger: {
hoverBackground: "color-mix(in srgb, {red.400}, transparent 96%)",
activeBackground: "color-mix(in srgb, {red.400}, transparent 84%)",
color: "{red.400}"
},
plain: {
hoverBackground: "{surface.800}",
activeBackground: "{surface.700}",
color: "{surface.0}"
}
},
link: {
color: "{primary.color}",
hoverColor: "{primary.color}",
activeColor: "{primary.color}"
}
}
}
};
var index$1g = {
root: {
background: "{content.background}",
borderRadius: "{border.radius.xl}",
color: "{content.color}",
shadow: "0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px -1px rgba(0, 0, 0, 0.1)"
},
body: {
padding: "1.25rem",
gap: "0.5rem"
},
caption: {
gap: "0.5rem"
},
title: {
fontSize: "1.25rem",
fontWeight: "500"
},
subtitle: {
color: "{text.muted.color}"
}
};
var index$1f = {
root: {
transitionDuration: "{transition.duration}"
},
content: {
gap: "0.25rem"
},
indicatorList: {
padding: "1rem",
gap: "0.5rem"
},
indicator: {
width: "2rem",
height: "0.5rem",
borderRadius: "{content.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
colorScheme: {
light: {
indicator: {
background: "{surface.200}",
hoverBackground: "{surface.300}",
activeBackground: "{primary.color}"
}
},
dark: {
indicator: {
background: "{surface.700}",
hoverBackground: "{surface.600}",
activeBackground: "{primary.color}"
}
}
}
};
var index$1e = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledHoverBackground: "{form.field.filled.hover.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
dropdown: {
width: "2.5rem",
color: "{form.field.icon.color}"
},
overlay: {
background: "{overlay.select.background}",
borderColor: "{overlay.select.border.color}",
borderRadius: "{overlay.select.border.radius}",
color: "{overlay.select.color}",
shadow: "{overlay.select.shadow}"
},
list: {
padding: "{list.padding}",
gap: "{list.gap}",
mobileIndent: "1rem"
},
option: {
focusBackground: "{list.option.focus.background}",
selectedBackground: "{list.option.selected.background}",
selectedFocusBackground: "{list.option.selected.focus.background}",
color: "{list.option.color}",
focusColor: "{list.option.focus.color}",
selectedColor: "{list.option.selected.color}",
selectedFocusColor: "{list.option.selected.focus.color}",
padding: "{list.option.padding}",
borderRadius: "{list.option.border.radius}",
icon: {
color: "{list.option.icon.color}",
focusColor: "{list.option.icon.focus.color}",
size: "0.875rem"
}
}
};
var index$1d = {
root: {
borderRadius: "{border.radius.sm}",
width: "1.25rem",
height: "1.25rem",
background: "{form.field.background}",
checkedBackground: "{primary.color}",
checkedHoverBackground: "{primary.hover.color}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.border.color}",
checkedBorderColor: "{primary.color}",
checkedHoverBorderColor: "{primary.hover.color}",
checkedFocusBorderColor: "{primary.color}",
checkedDisabledBorderColor: "{form.field.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
shadow: "{form.field.shadow}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
icon: {
size: "0.875rem",
color: "{form.field.color}",
checkedColor: "{primary.contrast.color}",
checkedHoverColor: "{primary.contrast.color}",
disabledColor: "{form.field.disabled.color}"
}
};
var index$1c = {
root: {
borderRadius: "16px",
paddingX: "0.75rem",
paddingY: "0.5rem",
gap: "0.5rem",
transitionDuration: "{transition.duration}"
},
image: {
width: "2rem",
height: "2rem"
},
icon: {
size: "1rem"
},
removeIcon: {
size: "1rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
}
},
colorScheme: {
light: {
root: {
background: "{surface.100}",
color: "{surface.800}"
},
icon: {
color: "{surface.800}"
},
removeIcon: {
color: "{surface.800}"
}
},
dark: {
root: {
background: "{surface.800}",
color: "{surface.0}"
},
icon: {
color: "{surface.0}"
},
removeIcon: {
color: "{surface.0}"
}
}
}
};
var index$1b = {
root: {
transitionDuration: "{transition.duration}"
},
preview: {
width: "1.5rem",
height: "1.5rem",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
panel: {
shadow: "{overlay.popover.shadow}",
borderRadius: "{overlay.popover.borderRadius}"
},
colorScheme: {
light: {
panel: {
background: "{surface.800}",
borderColor: "{surface.900}"
},
handle: {
color: "{surface.0}"
}
},
dark: {
panel: {
background: "{surface.900}",
borderColor: "{surface.700}"
},
handle: {
color: "{surface.0}"
}
}
}
};
var index$1a = {
icon: {
size: "2rem",
color: "{overlay.modal.color}"
},
content: {
gap: "1rem"
}
};
var index$19 = {
root: {
background: "{overlay.popover.background}",
borderColor: "{overlay.popover.border.color}",
color: "{overlay.popover.color}",
borderRadius: "{overlay.popover.border.radius}",
shadow: "{overlay.popover.shadow}",
gutter: "10px",
arrowOffset: "1.25rem"
},
content: {
padding: "{overlay.popover.padding}",
gap: "1rem"
},
icon: {
size: "1.5rem",
color: "{overlay.popover.color}"
},
footer: {
gap: "0.5rem",
padding: "0 {overlay.popover.padding} {overlay.popover.padding} {overlay.popover.padding}"
}
};
var index$18 = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
borderRadius: "{content.border.radius}",
shadow: "{overlay.navigation.shadow}",
transitionDuration: "{transition.duration}"
},
list: {
padding: "{navigation.list.padding}",
gap: "{navigation.list.gap}"
},
item: {
focusBackground: "{navigation.item.focus.background}",
activeBackground: "{navigation.item.active.background}",
color: "{navigation.item.color}",
focusColor: "{navigation.item.focus.color}",
activeColor: "{navigation.item.active.color}",
padding: "{navigation.item.padding}",
borderRadius: "{navigation.item.border.radius}",
gap: "{navigation.item.gap}",
icon: {
color: "{navigation.item.icon.color}",
focusColor: "{navigation.item.icon.focus.color}",
activeColor: "{navigation.item.icon.active.color}"
}
},
submenu: {
mobileIndent: "1rem"
},
submenuIcon: {
size: "{navigation.submenu.icon.size}",
color: "{navigation.submenu.icon.color}",
focusColor: "{navigation.submenu.icon.focus.color}",
activeColor: "{navigation.submenu.icon.active.color}"
},
separator: {
borderColor: "{content.border.color}"
}
};
var index$17 = {
root: {
transitionDuration: "{transition.duration}"
},
header: {
background: "{content.background}",
borderColor: "{datatable.border.color}",
color: "{content.color}",
borderWidth: "0 0 1px 0",
padding: "0.75rem 1rem"
},
headerCell: {
background: "{content.background}",
hoverBackground: "{content.hover.background}",
selectedBackground: "{highlight.background}",
borderColor: "{datatable.border.color}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
selectedColor: "{highlight.color}",
gap: "0.5rem",
padding: "0.75rem 1rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "-1px",
shadow: "{focus.ring.shadow}"
}
},
columnTitle: {
fontWeight: "600"
},
row: {
background: "{content.background}",
hoverBackground: "{content.hover.background}",
selectedBackground: "{highlight.background}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
selectedColor: "{highlight.color}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "-1px",
shadow: "{focus.ring.shadow}"
}
},
bodyCell: {
borderColor: "{datatable.border.color}",
padding: "0.75rem 1rem"
},
footerCell: {
background: "{content.background}",
borderColor: "{datatable.border.color}",
color: "{content.color}",
padding: "0.75rem 1rem"
},
columnFooter: {
fontWeight: "600"
},
footer: {
background: "{content.background}",
borderColor: "{datatable.border.color}",
color: "{content.color}",
borderWidth: "0 0 1px 0",
padding: "0.75rem 1rem"
},
dropPointColor: "{primary.color}",
columnResizerWidth: "0.5rem",
resizeIndicator: {
width: "1px",
color: "{primary.color}"
},
sortIcon: {
color: "{text.muted.color}",
hoverColor: "{text.hover.muted.color}"
},
loadingIcon: {
size: "2rem"
},
rowToggleButton: {
hoverBackground: "{content.hover.background}",
selectedHoverBackground: "{content.background}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
selectedHoverColor: "{primary.color}",
size: "1.75rem",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
filter: {
inlineGap: "0.5rem",
overlaySelect: {
background: "{overlay.select.background}",
borderColor: "{overlay.select.border.color}",
borderRadius: "{overlay.select.border.radius}",
color: "{overlay.select.color}",
shadow: "{overlay.select.shadow}"
},
overlayPopover: {
background: "{overlay.popover.background}",
borderColor: "{overlay.popover.border.color}",
borderRadius: "{overlay.popover.border.radius}",
color: "{overlay.popover.color}",
shadow: "{overlay.popover.shadow}",
padding: "{overlay.popover.padding}",
gap: "0.5rem"
},
rule: {
borderColor: "{content.border.color}"
},
constraintList: {
padding: "{list.padding}",
gap: "{list.gap}"
},
constraint: {
focusBackground: "{list.option.focus.background}",
selectedBackground: "{list.option.selected.background}",
selectedFocusBackground: "{list.option.selected.focus.background}",
color: "{list.option.color}",
focusColor: "{list.option.focus.color}",
selectedColor: "{list.option.selected.color}",
selectedFocusColor: "{list.option.selected.focus.color}",
separator: {
borderColor: "{content.border.color}"
},
padding: "{list.option.padding}",
borderRadius: "{list.option.border.radius}"
}
},
paginatorTop: {
borderColor: "{datatable.border.color}",
borderWidth: "0 0 1px 0"
},
paginatorBottom: {
borderColor: "{datatable.border.color}",
borderWidth: "0 0 1px 0"
},
colorScheme: {
light: {
root: {
borderColor: "{content.border.color}"
},
row: {
stripedBackground: "{surface.50}"
},
bodyCell: {
selectedBorderColor: "{primary.100}"
}
},
dark: {
root: {
borderColor: "{surface.800}"
},
row: {
stripedBackground: "{surface.950}"
},
bodyCell: {
selectedBorderColor: "{primary.900}"
}
}
}
};
var index$16 = {
root: {
borderColor: "transparent",
borderWidth: "0",
borderRadius: "0",
padding: "0"
},
header: {
background: "{content.background}",
color: "{content.color}",
borderColor: "{content.border.color}",
borderWidth: "0 0 1px 0",
padding: "0.75rem 1rem",
borderRadius: "0"
},
content: {
background: "{content.background}",
color: "{content.color}",
borderColor: "transparent",
borderWidth: "0",
padding: "0",
borderRadius: "0"
},
footer: {
background: "{content.background}",
color: "{content.color}",
borderColor: "{content.border.color}",
borderWidth: "1px 0 0 0",
padding: "0.75rem 1rem",
borderRadius: "0"
},
paginatorTop: {
borderColor: "{content.border.color}",
borderWidth: "0 0 1px 0"
},
paginatorBottom: {
borderColor: "{content.border.color}",
borderWidth: "1px 0 0 0"
}
};
var index$15 = {
root: {
transitionDuration: "{transition.duration}"
},
panel: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
borderRadius: "{content.border.radius}",
shadow: "{overlay.popover.shadow}",
padding: "{overlay.popover.padding}"
},
header: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
padding: "0 0 0.5rem 0",
fontWeight: "500",
gap: "0.5rem"
},
title: {
gap: "0.5rem",
fontWeight: "500"
},
dropdown: {
width: "2.5rem",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.border.color}",
activeBorderColor: "{form.field.border.color}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
inputIcon: {
color: "{form.field.icon.color}"
},
selectMonth: {
hoverBackground: "{content.hover.background}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
padding: "0.25rem 0.5rem",
borderRadius: "{content.border.radius}"
},
selectYear: {
hoverBackground: "{content.hover.background}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
padding: "0.25rem 0.5rem",
borderRadius: "{content.border.radius}"
},
group: {
borderColor: "{content.border.color}",
gap: "{overlay.popover.padding}"
},
dayView: {
margin: "0.5rem 0 0 0"
},
weekDay: {
padding: "0.25rem",
fontWeight: "500",
color: "{content.color}"
},
date: {
hoverBackground: "{content.hover.background}",
selectedBackground: "{primary.color}",
rangeSelectedBackground: "{highlight.background}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
selectedColor: "{primary.contrast.color}",
rangeSelectedColor: "{highlight.color}",
width: "2rem",
height: "2rem",
borderRadius: "50%",
padding: "0.25rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
monthView: {
margin: "0.5rem 0 0 0"
},
month: {
padding: "0.375rem",
borderRadius: "{content.border.radius}"
},
yearView: {
margin: "0.5rem 0 0 0"
},
year: {
padding: "0.375rem",
borderRadius: "{content.border.radius}"
},
buttonbar: {
padding: "0.5rem 0 0 0",
borderColor: "{content.border.color}"
},
timePicker: {
padding: "0.5rem 0 0 0",
borderColor: "{content.border.color}",
gap: "0.5rem",
buttonGap: "0.25rem"
},
colorScheme: {
light: {
dropdown: {
background: "{surface.100}",
hoverBackground: "{surface.200}",
activeBackground: "{surface.300}",
color: "{surface.600}",
hoverColor: "{surface.700}",
activeColor: "{surface.800}"
},
today: {
background: "{surface.200}",
color: "{surface.900}"
}
},
dark: {
dropdown: {
background: "{surface.800}",
hoverBackground: "{surface.700}",
activeBackground: "{surface.600}",
color: "{surface.300}",
hoverColor: "{surface.200}",
activeColor: "{surface.100}"
},
today: {
background: "{surface.700}",
color: "{surface.0}"
}
}
}
};
var index$14 = {
root: {
background: "{overlay.modal.background}",
borderColor: "{overlay.modal.border.color}",
color: "{overlay.modal.color}",
borderRadius: "{overlay.modal.border.radius}",
shadow: "{overlay.modal.shadow}"
},
header: {
padding: "{overlay.modal.padding}",
gap: "0.5rem"
},
title: {
fontSize: "1.25rem",
fontWeight: "600"
},
content: {
padding: "0 {overlay.modal.padding} {overlay.modal.padding} {overlay.modal.padding}"
},
footer: {
padding: "0 {overlay.modal.padding} {overlay.modal.padding} {overlay.modal.padding}",
gap: "0.5rem"
}
};
var index$13 = {
root: {
borderColor: "{content.border.color}"
},
content: {
background: "{content.background}",
color: "{text.color}"
},
horizontal: {
margin: "1rem 0",
padding: "0 1rem",
content: {
padding: "0 0.5rem"
}
},
vertical: {
margin: "0 1rem",
padding: "0.5rem 0",
content: {
padding: "0.5rem 0"
}
}
};
var index$12 = {
root: {
background: "rgba(255, 255, 255, 0.1)",
borderColor: "rgba(255, 255, 255, 0.2)",
padding: "0.5rem",
borderRadius: "{border.radius.xl}"
},
item: {
borderRadius: "{content.border.radius}",
padding: "0.5rem",
size: "3rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
}
};
var index$11 = {
root: {
background: "{overlay.modal.background}",
borderColor: "{overlay.modal.border.color}",
color: "{overlay.modal.color}",
borderRadius: "{overlay.modal.border.radius}",
shadow: "{overlay.modal.shadow}"
},
header: {
padding: "{overlay.modal.padding}"
},
title: {
fontSize: "1.5rem",
fontWeight: "600"
},
content: {
padding: "0 {overlay.modal.padding} {overlay.modal.padding} {overlay.modal.padding}"
}
};
var index$10 = {
toolbar: {
background: "{content.background}",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}"
},
toolbarItem: {
color: "{text.muted.color}",
hoverColor: "{text.color}",
activeColor: "{primary.color}"
},
overlay: {
background: "{overlay.select.background}",
borderColor: "{overlay.select.border.color}",
borderRadius: "{overlay.select.border.radius}",
color: "{overlay.select.color}",
shadow: "{overlay.select.shadow}",
padding: "{list.padding}"
},
overlayOption: {
focusBackground: "{list.option.focus.background}",
color: "{list.option.color}",
focusColor: "{list.option.focus.color}",
padding: "{list.option.padding}",
borderRadius: "{list.option.border.radius}"
},
content: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
borderRadius: "{content.border.radius}"
}
};
var index$$ = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}",
color: "{content.color}",
padding: "0 1.125rem 1.125rem 1.125rem",
transitionDuration: "{transition.duration}"
},
legend: {
background: "{content.background}",
hoverBackground: "{content.hover.background}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
borderRadius: "{content.border.radius}",
borderWidth: "1px",
borderColor: "transparent",
padding: "0.5rem 0.75rem",
gap: "0.5rem",
fontWeight: "600",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
toggleIcon: {
color: "{text.muted.color}",
hoverColor: "{text.hover.muted.color}"
},
content: {
padding: "0"
}
};
var index$_ = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
borderRadius: "{content.border.radius}",
transitionDuration: "{transition.duration}"
},
header: {
background: "transparent",
color: "{text.color}",
padding: "1.125rem",
borderWidth: "0",
borderRadius: "0",
gap: "0.5rem"
},
content: {
highlightBorderColor: "{primary.color}",
padding: "0 1.125rem 1.125rem 1.125rem"
},
file: {
padding: "1rem",
gap: "1rem",
borderColor: "{content.border.color}",
info: {
gap: "0.5rem"
}
},
progressbar: {
height: "0.25rem"
},
basic: {
gap: "0.5rem"
}
};
var index$Z = {
root: {
color: "{form.field.float.label.color}",
focusColor: "{form.field.float.label.focus.color}",
activeColor: "{form.field.float.label.active.color}",
invalidColor: "{form.field.float.label.invalid.color}",
transitionDuration: "0.2s",
positionX: "{form.field.padding.x}",
positionY: "{form.field.padding.y}",
fontWeight: "500",
active: {
fontSize: "0.75rem",
fontWeight: "400"
}
},
over: {
active: {
top: "-1.25rem"
}
},
"in": {
input: {
paddingTop: "1.5rem",
paddingBottom: "{form.field.padding.y}"
},
active: {
top: "{form.field.padding.y}"
}
},
on: {
borderRadius: "{border.radius.xs}",
active: {
background: "{form.field.background}",
padding: "0 0.125rem"
}
}
};
var index$Y = {
root: {
borderWidth: "1px",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}",
transitionDuration: "{transition.duration}"
},
navButton: {
background: "rgba(255, 255, 255, 0.1)",
hoverBackground: "rgba(255, 255, 255, 0.2)",
color: "{surface.100}",
hoverColor: "{surface.0}",
size: "3rem",
gutter: "0.5rem",
prev: {
borderRadius: "50%"
},
next: {
borderRadius: "50%"
},
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
navIcon: {
size: "1.5rem"
},
thumbnailsContent: {
background: "{content.background}",
padding: "1rem 0.25rem"
},
thumbnailNavButton: {
size: "2rem",
borderRadius: "{content.border.radius}",
gutter: "0.5rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
thumbnailNavButtonIcon: {
size: "1rem"
},
caption: {
background: "rgba(0, 0, 0, 0.5)",
color: "{surface.100}",
padding: "1rem"
},
indicatorList: {
gap: "0.5rem",
padding: "1rem"
},
indicatorButton: {
width: "1rem",
height: "1rem",
activeBackground: "{primary.color}",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
insetIndicatorList: {
background: "rgba(0, 0, 0, 0.5)"
},
insetIndicatorButton: {
background: "rgba(255, 255, 255, 0.4)",
hoverBackground: "rgba(255, 255, 255, 0.6)",
activeBackground: "rgba(255, 255, 255, 0.9)"
},
mask: {
background: "{mask.background}",
color: "{mask.color}"
},
closeButton: {
size: "3rem",
gutter: "0.5rem",
background: "rgba(255, 255, 255, 0.1)",
hoverBackground: "rgba(255, 255, 255, 0.2)",
color: "{surface.50}",
hoverColor: "{surface.0}",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
closeButtonIcon: {
size: "1.5rem"
},
colorScheme: {
light: {
thumbnailNavButton: {
hoverBackground: "{surface.100}",
color: "{surface.600}",
hoverColor: "{surface.700}"
},
indicatorButton: {
background: "{surface.200}",
hoverBackground: "{surface.300}"
}
},
dark: {
thumbnailNavButton: {
hoverBackground: "{surface.700}",
color: "{surface.400}",
hoverColor: "{surface.0}"
},
indicatorButton: {
background: "{surface.700}",
hoverBackground: "{surface.600}"
}
}
}
};
var index$X = {
icon: {
color: "{form.field.icon.color}"
}
};
var index$W = {
root: {
color: "{form.field.float.label.color}",
focusColor: "{form.field.float.label.focus.color}",
invalidColor: "{form.field.float.label.invalid.color}",
transitionDuration: "0.2s",
positionX: "{form.field.padding.x}",
top: "{form.field.padding.y}",
fontSize: "0.75rem",
fontWeight: "400"
},
input: {
paddingTop: "1.5rem",
paddingBottom: "{form.field.padding.y}"
}
};
var index$V = {
root: {
transitionDuration: "{transition.duration}"
},
preview: {
icon: {
size: "1.5rem"
},
mask: {
background: "{mask.background}",
color: "{mask.color}"
}
},
toolbar: {
position: {
left: "auto",
right: "1rem",
top: "1rem",
bottom: "auto"
},
blur: "8px",
background: "rgba(255,255,255,0.1)",
borderColor: "rgba(255,255,255,0.2)",
borderWidth: "1px",
borderRadius: "30px",
padding: ".5rem",
gap: "0.5rem"
},
action: {
hoverBackground: "rgba(255,255,255,0.1)",
color: "{surface.50}",
hoverColor: "{surface.0}",
size: "3rem",
iconSize: "1.5rem",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
}
};
var index$U = {
handle: {
size: "15px",
hoverSize: "30px",
background: "rgba(255,255,255,0.3)",
hoverBackground: "rgba(255,255,255,0.3)",
borderColor: "unset",
hoverBorderColor: "unset",
borderWidth: "0",
borderRadius: "50%",
transitionDuration: "{transition.duration}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "rgba(255,255,255,0.3)",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
}
};
var index$T = {
root: {
padding: "{form.field.padding.y} {form.field.padding.x}",
borderRadius: "{content.border.radius}",
gap: "0.5rem"
},
text: {
fontWeight: "500"
},
icon: {
size: "1rem"
},
colorScheme: {
light: {
info: {
background: "color-mix(in srgb, {blue.50}, transparent 5%)",
borderColor: "{blue.200}",
color: "{blue.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {blue.500}, transparent 96%)"
},
success: {
background: "color-mix(in srgb, {green.50}, transparent 5%)",
borderColor: "{green.200}",
color: "{green.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {green.500}, transparent 96%)"
},
warn: {
background: "color-mix(in srgb,{yellow.50}, transparent 5%)",
borderColor: "{yellow.200}",
color: "{yellow.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {yellow.500}, transparent 96%)"
},
error: {
background: "color-mix(in srgb, {red.50}, transparent 5%)",
borderColor: "{red.200}",
color: "{red.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {red.500}, transparent 96%)"
},
secondary: {
background: "{surface.100}",
borderColor: "{surface.200}",
color: "{surface.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.500}, transparent 96%)"
},
contrast: {
background: "{surface.900}",
borderColor: "{surface.950}",
color: "{surface.50}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.950}, transparent 96%)"
}
},
dark: {
info: {
background: "color-mix(in srgb, {blue.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {blue.700}, transparent 64%)",
color: "{blue.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {blue.500}, transparent 96%)"
},
success: {
background: "color-mix(in srgb, {green.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {green.700}, transparent 64%)",
color: "{green.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {green.500}, transparent 96%)"
},
warn: {
background: "color-mix(in srgb, {yellow.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {yellow.700}, transparent 64%)",
color: "{yellow.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {yellow.500}, transparent 96%)"
},
error: {
background: "color-mix(in srgb, {red.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {red.700}, transparent 64%)",
color: "{red.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {red.500}, transparent 96%)"
},
secondary: {
background: "{surface.800}",
borderColor: "{surface.700}",
color: "{surface.300}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.500}, transparent 96%)"
},
contrast: {
background: "{surface.0}",
borderColor: "{surface.100}",
color: "{surface.950}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.950}, transparent 96%)"
}
}
}
};
var index$S = {
root: {
padding: "{form.field.padding.y} {form.field.padding.x}",
borderRadius: "{content.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
transitionDuration: "{transition.duration}"
},
display: {
hoverBackground: "{content.hover.background}",
hoverColor: "{content.hover.color}"
}
};
var index$R = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
chip: {
borderRadius: "{border.radius.sm}"
},
colorScheme: {
light: {
chip: {
focusBackground: "{surface.200}",
color: "{surface.800}"
}
},
dark: {
chip: {
focusBackground: "{surface.700}",
color: "{surface.0}"
}
}
}
};
var index$Q = {
addon: {
background: "{form.field.background}",
borderColor: "{form.field.border.color}",
color: "{form.field.icon.color}",
borderRadius: "{form.field.border.radius}",
padding: "0.5rem",
minWidth: "2.5rem"
}
};
var index$P = {
root: {
transitionDuration: "{transition.duration}"
},
button: {
width: "2.5rem",
borderRadius: "{form.field.border.radius}",
verticalPadding: "{form.field.padding.y}"
},
colorScheme: {
light: {
button: {
background: "transparent",
hoverBackground: "{surface.100}",
activeBackground: "{surface.200}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.border.color}",
activeBorderColor: "{form.field.border.color}",
color: "{surface.400}",
hoverColor: "{surface.500}",
activeColor: "{surface.600}"
}
},
dark: {
button: {
background: "transparent",
hoverBackground: "{surface.800}",
activeBackground: "{surface.700}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.border.color}",
activeBorderColor: "{form.field.border.color}",
color: "{surface.400}",
hoverColor: "{surface.300}",
activeColor: "{surface.200}"
}
}
}
};
var index$O = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledHoverBackground: "{form.field.filled.hover.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}",
sm: {
fontSize: "0.875rem",
paddingX: "0.625rem",
paddingY: "0.375rem"
},
lg: {
fontSize: "1.125rem",
paddingX: "0.875rem",
paddingY: "0.625rem"
}
}
};
var index$N = {
root: {
transitionDuration: "{transition.duration}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
value: {
background: "{primary.color}"
},
range: {
background: "{content.border.color}"
},
text: {
color: "{text.muted.color}"
}
};
var index$M = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
shadow: "{form.field.shadow}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
list: {
padding: "{list.padding}",
gap: "{list.gap}",
header: {
padding: "{list.header.padding}"
}
},
option: {
focusBackground: "{list.option.focus.background}",
selectedBackground: "{list.option.selected.background}",
selectedFocusBackground: "{list.option.selected.focus.background}",
color: "{list.option.color}",
focusColor: "{list.option.focus.color}",
selectedColor: "{list.option.selected.color}",
selectedFocusColor: "{list.option.selected.focus.color}",
padding: "{list.option.padding}",
borderRadius: "{list.option.border.radius}"
},
optionGroup: {
background: "{list.option.group.background}",
color: "{list.option.group.color}",
fontWeight: "{list.option.group.font.weight}",
padding: "{list.option.group.padding}"
},
checkmark: {
color: "{list.option.color}",
gutterStart: "-0.375rem",
gutterEnd: "0.375rem"
},
emptyMessage: {
padding: "{list.option.padding}"
},
colorScheme: {
light: {
option: {
stripedBackground: "{surface.50}"
}
},
dark: {
option: {
stripedBackground: "{surface.900}"
}
}
}
};
var index$L = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}",
color: "{content.color}",
gap: "0.5rem",
verticalOrientation: {
padding: "{navigation.list.padding}",
gap: "0"
},
horizontalOrientation: {
padding: "0.5rem 0.75rem"
},
transitionDuration: "{transition.duration}"
},
baseItem: {
borderRadius: "{content.border.radius}",
padding: "{navigation.item.padding}"
},
item: {
focusBackground: "{navigation.item.focus.background}",
activeBackground: "{navigation.item.active.background}",
color: "{navigation.item.color}",
focusColor: "{navigation.item.focus.color}",
activeColor: "{navigation.item.active.color}",
padding: "{navigation.item.padding}",
borderRadius: "{navigation.item.border.radius}",
gap: "{navigation.item.gap}",
icon: {
color: "{navigation.item.icon.color}",
focusColor: "{navigation.item.icon.focus.color}",
activeColor: "{navigation.item.icon.active.color}"
}
},
overlay: {
padding: "0",
background: "{content.background}",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}",
color: "{content.color}",
shadow: "{overlay.navigation.shadow}",
gap: "0.5rem"
},
submenu: {
padding: "{navigation.list.padding}",
gap: "{navigation.list.gap}"
},
submenuLabel: {
padding: "{navigation.submenu.label.padding}",
fontWeight: "{navigation.submenu.label.font.weight}",
background: "{navigation.submenu.label.background.}",
color: "{navigation.submenu.label.color}"
},
submenuIcon: {
size: "{navigation.submenu.icon.size}",
color: "{navigation.submenu.icon.color}",
focusColor: "{navigation.submenu.icon.focus.color}",
activeColor: "{navigation.submenu.icon.active.color}"
},
separator: {
borderColor: "{content.border.color}"
},
mobileButton: {
borderRadius: "50%",
size: "1.75rem",
color: "{text.muted.color}",
hoverColor: "{text.muted.hover.color}",
hoverBackground: "{content.hover.background}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
}
};
var index$K = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
borderRadius: "{content.border.radius}",
shadow: "{overlay.navigation.shadow}",
transitionDuration: "{transition.duration}"
},
list: {
padding: "{navigation.list.padding}",
gap: "{navigation.list.gap}"
},
item: {
focusBackground: "{navigation.item.focus.background}",
color: "{navigation.item.color}",
focusColor: "{navigation.item.focus.color}",
padding: "{navigation.item.padding}",
borderRadius: "{navigation.item.border.radius}",
gap: "{navigation.item.gap}",
icon: {
color: "{navigation.item.icon.color}",
focusColor: "{navigation.item.icon.focus.color}"
}
},
submenuLabel: {
padding: "{navigation.submenu.label.padding}",
fontWeight: "{navigation.submenu.label.font.weight}",
background: "{navigation.submenu.label.background}",
color: "{navigation.submenu.label.color}"
},
separator: {
borderColor: "{content.border.color}"
}
};
var index$J = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}",
color: "{content.color}",
gap: "0.5rem",
padding: "0.5rem 0.75rem",
transitionDuration: "{transition.duration}"
},
baseItem: {
borderRadius: "{content.border.radius}",
padding: "{navigation.item.padding}"
},
item: {
focusBackground: "{navigation.item.focus.background}",
activeBackground: "{navigation.item.active.background}",
color: "{navigation.item.color}",
focusColor: "{navigation.item.focus.color}",
activeColor: "{navigation.item.active.color}",
padding: "{navigation.item.padding}",
borderRadius: "{navigation.item.border.radius}",
gap: "{navigation.item.gap}",
icon: {
color: "{navigation.item.icon.color}",
focusColor: "{navigation.item.icon.focus.color}",
activeColor: "{navigation.item.icon.active.color}"
}
},
submenu: {
padding: "{navigation.list.padding}",
gap: "{navigation.list.gap}",
background: "{content.background}",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}",
shadow: "{overlay.navigation.shadow}",
mobileIndent: "1rem"
},
submenuIcon: {
size: "{navigation.submenu.icon.size}",
color: "{navigation.submenu.icon.color}",
focusColor: "{navigation.submenu.icon.focus.color}",
activeColor: "{navigation.submenu.icon.active.color}"
},
separator: {
borderColor: "{content.border.color}"
},
mobileButton: {
borderRadius: "50%",
size: "1.75rem",
color: "{text.muted.color}",
hoverColor: "{text.muted.hover.color}",
hoverBackground: "{content.hover.background}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
}
};
var index$I = {
root: {
borderRadius: "{content.border.radius}",
borderWidth: "1px",
transitionDuration: "{transition.duration}"
},
content: {
padding: "0.5rem 0.75rem",
gap: "0.5rem"
},
text: {
fontSize: "1rem",
fontWeight: "500"
},
icon: {
size: "1.125rem"
},
closeButton: {
width: "1.75rem",
height: "1.75rem",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
offset: "{focus.ring.offset}"
}
},
closeIcon: {
size: "1rem"
},
colorScheme: {
light: {
info: {
background: "color-mix(in srgb, {blue.50}, transparent 5%)",
borderColor: "{blue.200}",
color: "{blue.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {blue.500}, transparent 96%)",
closeButton: {
hoverBackground: "{blue.100}",
focusRing: {
color: "{blue.600}",
shadow: "none"
}
}
},
success: {
background: "color-mix(in srgb, {green.50}, transparent 5%)",
borderColor: "{green.200}",
color: "{green.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {green.500}, transparent 96%)",
closeButton: {
hoverBackground: "{green.100}",
focusRing: {
color: "{green.600}",
shadow: "none"
}
}
},
warn: {
background: "color-mix(in srgb,{yellow.50}, transparent 5%)",
borderColor: "{yellow.200}",
color: "{yellow.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {yellow.500}, transparent 96%)",
closeButton: {
hoverBackground: "{yellow.100}",
focusRing: {
color: "{yellow.600}",
shadow: "none"
}
}
},
error: {
background: "color-mix(in srgb, {red.50}, transparent 5%)",
borderColor: "{red.200}",
color: "{red.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {red.500}, transparent 96%)",
closeButton: {
hoverBackground: "{red.100}",
focusRing: {
color: "{red.600}",
shadow: "none"
}
}
},
secondary: {
background: "{surface.100}",
borderColor: "{surface.200}",
color: "{surface.600}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.500}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.200}",
focusRing: {
color: "{surface.600}",
shadow: "none"
}
}
},
contrast: {
background: "{surface.900}",
borderColor: "{surface.950}",
color: "{surface.50}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.950}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.800}",
focusRing: {
color: "{surface.50}",
shadow: "none"
}
}
}
},
dark: {
info: {
background: "color-mix(in srgb, {blue.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {blue.700}, transparent 64%)",
color: "{blue.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {blue.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{blue.500}",
shadow: "none"
}
}
},
success: {
background: "color-mix(in srgb, {green.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {green.700}, transparent 64%)",
color: "{green.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {green.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{green.500}",
shadow: "none"
}
}
},
warn: {
background: "color-mix(in srgb, {yellow.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {yellow.700}, transparent 64%)",
color: "{yellow.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {yellow.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{yellow.500}",
shadow: "none"
}
}
},
error: {
background: "color-mix(in srgb, {red.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {red.700}, transparent 64%)",
color: "{red.500}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {red.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{red.500}",
shadow: "none"
}
}
},
secondary: {
background: "{surface.800}",
borderColor: "{surface.700}",
color: "{surface.300}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.500}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.700}",
focusRing: {
color: "{surface.300}",
shadow: "none"
}
}
},
contrast: {
background: "{surface.0}",
borderColor: "{surface.100}",
color: "{surface.950}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.950}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.100}",
focusRing: {
color: "{surface.950}",
shadow: "none"
}
}
}
}
}
};
var index$H = {
root: {
borderRadius: "{content.border.radius}",
gap: "1rem"
},
meters: {
background: "{content.border.color}",
size: "0.5rem"
},
label: {
gap: "0.5rem"
},
labelMarker: {
size: "0.5rem"
},
labelIcon: {
size: "1rem"
},
labelList: {
verticalGap: "0.5rem",
horizontalGap: "1rem"
}
};
var index$G = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledHoverBackground: "{form.field.filled.hover.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
dropdown: {
width: "2.5rem",
color: "{form.field.icon.color}"
},
overlay: {
background: "{overlay.select.background}",
borderColor: "{overlay.select.border.color}",
borderRadius: "{overlay.select.border.radius}",
color: "{overlay.select.color}",
shadow: "{overlay.select.shadow}"
},
list: {
padding: "{list.padding}",
gap: "{list.gap}",
header: {
padding: "{list.header.padding}"
}
},
option: {
focusBackground: "{list.option.focus.background}",
selectedBackground: "{list.option.selected.background}",
selectedFocusBackground: "{list.option.selected.focus.background}",
color: "{list.option.color}",
focusColor: "{list.option.focus.color}",
selectedColor: "{list.option.selected.color}",
selectedFocusColor: "{list.option.selected.focus.color}",
padding: "{list.option.padding}",
borderRadius: "{list.option.border.radius}",
gap: "0.5rem"
},
optionGroup: {
background: "{list.option.group.background}",
color: "{list.option.group.color}",
fontWeight: "{list.option.group.font.weight}",
padding: "{list.option.group.padding}"
},
chip: {
borderRadius: "{border.radius.sm}"
},
emptyMessage: {
padding: "{list.option.padding}"
}
};
var index$F = {
root: {
gap: "1.125rem"
},
controls: {
gap: "0.5rem"
}
};
var index$E = {
root: {
gutter: "0.75rem",
transitionDuration: "{transition.duration}"
},
node: {
background: "{content.background}",
hoverBackground: "{content.hover.background}",
selectedBackground: "{highlight.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
selectedColor: "{highlight.color}",
hoverColor: "{content.hover.color}",
padding: "0.75rem 1rem",
toggleablePadding: "0.75rem 1rem 1.25rem 1rem",
borderRadius: "{content.border.radius}"
},
nodeToggleButton: {
background: "{content.background}",
hoverBackground: "{content.hover.background}",
borderColor: "{content.border.color}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
size: "1.5rem",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
connector: {
color: "{content.border.color}",
borderRadius: "{content.border.radius}",
height: "24px"
}
};
var index$D = {
root: {
outline: {
width: "2px",
color: "{content.background}"
}
}
};
var index$C = {
root: {
padding: "0.5rem 1rem",
gap: "0.25rem",
borderRadius: "{content.border.radius}",
background: "{content.background}",
color: "{content.color}",
transitionDuration: "{transition.duration}"
},
navButton: {
background: "transparent",
hoverBackground: "{content.hover.background}",
selectedBackground: "{highlight.background}",
color: "{text.muted.color}",
hoverColor: "{text.hover.muted.color}",
selectedColor: "{highlight.color}",
width: "2.5rem",
height: "2.5rem",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
currentPageReport: {
color: "{text.muted.color}"
},
jumpToPageInput: {
maxWidth: "2.5rem"
}
};
var index$B = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
borderRadius: "{content.border.radius}"
},
header: {
background: "transparent",
color: "{text.color}",
padding: "1.125rem",
borderColor: "{content.border.color}",
borderWidth: "0",
borderRadius: "0"
},
toggleableHeader: {
padding: "0.375rem 1.125rem"
},
title: {
fontWeight: "600"
},
content: {
padding: "0 1.125rem 1.125rem 1.125rem"
},
footer: {
padding: "0 1.125rem 1.125rem 1.125rem"
}
};
var index$A = {
root: {
gap: "0.5rem",
transitionDuration: "{transition.duration}"
},
panel: {
background: "{content.background}",
borderColor: "{content.border.color}",
borderWidth: "1px",
color: "{content.color}",
padding: "0.25rem 0.25rem",
borderRadius: "{content.border.radius}",
first: {
borderWidth: "1px",
topBorderRadius: "{content.border.radius}"
},
last: {
borderWidth: "1px",
bottomBorderRadius: "{content.border.radius}"
}
},
item: {
focusBackground: "{navigation.item.focus.background}",
color: "{navigation.item.color}",
focusColor: "{navigation.item.focus.color}",
gap: "0.5rem",
padding: "{navigation.item.padding}",
borderRadius: "{content.border.radius}",
icon: {
color: "{navigation.item.icon.color}",
focusColor: "{navigation.item.icon.focus.color}"
}
},
submenu: {
indent: "1rem"
},
submenuIcon: {
color: "{navigation.submenu.icon.color}",
focusColor: "{navigation.submenu.icon.focus.color}"
}
};
var index$z = {
meter: {
background: "{content.border.color}",
borderRadius: "{content.border.radius}",
height: ".75rem"
},
icon: {
color: "{form.field.icon.color}"
},
overlay: {
background: "{overlay.popover.background}",
borderColor: "{overlay.popover.border.color}",
borderRadius: "{overlay.popover.border.radius}",
color: "{overlay.popover.color}",
padding: "{overlay.popover.padding}",
shadow: "{overlay.popover.shadow}"
},
content: {
gap: "0.5rem"
},
colorScheme: {
light: {
strength: {
weakBackground: "{red.500}",
mediumBackground: "{amber.500}",
strongBackground: "{green.500}"
}
},
dark: {
strength: {
weakBackground: "{red.400}",
mediumBackground: "{amber.400}",
strongBackground: "{green.400}"
}
}
}
};
var index$y = {
root: {
gap: "1.125rem"
},
controls: {
gap: "0.5rem"
}
};
var index$x = {
root: {
background: "{overlay.popover.background}",
borderColor: "{overlay.popover.border.color}",
color: "{overlay.popover.color}",
borderRadius: "{overlay.popover.border.radius}",
shadow: "{overlay.popover.shadow}",
gutter: "10px",
arrowOffset: "1.25rem"
},
content: {
padding: "{overlay.popover.padding}"
}
};
var index$w = {
root: {
background: "{content.border.color}",
borderRadius: "{content.border.radius}",
height: "1.25rem"
},
value: {
background: "{primary.color}"
},
label: {
color: "{primary.contrast.color}",
fontSize: "0.75rem",
fontWeight: "600"
}
};
var index$v = {
colorScheme: {
light: {
root: {
"color.1": "{red.500}",
"color.2": "{blue.500}",
"color.3": "{green.500}",
"color.4": "{yellow.500}"
}
},
dark: {
root: {
"color.1": "{red.400}",
"color.2": "{blue.400}",
"color.3": "{green.400}",
"color.4": "{yellow.400}"
}
}
}
};
var index$u = {
root: {
width: "1.25rem",
height: "1.25rem",
background: "{form.field.background}",
checkedBackground: "{primary.color}",
checkedHoverBackground: "{primary.hover.color}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.border.color}",
checkedBorderColor: "{primary.color}",
checkedHoverBorderColor: "{primary.hover.color}",
checkedFocusBorderColor: "{primary.color}",
checkedDisabledBorderColor: "{form.field.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
shadow: "{form.field.shadow}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
icon: {
size: "0.75rem",
checkedColor: "{primary.contrast.color}",
checkedHoverColor: "{primary.contrast.color}",
disabledColor: "{form.field.disabled.color}"
}
};
var index$t = {
root: {
gap: "0.25rem",
transitionDuration: "{transition.duration}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
icon: {
size: "1rem",
color: "{text.muted.color}",
hoverColor: "{primary.color}",
activeColor: "{primary.color}"
}
};
var index$s = {
colorScheme: {
light: {
root: {
background: "rgba(0,0,0,0.1)"
}
},
dark: {
root: {
background: "rgba(255,255,255,0.3)"
}
}
}
};
var index$r = {
root: {
transitionDuration: "{transition.duration}"
},
bar: {
size: "9px",
borderRadius: "{border.radius.sm}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
colorScheme: {
light: {
bar: {
background: "{surface.100}"
}
},
dark: {
bar: {
background: "{surface.800}"
}
}
}
};
var index$q = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledHoverBackground: "{form.field.filled.hover.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
dropdown: {
width: "2.5rem",
color: "{form.field.icon.color}"
},
overlay: {
background: "{overlay.select.background}",
borderColor: "{overlay.select.border.color}",
borderRadius: "{overlay.select.border.radius}",
color: "{overlay.select.color}",
shadow: "{overlay.select.shadow}"
},
list: {
padding: "{list.padding}",
gap: "{list.gap}",
header: {
padding: "{list.header.padding}"
}
},
option: {
focusBackground: "{list.option.focus.background}",
selectedBackground: "{list.option.selected.background}",
selectedFocusBackground: "{list.option.selected.focus.background}",
color: "{list.option.color}",
focusColor: "{list.option.focus.color}",
selectedColor: "{list.option.selected.color}",
selectedFocusColor: "{list.option.selected.focus.color}",
padding: "{list.option.padding}",
borderRadius: "{list.option.border.radius}"
},
optionGroup: {
background: "{list.option.group.background}",
color: "{list.option.group.color}",
fontWeight: "{list.option.group.font.weight}",
padding: "{list.option.group.padding}"
},
clearIcon: {
color: "{form.field.icon.color}"
},
checkmark: {
color: "{list.option.color}",
gutterStart: "-0.375rem",
gutterEnd: "0.375rem"
},
emptyMessage: {
padding: "{list.option.padding}"
}
};
var index$p = {
root: {
borderRadius: "{form.field.border.radius}"
},
colorScheme: {
light: {
root: {
invalidBorderColor: "{form.field.invalid.border.color}"
}
},
dark: {
root: {
invalidBorderColor: "{form.field.invalid.border.color}"
}
}
}
};
var index$o = {
root: {
borderRadius: "{content.border.radius}"
},
colorScheme: {
light: {
root: {
background: "{surface.200}",
animationBackground: "rgba(255,255,255,0.4)"
}
},
dark: {
root: {
background: "rgba(255, 255, 255, 0.06)",
animationBackground: "rgba(255, 255, 255, 0.04)"
}
}
}
};
var index$n = {
root: {
transitionDuration: "{transition.duration}"
},
track: {
background: "{content.border.color}",
borderRadius: "{content.border.radius}",
size: "3px"
},
range: {
background: "{primary.color}"
},
handle: {
width: "20px",
height: "20px",
borderRadius: "50%",
background: "{content.border.color}",
hoverBackground: "{content.border.color}",
content: {
borderRadius: "50%",
hoverBackground: "{content.background}",
width: "16px",
height: "16px",
shadow: "0px 0.5px 0px 0px rgba(0, 0, 0, 0.08), 0px 1px 1px 0px rgba(0, 0, 0, 0.14)"
},
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
colorScheme: {
light: {
handle: {
contentBackground: "{surface.0}"
}
},
dark: {
handle: {
contentBackground: "{surface.950}"
}
}
}
};
var index$m = {
root: {
gap: "0.5rem",
transitionDuration: "{transition.duration}"
}
};
var index$l = {
root: {
borderRadius: "{form.field.border.radius}",
roundedBorderRadius: "2rem",
raisedShadow: "0 3px 1px -2px rgba(0, 0, 0, 0.2), 0 2px 2px 0 rgba(0, 0, 0, 0.14), 0 1px 5px 0 rgba(0, 0, 0, 0.12)"
}
};
var index$k = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
transitionDuration: "{transition.duration}"
},
gutter: {
background: "{content.border.color}"
},
handle: {
size: "24px",
background: "transparent",
borderRadius: "{content.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
}
};
var index$j = {
root: {
transitionDuration: "{transition.duration}"
},
separator: {
background: "{content.border.color}",
activeBackground: "{primary.color}",
margin: "0 0 0 1.625rem",
size: "2px"
},
step: {
padding: "0.5rem",
gap: "1rem"
},
stepHeader: {
padding: "0",
borderRadius: "{content.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
gap: "0.5rem"
},
stepTitle: {
color: "{text.muted.color}",
activeColor: "{primary.color}",
fontWeight: "500"
},
stepNumber: {
background: "{content.background}",
activeBackground: "{content.background}",
borderColor: "{content.border.color}",
activeBorderColor: "{content.border.color}",
color: "{text.muted.color}",
activeColor: "{primary.color}",
size: "2rem",
fontSize: "1.143rem",
fontWeight: "500",
borderRadius: "50%",
shadow: "0px 0.5px 0px 0px rgba(0, 0, 0, 0.06), 0px 1px 1px 0px rgba(0, 0, 0, 0.12)"
},
steppanels: {
padding: "0.875rem 0.5rem 1.125rem 0.5rem"
},
steppanel: {
background: "{content.background}",
color: "{content.color}",
padding: "0 0 0 1rem"
}
};
var index$i = {
root: {
transitionDuration: "{transition.duration}"
},
separator: {
background: "{content.border.color}"
},
itemLink: {
borderRadius: "{content.border.radius}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
gap: "0.5rem"
},
itemLabel: {
color: "{text.muted.color}",
activeColor: "{primary.color}",
fontWeight: "500"
},
itemNumber: {
background: "{content.background}",
activeBackground: "{content.background}",
borderColor: "{content.border.color}",
activeBorderColor: "{content.border.color}",
color: "{text.muted.color}",
activeColor: "{primary.color}",
size: "2rem",
fontSize: "1.143rem",
fontWeight: "500",
borderRadius: "50%",
shadow: "0px 0.5px 0px 0px rgba(0, 0, 0, 0.06), 0px 1px 1px 0px rgba(0, 0, 0, 0.12)"
}
};
var index$h = {
root: {
transitionDuration: "{transition.duration}"
},
tablist: {
borderWidth: "0 0 1px 0",
background: "{content.background}",
borderColor: "{content.border.color}"
},
item: {
background: "transparent",
hoverBackground: "transparent",
activeBackground: "transparent",
borderWidth: "0 0 1px 0",
borderColor: "{content.border.color}",
hoverBorderColor: "{content.border.color}",
activeBorderColor: "{primary.color}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
activeColor: "{primary.color}",
padding: "1rem 1.125rem",
fontWeight: "600",
margin: "0 0 -1px 0",
gap: "0.5rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
itemIcon: {
color: "{text.muted.color}",
hoverColor: "{text.color}",
activeColor: "{primary.color}"
},
activeBar: {
height: "1px",
bottom: "-1px",
background: "{primary.color}"
}
};
var index$g = {
root: {
transitionDuration: "{transition.duration}"
},
tablist: {
borderWidth: "0 0 1px 0",
background: "{content.background}",
borderColor: "{content.border.color}"
},
tab: {
background: "transparent",
hoverBackground: "transparent",
activeBackground: "transparent",
borderWidth: "0 0 1px 0",
borderColor: "{content.border.color}",
hoverBorderColor: "{content.border.color}",
activeBorderColor: "{primary.color}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
activeColor: "{primary.color}",
padding: "1rem 1.125rem",
fontWeight: "600",
margin: "0 0 -1px 0",
gap: "0.5rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "-1px",
shadow: "{focus.ring.shadow}"
}
},
tabpanel: {
background: "{content.background}",
color: "{content.color}",
padding: "0.875rem 1.125rem 1.125rem 1.125rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "inset {focus.ring.shadow}"
}
},
navButton: {
background: "{content.background}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
width: "2.5rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "-1px",
shadow: "{focus.ring.shadow}"
}
},
activeBar: {
height: "1px",
bottom: "-1px",
background: "{primary.color}"
},
colorScheme: {
light: {
navButton: {
shadow: "0px 0px 10px 50px rgba(255, 255, 255, 0.6)"
}
},
dark: {
navButton: {
shadow: "0px 0px 10px 50px color-mix(in srgb, {content.background}, transparent 50%)"
}
}
}
};
var index$f = {
root: {
transitionDuration: "{transition.duration}"
},
tabList: {
background: "{content.background}",
borderColor: "{content.border.color}"
},
tab: {
borderColor: "{content.border.color}",
activeBorderColor: "{primary.color}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
activeColor: "{primary.color}"
},
tabPanel: {
background: "{content.background}",
color: "{content.color}"
},
navButton: {
background: "{content.background}",
color: "{text.muted.color}",
hoverColor: "{text.color}"
},
colorScheme: {
light: {
navButton: {
shadow: "0px 0px 10px 50px rgba(255, 255, 255, 0.6)"
}
},
dark: {
navButton: {
shadow: "0px 0px 10px 50px color-mix(in srgb, {content.background}, transparent 50%)"
}
}
}
};
var index$e = {
root: {
fontSize: "0.875rem",
fontWeight: "700",
padding: "0.25rem 0.5rem",
gap: "0.25rem",
borderRadius: "{content.border.radius}",
roundedBorderRadius: "{border.radius.xl}"
},
icon: {
size: "0.75rem"
},
colorScheme: {
light: {
primary: {
background: "{primary.100}",
color: "{primary.700}"
},
secondary: {
background: "{surface.100}",
color: "{surface.600}"
},
success: {
background: "{green.100}",
color: "{green.700}"
},
info: {
background: "{sky.100}",
color: "{sky.700}"
},
warn: {
background: "{orange.100}",
color: "{orange.700}"
},
danger: {
background: "{red.100}",
color: "{red.700}"
},
contrast: {
background: "{surface.950}",
color: "{surface.0}"
}
},
dark: {
primary: {
background: "color-mix(in srgb, {primary.500}, transparent 84%)",
color: "{primary.300}"
},
secondary: {
background: "{surface.800}",
color: "{surface.300}"
},
success: {
background: "color-mix(in srgb, {green.500}, transparent 84%)",
color: "{green.300}"
},
info: {
background: "color-mix(in srgb, {sky.500}, transparent 84%)",
color: "{sky.300}"
},
warn: {
background: "color-mix(in srgb, {orange.500}, transparent 84%)",
color: "{orange.300}"
},
danger: {
background: "color-mix(in srgb, {red.500}, transparent 84%)",
color: "{red.300}"
},
contrast: {
background: "{surface.0}",
color: "{surface.950}"
}
}
}
};
var index$d = {
root: {
background: "{form.field.background}",
borderColor: "{form.field.border.color}",
color: "{form.field.color}",
height: "18rem",
padding: "{form.field.padding.y} {form.field.padding.x}",
borderRadius: "{form.field.border.radius}"
},
prompt: {
gap: "0.25rem"
},
commandResponse: {
margin: "2px 0"
}
};
var index$c = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
}
};
var index$b = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
color: "{content.color}",
borderRadius: "{content.border.radius}",
shadow: "{overlay.navigation.shadow}",
transitionDuration: "{transition.duration}"
},
list: {
padding: "{navigation.list.padding}",
gap: "{navigation.list.gap}"
},
item: {
focusBackground: "{navigation.item.focus.background}",
activeBackground: "{navigation.item.active.background}",
color: "{navigation.item.color}",
focusColor: "{navigation.item.focus.color}",
activeColor: "{navigation.item.active.color}",
padding: "{navigation.item.padding}",
borderRadius: "{navigation.item.border.radius}",
gap: "{navigation.item.gap}",
icon: {
color: "{navigation.item.icon.color}",
focusColor: "{navigation.item.icon.focus.color}",
activeColor: "{navigation.item.icon.active.color}"
}
},
submenu: {
mobileIndent: "1rem"
},
submenuLabel: {
padding: "{navigation.submenu.label.padding}",
fontWeight: "{navigation.submenu.label.font.weight}",
background: "{navigation.submenu.label.background.}",
color: "{navigation.submenu.label.color}"
},
submenuIcon: {
size: "{navigation.submenu.icon.size}",
color: "{navigation.submenu.icon.color}",
focusColor: "{navigation.submenu.icon.focus.color}",
activeColor: "{navigation.submenu.icon.active.color}"
},
separator: {
borderColor: "{content.border.color}"
}
};
var index$a = {
event: {
minHeight: "5rem"
},
horizontal: {
eventContent: {
padding: "1rem 0"
}
},
vertical: {
eventContent: {
padding: "0 1rem"
}
},
eventMarker: {
size: "1.125rem",
borderRadius: "50%",
borderWidth: "2px",
background: "{content.background}",
borderColor: "{content.border.color}",
content: {
borderRadius: "50%",
size: "0.375rem",
background: "{primary.color}",
insetShadow: "0px 0.5px 0px 0px rgba(0, 0, 0, 0.06), 0px 1px 1px 0px rgba(0, 0, 0, 0.12)"
}
},
eventConnector: {
color: "{content.border.color}",
size: "2px"
}
};
var index$9 = {
root: {
width: "25rem",
borderRadius: "{content.border.radius}",
borderWidth: "1px",
transitionDuration: "{transition.duration}"
},
icon: {
size: "1.125rem"
},
content: {
padding: "{overlay.popover.padding}",
gap: "0.5rem"
},
text: {
gap: "0.5rem"
},
summary: {
fontWeight: "500",
fontSize: "1rem"
},
detail: {
fontWeight: "500",
fontSize: "0.875rem"
},
closeButton: {
width: "1.75rem",
height: "1.75rem",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
offset: "{focus.ring.offset}"
}
},
closeIcon: {
size: "1rem"
},
colorScheme: {
light: {
blur: "1.5px",
info: {
background: "color-mix(in srgb, {blue.50}, transparent 5%)",
borderColor: "{blue.200}",
color: "{blue.600}",
detailColor: "{surface.700}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {blue.500}, transparent 96%)",
closeButton: {
hoverBackground: "{blue.100}",
focusRing: {
color: "{blue.600}",
shadow: "none"
}
}
},
success: {
background: "color-mix(in srgb, {green.50}, transparent 5%)",
borderColor: "{green.200}",
color: "{green.600}",
detailColor: "{surface.700}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {green.500}, transparent 96%)",
closeButton: {
hoverBackground: "{green.100}",
focusRing: {
color: "{green.600}",
shadow: "none"
}
}
},
warn: {
background: "color-mix(in srgb,{yellow.50}, transparent 5%)",
borderColor: "{yellow.200}",
color: "{yellow.600}",
detailColor: "{surface.700}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {yellow.500}, transparent 96%)",
closeButton: {
hoverBackground: "{yellow.100}",
focusRing: {
color: "{yellow.600}",
shadow: "none"
}
}
},
error: {
background: "color-mix(in srgb, {red.50}, transparent 5%)",
borderColor: "{red.200}",
color: "{red.600}",
detailColor: "{surface.700}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {red.500}, transparent 96%)",
closeButton: {
hoverBackground: "{red.100}",
focusRing: {
color: "{red.600}",
shadow: "none"
}
}
},
secondary: {
background: "{surface.100}",
borderColor: "{surface.200}",
color: "{surface.600}",
detailColor: "{surface.700}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.500}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.200}",
focusRing: {
color: "{surface.600}",
shadow: "none"
}
}
},
contrast: {
background: "{surface.900}",
borderColor: "{surface.950}",
color: "{surface.50}",
detailColor: "{surface.0}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.950}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.800}",
focusRing: {
color: "{surface.50}",
shadow: "none"
}
}
}
},
dark: {
blur: "10px",
info: {
background: "color-mix(in srgb, {blue.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {blue.700}, transparent 64%)",
color: "{blue.500}",
detailColor: "{surface.0}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {blue.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{blue.500}",
shadow: "none"
}
}
},
success: {
background: "color-mix(in srgb, {green.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {green.700}, transparent 64%)",
color: "{green.500}",
detailColor: "{surface.0}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {green.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{green.500}",
shadow: "none"
}
}
},
warn: {
background: "color-mix(in srgb, {yellow.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {yellow.700}, transparent 64%)",
color: "{yellow.500}",
detailColor: "{surface.0}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {yellow.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{yellow.500}",
shadow: "none"
}
}
},
error: {
background: "color-mix(in srgb, {red.500}, transparent 84%)",
borderColor: "color-mix(in srgb, {red.700}, transparent 64%)",
color: "{red.500}",
detailColor: "{surface.0}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {red.500}, transparent 96%)",
closeButton: {
hoverBackground: "rgba(255, 255, 255, 0.05)",
focusRing: {
color: "{red.500}",
shadow: "none"
}
}
},
secondary: {
background: "{surface.800}",
borderColor: "{surface.700}",
color: "{surface.300}",
detailColor: "{surface.0}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.500}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.700}",
focusRing: {
color: "{surface.300}",
shadow: "none"
}
}
},
contrast: {
background: "{surface.0}",
borderColor: "{surface.100}",
color: "{surface.950}",
detailColor: "{surface.950}",
shadow: "0px 4px 8px 0px color-mix(in srgb, {surface.950}, transparent 96%)",
closeButton: {
hoverBackground: "{surface.100}",
focusRing: {
color: "{surface.950}",
shadow: "none"
}
}
}
}
}
};
var index$8 = {
root: {
padding: "0.5rem 1rem",
borderRadius: "{content.border.radius}",
gap: "0.5rem",
fontWeight: "500",
disabledBackground: "{form.field.disabled.background}",
disabledBorderColor: "{form.field.disabled.background}",
disabledColor: "{form.field.disabled.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
icon: {
disabledColor: "{form.field.disabled.color}"
},
content: {
left: "0.25rem",
top: "0.25rem",
checkedShadow: "0px 1px 2px 0px rgba(0, 0, 0, 0.02), 0px 1px 2px 0px rgba(0, 0, 0, 0.04)"
},
colorScheme: {
light: {
root: {
background: "{surface.100}",
checkedBackground: "{surface.100}",
hoverBackground: "{surface.100}",
borderColor: "{surface.100}",
color: "{surface.500}",
hoverColor: "{surface.700}",
checkedColor: "{surface.900}",
checkedBorderColor: "{surface.100}"
},
content: {
checkedBackground: "{surface.0}"
},
icon: {
color: "{surface.500}",
hoverColor: "{surface.700}",
checkedColor: "{surface.900}"
}
},
dark: {
root: {
background: "{surface.950}",
checkedBackground: "{surface.950}",
hoverBackground: "{surface.950}",
borderColor: "{surface.950}",
color: "{surface.400}",
hoverColor: "{surface.300}",
checkedColor: "{surface.0}",
checkedBorderColor: "{surface.950}"
},
content: {
checkedBackground: "{surface.800}"
},
icon: {
color: "{surface.400}",
hoverColor: "{surface.300}",
checkedColor: "{surface.0}"
}
}
}
};
var index$7 = {
root: {
width: "2.5rem",
height: "1.5rem",
borderRadius: "30px",
gap: "0.25rem",
shadow: "{form.field.shadow}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
},
borderWidth: "1px",
borderColor: "transparent",
hoverBorderColor: "transparent",
checkedBorderColor: "transparent",
checkedHoverBorderColor: "transparent",
invalidBorderColor: "{form.field.invalid.border.color}",
transitionDuration: "{form.field.transition.duration}",
slideDuration: "0.2s",
disabledBackground: "{form.field.disabled.background}"
},
handle: {
borderRadius: "50%",
size: "1rem",
disabledBackground: "{form.field.disabled.color}"
},
colorScheme: {
light: {
root: {
background: "{surface.300}",
hoverBackground: "{surface.400}",
checkedBackground: "{primary.color}",
checkedHoverBackground: "{primary.hover.color}"
},
handle: {
background: "{surface.0}",
hoverBackground: "{surface.0}",
checkedBackground: "{surface.0}",
checkedHoverBackground: "{surface.0}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
checkedColor: "{primary.color}",
checkedHoverColor: "{primary.hover.color}"
}
},
dark: {
root: {
background: "{surface.700}",
hoverBackground: "{surface.600}",
checkedBackground: "{primary.color}",
checkedHoverBackground: "{primary.hover.color}"
},
handle: {
background: "{surface.400}",
hoverBackground: "{surface.300}",
checkedBackground: "{surface.900}",
checkedHoverBackground: "{surface.900}",
color: "{surface.900}",
hoverColor: "{surface.800}",
checkedColor: "{primary.color}",
checkedHoverColor: "{primary.hover.color}"
}
}
}
};
var index$6 = {
root: {
background: "{content.background}",
borderColor: "{content.border.color}",
borderRadius: "{content.border.radius}",
color: "{content.color}",
gap: "0.5rem",
padding: "0.75rem"
}
};
var index$5 = {
root: {
maxWidth: "12.5rem",
gutter: "0.25rem",
shadow: "{overlay.popover.shadow}",
padding: "0.5rem 0.75rem",
borderRadius: "{overlay.popover.border.radius}"
},
colorScheme: {
light: {
root: {
background: "{surface.700}",
color: "{surface.0}"
}
},
dark: {
root: {
background: "{surface.700}",
color: "{surface.0}"
}
}
}
};
var index$4 = {
root: {
background: "{content.background}",
color: "{content.color}",
padding: "1rem",
gap: "2px",
indent: "1rem",
transitionDuration: "{transition.duration}"
},
node: {
padding: "0.25rem 0.5rem",
borderRadius: "{content.border.radius}",
hoverBackground: "{content.hover.background}",
selectedBackground: "{highlight.background}",
color: "{text.color}",
hoverColor: "{text.hover.color}",
selectedColor: "{highlight.color}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "-1px",
shadow: "{focus.ring.shadow}"
},
gap: "0.25rem"
},
nodeIcon: {
color: "{text.muted.color}",
hoverColor: "{text.hover.muted.color}",
selectedColor: "{highlight.color}"
},
nodeToggleButton: {
borderRadius: "50%",
size: "1.75rem",
hoverBackground: "{content.hover.background}",
selectedHoverBackground: "{content.background}",
color: "{text.muted.color}",
hoverColor: "{text.hover.muted.color}",
selectedHoverColor: "{primary.color}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
loadingIcon: {
size: "2rem"
}
};
var index$3 = {
root: {
background: "{form.field.background}",
disabledBackground: "{form.field.disabled.background}",
filledBackground: "{form.field.filled.background}",
filledHoverBackground: "{form.field.filled.hover.background}",
filledFocusBackground: "{form.field.filled.focus.background}",
borderColor: "{form.field.border.color}",
hoverBorderColor: "{form.field.hover.border.color}",
focusBorderColor: "{form.field.focus.border.color}",
invalidBorderColor: "{form.field.invalid.border.color}",
color: "{form.field.color}",
disabledColor: "{form.field.disabled.color}",
placeholderColor: "{form.field.placeholder.color}",
shadow: "{form.field.shadow}",
paddingX: "{form.field.padding.x}",
paddingY: "{form.field.padding.y}",
borderRadius: "{form.field.border.radius}",
focusRing: {
width: "{form.field.focus.ring.width}",
style: "{form.field.focus.ring.style}",
color: "{form.field.focus.ring.color}",
offset: "{form.field.focus.ring.offset}",
shadow: "{form.field.focus.ring.shadow}"
},
transitionDuration: "{form.field.transition.duration}"
},
dropdown: {
width: "2.5rem",
color: "{form.field.icon.color}"
},
overlay: {
background: "{overlay.select.background}",
borderColor: "{overlay.select.border.color}",
borderRadius: "{overlay.select.border.radius}",
color: "{overlay.select.color}",
shadow: "{overlay.select.shadow}"
},
tree: {
padding: "{list.padding}"
},
emptyMessage: {
padding: "{list.option.padding}"
},
chip: {
borderRadius: "{border.radius.sm}"
}
};
var index$2 = {
root: {
transitionDuration: "{transition.duration}"
},
header: {
background: "{content.background}",
borderColor: "{treetable.border.color}",
color: "{content.color}",
borderWidth: "0 0 1px 0",
padding: "0.75rem 1rem"
},
headerCell: {
background: "{content.background}",
hoverBackground: "{content.hover.background}",
selectedBackground: "{highlight.background}",
borderColor: "{treetable.border.color}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
selectedColor: "{highlight.color}",
gap: "0.5rem",
padding: "0.75rem 1rem",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "-1px",
shadow: "{focus.ring.shadow}"
}
},
columnTitle: {
fontWeight: "600"
},
row: {
background: "{content.background}",
hoverBackground: "{content.hover.background}",
selectedBackground: "{highlight.background}",
color: "{content.color}",
hoverColor: "{content.hover.color}",
selectedColor: "{highlight.color}",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "-1px",
shadow: "{focus.ring.shadow}"
}
},
bodyCell: {
borderColor: "{treetable.border.color}",
padding: "0.75rem 1rem",
gap: "0.5rem"
},
footerCell: {
background: "{content.background}",
borderColor: "{treetable.border.color}",
color: "{content.color}",
padding: "0.75rem 1rem"
},
columnFooter: {
fontWeight: "600"
},
footer: {
background: "{content.background}",
borderColor: "{treetable.border.color}",
color: "{content.color}",
borderWidth: "0 0 1px 0",
padding: "0.75rem 1rem"
},
columnResizerWidth: "0.5rem",
resizeIndicator: {
width: "1px",
color: "{primary.color}"
},
sortIcon: {
color: "{text.muted.color}",
hoverColor: "{text.hover.muted.color}"
},
loadingIcon: {
size: "2rem"
},
nodeToggleButton: {
hoverBackground: "{content.hover.background}",
selectedHoverBackground: "{content.background}",
color: "{text.muted.color}",
hoverColor: "{text.color}",
selectedHoverColor: "{primary.color}",
size: "1.75rem",
borderRadius: "50%",
focusRing: {
width: "{focus.ring.width}",
style: "{focus.ring.style}",
color: "{focus.ring.color}",
offset: "{focus.ring.offset}",
shadow: "{focus.ring.shadow}"
}
},
paginatorTop: {
borderColor: "{content.border.color}",
borderWidth: "0 0 1px 0"
},
paginatorBottom: {
borderColor: "{content.border.color}",
borderWidth: "0 0 1px 0"
},
colorScheme: {
light: {
root: {
borderColor: "{content.border.color}"
},
bodyCell: {
selectedBorderColor: "{primary.100}"
}
},
dark: {
root: {
borderColor: "{surface.800}"
},
bodyCell: {
selectedBorderColor: "{primary.900}"
}
}
}
};
var index$1 = {
loader: {
mask: {
background: "{content.background}",
color: "{text.muted.color}"
},
icon: {
size: "2rem"
}
}
};
function _typeof$7(o) {
"@babel/helpers - typeof";
return _typeof$7 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$7(o);
}
function ownKeys$5(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$5(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$5(Object(t), true).forEach(function(r2) {
_defineProperty$8(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$5(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$8(e, r, t) {
return (r = _toPropertyKey$7(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$7(t) {
var i = _toPrimitive$7(t, "string");
return "symbol" == _typeof$7(i) ? i : i + "";
}
function _toPrimitive$7(t, r) {
if ("object" != _typeof$7(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$7(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var index = _objectSpread$5(_objectSpread$5({}, index$1k), {}, {
components: {
accordion: index$1o,
autocomplete: index$1n,
avatar: index$1m,
badge: index$1l,
blockui: index$1j,
breadcrumb: index$1i,
button: index$1h,
datepicker: index$15,
card: index$1g,
carousel: index$1f,
cascadeselect: index$1e,
checkbox: index$1d,
chip: index$1c,
colorpicker: index$1b,
confirmdialog: index$1a,
confirmpopup: index$19,
contextmenu: index$18,
dataview: index$16,
datatable: index$17,
dialog: index$14,
divider: index$13,
dock: index$12,
drawer: index$11,
editor: index$10,
fieldset: index$$,
fileupload: index$_,
iftalabel: index$W,
floatlabel: index$Z,
galleria: index$Y,
iconfield: index$X,
image: index$V,
imagecompare: index$U,
inlinemessage: index$T,
inplace: index$S,
inputchips: index$R,
inputgroup: index$Q,
inputnumber: index$P,
inputtext: index$O,
knob: index$N,
listbox: index$M,
megamenu: index$L,
menu: index$K,
menubar: index$J,
message: index$I,
metergroup: index$H,
multiselect: index$G,
orderlist: index$F,
organizationchart: index$E,
overlaybadge: index$D,
popover: index$x,
paginator: index$C,
password: index$z,
panel: index$B,
panelmenu: index$A,
picklist: index$y,
progressbar: index$w,
progressspinner: index$v,
radiobutton: index$u,
rating: index$t,
scrollpanel: index$r,
select: index$q,
selectbutton: index$p,
skeleton: index$o,
slider: index$n,
speeddial: index$m,
splitter: index$k,
splitbutton: index$l,
stepper: index$j,
steps: index$i,
tabmenu: index$h,
tabs: index$g,
tabview: index$f,
textarea: index$c,
tieredmenu: index$b,
tag: index$e,
terminal: index$d,
timeline: index$a,
togglebutton: index$8,
toggleswitch: index$7,
tree: index$4,
treeselect: index$3,
treetable: index$2,
toast: index$9,
toolbar: index$6,
virtualscroller: index$1
},
directives: {
tooltip: index$5,
ripple: index$s
}
});
/*!
* vue-router v4.4.5
* (c) 2024 Eduardo San Martin Morote
* @license MIT
*/
const isBrowser = typeof document !== "undefined";
function isRouteComponent(component) {
return typeof component === "object" || "displayName" in component || "props" in component || "__vccOpts" in component;
}
function isESModule(obj) {
return obj.__esModule || obj[Symbol.toStringTag] === "Module" || // support CF with dynamic imports that do not
// add the Module string tag
obj.default && isRouteComponent(obj.default);
}
const assign = Object.assign;
function applyToParams(fn, params) {
const newParams = {};
for (const key in params) {
const value = params[key];
newParams[key] = isArray$4(value) ? value.map(fn) : fn(value);
}
return newParams;
}
const noop = () => {
};
const isArray$4 = Array.isArray;
const HASH_RE = /#/g;
const AMPERSAND_RE = /&/g;
const SLASH_RE = /\//g;
const EQUAL_RE = /=/g;
const IM_RE = /\?/g;
const PLUS_RE = /\+/g;
const ENC_BRACKET_OPEN_RE = /%5B/g;
const ENC_BRACKET_CLOSE_RE = /%5D/g;
const ENC_CARET_RE = /%5E/g;
const ENC_BACKTICK_RE = /%60/g;
const ENC_CURLY_OPEN_RE = /%7B/g;
const ENC_PIPE_RE = /%7C/g;
const ENC_CURLY_CLOSE_RE = /%7D/g;
const ENC_SPACE_RE = /%20/g;
function commonEncode(text) {
return encodeURI("" + text).replace(ENC_PIPE_RE, "|").replace(ENC_BRACKET_OPEN_RE, "[").replace(ENC_BRACKET_CLOSE_RE, "]");
}
function encodeHash(text) {
return commonEncode(text).replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
}
function encodeQueryValue(text) {
return commonEncode(text).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
}
function encodeQueryKey(text) {
return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
}
function encodePath(text) {
return commonEncode(text).replace(HASH_RE, "%23").replace(IM_RE, "%3F");
}
function encodeParam(text) {
return text == null ? "" : encodePath(text).replace(SLASH_RE, "%2F");
}
function decode(text) {
try {
return decodeURIComponent("" + text);
} catch (err) {
}
return "" + text;
}
const TRAILING_SLASH_RE = /\/$/;
const removeTrailingSlash = (path) => path.replace(TRAILING_SLASH_RE, "");
function parseURL(parseQuery2, location2, currentLocation = "/") {
let path, query = {}, searchString = "", hash = "";
const hashPos = location2.indexOf("#");
let searchPos = location2.indexOf("?");
if (hashPos < searchPos && hashPos >= 0) {
searchPos = -1;
}
if (searchPos > -1) {
path = location2.slice(0, searchPos);
searchString = location2.slice(searchPos + 1, hashPos > -1 ? hashPos : location2.length);
query = parseQuery2(searchString);
}
if (hashPos > -1) {
path = path || location2.slice(0, hashPos);
hash = location2.slice(hashPos, location2.length);
}
path = resolveRelativePath(path != null ? path : location2, currentLocation);
return {
fullPath: path + (searchString && "?") + searchString + hash,
path,
query,
hash: decode(hash)
};
}
function stringifyURL(stringifyQuery2, location2) {
const query = location2.query ? stringifyQuery2(location2.query) : "";
return location2.path + (query && "?") + query + (location2.hash || "");
}
function isSameRouteLocation(stringifyQuery2, a, b) {
const aLastIndex = a.matched.length - 1;
const bLastIndex = b.matched.length - 1;
return aLastIndex > -1 && aLastIndex === bLastIndex && isSameRouteRecord(a.matched[aLastIndex], b.matched[bLastIndex]) && isSameRouteLocationParams(a.params, b.params) && stringifyQuery2(a.query) === stringifyQuery2(b.query) && a.hash === b.hash;
}
function isSameRouteRecord(a, b) {
return (a.aliasOf || a) === (b.aliasOf || b);
}
function isSameRouteLocationParams(a, b) {
if (Object.keys(a).length !== Object.keys(b).length)
return false;
for (const key in a) {
if (!isSameRouteLocationParamsValue(a[key], b[key]))
return false;
}
return true;
}
function isSameRouteLocationParamsValue(a, b) {
return isArray$4(a) ? isEquivalentArray(a, b) : isArray$4(b) ? isEquivalentArray(b, a) : a === b;
}
function isEquivalentArray(a, b) {
return isArray$4(b) ? a.length === b.length && a.every((value, i) => value === b[i]) : a.length === 1 && a[0] === b;
}
function resolveRelativePath(to, from) {
if (to.startsWith("/"))
return to;
if (!to)
return from;
const fromSegments = from.split("/");
const toSegments = to.split("/");
const lastToSegment = toSegments[toSegments.length - 1];
if (lastToSegment === ".." || lastToSegment === ".") {
toSegments.push("");
}
let position = fromSegments.length - 1;
let toPosition;
let segment;
for (toPosition = 0; toPosition < toSegments.length; toPosition++) {
segment = toSegments[toPosition];
if (segment === ".")
continue;
if (segment === "..") {
if (position > 1)
position--;
} else
break;
}
return fromSegments.slice(0, position).join("/") + "/" + toSegments.slice(toPosition).join("/");
}
const START_LOCATION_NORMALIZED = {
path: "/",
// TODO: could we use a symbol in the future?
name: void 0,
params: {},
query: {},
hash: "",
fullPath: "/",
matched: [],
meta: {},
redirectedFrom: void 0
};
var NavigationType;
(function(NavigationType2) {
NavigationType2["pop"] = "pop";
NavigationType2["push"] = "push";
})(NavigationType || (NavigationType = {}));
var NavigationDirection;
(function(NavigationDirection2) {
NavigationDirection2["back"] = "back";
NavigationDirection2["forward"] = "forward";
NavigationDirection2["unknown"] = "";
})(NavigationDirection || (NavigationDirection = {}));
const START = "";
function normalizeBase(base) {
if (!base) {
if (isBrowser) {
const baseEl = document.querySelector("base");
base = baseEl && baseEl.getAttribute("href") || "/";
base = base.replace(/^\w+:\/\/[^\/]+/, "");
} else {
base = "/";
}
}
if (base[0] !== "/" && base[0] !== "#")
base = "/" + base;
return removeTrailingSlash(base);
}
const BEFORE_HASH_RE = /^[^#]+#/;
function createHref(base, location2) {
return base.replace(BEFORE_HASH_RE, "#") + location2;
}
function getElementPosition(el, offset) {
const docRect = document.documentElement.getBoundingClientRect();
const elRect = el.getBoundingClientRect();
return {
behavior: offset.behavior,
left: elRect.left - docRect.left - (offset.left || 0),
top: elRect.top - docRect.top - (offset.top || 0)
};
}
const computeScrollPosition = () => ({
left: window.scrollX,
top: window.scrollY
});
function scrollToPosition(position) {
let scrollToOptions;
if ("el" in position) {
const positionEl = position.el;
const isIdSelector = typeof positionEl === "string" && positionEl.startsWith("#");
const el = typeof positionEl === "string" ? isIdSelector ? document.getElementById(positionEl.slice(1)) : document.querySelector(positionEl) : positionEl;
if (!el) {
return;
}
scrollToOptions = getElementPosition(el, position);
} else {
scrollToOptions = position;
}
if ("scrollBehavior" in document.documentElement.style)
window.scrollTo(scrollToOptions);
else {
window.scrollTo(scrollToOptions.left != null ? scrollToOptions.left : window.scrollX, scrollToOptions.top != null ? scrollToOptions.top : window.scrollY);
}
}
function getScrollKey(path, delta) {
const position = history.state ? history.state.position - delta : -1;
return position + path;
}
const scrollPositions = /* @__PURE__ */ new Map();
function saveScrollPosition(key, scrollPosition) {
scrollPositions.set(key, scrollPosition);
}
function getSavedScrollPosition(key) {
const scroll = scrollPositions.get(key);
scrollPositions.delete(key);
return scroll;
}
function createMemoryHistory(base = "") {
let listeners = [];
let queue2 = [START];
let position = 0;
base = normalizeBase(base);
function setLocation(location2) {
position++;
if (position !== queue2.length) {
queue2.splice(position);
}
queue2.push(location2);
}
function triggerListeners(to, from, { direction, delta }) {
const info = {
direction,
delta,
type: NavigationType.pop
};
for (const callback of listeners) {
callback(to, from, info);
}
}
const routerHistory = {
// rewritten by Object.defineProperty
location: START,
// TODO: should be kept in queue
state: {},
base,
createHref: createHref.bind(null, base),
replace(to) {
queue2.splice(position--, 1);
setLocation(to);
},
push(to, data4) {
setLocation(to);
},
listen(callback) {
listeners.push(callback);
return () => {
const index2 = listeners.indexOf(callback);
if (index2 > -1)
listeners.splice(index2, 1);
};
},
destroy() {
listeners = [];
queue2 = [START];
position = 0;
},
go(delta, shouldTrigger = true) {
const from = this.location;
const direction = (
// we are considering delta === 0 going forward, but in abstract mode
// using 0 for the delta doesn't make sense like it does in html5 where
// it reloads the page
delta < 0 ? NavigationDirection.back : NavigationDirection.forward
);
position = Math.max(0, Math.min(position + delta, queue2.length - 1));
if (shouldTrigger) {
triggerListeners(this.location, from, {
direction,
delta
});
}
}
};
Object.defineProperty(routerHistory, "location", {
enumerable: true,
get: () => queue2[position]
});
return routerHistory;
}
function isRouteLocation(route) {
return typeof route === "string" || route && typeof route === "object";
}
function isRouteName(name) {
return typeof name === "string" || typeof name === "symbol";
}
const NavigationFailureSymbol = Symbol("");
var NavigationFailureType;
(function(NavigationFailureType2) {
NavigationFailureType2[NavigationFailureType2["aborted"] = 4] = "aborted";
NavigationFailureType2[NavigationFailureType2["cancelled"] = 8] = "cancelled";
NavigationFailureType2[NavigationFailureType2["duplicated"] = 16] = "duplicated";
})(NavigationFailureType || (NavigationFailureType = {}));
function createRouterError(type, params) {
{
return assign(new Error(), {
type,
[NavigationFailureSymbol]: true
}, params);
}
}
function isNavigationFailure(error, type) {
return error instanceof Error && NavigationFailureSymbol in error && (type == null || !!(error.type & type));
}
const BASE_PARAM_PATTERN = "[^/]+?";
const BASE_PATH_PARSER_OPTIONS = {
sensitive: false,
strict: false,
start: true,
end: true
};
const REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
function tokensToParser(segments, extraOptions) {
const options = assign({}, BASE_PATH_PARSER_OPTIONS, extraOptions);
const score = [];
let pattern = options.start ? "^" : "";
const keys2 = [];
for (const segment of segments) {
const segmentScores = segment.length ? [] : [
90
/* PathScore.Root */
];
if (options.strict && !segment.length)
pattern += "/";
for (let tokenIndex = 0; tokenIndex < segment.length; tokenIndex++) {
const token = segment[tokenIndex];
let subSegmentScore = 40 + (options.sensitive ? 0.25 : 0);
if (token.type === 0) {
if (!tokenIndex)
pattern += "/";
pattern += token.value.replace(REGEX_CHARS_RE, "\\$&");
subSegmentScore += 40;
} else if (token.type === 1) {
const { value, repeatable, optional, regexp } = token;
keys2.push({
name: value,
repeatable,
optional
});
const re2 = regexp ? regexp : BASE_PARAM_PATTERN;
if (re2 !== BASE_PARAM_PATTERN) {
subSegmentScore += 10;
try {
new RegExp(`(${re2})`);
} catch (err) {
throw new Error(`Invalid custom RegExp for param "${value}" (${re2}): ` + err.message);
}
}
let subPattern = repeatable ? `((?:${re2})(?:/(?:${re2}))*)` : `(${re2})`;
if (!tokenIndex)
subPattern = // avoid an optional / if there are more segments e.g. /:p?-static
// or /:p?-:p2
optional && segment.length < 2 ? `(?:/${subPattern})` : "/" + subPattern;
if (optional)
subPattern += "?";
pattern += subPattern;
subSegmentScore += 20;
if (optional)
subSegmentScore += -8;
if (repeatable)
subSegmentScore += -20;
if (re2 === ".*")
subSegmentScore += -50;
}
segmentScores.push(subSegmentScore);
}
score.push(segmentScores);
}
if (options.strict && options.end) {
const i = score.length - 1;
score[i][score[i].length - 1] += 0.7000000000000001;
}
if (!options.strict)
pattern += "/?";
if (options.end)
pattern += "$";
else if (options.strict)
pattern += "(?:/|$)";
const re = new RegExp(pattern, options.sensitive ? "" : "i");
function parse(path) {
const match = path.match(re);
const params = {};
if (!match)
return null;
for (let i = 1; i < match.length; i++) {
const value = match[i] || "";
const key = keys2[i - 1];
params[key.name] = value && key.repeatable ? value.split("/") : value;
}
return params;
}
function stringify(params) {
let path = "";
let avoidDuplicatedSlash = false;
for (const segment of segments) {
if (!avoidDuplicatedSlash || !path.endsWith("/"))
path += "/";
avoidDuplicatedSlash = false;
for (const token of segment) {
if (token.type === 0) {
path += token.value;
} else if (token.type === 1) {
const { value, repeatable, optional } = token;
const param = value in params ? params[value] : "";
if (isArray$4(param) && !repeatable) {
throw new Error(`Provided param "${value}" is an array but it is not repeatable (* or + modifiers)`);
}
const text = isArray$4(param) ? param.join("/") : param;
if (!text) {
if (optional) {
if (segment.length < 2) {
if (path.endsWith("/"))
path = path.slice(0, -1);
else
avoidDuplicatedSlash = true;
}
} else
throw new Error(`Missing required param "${value}"`);
}
path += text;
}
}
}
return path || "/";
}
return {
re,
score,
keys: keys2,
parse,
stringify
};
}
function compareScoreArray(a, b) {
let i = 0;
while (i < a.length && i < b.length) {
const diff = b[i] - a[i];
if (diff)
return diff;
i++;
}
if (a.length < b.length) {
return a.length === 1 && a[0] === 40 + 40 ? -1 : 1;
} else if (a.length > b.length) {
return b.length === 1 && b[0] === 40 + 40 ? 1 : -1;
}
return 0;
}
function comparePathParserScore(a, b) {
let i = 0;
const aScore = a.score;
const bScore = b.score;
while (i < aScore.length && i < bScore.length) {
const comp = compareScoreArray(aScore[i], bScore[i]);
if (comp)
return comp;
i++;
}
if (Math.abs(bScore.length - aScore.length) === 1) {
if (isLastScoreNegative(aScore))
return 1;
if (isLastScoreNegative(bScore))
return -1;
}
return bScore.length - aScore.length;
}
function isLastScoreNegative(score) {
const last = score[score.length - 1];
return score.length > 0 && last[last.length - 1] < 0;
}
const ROOT_TOKEN = {
type: 0,
value: ""
};
const VALID_PARAM_RE = /[a-zA-Z0-9_]/;
function tokenizePath(path) {
if (!path)
return [[]];
if (path === "/")
return [[ROOT_TOKEN]];
if (!path.startsWith("/")) {
throw new Error(`Invalid path "${path}"`);
}
function crash(message) {
throw new Error(`ERR (${state})/"${buffer}": ${message}`);
}
let state = 0;
let previousState = state;
const tokens = [];
let segment;
function finalizeSegment() {
if (segment)
tokens.push(segment);
segment = [];
}
let i = 0;
let char;
let buffer = "";
let customRe = "";
function consumeBuffer() {
if (!buffer)
return;
if (state === 0) {
segment.push({
type: 0,
value: buffer
});
} else if (state === 1 || state === 2 || state === 3) {
if (segment.length > 1 && (char === "*" || char === "+"))
crash(`A repeatable param (${buffer}) must be alone in its segment. eg: '/:ids+.`);
segment.push({
type: 1,
value: buffer,
regexp: customRe,
repeatable: char === "*" || char === "+",
optional: char === "*" || char === "?"
});
} else {
crash("Invalid state to consume buffer");
}
buffer = "";
}
function addCharToBuffer() {
buffer += char;
}
while (i < path.length) {
char = path[i++];
if (char === "\\" && state !== 2) {
previousState = state;
state = 4;
continue;
}
switch (state) {
case 0:
if (char === "/") {
if (buffer) {
consumeBuffer();
}
finalizeSegment();
} else if (char === ":") {
consumeBuffer();
state = 1;
} else {
addCharToBuffer();
}
break;
case 4:
addCharToBuffer();
state = previousState;
break;
case 1:
if (char === "(") {
state = 2;
} else if (VALID_PARAM_RE.test(char)) {
addCharToBuffer();
} else {
consumeBuffer();
state = 0;
if (char !== "*" && char !== "?" && char !== "+")
i--;
}
break;
case 2:
if (char === ")") {
if (customRe[customRe.length - 1] == "\\")
customRe = customRe.slice(0, -1) + char;
else
state = 3;
} else {
customRe += char;
}
break;
case 3:
consumeBuffer();
state = 0;
if (char !== "*" && char !== "?" && char !== "+")
i--;
customRe = "";
break;
default:
crash("Unknown state");
break;
}
}
if (state === 2)
crash(`Unfinished custom RegExp for param "${buffer}"`);
consumeBuffer();
finalizeSegment();
return tokens;
}
function createRouteRecordMatcher(record, parent, options) {
const parser = tokensToParser(tokenizePath(record.path), options);
const matcher = assign(parser, {
record,
parent,
// these needs to be populated by the parent
children: [],
alias: []
});
if (parent) {
if (!matcher.record.aliasOf === !parent.record.aliasOf)
parent.children.push(matcher);
}
return matcher;
}
function createRouterMatcher(routes, globalOptions) {
const matchers = [];
const matcherMap = /* @__PURE__ */ new Map();
globalOptions = mergeOptions({ strict: false, end: true, sensitive: false }, globalOptions);
function getRecordMatcher(name) {
return matcherMap.get(name);
}
function addRoute(record, parent, originalRecord) {
const isRootAdd = !originalRecord;
const mainNormalizedRecord = normalizeRouteRecord(record);
mainNormalizedRecord.aliasOf = originalRecord && originalRecord.record;
const options = mergeOptions(globalOptions, record);
const normalizedRecords = [mainNormalizedRecord];
if ("alias" in record) {
const aliases = typeof record.alias === "string" ? [record.alias] : record.alias;
for (const alias of aliases) {
normalizedRecords.push(
// we need to normalize again to ensure the `mods` property
// being non enumerable
normalizeRouteRecord(assign({}, mainNormalizedRecord, {
// this allows us to hold a copy of the `components` option
// so that async components cache is hold on the original record
components: originalRecord ? originalRecord.record.components : mainNormalizedRecord.components,
path: alias,
// we might be the child of an alias
aliasOf: originalRecord ? originalRecord.record : mainNormalizedRecord
// the aliases are always of the same kind as the original since they
// are defined on the same record
}))
);
}
}
let matcher;
let originalMatcher;
for (const normalizedRecord of normalizedRecords) {
const { path } = normalizedRecord;
if (parent && path[0] !== "/") {
const parentPath = parent.record.path;
const connectingSlash = parentPath[parentPath.length - 1] === "/" ? "" : "/";
normalizedRecord.path = parent.record.path + (path && connectingSlash + path);
}
matcher = createRouteRecordMatcher(normalizedRecord, parent, options);
if (originalRecord) {
originalRecord.alias.push(matcher);
} else {
originalMatcher = originalMatcher || matcher;
if (originalMatcher !== matcher)
originalMatcher.alias.push(matcher);
if (isRootAdd && record.name && !isAliasRecord(matcher))
removeRoute(record.name);
}
if (isMatchable(matcher)) {
insertMatcher(matcher);
}
if (mainNormalizedRecord.children) {
const children = mainNormalizedRecord.children;
for (let i = 0; i < children.length; i++) {
addRoute(children[i], matcher, originalRecord && originalRecord.children[i]);
}
}
originalRecord = originalRecord || matcher;
}
return originalMatcher ? () => {
removeRoute(originalMatcher);
} : noop;
}
function removeRoute(matcherRef) {
if (isRouteName(matcherRef)) {
const matcher = matcherMap.get(matcherRef);
if (matcher) {
matcherMap.delete(matcherRef);
matchers.splice(matchers.indexOf(matcher), 1);
matcher.children.forEach(removeRoute);
matcher.alias.forEach(removeRoute);
}
} else {
const index2 = matchers.indexOf(matcherRef);
if (index2 > -1) {
matchers.splice(index2, 1);
if (matcherRef.record.name)
matcherMap.delete(matcherRef.record.name);
matcherRef.children.forEach(removeRoute);
matcherRef.alias.forEach(removeRoute);
}
}
}
function getRoutes() {
return matchers;
}
function insertMatcher(matcher) {
const index2 = findInsertionIndex(matcher, matchers);
matchers.splice(index2, 0, matcher);
if (matcher.record.name && !isAliasRecord(matcher))
matcherMap.set(matcher.record.name, matcher);
}
function resolve2(location2, currentLocation) {
let matcher;
let params = {};
let path;
let name;
if ("name" in location2 && location2.name) {
matcher = matcherMap.get(location2.name);
if (!matcher)
throw createRouterError(1, {
location: location2
});
name = matcher.record.name;
params = assign(
// paramsFromLocation is a new object
paramsFromLocation(
currentLocation.params,
// only keep params that exist in the resolved location
// only keep optional params coming from a parent record
matcher.keys.filter((k) => !k.optional).concat(matcher.parent ? matcher.parent.keys.filter((k) => k.optional) : []).map((k) => k.name)
),
// discard any existing params in the current location that do not exist here
// #1497 this ensures better active/exact matching
location2.params && paramsFromLocation(location2.params, matcher.keys.map((k) => k.name))
);
path = matcher.stringify(params);
} else if (location2.path != null) {
path = location2.path;
matcher = matchers.find((m) => m.re.test(path));
if (matcher) {
params = matcher.parse(path);
name = matcher.record.name;
}
} else {
matcher = currentLocation.name ? matcherMap.get(currentLocation.name) : matchers.find((m) => m.re.test(currentLocation.path));
if (!matcher)
throw createRouterError(1, {
location: location2,
currentLocation
});
name = matcher.record.name;
params = assign({}, currentLocation.params, location2.params);
path = matcher.stringify(params);
}
const matched = [];
let parentMatcher = matcher;
while (parentMatcher) {
matched.unshift(parentMatcher.record);
parentMatcher = parentMatcher.parent;
}
return {
name,
path,
params,
matched,
meta: mergeMetaFields(matched)
};
}
routes.forEach((route) => addRoute(route));
function clearRoutes() {
matchers.length = 0;
matcherMap.clear();
}
return {
addRoute,
resolve: resolve2,
removeRoute,
clearRoutes,
getRoutes,
getRecordMatcher
};
}
function paramsFromLocation(params, keys2) {
const newParams = {};
for (const key of keys2) {
if (key in params)
newParams[key] = params[key];
}
return newParams;
}
function normalizeRouteRecord(record) {
const normalized = {
path: record.path,
redirect: record.redirect,
name: record.name,
meta: record.meta || {},
aliasOf: record.aliasOf,
beforeEnter: record.beforeEnter,
props: normalizeRecordProps(record),
children: record.children || [],
instances: {},
leaveGuards: /* @__PURE__ */ new Set(),
updateGuards: /* @__PURE__ */ new Set(),
enterCallbacks: {},
// must be declared afterwards
// mods: {},
components: "components" in record ? record.components || null : record.component && { default: record.component }
};
Object.defineProperty(normalized, "mods", {
value: {}
});
return normalized;
}
function normalizeRecordProps(record) {
const propsObject = {};
const props = record.props || false;
if ("component" in record) {
propsObject.default = props;
} else {
for (const name in record.components)
propsObject[name] = typeof props === "object" ? props[name] : props;
}
return propsObject;
}
function isAliasRecord(record) {
while (record) {
if (record.record.aliasOf)
return true;
record = record.parent;
}
return false;
}
function mergeMetaFields(matched) {
return matched.reduce((meta, record) => assign(meta, record.meta), {});
}
function mergeOptions(defaults, partialOptions) {
const options = {};
for (const key in defaults) {
options[key] = key in partialOptions ? partialOptions[key] : defaults[key];
}
return options;
}
function findInsertionIndex(matcher, matchers) {
let lower = 0;
let upper = matchers.length;
while (lower !== upper) {
const mid = lower + upper >> 1;
const sortOrder = comparePathParserScore(matcher, matchers[mid]);
if (sortOrder < 0) {
upper = mid;
} else {
lower = mid + 1;
}
}
const insertionAncestor = getInsertionAncestor(matcher);
if (insertionAncestor) {
upper = matchers.lastIndexOf(insertionAncestor, upper - 1);
}
return upper;
}
function getInsertionAncestor(matcher) {
let ancestor = matcher;
while (ancestor = ancestor.parent) {
if (isMatchable(ancestor) && comparePathParserScore(matcher, ancestor) === 0) {
return ancestor;
}
}
return;
}
function isMatchable({ record }) {
return !!(record.name || record.components && Object.keys(record.components).length || record.redirect);
}
function parseQuery(search) {
const query = {};
if (search === "" || search === "?")
return query;
const hasLeadingIM = search[0] === "?";
const searchParams = (hasLeadingIM ? search.slice(1) : search).split("&");
for (let i = 0; i < searchParams.length; ++i) {
const searchParam = searchParams[i].replace(PLUS_RE, " ");
const eqPos = searchParam.indexOf("=");
const key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));
const value = eqPos < 0 ? null : decode(searchParam.slice(eqPos + 1));
if (key in query) {
let currentValue = query[key];
if (!isArray$4(currentValue)) {
currentValue = query[key] = [currentValue];
}
currentValue.push(value);
} else {
query[key] = value;
}
}
return query;
}
function stringifyQuery(query) {
let search = "";
for (let key in query) {
const value = query[key];
key = encodeQueryKey(key);
if (value == null) {
if (value !== void 0) {
search += (search.length ? "&" : "") + key;
}
continue;
}
const values = isArray$4(value) ? value.map((v) => v && encodeQueryValue(v)) : [value && encodeQueryValue(value)];
values.forEach((value2) => {
if (value2 !== void 0) {
search += (search.length ? "&" : "") + key;
if (value2 != null)
search += "=" + value2;
}
});
}
return search;
}
function normalizeQuery(query) {
const normalizedQuery = {};
for (const key in query) {
const value = query[key];
if (value !== void 0) {
normalizedQuery[key] = isArray$4(value) ? value.map((v) => v == null ? null : "" + v) : value == null ? value : "" + value;
}
}
return normalizedQuery;
}
const matchedRouteKey = Symbol("");
const viewDepthKey = Symbol("");
const routerKey = Symbol("");
const routeLocationKey = Symbol("");
const routerViewLocationKey = Symbol("");
function useCallbacks() {
let handlers = [];
function add2(handler5) {
handlers.push(handler5);
return () => {
const i = handlers.indexOf(handler5);
if (i > -1)
handlers.splice(i, 1);
};
}
function reset() {
handlers = [];
}
return {
add: add2,
list: () => handlers.slice(),
reset
};
}
function guardToPromiseFn(guard, to, from, record, name, runWithContext = (fn) => fn()) {
const enterCallbackArray = record && // name is defined if record is because of the function overload
(record.enterCallbacks[name] = record.enterCallbacks[name] || []);
return () => new Promise((resolve2, reject) => {
const next = (valid) => {
if (valid === false) {
reject(createRouterError(4, {
from,
to
}));
} else if (valid instanceof Error) {
reject(valid);
} else if (isRouteLocation(valid)) {
reject(createRouterError(2, {
from: to,
to: valid
}));
} else {
if (enterCallbackArray && // since enterCallbackArray is truthy, both record and name also are
record.enterCallbacks[name] === enterCallbackArray && typeof valid === "function") {
enterCallbackArray.push(valid);
}
resolve2();
}
};
const guardReturn = runWithContext(() => guard.call(record && record.instances[name], to, from, next));
let guardCall = Promise.resolve(guardReturn);
if (guard.length < 3)
guardCall = guardCall.then(next);
guardCall.catch((err) => reject(err));
});
}
function extractComponentsGuards(matched, guardType, to, from, runWithContext = (fn) => fn()) {
const guards = [];
for (const record of matched) {
for (const name in record.components) {
let rawComponent = record.components[name];
if (guardType !== "beforeRouteEnter" && !record.instances[name])
continue;
if (isRouteComponent(rawComponent)) {
const options = rawComponent.__vccOpts || rawComponent;
const guard = options[guardType];
guard && guards.push(guardToPromiseFn(guard, to, from, record, name, runWithContext));
} else {
let componentPromise = rawComponent();
guards.push(() => componentPromise.then((resolved) => {
if (!resolved)
throw new Error(`Couldn't resolve component "${name}" at "${record.path}"`);
const resolvedComponent = isESModule(resolved) ? resolved.default : resolved;
record.mods[name] = resolved;
record.components[name] = resolvedComponent;
const options = resolvedComponent.__vccOpts || resolvedComponent;
const guard = options[guardType];
return guard && guardToPromiseFn(guard, to, from, record, name, runWithContext)();
}));
}
}
}
return guards;
}
function useLink(props) {
const router2 = inject(routerKey);
const currentRoute = inject(routeLocationKey);
const route = computed(() => {
const to = unref(props.to);
return router2.resolve(to);
});
const activeRecordIndex = computed(() => {
const { matched } = route.value;
const { length } = matched;
const routeMatched = matched[length - 1];
const currentMatched = currentRoute.matched;
if (!routeMatched || !currentMatched.length)
return -1;
const index2 = currentMatched.findIndex(isSameRouteRecord.bind(null, routeMatched));
if (index2 > -1)
return index2;
const parentRecordPath = getOriginalPath(matched[length - 2]);
return (
// we are dealing with nested routes
length > 1 && // if the parent and matched route have the same path, this link is
// referring to the empty child. Or we currently are on a different
// child of the same parent
getOriginalPath(routeMatched) === parentRecordPath && // avoid comparing the child with its parent
currentMatched[currentMatched.length - 1].path !== parentRecordPath ? currentMatched.findIndex(isSameRouteRecord.bind(null, matched[length - 2])) : index2
);
});
const isActive = computed(() => activeRecordIndex.value > -1 && includesParams(currentRoute.params, route.value.params));
const isExactActive = computed(() => activeRecordIndex.value > -1 && activeRecordIndex.value === currentRoute.matched.length - 1 && isSameRouteLocationParams(currentRoute.params, route.value.params));
function navigate(e = {}) {
if (guardEvent(e)) {
return router2[unref(props.replace) ? "replace" : "push"](
unref(props.to)
// avoid uncaught errors are they are logged anyway
).catch(noop);
}
return Promise.resolve();
}
return {
route,
href: computed(() => route.value.href),
isActive,
isExactActive,
navigate
};
}
const RouterLinkImpl = /* @__PURE__ */ defineComponent({
name: "RouterLink",
compatConfig: { MODE: 3 },
props: {
to: {
type: [String, Object],
required: true
},
replace: Boolean,
activeClass: String,
// inactiveClass: String,
exactActiveClass: String,
custom: Boolean,
ariaCurrentValue: {
type: String,
default: "page"
}
},
useLink,
setup(props, { slots }) {
const link = reactive(useLink(props));
const { options } = inject(routerKey);
const elClass = computed(() => ({
[getLinkClass(props.activeClass, options.linkActiveClass, "router-link-active")]: link.isActive,
// [getLinkClass(
// props.inactiveClass,
// options.linkInactiveClass,
// 'router-link-inactive'
// )]: !link.isExactActive,
[getLinkClass(props.exactActiveClass, options.linkExactActiveClass, "router-link-exact-active")]: link.isExactActive
}));
return () => {
const children = slots.default && slots.default(link);
return props.custom ? children : h("a", {
"aria-current": link.isExactActive ? props.ariaCurrentValue : null,
href: link.href,
// this would override user added attrs but Vue will still add
// the listener, so we end up triggering both
onClick: link.navigate,
class: elClass.value
}, children);
};
}
});
const RouterLink = RouterLinkImpl;
function guardEvent(e) {
if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)
return;
if (e.defaultPrevented)
return;
if (e.button !== void 0 && e.button !== 0)
return;
if (e.currentTarget && e.currentTarget.getAttribute) {
const target = e.currentTarget.getAttribute("target");
if (/\b_blank\b/i.test(target))
return;
}
if (e.preventDefault)
e.preventDefault();
return true;
}
function includesParams(outer, inner) {
for (const key in inner) {
const innerValue = inner[key];
const outerValue = outer[key];
if (typeof innerValue === "string") {
if (innerValue !== outerValue)
return false;
} else {
if (!isArray$4(outerValue) || outerValue.length !== innerValue.length || innerValue.some((value, i) => value !== outerValue[i]))
return false;
}
}
return true;
}
function getOriginalPath(record) {
return record ? record.aliasOf ? record.aliasOf.path : record.path : "";
}
const getLinkClass = (propClass, globalClass, defaultClass) => propClass != null ? propClass : globalClass != null ? globalClass : defaultClass;
const RouterViewImpl = /* @__PURE__ */ defineComponent({
name: "RouterView",
// #674 we manually inherit them
inheritAttrs: false,
props: {
name: {
type: String,
default: "default"
},
route: Object
},
// Better compat for @vue/compat users
// https://github.com/vuejs/router/issues/1315
compatConfig: { MODE: 3 },
setup(props, { attrs: attrs2, slots }) {
const injectedRoute = inject(routerViewLocationKey);
const routeToDisplay = computed(() => props.route || injectedRoute.value);
const injectedDepth = inject(viewDepthKey, 0);
const depth = computed(() => {
let initialDepth = unref(injectedDepth);
const { matched } = routeToDisplay.value;
let matchedRoute;
while ((matchedRoute = matched[initialDepth]) && !matchedRoute.components) {
initialDepth++;
}
return initialDepth;
});
const matchedRouteRef = computed(() => routeToDisplay.value.matched[depth.value]);
provide(viewDepthKey, computed(() => depth.value + 1));
provide(matchedRouteKey, matchedRouteRef);
provide(routerViewLocationKey, routeToDisplay);
const viewRef = ref();
watch(() => [viewRef.value, matchedRouteRef.value, props.name], ([instance, to, name], [oldInstance, from, oldName]) => {
if (to) {
to.instances[name] = instance;
if (from && from !== to && instance && instance === oldInstance) {
if (!to.leaveGuards.size) {
to.leaveGuards = from.leaveGuards;
}
if (!to.updateGuards.size) {
to.updateGuards = from.updateGuards;
}
}
}
if (instance && to && // if there is no instance but to and from are the same this might be
// the first visit
(!from || !isSameRouteRecord(to, from) || !oldInstance)) {
(to.enterCallbacks[name] || []).forEach((callback) => callback(instance));
}
}, { flush: "post" });
return () => {
const route = routeToDisplay.value;
const currentName = props.name;
const matchedRoute = matchedRouteRef.value;
const ViewComponent = matchedRoute && matchedRoute.components[currentName];
if (!ViewComponent) {
return normalizeSlot(slots.default, { Component: ViewComponent, route });
}
const routePropsOption = matchedRoute.props[currentName];
const routeProps = routePropsOption ? routePropsOption === true ? route.params : typeof routePropsOption === "function" ? routePropsOption(route) : routePropsOption : null;
const onVnodeUnmounted = (vnode) => {
if (vnode.component.isUnmounted) {
matchedRoute.instances[currentName] = null;
}
};
const component = h(ViewComponent, assign({}, routeProps, attrs2, {
onVnodeUnmounted,
ref: viewRef
}));
return (
// pass the vnode to the slot as a prop.
// h and <component :is="..."> both accept vnodes
normalizeSlot(slots.default, { Component: component, route }) || component
);
};
}
});
function normalizeSlot(slot, data4) {
if (!slot)
return null;
const slotContent = slot(data4);
return slotContent.length === 1 ? slotContent[0] : slotContent;
}
const RouterView = RouterViewImpl;
function createRouter(options) {
const matcher = createRouterMatcher(options.routes, options);
const parseQuery$1 = options.parseQuery || parseQuery;
const stringifyQuery$1 = options.stringifyQuery || stringifyQuery;
const routerHistory = options.history;
const beforeGuards = useCallbacks();
const beforeResolveGuards = useCallbacks();
const afterGuards = useCallbacks();
const currentRoute = shallowRef(START_LOCATION_NORMALIZED);
let pendingLocation = START_LOCATION_NORMALIZED;
if (isBrowser && options.scrollBehavior && "scrollRestoration" in history) {
history.scrollRestoration = "manual";
}
const normalizeParams = applyToParams.bind(null, (paramValue) => "" + paramValue);
const encodeParams = applyToParams.bind(null, encodeParam);
const decodeParams = (
// @ts-expect-error: intentionally avoid the type check
applyToParams.bind(null, decode)
);
function addRoute(parentOrRoute, route) {
let parent;
let record;
if (isRouteName(parentOrRoute)) {
parent = matcher.getRecordMatcher(parentOrRoute);
record = route;
} else {
record = parentOrRoute;
}
return matcher.addRoute(record, parent);
}
function removeRoute(name) {
const recordMatcher = matcher.getRecordMatcher(name);
if (recordMatcher) {
matcher.removeRoute(recordMatcher);
}
}
function getRoutes() {
return matcher.getRoutes().map((routeMatcher) => routeMatcher.record);
}
function hasRoute(name) {
return !!matcher.getRecordMatcher(name);
}
function resolve2(rawLocation, currentLocation) {
currentLocation = assign({}, currentLocation || currentRoute.value);
if (typeof rawLocation === "string") {
const locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);
const matchedRoute2 = matcher.resolve({ path: locationNormalized.path }, currentLocation);
const href2 = routerHistory.createHref(locationNormalized.fullPath);
return assign(locationNormalized, matchedRoute2, {
params: decodeParams(matchedRoute2.params),
hash: decode(locationNormalized.hash),
redirectedFrom: void 0,
href: href2
});
}
let matcherLocation;
if (rawLocation.path != null) {
matcherLocation = assign({}, rawLocation, {
path: parseURL(parseQuery$1, rawLocation.path, currentLocation.path).path
});
} else {
const targetParams = assign({}, rawLocation.params);
for (const key in targetParams) {
if (targetParams[key] == null) {
delete targetParams[key];
}
}
matcherLocation = assign({}, rawLocation, {
params: encodeParams(targetParams)
});
currentLocation.params = encodeParams(currentLocation.params);
}
const matchedRoute = matcher.resolve(matcherLocation, currentLocation);
const hash = rawLocation.hash || "";
matchedRoute.params = normalizeParams(decodeParams(matchedRoute.params));
const fullPath = stringifyURL(stringifyQuery$1, assign({}, rawLocation, {
hash: encodeHash(hash),
path: matchedRoute.path
}));
const href = routerHistory.createHref(fullPath);
return assign({
fullPath,
// keep the hash encoded so fullPath is effectively path + encodedQuery +
// hash
hash,
query: (
// if the user is using a custom query lib like qs, we might have
// nested objects, so we keep the query as is, meaning it can contain
// numbers at `$route.query`, but at the point, the user will have to
// use their own type anyway.
// https://github.com/vuejs/router/issues/328#issuecomment-649481567
stringifyQuery$1 === stringifyQuery ? normalizeQuery(rawLocation.query) : rawLocation.query || {}
)
}, matchedRoute, {
redirectedFrom: void 0,
href
});
}
function locationAsObject(to) {
return typeof to === "string" ? parseURL(parseQuery$1, to, currentRoute.value.path) : assign({}, to);
}
function checkCanceledNavigation(to, from) {
if (pendingLocation !== to) {
return createRouterError(8, {
from,
to
});
}
}
function push(to) {
return pushWithRedirect(to);
}
function replace(to) {
return push(assign(locationAsObject(to), { replace: true }));
}
function handleRedirectRecord(to) {
const lastMatched = to.matched[to.matched.length - 1];
if (lastMatched && lastMatched.redirect) {
const { redirect } = lastMatched;
let newTargetLocation = typeof redirect === "function" ? redirect(to) : redirect;
if (typeof newTargetLocation === "string") {
newTargetLocation = newTargetLocation.includes("?") || newTargetLocation.includes("#") ? newTargetLocation = locationAsObject(newTargetLocation) : (
// force empty params
{ path: newTargetLocation }
);
newTargetLocation.params = {};
}
return assign({
query: to.query,
hash: to.hash,
// avoid transferring params if the redirect has a path
params: newTargetLocation.path != null ? {} : to.params
}, newTargetLocation);
}
}
function pushWithRedirect(to, redirectedFrom) {
const targetLocation = pendingLocation = resolve2(to);
const from = currentRoute.value;
const data4 = to.state;
const force = to.force;
const replace2 = to.replace === true;
const shouldRedirect = handleRedirectRecord(targetLocation);
if (shouldRedirect)
return pushWithRedirect(
assign(locationAsObject(shouldRedirect), {
state: typeof shouldRedirect === "object" ? assign({}, data4, shouldRedirect.state) : data4,
force,
replace: replace2
}),
// keep original redirectedFrom if it exists
redirectedFrom || targetLocation
);
const toLocation = targetLocation;
toLocation.redirectedFrom = redirectedFrom;
let failure;
if (!force && isSameRouteLocation(stringifyQuery$1, from, targetLocation)) {
failure = createRouterError(16, { to: toLocation, from });
handleScroll(
from,
from,
// this is a push, the only way for it to be triggered from a
// history.listen is with a redirect, which makes it become a push
true,
// This cannot be the first navigation because the initial location
// cannot be manually navigated to
false
);
}
return (failure ? Promise.resolve(failure) : navigate(toLocation, from)).catch((error) => isNavigationFailure(error) ? (
// navigation redirects still mark the router as ready
isNavigationFailure(
error,
2
/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
) ? error : markAsReady(error)
) : (
// reject any unknown error
triggerError(error, toLocation, from)
)).then((failure2) => {
if (failure2) {
if (isNavigationFailure(
failure2,
2
/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
)) {
return pushWithRedirect(
// keep options
assign({
// preserve an existing replacement but allow the redirect to override it
replace: replace2
}, locationAsObject(failure2.to), {
state: typeof failure2.to === "object" ? assign({}, data4, failure2.to.state) : data4,
force
}),
// preserve the original redirectedFrom if any
redirectedFrom || toLocation
);
}
} else {
failure2 = finalizeNavigation(toLocation, from, true, replace2, data4);
}
triggerAfterEach(toLocation, from, failure2);
return failure2;
});
}
function checkCanceledNavigationAndReject(to, from) {
const error = checkCanceledNavigation(to, from);
return error ? Promise.reject(error) : Promise.resolve();
}
function runWithContext(fn) {
const app2 = installedApps.values().next().value;
return app2 && typeof app2.runWithContext === "function" ? app2.runWithContext(fn) : fn();
}
function navigate(to, from) {
let guards;
const [leavingRecords, updatingRecords, enteringRecords] = extractChangingRecords(to, from);
guards = extractComponentsGuards(leavingRecords.reverse(), "beforeRouteLeave", to, from);
for (const record of leavingRecords) {
record.leaveGuards.forEach((guard) => {
guards.push(guardToPromiseFn(guard, to, from));
});
}
const canceledNavigationCheck = checkCanceledNavigationAndReject.bind(null, to, from);
guards.push(canceledNavigationCheck);
return runGuardQueue(guards).then(() => {
guards = [];
for (const guard of beforeGuards.list()) {
guards.push(guardToPromiseFn(guard, to, from));
}
guards.push(canceledNavigationCheck);
return runGuardQueue(guards);
}).then(() => {
guards = extractComponentsGuards(updatingRecords, "beforeRouteUpdate", to, from);
for (const record of updatingRecords) {
record.updateGuards.forEach((guard) => {
guards.push(guardToPromiseFn(guard, to, from));
});
}
guards.push(canceledNavigationCheck);
return runGuardQueue(guards);
}).then(() => {
guards = [];
for (const record of enteringRecords) {
if (record.beforeEnter) {
if (isArray$4(record.beforeEnter)) {
for (const beforeEnter of record.beforeEnter)
guards.push(guardToPromiseFn(beforeEnter, to, from));
} else {
guards.push(guardToPromiseFn(record.beforeEnter, to, from));
}
}
}
guards.push(canceledNavigationCheck);
return runGuardQueue(guards);
}).then(() => {
to.matched.forEach((record) => record.enterCallbacks = {});
guards = extractComponentsGuards(enteringRecords, "beforeRouteEnter", to, from, runWithContext);
guards.push(canceledNavigationCheck);
return runGuardQueue(guards);
}).then(() => {
guards = [];
for (const guard of beforeResolveGuards.list()) {
guards.push(guardToPromiseFn(guard, to, from));
}
guards.push(canceledNavigationCheck);
return runGuardQueue(guards);
}).catch((err) => isNavigationFailure(
err,
8
/* ErrorTypes.NAVIGATION_CANCELLED */
) ? err : Promise.reject(err));
}
function triggerAfterEach(to, from, failure) {
afterGuards.list().forEach((guard) => runWithContext(() => guard(to, from, failure)));
}
function finalizeNavigation(toLocation, from, isPush, replace2, data4) {
const error = checkCanceledNavigation(toLocation, from);
if (error)
return error;
const isFirstNavigation = from === START_LOCATION_NORMALIZED;
const state = !isBrowser ? {} : history.state;
if (isPush) {
if (replace2 || isFirstNavigation)
routerHistory.replace(toLocation.fullPath, assign({
scroll: isFirstNavigation && state && state.scroll
}, data4));
else
routerHistory.push(toLocation.fullPath, data4);
}
currentRoute.value = toLocation;
handleScroll(toLocation, from, isPush, isFirstNavigation);
markAsReady();
}
let removeHistoryListener;
function setupListeners() {
if (removeHistoryListener)
return;
removeHistoryListener = routerHistory.listen((to, _from, info) => {
if (!router2.listening)
return;
const toLocation = resolve2(to);
const shouldRedirect = handleRedirectRecord(toLocation);
if (shouldRedirect) {
pushWithRedirect(assign(shouldRedirect, { replace: true }), toLocation).catch(noop);
return;
}
pendingLocation = toLocation;
const from = currentRoute.value;
if (isBrowser) {
saveScrollPosition(getScrollKey(from.fullPath, info.delta), computeScrollPosition());
}
navigate(toLocation, from).catch((error) => {
if (isNavigationFailure(
error,
4 | 8
/* ErrorTypes.NAVIGATION_CANCELLED */
)) {
return error;
}
if (isNavigationFailure(
error,
2
/* ErrorTypes.NAVIGATION_GUARD_REDIRECT */
)) {
pushWithRedirect(
error.to,
toLocation
// avoid an uncaught rejection, let push call triggerError
).then((failure) => {
if (isNavigationFailure(
failure,
4 | 16
/* ErrorTypes.NAVIGATION_DUPLICATED */
) && !info.delta && info.type === NavigationType.pop) {
routerHistory.go(-1, false);
}
}).catch(noop);
return Promise.reject();
}
if (info.delta) {
routerHistory.go(-info.delta, false);
}
return triggerError(error, toLocation, from);
}).then((failure) => {
failure = failure || finalizeNavigation(
// after navigation, all matched components are resolved
toLocation,
from,
false
);
if (failure) {
if (info.delta && // a new navigation has been triggered, so we do not want to revert, that will change the current history
// entry while a different route is displayed
!isNavigationFailure(
failure,
8
/* ErrorTypes.NAVIGATION_CANCELLED */
)) {
routerHistory.go(-info.delta, false);
} else if (info.type === NavigationType.pop && isNavigationFailure(
failure,
4 | 16
/* ErrorTypes.NAVIGATION_DUPLICATED */
)) {
routerHistory.go(-1, false);
}
}
triggerAfterEach(toLocation, from, failure);
}).catch(noop);
});
}
let readyHandlers = useCallbacks();
let errorListeners = useCallbacks();
let ready;
function triggerError(error, to, from) {
markAsReady(error);
const list = errorListeners.list();
if (list.length) {
list.forEach((handler5) => handler5(error, to, from));
} else {
console.error(error);
}
return Promise.reject(error);
}
function isReady() {
if (ready && currentRoute.value !== START_LOCATION_NORMALIZED)
return Promise.resolve();
return new Promise((resolve22, reject) => {
readyHandlers.add([resolve22, reject]);
});
}
function markAsReady(err) {
if (!ready) {
ready = !err;
setupListeners();
readyHandlers.list().forEach(([resolve22, reject]) => err ? reject(err) : resolve22());
readyHandlers.reset();
}
return err;
}
function handleScroll(to, from, isPush, isFirstNavigation) {
const { scrollBehavior } = options;
if (!isBrowser || !scrollBehavior)
return Promise.resolve();
const scrollPosition = !isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0)) || (isFirstNavigation || !isPush) && history.state && history.state.scroll || null;
return nextTick().then(() => scrollBehavior(to, from, scrollPosition)).then((position) => position && scrollToPosition(position)).catch((err) => triggerError(err, to, from));
}
const go = (delta) => routerHistory.go(delta);
let started;
const installedApps = /* @__PURE__ */ new Set();
const router2 = {
currentRoute,
listening: true,
addRoute,
removeRoute,
clearRoutes: matcher.clearRoutes,
hasRoute,
getRoutes,
resolve: resolve2,
options,
push,
replace,
go,
back: () => go(-1),
forward: () => go(1),
beforeEach: beforeGuards.add,
beforeResolve: beforeResolveGuards.add,
afterEach: afterGuards.add,
onError: errorListeners.add,
isReady,
install(app2) {
const router22 = this;
app2.component("RouterLink", RouterLink);
app2.component("RouterView", RouterView);
app2.config.globalProperties.$router = router22;
Object.defineProperty(app2.config.globalProperties, "$route", {
enumerable: true,
get: () => unref(currentRoute)
});
if (isBrowser && // used for the initial navigation client side to avoid pushing
// multiple times when the router is used in multiple apps
!started && currentRoute.value === START_LOCATION_NORMALIZED) {
started = true;
push(routerHistory.location).catch((err) => {
});
}
const reactiveRoute = {};
for (const key in START_LOCATION_NORMALIZED) {
Object.defineProperty(reactiveRoute, key, {
get: () => currentRoute.value[key],
enumerable: true
});
}
app2.provide(routerKey, router22);
app2.provide(routeLocationKey, shallowReactive(reactiveRoute));
app2.provide(routerViewLocationKey, currentRoute);
const unmountApp = app2.unmount;
installedApps.add(app2);
app2.unmount = function() {
installedApps.delete(app2);
if (installedApps.size < 1) {
pendingLocation = START_LOCATION_NORMALIZED;
removeHistoryListener && removeHistoryListener();
removeHistoryListener = null;
currentRoute.value = START_LOCATION_NORMALIZED;
started = false;
ready = false;
}
unmountApp();
};
}
};
function runGuardQueue(guards) {
return guards.reduce((promise, guard) => promise.then(() => runWithContext(guard)), Promise.resolve());
}
return router2;
}
function extractChangingRecords(to, from) {
const leavingRecords = [];
const updatingRecords = [];
const enteringRecords = [];
const len = Math.max(from.matched.length, to.matched.length);
for (let i = 0; i < len; i++) {
const recordFrom = from.matched[i];
if (recordFrom) {
if (to.matched.find((record) => isSameRouteRecord(record, recordFrom)))
updatingRecords.push(recordFrom);
else
leavingRecords.push(recordFrom);
}
const recordTo = to.matched[i];
if (recordTo) {
if (!from.matched.find((record) => isSameRouteRecord(record, recordTo))) {
enteringRecords.push(recordTo);
}
}
}
return [leavingRecords, updatingRecords, enteringRecords];
}
const useIndexStore = /* @__PURE__ */ defineStore("index", () => {
const debug = false;
const dashboardLoaded = ref(false);
const scriptName2 = "WaniKani Reviews Plus";
const scriptId2 = "waniKaniReviewsPlus";
const loadingCount = ref(0);
const defaultSettings = ref({
answers: {
showOnWrong: true,
showOnRight: true,
showOnRightSolo: true
},
breakdown: {
showBreakdown: true
},
tally: {
showTally: true,
showTallyLive: true
}
});
const settings = ref();
const loading = computed(() => loadingCount.value > 0);
const showAnswers = computed(
() => settings.value.answers.showOnRight || settings.value.answers.showOnWrong
);
return {
loading,
settings,
debug,
defaultSettings,
scriptId: scriptId2,
scriptName: scriptName2,
showAnswers,
dashboardLoaded
};
});
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getDefaultExportFromCjs(x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
var lodash = { exports: {} };
/**
* @license
* Lodash <https://lodash.com/>
* Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
* Released under MIT license <https://lodash.com/license>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
*/
lodash.exports;
(function(module, exports) {
(function() {
var undefined$1;
var VERSION = "4.17.21";
var LARGE_ARRAY_SIZE2 = 200;
var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
var MAX_MEMOIZE_SIZE = 500;
var PLACEHOLDER = "__lodash_placeholder__";
var CLONE_DEEP_FLAG2 = 1, CLONE_FLAT_FLAG2 = 2, CLONE_SYMBOLS_FLAG2 = 4;
var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512;
var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = "...";
var HOT_COUNT = 800, HOT_SPAN = 16;
var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3;
var INFINITY = 1 / 0, MAX_SAFE_INTEGER2 = 9007199254740991, MAX_INTEGER = 17976931348623157e292, NAN = 0 / 0;
var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
var wrapFlags = [
["ary", WRAP_ARY_FLAG],
["bind", WRAP_BIND_FLAG],
["bindKey", WRAP_BIND_KEY_FLAG],
["curry", WRAP_CURRY_FLAG],
["curryRight", WRAP_CURRY_RIGHT_FLAG],
["flip", WRAP_FLIP_FLAG],
["partial", WRAP_PARTIAL_FLAG],
["partialRight", WRAP_PARTIAL_RIGHT_FLAG],
["rearg", WRAP_REARG_FLAG]
];
var argsTag2 = "[object Arguments]", arrayTag2 = "[object Array]", asyncTag2 = "[object AsyncFunction]", boolTag2 = "[object Boolean]", dateTag2 = "[object Date]", domExcTag = "[object DOMException]", errorTag2 = "[object Error]", funcTag2 = "[object Function]", genTag2 = "[object GeneratorFunction]", mapTag2 = "[object Map]", numberTag2 = "[object Number]", nullTag2 = "[object Null]", objectTag2 = "[object Object]", promiseTag2 = "[object Promise]", proxyTag2 = "[object Proxy]", regexpTag2 = "[object RegExp]", setTag2 = "[object Set]", stringTag2 = "[object String]", symbolTag2 = "[object Symbol]", undefinedTag2 = "[object Undefined]", weakMapTag2 = "[object WeakMap]", weakSetTag = "[object WeakSet]";
var arrayBufferTag2 = "[object ArrayBuffer]", dataViewTag2 = "[object DataView]", float32Tag2 = "[object Float32Array]", float64Tag2 = "[object Float64Array]", int8Tag2 = "[object Int8Array]", int16Tag2 = "[object Int16Array]", int32Tag2 = "[object Int32Array]", uint8Tag2 = "[object Uint8Array]", uint8ClampedTag2 = "[object Uint8ClampedArray]", uint16Tag2 = "[object Uint16Array]", uint32Tag2 = "[object Uint32Array]";
var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml = /[&<>"']/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g;
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
var reRegExpChar2 = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar2.source);
var reTrimStart = /^\s+/;
var reWhitespace = /\s/;
var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /;
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
var reEscapeChar = /\\(\\)?/g;
var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
var reFlags2 = /\w*$/;
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
var reIsBinary = /^0b[01]+$/i;
var reIsHostCtor2 = /^\[object .+?Constructor\]$/;
var reIsOctal = /^0o[0-7]+$/i;
var reIsUint2 = /^(?:0|[1-9]\d*)$/;
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
var reNoMatch = /($^)/;
var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
var rsApos = "['’]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
var reApos = RegExp(rsApos, "g");
var reComboMark = RegExp(rsCombo, "g");
var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
var reUnicodeWord = RegExp([
rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
rsUpper + "+" + rsOptContrUpper,
rsOrdUpper,
rsOrdLower,
rsDigits,
rsEmoji
].join("|"), "g");
var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
var contextProps = [
"Array",
"Buffer",
"DataView",
"Date",
"Error",
"Float32Array",
"Float64Array",
"Function",
"Int8Array",
"Int16Array",
"Int32Array",
"Map",
"Math",
"Object",
"Promise",
"RegExp",
"Set",
"String",
"Symbol",
"TypeError",
"Uint8Array",
"Uint8ClampedArray",
"Uint16Array",
"Uint32Array",
"WeakMap",
"_",
"clearTimeout",
"isFinite",
"parseInt",
"setTimeout"
];
var templateCounter = -1;
var typedArrayTags2 = {};
typedArrayTags2[float32Tag2] = typedArrayTags2[float64Tag2] = typedArrayTags2[int8Tag2] = typedArrayTags2[int16Tag2] = typedArrayTags2[int32Tag2] = typedArrayTags2[uint8Tag2] = typedArrayTags2[uint8ClampedTag2] = typedArrayTags2[uint16Tag2] = typedArrayTags2[uint32Tag2] = true;
typedArrayTags2[argsTag2] = typedArrayTags2[arrayTag2] = typedArrayTags2[arrayBufferTag2] = typedArrayTags2[boolTag2] = typedArrayTags2[dataViewTag2] = typedArrayTags2[dateTag2] = typedArrayTags2[errorTag2] = typedArrayTags2[funcTag2] = typedArrayTags2[mapTag2] = typedArrayTags2[numberTag2] = typedArrayTags2[objectTag2] = typedArrayTags2[regexpTag2] = typedArrayTags2[setTag2] = typedArrayTags2[stringTag2] = typedArrayTags2[weakMapTag2] = false;
var cloneableTags2 = {};
cloneableTags2[argsTag2] = cloneableTags2[arrayTag2] = cloneableTags2[arrayBufferTag2] = cloneableTags2[dataViewTag2] = cloneableTags2[boolTag2] = cloneableTags2[dateTag2] = cloneableTags2[float32Tag2] = cloneableTags2[float64Tag2] = cloneableTags2[int8Tag2] = cloneableTags2[int16Tag2] = cloneableTags2[int32Tag2] = cloneableTags2[mapTag2] = cloneableTags2[numberTag2] = cloneableTags2[objectTag2] = cloneableTags2[regexpTag2] = cloneableTags2[setTag2] = cloneableTags2[stringTag2] = cloneableTags2[symbolTag2] = cloneableTags2[uint8Tag2] = cloneableTags2[uint8ClampedTag2] = cloneableTags2[uint16Tag2] = cloneableTags2[uint32Tag2] = true;
cloneableTags2[errorTag2] = cloneableTags2[funcTag2] = cloneableTags2[weakMapTag2] = false;
var deburredLetters = {
// Latin-1 Supplement block.
"À": "A",
"Á": "A",
"Â": "A",
"Ã": "A",
"Ä": "A",
"Å": "A",
"à": "a",
"á": "a",
"â": "a",
"ã": "a",
"ä": "a",
"å": "a",
"Ç": "C",
"ç": "c",
"Ð": "D",
"ð": "d",
"È": "E",
"É": "E",
"Ê": "E",
"Ë": "E",
"è": "e",
"é": "e",
"ê": "e",
"ë": "e",
"Ì": "I",
"Í": "I",
"Î": "I",
"Ï": "I",
"ì": "i",
"í": "i",
"î": "i",
"ï": "i",
"Ñ": "N",
"ñ": "n",
"Ò": "O",
"Ó": "O",
"Ô": "O",
"Õ": "O",
"Ö": "O",
"Ø": "O",
"ò": "o",
"ó": "o",
"ô": "o",
"õ": "o",
"ö": "o",
"ø": "o",
"Ù": "U",
"Ú": "U",
"Û": "U",
"Ü": "U",
"ù": "u",
"ú": "u",
"û": "u",
"ü": "u",
"Ý": "Y",
"ý": "y",
"ÿ": "y",
"Æ": "Ae",
"æ": "ae",
"Þ": "Th",
"þ": "th",
"ß": "ss",
// Latin Extended-A block.
"Ā": "A",
"Ă": "A",
"Ą": "A",
"ā": "a",
"ă": "a",
"ą": "a",
"Ć": "C",
"Ĉ": "C",
"Ċ": "C",
"Č": "C",
"ć": "c",
"ĉ": "c",
"ċ": "c",
"č": "c",
"Ď": "D",
"Đ": "D",
"ď": "d",
"đ": "d",
"Ē": "E",
"Ĕ": "E",
"Ė": "E",
"Ę": "E",
"Ě": "E",
"ē": "e",
"ĕ": "e",
"ė": "e",
"ę": "e",
"ě": "e",
"Ĝ": "G",
"Ğ": "G",
"Ġ": "G",
"Ģ": "G",
"ĝ": "g",
"ğ": "g",
"ġ": "g",
"ģ": "g",
"Ĥ": "H",
"Ħ": "H",
"ĥ": "h",
"ħ": "h",
"Ĩ": "I",
"Ī": "I",
"Ĭ": "I",
"Į": "I",
"İ": "I",
"ĩ": "i",
"ī": "i",
"ĭ": "i",
"į": "i",
"ı": "i",
"Ĵ": "J",
"ĵ": "j",
"Ķ": "K",
"ķ": "k",
"ĸ": "k",
"Ĺ": "L",
"Ļ": "L",
"Ľ": "L",
"Ŀ": "L",
"Ł": "L",
"ĺ": "l",
"ļ": "l",
"ľ": "l",
"ŀ": "l",
"ł": "l",
"Ń": "N",
"Ņ": "N",
"Ň": "N",
"Ŋ": "N",
"ń": "n",
"ņ": "n",
"ň": "n",
"ŋ": "n",
"Ō": "O",
"Ŏ": "O",
"Ő": "O",
"ō": "o",
"ŏ": "o",
"ő": "o",
"Ŕ": "R",
"Ŗ": "R",
"Ř": "R",
"ŕ": "r",
"ŗ": "r",
"ř": "r",
"Ś": "S",
"Ŝ": "S",
"Ş": "S",
"Š": "S",
"ś": "s",
"ŝ": "s",
"ş": "s",
"š": "s",
"Ţ": "T",
"Ť": "T",
"Ŧ": "T",
"ţ": "t",
"ť": "t",
"ŧ": "t",
"Ũ": "U",
"Ū": "U",
"Ŭ": "U",
"Ů": "U",
"Ű": "U",
"Ų": "U",
"ũ": "u",
"ū": "u",
"ŭ": "u",
"ů": "u",
"ű": "u",
"ų": "u",
"Ŵ": "W",
"ŵ": "w",
"Ŷ": "Y",
"ŷ": "y",
"Ÿ": "Y",
"Ź": "Z",
"Ż": "Z",
"Ž": "Z",
"ź": "z",
"ż": "z",
"ž": "z",
"IJ": "IJ",
"ij": "ij",
"Œ": "Oe",
"œ": "oe",
"ʼn": "'n",
"ſ": "s"
};
var htmlEscapes = {
"&": "&",
"<": "<",
">": ">",
'"': """,
"'": "'"
};
var htmlUnescapes = {
"&": "&",
"<": "<",
">": ">",
""": '"',
"'": "'"
};
var stringEscapes = {
"\\": "\\",
"'": "'",
"\n": "n",
"\r": "r",
"\u2028": "u2028",
"\u2029": "u2029"
};
var freeParseFloat = parseFloat, freeParseInt = parseInt;
var freeGlobal2 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
var freeSelf2 = typeof self == "object" && self && self.Object === Object && self;
var root7 = freeGlobal2 || freeSelf2 || Function("return this")();
var freeExports = exports && !exports.nodeType && exports;
var freeModule = freeExports && true && module && !module.nodeType && module;
var moduleExports = freeModule && freeModule.exports === freeExports;
var freeProcess = moduleExports && freeGlobal2.process;
var nodeUtil2 = function() {
try {
var types = freeModule && freeModule.require && freeModule.require("util").types;
if (types) {
return types;
}
return freeProcess && freeProcess.binding && freeProcess.binding("util");
} catch (e) {
}
}();
var nodeIsArrayBuffer = nodeUtil2 && nodeUtil2.isArrayBuffer, nodeIsDate = nodeUtil2 && nodeUtil2.isDate, nodeIsMap2 = nodeUtil2 && nodeUtil2.isMap, nodeIsRegExp = nodeUtil2 && nodeUtil2.isRegExp, nodeIsSet2 = nodeUtil2 && nodeUtil2.isSet, nodeIsTypedArray2 = nodeUtil2 && nodeUtil2.isTypedArray;
function apply2(func, thisArg, args) {
switch (args.length) {
case 0:
return func.call(thisArg);
case 1:
return func.call(thisArg, args[0]);
case 2:
return func.call(thisArg, args[0], args[1]);
case 3:
return func.call(thisArg, args[0], args[1], args[2]);
}
return func.apply(thisArg, args);
}
function arrayAggregator(array, setter, iteratee, accumulator) {
var index2 = -1, length = array == null ? 0 : array.length;
while (++index2 < length) {
var value = array[index2];
setter(accumulator, value, iteratee(value), array);
}
return accumulator;
}
function arrayEach2(array, iteratee) {
var index2 = -1, length = array == null ? 0 : array.length;
while (++index2 < length) {
if (iteratee(array[index2], index2, array) === false) {
break;
}
}
return array;
}
function arrayEachRight(array, iteratee) {
var length = array == null ? 0 : array.length;
while (length--) {
if (iteratee(array[length], length, array) === false) {
break;
}
}
return array;
}
function arrayEvery(array, predicate) {
var index2 = -1, length = array == null ? 0 : array.length;
while (++index2 < length) {
if (!predicate(array[index2], index2, array)) {
return false;
}
}
return true;
}
function arrayFilter2(array, predicate) {
var index2 = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
while (++index2 < length) {
var value = array[index2];
if (predicate(value, index2, array)) {
result[resIndex++] = value;
}
}
return result;
}
function arrayIncludes(array, value) {
var length = array == null ? 0 : array.length;
return !!length && baseIndexOf(array, value, 0) > -1;
}
function arrayIncludesWith(array, value, comparator) {
var index2 = -1, length = array == null ? 0 : array.length;
while (++index2 < length) {
if (comparator(value, array[index2])) {
return true;
}
}
return false;
}
function arrayMap(array, iteratee) {
var index2 = -1, length = array == null ? 0 : array.length, result = Array(length);
while (++index2 < length) {
result[index2] = iteratee(array[index2], index2, array);
}
return result;
}
function arrayPush2(array, values) {
var index2 = -1, length = values.length, offset = array.length;
while (++index2 < length) {
array[offset + index2] = values[index2];
}
return array;
}
function arrayReduce(array, iteratee, accumulator, initAccum) {
var index2 = -1, length = array == null ? 0 : array.length;
if (initAccum && length) {
accumulator = array[++index2];
}
while (++index2 < length) {
accumulator = iteratee(accumulator, array[index2], index2, array);
}
return accumulator;
}
function arrayReduceRight(array, iteratee, accumulator, initAccum) {
var length = array == null ? 0 : array.length;
if (initAccum && length) {
accumulator = array[--length];
}
while (length--) {
accumulator = iteratee(accumulator, array[length], length, array);
}
return accumulator;
}
function arraySome(array, predicate) {
var index2 = -1, length = array == null ? 0 : array.length;
while (++index2 < length) {
if (predicate(array[index2], index2, array)) {
return true;
}
}
return false;
}
var asciiSize = baseProperty("length");
function asciiToArray(string) {
return string.split("");
}
function asciiWords(string) {
return string.match(reAsciiWord) || [];
}
function baseFindKey(collection, predicate, eachFunc) {
var result;
eachFunc(collection, function(value, key, collection2) {
if (predicate(value, key, collection2)) {
result = key;
return false;
}
});
return result;
}
function baseFindIndex(array, predicate, fromIndex, fromRight) {
var length = array.length, index2 = fromIndex + (fromRight ? 1 : -1);
while (fromRight ? index2-- : ++index2 < length) {
if (predicate(array[index2], index2, array)) {
return index2;
}
}
return -1;
}
function baseIndexOf(array, value, fromIndex) {
return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
}
function baseIndexOfWith(array, value, fromIndex, comparator) {
var index2 = fromIndex - 1, length = array.length;
while (++index2 < length) {
if (comparator(array[index2], value)) {
return index2;
}
}
return -1;
}
function baseIsNaN(value) {
return value !== value;
}
function baseMean(array, iteratee) {
var length = array == null ? 0 : array.length;
return length ? baseSum(array, iteratee) / length : NAN;
}
function baseProperty(key) {
return function(object) {
return object == null ? undefined$1 : object[key];
};
}
function basePropertyOf(object) {
return function(key) {
return object == null ? undefined$1 : object[key];
};
}
function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
eachFunc(collection, function(value, index2, collection2) {
accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index2, collection2);
});
return accumulator;
}
function baseSortBy(array, comparer) {
var length = array.length;
array.sort(comparer);
while (length--) {
array[length] = array[length].value;
}
return array;
}
function baseSum(array, iteratee) {
var result, index2 = -1, length = array.length;
while (++index2 < length) {
var current = iteratee(array[index2]);
if (current !== undefined$1) {
result = result === undefined$1 ? current : result + current;
}
}
return result;
}
function baseTimes2(n, iteratee) {
var index2 = -1, result = Array(n);
while (++index2 < n) {
result[index2] = iteratee(index2);
}
return result;
}
function baseToPairs(object, props) {
return arrayMap(props, function(key) {
return [key, object[key]];
});
}
function baseTrim(string) {
return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
}
function baseUnary2(func) {
return function(value) {
return func(value);
};
}
function baseValues(object, props) {
return arrayMap(props, function(key) {
return object[key];
});
}
function cacheHas(cache, key) {
return cache.has(key);
}
function charsStartIndex(strSymbols, chrSymbols) {
var index2 = -1, length = strSymbols.length;
while (++index2 < length && baseIndexOf(chrSymbols, strSymbols[index2], 0) > -1) {
}
return index2;
}
function charsEndIndex(strSymbols, chrSymbols) {
var index2 = strSymbols.length;
while (index2-- && baseIndexOf(chrSymbols, strSymbols[index2], 0) > -1) {
}
return index2;
}
function countHolders(array, placeholder) {
var length = array.length, result = 0;
while (length--) {
if (array[length] === placeholder) {
++result;
}
}
return result;
}
var deburrLetter = basePropertyOf(deburredLetters);
var escapeHtmlChar = basePropertyOf(htmlEscapes);
function escapeStringChar(chr) {
return "\\" + stringEscapes[chr];
}
function getValue2(object, key) {
return object == null ? undefined$1 : object[key];
}
function hasUnicode(string) {
return reHasUnicode.test(string);
}
function hasUnicodeWord(string) {
return reHasUnicodeWord.test(string);
}
function iteratorToArray(iterator2) {
var data4, result = [];
while (!(data4 = iterator2.next()).done) {
result.push(data4.value);
}
return result;
}
function mapToArray(map) {
var index2 = -1, result = Array(map.size);
map.forEach(function(value, key) {
result[++index2] = [key, value];
});
return result;
}
function overArg2(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
function replaceHolders(array, placeholder) {
var index2 = -1, length = array.length, resIndex = 0, result = [];
while (++index2 < length) {
var value = array[index2];
if (value === placeholder || value === PLACEHOLDER) {
array[index2] = PLACEHOLDER;
result[resIndex++] = index2;
}
}
return result;
}
function setToArray(set2) {
var index2 = -1, result = Array(set2.size);
set2.forEach(function(value) {
result[++index2] = value;
});
return result;
}
function setToPairs(set2) {
var index2 = -1, result = Array(set2.size);
set2.forEach(function(value) {
result[++index2] = [value, value];
});
return result;
}
function strictIndexOf(array, value, fromIndex) {
var index2 = fromIndex - 1, length = array.length;
while (++index2 < length) {
if (array[index2] === value) {
return index2;
}
}
return -1;
}
function strictLastIndexOf(array, value, fromIndex) {
var index2 = fromIndex + 1;
while (index2--) {
if (array[index2] === value) {
return index2;
}
}
return index2;
}
function stringSize(string) {
return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
}
function stringToArray(string) {
return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
}
function trimmedEndIndex(string) {
var index2 = string.length;
while (index2-- && reWhitespace.test(string.charAt(index2))) {
}
return index2;
}
var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
function unicodeSize(string) {
var result = reUnicode.lastIndex = 0;
while (reUnicode.test(string)) {
++result;
}
return result;
}
function unicodeToArray(string) {
return string.match(reUnicode) || [];
}
function unicodeWords(string) {
return string.match(reUnicodeWord) || [];
}
var runInContext = function runInContext2(context) {
context = context == null ? root7 : _.defaults(root7.Object(), context, _.pick(root7, contextProps));
var Array2 = context.Array, Date2 = context.Date, Error2 = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String2 = context.String, TypeError2 = context.TypeError;
var arrayProto2 = Array2.prototype, funcProto2 = Function2.prototype, objectProto2 = Object2.prototype;
var coreJsData2 = context["__core-js_shared__"];
var funcToString2 = funcProto2.toString;
var hasOwnProperty2 = objectProto2.hasOwnProperty;
var idCounter = 0;
var maskSrcKey2 = function() {
var uid2 = /[^.]+$/.exec(coreJsData2 && coreJsData2.keys && coreJsData2.keys.IE_PROTO || "");
return uid2 ? "Symbol(src)_1." + uid2 : "";
}();
var nativeObjectToString2 = objectProto2.toString;
var objectCtorString = funcToString2.call(Object2);
var oldDash = root7._;
var reIsNative2 = RegExp2(
"^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar2, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
);
var Buffer = moduleExports ? context.Buffer : undefined$1, Symbol2 = context.Symbol, Uint8Array2 = context.Uint8Array, allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined$1, getPrototype2 = overArg2(Object2.getPrototypeOf, Object2), objectCreate2 = Object2.create, propertyIsEnumerable2 = objectProto2.propertyIsEnumerable, splice2 = arrayProto2.splice, spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : undefined$1, symIterator = Symbol2 ? Symbol2.iterator : undefined$1, symToStringTag2 = Symbol2 ? Symbol2.toStringTag : undefined$1;
var defineProperty2 = function() {
try {
var func = getNative2(Object2, "defineProperty");
func({}, "", {});
return func;
} catch (e) {
}
}();
var ctxClearTimeout = context.clearTimeout !== root7.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root7.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root7.setTimeout && context.setTimeout;
var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols2 = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined$1, nativeIsFinite = context.isFinite, nativeJoin = arrayProto2.join, nativeKeys2 = overArg2(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto2.reverse;
var DataView2 = getNative2(context, "DataView"), Map2 = getNative2(context, "Map"), Promise2 = getNative2(context, "Promise"), Set2 = getNative2(context, "Set"), WeakMap2 = getNative2(context, "WeakMap"), nativeCreate2 = getNative2(Object2, "create");
var metaMap = WeakMap2 && new WeakMap2();
var realNames = {};
var dataViewCtorString2 = toSource2(DataView2), mapCtorString2 = toSource2(Map2), promiseCtorString2 = toSource2(Promise2), setCtorString2 = toSource2(Set2), weakMapCtorString2 = toSource2(WeakMap2);
var symbolProto2 = Symbol2 ? Symbol2.prototype : undefined$1, symbolValueOf2 = symbolProto2 ? symbolProto2.valueOf : undefined$1, symbolToString = symbolProto2 ? symbolProto2.toString : undefined$1;
function lodash2(value) {
if (isObjectLike2(value) && !isArray2(value) && !(value instanceof LazyWrapper)) {
if (value instanceof LodashWrapper) {
return value;
}
if (hasOwnProperty2.call(value, "__wrapped__")) {
return wrapperClone(value);
}
}
return new LodashWrapper(value);
}
var baseCreate2 = /* @__PURE__ */ function() {
function object() {
}
return function(proto) {
if (!isObject2(proto)) {
return {};
}
if (objectCreate2) {
return objectCreate2(proto);
}
object.prototype = proto;
var result2 = new object();
object.prototype = undefined$1;
return result2;
};
}();
function baseLodash() {
}
function LodashWrapper(value, chainAll) {
this.__wrapped__ = value;
this.__actions__ = [];
this.__chain__ = !!chainAll;
this.__index__ = 0;
this.__values__ = undefined$1;
}
lodash2.templateSettings = {
/**
* Used to detect `data` property values to be HTML-escaped.
*
* @memberOf _.templateSettings
* @type {RegExp}
*/
"escape": reEscape,
/**
* Used to detect code to be evaluated.
*
* @memberOf _.templateSettings
* @type {RegExp}
*/
"evaluate": reEvaluate,
/**
* Used to detect `data` property values to inject.
*
* @memberOf _.templateSettings
* @type {RegExp}
*/
"interpolate": reInterpolate,
/**
* Used to reference the data object in the template text.
*
* @memberOf _.templateSettings
* @type {string}
*/
"variable": "",
/**
* Used to import variables into the compiled template.
*
* @memberOf _.templateSettings
* @type {Object}
*/
"imports": {
/**
* A reference to the `lodash` function.
*
* @memberOf _.templateSettings.imports
* @type {Function}
*/
"_": lodash2
}
};
lodash2.prototype = baseLodash.prototype;
lodash2.prototype.constructor = lodash2;
LodashWrapper.prototype = baseCreate2(baseLodash.prototype);
LodashWrapper.prototype.constructor = LodashWrapper;
function LazyWrapper(value) {
this.__wrapped__ = value;
this.__actions__ = [];
this.__dir__ = 1;
this.__filtered__ = false;
this.__iteratees__ = [];
this.__takeCount__ = MAX_ARRAY_LENGTH;
this.__views__ = [];
}
function lazyClone() {
var result2 = new LazyWrapper(this.__wrapped__);
result2.__actions__ = copyArray2(this.__actions__);
result2.__dir__ = this.__dir__;
result2.__filtered__ = this.__filtered__;
result2.__iteratees__ = copyArray2(this.__iteratees__);
result2.__takeCount__ = this.__takeCount__;
result2.__views__ = copyArray2(this.__views__);
return result2;
}
function lazyReverse() {
if (this.__filtered__) {
var result2 = new LazyWrapper(this);
result2.__dir__ = -1;
result2.__filtered__ = true;
} else {
result2 = this.clone();
result2.__dir__ *= -1;
}
return result2;
}
function lazyValue() {
var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray2(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index2 = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__);
if (!isArr || !isRight && arrLength == length && takeCount == length) {
return baseWrapperValue(array, this.__actions__);
}
var result2 = [];
outer:
while (length-- && resIndex < takeCount) {
index2 += dir;
var iterIndex = -1, value = array[index2];
while (++iterIndex < iterLength) {
var data4 = iteratees[iterIndex], iteratee2 = data4.iteratee, type = data4.type, computed2 = iteratee2(value);
if (type == LAZY_MAP_FLAG) {
value = computed2;
} else if (!computed2) {
if (type == LAZY_FILTER_FLAG) {
continue outer;
} else {
break outer;
}
}
}
result2[resIndex++] = value;
}
return result2;
}
LazyWrapper.prototype = baseCreate2(baseLodash.prototype);
LazyWrapper.prototype.constructor = LazyWrapper;
function Hash2(entries) {
var index2 = -1, length = entries == null ? 0 : entries.length;
this.clear();
while (++index2 < length) {
var entry = entries[index2];
this.set(entry[0], entry[1]);
}
}
function hashClear2() {
this.__data__ = nativeCreate2 ? nativeCreate2(null) : {};
this.size = 0;
}
function hashDelete2(key) {
var result2 = this.has(key) && delete this.__data__[key];
this.size -= result2 ? 1 : 0;
return result2;
}
function hashGet2(key) {
var data4 = this.__data__;
if (nativeCreate2) {
var result2 = data4[key];
return result2 === HASH_UNDEFINED2 ? undefined$1 : result2;
}
return hasOwnProperty2.call(data4, key) ? data4[key] : undefined$1;
}
function hashHas2(key) {
var data4 = this.__data__;
return nativeCreate2 ? data4[key] !== undefined$1 : hasOwnProperty2.call(data4, key);
}
function hashSet2(key, value) {
var data4 = this.__data__;
this.size += this.has(key) ? 0 : 1;
data4[key] = nativeCreate2 && value === undefined$1 ? HASH_UNDEFINED2 : value;
return this;
}
Hash2.prototype.clear = hashClear2;
Hash2.prototype["delete"] = hashDelete2;
Hash2.prototype.get = hashGet2;
Hash2.prototype.has = hashHas2;
Hash2.prototype.set = hashSet2;
function ListCache2(entries) {
var index2 = -1, length = entries == null ? 0 : entries.length;
this.clear();
while (++index2 < length) {
var entry = entries[index2];
this.set(entry[0], entry[1]);
}
}
function listCacheClear2() {
this.__data__ = [];
this.size = 0;
}
function listCacheDelete2(key) {
var data4 = this.__data__, index2 = assocIndexOf2(data4, key);
if (index2 < 0) {
return false;
}
var lastIndex = data4.length - 1;
if (index2 == lastIndex) {
data4.pop();
} else {
splice2.call(data4, index2, 1);
}
--this.size;
return true;
}
function listCacheGet2(key) {
var data4 = this.__data__, index2 = assocIndexOf2(data4, key);
return index2 < 0 ? undefined$1 : data4[index2][1];
}
function listCacheHas2(key) {
return assocIndexOf2(this.__data__, key) > -1;
}
function listCacheSet2(key, value) {
var data4 = this.__data__, index2 = assocIndexOf2(data4, key);
if (index2 < 0) {
++this.size;
data4.push([key, value]);
} else {
data4[index2][1] = value;
}
return this;
}
ListCache2.prototype.clear = listCacheClear2;
ListCache2.prototype["delete"] = listCacheDelete2;
ListCache2.prototype.get = listCacheGet2;
ListCache2.prototype.has = listCacheHas2;
ListCache2.prototype.set = listCacheSet2;
function MapCache2(entries) {
var index2 = -1, length = entries == null ? 0 : entries.length;
this.clear();
while (++index2 < length) {
var entry = entries[index2];
this.set(entry[0], entry[1]);
}
}
function mapCacheClear2() {
this.size = 0;
this.__data__ = {
"hash": new Hash2(),
"map": new (Map2 || ListCache2)(),
"string": new Hash2()
};
}
function mapCacheDelete2(key) {
var result2 = getMapData2(this, key)["delete"](key);
this.size -= result2 ? 1 : 0;
return result2;
}
function mapCacheGet2(key) {
return getMapData2(this, key).get(key);
}
function mapCacheHas2(key) {
return getMapData2(this, key).has(key);
}
function mapCacheSet2(key, value) {
var data4 = getMapData2(this, key), size3 = data4.size;
data4.set(key, value);
this.size += data4.size == size3 ? 0 : 1;
return this;
}
MapCache2.prototype.clear = mapCacheClear2;
MapCache2.prototype["delete"] = mapCacheDelete2;
MapCache2.prototype.get = mapCacheGet2;
MapCache2.prototype.has = mapCacheHas2;
MapCache2.prototype.set = mapCacheSet2;
function SetCache(values2) {
var index2 = -1, length = values2 == null ? 0 : values2.length;
this.__data__ = new MapCache2();
while (++index2 < length) {
this.add(values2[index2]);
}
}
function setCacheAdd(value) {
this.__data__.set(value, HASH_UNDEFINED2);
return this;
}
function setCacheHas(value) {
return this.__data__.has(value);
}
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
SetCache.prototype.has = setCacheHas;
function Stack2(entries) {
var data4 = this.__data__ = new ListCache2(entries);
this.size = data4.size;
}
function stackClear2() {
this.__data__ = new ListCache2();
this.size = 0;
}
function stackDelete2(key) {
var data4 = this.__data__, result2 = data4["delete"](key);
this.size = data4.size;
return result2;
}
function stackGet2(key) {
return this.__data__.get(key);
}
function stackHas2(key) {
return this.__data__.has(key);
}
function stackSet2(key, value) {
var data4 = this.__data__;
if (data4 instanceof ListCache2) {
var pairs = data4.__data__;
if (!Map2 || pairs.length < LARGE_ARRAY_SIZE2 - 1) {
pairs.push([key, value]);
this.size = ++data4.size;
return this;
}
data4 = this.__data__ = new MapCache2(pairs);
}
data4.set(key, value);
this.size = data4.size;
return this;
}
Stack2.prototype.clear = stackClear2;
Stack2.prototype["delete"] = stackDelete2;
Stack2.prototype.get = stackGet2;
Stack2.prototype.has = stackHas2;
Stack2.prototype.set = stackSet2;
function arrayLikeKeys2(value, inherited) {
var isArr = isArray2(value), isArg = !isArr && isArguments2(value), isBuff = !isArr && !isArg && isBuffer2(value), isType = !isArr && !isArg && !isBuff && isTypedArray2(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes2(value.length, String2) : [], length = result2.length;
for (var key in value) {
if ((inherited || hasOwnProperty2.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
(key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
isIndex2(key, length)))) {
result2.push(key);
}
}
return result2;
}
function arraySample(array) {
var length = array.length;
return length ? array[baseRandom(0, length - 1)] : undefined$1;
}
function arraySampleSize(array, n) {
return shuffleSelf(copyArray2(array), baseClamp(n, 0, array.length));
}
function arrayShuffle(array) {
return shuffleSelf(copyArray2(array));
}
function assignMergeValue(object, key, value) {
if (value !== undefined$1 && !eq2(object[key], value) || value === undefined$1 && !(key in object)) {
baseAssignValue2(object, key, value);
}
}
function assignValue2(object, key, value) {
var objValue = object[key];
if (!(hasOwnProperty2.call(object, key) && eq2(objValue, value)) || value === undefined$1 && !(key in object)) {
baseAssignValue2(object, key, value);
}
}
function assocIndexOf2(array, key) {
var length = array.length;
while (length--) {
if (eq2(array[length][0], key)) {
return length;
}
}
return -1;
}
function baseAggregator(collection, setter, iteratee2, accumulator) {
baseEach(collection, function(value, key, collection2) {
setter(accumulator, value, iteratee2(value), collection2);
});
return accumulator;
}
function baseAssign2(object, source) {
return object && copyObject2(source, keys2(source), object);
}
function baseAssignIn2(object, source) {
return object && copyObject2(source, keysIn2(source), object);
}
function baseAssignValue2(object, key, value) {
if (key == "__proto__" && defineProperty2) {
defineProperty2(object, key, {
"configurable": true,
"enumerable": true,
"value": value,
"writable": true
});
} else {
object[key] = value;
}
}
function baseAt(object, paths) {
var index2 = -1, length = paths.length, result2 = Array2(length), skip = object == null;
while (++index2 < length) {
result2[index2] = skip ? undefined$1 : get2(object, paths[index2]);
}
return result2;
}
function baseClamp(number, lower, upper) {
if (number === number) {
if (upper !== undefined$1) {
number = number <= upper ? number : upper;
}
if (lower !== undefined$1) {
number = number >= lower ? number : lower;
}
}
return number;
}
function baseClone2(value, bitmask, customizer, key, object, stack2) {
var result2, isDeep = bitmask & CLONE_DEEP_FLAG2, isFlat = bitmask & CLONE_FLAT_FLAG2, isFull = bitmask & CLONE_SYMBOLS_FLAG2;
if (customizer) {
result2 = object ? customizer(value, key, object, stack2) : customizer(value);
}
if (result2 !== undefined$1) {
return result2;
}
if (!isObject2(value)) {
return value;
}
var isArr = isArray2(value);
if (isArr) {
result2 = initCloneArray2(value);
if (!isDeep) {
return copyArray2(value, result2);
}
} else {
var tag = getTag2(value), isFunc = tag == funcTag2 || tag == genTag2;
if (isBuffer2(value)) {
return cloneBuffer2(value, isDeep);
}
if (tag == objectTag2 || tag == argsTag2 || isFunc && !object) {
result2 = isFlat || isFunc ? {} : initCloneObject2(value);
if (!isDeep) {
return isFlat ? copySymbolsIn2(value, baseAssignIn2(result2, value)) : copySymbols2(value, baseAssign2(result2, value));
}
} else {
if (!cloneableTags2[tag]) {
return object ? value : {};
}
result2 = initCloneByTag2(value, tag, isDeep);
}
}
stack2 || (stack2 = new Stack2());
var stacked = stack2.get(value);
if (stacked) {
return stacked;
}
stack2.set(value, result2);
if (isSet2(value)) {
value.forEach(function(subValue) {
result2.add(baseClone2(subValue, bitmask, customizer, subValue, value, stack2));
});
} else if (isMap2(value)) {
value.forEach(function(subValue, key2) {
result2.set(key2, baseClone2(subValue, bitmask, customizer, key2, value, stack2));
});
}
var keysFunc = isFull ? isFlat ? getAllKeysIn2 : getAllKeys2 : isFlat ? keysIn2 : keys2;
var props = isArr ? undefined$1 : keysFunc(value);
arrayEach2(props || value, function(subValue, key2) {
if (props) {
key2 = subValue;
subValue = value[key2];
}
assignValue2(result2, key2, baseClone2(subValue, bitmask, customizer, key2, value, stack2));
});
return result2;
}
function baseConforms(source) {
var props = keys2(source);
return function(object) {
return baseConformsTo(object, source, props);
};
}
function baseConformsTo(object, source, props) {
var length = props.length;
if (object == null) {
return !length;
}
object = Object2(object);
while (length--) {
var key = props[length], predicate = source[key], value = object[key];
if (value === undefined$1 && !(key in object) || !predicate(value)) {
return false;
}
}
return true;
}
function baseDelay(func, wait, args) {
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
return setTimeout2(function() {
func.apply(undefined$1, args);
}, wait);
}
function baseDifference(array, values2, iteratee2, comparator) {
var index2 = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;
if (!length) {
return result2;
}
if (iteratee2) {
values2 = arrayMap(values2, baseUnary2(iteratee2));
}
if (comparator) {
includes2 = arrayIncludesWith;
isCommon = false;
} else if (values2.length >= LARGE_ARRAY_SIZE2) {
includes2 = cacheHas;
isCommon = false;
values2 = new SetCache(values2);
}
outer:
while (++index2 < length) {
var value = array[index2], computed2 = iteratee2 == null ? value : iteratee2(value);
value = comparator || value !== 0 ? value : 0;
if (isCommon && computed2 === computed2) {
var valuesIndex = valuesLength;
while (valuesIndex--) {
if (values2[valuesIndex] === computed2) {
continue outer;
}
}
result2.push(value);
} else if (!includes2(values2, computed2, comparator)) {
result2.push(value);
}
}
return result2;
}
var baseEach = createBaseEach(baseForOwn);
var baseEachRight = createBaseEach(baseForOwnRight, true);
function baseEvery(collection, predicate) {
var result2 = true;
baseEach(collection, function(value, index2, collection2) {
result2 = !!predicate(value, index2, collection2);
return result2;
});
return result2;
}
function baseExtremum(array, iteratee2, comparator) {
var index2 = -1, length = array.length;
while (++index2 < length) {
var value = array[index2], current = iteratee2(value);
if (current != null && (computed2 === undefined$1 ? current === current && !isSymbol2(current) : comparator(current, computed2))) {
var computed2 = current, result2 = value;
}
}
return result2;
}
function baseFill(array, value, start, end) {
var length = array.length;
start = toInteger(start);
if (start < 0) {
start = -start > length ? 0 : length + start;
}
end = end === undefined$1 || end > length ? length : toInteger(end);
if (end < 0) {
end += length;
}
end = start > end ? 0 : toLength(end);
while (start < end) {
array[start++] = value;
}
return array;
}
function baseFilter(collection, predicate) {
var result2 = [];
baseEach(collection, function(value, index2, collection2) {
if (predicate(value, index2, collection2)) {
result2.push(value);
}
});
return result2;
}
function baseFlatten(array, depth, predicate, isStrict, result2) {
var index2 = -1, length = array.length;
predicate || (predicate = isFlattenable);
result2 || (result2 = []);
while (++index2 < length) {
var value = array[index2];
if (depth > 0 && predicate(value)) {
if (depth > 1) {
baseFlatten(value, depth - 1, predicate, isStrict, result2);
} else {
arrayPush2(result2, value);
}
} else if (!isStrict) {
result2[result2.length] = value;
}
}
return result2;
}
var baseFor = createBaseFor();
var baseForRight = createBaseFor(true);
function baseForOwn(object, iteratee2) {
return object && baseFor(object, iteratee2, keys2);
}
function baseForOwnRight(object, iteratee2) {
return object && baseForRight(object, iteratee2, keys2);
}
function baseFunctions(object, props) {
return arrayFilter2(props, function(key) {
return isFunction2(object[key]);
});
}
function baseGet(object, path) {
path = castPath(path, object);
var index2 = 0, length = path.length;
while (object != null && index2 < length) {
object = object[toKey(path[index2++])];
}
return index2 && index2 == length ? object : undefined$1;
}
function baseGetAllKeys2(object, keysFunc, symbolsFunc) {
var result2 = keysFunc(object);
return isArray2(object) ? result2 : arrayPush2(result2, symbolsFunc(object));
}
function baseGetTag2(value) {
if (value == null) {
return value === undefined$1 ? undefinedTag2 : nullTag2;
}
return symToStringTag2 && symToStringTag2 in Object2(value) ? getRawTag2(value) : objectToString2(value);
}
function baseGt(value, other) {
return value > other;
}
function baseHas(object, key) {
return object != null && hasOwnProperty2.call(object, key);
}
function baseHasIn(object, key) {
return object != null && key in Object2(object);
}
function baseInRange(number, start, end) {
return number >= nativeMin(start, end) && number < nativeMax(start, end);
}
function baseIntersection(arrays, iteratee2, comparator) {
var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array2(othLength), maxLength = Infinity, result2 = [];
while (othIndex--) {
var array = arrays[othIndex];
if (othIndex && iteratee2) {
array = arrayMap(array, baseUnary2(iteratee2));
}
maxLength = nativeMin(array.length, maxLength);
caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined$1;
}
array = arrays[0];
var index2 = -1, seen = caches[0];
outer:
while (++index2 < length && result2.length < maxLength) {
var value = array[index2], computed2 = iteratee2 ? iteratee2(value) : value;
value = comparator || value !== 0 ? value : 0;
if (!(seen ? cacheHas(seen, computed2) : includes2(result2, computed2, comparator))) {
othIndex = othLength;
while (--othIndex) {
var cache = caches[othIndex];
if (!(cache ? cacheHas(cache, computed2) : includes2(arrays[othIndex], computed2, comparator))) {
continue outer;
}
}
if (seen) {
seen.push(computed2);
}
result2.push(value);
}
}
return result2;
}
function baseInverter(object, setter, iteratee2, accumulator) {
baseForOwn(object, function(value, key, object2) {
setter(accumulator, iteratee2(value), key, object2);
});
return accumulator;
}
function baseInvoke(object, path, args) {
path = castPath(path, object);
object = parent(object, path);
var func = object == null ? object : object[toKey(last(path))];
return func == null ? undefined$1 : apply2(func, object, args);
}
function baseIsArguments2(value) {
return isObjectLike2(value) && baseGetTag2(value) == argsTag2;
}
function baseIsArrayBuffer(value) {
return isObjectLike2(value) && baseGetTag2(value) == arrayBufferTag2;
}
function baseIsDate(value) {
return isObjectLike2(value) && baseGetTag2(value) == dateTag2;
}
function baseIsEqual(value, other, bitmask, customizer, stack2) {
if (value === other) {
return true;
}
if (value == null || other == null || !isObjectLike2(value) && !isObjectLike2(other)) {
return value !== value && other !== other;
}
return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack2);
}
function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack2) {
var objIsArr = isArray2(object), othIsArr = isArray2(other), objTag = objIsArr ? arrayTag2 : getTag2(object), othTag = othIsArr ? arrayTag2 : getTag2(other);
objTag = objTag == argsTag2 ? objectTag2 : objTag;
othTag = othTag == argsTag2 ? objectTag2 : othTag;
var objIsObj = objTag == objectTag2, othIsObj = othTag == objectTag2, isSameTag = objTag == othTag;
if (isSameTag && isBuffer2(object)) {
if (!isBuffer2(other)) {
return false;
}
objIsArr = true;
objIsObj = false;
}
if (isSameTag && !objIsObj) {
stack2 || (stack2 = new Stack2());
return objIsArr || isTypedArray2(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack2) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack2);
}
if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
var objIsWrapped = objIsObj && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
if (objIsWrapped || othIsWrapped) {
var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
stack2 || (stack2 = new Stack2());
return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack2);
}
}
if (!isSameTag) {
return false;
}
stack2 || (stack2 = new Stack2());
return equalObjects(object, other, bitmask, customizer, equalFunc, stack2);
}
function baseIsMap2(value) {
return isObjectLike2(value) && getTag2(value) == mapTag2;
}
function baseIsMatch(object, source, matchData, customizer) {
var index2 = matchData.length, length = index2, noCustomizer = !customizer;
if (object == null) {
return !length;
}
object = Object2(object);
while (index2--) {
var data4 = matchData[index2];
if (noCustomizer && data4[2] ? data4[1] !== object[data4[0]] : !(data4[0] in object)) {
return false;
}
}
while (++index2 < length) {
data4 = matchData[index2];
var key = data4[0], objValue = object[key], srcValue = data4[1];
if (noCustomizer && data4[2]) {
if (objValue === undefined$1 && !(key in object)) {
return false;
}
} else {
var stack2 = new Stack2();
if (customizer) {
var result2 = customizer(objValue, srcValue, key, object, source, stack2);
}
if (!(result2 === undefined$1 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack2) : result2)) {
return false;
}
}
}
return true;
}
function baseIsNative2(value) {
if (!isObject2(value) || isMasked2(value)) {
return false;
}
var pattern = isFunction2(value) ? reIsNative2 : reIsHostCtor2;
return pattern.test(toSource2(value));
}
function baseIsRegExp(value) {
return isObjectLike2(value) && baseGetTag2(value) == regexpTag2;
}
function baseIsSet2(value) {
return isObjectLike2(value) && getTag2(value) == setTag2;
}
function baseIsTypedArray2(value) {
return isObjectLike2(value) && isLength2(value.length) && !!typedArrayTags2[baseGetTag2(value)];
}
function baseIteratee(value) {
if (typeof value == "function") {
return value;
}
if (value == null) {
return identity;
}
if (typeof value == "object") {
return isArray2(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
}
return property(value);
}
function baseKeys2(object) {
if (!isPrototype2(object)) {
return nativeKeys2(object);
}
var result2 = [];
for (var key in Object2(object)) {
if (hasOwnProperty2.call(object, key) && key != "constructor") {
result2.push(key);
}
}
return result2;
}
function baseKeysIn2(object) {
if (!isObject2(object)) {
return nativeKeysIn2(object);
}
var isProto = isPrototype2(object), result2 = [];
for (var key in object) {
if (!(key == "constructor" && (isProto || !hasOwnProperty2.call(object, key)))) {
result2.push(key);
}
}
return result2;
}
function baseLt(value, other) {
return value < other;
}
function baseMap(collection, iteratee2) {
var index2 = -1, result2 = isArrayLike2(collection) ? Array2(collection.length) : [];
baseEach(collection, function(value, key, collection2) {
result2[++index2] = iteratee2(value, key, collection2);
});
return result2;
}
function baseMatches(source) {
var matchData = getMatchData(source);
if (matchData.length == 1 && matchData[0][2]) {
return matchesStrictComparable(matchData[0][0], matchData[0][1]);
}
return function(object) {
return object === source || baseIsMatch(object, source, matchData);
};
}
function baseMatchesProperty(path, srcValue) {
if (isKey(path) && isStrictComparable(srcValue)) {
return matchesStrictComparable(toKey(path), srcValue);
}
return function(object) {
var objValue = get2(object, path);
return objValue === undefined$1 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
};
}
function baseMerge(object, source, srcIndex, customizer, stack2) {
if (object === source) {
return;
}
baseFor(source, function(srcValue, key) {
stack2 || (stack2 = new Stack2());
if (isObject2(srcValue)) {
baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack2);
} else {
var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack2) : undefined$1;
if (newValue === undefined$1) {
newValue = srcValue;
}
assignMergeValue(object, key, newValue);
}
}, keysIn2);
}
function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack2) {
var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack2.get(srcValue);
if (stacked) {
assignMergeValue(object, key, stacked);
return;
}
var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack2) : undefined$1;
var isCommon = newValue === undefined$1;
if (isCommon) {
var isArr = isArray2(srcValue), isBuff = !isArr && isBuffer2(srcValue), isTyped = !isArr && !isBuff && isTypedArray2(srcValue);
newValue = srcValue;
if (isArr || isBuff || isTyped) {
if (isArray2(objValue)) {
newValue = objValue;
} else if (isArrayLikeObject(objValue)) {
newValue = copyArray2(objValue);
} else if (isBuff) {
isCommon = false;
newValue = cloneBuffer2(srcValue, true);
} else if (isTyped) {
isCommon = false;
newValue = cloneTypedArray2(srcValue, true);
} else {
newValue = [];
}
} else if (isPlainObject2(srcValue) || isArguments2(srcValue)) {
newValue = objValue;
if (isArguments2(objValue)) {
newValue = toPlainObject(objValue);
} else if (!isObject2(objValue) || isFunction2(objValue)) {
newValue = initCloneObject2(srcValue);
}
} else {
isCommon = false;
}
}
if (isCommon) {
stack2.set(srcValue, newValue);
mergeFunc(newValue, srcValue, srcIndex, customizer, stack2);
stack2["delete"](srcValue);
}
assignMergeValue(object, key, newValue);
}
function baseNth(array, n) {
var length = array.length;
if (!length) {
return;
}
n += n < 0 ? length : 0;
return isIndex2(n, length) ? array[n] : undefined$1;
}
function baseOrderBy(collection, iteratees, orders) {
if (iteratees.length) {
iteratees = arrayMap(iteratees, function(iteratee2) {
if (isArray2(iteratee2)) {
return function(value) {
return baseGet(value, iteratee2.length === 1 ? iteratee2[0] : iteratee2);
};
}
return iteratee2;
});
} else {
iteratees = [identity];
}
var index2 = -1;
iteratees = arrayMap(iteratees, baseUnary2(getIteratee()));
var result2 = baseMap(collection, function(value, key, collection2) {
var criteria = arrayMap(iteratees, function(iteratee2) {
return iteratee2(value);
});
return { "criteria": criteria, "index": ++index2, "value": value };
});
return baseSortBy(result2, function(object, other) {
return compareMultiple(object, other, orders);
});
}
function basePick(object, paths) {
return basePickBy(object, paths, function(value, path) {
return hasIn(object, path);
});
}
function basePickBy(object, paths, predicate) {
var index2 = -1, length = paths.length, result2 = {};
while (++index2 < length) {
var path = paths[index2], value = baseGet(object, path);
if (predicate(value, path)) {
baseSet(result2, castPath(path, object), value);
}
}
return result2;
}
function basePropertyDeep(path) {
return function(object) {
return baseGet(object, path);
};
}
function basePullAll(array, values2, iteratee2, comparator) {
var indexOf2 = comparator ? baseIndexOfWith : baseIndexOf, index2 = -1, length = values2.length, seen = array;
if (array === values2) {
values2 = copyArray2(values2);
}
if (iteratee2) {
seen = arrayMap(array, baseUnary2(iteratee2));
}
while (++index2 < length) {
var fromIndex = 0, value = values2[index2], computed2 = iteratee2 ? iteratee2(value) : value;
while ((fromIndex = indexOf2(seen, computed2, fromIndex, comparator)) > -1) {
if (seen !== array) {
splice2.call(seen, fromIndex, 1);
}
splice2.call(array, fromIndex, 1);
}
}
return array;
}
function basePullAt(array, indexes) {
var length = array ? indexes.length : 0, lastIndex = length - 1;
while (length--) {
var index2 = indexes[length];
if (length == lastIndex || index2 !== previous) {
var previous = index2;
if (isIndex2(index2)) {
splice2.call(array, index2, 1);
} else {
baseUnset(array, index2);
}
}
}
return array;
}
function baseRandom(lower, upper) {
return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
}
function baseRange(start, end, step, fromRight) {
var index2 = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result2 = Array2(length);
while (length--) {
result2[fromRight ? length : ++index2] = start;
start += step;
}
return result2;
}
function baseRepeat(string, n) {
var result2 = "";
if (!string || n < 1 || n > MAX_SAFE_INTEGER2) {
return result2;
}
do {
if (n % 2) {
result2 += string;
}
n = nativeFloor(n / 2);
if (n) {
string += string;
}
} while (n);
return result2;
}
function baseRest(func, start) {
return setToString(overRest(func, start, identity), func + "");
}
function baseSample(collection) {
return arraySample(values(collection));
}
function baseSampleSize(collection, n) {
var array = values(collection);
return shuffleSelf(array, baseClamp(n, 0, array.length));
}
function baseSet(object, path, value, customizer) {
if (!isObject2(object)) {
return object;
}
path = castPath(path, object);
var index2 = -1, length = path.length, lastIndex = length - 1, nested = object;
while (nested != null && ++index2 < length) {
var key = toKey(path[index2]), newValue = value;
if (key === "__proto__" || key === "constructor" || key === "prototype") {
return object;
}
if (index2 != lastIndex) {
var objValue = nested[key];
newValue = customizer ? customizer(objValue, key, nested) : undefined$1;
if (newValue === undefined$1) {
newValue = isObject2(objValue) ? objValue : isIndex2(path[index2 + 1]) ? [] : {};
}
}
assignValue2(nested, key, newValue);
nested = nested[key];
}
return object;
}
var baseSetData = !metaMap ? identity : function(func, data4) {
metaMap.set(func, data4);
return func;
};
var baseSetToString = !defineProperty2 ? identity : function(func, string) {
return defineProperty2(func, "toString", {
"configurable": true,
"enumerable": false,
"value": constant(string),
"writable": true
});
};
function baseShuffle(collection) {
return shuffleSelf(values(collection));
}
function baseSlice(array, start, end) {
var index2 = -1, length = array.length;
if (start < 0) {
start = -start > length ? 0 : length + start;
}
end = end > length ? length : end;
if (end < 0) {
end += length;
}
length = start > end ? 0 : end - start >>> 0;
start >>>= 0;
var result2 = Array2(length);
while (++index2 < length) {
result2[index2] = array[index2 + start];
}
return result2;
}
function baseSome(collection, predicate) {
var result2;
baseEach(collection, function(value, index2, collection2) {
result2 = predicate(value, index2, collection2);
return !result2;
});
return !!result2;
}
function baseSortedIndex(array, value, retHighest) {
var low = 0, high = array == null ? low : array.length;
if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
while (low < high) {
var mid = low + high >>> 1, computed2 = array[mid];
if (computed2 !== null && !isSymbol2(computed2) && (retHighest ? computed2 <= value : computed2 < value)) {
low = mid + 1;
} else {
high = mid;
}
}
return high;
}
return baseSortedIndexBy(array, value, identity, retHighest);
}
function baseSortedIndexBy(array, value, iteratee2, retHighest) {
var low = 0, high = array == null ? 0 : array.length;
if (high === 0) {
return 0;
}
value = iteratee2(value);
var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol2(value), valIsUndefined = value === undefined$1;
while (low < high) {
var mid = nativeFloor((low + high) / 2), computed2 = iteratee2(array[mid]), othIsDefined = computed2 !== undefined$1, othIsNull = computed2 === null, othIsReflexive = computed2 === computed2, othIsSymbol = isSymbol2(computed2);
if (valIsNaN) {
var setLow = retHighest || othIsReflexive;
} else if (valIsUndefined) {
setLow = othIsReflexive && (retHighest || othIsDefined);
} else if (valIsNull) {
setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
} else if (valIsSymbol) {
setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
} else if (othIsNull || othIsSymbol) {
setLow = false;
} else {
setLow = retHighest ? computed2 <= value : computed2 < value;
}
if (setLow) {
low = mid + 1;
} else {
high = mid;
}
}
return nativeMin(high, MAX_ARRAY_INDEX);
}
function baseSortedUniq(array, iteratee2) {
var index2 = -1, length = array.length, resIndex = 0, result2 = [];
while (++index2 < length) {
var value = array[index2], computed2 = iteratee2 ? iteratee2(value) : value;
if (!index2 || !eq2(computed2, seen)) {
var seen = computed2;
result2[resIndex++] = value === 0 ? 0 : value;
}
}
return result2;
}
function baseToNumber(value) {
if (typeof value == "number") {
return value;
}
if (isSymbol2(value)) {
return NAN;
}
return +value;
}
function baseToString(value) {
if (typeof value == "string") {
return value;
}
if (isArray2(value)) {
return arrayMap(value, baseToString) + "";
}
if (isSymbol2(value)) {
return symbolToString ? symbolToString.call(value) : "";
}
var result2 = value + "";
return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2;
}
function baseUniq(array, iteratee2, comparator) {
var index2 = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2;
if (comparator) {
isCommon = false;
includes2 = arrayIncludesWith;
} else if (length >= LARGE_ARRAY_SIZE2) {
var set3 = iteratee2 ? null : createSet(array);
if (set3) {
return setToArray(set3);
}
isCommon = false;
includes2 = cacheHas;
seen = new SetCache();
} else {
seen = iteratee2 ? [] : result2;
}
outer:
while (++index2 < length) {
var value = array[index2], computed2 = iteratee2 ? iteratee2(value) : value;
value = comparator || value !== 0 ? value : 0;
if (isCommon && computed2 === computed2) {
var seenIndex = seen.length;
while (seenIndex--) {
if (seen[seenIndex] === computed2) {
continue outer;
}
}
if (iteratee2) {
seen.push(computed2);
}
result2.push(value);
} else if (!includes2(seen, computed2, comparator)) {
if (seen !== result2) {
seen.push(computed2);
}
result2.push(value);
}
}
return result2;
}
function baseUnset(object, path) {
path = castPath(path, object);
object = parent(object, path);
return object == null || delete object[toKey(last(path))];
}
function baseUpdate(object, path, updater, customizer) {
return baseSet(object, path, updater(baseGet(object, path)), customizer);
}
function baseWhile(array, predicate, isDrop, fromRight) {
var length = array.length, index2 = fromRight ? length : -1;
while ((fromRight ? index2-- : ++index2 < length) && predicate(array[index2], index2, array)) {
}
return isDrop ? baseSlice(array, fromRight ? 0 : index2, fromRight ? index2 + 1 : length) : baseSlice(array, fromRight ? index2 + 1 : 0, fromRight ? length : index2);
}
function baseWrapperValue(value, actions) {
var result2 = value;
if (result2 instanceof LazyWrapper) {
result2 = result2.value();
}
return arrayReduce(actions, function(result3, action) {
return action.func.apply(action.thisArg, arrayPush2([result3], action.args));
}, result2);
}
function baseXor(arrays, iteratee2, comparator) {
var length = arrays.length;
if (length < 2) {
return length ? baseUniq(arrays[0]) : [];
}
var index2 = -1, result2 = Array2(length);
while (++index2 < length) {
var array = arrays[index2], othIndex = -1;
while (++othIndex < length) {
if (othIndex != index2) {
result2[index2] = baseDifference(result2[index2] || array, arrays[othIndex], iteratee2, comparator);
}
}
}
return baseUniq(baseFlatten(result2, 1), iteratee2, comparator);
}
function baseZipObject(props, values2, assignFunc) {
var index2 = -1, length = props.length, valsLength = values2.length, result2 = {};
while (++index2 < length) {
var value = index2 < valsLength ? values2[index2] : undefined$1;
assignFunc(result2, props[index2], value);
}
return result2;
}
function castArrayLikeObject(value) {
return isArrayLikeObject(value) ? value : [];
}
function castFunction(value) {
return typeof value == "function" ? value : identity;
}
function castPath(value, object) {
if (isArray2(value)) {
return value;
}
return isKey(value, object) ? [value] : stringToPath(toString(value));
}
var castRest = baseRest;
function castSlice(array, start, end) {
var length = array.length;
end = end === undefined$1 ? length : end;
return !start && end >= length ? array : baseSlice(array, start, end);
}
var clearTimeout2 = ctxClearTimeout || function(id) {
return root7.clearTimeout(id);
};
function cloneBuffer2(buffer, isDeep) {
if (isDeep) {
return buffer.slice();
}
var length = buffer.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
buffer.copy(result2);
return result2;
}
function cloneArrayBuffer2(arrayBuffer) {
var result2 = new arrayBuffer.constructor(arrayBuffer.byteLength);
new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer));
return result2;
}
function cloneDataView2(dataView, isDeep) {
var buffer = isDeep ? cloneArrayBuffer2(dataView.buffer) : dataView.buffer;
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
}
function cloneRegExp2(regexp) {
var result2 = new regexp.constructor(regexp.source, reFlags2.exec(regexp));
result2.lastIndex = regexp.lastIndex;
return result2;
}
function cloneSymbol2(symbol) {
return symbolValueOf2 ? Object2(symbolValueOf2.call(symbol)) : {};
}
function cloneTypedArray2(typedArray, isDeep) {
var buffer = isDeep ? cloneArrayBuffer2(typedArray.buffer) : typedArray.buffer;
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
}
function compareAscending(value, other) {
if (value !== other) {
var valIsDefined = value !== undefined$1, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol2(value);
var othIsDefined = other !== undefined$1, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol2(other);
if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
return 1;
}
if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
return -1;
}
}
return 0;
}
function compareMultiple(object, other, orders) {
var index2 = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
while (++index2 < length) {
var result2 = compareAscending(objCriteria[index2], othCriteria[index2]);
if (result2) {
if (index2 >= ordersLength) {
return result2;
}
var order = orders[index2];
return result2 * (order == "desc" ? -1 : 1);
}
}
return object.index - other.index;
}
function composeArgs(args, partials, holders, isCurried) {
var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(leftLength + rangeLength), isUncurried = !isCurried;
while (++leftIndex < leftLength) {
result2[leftIndex] = partials[leftIndex];
}
while (++argsIndex < holdersLength) {
if (isUncurried || argsIndex < argsLength) {
result2[holders[argsIndex]] = args[argsIndex];
}
}
while (rangeLength--) {
result2[leftIndex++] = args[argsIndex++];
}
return result2;
}
function composeArgsRight(args, partials, holders, isCurried) {
var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(rangeLength + rightLength), isUncurried = !isCurried;
while (++argsIndex < rangeLength) {
result2[argsIndex] = args[argsIndex];
}
var offset = argsIndex;
while (++rightIndex < rightLength) {
result2[offset + rightIndex] = partials[rightIndex];
}
while (++holdersIndex < holdersLength) {
if (isUncurried || argsIndex < argsLength) {
result2[offset + holders[holdersIndex]] = args[argsIndex++];
}
}
return result2;
}
function copyArray2(source, array) {
var index2 = -1, length = source.length;
array || (array = Array2(length));
while (++index2 < length) {
array[index2] = source[index2];
}
return array;
}
function copyObject2(source, props, object, customizer) {
var isNew = !object;
object || (object = {});
var index2 = -1, length = props.length;
while (++index2 < length) {
var key = props[index2];
var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined$1;
if (newValue === undefined$1) {
newValue = source[key];
}
if (isNew) {
baseAssignValue2(object, key, newValue);
} else {
assignValue2(object, key, newValue);
}
}
return object;
}
function copySymbols2(source, object) {
return copyObject2(source, getSymbols2(source), object);
}
function copySymbolsIn2(source, object) {
return copyObject2(source, getSymbolsIn2(source), object);
}
function createAggregator(setter, initializer) {
return function(collection, iteratee2) {
var func = isArray2(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
return func(collection, setter, getIteratee(iteratee2, 2), accumulator);
};
}
function createAssigner(assigner) {
return baseRest(function(object, sources) {
var index2 = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined$1, guard = length > 2 ? sources[2] : undefined$1;
customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : undefined$1;
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
customizer = length < 3 ? undefined$1 : customizer;
length = 1;
}
object = Object2(object);
while (++index2 < length) {
var source = sources[index2];
if (source) {
assigner(object, source, index2, customizer);
}
}
return object;
});
}
function createBaseEach(eachFunc, fromRight) {
return function(collection, iteratee2) {
if (collection == null) {
return collection;
}
if (!isArrayLike2(collection)) {
return eachFunc(collection, iteratee2);
}
var length = collection.length, index2 = fromRight ? length : -1, iterable = Object2(collection);
while (fromRight ? index2-- : ++index2 < length) {
if (iteratee2(iterable[index2], index2, iterable) === false) {
break;
}
}
return collection;
};
}
function createBaseFor(fromRight) {
return function(object, iteratee2, keysFunc) {
var index2 = -1, iterable = Object2(object), props = keysFunc(object), length = props.length;
while (length--) {
var key = props[fromRight ? length : ++index2];
if (iteratee2(iterable[key], key, iterable) === false) {
break;
}
}
return object;
};
}
function createBind(func, bitmask, thisArg) {
var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
function wrapper() {
var fn = this && this !== root7 && this instanceof wrapper ? Ctor : func;
return fn.apply(isBind ? thisArg : this, arguments);
}
return wrapper;
}
function createCaseFirst(methodName) {
return function(string) {
string = toString(string);
var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined$1;
var chr = strSymbols ? strSymbols[0] : string.charAt(0);
var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
return chr[methodName]() + trailing;
};
}
function createCompounder(callback) {
return function(string) {
return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
};
}
function createCtor(Ctor) {
return function() {
var args = arguments;
switch (args.length) {
case 0:
return new Ctor();
case 1:
return new Ctor(args[0]);
case 2:
return new Ctor(args[0], args[1]);
case 3:
return new Ctor(args[0], args[1], args[2]);
case 4:
return new Ctor(args[0], args[1], args[2], args[3]);
case 5:
return new Ctor(args[0], args[1], args[2], args[3], args[4]);
case 6:
return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
case 7:
return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
}
var thisBinding = baseCreate2(Ctor.prototype), result2 = Ctor.apply(thisBinding, args);
return isObject2(result2) ? result2 : thisBinding;
};
}
function createCurry(func, bitmask, arity) {
var Ctor = createCtor(func);
function wrapper() {
var length = arguments.length, args = Array2(length), index2 = length, placeholder = getHolder(wrapper);
while (index2--) {
args[index2] = arguments[index2];
}
var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);
length -= holders.length;
if (length < arity) {
return createRecurry(
func,
bitmask,
createHybrid,
wrapper.placeholder,
undefined$1,
args,
holders,
undefined$1,
undefined$1,
arity - length
);
}
var fn = this && this !== root7 && this instanceof wrapper ? Ctor : func;
return apply2(fn, this, args);
}
return wrapper;
}
function createFind(findIndexFunc) {
return function(collection, predicate, fromIndex) {
var iterable = Object2(collection);
if (!isArrayLike2(collection)) {
var iteratee2 = getIteratee(predicate, 3);
collection = keys2(collection);
predicate = function(key) {
return iteratee2(iterable[key], key, iterable);
};
}
var index2 = findIndexFunc(collection, predicate, fromIndex);
return index2 > -1 ? iterable[iteratee2 ? collection[index2] : index2] : undefined$1;
};
}
function createFlow(fromRight) {
return flatRest(function(funcs) {
var length = funcs.length, index2 = length, prereq = LodashWrapper.prototype.thru;
if (fromRight) {
funcs.reverse();
}
while (index2--) {
var func = funcs[index2];
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
if (prereq && !wrapper && getFuncName(func) == "wrapper") {
var wrapper = new LodashWrapper([], true);
}
}
index2 = wrapper ? index2 : length;
while (++index2 < length) {
func = funcs[index2];
var funcName = getFuncName(func), data4 = funcName == "wrapper" ? getData(func) : undefined$1;
if (data4 && isLaziable(data4[0]) && data4[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data4[4].length && data4[9] == 1) {
wrapper = wrapper[getFuncName(data4[0])].apply(wrapper, data4[3]);
} else {
wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);
}
}
return function() {
var args = arguments, value = args[0];
if (wrapper && args.length == 1 && isArray2(value)) {
return wrapper.plant(value).value();
}
var index3 = 0, result2 = length ? funcs[index3].apply(this, args) : value;
while (++index3 < length) {
result2 = funcs[index3].call(this, result2);
}
return result2;
};
});
}
function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {
var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined$1 : createCtor(func);
function wrapper() {
var length = arguments.length, args = Array2(length), index2 = length;
while (index2--) {
args[index2] = arguments[index2];
}
if (isCurried) {
var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);
}
if (partials) {
args = composeArgs(args, partials, holders, isCurried);
}
if (partialsRight) {
args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
}
length -= holdersCount;
if (isCurried && length < arity) {
var newHolders = replaceHolders(args, placeholder);
return createRecurry(
func,
bitmask,
createHybrid,
wrapper.placeholder,
thisArg,
args,
newHolders,
argPos,
ary2,
arity - length
);
}
var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func;
length = args.length;
if (argPos) {
args = reorder(args, argPos);
} else if (isFlip && length > 1) {
args.reverse();
}
if (isAry && ary2 < length) {
args.length = ary2;
}
if (this && this !== root7 && this instanceof wrapper) {
fn = Ctor || createCtor(fn);
}
return fn.apply(thisBinding, args);
}
return wrapper;
}
function createInverter(setter, toIteratee) {
return function(object, iteratee2) {
return baseInverter(object, setter, toIteratee(iteratee2), {});
};
}
function createMathOperation(operator, defaultValue) {
return function(value, other) {
var result2;
if (value === undefined$1 && other === undefined$1) {
return defaultValue;
}
if (value !== undefined$1) {
result2 = value;
}
if (other !== undefined$1) {
if (result2 === undefined$1) {
return other;
}
if (typeof value == "string" || typeof other == "string") {
value = baseToString(value);
other = baseToString(other);
} else {
value = baseToNumber(value);
other = baseToNumber(other);
}
result2 = operator(value, other);
}
return result2;
};
}
function createOver(arrayFunc) {
return flatRest(function(iteratees) {
iteratees = arrayMap(iteratees, baseUnary2(getIteratee()));
return baseRest(function(args) {
var thisArg = this;
return arrayFunc(iteratees, function(iteratee2) {
return apply2(iteratee2, thisArg, args);
});
});
});
}
function createPadding(length, chars) {
chars = chars === undefined$1 ? " " : baseToString(chars);
var charsLength = chars.length;
if (charsLength < 2) {
return charsLength ? baseRepeat(chars, length) : chars;
}
var result2 = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
return hasUnicode(chars) ? castSlice(stringToArray(result2), 0, length).join("") : result2.slice(0, length);
}
function createPartial(func, bitmask, thisArg, partials) {
var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
function wrapper() {
var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array2(leftLength + argsLength), fn = this && this !== root7 && this instanceof wrapper ? Ctor : func;
while (++leftIndex < leftLength) {
args[leftIndex] = partials[leftIndex];
}
while (argsLength--) {
args[leftIndex++] = arguments[++argsIndex];
}
return apply2(fn, isBind ? thisArg : this, args);
}
return wrapper;
}
function createRange(fromRight) {
return function(start, end, step) {
if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
end = step = undefined$1;
}
start = toFinite(start);
if (end === undefined$1) {
end = start;
start = 0;
} else {
end = toFinite(end);
}
step = step === undefined$1 ? start < end ? 1 : -1 : toFinite(step);
return baseRange(start, end, step, fromRight);
};
}
function createRelationalOperation(operator) {
return function(value, other) {
if (!(typeof value == "string" && typeof other == "string")) {
value = toNumber2(value);
other = toNumber2(other);
}
return operator(value, other);
};
}
function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {
var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined$1, newHoldersRight = isCurry ? undefined$1 : holders, newPartials = isCurry ? partials : undefined$1, newPartialsRight = isCurry ? undefined$1 : partials;
bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG;
bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
}
var newData = [
func,
bitmask,
thisArg,
newPartials,
newHolders,
newPartialsRight,
newHoldersRight,
argPos,
ary2,
arity
];
var result2 = wrapFunc.apply(undefined$1, newData);
if (isLaziable(func)) {
setData(result2, newData);
}
result2.placeholder = placeholder;
return setWrapToString(result2, func, bitmask);
}
function createRound(methodName) {
var func = Math2[methodName];
return function(number, precision) {
number = toNumber2(number);
precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
if (precision && nativeIsFinite(number)) {
var pair = (toString(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
pair = (toString(value) + "e").split("e");
return +(pair[0] + "e" + (+pair[1] - precision));
}
return func(number);
};
}
var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop2 : function(values2) {
return new Set2(values2);
};
function createToPairs(keysFunc) {
return function(object) {
var tag = getTag2(object);
if (tag == mapTag2) {
return mapToArray(object);
}
if (tag == setTag2) {
return setToPairs(object);
}
return baseToPairs(object, keysFunc(object));
};
}
function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) {
var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
if (!isBindKey && typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
var length = partials ? partials.length : 0;
if (!length) {
bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
partials = holders = undefined$1;
}
ary2 = ary2 === undefined$1 ? ary2 : nativeMax(toInteger(ary2), 0);
arity = arity === undefined$1 ? arity : toInteger(arity);
length -= holders ? holders.length : 0;
if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
var partialsRight = partials, holdersRight = holders;
partials = holders = undefined$1;
}
var data4 = isBindKey ? undefined$1 : getData(func);
var newData = [
func,
bitmask,
thisArg,
partials,
holders,
partialsRight,
holdersRight,
argPos,
ary2,
arity
];
if (data4) {
mergeData(newData, data4);
}
func = newData[0];
bitmask = newData[1];
thisArg = newData[2];
partials = newData[3];
holders = newData[4];
arity = newData[9] = newData[9] === undefined$1 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0);
if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
}
if (!bitmask || bitmask == WRAP_BIND_FLAG) {
var result2 = createBind(func, bitmask, thisArg);
} else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
result2 = createCurry(func, bitmask, arity);
} else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
result2 = createPartial(func, bitmask, thisArg, partials);
} else {
result2 = createHybrid.apply(undefined$1, newData);
}
var setter = data4 ? baseSetData : setData;
return setWrapToString(setter(result2, newData), func, bitmask);
}
function customDefaultsAssignIn(objValue, srcValue, key, object) {
if (objValue === undefined$1 || eq2(objValue, objectProto2[key]) && !hasOwnProperty2.call(object, key)) {
return srcValue;
}
return objValue;
}
function customDefaultsMerge(objValue, srcValue, key, object, source, stack2) {
if (isObject2(objValue) && isObject2(srcValue)) {
stack2.set(srcValue, objValue);
baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack2);
stack2["delete"](srcValue);
}
return objValue;
}
function customOmitClone(value) {
return isPlainObject2(value) ? undefined$1 : value;
}
function equalArrays(array, other, bitmask, customizer, equalFunc, stack2) {
var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
return false;
}
var arrStacked = stack2.get(array);
var othStacked = stack2.get(other);
if (arrStacked && othStacked) {
return arrStacked == other && othStacked == array;
}
var index2 = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined$1;
stack2.set(array, other);
stack2.set(other, array);
while (++index2 < arrLength) {
var arrValue = array[index2], othValue = other[index2];
if (customizer) {
var compared = isPartial ? customizer(othValue, arrValue, index2, other, array, stack2) : customizer(arrValue, othValue, index2, array, other, stack2);
}
if (compared !== undefined$1) {
if (compared) {
continue;
}
result2 = false;
break;
}
if (seen) {
if (!arraySome(other, function(othValue2, othIndex) {
if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack2))) {
return seen.push(othIndex);
}
})) {
result2 = false;
break;
}
} else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack2))) {
result2 = false;
break;
}
}
stack2["delete"](array);
stack2["delete"](other);
return result2;
}
function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack2) {
switch (tag) {
case dataViewTag2:
if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
return false;
}
object = object.buffer;
other = other.buffer;
case arrayBufferTag2:
if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
return false;
}
return true;
case boolTag2:
case dateTag2:
case numberTag2:
return eq2(+object, +other);
case errorTag2:
return object.name == other.name && object.message == other.message;
case regexpTag2:
case stringTag2:
return object == other + "";
case mapTag2:
var convert = mapToArray;
case setTag2:
var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
convert || (convert = setToArray);
if (object.size != other.size && !isPartial) {
return false;
}
var stacked = stack2.get(object);
if (stacked) {
return stacked == other;
}
bitmask |= COMPARE_UNORDERED_FLAG;
stack2.set(object, other);
var result2 = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack2);
stack2["delete"](object);
return result2;
case symbolTag2:
if (symbolValueOf2) {
return symbolValueOf2.call(object) == symbolValueOf2.call(other);
}
}
return false;
}
function equalObjects(object, other, bitmask, customizer, equalFunc, stack2) {
var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys2(object), objLength = objProps.length, othProps = getAllKeys2(other), othLength = othProps.length;
if (objLength != othLength && !isPartial) {
return false;
}
var index2 = objLength;
while (index2--) {
var key = objProps[index2];
if (!(isPartial ? key in other : hasOwnProperty2.call(other, key))) {
return false;
}
}
var objStacked = stack2.get(object);
var othStacked = stack2.get(other);
if (objStacked && othStacked) {
return objStacked == other && othStacked == object;
}
var result2 = true;
stack2.set(object, other);
stack2.set(other, object);
var skipCtor = isPartial;
while (++index2 < objLength) {
key = objProps[index2];
var objValue = object[key], othValue = other[key];
if (customizer) {
var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack2) : customizer(objValue, othValue, key, object, other, stack2);
}
if (!(compared === undefined$1 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack2) : compared)) {
result2 = false;
break;
}
skipCtor || (skipCtor = key == "constructor");
}
if (result2 && !skipCtor) {
var objCtor = object.constructor, othCtor = other.constructor;
if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
result2 = false;
}
}
stack2["delete"](object);
stack2["delete"](other);
return result2;
}
function flatRest(func) {
return setToString(overRest(func, undefined$1, flatten), func + "");
}
function getAllKeys2(object) {
return baseGetAllKeys2(object, keys2, getSymbols2);
}
function getAllKeysIn2(object) {
return baseGetAllKeys2(object, keysIn2, getSymbolsIn2);
}
var getData = !metaMap ? noop2 : function(func) {
return metaMap.get(func);
};
function getFuncName(func) {
var result2 = func.name + "", array = realNames[result2], length = hasOwnProperty2.call(realNames, result2) ? array.length : 0;
while (length--) {
var data4 = array[length], otherFunc = data4.func;
if (otherFunc == null || otherFunc == func) {
return data4.name;
}
}
return result2;
}
function getHolder(func) {
var object = hasOwnProperty2.call(lodash2, "placeholder") ? lodash2 : func;
return object.placeholder;
}
function getIteratee() {
var result2 = lodash2.iteratee || iteratee;
result2 = result2 === iteratee ? baseIteratee : result2;
return arguments.length ? result2(arguments[0], arguments[1]) : result2;
}
function getMapData2(map2, key) {
var data4 = map2.__data__;
return isKeyable2(key) ? data4[typeof key == "string" ? "string" : "hash"] : data4.map;
}
function getMatchData(object) {
var result2 = keys2(object), length = result2.length;
while (length--) {
var key = result2[length], value = object[key];
result2[length] = [key, value, isStrictComparable(value)];
}
return result2;
}
function getNative2(object, key) {
var value = getValue2(object, key);
return baseIsNative2(value) ? value : undefined$1;
}
function getRawTag2(value) {
var isOwn = hasOwnProperty2.call(value, symToStringTag2), tag = value[symToStringTag2];
try {
value[symToStringTag2] = undefined$1;
var unmasked = true;
} catch (e) {
}
var result2 = nativeObjectToString2.call(value);
if (unmasked) {
if (isOwn) {
value[symToStringTag2] = tag;
} else {
delete value[symToStringTag2];
}
}
return result2;
}
var getSymbols2 = !nativeGetSymbols2 ? stubArray2 : function(object) {
if (object == null) {
return [];
}
object = Object2(object);
return arrayFilter2(nativeGetSymbols2(object), function(symbol) {
return propertyIsEnumerable2.call(object, symbol);
});
};
var getSymbolsIn2 = !nativeGetSymbols2 ? stubArray2 : function(object) {
var result2 = [];
while (object) {
arrayPush2(result2, getSymbols2(object));
object = getPrototype2(object);
}
return result2;
};
var getTag2 = baseGetTag2;
if (DataView2 && getTag2(new DataView2(new ArrayBuffer(1))) != dataViewTag2 || Map2 && getTag2(new Map2()) != mapTag2 || Promise2 && getTag2(Promise2.resolve()) != promiseTag2 || Set2 && getTag2(new Set2()) != setTag2 || WeakMap2 && getTag2(new WeakMap2()) != weakMapTag2) {
getTag2 = function(value) {
var result2 = baseGetTag2(value), Ctor = result2 == objectTag2 ? value.constructor : undefined$1, ctorString = Ctor ? toSource2(Ctor) : "";
if (ctorString) {
switch (ctorString) {
case dataViewCtorString2:
return dataViewTag2;
case mapCtorString2:
return mapTag2;
case promiseCtorString2:
return promiseTag2;
case setCtorString2:
return setTag2;
case weakMapCtorString2:
return weakMapTag2;
}
}
return result2;
};
}
function getView(start, end, transforms) {
var index2 = -1, length = transforms.length;
while (++index2 < length) {
var data4 = transforms[index2], size3 = data4.size;
switch (data4.type) {
case "drop":
start += size3;
break;
case "dropRight":
end -= size3;
break;
case "take":
end = nativeMin(end, start + size3);
break;
case "takeRight":
start = nativeMax(start, end - size3);
break;
}
}
return { "start": start, "end": end };
}
function getWrapDetails(source) {
var match = source.match(reWrapDetails);
return match ? match[1].split(reSplitDetails) : [];
}
function hasPath(object, path, hasFunc) {
path = castPath(path, object);
var index2 = -1, length = path.length, result2 = false;
while (++index2 < length) {
var key = toKey(path[index2]);
if (!(result2 = object != null && hasFunc(object, key))) {
break;
}
object = object[key];
}
if (result2 || ++index2 != length) {
return result2;
}
length = object == null ? 0 : object.length;
return !!length && isLength2(length) && isIndex2(key, length) && (isArray2(object) || isArguments2(object));
}
function initCloneArray2(array) {
var length = array.length, result2 = new array.constructor(length);
if (length && typeof array[0] == "string" && hasOwnProperty2.call(array, "index")) {
result2.index = array.index;
result2.input = array.input;
}
return result2;
}
function initCloneObject2(object) {
return typeof object.constructor == "function" && !isPrototype2(object) ? baseCreate2(getPrototype2(object)) : {};
}
function initCloneByTag2(object, tag, isDeep) {
var Ctor = object.constructor;
switch (tag) {
case arrayBufferTag2:
return cloneArrayBuffer2(object);
case boolTag2:
case dateTag2:
return new Ctor(+object);
case dataViewTag2:
return cloneDataView2(object, isDeep);
case float32Tag2:
case float64Tag2:
case int8Tag2:
case int16Tag2:
case int32Tag2:
case uint8Tag2:
case uint8ClampedTag2:
case uint16Tag2:
case uint32Tag2:
return cloneTypedArray2(object, isDeep);
case mapTag2:
return new Ctor();
case numberTag2:
case stringTag2:
return new Ctor(object);
case regexpTag2:
return cloneRegExp2(object);
case setTag2:
return new Ctor();
case symbolTag2:
return cloneSymbol2(object);
}
}
function insertWrapDetails(source, details) {
var length = details.length;
if (!length) {
return source;
}
var lastIndex = length - 1;
details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
details = details.join(length > 2 ? ", " : " ");
return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
}
function isFlattenable(value) {
return isArray2(value) || isArguments2(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
}
function isIndex2(value, length) {
var type = typeof value;
length = length == null ? MAX_SAFE_INTEGER2 : length;
return !!length && (type == "number" || type != "symbol" && reIsUint2.test(value)) && (value > -1 && value % 1 == 0 && value < length);
}
function isIterateeCall(value, index2, object) {
if (!isObject2(object)) {
return false;
}
var type = typeof index2;
if (type == "number" ? isArrayLike2(object) && isIndex2(index2, object.length) : type == "string" && index2 in object) {
return eq2(object[index2], value);
}
return false;
}
function isKey(value, object) {
if (isArray2(value)) {
return false;
}
var type = typeof value;
if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol2(value)) {
return true;
}
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object2(object);
}
function isKeyable2(value) {
var type = typeof value;
return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
}
function isLaziable(func) {
var funcName = getFuncName(func), other = lodash2[funcName];
if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
return false;
}
if (func === other) {
return true;
}
var data4 = getData(other);
return !!data4 && func === data4[0];
}
function isMasked2(func) {
return !!maskSrcKey2 && maskSrcKey2 in func;
}
var isMaskable = coreJsData2 ? isFunction2 : stubFalse2;
function isPrototype2(value) {
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto2;
return value === proto;
}
function isStrictComparable(value) {
return value === value && !isObject2(value);
}
function matchesStrictComparable(key, srcValue) {
return function(object) {
if (object == null) {
return false;
}
return object[key] === srcValue && (srcValue !== undefined$1 || key in Object2(object));
};
}
function memoizeCapped(func) {
var result2 = memoize(func, function(key) {
if (cache.size === MAX_MEMOIZE_SIZE) {
cache.clear();
}
return key;
});
var cache = result2.cache;
return result2;
}
function mergeData(data4, source) {
var bitmask = data4[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data4[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG;
if (!(isCommon || isCombo)) {
return data4;
}
if (srcBitmask & WRAP_BIND_FLAG) {
data4[2] = source[2];
newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
}
var value = source[3];
if (value) {
var partials = data4[3];
data4[3] = partials ? composeArgs(partials, value, source[4]) : value;
data4[4] = partials ? replaceHolders(data4[3], PLACEHOLDER) : source[4];
}
value = source[5];
if (value) {
partials = data4[5];
data4[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
data4[6] = partials ? replaceHolders(data4[5], PLACEHOLDER) : source[6];
}
value = source[7];
if (value) {
data4[7] = value;
}
if (srcBitmask & WRAP_ARY_FLAG) {
data4[8] = data4[8] == null ? source[8] : nativeMin(data4[8], source[8]);
}
if (data4[9] == null) {
data4[9] = source[9];
}
data4[0] = source[0];
data4[1] = newBitmask;
return data4;
}
function nativeKeysIn2(object) {
var result2 = [];
if (object != null) {
for (var key in Object2(object)) {
result2.push(key);
}
}
return result2;
}
function objectToString2(value) {
return nativeObjectToString2.call(value);
}
function overRest(func, start, transform2) {
start = nativeMax(start === undefined$1 ? func.length - 1 : start, 0);
return function() {
var args = arguments, index2 = -1, length = nativeMax(args.length - start, 0), array = Array2(length);
while (++index2 < length) {
array[index2] = args[start + index2];
}
index2 = -1;
var otherArgs = Array2(start + 1);
while (++index2 < start) {
otherArgs[index2] = args[index2];
}
otherArgs[start] = transform2(array);
return apply2(func, this, otherArgs);
};
}
function parent(object, path) {
return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
}
function reorder(array, indexes) {
var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray2(array);
while (length--) {
var index2 = indexes[length];
array[length] = isIndex2(index2, arrLength) ? oldArray[index2] : undefined$1;
}
return array;
}
function safeGet(object, key) {
if (key === "constructor" && typeof object[key] === "function") {
return;
}
if (key == "__proto__") {
return;
}
return object[key];
}
var setData = shortOut(baseSetData);
var setTimeout2 = ctxSetTimeout || function(func, wait) {
return root7.setTimeout(func, wait);
};
var setToString = shortOut(baseSetToString);
function setWrapToString(wrapper, reference, bitmask) {
var source = reference + "";
return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
}
function shortOut(func) {
var count = 0, lastCalled = 0;
return function() {
var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
lastCalled = stamp;
if (remaining > 0) {
if (++count >= HOT_COUNT) {
return arguments[0];
}
} else {
count = 0;
}
return func.apply(undefined$1, arguments);
};
}
function shuffleSelf(array, size3) {
var index2 = -1, length = array.length, lastIndex = length - 1;
size3 = size3 === undefined$1 ? length : size3;
while (++index2 < size3) {
var rand = baseRandom(index2, lastIndex), value = array[rand];
array[rand] = array[index2];
array[index2] = value;
}
array.length = size3;
return array;
}
var stringToPath = memoizeCapped(function(string) {
var result2 = [];
if (string.charCodeAt(0) === 46) {
result2.push("");
}
string.replace(rePropName, function(match, number, quote, subString) {
result2.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
});
return result2;
});
function toKey(value) {
if (typeof value == "string" || isSymbol2(value)) {
return value;
}
var result2 = value + "";
return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2;
}
function toSource2(func) {
if (func != null) {
try {
return funcToString2.call(func);
} catch (e) {
}
try {
return func + "";
} catch (e) {
}
}
return "";
}
function updateWrapDetails(details, bitmask) {
arrayEach2(wrapFlags, function(pair) {
var value = "_." + pair[0];
if (bitmask & pair[1] && !arrayIncludes(details, value)) {
details.push(value);
}
});
return details.sort();
}
function wrapperClone(wrapper) {
if (wrapper instanceof LazyWrapper) {
return wrapper.clone();
}
var result2 = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
result2.__actions__ = copyArray2(wrapper.__actions__);
result2.__index__ = wrapper.__index__;
result2.__values__ = wrapper.__values__;
return result2;
}
function chunk(array, size3, guard) {
if (guard ? isIterateeCall(array, size3, guard) : size3 === undefined$1) {
size3 = 1;
} else {
size3 = nativeMax(toInteger(size3), 0);
}
var length = array == null ? 0 : array.length;
if (!length || size3 < 1) {
return [];
}
var index2 = 0, resIndex = 0, result2 = Array2(nativeCeil(length / size3));
while (index2 < length) {
result2[resIndex++] = baseSlice(array, index2, index2 += size3);
}
return result2;
}
function compact(array) {
var index2 = -1, length = array == null ? 0 : array.length, resIndex = 0, result2 = [];
while (++index2 < length) {
var value = array[index2];
if (value) {
result2[resIndex++] = value;
}
}
return result2;
}
function concat() {
var length = arguments.length;
if (!length) {
return [];
}
var args = Array2(length - 1), array = arguments[0], index2 = length;
while (index2--) {
args[index2 - 1] = arguments[index2];
}
return arrayPush2(isArray2(array) ? copyArray2(array) : [array], baseFlatten(args, 1));
}
var difference = baseRest(function(array, values2) {
return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true)) : [];
});
var differenceBy = baseRest(function(array, values2) {
var iteratee2 = last(values2);
if (isArrayLikeObject(iteratee2)) {
iteratee2 = undefined$1;
}
return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)) : [];
});
var differenceWith = baseRest(function(array, values2) {
var comparator = last(values2);
if (isArrayLikeObject(comparator)) {
comparator = undefined$1;
}
return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), undefined$1, comparator) : [];
});
function drop(array, n, guard) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
n = guard || n === undefined$1 ? 1 : toInteger(n);
return baseSlice(array, n < 0 ? 0 : n, length);
}
function dropRight(array, n, guard) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
n = guard || n === undefined$1 ? 1 : toInteger(n);
n = length - n;
return baseSlice(array, 0, n < 0 ? 0 : n);
}
function dropRightWhile(array, predicate) {
return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : [];
}
function dropWhile(array, predicate) {
return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : [];
}
function fill(array, value, start, end) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
if (start && typeof start != "number" && isIterateeCall(array, value, start)) {
start = 0;
end = length;
}
return baseFill(array, value, start, end);
}
function findIndex(array, predicate, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index2 = fromIndex == null ? 0 : toInteger(fromIndex);
if (index2 < 0) {
index2 = nativeMax(length + index2, 0);
}
return baseFindIndex(array, getIteratee(predicate, 3), index2);
}
function findLastIndex(array, predicate, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index2 = length - 1;
if (fromIndex !== undefined$1) {
index2 = toInteger(fromIndex);
index2 = fromIndex < 0 ? nativeMax(length + index2, 0) : nativeMin(index2, length - 1);
}
return baseFindIndex(array, getIteratee(predicate, 3), index2, true);
}
function flatten(array) {
var length = array == null ? 0 : array.length;
return length ? baseFlatten(array, 1) : [];
}
function flattenDeep(array) {
var length = array == null ? 0 : array.length;
return length ? baseFlatten(array, INFINITY) : [];
}
function flattenDepth(array, depth) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
depth = depth === undefined$1 ? 1 : toInteger(depth);
return baseFlatten(array, depth);
}
function fromPairs(pairs) {
var index2 = -1, length = pairs == null ? 0 : pairs.length, result2 = {};
while (++index2 < length) {
var pair = pairs[index2];
result2[pair[0]] = pair[1];
}
return result2;
}
function head(array) {
return array && array.length ? array[0] : undefined$1;
}
function indexOf(array, value, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index2 = fromIndex == null ? 0 : toInteger(fromIndex);
if (index2 < 0) {
index2 = nativeMax(length + index2, 0);
}
return baseIndexOf(array, value, index2);
}
function initial(array) {
var length = array == null ? 0 : array.length;
return length ? baseSlice(array, 0, -1) : [];
}
var intersection = baseRest(function(arrays) {
var mapped = arrayMap(arrays, castArrayLikeObject);
return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
});
var intersectionBy = baseRest(function(arrays) {
var iteratee2 = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
if (iteratee2 === last(mapped)) {
iteratee2 = undefined$1;
} else {
mapped.pop();
}
return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee2, 2)) : [];
});
var intersectionWith = baseRest(function(arrays) {
var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
comparator = typeof comparator == "function" ? comparator : undefined$1;
if (comparator) {
mapped.pop();
}
return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined$1, comparator) : [];
});
function join(array, separator) {
return array == null ? "" : nativeJoin.call(array, separator);
}
function last(array) {
var length = array == null ? 0 : array.length;
return length ? array[length - 1] : undefined$1;
}
function lastIndexOf(array, value, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index2 = length;
if (fromIndex !== undefined$1) {
index2 = toInteger(fromIndex);
index2 = index2 < 0 ? nativeMax(length + index2, 0) : nativeMin(index2, length - 1);
}
return value === value ? strictLastIndexOf(array, value, index2) : baseFindIndex(array, baseIsNaN, index2, true);
}
function nth(array, n) {
return array && array.length ? baseNth(array, toInteger(n)) : undefined$1;
}
var pull = baseRest(pullAll);
function pullAll(array, values2) {
return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array;
}
function pullAllBy(array, values2, iteratee2) {
return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array;
}
function pullAllWith(array, values2, comparator) {
return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined$1, comparator) : array;
}
var pullAt = flatRest(function(array, indexes) {
var length = array == null ? 0 : array.length, result2 = baseAt(array, indexes);
basePullAt(array, arrayMap(indexes, function(index2) {
return isIndex2(index2, length) ? +index2 : index2;
}).sort(compareAscending));
return result2;
});
function remove3(array, predicate) {
var result2 = [];
if (!(array && array.length)) {
return result2;
}
var index2 = -1, indexes = [], length = array.length;
predicate = getIteratee(predicate, 3);
while (++index2 < length) {
var value = array[index2];
if (predicate(value, index2, array)) {
result2.push(value);
indexes.push(index2);
}
}
basePullAt(array, indexes);
return result2;
}
function reverse(array) {
return array == null ? array : nativeReverse.call(array);
}
function slice(array, start, end) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
if (end && typeof end != "number" && isIterateeCall(array, start, end)) {
start = 0;
end = length;
} else {
start = start == null ? 0 : toInteger(start);
end = end === undefined$1 ? length : toInteger(end);
}
return baseSlice(array, start, end);
}
function sortedIndex(array, value) {
return baseSortedIndex(array, value);
}
function sortedIndexBy(array, value, iteratee2) {
return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2));
}
function sortedIndexOf(array, value) {
var length = array == null ? 0 : array.length;
if (length) {
var index2 = baseSortedIndex(array, value);
if (index2 < length && eq2(array[index2], value)) {
return index2;
}
}
return -1;
}
function sortedLastIndex(array, value) {
return baseSortedIndex(array, value, true);
}
function sortedLastIndexBy(array, value, iteratee2) {
return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2), true);
}
function sortedLastIndexOf(array, value) {
var length = array == null ? 0 : array.length;
if (length) {
var index2 = baseSortedIndex(array, value, true) - 1;
if (eq2(array[index2], value)) {
return index2;
}
}
return -1;
}
function sortedUniq(array) {
return array && array.length ? baseSortedUniq(array) : [];
}
function sortedUniqBy(array, iteratee2) {
return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : [];
}
function tail(array) {
var length = array == null ? 0 : array.length;
return length ? baseSlice(array, 1, length) : [];
}
function take(array, n, guard) {
if (!(array && array.length)) {
return [];
}
n = guard || n === undefined$1 ? 1 : toInteger(n);
return baseSlice(array, 0, n < 0 ? 0 : n);
}
function takeRight(array, n, guard) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
n = guard || n === undefined$1 ? 1 : toInteger(n);
n = length - n;
return baseSlice(array, n < 0 ? 0 : n, length);
}
function takeRightWhile(array, predicate) {
return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : [];
}
function takeWhile(array, predicate) {
return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : [];
}
var union = baseRest(function(arrays) {
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
});
var unionBy = baseRest(function(arrays) {
var iteratee2 = last(arrays);
if (isArrayLikeObject(iteratee2)) {
iteratee2 = undefined$1;
}
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2));
});
var unionWith = baseRest(function(arrays) {
var comparator = last(arrays);
comparator = typeof comparator == "function" ? comparator : undefined$1;
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined$1, comparator);
});
function uniq(array) {
return array && array.length ? baseUniq(array) : [];
}
function uniqBy(array, iteratee2) {
return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : [];
}
function uniqWith(array, comparator) {
comparator = typeof comparator == "function" ? comparator : undefined$1;
return array && array.length ? baseUniq(array, undefined$1, comparator) : [];
}
function unzip(array) {
if (!(array && array.length)) {
return [];
}
var length = 0;
array = arrayFilter2(array, function(group) {
if (isArrayLikeObject(group)) {
length = nativeMax(group.length, length);
return true;
}
});
return baseTimes2(length, function(index2) {
return arrayMap(array, baseProperty(index2));
});
}
function unzipWith(array, iteratee2) {
if (!(array && array.length)) {
return [];
}
var result2 = unzip(array);
if (iteratee2 == null) {
return result2;
}
return arrayMap(result2, function(group) {
return apply2(iteratee2, undefined$1, group);
});
}
var without = baseRest(function(array, values2) {
return isArrayLikeObject(array) ? baseDifference(array, values2) : [];
});
var xor = baseRest(function(arrays) {
return baseXor(arrayFilter2(arrays, isArrayLikeObject));
});
var xorBy = baseRest(function(arrays) {
var iteratee2 = last(arrays);
if (isArrayLikeObject(iteratee2)) {
iteratee2 = undefined$1;
}
return baseXor(arrayFilter2(arrays, isArrayLikeObject), getIteratee(iteratee2, 2));
});
var xorWith = baseRest(function(arrays) {
var comparator = last(arrays);
comparator = typeof comparator == "function" ? comparator : undefined$1;
return baseXor(arrayFilter2(arrays, isArrayLikeObject), undefined$1, comparator);
});
var zip = baseRest(unzip);
function zipObject(props, values2) {
return baseZipObject(props || [], values2 || [], assignValue2);
}
function zipObjectDeep(props, values2) {
return baseZipObject(props || [], values2 || [], baseSet);
}
var zipWith = baseRest(function(arrays) {
var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : undefined$1;
iteratee2 = typeof iteratee2 == "function" ? (arrays.pop(), iteratee2) : undefined$1;
return unzipWith(arrays, iteratee2);
});
function chain(value) {
var result2 = lodash2(value);
result2.__chain__ = true;
return result2;
}
function tap(value, interceptor) {
interceptor(value);
return value;
}
function thru(value, interceptor) {
return interceptor(value);
}
var wrapperAt = flatRest(function(paths) {
var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object) {
return baseAt(object, paths);
};
if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex2(start)) {
return this.thru(interceptor);
}
value = value.slice(start, +start + (length ? 1 : 0));
value.__actions__.push({
"func": thru,
"args": [interceptor],
"thisArg": undefined$1
});
return new LodashWrapper(value, this.__chain__).thru(function(array) {
if (length && !array.length) {
array.push(undefined$1);
}
return array;
});
});
function wrapperChain() {
return chain(this);
}
function wrapperCommit() {
return new LodashWrapper(this.value(), this.__chain__);
}
function wrapperNext() {
if (this.__values__ === undefined$1) {
this.__values__ = toArray(this.value());
}
var done = this.__index__ >= this.__values__.length, value = done ? undefined$1 : this.__values__[this.__index__++];
return { "done": done, "value": value };
}
function wrapperToIterator() {
return this;
}
function wrapperPlant(value) {
var result2, parent2 = this;
while (parent2 instanceof baseLodash) {
var clone2 = wrapperClone(parent2);
clone2.__index__ = 0;
clone2.__values__ = undefined$1;
if (result2) {
previous.__wrapped__ = clone2;
} else {
result2 = clone2;
}
var previous = clone2;
parent2 = parent2.__wrapped__;
}
previous.__wrapped__ = value;
return result2;
}
function wrapperReverse() {
var value = this.__wrapped__;
if (value instanceof LazyWrapper) {
var wrapped = value;
if (this.__actions__.length) {
wrapped = new LazyWrapper(this);
}
wrapped = wrapped.reverse();
wrapped.__actions__.push({
"func": thru,
"args": [reverse],
"thisArg": undefined$1
});
return new LodashWrapper(wrapped, this.__chain__);
}
return this.thru(reverse);
}
function wrapperValue() {
return baseWrapperValue(this.__wrapped__, this.__actions__);
}
var countBy = createAggregator(function(result2, value, key) {
if (hasOwnProperty2.call(result2, key)) {
++result2[key];
} else {
baseAssignValue2(result2, key, 1);
}
});
function every(collection, predicate, guard) {
var func = isArray2(collection) ? arrayEvery : baseEvery;
if (guard && isIterateeCall(collection, predicate, guard)) {
predicate = undefined$1;
}
return func(collection, getIteratee(predicate, 3));
}
function filter(collection, predicate) {
var func = isArray2(collection) ? arrayFilter2 : baseFilter;
return func(collection, getIteratee(predicate, 3));
}
var find2 = createFind(findIndex);
var findLast = createFind(findLastIndex);
function flatMap(collection, iteratee2) {
return baseFlatten(map(collection, iteratee2), 1);
}
function flatMapDeep(collection, iteratee2) {
return baseFlatten(map(collection, iteratee2), INFINITY);
}
function flatMapDepth(collection, iteratee2, depth) {
depth = depth === undefined$1 ? 1 : toInteger(depth);
return baseFlatten(map(collection, iteratee2), depth);
}
function forEach(collection, iteratee2) {
var func = isArray2(collection) ? arrayEach2 : baseEach;
return func(collection, getIteratee(iteratee2, 3));
}
function forEachRight(collection, iteratee2) {
var func = isArray2(collection) ? arrayEachRight : baseEachRight;
return func(collection, getIteratee(iteratee2, 3));
}
var groupBy = createAggregator(function(result2, value, key) {
if (hasOwnProperty2.call(result2, key)) {
result2[key].push(value);
} else {
baseAssignValue2(result2, key, [value]);
}
});
function includes(collection, value, fromIndex, guard) {
collection = isArrayLike2(collection) ? collection : values(collection);
fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
var length = collection.length;
if (fromIndex < 0) {
fromIndex = nativeMax(length + fromIndex, 0);
}
return isString2(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
}
var invokeMap = baseRest(function(collection, path, args) {
var index2 = -1, isFunc = typeof path == "function", result2 = isArrayLike2(collection) ? Array2(collection.length) : [];
baseEach(collection, function(value) {
result2[++index2] = isFunc ? apply2(path, value, args) : baseInvoke(value, path, args);
});
return result2;
});
var keyBy = createAggregator(function(result2, value, key) {
baseAssignValue2(result2, key, value);
});
function map(collection, iteratee2) {
var func = isArray2(collection) ? arrayMap : baseMap;
return func(collection, getIteratee(iteratee2, 3));
}
function orderBy(collection, iteratees, orders, guard) {
if (collection == null) {
return [];
}
if (!isArray2(iteratees)) {
iteratees = iteratees == null ? [] : [iteratees];
}
orders = guard ? undefined$1 : orders;
if (!isArray2(orders)) {
orders = orders == null ? [] : [orders];
}
return baseOrderBy(collection, iteratees, orders);
}
var partition = createAggregator(function(result2, value, key) {
result2[key ? 0 : 1].push(value);
}, function() {
return [[], []];
});
function reduce2(collection, iteratee2, accumulator) {
var func = isArray2(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEach);
}
function reduceRight(collection, iteratee2, accumulator) {
var func = isArray2(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight);
}
function reject(collection, predicate) {
var func = isArray2(collection) ? arrayFilter2 : baseFilter;
return func(collection, negate(getIteratee(predicate, 3)));
}
function sample(collection) {
var func = isArray2(collection) ? arraySample : baseSample;
return func(collection);
}
function sampleSize(collection, n, guard) {
if (guard ? isIterateeCall(collection, n, guard) : n === undefined$1) {
n = 1;
} else {
n = toInteger(n);
}
var func = isArray2(collection) ? arraySampleSize : baseSampleSize;
return func(collection, n);
}
function shuffle(collection) {
var func = isArray2(collection) ? arrayShuffle : baseShuffle;
return func(collection);
}
function size2(collection) {
if (collection == null) {
return 0;
}
if (isArrayLike2(collection)) {
return isString2(collection) ? stringSize(collection) : collection.length;
}
var tag = getTag2(collection);
if (tag == mapTag2 || tag == setTag2) {
return collection.size;
}
return baseKeys2(collection).length;
}
function some(collection, predicate, guard) {
var func = isArray2(collection) ? arraySome : baseSome;
if (guard && isIterateeCall(collection, predicate, guard)) {
predicate = undefined$1;
}
return func(collection, getIteratee(predicate, 3));
}
var sortBy = baseRest(function(collection, iteratees) {
if (collection == null) {
return [];
}
var length = iteratees.length;
if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
iteratees = [];
} else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
iteratees = [iteratees[0]];
}
return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
});
var now = ctxNow || function() {
return root7.Date.now();
};
function after(n, func) {
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
n = toInteger(n);
return function() {
if (--n < 1) {
return func.apply(this, arguments);
}
};
}
function ary(func, n, guard) {
n = guard ? undefined$1 : n;
n = func && n == null ? func.length : n;
return createWrap(func, WRAP_ARY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, n);
}
function before(n, func) {
var result2;
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
n = toInteger(n);
return function() {
if (--n > 0) {
result2 = func.apply(this, arguments);
}
if (n <= 1) {
func = undefined$1;
}
return result2;
};
}
var bind2 = baseRest(function(func, thisArg, partials) {
var bitmask = WRAP_BIND_FLAG;
if (partials.length) {
var holders = replaceHolders(partials, getHolder(bind2));
bitmask |= WRAP_PARTIAL_FLAG;
}
return createWrap(func, bitmask, thisArg, partials, holders);
});
var bindKey = baseRest(function(object, key, partials) {
var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
if (partials.length) {
var holders = replaceHolders(partials, getHolder(bindKey));
bitmask |= WRAP_PARTIAL_FLAG;
}
return createWrap(key, bitmask, object, partials, holders);
});
function curry(func, arity, guard) {
arity = guard ? undefined$1 : arity;
var result2 = createWrap(func, WRAP_CURRY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
result2.placeholder = curry.placeholder;
return result2;
}
function curryRight(func, arity, guard) {
arity = guard ? undefined$1 : arity;
var result2 = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
result2.placeholder = curryRight.placeholder;
return result2;
}
function debounce(func, wait, options) {
var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
wait = toNumber2(wait) || 0;
if (isObject2(options)) {
leading = !!options.leading;
maxing = "maxWait" in options;
maxWait = maxing ? nativeMax(toNumber2(options.maxWait) || 0, wait) : maxWait;
trailing = "trailing" in options ? !!options.trailing : trailing;
}
function invokeFunc(time) {
var args = lastArgs, thisArg = lastThis;
lastArgs = lastThis = undefined$1;
lastInvokeTime = time;
result2 = func.apply(thisArg, args);
return result2;
}
function leadingEdge(time) {
lastInvokeTime = time;
timerId = setTimeout2(timerExpired, wait);
return leading ? invokeFunc(time) : result2;
}
function remainingWait(time) {
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
}
function shouldInvoke(time) {
var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
return lastCallTime === undefined$1 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
}
function timerExpired() {
var time = now();
if (shouldInvoke(time)) {
return trailingEdge(time);
}
timerId = setTimeout2(timerExpired, remainingWait(time));
}
function trailingEdge(time) {
timerId = undefined$1;
if (trailing && lastArgs) {
return invokeFunc(time);
}
lastArgs = lastThis = undefined$1;
return result2;
}
function cancel() {
if (timerId !== undefined$1) {
clearTimeout2(timerId);
}
lastInvokeTime = 0;
lastArgs = lastCallTime = lastThis = timerId = undefined$1;
}
function flush() {
return timerId === undefined$1 ? result2 : trailingEdge(now());
}
function debounced() {
var time = now(), isInvoking = shouldInvoke(time);
lastArgs = arguments;
lastThis = this;
lastCallTime = time;
if (isInvoking) {
if (timerId === undefined$1) {
return leadingEdge(lastCallTime);
}
if (maxing) {
clearTimeout2(timerId);
timerId = setTimeout2(timerExpired, wait);
return invokeFunc(lastCallTime);
}
}
if (timerId === undefined$1) {
timerId = setTimeout2(timerExpired, wait);
}
return result2;
}
debounced.cancel = cancel;
debounced.flush = flush;
return debounced;
}
var defer = baseRest(function(func, args) {
return baseDelay(func, 1, args);
});
var delay = baseRest(function(func, wait, args) {
return baseDelay(func, toNumber2(wait) || 0, args);
});
function flip(func) {
return createWrap(func, WRAP_FLIP_FLAG);
}
function memoize(func, resolver) {
if (typeof func != "function" || resolver != null && typeof resolver != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
var memoized = function() {
var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
if (cache.has(key)) {
return cache.get(key);
}
var result2 = func.apply(this, args);
memoized.cache = cache.set(key, result2) || cache;
return result2;
};
memoized.cache = new (memoize.Cache || MapCache2)();
return memoized;
}
memoize.Cache = MapCache2;
function negate(predicate) {
if (typeof predicate != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
return function() {
var args = arguments;
switch (args.length) {
case 0:
return !predicate.call(this);
case 1:
return !predicate.call(this, args[0]);
case 2:
return !predicate.call(this, args[0], args[1]);
case 3:
return !predicate.call(this, args[0], args[1], args[2]);
}
return !predicate.apply(this, args);
};
}
function once(func) {
return before(2, func);
}
var overArgs = castRest(function(func, transforms) {
transforms = transforms.length == 1 && isArray2(transforms[0]) ? arrayMap(transforms[0], baseUnary2(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary2(getIteratee()));
var funcsLength = transforms.length;
return baseRest(function(args) {
var index2 = -1, length = nativeMin(args.length, funcsLength);
while (++index2 < length) {
args[index2] = transforms[index2].call(this, args[index2]);
}
return apply2(func, this, args);
});
});
var partial = baseRest(function(func, partials) {
var holders = replaceHolders(partials, getHolder(partial));
return createWrap(func, WRAP_PARTIAL_FLAG, undefined$1, partials, holders);
});
var partialRight = baseRest(function(func, partials) {
var holders = replaceHolders(partials, getHolder(partialRight));
return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined$1, partials, holders);
});
var rearg = flatRest(function(func, indexes) {
return createWrap(func, WRAP_REARG_FLAG, undefined$1, undefined$1, undefined$1, indexes);
});
function rest(func, start) {
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
start = start === undefined$1 ? start : toInteger(start);
return baseRest(func, start);
}
function spread(func, start) {
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
start = start == null ? 0 : nativeMax(toInteger(start), 0);
return baseRest(function(args) {
var array = args[start], otherArgs = castSlice(args, 0, start);
if (array) {
arrayPush2(otherArgs, array);
}
return apply2(func, this, otherArgs);
});
}
function throttle(func, wait, options) {
var leading = true, trailing = true;
if (typeof func != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
if (isObject2(options)) {
leading = "leading" in options ? !!options.leading : leading;
trailing = "trailing" in options ? !!options.trailing : trailing;
}
return debounce(func, wait, {
"leading": leading,
"maxWait": wait,
"trailing": trailing
});
}
function unary(func) {
return ary(func, 1);
}
function wrap(value, wrapper) {
return partial(castFunction(wrapper), value);
}
function castArray() {
if (!arguments.length) {
return [];
}
var value = arguments[0];
return isArray2(value) ? value : [value];
}
function clone(value) {
return baseClone2(value, CLONE_SYMBOLS_FLAG2);
}
function cloneWith(value, customizer) {
customizer = typeof customizer == "function" ? customizer : undefined$1;
return baseClone2(value, CLONE_SYMBOLS_FLAG2, customizer);
}
function cloneDeep2(value) {
return baseClone2(value, CLONE_DEEP_FLAG2 | CLONE_SYMBOLS_FLAG2);
}
function cloneDeepWith(value, customizer) {
customizer = typeof customizer == "function" ? customizer : undefined$1;
return baseClone2(value, CLONE_DEEP_FLAG2 | CLONE_SYMBOLS_FLAG2, customizer);
}
function conformsTo(object, source) {
return source == null || baseConformsTo(object, source, keys2(source));
}
function eq2(value, other) {
return value === other || value !== value && other !== other;
}
var gt = createRelationalOperation(baseGt);
var gte = createRelationalOperation(function(value, other) {
return value >= other;
});
var isArguments2 = baseIsArguments2(/* @__PURE__ */ function() {
return arguments;
}()) ? baseIsArguments2 : function(value) {
return isObjectLike2(value) && hasOwnProperty2.call(value, "callee") && !propertyIsEnumerable2.call(value, "callee");
};
var isArray2 = Array2.isArray;
var isArrayBuffer = nodeIsArrayBuffer ? baseUnary2(nodeIsArrayBuffer) : baseIsArrayBuffer;
function isArrayLike2(value) {
return value != null && isLength2(value.length) && !isFunction2(value);
}
function isArrayLikeObject(value) {
return isObjectLike2(value) && isArrayLike2(value);
}
function isBoolean(value) {
return value === true || value === false || isObjectLike2(value) && baseGetTag2(value) == boolTag2;
}
var isBuffer2 = nativeIsBuffer || stubFalse2;
var isDate = nodeIsDate ? baseUnary2(nodeIsDate) : baseIsDate;
function isElement2(value) {
return isObjectLike2(value) && value.nodeType === 1 && !isPlainObject2(value);
}
function isEmpty2(value) {
if (value == null) {
return true;
}
if (isArrayLike2(value) && (isArray2(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer2(value) || isTypedArray2(value) || isArguments2(value))) {
return !value.length;
}
var tag = getTag2(value);
if (tag == mapTag2 || tag == setTag2) {
return !value.size;
}
if (isPrototype2(value)) {
return !baseKeys2(value).length;
}
for (var key in value) {
if (hasOwnProperty2.call(value, key)) {
return false;
}
}
return true;
}
function isEqual(value, other) {
return baseIsEqual(value, other);
}
function isEqualWith(value, other, customizer) {
customizer = typeof customizer == "function" ? customizer : undefined$1;
var result2 = customizer ? customizer(value, other) : undefined$1;
return result2 === undefined$1 ? baseIsEqual(value, other, undefined$1, customizer) : !!result2;
}
function isError(value) {
if (!isObjectLike2(value)) {
return false;
}
var tag = baseGetTag2(value);
return tag == errorTag2 || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject2(value);
}
function isFinite(value) {
return typeof value == "number" && nativeIsFinite(value);
}
function isFunction2(value) {
if (!isObject2(value)) {
return false;
}
var tag = baseGetTag2(value);
return tag == funcTag2 || tag == genTag2 || tag == asyncTag2 || tag == proxyTag2;
}
function isInteger(value) {
return typeof value == "number" && value == toInteger(value);
}
function isLength2(value) {
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
}
function isObject2(value) {
var type = typeof value;
return value != null && (type == "object" || type == "function");
}
function isObjectLike2(value) {
return value != null && typeof value == "object";
}
var isMap2 = nodeIsMap2 ? baseUnary2(nodeIsMap2) : baseIsMap2;
function isMatch(object, source) {
return object === source || baseIsMatch(object, source, getMatchData(source));
}
function isMatchWith(object, source, customizer) {
customizer = typeof customizer == "function" ? customizer : undefined$1;
return baseIsMatch(object, source, getMatchData(source), customizer);
}
function isNaN2(value) {
return isNumber2(value) && value != +value;
}
function isNative(value) {
if (isMaskable(value)) {
throw new Error2(CORE_ERROR_TEXT);
}
return baseIsNative2(value);
}
function isNull(value) {
return value === null;
}
function isNil(value) {
return value == null;
}
function isNumber2(value) {
return typeof value == "number" || isObjectLike2(value) && baseGetTag2(value) == numberTag2;
}
function isPlainObject2(value) {
if (!isObjectLike2(value) || baseGetTag2(value) != objectTag2) {
return false;
}
var proto = getPrototype2(value);
if (proto === null) {
return true;
}
var Ctor = hasOwnProperty2.call(proto, "constructor") && proto.constructor;
return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString2.call(Ctor) == objectCtorString;
}
var isRegExp = nodeIsRegExp ? baseUnary2(nodeIsRegExp) : baseIsRegExp;
function isSafeInteger(value) {
return isInteger(value) && value >= -MAX_SAFE_INTEGER2 && value <= MAX_SAFE_INTEGER2;
}
var isSet2 = nodeIsSet2 ? baseUnary2(nodeIsSet2) : baseIsSet2;
function isString2(value) {
return typeof value == "string" || !isArray2(value) && isObjectLike2(value) && baseGetTag2(value) == stringTag2;
}
function isSymbol2(value) {
return typeof value == "symbol" || isObjectLike2(value) && baseGetTag2(value) == symbolTag2;
}
var isTypedArray2 = nodeIsTypedArray2 ? baseUnary2(nodeIsTypedArray2) : baseIsTypedArray2;
function isUndefined(value) {
return value === undefined$1;
}
function isWeakMap(value) {
return isObjectLike2(value) && getTag2(value) == weakMapTag2;
}
function isWeakSet(value) {
return isObjectLike2(value) && baseGetTag2(value) == weakSetTag;
}
var lt = createRelationalOperation(baseLt);
var lte = createRelationalOperation(function(value, other) {
return value <= other;
});
function toArray(value) {
if (!value) {
return [];
}
if (isArrayLike2(value)) {
return isString2(value) ? stringToArray(value) : copyArray2(value);
}
if (symIterator && value[symIterator]) {
return iteratorToArray(value[symIterator]());
}
var tag = getTag2(value), func = tag == mapTag2 ? mapToArray : tag == setTag2 ? setToArray : values;
return func(value);
}
function toFinite(value) {
if (!value) {
return value === 0 ? value : 0;
}
value = toNumber2(value);
if (value === INFINITY || value === -INFINITY) {
var sign = value < 0 ? -1 : 1;
return sign * MAX_INTEGER;
}
return value === value ? value : 0;
}
function toInteger(value) {
var result2 = toFinite(value), remainder = result2 % 1;
return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;
}
function toLength(value) {
return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
}
function toNumber2(value) {
if (typeof value == "number") {
return value;
}
if (isSymbol2(value)) {
return NAN;
}
if (isObject2(value)) {
var other = typeof value.valueOf == "function" ? value.valueOf() : value;
value = isObject2(other) ? other + "" : other;
}
if (typeof value != "string") {
return value === 0 ? value : +value;
}
value = baseTrim(value);
var isBinary = reIsBinary.test(value);
return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
}
function toPlainObject(value) {
return copyObject2(value, keysIn2(value));
}
function toSafeInteger(value) {
return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER2, MAX_SAFE_INTEGER2) : value === 0 ? value : 0;
}
function toString(value) {
return value == null ? "" : baseToString(value);
}
var assign2 = createAssigner(function(object, source) {
if (isPrototype2(source) || isArrayLike2(source)) {
copyObject2(source, keys2(source), object);
return;
}
for (var key in source) {
if (hasOwnProperty2.call(source, key)) {
assignValue2(object, key, source[key]);
}
}
});
var assignIn = createAssigner(function(object, source) {
copyObject2(source, keysIn2(source), object);
});
var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
copyObject2(source, keysIn2(source), object, customizer);
});
var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
copyObject2(source, keys2(source), object, customizer);
});
var at = flatRest(baseAt);
function create(prototype, properties) {
var result2 = baseCreate2(prototype);
return properties == null ? result2 : baseAssign2(result2, properties);
}
var defaults = baseRest(function(object, sources) {
object = Object2(object);
var index2 = -1;
var length = sources.length;
var guard = length > 2 ? sources[2] : undefined$1;
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
length = 1;
}
while (++index2 < length) {
var source = sources[index2];
var props = keysIn2(source);
var propsIndex = -1;
var propsLength = props.length;
while (++propsIndex < propsLength) {
var key = props[propsIndex];
var value = object[key];
if (value === undefined$1 || eq2(value, objectProto2[key]) && !hasOwnProperty2.call(object, key)) {
object[key] = source[key];
}
}
}
return object;
});
var defaultsDeep = baseRest(function(args) {
args.push(undefined$1, customDefaultsMerge);
return apply2(mergeWith, undefined$1, args);
});
function findKey(object, predicate) {
return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
}
function findLastKey(object, predicate) {
return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
}
function forIn(object, iteratee2) {
return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn2);
}
function forInRight(object, iteratee2) {
return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn2);
}
function forOwn(object, iteratee2) {
return object && baseForOwn(object, getIteratee(iteratee2, 3));
}
function forOwnRight(object, iteratee2) {
return object && baseForOwnRight(object, getIteratee(iteratee2, 3));
}
function functions(object) {
return object == null ? [] : baseFunctions(object, keys2(object));
}
function functionsIn(object) {
return object == null ? [] : baseFunctions(object, keysIn2(object));
}
function get2(object, path, defaultValue) {
var result2 = object == null ? undefined$1 : baseGet(object, path);
return result2 === undefined$1 ? defaultValue : result2;
}
function has2(object, path) {
return object != null && hasPath(object, path, baseHas);
}
function hasIn(object, path) {
return object != null && hasPath(object, path, baseHasIn);
}
var invert = createInverter(function(result2, value, key) {
if (value != null && typeof value.toString != "function") {
value = nativeObjectToString2.call(value);
}
result2[value] = key;
}, constant(identity));
var invertBy = createInverter(function(result2, value, key) {
if (value != null && typeof value.toString != "function") {
value = nativeObjectToString2.call(value);
}
if (hasOwnProperty2.call(result2, value)) {
result2[value].push(key);
} else {
result2[value] = [key];
}
}, getIteratee);
var invoke = baseRest(baseInvoke);
function keys2(object) {
return isArrayLike2(object) ? arrayLikeKeys2(object) : baseKeys2(object);
}
function keysIn2(object) {
return isArrayLike2(object) ? arrayLikeKeys2(object, true) : baseKeysIn2(object);
}
function mapKeys(object, iteratee2) {
var result2 = {};
iteratee2 = getIteratee(iteratee2, 3);
baseForOwn(object, function(value, key, object2) {
baseAssignValue2(result2, iteratee2(value, key, object2), value);
});
return result2;
}
function mapValues(object, iteratee2) {
var result2 = {};
iteratee2 = getIteratee(iteratee2, 3);
baseForOwn(object, function(value, key, object2) {
baseAssignValue2(result2, key, iteratee2(value, key, object2));
});
return result2;
}
var merge2 = createAssigner(function(object, source, srcIndex) {
baseMerge(object, source, srcIndex);
});
var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
baseMerge(object, source, srcIndex, customizer);
});
var omit = flatRest(function(object, paths) {
var result2 = {};
if (object == null) {
return result2;
}
var isDeep = false;
paths = arrayMap(paths, function(path) {
path = castPath(path, object);
isDeep || (isDeep = path.length > 1);
return path;
});
copyObject2(object, getAllKeysIn2(object), result2);
if (isDeep) {
result2 = baseClone2(result2, CLONE_DEEP_FLAG2 | CLONE_FLAT_FLAG2 | CLONE_SYMBOLS_FLAG2, customOmitClone);
}
var length = paths.length;
while (length--) {
baseUnset(result2, paths[length]);
}
return result2;
});
function omitBy(object, predicate) {
return pickBy(object, negate(getIteratee(predicate)));
}
var pick = flatRest(function(object, paths) {
return object == null ? {} : basePick(object, paths);
});
function pickBy(object, predicate) {
if (object == null) {
return {};
}
var props = arrayMap(getAllKeysIn2(object), function(prop) {
return [prop];
});
predicate = getIteratee(predicate);
return basePickBy(object, props, function(value, path) {
return predicate(value, path[0]);
});
}
function result(object, path, defaultValue) {
path = castPath(path, object);
var index2 = -1, length = path.length;
if (!length) {
length = 1;
object = undefined$1;
}
while (++index2 < length) {
var value = object == null ? undefined$1 : object[toKey(path[index2])];
if (value === undefined$1) {
index2 = length;
value = defaultValue;
}
object = isFunction2(value) ? value.call(object) : value;
}
return object;
}
function set2(object, path, value) {
return object == null ? object : baseSet(object, path, value);
}
function setWith(object, path, value, customizer) {
customizer = typeof customizer == "function" ? customizer : undefined$1;
return object == null ? object : baseSet(object, path, value, customizer);
}
var toPairs = createToPairs(keys2);
var toPairsIn = createToPairs(keysIn2);
function transform(object, iteratee2, accumulator) {
var isArr = isArray2(object), isArrLike = isArr || isBuffer2(object) || isTypedArray2(object);
iteratee2 = getIteratee(iteratee2, 4);
if (accumulator == null) {
var Ctor = object && object.constructor;
if (isArrLike) {
accumulator = isArr ? new Ctor() : [];
} else if (isObject2(object)) {
accumulator = isFunction2(Ctor) ? baseCreate2(getPrototype2(object)) : {};
} else {
accumulator = {};
}
}
(isArrLike ? arrayEach2 : baseForOwn)(object, function(value, index2, object2) {
return iteratee2(accumulator, value, index2, object2);
});
return accumulator;
}
function unset2(object, path) {
return object == null ? true : baseUnset(object, path);
}
function update(object, path, updater) {
return object == null ? object : baseUpdate(object, path, castFunction(updater));
}
function updateWith(object, path, updater, customizer) {
customizer = typeof customizer == "function" ? customizer : undefined$1;
return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
}
function values(object) {
return object == null ? [] : baseValues(object, keys2(object));
}
function valuesIn(object) {
return object == null ? [] : baseValues(object, keysIn2(object));
}
function clamp(number, lower, upper) {
if (upper === undefined$1) {
upper = lower;
lower = undefined$1;
}
if (upper !== undefined$1) {
upper = toNumber2(upper);
upper = upper === upper ? upper : 0;
}
if (lower !== undefined$1) {
lower = toNumber2(lower);
lower = lower === lower ? lower : 0;
}
return baseClamp(toNumber2(number), lower, upper);
}
function inRange(number, start, end) {
start = toFinite(start);
if (end === undefined$1) {
end = start;
start = 0;
} else {
end = toFinite(end);
}
number = toNumber2(number);
return baseInRange(number, start, end);
}
function random(lower, upper, floating) {
if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
upper = floating = undefined$1;
}
if (floating === undefined$1) {
if (typeof upper == "boolean") {
floating = upper;
upper = undefined$1;
} else if (typeof lower == "boolean") {
floating = lower;
lower = undefined$1;
}
}
if (lower === undefined$1 && upper === undefined$1) {
lower = 0;
upper = 1;
} else {
lower = toFinite(lower);
if (upper === undefined$1) {
upper = lower;
lower = 0;
} else {
upper = toFinite(upper);
}
}
if (lower > upper) {
var temp = lower;
lower = upper;
upper = temp;
}
if (floating || lower % 1 || upper % 1) {
var rand = nativeRandom();
return nativeMin(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
}
return baseRandom(lower, upper);
}
var camelCase = createCompounder(function(result2, word, index2) {
word = word.toLowerCase();
return result2 + (index2 ? capitalize2(word) : word);
});
function capitalize2(string) {
return upperFirst(toString(string).toLowerCase());
}
function deburr(string) {
string = toString(string);
return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
}
function endsWith(string, target, position) {
string = toString(string);
target = baseToString(target);
var length = string.length;
position = position === undefined$1 ? length : baseClamp(toInteger(position), 0, length);
var end = position;
position -= target.length;
return position >= 0 && string.slice(position, end) == target;
}
function escape(string) {
string = toString(string);
return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
}
function escapeRegExp(string) {
string = toString(string);
return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar2, "\\$&") : string;
}
var kebabCase = createCompounder(function(result2, word, index2) {
return result2 + (index2 ? "-" : "") + word.toLowerCase();
});
var lowerCase = createCompounder(function(result2, word, index2) {
return result2 + (index2 ? " " : "") + word.toLowerCase();
});
var lowerFirst = createCaseFirst("toLowerCase");
function pad(string, length, chars) {
string = toString(string);
length = toInteger(length);
var strLength = length ? stringSize(string) : 0;
if (!length || strLength >= length) {
return string;
}
var mid = (length - strLength) / 2;
return createPadding(nativeFloor(mid), chars) + string + createPadding(nativeCeil(mid), chars);
}
function padEnd(string, length, chars) {
string = toString(string);
length = toInteger(length);
var strLength = length ? stringSize(string) : 0;
return length && strLength < length ? string + createPadding(length - strLength, chars) : string;
}
function padStart(string, length, chars) {
string = toString(string);
length = toInteger(length);
var strLength = length ? stringSize(string) : 0;
return length && strLength < length ? createPadding(length - strLength, chars) + string : string;
}
function parseInt2(string, radix, guard) {
if (guard || radix == null) {
radix = 0;
} else if (radix) {
radix = +radix;
}
return nativeParseInt(toString(string).replace(reTrimStart, ""), radix || 0);
}
function repeat(string, n, guard) {
if (guard ? isIterateeCall(string, n, guard) : n === undefined$1) {
n = 1;
} else {
n = toInteger(n);
}
return baseRepeat(toString(string), n);
}
function replace() {
var args = arguments, string = toString(args[0]);
return args.length < 3 ? string : string.replace(args[1], args[2]);
}
var snakeCase = createCompounder(function(result2, word, index2) {
return result2 + (index2 ? "_" : "") + word.toLowerCase();
});
function split(string, separator, limit) {
if (limit && typeof limit != "number" && isIterateeCall(string, separator, limit)) {
separator = limit = undefined$1;
}
limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0;
if (!limit) {
return [];
}
string = toString(string);
if (string && (typeof separator == "string" || separator != null && !isRegExp(separator))) {
separator = baseToString(separator);
if (!separator && hasUnicode(string)) {
return castSlice(stringToArray(string), 0, limit);
}
}
return string.split(separator, limit);
}
var startCase = createCompounder(function(result2, word, index2) {
return result2 + (index2 ? " " : "") + upperFirst(word);
});
function startsWith(string, target, position) {
string = toString(string);
position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length);
target = baseToString(target);
return string.slice(position, position + target.length) == target;
}
function template(string, options, guard) {
var settings = lodash2.templateSettings;
if (guard && isIterateeCall(string, options, guard)) {
options = undefined$1;
}
string = toString(string);
options = assignInWith({}, options, settings, customDefaultsAssignIn);
var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys2(imports), importsValues = baseValues(imports, importsKeys);
var isEscaping, isEvaluating, index2 = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
var reDelimiters = RegExp2(
(options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$",
"g"
);
var sourceURL = "//# sourceURL=" + (hasOwnProperty2.call(options, "sourceURL") ? (options.sourceURL + "").replace(/\s/g, " ") : "lodash.templateSources[" + ++templateCounter + "]") + "\n";
string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
interpolateValue || (interpolateValue = esTemplateValue);
source += string.slice(index2, offset).replace(reUnescapedString, escapeStringChar);
if (escapeValue) {
isEscaping = true;
source += "' +\n__e(" + escapeValue + ") +\n'";
}
if (evaluateValue) {
isEvaluating = true;
source += "';\n" + evaluateValue + ";\n__p += '";
}
if (interpolateValue) {
source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
}
index2 = offset + match.length;
return match;
});
source += "';\n";
var variable = hasOwnProperty2.call(options, "variable") && options.variable;
if (!variable) {
source = "with (obj) {\n" + source + "\n}\n";
} else if (reForbiddenIdentifierChars.test(variable)) {
throw new Error2(INVALID_TEMPL_VAR_ERROR_TEXT);
}
source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
var result2 = attempt(function() {
return Function2(importsKeys, sourceURL + "return " + source).apply(undefined$1, importsValues);
});
result2.source = source;
if (isError(result2)) {
throw result2;
}
return result2;
}
function toLower(value) {
return toString(value).toLowerCase();
}
function toUpper(value) {
return toString(value).toUpperCase();
}
function trim(string, chars, guard) {
string = toString(string);
if (string && (guard || chars === undefined$1)) {
return baseTrim(string);
}
if (!string || !(chars = baseToString(chars))) {
return string;
}
var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
return castSlice(strSymbols, start, end).join("");
}
function trimEnd(string, chars, guard) {
string = toString(string);
if (string && (guard || chars === undefined$1)) {
return string.slice(0, trimmedEndIndex(string) + 1);
}
if (!string || !(chars = baseToString(chars))) {
return string;
}
var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
return castSlice(strSymbols, 0, end).join("");
}
function trimStart(string, chars, guard) {
string = toString(string);
if (string && (guard || chars === undefined$1)) {
return string.replace(reTrimStart, "");
}
if (!string || !(chars = baseToString(chars))) {
return string;
}
var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars));
return castSlice(strSymbols, start).join("");
}
function truncate(string, options) {
var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
if (isObject2(options)) {
var separator = "separator" in options ? options.separator : separator;
length = "length" in options ? toInteger(options.length) : length;
omission = "omission" in options ? baseToString(options.omission) : omission;
}
string = toString(string);
var strLength = string.length;
if (hasUnicode(string)) {
var strSymbols = stringToArray(string);
strLength = strSymbols.length;
}
if (length >= strLength) {
return string;
}
var end = length - stringSize(omission);
if (end < 1) {
return omission;
}
var result2 = strSymbols ? castSlice(strSymbols, 0, end).join("") : string.slice(0, end);
if (separator === undefined$1) {
return result2 + omission;
}
if (strSymbols) {
end += result2.length - end;
}
if (isRegExp(separator)) {
if (string.slice(end).search(separator)) {
var match, substring = result2;
if (!separator.global) {
separator = RegExp2(separator.source, toString(reFlags2.exec(separator)) + "g");
}
separator.lastIndex = 0;
while (match = separator.exec(substring)) {
var newEnd = match.index;
}
result2 = result2.slice(0, newEnd === undefined$1 ? end : newEnd);
}
} else if (string.indexOf(baseToString(separator), end) != end) {
var index2 = result2.lastIndexOf(separator);
if (index2 > -1) {
result2 = result2.slice(0, index2);
}
}
return result2 + omission;
}
function unescape(string) {
string = toString(string);
return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;
}
var upperCase = createCompounder(function(result2, word, index2) {
return result2 + (index2 ? " " : "") + word.toUpperCase();
});
var upperFirst = createCaseFirst("toUpperCase");
function words(string, pattern, guard) {
string = toString(string);
pattern = guard ? undefined$1 : pattern;
if (pattern === undefined$1) {
return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
}
return string.match(pattern) || [];
}
var attempt = baseRest(function(func, args) {
try {
return apply2(func, undefined$1, args);
} catch (e) {
return isError(e) ? e : new Error2(e);
}
});
var bindAll = flatRest(function(object, methodNames) {
arrayEach2(methodNames, function(key) {
key = toKey(key);
baseAssignValue2(object, key, bind2(object[key], object));
});
return object;
});
function cond(pairs) {
var length = pairs == null ? 0 : pairs.length, toIteratee = getIteratee();
pairs = !length ? [] : arrayMap(pairs, function(pair) {
if (typeof pair[1] != "function") {
throw new TypeError2(FUNC_ERROR_TEXT);
}
return [toIteratee(pair[0]), pair[1]];
});
return baseRest(function(args) {
var index2 = -1;
while (++index2 < length) {
var pair = pairs[index2];
if (apply2(pair[0], this, args)) {
return apply2(pair[1], this, args);
}
}
});
}
function conforms(source) {
return baseConforms(baseClone2(source, CLONE_DEEP_FLAG2));
}
function constant(value) {
return function() {
return value;
};
}
function defaultTo(value, defaultValue) {
return value == null || value !== value ? defaultValue : value;
}
var flow = createFlow();
var flowRight = createFlow(true);
function identity(value) {
return value;
}
function iteratee(func) {
return baseIteratee(typeof func == "function" ? func : baseClone2(func, CLONE_DEEP_FLAG2));
}
function matches(source) {
return baseMatches(baseClone2(source, CLONE_DEEP_FLAG2));
}
function matchesProperty(path, srcValue) {
return baseMatchesProperty(path, baseClone2(srcValue, CLONE_DEEP_FLAG2));
}
var method = baseRest(function(path, args) {
return function(object) {
return baseInvoke(object, path, args);
};
});
var methodOf = baseRest(function(object, args) {
return function(path) {
return baseInvoke(object, path, args);
};
});
function mixin(object, source, options) {
var props = keys2(source), methodNames = baseFunctions(source, props);
if (options == null && !(isObject2(source) && (methodNames.length || !props.length))) {
options = source;
source = object;
object = this;
methodNames = baseFunctions(source, keys2(source));
}
var chain2 = !(isObject2(options) && "chain" in options) || !!options.chain, isFunc = isFunction2(object);
arrayEach2(methodNames, function(methodName) {
var func = source[methodName];
object[methodName] = func;
if (isFunc) {
object.prototype[methodName] = function() {
var chainAll = this.__chain__;
if (chain2 || chainAll) {
var result2 = object(this.__wrapped__), actions = result2.__actions__ = copyArray2(this.__actions__);
actions.push({ "func": func, "args": arguments, "thisArg": object });
result2.__chain__ = chainAll;
return result2;
}
return func.apply(object, arrayPush2([this.value()], arguments));
};
}
});
return object;
}
function noConflict() {
if (root7._ === this) {
root7._ = oldDash;
}
return this;
}
function noop2() {
}
function nthArg(n) {
n = toInteger(n);
return baseRest(function(args) {
return baseNth(args, n);
});
}
var over = createOver(arrayMap);
var overEvery = createOver(arrayEvery);
var overSome = createOver(arraySome);
function property(path) {
return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
}
function propertyOf(object) {
return function(path) {
return object == null ? undefined$1 : baseGet(object, path);
};
}
var range = createRange();
var rangeRight = createRange(true);
function stubArray2() {
return [];
}
function stubFalse2() {
return false;
}
function stubObject() {
return {};
}
function stubString() {
return "";
}
function stubTrue() {
return true;
}
function times(n, iteratee2) {
n = toInteger(n);
if (n < 1 || n > MAX_SAFE_INTEGER2) {
return [];
}
var index2 = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH);
iteratee2 = getIteratee(iteratee2);
n -= MAX_ARRAY_LENGTH;
var result2 = baseTimes2(length, iteratee2);
while (++index2 < n) {
iteratee2(index2);
}
return result2;
}
function toPath(value) {
if (isArray2(value)) {
return arrayMap(value, toKey);
}
return isSymbol2(value) ? [value] : copyArray2(stringToPath(toString(value)));
}
function uniqueId(prefix) {
var id = ++idCounter;
return toString(prefix) + id;
}
var add2 = createMathOperation(function(augend, addend) {
return augend + addend;
}, 0);
var ceil = createRound("ceil");
var divide = createMathOperation(function(dividend, divisor) {
return dividend / divisor;
}, 1);
var floor = createRound("floor");
function max(array) {
return array && array.length ? baseExtremum(array, identity, baseGt) : undefined$1;
}
function maxBy(array, iteratee2) {
return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined$1;
}
function mean(array) {
return baseMean(array, identity);
}
function meanBy(array, iteratee2) {
return baseMean(array, getIteratee(iteratee2, 2));
}
function min(array) {
return array && array.length ? baseExtremum(array, identity, baseLt) : undefined$1;
}
function minBy(array, iteratee2) {
return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined$1;
}
var multiply = createMathOperation(function(multiplier, multiplicand) {
return multiplier * multiplicand;
}, 1);
var round = createRound("round");
var subtract = createMathOperation(function(minuend, subtrahend) {
return minuend - subtrahend;
}, 0);
function sum(array) {
return array && array.length ? baseSum(array, identity) : 0;
}
function sumBy(array, iteratee2) {
return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0;
}
lodash2.after = after;
lodash2.ary = ary;
lodash2.assign = assign2;
lodash2.assignIn = assignIn;
lodash2.assignInWith = assignInWith;
lodash2.assignWith = assignWith;
lodash2.at = at;
lodash2.before = before;
lodash2.bind = bind2;
lodash2.bindAll = bindAll;
lodash2.bindKey = bindKey;
lodash2.castArray = castArray;
lodash2.chain = chain;
lodash2.chunk = chunk;
lodash2.compact = compact;
lodash2.concat = concat;
lodash2.cond = cond;
lodash2.conforms = conforms;
lodash2.constant = constant;
lodash2.countBy = countBy;
lodash2.create = create;
lodash2.curry = curry;
lodash2.curryRight = curryRight;
lodash2.debounce = debounce;
lodash2.defaults = defaults;
lodash2.defaultsDeep = defaultsDeep;
lodash2.defer = defer;
lodash2.delay = delay;
lodash2.difference = difference;
lodash2.differenceBy = differenceBy;
lodash2.differenceWith = differenceWith;
lodash2.drop = drop;
lodash2.dropRight = dropRight;
lodash2.dropRightWhile = dropRightWhile;
lodash2.dropWhile = dropWhile;
lodash2.fill = fill;
lodash2.filter = filter;
lodash2.flatMap = flatMap;
lodash2.flatMapDeep = flatMapDeep;
lodash2.flatMapDepth = flatMapDepth;
lodash2.flatten = flatten;
lodash2.flattenDeep = flattenDeep;
lodash2.flattenDepth = flattenDepth;
lodash2.flip = flip;
lodash2.flow = flow;
lodash2.flowRight = flowRight;
lodash2.fromPairs = fromPairs;
lodash2.functions = functions;
lodash2.functionsIn = functionsIn;
lodash2.groupBy = groupBy;
lodash2.initial = initial;
lodash2.intersection = intersection;
lodash2.intersectionBy = intersectionBy;
lodash2.intersectionWith = intersectionWith;
lodash2.invert = invert;
lodash2.invertBy = invertBy;
lodash2.invokeMap = invokeMap;
lodash2.iteratee = iteratee;
lodash2.keyBy = keyBy;
lodash2.keys = keys2;
lodash2.keysIn = keysIn2;
lodash2.map = map;
lodash2.mapKeys = mapKeys;
lodash2.mapValues = mapValues;
lodash2.matches = matches;
lodash2.matchesProperty = matchesProperty;
lodash2.memoize = memoize;
lodash2.merge = merge2;
lodash2.mergeWith = mergeWith;
lodash2.method = method;
lodash2.methodOf = methodOf;
lodash2.mixin = mixin;
lodash2.negate = negate;
lodash2.nthArg = nthArg;
lodash2.omit = omit;
lodash2.omitBy = omitBy;
lodash2.once = once;
lodash2.orderBy = orderBy;
lodash2.over = over;
lodash2.overArgs = overArgs;
lodash2.overEvery = overEvery;
lodash2.overSome = overSome;
lodash2.partial = partial;
lodash2.partialRight = partialRight;
lodash2.partition = partition;
lodash2.pick = pick;
lodash2.pickBy = pickBy;
lodash2.property = property;
lodash2.propertyOf = propertyOf;
lodash2.pull = pull;
lodash2.pullAll = pullAll;
lodash2.pullAllBy = pullAllBy;
lodash2.pullAllWith = pullAllWith;
lodash2.pullAt = pullAt;
lodash2.range = range;
lodash2.rangeRight = rangeRight;
lodash2.rearg = rearg;
lodash2.reject = reject;
lodash2.remove = remove3;
lodash2.rest = rest;
lodash2.reverse = reverse;
lodash2.sampleSize = sampleSize;
lodash2.set = set2;
lodash2.setWith = setWith;
lodash2.shuffle = shuffle;
lodash2.slice = slice;
lodash2.sortBy = sortBy;
lodash2.sortedUniq = sortedUniq;
lodash2.sortedUniqBy = sortedUniqBy;
lodash2.split = split;
lodash2.spread = spread;
lodash2.tail = tail;
lodash2.take = take;
lodash2.takeRight = takeRight;
lodash2.takeRightWhile = takeRightWhile;
lodash2.takeWhile = takeWhile;
lodash2.tap = tap;
lodash2.throttle = throttle;
lodash2.thru = thru;
lodash2.toArray = toArray;
lodash2.toPairs = toPairs;
lodash2.toPairsIn = toPairsIn;
lodash2.toPath = toPath;
lodash2.toPlainObject = toPlainObject;
lodash2.transform = transform;
lodash2.unary = unary;
lodash2.union = union;
lodash2.unionBy = unionBy;
lodash2.unionWith = unionWith;
lodash2.uniq = uniq;
lodash2.uniqBy = uniqBy;
lodash2.uniqWith = uniqWith;
lodash2.unset = unset2;
lodash2.unzip = unzip;
lodash2.unzipWith = unzipWith;
lodash2.update = update;
lodash2.updateWith = updateWith;
lodash2.values = values;
lodash2.valuesIn = valuesIn;
lodash2.without = without;
lodash2.words = words;
lodash2.wrap = wrap;
lodash2.xor = xor;
lodash2.xorBy = xorBy;
lodash2.xorWith = xorWith;
lodash2.zip = zip;
lodash2.zipObject = zipObject;
lodash2.zipObjectDeep = zipObjectDeep;
lodash2.zipWith = zipWith;
lodash2.entries = toPairs;
lodash2.entriesIn = toPairsIn;
lodash2.extend = assignIn;
lodash2.extendWith = assignInWith;
mixin(lodash2, lodash2);
lodash2.add = add2;
lodash2.attempt = attempt;
lodash2.camelCase = camelCase;
lodash2.capitalize = capitalize2;
lodash2.ceil = ceil;
lodash2.clamp = clamp;
lodash2.clone = clone;
lodash2.cloneDeep = cloneDeep2;
lodash2.cloneDeepWith = cloneDeepWith;
lodash2.cloneWith = cloneWith;
lodash2.conformsTo = conformsTo;
lodash2.deburr = deburr;
lodash2.defaultTo = defaultTo;
lodash2.divide = divide;
lodash2.endsWith = endsWith;
lodash2.eq = eq2;
lodash2.escape = escape;
lodash2.escapeRegExp = escapeRegExp;
lodash2.every = every;
lodash2.find = find2;
lodash2.findIndex = findIndex;
lodash2.findKey = findKey;
lodash2.findLast = findLast;
lodash2.findLastIndex = findLastIndex;
lodash2.findLastKey = findLastKey;
lodash2.floor = floor;
lodash2.forEach = forEach;
lodash2.forEachRight = forEachRight;
lodash2.forIn = forIn;
lodash2.forInRight = forInRight;
lodash2.forOwn = forOwn;
lodash2.forOwnRight = forOwnRight;
lodash2.get = get2;
lodash2.gt = gt;
lodash2.gte = gte;
lodash2.has = has2;
lodash2.hasIn = hasIn;
lodash2.head = head;
lodash2.identity = identity;
lodash2.includes = includes;
lodash2.indexOf = indexOf;
lodash2.inRange = inRange;
lodash2.invoke = invoke;
lodash2.isArguments = isArguments2;
lodash2.isArray = isArray2;
lodash2.isArrayBuffer = isArrayBuffer;
lodash2.isArrayLike = isArrayLike2;
lodash2.isArrayLikeObject = isArrayLikeObject;
lodash2.isBoolean = isBoolean;
lodash2.isBuffer = isBuffer2;
lodash2.isDate = isDate;
lodash2.isElement = isElement2;
lodash2.isEmpty = isEmpty2;
lodash2.isEqual = isEqual;
lodash2.isEqualWith = isEqualWith;
lodash2.isError = isError;
lodash2.isFinite = isFinite;
lodash2.isFunction = isFunction2;
lodash2.isInteger = isInteger;
lodash2.isLength = isLength2;
lodash2.isMap = isMap2;
lodash2.isMatch = isMatch;
lodash2.isMatchWith = isMatchWith;
lodash2.isNaN = isNaN2;
lodash2.isNative = isNative;
lodash2.isNil = isNil;
lodash2.isNull = isNull;
lodash2.isNumber = isNumber2;
lodash2.isObject = isObject2;
lodash2.isObjectLike = isObjectLike2;
lodash2.isPlainObject = isPlainObject2;
lodash2.isRegExp = isRegExp;
lodash2.isSafeInteger = isSafeInteger;
lodash2.isSet = isSet2;
lodash2.isString = isString2;
lodash2.isSymbol = isSymbol2;
lodash2.isTypedArray = isTypedArray2;
lodash2.isUndefined = isUndefined;
lodash2.isWeakMap = isWeakMap;
lodash2.isWeakSet = isWeakSet;
lodash2.join = join;
lodash2.kebabCase = kebabCase;
lodash2.last = last;
lodash2.lastIndexOf = lastIndexOf;
lodash2.lowerCase = lowerCase;
lodash2.lowerFirst = lowerFirst;
lodash2.lt = lt;
lodash2.lte = lte;
lodash2.max = max;
lodash2.maxBy = maxBy;
lodash2.mean = mean;
lodash2.meanBy = meanBy;
lodash2.min = min;
lodash2.minBy = minBy;
lodash2.stubArray = stubArray2;
lodash2.stubFalse = stubFalse2;
lodash2.stubObject = stubObject;
lodash2.stubString = stubString;
lodash2.stubTrue = stubTrue;
lodash2.multiply = multiply;
lodash2.nth = nth;
lodash2.noConflict = noConflict;
lodash2.noop = noop2;
lodash2.now = now;
lodash2.pad = pad;
lodash2.padEnd = padEnd;
lodash2.padStart = padStart;
lodash2.parseInt = parseInt2;
lodash2.random = random;
lodash2.reduce = reduce2;
lodash2.reduceRight = reduceRight;
lodash2.repeat = repeat;
lodash2.replace = replace;
lodash2.result = result;
lodash2.round = round;
lodash2.runInContext = runInContext2;
lodash2.sample = sample;
lodash2.size = size2;
lodash2.snakeCase = snakeCase;
lodash2.some = some;
lodash2.sortedIndex = sortedIndex;
lodash2.sortedIndexBy = sortedIndexBy;
lodash2.sortedIndexOf = sortedIndexOf;
lodash2.sortedLastIndex = sortedLastIndex;
lodash2.sortedLastIndexBy = sortedLastIndexBy;
lodash2.sortedLastIndexOf = sortedLastIndexOf;
lodash2.startCase = startCase;
lodash2.startsWith = startsWith;
lodash2.subtract = subtract;
lodash2.sum = sum;
lodash2.sumBy = sumBy;
lodash2.template = template;
lodash2.times = times;
lodash2.toFinite = toFinite;
lodash2.toInteger = toInteger;
lodash2.toLength = toLength;
lodash2.toLower = toLower;
lodash2.toNumber = toNumber2;
lodash2.toSafeInteger = toSafeInteger;
lodash2.toString = toString;
lodash2.toUpper = toUpper;
lodash2.trim = trim;
lodash2.trimEnd = trimEnd;
lodash2.trimStart = trimStart;
lodash2.truncate = truncate;
lodash2.unescape = unescape;
lodash2.uniqueId = uniqueId;
lodash2.upperCase = upperCase;
lodash2.upperFirst = upperFirst;
lodash2.each = forEach;
lodash2.eachRight = forEachRight;
lodash2.first = head;
mixin(lodash2, function() {
var source = {};
baseForOwn(lodash2, function(func, methodName) {
if (!hasOwnProperty2.call(lodash2.prototype, methodName)) {
source[methodName] = func;
}
});
return source;
}(), { "chain": false });
lodash2.VERSION = VERSION;
arrayEach2(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
lodash2[methodName].placeholder = lodash2;
});
arrayEach2(["drop", "take"], function(methodName, index2) {
LazyWrapper.prototype[methodName] = function(n) {
n = n === undefined$1 ? 1 : nativeMax(toInteger(n), 0);
var result2 = this.__filtered__ && !index2 ? new LazyWrapper(this) : this.clone();
if (result2.__filtered__) {
result2.__takeCount__ = nativeMin(n, result2.__takeCount__);
} else {
result2.__views__.push({
"size": nativeMin(n, MAX_ARRAY_LENGTH),
"type": methodName + (result2.__dir__ < 0 ? "Right" : "")
});
}
return result2;
};
LazyWrapper.prototype[methodName + "Right"] = function(n) {
return this.reverse()[methodName](n).reverse();
};
});
arrayEach2(["filter", "map", "takeWhile"], function(methodName, index2) {
var type = index2 + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
LazyWrapper.prototype[methodName] = function(iteratee2) {
var result2 = this.clone();
result2.__iteratees__.push({
"iteratee": getIteratee(iteratee2, 3),
"type": type
});
result2.__filtered__ = result2.__filtered__ || isFilter;
return result2;
};
});
arrayEach2(["head", "last"], function(methodName, index2) {
var takeName = "take" + (index2 ? "Right" : "");
LazyWrapper.prototype[methodName] = function() {
return this[takeName](1).value()[0];
};
});
arrayEach2(["initial", "tail"], function(methodName, index2) {
var dropName = "drop" + (index2 ? "" : "Right");
LazyWrapper.prototype[methodName] = function() {
return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
};
});
LazyWrapper.prototype.compact = function() {
return this.filter(identity);
};
LazyWrapper.prototype.find = function(predicate) {
return this.filter(predicate).head();
};
LazyWrapper.prototype.findLast = function(predicate) {
return this.reverse().find(predicate);
};
LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
if (typeof path == "function") {
return new LazyWrapper(this);
}
return this.map(function(value) {
return baseInvoke(value, path, args);
});
});
LazyWrapper.prototype.reject = function(predicate) {
return this.filter(negate(getIteratee(predicate)));
};
LazyWrapper.prototype.slice = function(start, end) {
start = toInteger(start);
var result2 = this;
if (result2.__filtered__ && (start > 0 || end < 0)) {
return new LazyWrapper(result2);
}
if (start < 0) {
result2 = result2.takeRight(-start);
} else if (start) {
result2 = result2.drop(start);
}
if (end !== undefined$1) {
end = toInteger(end);
result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
}
return result2;
};
LazyWrapper.prototype.takeRightWhile = function(predicate) {
return this.reverse().takeWhile(predicate).reverse();
};
LazyWrapper.prototype.toArray = function() {
return this.take(MAX_ARRAY_LENGTH);
};
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash2[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
if (!lodashFunc) {
return;
}
lodash2.prototype[methodName] = function() {
var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray2(value);
var interceptor = function(value2) {
var result3 = lodashFunc.apply(lodash2, arrayPush2([value2], args));
return isTaker && chainAll ? result3[0] : result3;
};
if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
isLazy = useLazy = false;
}
var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
if (!retUnwrapped && useLazy) {
value = onlyLazy ? value : new LazyWrapper(this);
var result2 = func.apply(value, args);
result2.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": undefined$1 });
return new LodashWrapper(result2, chainAll);
}
if (isUnwrapped && onlyLazy) {
return func.apply(this, args);
}
result2 = this.thru(interceptor);
return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
};
});
arrayEach2(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
var func = arrayProto2[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
lodash2.prototype[methodName] = function() {
var args = arguments;
if (retUnwrapped && !this.__chain__) {
var value = this.value();
return func.apply(isArray2(value) ? value : [], args);
}
return this[chainName](function(value2) {
return func.apply(isArray2(value2) ? value2 : [], args);
});
};
});
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
var lodashFunc = lodash2[methodName];
if (lodashFunc) {
var key = lodashFunc.name + "";
if (!hasOwnProperty2.call(realNames, key)) {
realNames[key] = [];
}
realNames[key].push({ "name": methodName, "func": lodashFunc });
}
});
realNames[createHybrid(undefined$1, WRAP_BIND_KEY_FLAG).name] = [{
"name": "wrapper",
"func": undefined$1
}];
LazyWrapper.prototype.clone = lazyClone;
LazyWrapper.prototype.reverse = lazyReverse;
LazyWrapper.prototype.value = lazyValue;
lodash2.prototype.at = wrapperAt;
lodash2.prototype.chain = wrapperChain;
lodash2.prototype.commit = wrapperCommit;
lodash2.prototype.next = wrapperNext;
lodash2.prototype.plant = wrapperPlant;
lodash2.prototype.reverse = wrapperReverse;
lodash2.prototype.toJSON = lodash2.prototype.valueOf = lodash2.prototype.value = wrapperValue;
lodash2.prototype.first = lodash2.prototype.head;
if (symIterator) {
lodash2.prototype[symIterator] = wrapperToIterator;
}
return lodash2;
};
var _ = runInContext();
if (freeModule) {
(freeModule.exports = _)._ = _;
freeExports._ = _;
} else {
root7._ = _;
}
}).call(commonjsGlobal);
})(lodash, lodash.exports);
var lodashExports = lodash.exports;
const useReviewsStore = /* @__PURE__ */ defineStore("reviews", () => {
const loadingCount = ref(0);
const reviews = ref([]);
const detail = ref(null);
const reviewsLoaded = ref(false);
const allItems = ref([]);
const itemDetails = ref();
const loading = computed(() => loadingCount.value > 0);
const shouldShow = computed(() => {
const indexStore = useIndexStore();
if (detail.value == null) return false;
const action = detail.value.results.action;
if (action == "fail") {
return indexStore.settings.answers.showOnWrong ? true : false;
} else if (indexStore.settings.answers.showOnRight) {
if (indexStore.settings.answers.showOnRightSolo || // message.text.startsWith('Did you know this item has multiple possible')
correctAnswerCount.value > 1) {
return true;
}
}
return false;
});
const correctAnswerCount = computed(() => {
var _a;
const subject = (_a = detail.value) == null ? void 0 : _a.subjectWithStats.subject;
const subjectType = subject == null ? void 0 : subject.type;
if (subjectType == "Kanji") {
return (correctAnswer.value == void 0 ? 0 : correctAnswer.value[0].split(",").length) + (correctAnswer.value == void 0 ? 0 : correctAnswer.value[1].split(",").length);
} else {
return correctAnswer.value == void 0 ? 0 : correctAnswer.value.split(",").length;
}
});
const shouldShowBreakdown = computed(() => {
var _a;
const indexStore = useIndexStore();
return indexStore.settings.breakdown.showBreakdown && correctAnswer.value != "" && ((_a = detail.value) == null ? void 0 : _a.questionType) == "meaning";
});
const shouldShowTally = computed(() => {
const indexStore = useIndexStore();
return indexStore.settings.tally.showTally;
});
const shouldShowTallyLive = computed(() => {
const indexStore = useIndexStore();
return indexStore.settings.tally.showTally && indexStore.settings.tally.showTallyLive;
});
const correctAnswer = computed(() => {
var _a, _b;
if (detail.value == null) return "";
const questionType = detail.value.questionType;
const subject = detail.value.subjectWithStats.subject;
if (questionType == "meaning") {
return subject.meanings.join(", ");
} else {
const subjectType = subject.type;
if (subjectType == "Kanji") {
return [
//@ts-ignore
subject[subject.primary_reading_type].join(", "),
//@ts-ignore
(_a = lodashExports.difference(
[
...(subject["onyomi"] == void 0 ? [] : subject["onyomi"]).filter(
(o) => o != ""
),
...(subject["kunyomi"] == void 0 ? [] : subject["kunyomi"]).filter(
(o) => o != ""
),
...(subject["nanori"] == void 0 ? [] : subject["nanori"]).filter(
(o) => o != ""
)
],
//@ts-ignore
subject[subject.primary_reading_type]
)) == null ? void 0 : _a.join(", ")
];
} else {
return (_b = subject.readings) == null ? void 0 : _b.map((r) => r.reading).join(", ");
}
}
});
const getItemDetails = (item, type) => {
itemDetails.value = allItems.value.filter(
(i) => i.data.slug == item && i.object == type.toLowerCase()
);
};
const getComponents = (comp) => {
const dets = [];
debugger;
comp.forEach((id) => {
const thisOne = allItems.value.find((i) => parseInt(i.id) == id);
dets.push(thisOne);
});
return dets;
};
const reviewsCorrects = computed(() => {
const g = reviews.value.filter(
(r) => r.stats.meaning.complete && r.stats.reading.complete
);
return g.filter(
(r) => r.stats.meaning.incorrect == 0 && r.stats.reading.incorrect == 0
);
});
const reviewsIncorrects = computed(() => {
const g = reviews.value.filter(
(r) => r.stats.meaning.complete && r.stats.reading.complete
);
return g.filter(
(r) => r.stats.meaning.incorrect > 0 || r.stats.reading.incorrect > 0
);
});
const reviewPassed = computed(() => {
var _a, _b;
return ((_a = detail.value) == null ? void 0 : _a.results.passed) || ((_b = detail.value) == null ? void 0 : _b.results.action) == "pass";
});
return {
loading,
detail,
reviews,
shouldShow,
correctAnswer,
reviewsLoaded,
allItems,
getItemDetails,
itemDetails,
getComponents,
shouldShowBreakdown,
reviewsIncorrects,
reviewsCorrects,
shouldShowTally,
shouldShowTallyLive,
reviewPassed
};
});
function _typeof$1$1(o) {
"@babel/helpers - typeof";
return _typeof$1$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$1$1(o);
}
function _classCallCheck$1(a, n) {
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties$1(e, r) {
for (var t = 0; t < r.length; t++) {
var o = r[t];
o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey$1$1(o.key), o);
}
}
function _createClass$1(e, r, t) {
return r && _defineProperties$1(e.prototype, r), Object.defineProperty(e, "prototype", { writable: false }), e;
}
function _toPropertyKey$1$1(t) {
var i = _toPrimitive$1$1(t, "string");
return "symbol" == _typeof$1$1(i) ? i : i + "";
}
function _toPrimitive$1$1(t, r) {
if ("object" != _typeof$1$1(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r);
if ("object" != _typeof$1$1(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return String(t);
}
var ConnectedOverlayScrollHandler = /* @__PURE__ */ function() {
function ConnectedOverlayScrollHandler2(element) {
var listener = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
};
_classCallCheck$1(this, ConnectedOverlayScrollHandler2);
this.element = element;
this.listener = listener;
}
return _createClass$1(ConnectedOverlayScrollHandler2, [{
key: "bindScrollListener",
value: function bindScrollListener2() {
this.scrollableParents = getScrollableParents(this.element);
for (var i = 0; i < this.scrollableParents.length; i++) {
this.scrollableParents[i].addEventListener("scroll", this.listener);
}
}
}, {
key: "unbindScrollListener",
value: function unbindScrollListener2() {
if (this.scrollableParents) {
for (var i = 0; i < this.scrollableParents.length; i++) {
this.scrollableParents[i].removeEventListener("scroll", this.listener);
}
}
}
}, {
key: "destroy",
value: function destroy() {
this.unbindScrollListener();
this.element = null;
this.listener = null;
this.scrollableParents = null;
}
}]);
}();
var Base = {
_loadedStyleNames: /* @__PURE__ */ new Set(),
getLoadedStyleNames: function getLoadedStyleNames() {
return this._loadedStyleNames;
},
isStyleNameLoaded: function isStyleNameLoaded(name) {
return this._loadedStyleNames.has(name);
},
setLoadedStyleName: function setLoadedStyleName(name) {
this._loadedStyleNames.add(name);
},
deleteLoadedStyleName: function deleteLoadedStyleName(name) {
this._loadedStyleNames["delete"](name);
},
clearLoadedStyleNames: function clearLoadedStyleNames() {
this._loadedStyleNames.clear();
}
};
function _typeof$6(o) {
"@babel/helpers - typeof";
return _typeof$6 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$6(o);
}
function _slicedToArray$1(r, e) {
return _arrayWithHoles$1(r) || _iterableToArrayLimit$1(r, e) || _unsupportedIterableToArray$2(r, e) || _nonIterableRest$1();
}
function _nonIterableRest$1() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray$2(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray$2(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : void 0;
}
}
function _arrayLikeToArray$2(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _iterableToArrayLimit$1(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e, n, i, u, a = [], f = true, o = false;
try {
if (i = (t = t.call(r)).next, 0 === l) ;
else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
} catch (r2) {
o = true, n = r2;
} finally {
try {
if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _arrayWithHoles$1(r) {
if (Array.isArray(r)) return r;
}
function ownKeys$4(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$4(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$4(Object(t), true).forEach(function(r2) {
_defineProperty$7(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$4(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$7(e, r, t) {
return (r = _toPropertyKey$6(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$6(t) {
var i = _toPrimitive$6(t, "string");
return "symbol" == _typeof$6(i) ? i : i + "";
}
function _toPrimitive$6(t, r) {
if ("object" != _typeof$6(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$6(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var BaseDirective = {
_getMeta: function _getMeta() {
return [isObject$6(arguments.length <= 0 ? void 0 : arguments[0]) ? void 0 : arguments.length <= 0 ? void 0 : arguments[0], resolve(isObject$6(arguments.length <= 0 ? void 0 : arguments[0]) ? arguments.length <= 0 ? void 0 : arguments[0] : arguments.length <= 1 ? void 0 : arguments[1])];
},
_getConfig: function _getConfig(binding, vnode) {
var _ref, _binding$instance, _vnode$ctx;
return (_ref = (binding === null || binding === void 0 || (_binding$instance = binding.instance) === null || _binding$instance === void 0 ? void 0 : _binding$instance.$primevue) || (vnode === null || vnode === void 0 || (_vnode$ctx = vnode.ctx) === null || _vnode$ctx === void 0 || (_vnode$ctx = _vnode$ctx.appContext) === null || _vnode$ctx === void 0 || (_vnode$ctx = _vnode$ctx.config) === null || _vnode$ctx === void 0 || (_vnode$ctx = _vnode$ctx.globalProperties) === null || _vnode$ctx === void 0 ? void 0 : _vnode$ctx.$primevue)) === null || _ref === void 0 ? void 0 : _ref.config;
},
_getOptionValue: getKeyValue,
_getPTValue: function _getPTValue() {
var _instance$binding, _instance$$primevueCo;
var instance = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var obj = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var key = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "";
var params = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
var searchInDefaultPT = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : true;
var getValue2 = function getValue3() {
var value = BaseDirective._getOptionValue.apply(BaseDirective, arguments);
return isString(value) || isArray$5(value) ? {
"class": value
} : value;
};
var _ref2 = ((_instance$binding = instance.binding) === null || _instance$binding === void 0 || (_instance$binding = _instance$binding.value) === null || _instance$binding === void 0 ? void 0 : _instance$binding.ptOptions) || ((_instance$$primevueCo = instance.$primevueConfig) === null || _instance$$primevueCo === void 0 ? void 0 : _instance$$primevueCo.ptOptions) || {}, _ref2$mergeSections = _ref2.mergeSections, mergeSections = _ref2$mergeSections === void 0 ? true : _ref2$mergeSections, _ref2$mergeProps = _ref2.mergeProps, useMergeProps = _ref2$mergeProps === void 0 ? false : _ref2$mergeProps;
var global2 = searchInDefaultPT ? BaseDirective._useDefaultPT(instance, instance.defaultPT(), getValue2, key, params) : void 0;
var self2 = BaseDirective._usePT(instance, BaseDirective._getPT(obj, instance.$name), getValue2, key, _objectSpread$4(_objectSpread$4({}, params), {}, {
global: global2 || {}
}));
var datasets = BaseDirective._getPTDatasets(instance, key);
return mergeSections || !mergeSections && self2 ? useMergeProps ? BaseDirective._mergeProps(instance, useMergeProps, global2, self2, datasets) : _objectSpread$4(_objectSpread$4(_objectSpread$4({}, global2), self2), datasets) : _objectSpread$4(_objectSpread$4({}, self2), datasets);
},
_getPTDatasets: function _getPTDatasets() {
var instance = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
var datasetPrefix = "data-pc-";
return _objectSpread$4(_objectSpread$4({}, key === "root" && _defineProperty$7({}, "".concat(datasetPrefix, "name"), toFlatCase(instance.$name))), {}, _defineProperty$7({}, "".concat(datasetPrefix, "section"), toFlatCase(key)));
},
_getPT: function _getPT(pt) {
var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
var callback = arguments.length > 2 ? arguments[2] : void 0;
var getValue2 = function getValue3(value) {
var _computedValue$_key;
var computedValue = callback ? callback(value) : value;
var _key = toFlatCase(key);
return (_computedValue$_key = computedValue === null || computedValue === void 0 ? void 0 : computedValue[_key]) !== null && _computedValue$_key !== void 0 ? _computedValue$_key : computedValue;
};
return pt !== null && pt !== void 0 && pt.hasOwnProperty("_usept") ? {
_usept: pt["_usept"],
originalValue: getValue2(pt.originalValue),
value: getValue2(pt.value)
} : getValue2(pt);
},
_usePT: function _usePT() {
var instance = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var pt = arguments.length > 1 ? arguments[1] : void 0;
var callback = arguments.length > 2 ? arguments[2] : void 0;
var key = arguments.length > 3 ? arguments[3] : void 0;
var params = arguments.length > 4 ? arguments[4] : void 0;
var fn = function fn2(value2) {
return callback(value2, key, params);
};
if (pt !== null && pt !== void 0 && pt.hasOwnProperty("_usept")) {
var _instance$$primevueCo2;
var _ref4 = pt["_usept"] || ((_instance$$primevueCo2 = instance.$primevueConfig) === null || _instance$$primevueCo2 === void 0 ? void 0 : _instance$$primevueCo2.ptOptions) || {}, _ref4$mergeSections = _ref4.mergeSections, mergeSections = _ref4$mergeSections === void 0 ? true : _ref4$mergeSections, _ref4$mergeProps = _ref4.mergeProps, useMergeProps = _ref4$mergeProps === void 0 ? false : _ref4$mergeProps;
var originalValue = fn(pt.originalValue);
var value = fn(pt.value);
if (originalValue === void 0 && value === void 0) return void 0;
else if (isString(value)) return value;
else if (isString(originalValue)) return originalValue;
return mergeSections || !mergeSections && value ? useMergeProps ? BaseDirective._mergeProps(instance, useMergeProps, originalValue, value) : _objectSpread$4(_objectSpread$4({}, originalValue), value) : value;
}
return fn(pt);
},
_useDefaultPT: function _useDefaultPT() {
var instance = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var defaultPT2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var callback = arguments.length > 2 ? arguments[2] : void 0;
var key = arguments.length > 3 ? arguments[3] : void 0;
var params = arguments.length > 4 ? arguments[4] : void 0;
return BaseDirective._usePT(instance, defaultPT2, callback, key, params);
},
_loadStyles: function _loadStyles(el, binding, vnode) {
var _config$csp;
var config = BaseDirective._getConfig(binding, vnode);
var useStyleOptions = {
nonce: config === null || config === void 0 || (_config$csp = config.csp) === null || _config$csp === void 0 ? void 0 : _config$csp.nonce
};
BaseDirective._loadCoreStyles(el.$instance, useStyleOptions);
BaseDirective._loadThemeStyles(el.$instance, useStyleOptions);
BaseDirective._loadScopedThemeStyles(el.$instance, useStyleOptions);
BaseDirective._themeChangeListener(function() {
return BaseDirective._loadThemeStyles(el.$instance, useStyleOptions);
});
},
_loadCoreStyles: function _loadCoreStyles() {
var _instance$$style, _instance$$style2;
var instance = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var useStyleOptions = arguments.length > 1 ? arguments[1] : void 0;
if (!Base.isStyleNameLoaded((_instance$$style = instance.$style) === null || _instance$$style === void 0 ? void 0 : _instance$$style.name) && (_instance$$style2 = instance.$style) !== null && _instance$$style2 !== void 0 && _instance$$style2.name) {
var _instance$$style3;
BaseStyle.loadCSS(useStyleOptions);
(_instance$$style3 = instance.$style) === null || _instance$$style3 === void 0 || _instance$$style3.loadCSS(useStyleOptions);
Base.setLoadedStyleName(instance.$style.name);
}
},
_loadThemeStyles: function _loadThemeStyles() {
var _instance$theme, _instance$$style5, _instance$$style6;
var instance = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var useStyleOptions = arguments.length > 1 ? arguments[1] : void 0;
if (instance !== null && instance !== void 0 && instance.isUnstyled() || (instance === null || instance === void 0 || (_instance$theme = instance.theme) === null || _instance$theme === void 0 ? void 0 : _instance$theme.call(instance)) === "none") return;
if (!config_default.isStyleNameLoaded("common")) {
var _instance$$style4, _instance$$style4$get;
var _ref5 = ((_instance$$style4 = instance.$style) === null || _instance$$style4 === void 0 || (_instance$$style4$get = _instance$$style4.getCommonTheme) === null || _instance$$style4$get === void 0 ? void 0 : _instance$$style4$get.call(_instance$$style4)) || {}, primitive = _ref5.primitive, semantic = _ref5.semantic, global2 = _ref5.global, style = _ref5.style;
BaseStyle.load(primitive === null || primitive === void 0 ? void 0 : primitive.css, _objectSpread$4({
name: "primitive-variables"
}, useStyleOptions));
BaseStyle.load(semantic === null || semantic === void 0 ? void 0 : semantic.css, _objectSpread$4({
name: "semantic-variables"
}, useStyleOptions));
BaseStyle.load(global2 === null || global2 === void 0 ? void 0 : global2.css, _objectSpread$4({
name: "global-variables"
}, useStyleOptions));
BaseStyle.loadTheme(_objectSpread$4({
name: "global-style"
}, useStyleOptions), style);
config_default.setLoadedStyleName("common");
}
if (!config_default.isStyleNameLoaded((_instance$$style5 = instance.$style) === null || _instance$$style5 === void 0 ? void 0 : _instance$$style5.name) && (_instance$$style6 = instance.$style) !== null && _instance$$style6 !== void 0 && _instance$$style6.name) {
var _instance$$style7, _instance$$style7$get, _instance$$style8, _instance$$style9;
var _ref6 = ((_instance$$style7 = instance.$style) === null || _instance$$style7 === void 0 || (_instance$$style7$get = _instance$$style7.getDirectiveTheme) === null || _instance$$style7$get === void 0 ? void 0 : _instance$$style7$get.call(_instance$$style7)) || {}, css3 = _ref6.css, _style = _ref6.style;
(_instance$$style8 = instance.$style) === null || _instance$$style8 === void 0 || _instance$$style8.load(css3, _objectSpread$4({
name: "".concat(instance.$style.name, "-variables")
}, useStyleOptions));
(_instance$$style9 = instance.$style) === null || _instance$$style9 === void 0 || _instance$$style9.loadTheme(_objectSpread$4({
name: "".concat(instance.$style.name, "-style")
}, useStyleOptions), _style);
config_default.setLoadedStyleName(instance.$style.name);
}
if (!config_default.isStyleNameLoaded("layer-order")) {
var _instance$$style10, _instance$$style10$ge;
var layerOrder = (_instance$$style10 = instance.$style) === null || _instance$$style10 === void 0 || (_instance$$style10$ge = _instance$$style10.getLayerOrderThemeCSS) === null || _instance$$style10$ge === void 0 ? void 0 : _instance$$style10$ge.call(_instance$$style10);
BaseStyle.load(layerOrder, _objectSpread$4({
name: "layer-order",
first: true
}, useStyleOptions));
config_default.setLoadedStyleName("layer-order");
}
},
_loadScopedThemeStyles: function _loadScopedThemeStyles() {
var instance = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var useStyleOptions = arguments.length > 1 ? arguments[1] : void 0;
var preset = instance.preset();
if (preset && instance.$attrSelector) {
var _instance$$style11, _instance$$style11$ge, _instance$$style12;
var _ref7 = ((_instance$$style11 = instance.$style) === null || _instance$$style11 === void 0 || (_instance$$style11$ge = _instance$$style11.getPresetTheme) === null || _instance$$style11$ge === void 0 ? void 0 : _instance$$style11$ge.call(_instance$$style11, preset, "[".concat(instance.$attrSelector, "]"))) || {}, css3 = _ref7.css;
var scopedStyle = (_instance$$style12 = instance.$style) === null || _instance$$style12 === void 0 ? void 0 : _instance$$style12.load(css3, _objectSpread$4({
name: "".concat(instance.$attrSelector, "-").concat(instance.$style.name)
}, useStyleOptions));
instance.scopedStyleEl = scopedStyle.el;
}
},
_themeChangeListener: function _themeChangeListener() {
var callback = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {
};
Base.clearLoadedStyleNames();
service_default.on("theme:change", callback);
},
_hook: function _hook(directiveName, hookName, el, binding, vnode, prevVnode) {
var _binding$value, _config$pt;
var name = "on".concat(toCapitalCase(hookName));
var config = BaseDirective._getConfig(binding, vnode);
var instance = el === null || el === void 0 ? void 0 : el.$instance;
var selfHook = BaseDirective._usePT(instance, BaseDirective._getPT(binding === null || binding === void 0 || (_binding$value = binding.value) === null || _binding$value === void 0 ? void 0 : _binding$value.pt, directiveName), BaseDirective._getOptionValue, "hooks.".concat(name));
var defaultHook = BaseDirective._useDefaultPT(instance, config === null || config === void 0 || (_config$pt = config.pt) === null || _config$pt === void 0 || (_config$pt = _config$pt.directives) === null || _config$pt === void 0 ? void 0 : _config$pt[directiveName], BaseDirective._getOptionValue, "hooks.".concat(name));
var options = {
el,
binding,
vnode,
prevVnode
};
selfHook === null || selfHook === void 0 || selfHook(instance, options);
defaultHook === null || defaultHook === void 0 || defaultHook(instance, options);
},
_mergeProps: function _mergeProps() {
var fn = arguments.length > 1 ? arguments[1] : void 0;
for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key2 = 2; _key2 < _len; _key2++) {
args[_key2 - 2] = arguments[_key2];
}
return isFunction$3(fn) ? fn.apply(void 0, args) : mergeProps.apply(void 0, args);
},
_extend: function _extend(name) {
var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var handleHook = function handleHook2(hook, el, binding, vnode, prevVnode) {
var _el$$pd, _el$$instance$hook, _el$$instance9, _el$$pd2;
el._$instances = el._$instances || {};
var config = BaseDirective._getConfig(binding, vnode);
var $prevInstance = el._$instances[name] || {};
var $options = isEmpty($prevInstance) ? _objectSpread$4(_objectSpread$4({}, options), options === null || options === void 0 ? void 0 : options.methods) : {};
el._$instances[name] = _objectSpread$4(_objectSpread$4({}, $prevInstance), {}, {
/* new instance variables to pass in directive methods */
$name: name,
$host: el,
$binding: binding,
$modifiers: binding === null || binding === void 0 ? void 0 : binding.modifiers,
$value: binding === null || binding === void 0 ? void 0 : binding.value,
$el: $prevInstance["$el"] || el || void 0,
$style: _objectSpread$4({
classes: void 0,
inlineStyles: void 0,
load: function load2() {
},
loadCSS: function loadCSS2() {
},
loadTheme: function loadTheme2() {
}
}, options === null || options === void 0 ? void 0 : options.style),
$primevueConfig: config,
$attrSelector: (_el$$pd = el.$pd) === null || _el$$pd === void 0 || (_el$$pd = _el$$pd[name]) === null || _el$$pd === void 0 ? void 0 : _el$$pd.attrSelector,
/* computed instance variables */
defaultPT: function defaultPT2() {
return BaseDirective._getPT(config === null || config === void 0 ? void 0 : config.pt, void 0, function(value) {
var _value$directives;
return value === null || value === void 0 || (_value$directives = value.directives) === null || _value$directives === void 0 ? void 0 : _value$directives[name];
});
},
isUnstyled: function isUnstyled2() {
var _el$$instance, _el$$instance2;
return ((_el$$instance = el.$instance) === null || _el$$instance === void 0 || (_el$$instance = _el$$instance.$binding) === null || _el$$instance === void 0 || (_el$$instance = _el$$instance.value) === null || _el$$instance === void 0 ? void 0 : _el$$instance.unstyled) !== void 0 ? (_el$$instance2 = el.$instance) === null || _el$$instance2 === void 0 || (_el$$instance2 = _el$$instance2.$binding) === null || _el$$instance2 === void 0 || (_el$$instance2 = _el$$instance2.value) === null || _el$$instance2 === void 0 ? void 0 : _el$$instance2.unstyled : config === null || config === void 0 ? void 0 : config.unstyled;
},
theme: function theme9() {
var _el$$instance3;
return (_el$$instance3 = el.$instance) === null || _el$$instance3 === void 0 || (_el$$instance3 = _el$$instance3.$primevueConfig) === null || _el$$instance3 === void 0 ? void 0 : _el$$instance3.theme;
},
preset: function preset() {
var _el$$instance4;
return (_el$$instance4 = el.$instance) === null || _el$$instance4 === void 0 || (_el$$instance4 = _el$$instance4.$binding) === null || _el$$instance4 === void 0 || (_el$$instance4 = _el$$instance4.value) === null || _el$$instance4 === void 0 ? void 0 : _el$$instance4.dt;
},
/* instance's methods */
ptm: function ptm2() {
var _el$$instance5;
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
return BaseDirective._getPTValue(el.$instance, (_el$$instance5 = el.$instance) === null || _el$$instance5 === void 0 || (_el$$instance5 = _el$$instance5.$binding) === null || _el$$instance5 === void 0 || (_el$$instance5 = _el$$instance5.value) === null || _el$$instance5 === void 0 ? void 0 : _el$$instance5.pt, key, _objectSpread$4({}, params));
},
ptmo: function ptmo2() {
var obj = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
return BaseDirective._getPTValue(el.$instance, obj, key, params, false);
},
cx: function cx2() {
var _el$$instance6, _el$$instance7;
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
return !((_el$$instance6 = el.$instance) !== null && _el$$instance6 !== void 0 && _el$$instance6.isUnstyled()) ? BaseDirective._getOptionValue((_el$$instance7 = el.$instance) === null || _el$$instance7 === void 0 || (_el$$instance7 = _el$$instance7.$style) === null || _el$$instance7 === void 0 ? void 0 : _el$$instance7.classes, key, _objectSpread$4({}, params)) : void 0;
},
sx: function sx2() {
var _el$$instance8;
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var when = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
return when ? BaseDirective._getOptionValue((_el$$instance8 = el.$instance) === null || _el$$instance8 === void 0 || (_el$$instance8 = _el$$instance8.$style) === null || _el$$instance8 === void 0 ? void 0 : _el$$instance8.inlineStyles, key, _objectSpread$4({}, params)) : void 0;
}
}, $options);
el.$instance = el._$instances[name];
(_el$$instance$hook = (_el$$instance9 = el.$instance)[hook]) === null || _el$$instance$hook === void 0 || _el$$instance$hook.call(_el$$instance9, el, binding, vnode, prevVnode);
el["$".concat(name)] = el.$instance;
BaseDirective._hook(name, hook, el, binding, vnode, prevVnode);
el.$pd || (el.$pd = {});
el.$pd[name] = _objectSpread$4(_objectSpread$4({}, (_el$$pd2 = el.$pd) === null || _el$$pd2 === void 0 ? void 0 : _el$$pd2[name]), {}, {
name,
instance: el.$instance
});
};
var handleWatch = function handleWatch2(el) {
var _el$$instance10, _watchers$config, _el$$instance11, _watchers$configRipp, _el$$instance12;
var watchers = (_el$$instance10 = el.$instance) === null || _el$$instance10 === void 0 ? void 0 : _el$$instance10.watch;
watchers === null || watchers === void 0 || (_watchers$config = watchers["config"]) === null || _watchers$config === void 0 || _watchers$config.call(el.$instance, (_el$$instance11 = el.$instance) === null || _el$$instance11 === void 0 ? void 0 : _el$$instance11.$primevueConfig);
PrimeVueService.on("config:change", function(_ref8) {
var _watchers$config2;
var newValue = _ref8.newValue, oldValue = _ref8.oldValue;
return watchers === null || watchers === void 0 || (_watchers$config2 = watchers["config"]) === null || _watchers$config2 === void 0 ? void 0 : _watchers$config2.call(el.$instance, newValue, oldValue);
});
watchers === null || watchers === void 0 || (_watchers$configRipp = watchers["config.ripple"]) === null || _watchers$configRipp === void 0 || _watchers$configRipp.call(el.$instance, (_el$$instance12 = el.$instance) === null || _el$$instance12 === void 0 || (_el$$instance12 = _el$$instance12.$primevueConfig) === null || _el$$instance12 === void 0 ? void 0 : _el$$instance12.ripple);
PrimeVueService.on("config:ripple:change", function(_ref9) {
var _watchers$configRipp2;
var newValue = _ref9.newValue, oldValue = _ref9.oldValue;
return watchers === null || watchers === void 0 || (_watchers$configRipp2 = watchers["config.ripple"]) === null || _watchers$configRipp2 === void 0 ? void 0 : _watchers$configRipp2.call(el.$instance, newValue, oldValue);
});
};
return {
created: function created2(el, binding, vnode, prevVnode) {
el.$pd || (el.$pd = {});
el.$pd[name] = {
name,
attrSelector: uuid("pd")
};
handleHook("created", el, binding, vnode, prevVnode);
},
beforeMount: function beforeMount2(el, binding, vnode, prevVnode) {
BaseDirective._loadStyles(el, binding, vnode);
handleHook("beforeMount", el, binding, vnode, prevVnode);
handleWatch(el);
},
mounted: function mounted6(el, binding, vnode, prevVnode) {
BaseDirective._loadStyles(el, binding, vnode);
handleHook("mounted", el, binding, vnode, prevVnode);
},
beforeUpdate: function beforeUpdate2(el, binding, vnode, prevVnode) {
handleHook("beforeUpdate", el, binding, vnode, prevVnode);
},
updated: function updated3(el, binding, vnode, prevVnode) {
BaseDirective._loadStyles(el, binding, vnode);
handleHook("updated", el, binding, vnode, prevVnode);
},
beforeUnmount: function beforeUnmount3(el, binding, vnode, prevVnode) {
handleHook("beforeUnmount", el, binding, vnode, prevVnode);
},
unmounted: function unmounted4(el, binding, vnode, prevVnode) {
var _el$$instance13;
(_el$$instance13 = el.$instance) === null || _el$$instance13 === void 0 || (_el$$instance13 = _el$$instance13.scopedStyleEl) === null || _el$$instance13 === void 0 || (_el$$instance13 = _el$$instance13.value) === null || _el$$instance13 === void 0 || _el$$instance13.remove();
handleHook("unmounted", el, binding, vnode, prevVnode);
}
};
},
extend: function extend3() {
var _BaseDirective$_getMe = BaseDirective._getMeta.apply(BaseDirective, arguments), _BaseDirective$_getMe2 = _slicedToArray$1(_BaseDirective$_getMe, 2), name = _BaseDirective$_getMe2[0], options = _BaseDirective$_getMe2[1];
return _objectSpread$4({
extend: function extend4() {
var _BaseDirective$_getMe3 = BaseDirective._getMeta.apply(BaseDirective, arguments), _BaseDirective$_getMe4 = _slicedToArray$1(_BaseDirective$_getMe3, 2), _name = _BaseDirective$_getMe4[0], _options = _BaseDirective$_getMe4[1];
return BaseDirective.extend(_name, _objectSpread$4(_objectSpread$4(_objectSpread$4({}, options), options === null || options === void 0 ? void 0 : options.methods), _options));
}
}, BaseDirective._extend(name, options));
}
};
var FocusTrapStyle = BaseStyle.extend({
name: "focustrap-directive"
});
var BaseFocusTrap = BaseDirective.extend({
style: FocusTrapStyle
});
function _typeof$5(o) {
"@babel/helpers - typeof";
return _typeof$5 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$5(o);
}
function ownKeys$3(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$3(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$3(Object(t), true).forEach(function(r2) {
_defineProperty$6(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$3(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$6(e, r, t) {
return (r = _toPropertyKey$5(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$5(t) {
var i = _toPrimitive$5(t, "string");
return "symbol" == _typeof$5(i) ? i : i + "";
}
function _toPrimitive$5(t, r) {
if ("object" != _typeof$5(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$5(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var FocusTrap = BaseFocusTrap.extend("focustrap", {
mounted: function mounted(el, binding) {
var _ref = binding.value || {}, disabled2 = _ref.disabled;
if (!disabled2) {
this.createHiddenFocusableElements(el, binding);
this.bind(el, binding);
this.autoElementFocus(el, binding);
}
el.setAttribute("data-pd-focustrap", true);
this.$el = el;
},
updated: function updated(el, binding) {
var _ref2 = binding.value || {}, disabled2 = _ref2.disabled;
disabled2 && this.unbind(el);
},
unmounted: function unmounted(el) {
this.unbind(el);
},
methods: {
getComputedSelector: function getComputedSelector(selector) {
return ':not(.p-hidden-focusable):not([data-p-hidden-focusable="true"])'.concat(selector !== null && selector !== void 0 ? selector : "");
},
bind: function bind(el, binding) {
var _this = this;
var _ref3 = binding.value || {}, onFocusIn = _ref3.onFocusIn, onFocusOut = _ref3.onFocusOut;
el.$_pfocustrap_mutationobserver = new MutationObserver(function(mutationList) {
mutationList.forEach(function(mutation) {
if (mutation.type === "childList" && !el.contains(document.activeElement)) {
var _findNextFocusableElement = function findNextFocusableElement(_el) {
var focusableElement = isFocusableElement(_el) ? isFocusableElement(_el, _this.getComputedSelector(el.$_pfocustrap_focusableselector)) ? _el : getFirstFocusableElement(el, _this.getComputedSelector(el.$_pfocustrap_focusableselector)) : getFirstFocusableElement(_el);
return isNotEmpty(focusableElement) ? focusableElement : _el.nextSibling && _findNextFocusableElement(_el.nextSibling);
};
focus(_findNextFocusableElement(mutation.nextSibling));
}
});
});
el.$_pfocustrap_mutationobserver.disconnect();
el.$_pfocustrap_mutationobserver.observe(el, {
childList: true
});
el.$_pfocustrap_focusinlistener = function(event) {
return onFocusIn && onFocusIn(event);
};
el.$_pfocustrap_focusoutlistener = function(event) {
return onFocusOut && onFocusOut(event);
};
el.addEventListener("focusin", el.$_pfocustrap_focusinlistener);
el.addEventListener("focusout", el.$_pfocustrap_focusoutlistener);
},
unbind: function unbind(el) {
el.$_pfocustrap_mutationobserver && el.$_pfocustrap_mutationobserver.disconnect();
el.$_pfocustrap_focusinlistener && el.removeEventListener("focusin", el.$_pfocustrap_focusinlistener) && (el.$_pfocustrap_focusinlistener = null);
el.$_pfocustrap_focusoutlistener && el.removeEventListener("focusout", el.$_pfocustrap_focusoutlistener) && (el.$_pfocustrap_focusoutlistener = null);
},
autoFocus: function autoFocus(options) {
this.autoElementFocus(this.$el, {
value: _objectSpread$3(_objectSpread$3({}, options), {}, {
autoFocus: true
})
});
},
autoElementFocus: function autoElementFocus(el, binding) {
var _ref4 = binding.value || {}, _ref4$autoFocusSelect = _ref4.autoFocusSelector, autoFocusSelector = _ref4$autoFocusSelect === void 0 ? "" : _ref4$autoFocusSelect, _ref4$firstFocusableS = _ref4.firstFocusableSelector, firstFocusableSelector = _ref4$firstFocusableS === void 0 ? "" : _ref4$firstFocusableS, _ref4$autoFocus = _ref4.autoFocus, autoFocus2 = _ref4$autoFocus === void 0 ? false : _ref4$autoFocus;
var focusableElement = getFirstFocusableElement(el, "[autofocus]".concat(this.getComputedSelector(autoFocusSelector)));
autoFocus2 && !focusableElement && (focusableElement = getFirstFocusableElement(el, this.getComputedSelector(firstFocusableSelector)));
focus(focusableElement);
},
onFirstHiddenElementFocus: function onFirstHiddenElementFocus(event) {
var _this$$el;
var currentTarget = event.currentTarget, relatedTarget = event.relatedTarget;
var focusableElement = relatedTarget === currentTarget.$_pfocustrap_lasthiddenfocusableelement || !((_this$$el = this.$el) !== null && _this$$el !== void 0 && _this$$el.contains(relatedTarget)) ? getFirstFocusableElement(currentTarget.parentElement, this.getComputedSelector(currentTarget.$_pfocustrap_focusableselector)) : currentTarget.$_pfocustrap_lasthiddenfocusableelement;
focus(focusableElement);
},
onLastHiddenElementFocus: function onLastHiddenElementFocus(event) {
var _this$$el2;
var currentTarget = event.currentTarget, relatedTarget = event.relatedTarget;
var focusableElement = relatedTarget === currentTarget.$_pfocustrap_firsthiddenfocusableelement || !((_this$$el2 = this.$el) !== null && _this$$el2 !== void 0 && _this$$el2.contains(relatedTarget)) ? getLastFocusableElement(currentTarget.parentElement, this.getComputedSelector(currentTarget.$_pfocustrap_focusableselector)) : currentTarget.$_pfocustrap_firsthiddenfocusableelement;
focus(focusableElement);
},
createHiddenFocusableElements: function createHiddenFocusableElements(el, binding) {
var _this2 = this;
var _ref5 = binding.value || {}, _ref5$tabIndex = _ref5.tabIndex, tabIndex = _ref5$tabIndex === void 0 ? 0 : _ref5$tabIndex, _ref5$firstFocusableS = _ref5.firstFocusableSelector, firstFocusableSelector = _ref5$firstFocusableS === void 0 ? "" : _ref5$firstFocusableS, _ref5$lastFocusableSe = _ref5.lastFocusableSelector, lastFocusableSelector = _ref5$lastFocusableSe === void 0 ? "" : _ref5$lastFocusableSe;
var createFocusableElement = function createFocusableElement2(onFocus) {
return createElement("span", {
"class": "p-hidden-accessible p-hidden-focusable",
tabIndex,
role: "presentation",
"aria-hidden": true,
"data-p-hidden-accessible": true,
"data-p-hidden-focusable": true,
onFocus: onFocus === null || onFocus === void 0 ? void 0 : onFocus.bind(_this2)
});
};
var firstFocusableElement = createFocusableElement(this.onFirstHiddenElementFocus);
var lastFocusableElement = createFocusableElement(this.onLastHiddenElementFocus);
firstFocusableElement.$_pfocustrap_lasthiddenfocusableelement = lastFocusableElement;
firstFocusableElement.$_pfocustrap_focusableselector = firstFocusableSelector;
firstFocusableElement.setAttribute("data-pc-section", "firstfocusableelement");
lastFocusableElement.$_pfocustrap_firsthiddenfocusableelement = firstFocusableElement;
lastFocusableElement.$_pfocustrap_focusableselector = lastFocusableSelector;
lastFocusableElement.setAttribute("data-pc-section", "lastfocusableelement");
el.prepend(firstFocusableElement);
el.append(lastFocusableElement);
}
}
});
var OverlayEventBus = EventBus();
var script$a = {
name: "Portal",
props: {
appendTo: {
type: [String, Object],
"default": "body"
},
disabled: {
type: Boolean,
"default": false
}
},
data: function data() {
return {
mounted: false
};
},
mounted: function mounted2() {
this.mounted = isClient();
},
computed: {
inline: function inline() {
return this.disabled || this.appendTo === "self";
}
}
};
function render$7(_ctx, _cache, $props, $setup, $data, $options) {
return $options.inline ? renderSlot(_ctx.$slots, "default", {
key: 0
}) : $data.mounted ? (openBlock(), createBlock(Teleport, {
key: 1,
to: $props.appendTo
}, [renderSlot(_ctx.$slots, "default")], 8, ["to"])) : createCommentVNode("", true);
}
script$a.render = render$7;
var theme$5 = function theme2(_ref) {
var dt2 = _ref.dt;
return "\n.p-ink {\n display: block;\n position: absolute;\n background: ".concat(dt2("ripple.background"), ";\n border-radius: 100%;\n transform: scale(0);\n pointer-events: none;\n}\n\n.p-ink-active {\n animation: ripple 0.4s linear;\n}\n\n@keyframes ripple {\n 100% {\n opacity: 0;\n transform: scale(2.5);\n }\n}\n");
};
var classes$5 = {
root: "p-ink"
};
var RippleStyle = BaseStyle.extend({
name: "ripple-directive",
theme: theme$5,
classes: classes$5
});
var BaseRipple = BaseDirective.extend({
style: RippleStyle
});
function _typeof$4(o) {
"@babel/helpers - typeof";
return _typeof$4 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$4(o);
}
function _toConsumableArray(r) {
return _arrayWithoutHoles(r) || _iterableToArray$1(r) || _unsupportedIterableToArray$1(r) || _nonIterableSpread();
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray$1(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray$1(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0;
}
}
function _iterableToArray$1(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _arrayWithoutHoles(r) {
if (Array.isArray(r)) return _arrayLikeToArray$1(r);
}
function _arrayLikeToArray$1(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _defineProperty$5(e, r, t) {
return (r = _toPropertyKey$4(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$4(t) {
var i = _toPrimitive$4(t, "string");
return "symbol" == _typeof$4(i) ? i : i + "";
}
function _toPrimitive$4(t, r) {
if ("object" != _typeof$4(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$4(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var Ripple = BaseRipple.extend("ripple", {
watch: {
"config.ripple": function configRipple(newValue) {
if (newValue) {
this.createRipple(this.$host);
this.bindEvents(this.$host);
this.$host.setAttribute("data-pd-ripple", true);
this.$host.style["overflow"] = "hidden";
this.$host.style["position"] = "relative";
} else {
this.remove(this.$host);
this.$host.removeAttribute("data-pd-ripple");
}
}
},
unmounted: function unmounted2(el) {
this.remove(el);
},
timeout: void 0,
methods: {
bindEvents: function bindEvents(el) {
el.addEventListener("mousedown", this.onMouseDown.bind(this));
},
unbindEvents: function unbindEvents(el) {
el.removeEventListener("mousedown", this.onMouseDown.bind(this));
},
createRipple: function createRipple(el) {
var ink = createElement("span", _defineProperty$5(_defineProperty$5({
role: "presentation",
"aria-hidden": true,
"data-p-ink": true,
"data-p-ink-active": false,
"class": !this.isUnstyled() && this.cx("root"),
onAnimationEnd: this.onAnimationEnd.bind(this)
}, this.$attrSelector, ""), "p-bind", this.ptm("root")));
el.appendChild(ink);
this.$el = ink;
},
remove: function remove2(el) {
var ink = this.getInk(el);
if (ink) {
this.$host.style["overflow"] = "";
this.$host.style["position"] = "";
this.unbindEvents(el);
ink.removeEventListener("animationend", this.onAnimationEnd);
ink.remove();
}
},
onMouseDown: function onMouseDown(event) {
var _this = this;
var target = event.currentTarget;
var ink = this.getInk(target);
if (!ink || getComputedStyle(ink, null).display === "none") {
return;
}
!this.isUnstyled() && removeClass(ink, "p-ink-active");
ink.setAttribute("data-p-ink-active", "false");
if (!getHeight(ink) && !getWidth(ink)) {
var d = Math.max(getOuterWidth(target), getOuterHeight(target));
ink.style.height = d + "px";
ink.style.width = d + "px";
}
var offset = getOffset(target);
var x = event.pageX - offset.left + document.body.scrollTop - getWidth(ink) / 2;
var y = event.pageY - offset.top + document.body.scrollLeft - getHeight(ink) / 2;
ink.style.top = y + "px";
ink.style.left = x + "px";
!this.isUnstyled() && addClass(ink, "p-ink-active");
ink.setAttribute("data-p-ink-active", "true");
this.timeout = setTimeout(function() {
if (ink) {
!_this.isUnstyled() && removeClass(ink, "p-ink-active");
ink.setAttribute("data-p-ink-active", "false");
}
}, 401);
},
onAnimationEnd: function onAnimationEnd(event) {
if (this.timeout) {
clearTimeout(this.timeout);
}
!this.isUnstyled() && removeClass(event.currentTarget, "p-ink-active");
event.currentTarget.setAttribute("data-p-ink-active", "false");
},
getInk: function getInk(el) {
return el && el.children ? _toConsumableArray(el.children).find(function(child) {
return getAttribute(child, "data-pc-name") === "ripple";
}) : void 0;
}
}
});
var BaseComponentStyle = BaseStyle.extend({
name: "common"
});
function _typeof$3(o) {
"@babel/helpers - typeof";
return _typeof$3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$3(o);
}
function _toArray(r) {
return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest();
}
function _iterableToArray(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _slicedToArray(r, e) {
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _iterableToArrayLimit(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e, n, i, u, a = [], f = true, o = false;
try {
if (i = (t = t.call(r)).next, 0 === l) {
if (Object(t) !== t) return;
f = false;
} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
} catch (r2) {
o = true, n = r2;
} finally {
try {
if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _arrayWithHoles(r) {
if (Array.isArray(r)) return r;
}
function ownKeys$2(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$2(Object(t), true).forEach(function(r2) {
_defineProperty$4(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$4(e, r, t) {
return (r = _toPropertyKey$3(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$3(t) {
var i = _toPrimitive$3(t, "string");
return "symbol" == _typeof$3(i) ? i : i + "";
}
function _toPrimitive$3(t, r) {
if ("object" != _typeof$3(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$3(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var script$9 = {
name: "BaseComponent",
props: {
pt: {
type: Object,
"default": void 0
},
ptOptions: {
type: Object,
"default": void 0
},
unstyled: {
type: Boolean,
"default": void 0
},
dt: {
type: Object,
"default": void 0
}
},
inject: {
$parentInstance: {
"default": void 0
}
},
watch: {
isUnstyled: {
immediate: true,
handler: function handler2(newValue) {
if (!newValue) {
this._loadCoreStyles();
this._themeChangeListener(this._loadCoreStyles);
}
}
},
dt: {
immediate: true,
handler: function handler3(newValue) {
var _this = this;
if (newValue) {
this._loadScopedThemeStyles(newValue);
this._themeChangeListener(function() {
return _this._loadScopedThemeStyles(newValue);
});
} else {
this._unloadScopedThemeStyles();
}
}
}
},
scopedStyleEl: void 0,
rootEl: void 0,
$attrSelector: void 0,
beforeCreate: function beforeCreate() {
var _this$pt, _this$pt2, _this$pt3, _ref, _ref$onBeforeCreate, _this$$primevueConfig, _this$$primevue, _this$$primevue2, _this$$primevue3, _ref2, _ref2$onBeforeCreate;
var _usept = (_this$pt = this.pt) === null || _this$pt === void 0 ? void 0 : _this$pt["_usept"];
var originalValue = _usept ? (_this$pt2 = this.pt) === null || _this$pt2 === void 0 || (_this$pt2 = _this$pt2.originalValue) === null || _this$pt2 === void 0 ? void 0 : _this$pt2[this.$.type.name] : void 0;
var value = _usept ? (_this$pt3 = this.pt) === null || _this$pt3 === void 0 || (_this$pt3 = _this$pt3.value) === null || _this$pt3 === void 0 ? void 0 : _this$pt3[this.$.type.name] : this.pt;
(_ref = value || originalValue) === null || _ref === void 0 || (_ref = _ref.hooks) === null || _ref === void 0 || (_ref$onBeforeCreate = _ref["onBeforeCreate"]) === null || _ref$onBeforeCreate === void 0 || _ref$onBeforeCreate.call(_ref);
var _useptInConfig = (_this$$primevueConfig = this.$primevueConfig) === null || _this$$primevueConfig === void 0 || (_this$$primevueConfig = _this$$primevueConfig.pt) === null || _this$$primevueConfig === void 0 ? void 0 : _this$$primevueConfig["_usept"];
var originalValueInConfig = _useptInConfig ? (_this$$primevue = this.$primevue) === null || _this$$primevue === void 0 || (_this$$primevue = _this$$primevue.config) === null || _this$$primevue === void 0 || (_this$$primevue = _this$$primevue.pt) === null || _this$$primevue === void 0 ? void 0 : _this$$primevue.originalValue : void 0;
var valueInConfig = _useptInConfig ? (_this$$primevue2 = this.$primevue) === null || _this$$primevue2 === void 0 || (_this$$primevue2 = _this$$primevue2.config) === null || _this$$primevue2 === void 0 || (_this$$primevue2 = _this$$primevue2.pt) === null || _this$$primevue2 === void 0 ? void 0 : _this$$primevue2.value : (_this$$primevue3 = this.$primevue) === null || _this$$primevue3 === void 0 || (_this$$primevue3 = _this$$primevue3.config) === null || _this$$primevue3 === void 0 ? void 0 : _this$$primevue3.pt;
(_ref2 = valueInConfig || originalValueInConfig) === null || _ref2 === void 0 || (_ref2 = _ref2[this.$.type.name]) === null || _ref2 === void 0 || (_ref2 = _ref2.hooks) === null || _ref2 === void 0 || (_ref2$onBeforeCreate = _ref2["onBeforeCreate"]) === null || _ref2$onBeforeCreate === void 0 || _ref2$onBeforeCreate.call(_ref2);
this.$attrSelector = uuid("pc");
},
created: function created() {
this._hook("onCreated");
},
beforeMount: function beforeMount() {
this.rootEl = findSingle(this.$el, '[data-pc-name="'.concat(toFlatCase(this.$.type.name), '"]'));
if (this.rootEl) {
this.$attrSelector && !this.rootEl.hasAttribute(this.$attrSelector) && this.rootEl.setAttribute(this.$attrSelector, "");
this.rootEl.$pc = _objectSpread$2({
name: this.$.type.name,
attrSelector: this.$attrSelector
}, this.$params);
}
this._loadStyles();
this._hook("onBeforeMount");
},
mounted: function mounted3() {
this._hook("onMounted");
},
beforeUpdate: function beforeUpdate() {
this._hook("onBeforeUpdate");
},
updated: function updated2() {
this._hook("onUpdated");
},
beforeUnmount: function beforeUnmount() {
this._hook("onBeforeUnmount");
},
unmounted: function unmounted3() {
this._unloadScopedThemeStyles();
this._hook("onUnmounted");
},
methods: {
_hook: function _hook2(hookName) {
if (!this.$options.hostName) {
var selfHook = this._usePT(this._getPT(this.pt, this.$.type.name), this._getOptionValue, "hooks.".concat(hookName));
var defaultHook = this._useDefaultPT(this._getOptionValue, "hooks.".concat(hookName));
selfHook === null || selfHook === void 0 || selfHook();
defaultHook === null || defaultHook === void 0 || defaultHook();
}
},
_mergeProps: function _mergeProps2(fn) {
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
return isFunction$3(fn) ? fn.apply(void 0, args) : mergeProps.apply(void 0, args);
},
_loadStyles: function _loadStyles2() {
var _this2 = this;
var _load = function _load2() {
if (!Base.isStyleNameLoaded("base")) {
BaseStyle.loadCSS(_this2.$styleOptions);
_this2._loadGlobalStyles();
Base.setLoadedStyleName("base");
}
_this2._loadThemeStyles();
};
_load();
this._themeChangeListener(_load);
},
_loadCoreStyles: function _loadCoreStyles2() {
var _this$$style, _this$$style2;
if (!Base.isStyleNameLoaded((_this$$style = this.$style) === null || _this$$style === void 0 ? void 0 : _this$$style.name) && (_this$$style2 = this.$style) !== null && _this$$style2 !== void 0 && _this$$style2.name) {
BaseComponentStyle.loadCSS(this.$styleOptions);
this.$options.style && this.$style.loadCSS(this.$styleOptions);
Base.setLoadedStyleName(this.$style.name);
}
},
_loadGlobalStyles: function _loadGlobalStyles() {
var globalCSS = this._useGlobalPT(this._getOptionValue, "global.css", this.$params);
isNotEmpty(globalCSS) && BaseStyle.load(globalCSS, _objectSpread$2({
name: "global"
}, this.$styleOptions));
},
_loadThemeStyles: function _loadThemeStyles2() {
var _this$$style4, _this$$style5;
if (this.isUnstyled || this.$theme === "none") return;
if (!config_default.isStyleNameLoaded("common")) {
var _this$$style3, _this$$style3$getComm;
var _ref3 = ((_this$$style3 = this.$style) === null || _this$$style3 === void 0 || (_this$$style3$getComm = _this$$style3.getCommonTheme) === null || _this$$style3$getComm === void 0 ? void 0 : _this$$style3$getComm.call(_this$$style3)) || {}, primitive = _ref3.primitive, semantic = _ref3.semantic, global2 = _ref3.global, style = _ref3.style;
BaseStyle.load(primitive === null || primitive === void 0 ? void 0 : primitive.css, _objectSpread$2({
name: "primitive-variables"
}, this.$styleOptions));
BaseStyle.load(semantic === null || semantic === void 0 ? void 0 : semantic.css, _objectSpread$2({
name: "semantic-variables"
}, this.$styleOptions));
BaseStyle.load(global2 === null || global2 === void 0 ? void 0 : global2.css, _objectSpread$2({
name: "global-variables"
}, this.$styleOptions));
BaseStyle.loadTheme(_objectSpread$2({
name: "global-style"
}, this.$styleOptions), style);
config_default.setLoadedStyleName("common");
}
if (!config_default.isStyleNameLoaded((_this$$style4 = this.$style) === null || _this$$style4 === void 0 ? void 0 : _this$$style4.name) && (_this$$style5 = this.$style) !== null && _this$$style5 !== void 0 && _this$$style5.name) {
var _this$$style6, _this$$style6$getComp, _this$$style7, _this$$style8;
var _ref4 = ((_this$$style6 = this.$style) === null || _this$$style6 === void 0 || (_this$$style6$getComp = _this$$style6.getComponentTheme) === null || _this$$style6$getComp === void 0 ? void 0 : _this$$style6$getComp.call(_this$$style6)) || {}, css3 = _ref4.css, _style = _ref4.style;
(_this$$style7 = this.$style) === null || _this$$style7 === void 0 || _this$$style7.load(css3, _objectSpread$2({
name: "".concat(this.$style.name, "-variables")
}, this.$styleOptions));
(_this$$style8 = this.$style) === null || _this$$style8 === void 0 || _this$$style8.loadTheme(_objectSpread$2({
name: "".concat(this.$style.name, "-style")
}, this.$styleOptions), _style);
config_default.setLoadedStyleName(this.$style.name);
}
if (!config_default.isStyleNameLoaded("layer-order")) {
var _this$$style9, _this$$style9$getLaye;
var layerOrder = (_this$$style9 = this.$style) === null || _this$$style9 === void 0 || (_this$$style9$getLaye = _this$$style9.getLayerOrderThemeCSS) === null || _this$$style9$getLaye === void 0 ? void 0 : _this$$style9$getLaye.call(_this$$style9);
BaseStyle.load(layerOrder, _objectSpread$2({
name: "layer-order",
first: true
}, this.$styleOptions));
config_default.setLoadedStyleName("layer-order");
}
},
_loadScopedThemeStyles: function _loadScopedThemeStyles2(preset) {
var _this$$style10, _this$$style10$getPre, _this$$style11;
var _ref5 = ((_this$$style10 = this.$style) === null || _this$$style10 === void 0 || (_this$$style10$getPre = _this$$style10.getPresetTheme) === null || _this$$style10$getPre === void 0 ? void 0 : _this$$style10$getPre.call(_this$$style10, preset, "[".concat(this.$attrSelector, "]"))) || {}, css3 = _ref5.css;
var scopedStyle = (_this$$style11 = this.$style) === null || _this$$style11 === void 0 ? void 0 : _this$$style11.load(css3, _objectSpread$2({
name: "".concat(this.$attrSelector, "-").concat(this.$style.name)
}, this.$styleOptions));
this.scopedStyleEl = scopedStyle.el;
},
_unloadScopedThemeStyles: function _unloadScopedThemeStyles() {
var _this$scopedStyleEl;
(_this$scopedStyleEl = this.scopedStyleEl) === null || _this$scopedStyleEl === void 0 || (_this$scopedStyleEl = _this$scopedStyleEl.value) === null || _this$scopedStyleEl === void 0 || _this$scopedStyleEl.remove();
},
_themeChangeListener: function _themeChangeListener2() {
var callback = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {
};
Base.clearLoadedStyleNames();
service_default.on("theme:change", callback);
},
_getHostInstance: function _getHostInstance(instance) {
return instance ? this.$options.hostName ? instance.$.type.name === this.$options.hostName ? instance : this._getHostInstance(instance.$parentInstance) : instance.$parentInstance : void 0;
},
_getPropValue: function _getPropValue(name) {
var _this$_getHostInstanc;
return this[name] || ((_this$_getHostInstanc = this._getHostInstance(this)) === null || _this$_getHostInstanc === void 0 ? void 0 : _this$_getHostInstanc[name]);
},
_getOptionValue: function _getOptionValue(options) {
var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
return getKeyValue(options, key, params);
},
_getPTValue: function _getPTValue2() {
var _this$$primevueConfig2;
var obj = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
var searchInDefaultPT = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
var searchOut = /./g.test(key) && !!params[key.split(".")[0]];
var _ref6 = this._getPropValue("ptOptions") || ((_this$$primevueConfig2 = this.$primevueConfig) === null || _this$$primevueConfig2 === void 0 ? void 0 : _this$$primevueConfig2.ptOptions) || {}, _ref6$mergeSections = _ref6.mergeSections, mergeSections = _ref6$mergeSections === void 0 ? true : _ref6$mergeSections, _ref6$mergeProps = _ref6.mergeProps, useMergeProps = _ref6$mergeProps === void 0 ? false : _ref6$mergeProps;
var global2 = searchInDefaultPT ? searchOut ? this._useGlobalPT(this._getPTClassValue, key, params) : this._useDefaultPT(this._getPTClassValue, key, params) : void 0;
var self2 = searchOut ? void 0 : this._getPTSelf(obj, this._getPTClassValue, key, _objectSpread$2(_objectSpread$2({}, params), {}, {
global: global2 || {}
}));
var datasets = this._getPTDatasets(key);
return mergeSections || !mergeSections && self2 ? useMergeProps ? this._mergeProps(useMergeProps, global2, self2, datasets) : _objectSpread$2(_objectSpread$2(_objectSpread$2({}, global2), self2), datasets) : _objectSpread$2(_objectSpread$2({}, self2), datasets);
},
_getPTSelf: function _getPTSelf() {
var obj = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key3 = 1; _key3 < _len2; _key3++) {
args[_key3 - 1] = arguments[_key3];
}
return mergeProps(
this._usePT.apply(this, [this._getPT(obj, this.$name)].concat(args)),
// Exp; <component :pt="{}"
this._usePT.apply(this, [this.$_attrsPT].concat(args))
// Exp; <component :pt:[passthrough_key]:[attribute]="{value}" or <component :pt:[passthrough_key]="() =>{value}"
);
},
_getPTDatasets: function _getPTDatasets2() {
var _this$pt4, _this$pt5;
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var datasetPrefix = "data-pc-";
var isExtended = key === "root" && isNotEmpty((_this$pt4 = this.pt) === null || _this$pt4 === void 0 ? void 0 : _this$pt4["data-pc-section"]);
return key !== "transition" && _objectSpread$2(_objectSpread$2({}, key === "root" && _objectSpread$2(_objectSpread$2(_defineProperty$4({}, "".concat(datasetPrefix, "name"), toFlatCase(isExtended ? (_this$pt5 = this.pt) === null || _this$pt5 === void 0 ? void 0 : _this$pt5["data-pc-section"] : this.$.type.name)), isExtended && _defineProperty$4({}, "".concat(datasetPrefix, "extend"), toFlatCase(this.$.type.name))), isClient() && _defineProperty$4({}, "".concat(this.$attrSelector), ""))), {}, _defineProperty$4({}, "".concat(datasetPrefix, "section"), toFlatCase(key)));
},
_getPTClassValue: function _getPTClassValue() {
var value = this._getOptionValue.apply(this, arguments);
return isString(value) || isArray$5(value) ? {
"class": value
} : value;
},
_getPT: function _getPT2(pt) {
var _this3 = this;
var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
var callback = arguments.length > 2 ? arguments[2] : void 0;
var getValue2 = function getValue3(value) {
var _ref9;
var checkSameKey = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
var computedValue = callback ? callback(value) : value;
var _key = toFlatCase(key);
var _cKey = toFlatCase(_this3.$name);
return (_ref9 = checkSameKey ? _key !== _cKey ? computedValue === null || computedValue === void 0 ? void 0 : computedValue[_key] : void 0 : computedValue === null || computedValue === void 0 ? void 0 : computedValue[_key]) !== null && _ref9 !== void 0 ? _ref9 : computedValue;
};
return pt !== null && pt !== void 0 && pt.hasOwnProperty("_usept") ? {
_usept: pt["_usept"],
originalValue: getValue2(pt.originalValue),
value: getValue2(pt.value)
} : getValue2(pt, true);
},
_usePT: function _usePT2(pt, callback, key, params) {
var fn = function fn2(value2) {
return callback(value2, key, params);
};
if (pt !== null && pt !== void 0 && pt.hasOwnProperty("_usept")) {
var _this$$primevueConfig3;
var _ref10 = pt["_usept"] || ((_this$$primevueConfig3 = this.$primevueConfig) === null || _this$$primevueConfig3 === void 0 ? void 0 : _this$$primevueConfig3.ptOptions) || {}, _ref10$mergeSections = _ref10.mergeSections, mergeSections = _ref10$mergeSections === void 0 ? true : _ref10$mergeSections, _ref10$mergeProps = _ref10.mergeProps, useMergeProps = _ref10$mergeProps === void 0 ? false : _ref10$mergeProps;
var originalValue = fn(pt.originalValue);
var value = fn(pt.value);
if (originalValue === void 0 && value === void 0) return void 0;
else if (isString(value)) return value;
else if (isString(originalValue)) return originalValue;
return mergeSections || !mergeSections && value ? useMergeProps ? this._mergeProps(useMergeProps, originalValue, value) : _objectSpread$2(_objectSpread$2({}, originalValue), value) : value;
}
return fn(pt);
},
_useGlobalPT: function _useGlobalPT(callback, key, params) {
return this._usePT(this.globalPT, callback, key, params);
},
_useDefaultPT: function _useDefaultPT2(callback, key, params) {
return this._usePT(this.defaultPT, callback, key, params);
},
ptm: function ptm() {
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
return this._getPTValue(this.pt, key, _objectSpread$2(_objectSpread$2({}, this.$params), params));
},
ptmi: function ptmi() {
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
return mergeProps(this.$_attrsWithoutPT, this.ptm(key, params));
},
ptmo: function ptmo() {
var obj = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
return this._getPTValue(obj, key, _objectSpread$2({
instance: this
}, params), false);
},
cx: function cx() {
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var params = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
return !this.isUnstyled ? this._getOptionValue(this.$style.classes, key, _objectSpread$2(_objectSpread$2({}, this.$params), params)) : void 0;
},
sx: function sx() {
var key = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
var when = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
var params = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
if (when) {
var self2 = this._getOptionValue(this.$style.inlineStyles, key, _objectSpread$2(_objectSpread$2({}, this.$params), params));
var base = this._getOptionValue(BaseComponentStyle.inlineStyles, key, _objectSpread$2(_objectSpread$2({}, this.$params), params));
return [base, self2];
}
return void 0;
}
},
computed: {
globalPT: function globalPT() {
var _this$$primevueConfig4, _this4 = this;
return this._getPT((_this$$primevueConfig4 = this.$primevueConfig) === null || _this$$primevueConfig4 === void 0 ? void 0 : _this$$primevueConfig4.pt, void 0, function(value) {
return resolve(value, {
instance: _this4
});
});
},
defaultPT: function defaultPT() {
var _this$$primevueConfig5, _this5 = this;
return this._getPT((_this$$primevueConfig5 = this.$primevueConfig) === null || _this$$primevueConfig5 === void 0 ? void 0 : _this$$primevueConfig5.pt, void 0, function(value) {
return _this5._getOptionValue(value, _this5.$name, _objectSpread$2({}, _this5.$params)) || resolve(value, _objectSpread$2({}, _this5.$params));
});
},
isUnstyled: function isUnstyled() {
var _this$$primevueConfig6;
return this.unstyled !== void 0 ? this.unstyled : (_this$$primevueConfig6 = this.$primevueConfig) === null || _this$$primevueConfig6 === void 0 ? void 0 : _this$$primevueConfig6.unstyled;
},
$theme: function $theme() {
var _this$$primevueConfig7;
return (_this$$primevueConfig7 = this.$primevueConfig) === null || _this$$primevueConfig7 === void 0 ? void 0 : _this$$primevueConfig7.theme;
},
$style: function $style() {
return _objectSpread$2(_objectSpread$2({
classes: void 0,
inlineStyles: void 0,
load: function load2() {
},
loadCSS: function loadCSS2() {
},
loadTheme: function loadTheme2() {
}
}, (this._getHostInstance(this) || {}).$style), this.$options.style);
},
$styleOptions: function $styleOptions() {
var _this$$primevueConfig8;
return {
nonce: (_this$$primevueConfig8 = this.$primevueConfig) === null || _this$$primevueConfig8 === void 0 || (_this$$primevueConfig8 = _this$$primevueConfig8.csp) === null || _this$$primevueConfig8 === void 0 ? void 0 : _this$$primevueConfig8.nonce
};
},
$primevueConfig: function $primevueConfig() {
var _this$$primevue4;
return (_this$$primevue4 = this.$primevue) === null || _this$$primevue4 === void 0 ? void 0 : _this$$primevue4.config;
},
$name: function $name() {
return this.$options.hostName || this.$.type.name;
},
$params: function $params() {
var parentInstance = this._getHostInstance(this) || this.$parent;
return {
instance: this,
props: this.$props,
state: this.$data,
attrs: this.$attrs,
parent: {
instance: parentInstance,
props: parentInstance === null || parentInstance === void 0 ? void 0 : parentInstance.$props,
state: parentInstance === null || parentInstance === void 0 ? void 0 : parentInstance.$data,
attrs: parentInstance === null || parentInstance === void 0 ? void 0 : parentInstance.$attrs
}
};
},
$_attrsPT: function $_attrsPT() {
return Object.entries(this.$attrs || {}).filter(function(_ref11) {
var _ref12 = _slicedToArray(_ref11, 1), key = _ref12[0];
return key === null || key === void 0 ? void 0 : key.startsWith("pt:");
}).reduce(function(result, _ref13) {
var _ref14 = _slicedToArray(_ref13, 2), key = _ref14[0], value = _ref14[1];
var _key$split = key.split(":"), _key$split2 = _toArray(_key$split), rest = _key$split2.slice(1);
rest === null || rest === void 0 || rest.reduce(function(currentObj, nestedKey, index2, array) {
!currentObj[nestedKey] && (currentObj[nestedKey] = index2 === array.length - 1 ? value : {});
return currentObj[nestedKey];
}, result);
return result;
}, {});
},
$_attrsWithoutPT: function $_attrsWithoutPT() {
return Object.entries(this.$attrs || {}).filter(function(_ref15) {
var _ref16 = _slicedToArray(_ref15, 1), key = _ref16[0];
return !(key !== null && key !== void 0 && key.startsWith("pt:"));
}).reduce(function(acc, _ref17) {
var _ref18 = _slicedToArray(_ref17, 2), key = _ref18[0], value = _ref18[1];
acc[key] = value;
return acc;
}, {});
}
}
};
var theme$4 = function theme3(_ref) {
var dt2 = _ref.dt;
return "\n.p-popover {\n margin-top: ".concat(dt2("popover.gutter"), ";\n background: ").concat(dt2("popover.background"), ";\n color: ").concat(dt2("popover.color"), ";\n border: 1px solid ").concat(dt2("popover.border.color"), ";\n border-radius: ").concat(dt2("popover.border.radius"), ";\n box-shadow: ").concat(dt2("popover.shadow"), ";\n}\n\n.p-popover-content {\n padding: ").concat(dt2("popover.content.padding"), ";\n}\n\n.p-popover-flipped {\n margin-top: calc(").concat(dt2("popover.gutter"), " * -1);\n margin-bottom: ").concat(dt2("popover.gutter"), ";\n}\n\n.p-popover-enter-from {\n opacity: 0;\n transform: scaleY(0.8);\n}\n\n.p-popover-leave-to {\n opacity: 0;\n}\n\n.p-popover-enter-active {\n transition: transform 0.12s cubic-bezier(0, 0, 0.2, 1), opacity 0.12s cubic-bezier(0, 0, 0.2, 1);\n}\n\n.p-popover-leave-active {\n transition: opacity 0.1s linear;\n}\n\n.p-popover:after,\n.p-popover:before {\n bottom: 100%;\n left: calc(").concat(dt2("popover.arrow.offset"), " + ").concat(dt2("popover.arrow.left"), ');\n content: " ";\n height: 0;\n width: 0;\n position: absolute;\n pointer-events: none;\n}\n\n.p-popover:after {\n border-width: calc(').concat(dt2("popover.gutter"), " - 2px);\n margin-left: calc(-1 * (").concat(dt2("popover.gutter"), " - 2px));\n border-style: solid;\n border-color: transparent;\n border-bottom-color: ").concat(dt2("popover.background"), ";\n}\n\n.p-popover:before {\n border-width: ").concat(dt2("popover.gutter"), ";\n margin-left: calc(-1 * ").concat(dt2("popover.gutter"), ");\n border-style: solid;\n border-color: transparent;\n border-bottom-color: ").concat(dt2("popover.border.color"), ";\n}\n\n.p-popover-flipped:after,\n.p-popover-flipped:before {\n bottom: auto;\n top: 100%;\n}\n\n.p-popover.p-popover-flipped:after {\n border-bottom-color: transparent;\n border-top-color: ").concat(dt2("popover.background"), ";\n}\n\n.p-popover.p-popover-flipped:before {\n border-bottom-color: transparent;\n border-top-color: ").concat(dt2("popover.border.color"), ";\n}\n");
};
var classes$4 = {
root: "p-popover p-component",
content: "p-popover-content"
};
var PopoverStyle = BaseStyle.extend({
name: "popover",
theme: theme$4,
classes: classes$4
});
var script$1$4 = {
name: "BasePopover",
"extends": script$9,
props: {
dismissable: {
type: Boolean,
"default": true
},
appendTo: {
type: [String, Object],
"default": "body"
},
baseZIndex: {
type: Number,
"default": 0
},
autoZIndex: {
type: Boolean,
"default": true
},
breakpoints: {
type: Object,
"default": null
},
closeOnEscape: {
type: Boolean,
"default": true
}
},
style: PopoverStyle,
provide: function provide2() {
return {
$pcPopover: this,
$parentInstance: this
};
}
};
var script$8 = {
name: "Popover",
"extends": script$1$4,
inheritAttrs: false,
emits: ["show", "hide"],
data: function data2() {
return {
visible: false
};
},
watch: {
dismissable: {
immediate: true,
handler: function handler4(newValue) {
if (newValue) {
this.bindOutsideClickListener();
} else {
this.unbindOutsideClickListener();
}
}
}
},
selfClick: false,
target: null,
eventTarget: null,
outsideClickListener: null,
scrollHandler: null,
resizeListener: null,
container: null,
styleElement: null,
overlayEventListener: null,
documentKeydownListener: null,
beforeUnmount: function beforeUnmount2() {
if (this.dismissable) {
this.unbindOutsideClickListener();
}
if (this.scrollHandler) {
this.scrollHandler.destroy();
this.scrollHandler = null;
}
this.destroyStyle();
this.unbindResizeListener();
this.target = null;
if (this.container && this.autoZIndex) {
ZIndex.clear(this.container);
}
if (this.overlayEventListener) {
OverlayEventBus.off("overlay-click", this.overlayEventListener);
this.overlayEventListener = null;
}
this.container = null;
},
mounted: function mounted4() {
if (this.breakpoints) {
this.createStyle();
}
},
methods: {
toggle: function toggle(event, target) {
if (this.visible) this.hide();
else this.show(event, target);
},
show: function show(event, target) {
this.visible = true;
this.eventTarget = event.currentTarget;
this.target = target || event.currentTarget;
},
hide: function hide() {
this.visible = false;
},
onContentClick: function onContentClick() {
this.selfClick = true;
},
onEnter: function onEnter(el) {
var _this = this;
addStyle(el, {
position: "absolute",
top: "0",
left: "0"
});
this.alignOverlay();
if (this.dismissable) {
this.bindOutsideClickListener();
}
this.bindScrollListener();
this.bindResizeListener();
if (this.autoZIndex) {
ZIndex.set("overlay", el, this.baseZIndex + this.$primevue.config.zIndex.overlay);
}
this.overlayEventListener = function(e) {
if (_this.container.contains(e.target)) {
_this.selfClick = true;
}
};
this.focus();
OverlayEventBus.on("overlay-click", this.overlayEventListener);
this.$emit("show");
if (this.closeOnEscape) {
this.bindDocumentKeyDownListener();
}
},
onLeave: function onLeave() {
this.unbindOutsideClickListener();
this.unbindScrollListener();
this.unbindResizeListener();
this.unbindDocumentKeyDownListener();
OverlayEventBus.off("overlay-click", this.overlayEventListener);
this.overlayEventListener = null;
this.$emit("hide");
},
onAfterLeave: function onAfterLeave(el) {
if (this.autoZIndex) {
ZIndex.clear(el);
}
},
alignOverlay: function alignOverlay() {
absolutePosition(this.container, this.target, false);
var containerOffset = getOffset(this.container);
var targetOffset = getOffset(this.target);
var arrowLeft = 0;
if (containerOffset.left < targetOffset.left) {
arrowLeft = targetOffset.left - containerOffset.left;
}
this.container.style.setProperty($dt("popover.arrow.left").name, "".concat(arrowLeft, "px"));
if (containerOffset.top < targetOffset.top) {
this.container.setAttribute("data-p-popover-flipped", "true");
!this.isUnstyled && addClass(this.container, "p-popover-flipped");
}
},
onContentKeydown: function onContentKeydown(event) {
if (event.code === "Escape" && this.closeOnEscape) {
this.hide();
focus(this.target);
}
},
onButtonKeydown: function onButtonKeydown(event) {
switch (event.code) {
case "ArrowDown":
case "ArrowUp":
case "ArrowLeft":
case "ArrowRight":
event.preventDefault();
}
},
focus: function focus2() {
var focusTarget = this.container.querySelector("[autofocus]");
if (focusTarget) {
focusTarget.focus();
}
},
onKeyDown: function onKeyDown(event) {
if (event.code === "Escape" && this.closeOnEscape) {
this.visible = false;
}
},
bindDocumentKeyDownListener: function bindDocumentKeyDownListener() {
if (!this.documentKeydownListener) {
this.documentKeydownListener = this.onKeyDown.bind(this);
window.document.addEventListener("keydown", this.documentKeydownListener);
}
},
unbindDocumentKeyDownListener: function unbindDocumentKeyDownListener() {
if (this.documentKeydownListener) {
window.document.removeEventListener("keydown", this.documentKeydownListener);
this.documentKeydownListener = null;
}
},
bindOutsideClickListener: function bindOutsideClickListener() {
var _this2 = this;
if (!this.outsideClickListener && isClient()) {
this.outsideClickListener = function(event) {
if (_this2.visible && !_this2.selfClick && !_this2.isTargetClicked(event)) {
_this2.visible = false;
}
_this2.selfClick = false;
};
document.addEventListener("click", this.outsideClickListener);
}
},
unbindOutsideClickListener: function unbindOutsideClickListener() {
if (this.outsideClickListener) {
document.removeEventListener("click", this.outsideClickListener);
this.outsideClickListener = null;
this.selfClick = false;
}
},
bindScrollListener: function bindScrollListener() {
var _this3 = this;
if (!this.scrollHandler) {
this.scrollHandler = new ConnectedOverlayScrollHandler(this.target, function() {
if (_this3.visible) {
_this3.visible = false;
}
});
}
this.scrollHandler.bindScrollListener();
},
unbindScrollListener: function unbindScrollListener() {
if (this.scrollHandler) {
this.scrollHandler.unbindScrollListener();
}
},
bindResizeListener: function bindResizeListener() {
var _this4 = this;
if (!this.resizeListener) {
this.resizeListener = function() {
if (_this4.visible && !isTouchDevice()) {
_this4.visible = false;
}
};
window.addEventListener("resize", this.resizeListener);
}
},
unbindResizeListener: function unbindResizeListener() {
if (this.resizeListener) {
window.removeEventListener("resize", this.resizeListener);
this.resizeListener = null;
}
},
isTargetClicked: function isTargetClicked(event) {
return this.eventTarget && (this.eventTarget === event.target || this.eventTarget.contains(event.target));
},
containerRef: function containerRef(el) {
this.container = el;
},
createStyle: function createStyle() {
if (!this.styleElement && !this.isUnstyled) {
var _this$$primevue;
this.styleElement = document.createElement("style");
this.styleElement.type = "text/css";
setAttribute(this.styleElement, "nonce", (_this$$primevue = this.$primevue) === null || _this$$primevue === void 0 || (_this$$primevue = _this$$primevue.config) === null || _this$$primevue === void 0 || (_this$$primevue = _this$$primevue.csp) === null || _this$$primevue === void 0 ? void 0 : _this$$primevue.nonce);
document.head.appendChild(this.styleElement);
var innerHTML = "";
for (var breakpoint in this.breakpoints) {
innerHTML += "\n @media screen and (max-width: ".concat(breakpoint, ") {\n .p-popover[").concat(this.$attrSelector, "] {\n width: ").concat(this.breakpoints[breakpoint], " !important;\n }\n }\n ");
}
this.styleElement.innerHTML = innerHTML;
}
},
destroyStyle: function destroyStyle() {
if (this.styleElement) {
document.head.removeChild(this.styleElement);
this.styleElement = null;
}
},
onOverlayClick: function onOverlayClick(event) {
OverlayEventBus.emit("overlay-click", {
originalEvent: event,
target: this.target
});
}
},
directives: {
focustrap: FocusTrap,
ripple: Ripple
},
components: {
Portal: script$a
}
};
var _hoisted_1$a = ["aria-modal"];
function render$6(_ctx, _cache, $props, $setup, $data, $options) {
var _component_Portal = resolveComponent("Portal");
var _directive_focustrap = resolveDirective("focustrap");
return openBlock(), createBlock(_component_Portal, {
appendTo: _ctx.appendTo
}, {
"default": withCtx(function() {
return [createVNode(Transition, mergeProps({
name: "p-popover",
onEnter: $options.onEnter,
onLeave: $options.onLeave,
onAfterLeave: $options.onAfterLeave
}, _ctx.ptm("transition")), {
"default": withCtx(function() {
return [$data.visible ? withDirectives((openBlock(), createElementBlock("div", mergeProps({
key: 0,
ref: $options.containerRef,
role: "dialog",
"aria-modal": $data.visible,
onClick: _cache[3] || (_cache[3] = function() {
return $options.onOverlayClick && $options.onOverlayClick.apply($options, arguments);
}),
"class": _ctx.cx("root")
}, _ctx.ptmi("root")), [_ctx.$slots.container ? renderSlot(_ctx.$slots, "container", {
key: 0,
closeCallback: $options.hide,
keydownCallback: function keydownCallback(event) {
return $options.onButtonKeydown(event);
}
}) : (openBlock(), createElementBlock("div", mergeProps({
key: 1,
"class": _ctx.cx("content"),
onClick: _cache[0] || (_cache[0] = function() {
return $options.onContentClick && $options.onContentClick.apply($options, arguments);
}),
onMousedown: _cache[1] || (_cache[1] = function() {
return $options.onContentClick && $options.onContentClick.apply($options, arguments);
}),
onKeydown: _cache[2] || (_cache[2] = function() {
return $options.onContentKeydown && $options.onContentKeydown.apply($options, arguments);
})
}, _ctx.ptm("content")), [renderSlot(_ctx.$slots, "default")], 16))], 16, _hoisted_1$a)), [[_directive_focustrap]]) : createCommentVNode("", true)];
}),
_: 3
}, 16, ["onEnter", "onLeave", "onAfterLeave"])];
}),
_: 3
}, 8, ["appendTo"]);
}
script$8.render = render$6;
var theme$3 = function theme4(_ref) {
var dt2 = _ref.dt;
return "\n.p-divider-horizontal {\n display: flex;\n width: 100%;\n position: relative;\n align-items: center;\n margin: ".concat(dt2("divider.horizontal.margin"), ";\n padding: ").concat(dt2("divider.horizontal.padding"), ';\n}\n\n.p-divider-horizontal:before {\n position: absolute;\n display: block;\n top: 50%;\n left: 0;\n width: 100%;\n content: "";\n border-top: 1px solid ').concat(dt2("divider.border.color"), ";\n}\n\n.p-divider-horizontal .p-divider-content {\n padding: ").concat(dt2("divider.horizontal.content.padding"), ";\n}\n\n.p-divider-vertical {\n min-height: 100%;\n margin: 0 1rem;\n display: flex;\n position: relative;\n justify-content: center;\n margin: ").concat(dt2("divider.vertical.margin"), ";\n padding: ").concat(dt2("divider.vertical.padding"), ';\n}\n\n.p-divider-vertical:before {\n position: absolute;\n display: block;\n top: 0;\n left: 50%;\n height: 100%;\n content: "";\n border-left: 1px solid ').concat(dt2("divider.border.color"), ";\n}\n\n.p-divider.p-divider-vertical .p-divider-content {\n padding: ").concat(dt2("divider.vertical.content.padding"), ";\n}\n\n.p-divider-content {\n z-index: 1;\n background: ").concat(dt2("divider.content.background"), ";\n color: ").concat(dt2("divider.content.color"), ";\n}\n\n.p-divider-solid.p-divider-horizontal:before {\n border-top-style: solid;\n}\n\n.p-divider-solid.p-divider-vertical:before {\n border-left-style: solid;\n}\n\n.p-divider-dashed.p-divider-horizontal:before {\n border-top-style: dashed;\n}\n\n.p-divider-dashed.p-divider-vertical:before {\n border-left-style: dashed;\n}\n\n.p-divider-dotted.p-divider-horizontal:before {\n border-top-style: dotted;\n}\n\n.p-divider-dotted.p-divider-vertical:before {\n border-left-style: dotted;\n}\n");
};
var inlineStyles = {
root: function root(_ref2) {
var props = _ref2.props;
return {
justifyContent: props.layout === "horizontal" ? props.align === "center" || props.align === null ? "center" : props.align === "left" ? "flex-start" : props.align === "right" ? "flex-end" : null : null,
alignItems: props.layout === "vertical" ? props.align === "center" || props.align === null ? "center" : props.align === "top" ? "flex-start" : props.align === "bottom" ? "flex-end" : null : null
};
}
};
var classes$3 = {
root: function root2(_ref3) {
var props = _ref3.props;
return ["p-divider p-component", "p-divider-" + props.layout, "p-divider-" + props.type, {
"p-divider-left": props.layout === "horizontal" && (!props.align || props.align === "left")
}, {
"p-divider-center": props.layout === "horizontal" && props.align === "center"
}, {
"p-divider-right": props.layout === "horizontal" && props.align === "right"
}, {
"p-divider-top": props.layout === "vertical" && props.align === "top"
}, {
"p-divider-center": props.layout === "vertical" && (!props.align || props.align === "center")
}, {
"p-divider-bottom": props.layout === "vertical" && props.align === "bottom"
}];
},
content: "p-divider-content"
};
var DividerStyle = BaseStyle.extend({
name: "divider",
theme: theme$3,
classes: classes$3,
inlineStyles
});
var script$1$3 = {
name: "BaseDivider",
"extends": script$9,
props: {
align: {
type: String,
"default": null
},
layout: {
type: String,
"default": "horizontal"
},
type: {
type: String,
"default": "solid"
}
},
style: DividerStyle,
provide: function provide3() {
return {
$pcDivider: this,
$parentInstance: this
};
}
};
var script$7 = {
name: "Divider",
"extends": script$1$3,
inheritAttrs: false
};
var _hoisted_1$9 = ["aria-orientation"];
function render$5(_ctx, _cache, $props, $setup, $data, $options) {
return openBlock(), createElementBlock("div", mergeProps({
"class": _ctx.cx("root"),
style: _ctx.sx("root"),
role: "separator",
"aria-orientation": _ctx.layout
}, _ctx.ptmi("root")), [_ctx.$slots["default"] ? (openBlock(), createElementBlock("div", mergeProps({
key: 0,
"class": _ctx.cx("content")
}, _ctx.ptm("content")), [renderSlot(_ctx.$slots, "default")], 16)) : createCommentVNode("", true)], 16, _hoisted_1$9);
}
script$7.render = render$5;
var css2 = "\n.p-icon {\n display: inline-block;\n vertical-align: baseline;\n}\n\n.p-icon-spin {\n -webkit-animation: p-icon-spin 2s infinite linear;\n animation: p-icon-spin 2s infinite linear;\n}\n\n@-webkit-keyframes p-icon-spin {\n 0% {\n -webkit-transform: rotate(0deg);\n transform: rotate(0deg);\n }\n 100% {\n -webkit-transform: rotate(359deg);\n transform: rotate(359deg);\n }\n}\n\n@keyframes p-icon-spin {\n 0% {\n -webkit-transform: rotate(0deg);\n transform: rotate(0deg);\n }\n 100% {\n -webkit-transform: rotate(359deg);\n transform: rotate(359deg);\n }\n}\n";
var BaseIconStyle = BaseStyle.extend({
name: "baseicon",
css: css2
});
function _typeof$2(o) {
"@babel/helpers - typeof";
return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$2(o);
}
function ownKeys$1(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread$1(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys$1(Object(t), true).forEach(function(r2) {
_defineProperty$3(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$3(e, r, t) {
return (r = _toPropertyKey$2(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$2(t) {
var i = _toPrimitive$2(t, "string");
return "symbol" == _typeof$2(i) ? i : i + "";
}
function _toPrimitive$2(t, r) {
if ("object" != _typeof$2(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$2(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var script$6 = {
name: "BaseIcon",
"extends": script$9,
props: {
label: {
type: String,
"default": void 0
},
spin: {
type: Boolean,
"default": false
}
},
style: BaseIconStyle,
provide: function provide4() {
return {
$pcIcon: this,
$parentInstance: this
};
},
methods: {
pti: function pti() {
var isLabelEmpty = isEmpty(this.label);
return _objectSpread$1(_objectSpread$1({}, !this.isUnstyled && {
"class": ["p-icon", {
"p-icon-spin": this.spin
}]
}), {}, {
role: !isLabelEmpty ? "img" : void 0,
"aria-label": !isLabelEmpty ? this.label : void 0,
"aria-hidden": isLabelEmpty
});
}
}
};
var script$5 = {
name: "SpinnerIcon",
"extends": script$6
};
function render$4(_ctx, _cache, $props, $setup, $data, $options) {
return openBlock(), createElementBlock("svg", mergeProps({
width: "14",
height: "14",
viewBox: "0 0 14 14",
fill: "none",
xmlns: "http://www.w3.org/2000/svg"
}, _ctx.pti()), _cache[0] || (_cache[0] = [createBaseVNode("path", {
d: "M6.99701 14C5.85441 13.999 4.72939 13.7186 3.72012 13.1832C2.71084 12.6478 1.84795 11.8737 1.20673 10.9284C0.565504 9.98305 0.165424 8.89526 0.041387 7.75989C-0.0826496 6.62453 0.073125 5.47607 0.495122 4.4147C0.917119 3.35333 1.59252 2.4113 2.46241 1.67077C3.33229 0.930247 4.37024 0.413729 5.4857 0.166275C6.60117 -0.0811796 7.76026 -0.0520535 8.86188 0.251112C9.9635 0.554278 10.9742 1.12227 11.8057 1.90555C11.915 2.01493 11.9764 2.16319 11.9764 2.31778C11.9764 2.47236 11.915 2.62062 11.8057 2.73C11.7521 2.78503 11.688 2.82877 11.6171 2.85864C11.5463 2.8885 11.4702 2.90389 11.3933 2.90389C11.3165 2.90389 11.2404 2.8885 11.1695 2.85864C11.0987 2.82877 11.0346 2.78503 10.9809 2.73C9.9998 1.81273 8.73246 1.26138 7.39226 1.16876C6.05206 1.07615 4.72086 1.44794 3.62279 2.22152C2.52471 2.99511 1.72683 4.12325 1.36345 5.41602C1.00008 6.70879 1.09342 8.08723 1.62775 9.31926C2.16209 10.5513 3.10478 11.5617 4.29713 12.1803C5.48947 12.7989 6.85865 12.988 8.17414 12.7157C9.48963 12.4435 10.6711 11.7264 11.5196 10.6854C12.3681 9.64432 12.8319 8.34282 12.8328 7C12.8328 6.84529 12.8943 6.69692 13.0038 6.58752C13.1132 6.47812 13.2616 6.41667 13.4164 6.41667C13.5712 6.41667 13.7196 6.47812 13.8291 6.58752C13.9385 6.69692 14 6.84529 14 7C14 8.85651 13.2622 10.637 11.9489 11.9497C10.6356 13.2625 8.85432 14 6.99701 14Z",
fill: "currentColor"
}, null, -1)]), 16);
}
script$5.render = render$4;
var theme$2 = function theme5(_ref) {
var dt2 = _ref.dt;
return "\n.p-badge {\n display: inline-flex;\n border-radius: ".concat(dt2("badge.border.radius"), ";\n align-items: center;\n justify-content: center;\n padding: ").concat(dt2("badge.padding"), ";\n background: ").concat(dt2("badge.primary.background"), ";\n color: ").concat(dt2("badge.primary.color"), ";\n font-size: ").concat(dt2("badge.font.size"), ";\n font-weight: ").concat(dt2("badge.font.weight"), ";\n min-width: ").concat(dt2("badge.min.width"), ";\n height: ").concat(dt2("badge.height"), ";\n}\n\n.p-badge-dot {\n width: ").concat(dt2("badge.dot.size"), ";\n min-width: ").concat(dt2("badge.dot.size"), ";\n height: ").concat(dt2("badge.dot.size"), ";\n border-radius: 50%;\n padding: 0;\n}\n\n.p-badge-circle {\n padding: 0;\n border-radius: 50%;\n}\n\n.p-badge-secondary {\n background: ").concat(dt2("badge.secondary.background"), ";\n color: ").concat(dt2("badge.secondary.color"), ";\n}\n\n.p-badge-success {\n background: ").concat(dt2("badge.success.background"), ";\n color: ").concat(dt2("badge.success.color"), ";\n}\n\n.p-badge-info {\n background: ").concat(dt2("badge.info.background"), ";\n color: ").concat(dt2("badge.info.color"), ";\n}\n\n.p-badge-warn {\n background: ").concat(dt2("badge.warn.background"), ";\n color: ").concat(dt2("badge.warn.color"), ";\n}\n\n.p-badge-danger {\n background: ").concat(dt2("badge.danger.background"), ";\n color: ").concat(dt2("badge.danger.color"), ";\n}\n\n.p-badge-contrast {\n background: ").concat(dt2("badge.contrast.background"), ";\n color: ").concat(dt2("badge.contrast.color"), ";\n}\n\n.p-badge-sm {\n font-size: ").concat(dt2("badge.sm.font.size"), ";\n min-width: ").concat(dt2("badge.sm.min.width"), ";\n height: ").concat(dt2("badge.sm.height"), ";\n}\n\n.p-badge-lg {\n font-size: ").concat(dt2("badge.lg.font.size"), ";\n min-width: ").concat(dt2("badge.lg.min.width"), ";\n height: ").concat(dt2("badge.lg.height"), ";\n}\n\n.p-badge-xl {\n font-size: ").concat(dt2("badge.xl.font.size"), ";\n min-width: ").concat(dt2("badge.xl.min.width"), ";\n height: ").concat(dt2("badge.xl.height"), ";\n}\n");
};
var classes$2 = {
root: function root3(_ref2) {
var props = _ref2.props, instance = _ref2.instance;
return ["p-badge p-component", {
"p-badge-circle": isNotEmpty(props.value) && String(props.value).length === 1,
"p-badge-dot": isEmpty(props.value) && !instance.$slots["default"],
"p-badge-sm": props.size === "small",
"p-badge-lg": props.size === "large",
"p-badge-xl": props.size === "xlarge",
"p-badge-info": props.severity === "info",
"p-badge-success": props.severity === "success",
"p-badge-warn": props.severity === "warn",
"p-badge-danger": props.severity === "danger",
"p-badge-secondary": props.severity === "secondary",
"p-badge-contrast": props.severity === "contrast"
}];
}
};
var BadgeStyle = BaseStyle.extend({
name: "badge",
theme: theme$2,
classes: classes$2
});
var script$1$2 = {
name: "BaseBadge",
"extends": script$9,
props: {
value: {
type: [String, Number],
"default": null
},
severity: {
type: String,
"default": null
},
size: {
type: String,
"default": null
}
},
style: BadgeStyle,
provide: function provide5() {
return {
$pcBadge: this,
$parentInstance: this
};
}
};
var script$4 = {
name: "Badge",
"extends": script$1$2,
inheritAttrs: false
};
function render$3(_ctx, _cache, $props, $setup, $data, $options) {
return openBlock(), createElementBlock("span", mergeProps({
"class": _ctx.cx("root")
}, _ctx.ptmi("root")), [renderSlot(_ctx.$slots, "default", {}, function() {
return [createTextVNode(toDisplayString(_ctx.value), 1)];
})], 16);
}
script$4.render = render$3;
function _typeof$1(o) {
"@babel/helpers - typeof";
return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof$1(o);
}
function _defineProperty$2(e, r, t) {
return (r = _toPropertyKey$1(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey$1(t) {
var i = _toPrimitive$1(t, "string");
return "symbol" == _typeof$1(i) ? i : i + "";
}
function _toPrimitive$1(t, r) {
if ("object" != _typeof$1(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof$1(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var theme$1 = function theme6(_ref) {
var dt2 = _ref.dt;
return "\n.p-button {\n display: inline-flex;\n cursor: pointer;\n user-select: none;\n align-items: center;\n justify-content: center;\n overflow: hidden;\n position: relative;\n color: ".concat(dt2("button.primary.color"), ";\n background: ").concat(dt2("button.primary.background"), ";\n border: 1px solid ").concat(dt2("button.primary.border.color"), ";\n padding: ").concat(dt2("button.padding.y"), " ").concat(dt2("button.padding.x"), ";\n font-size: 1rem;\n font-family: inherit;\n font-feature-settings: inherit;\n transition: background ").concat(dt2("button.transition.duration"), ", color ").concat(dt2("button.transition.duration"), ", border-color ").concat(dt2("button.transition.duration"), ",\n outline-color ").concat(dt2("button.transition.duration"), ", box-shadow ").concat(dt2("button.transition.duration"), ";\n border-radius: ").concat(dt2("button.border.radius"), ";\n outline-color: transparent;\n gap: ").concat(dt2("button.gap"), ";\n}\n\n.p-button:disabled {\n cursor: default;\n}\n\n.p-button-icon-right {\n order: 1;\n}\n\n.p-button-icon-bottom {\n order: 2;\n}\n\n.p-button-icon-only {\n width: ").concat(dt2("button.icon.only.width"), ";\n padding-left: 0;\n padding-right: 0;\n gap: 0;\n}\n\n.p-button-icon-only.p-button-rounded {\n border-radius: 50%;\n height: ").concat(dt2("button.icon.only.width"), ";\n}\n\n.p-button-icon-only .p-button-label {\n visibility: hidden;\n width: 0;\n}\n\n.p-button-sm {\n font-size: ").concat(dt2("button.sm.font.size"), ";\n padding: ").concat(dt2("button.sm.padding.y"), " ").concat(dt2("button.sm.padding.x"), ";\n}\n\n.p-button-sm .p-button-icon {\n font-size: ").concat(dt2("button.sm.font.size"), ";\n}\n\n.p-button-lg {\n font-size: ").concat(dt2("button.lg.font.size"), ";\n padding: ").concat(dt2("button.lg.padding.y"), " ").concat(dt2("button.lg.padding.x"), ";\n}\n\n.p-button-lg .p-button-icon {\n font-size: ").concat(dt2("button.lg.font.size"), ";\n}\n\n.p-button-vertical {\n flex-direction: column;\n}\n\n.p-button-label {\n font-weight: ").concat(dt2("button.label.font.weight"), ";\n}\n\n.p-button-fluid {\n width: 100%;\n}\n\n.p-button-fluid.p-button-icon-only {\n width: ").concat(dt2("button.icon.only.width"), ";\n}\n\n.p-button:not(:disabled):hover {\n background: ").concat(dt2("button.primary.hover.background"), ";\n border: 1px solid ").concat(dt2("button.primary.hover.border.color"), ";\n color: ").concat(dt2("button.primary.hover.color"), ";\n}\n\n.p-button:not(:disabled):active {\n background: ").concat(dt2("button.primary.active.background"), ";\n border: 1px solid ").concat(dt2("button.primary.active.border.color"), ";\n color: ").concat(dt2("button.primary.active.color"), ";\n}\n\n.p-button:focus-visible {\n box-shadow: ").concat(dt2("button.primary.focus.ring.shadow"), ";\n outline: ").concat(dt2("button.focus.ring.width"), " ").concat(dt2("button.focus.ring.style"), " ").concat(dt2("button.primary.focus.ring.color"), ";\n outline-offset: ").concat(dt2("button.focus.ring.offset"), ";\n}\n\n.p-button .p-badge {\n min-width: ").concat(dt2("button.badge.size"), ";\n height: ").concat(dt2("button.badge.size"), ";\n line-height: ").concat(dt2("button.badge.size"), ";\n}\n\n.p-button-raised {\n box-shadow: ").concat(dt2("button.raised.shadow"), ";\n}\n\n.p-button-rounded {\n border-radius: ").concat(dt2("button.rounded.border.radius"), ";\n}\n\n.p-button-secondary {\n background: ").concat(dt2("button.secondary.background"), ";\n border: 1px solid ").concat(dt2("button.secondary.border.color"), ";\n color: ").concat(dt2("button.secondary.color"), ";\n}\n\n.p-button-secondary:not(:disabled):hover {\n background: ").concat(dt2("button.secondary.hover.background"), ";\n border: 1px solid ").concat(dt2("button.secondary.hover.border.color"), ";\n color: ").concat(dt2("button.secondary.hover.color"), ";\n}\n\n.p-button-secondary:not(:disabled):active {\n background: ").concat(dt2("button.secondary.active.background"), ";\n border: 1px solid ").concat(dt2("button.secondary.active.border.color"), ";\n color: ").concat(dt2("button.secondary.active.color"), ";\n}\n\n.p-button-secondary:focus-visible {\n outline-color: ").concat(dt2("button.secondary.focus.ring.color"), ";\n box-shadow: ").concat(dt2("button.secondary.focus.ring.shadow"), ";\n}\n\n.p-button-success {\n background: ").concat(dt2("button.success.background"), ";\n border: 1px solid ").concat(dt2("button.success.border.color"), ";\n color: ").concat(dt2("button.success.color"), ";\n}\n\n.p-button-success:not(:disabled):hover {\n background: ").concat(dt2("button.success.hover.background"), ";\n border: 1px solid ").concat(dt2("button.success.hover.border.color"), ";\n color: ").concat(dt2("button.success.hover.color"), ";\n}\n\n.p-button-success:not(:disabled):active {\n background: ").concat(dt2("button.success.active.background"), ";\n border: 1px solid ").concat(dt2("button.success.active.border.color"), ";\n color: ").concat(dt2("button.success.active.color"), ";\n}\n\n.p-button-success:focus-visible {\n outline-color: ").concat(dt2("button.success.focus.ring.color"), ";\n box-shadow: ").concat(dt2("button.success.focus.ring.shadow"), ";\n}\n\n.p-button-info {\n background: ").concat(dt2("button.info.background"), ";\n border: 1px solid ").concat(dt2("button.info.border.color"), ";\n color: ").concat(dt2("button.info.color"), ";\n}\n\n.p-button-info:not(:disabled):hover {\n background: ").concat(dt2("button.info.hover.background"), ";\n border: 1px solid ").concat(dt2("button.info.hover.border.color"), ";\n color: ").concat(dt2("button.info.hover.color"), ";\n}\n\n.p-button-info:not(:disabled):active {\n background: ").concat(dt2("button.info.active.background"), ";\n border: 1px solid ").concat(dt2("button.info.active.border.color"), ";\n color: ").concat(dt2("button.info.active.color"), ";\n}\n\n.p-button-info:focus-visible {\n outline-color: ").concat(dt2("button.info.focus.ring.color"), ";\n box-shadow: ").concat(dt2("button.info.focus.ring.shadow"), ";\n}\n\n.p-button-warn {\n background: ").concat(dt2("button.warn.background"), ";\n border: 1px solid ").concat(dt2("button.warn.border.color"), ";\n color: ").concat(dt2("button.warn.color"), ";\n}\n\n.p-button-warn:not(:disabled):hover {\n background: ").concat(dt2("button.warn.hover.background"), ";\n border: 1px solid ").concat(dt2("button.warn.hover.border.color"), ";\n color: ").concat(dt2("button.warn.hover.color"), ";\n}\n\n.p-button-warn:not(:disabled):active {\n background: ").concat(dt2("button.warn.active.background"), ";\n border: 1px solid ").concat(dt2("button.warn.active.border.color"), ";\n color: ").concat(dt2("button.warn.active.color"), ";\n}\n\n.p-button-warn:focus-visible {\n outline-color: ").concat(dt2("button.warn.focus.ring.color"), ";\n box-shadow: ").concat(dt2("button.warn.focus.ring.shadow"), ";\n}\n\n.p-button-help {\n background: ").concat(dt2("button.help.background"), ";\n border: 1px solid ").concat(dt2("button.help.border.color"), ";\n color: ").concat(dt2("button.help.color"), ";\n}\n\n.p-button-help:not(:disabled):hover {\n background: ").concat(dt2("button.help.hover.background"), ";\n border: 1px solid ").concat(dt2("button.help.hover.border.color"), ";\n color: ").concat(dt2("button.help.hover.color"), ";\n}\n\n.p-button-help:not(:disabled):active {\n background: ").concat(dt2("button.help.active.background"), ";\n border: 1px solid ").concat(dt2("button.help.active.border.color"), ";\n color: ").concat(dt2("button.help.active.color"), ";\n}\n\n.p-button-help:focus-visible {\n outline-color: ").concat(dt2("button.help.focus.ring.color"), ";\n box-shadow: ").concat(dt2("button.help.focus.ring.shadow"), ";\n}\n\n.p-button-danger {\n background: ").concat(dt2("button.danger.background"), ";\n border: 1px solid ").concat(dt2("button.danger.border.color"), ";\n color: ").concat(dt2("button.danger.color"), ";\n}\n\n.p-button-danger:not(:disabled):hover {\n background: ").concat(dt2("button.danger.hover.background"), ";\n border: 1px solid ").concat(dt2("button.danger.hover.border.color"), ";\n color: ").concat(dt2("button.danger.hover.color"), ";\n}\n\n.p-button-danger:not(:disabled):active {\n background: ").concat(dt2("button.danger.active.background"), ";\n border: 1px solid ").concat(dt2("button.danger.active.border.color"), ";\n color: ").concat(dt2("button.danger.active.color"), ";\n}\n\n.p-button-danger:focus-visible {\n outline-color: ").concat(dt2("button.danger.focus.ring.color"), ";\n box-shadow: ").concat(dt2("button.danger.focus.ring.shadow"), ";\n}\n\n.p-button-contrast {\n background: ").concat(dt2("button.contrast.background"), ";\n border: 1px solid ").concat(dt2("button.contrast.border.color"), ";\n color: ").concat(dt2("button.contrast.color"), ";\n}\n\n.p-button-contrast:not(:disabled):hover {\n background: ").concat(dt2("button.contrast.hover.background"), ";\n border: 1px solid ").concat(dt2("button.contrast.hover.border.color"), ";\n color: ").concat(dt2("button.contrast.hover.color"), ";\n}\n\n.p-button-contrast:not(:disabled):active {\n background: ").concat(dt2("button.contrast.active.background"), ";\n border: 1px solid ").concat(dt2("button.contrast.active.border.color"), ";\n color: ").concat(dt2("button.contrast.active.color"), ";\n}\n\n.p-button-contrast:focus-visible {\n outline-color: ").concat(dt2("button.contrast.focus.ring.color"), ";\n box-shadow: ").concat(dt2("button.contrast.focus.ring.shadow"), ";\n}\n\n.p-button-outlined {\n background: transparent;\n border-color: ").concat(dt2("button.outlined.primary.border.color"), ";\n color: ").concat(dt2("button.outlined.primary.color"), ";\n}\n\n.p-button-outlined:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.primary.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.primary.border.color"), ";\n color: ").concat(dt2("button.outlined.primary.color"), ";\n}\n\n.p-button-outlined:not(:disabled):active {\n background: ").concat(dt2("button.outlined.primary.active.background"), ";\n border-color: ").concat(dt2("button.outlined.primary.border.color"), ";\n color: ").concat(dt2("button.outlined.primary.color"), ";\n}\n\n.p-button-outlined.p-button-secondary {\n border-color: ").concat(dt2("button.outlined.secondary.border.color"), ";\n color: ").concat(dt2("button.outlined.secondary.color"), ";\n}\n\n.p-button-outlined.p-button-secondary:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.secondary.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.secondary.border.color"), ";\n color: ").concat(dt2("button.outlined.secondary.color"), ";\n}\n\n.p-button-outlined.p-button-secondary:not(:disabled):active {\n background: ").concat(dt2("button.outlined.secondary.active.background"), ";\n border-color: ").concat(dt2("button.outlined.secondary.border.color"), ";\n color: ").concat(dt2("button.outlined.secondary.color"), ";\n}\n\n.p-button-outlined.p-button-success {\n border-color: ").concat(dt2("button.outlined.success.border.color"), ";\n color: ").concat(dt2("button.outlined.success.color"), ";\n}\n\n.p-button-outlined.p-button-success:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.success.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.success.border.color"), ";\n color: ").concat(dt2("button.outlined.success.color"), ";\n}\n\n.p-button-outlined.p-button-success:not(:disabled):active {\n background: ").concat(dt2("button.outlined.success.active.background"), ";\n border-color: ").concat(dt2("button.outlined.success.border.color"), ";\n color: ").concat(dt2("button.outlined.success.color"), ";\n}\n\n.p-button-outlined.p-button-info {\n border-color: ").concat(dt2("button.outlined.info.border.color"), ";\n color: ").concat(dt2("button.outlined.info.color"), ";\n}\n\n.p-button-outlined.p-button-info:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.info.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.info.border.color"), ";\n color: ").concat(dt2("button.outlined.info.color"), ";\n}\n\n.p-button-outlined.p-button-info:not(:disabled):active {\n background: ").concat(dt2("button.outlined.info.active.background"), ";\n border-color: ").concat(dt2("button.outlined.info.border.color"), ";\n color: ").concat(dt2("button.outlined.info.color"), ";\n}\n\n.p-button-outlined.p-button-warn {\n border-color: ").concat(dt2("button.outlined.warn.border.color"), ";\n color: ").concat(dt2("button.outlined.warn.color"), ";\n}\n\n.p-button-outlined.p-button-warn:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.warn.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.warn.border.color"), ";\n color: ").concat(dt2("button.outlined.warn.color"), ";\n}\n\n.p-button-outlined.p-button-warn:not(:disabled):active {\n background: ").concat(dt2("button.outlined.warn.active.background"), ";\n border-color: ").concat(dt2("button.outlined.warn.border.color"), ";\n color: ").concat(dt2("button.outlined.warn.color"), ";\n}\n\n.p-button-outlined.p-button-help {\n border-color: ").concat(dt2("button.outlined.help.border.color"), ";\n color: ").concat(dt2("button.outlined.help.color"), ";\n}\n\n.p-button-outlined.p-button-help:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.help.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.help.border.color"), ";\n color: ").concat(dt2("button.outlined.help.color"), ";\n}\n\n.p-button-outlined.p-button-help:not(:disabled):active {\n background: ").concat(dt2("button.outlined.help.active.background"), ";\n border-color: ").concat(dt2("button.outlined.help.border.color"), ";\n color: ").concat(dt2("button.outlined.help.color"), ";\n}\n\n.p-button-outlined.p-button-danger {\n border-color: ").concat(dt2("button.outlined.danger.border.color"), ";\n color: ").concat(dt2("button.outlined.danger.color"), ";\n}\n\n.p-button-outlined.p-button-danger:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.danger.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.danger.border.color"), ";\n color: ").concat(dt2("button.outlined.danger.color"), ";\n}\n\n.p-button-outlined.p-button-danger:not(:disabled):active {\n background: ").concat(dt2("button.outlined.danger.active.background"), ";\n border-color: ").concat(dt2("button.outlined.danger.border.color"), ";\n color: ").concat(dt2("button.outlined.danger.color"), ";\n}\n\n.p-button-outlined.p-button-contrast {\n border-color: ").concat(dt2("button.outlined.contrast.border.color"), ";\n color: ").concat(dt2("button.outlined.contrast.color"), ";\n}\n\n.p-button-outlined.p-button-contrast:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.contrast.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.contrast.border.color"), ";\n color: ").concat(dt2("button.outlined.contrast.color"), ";\n}\n\n.p-button-outlined.p-button-contrast:not(:disabled):active {\n background: ").concat(dt2("button.outlined.contrast.active.background"), ";\n border-color: ").concat(dt2("button.outlined.contrast.border.color"), ";\n color: ").concat(dt2("button.outlined.contrast.color"), ";\n}\n\n.p-button-outlined.p-button-plain {\n border-color: ").concat(dt2("button.outlined.plain.border.color"), ";\n color: ").concat(dt2("button.outlined.plain.color"), ";\n}\n\n.p-button-outlined.p-button-plain:not(:disabled):hover {\n background: ").concat(dt2("button.outlined.plain.hover.background"), ";\n border-color: ").concat(dt2("button.outlined.plain.border.color"), ";\n color: ").concat(dt2("button.outlined.plain.color"), ";\n}\n\n.p-button-outlined.p-button-plain:not(:disabled):active {\n background: ").concat(dt2("button.outlined.plain.active.background"), ";\n border-color: ").concat(dt2("button.outlined.plain.border.color"), ";\n color: ").concat(dt2("button.outlined.plain.color"), ";\n}\n\n.p-button-text {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.primary.color"), ";\n}\n\n.p-button-text:not(:disabled):hover {\n background: ").concat(dt2("button.text.primary.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.primary.color"), ";\n}\n\n.p-button-text:not(:disabled):active {\n background: ").concat(dt2("button.text.primary.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.primary.color"), ";\n}\n\n.p-button-text.p-button-secondary {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.secondary.color"), ";\n}\n\n.p-button-text.p-button-secondary:not(:disabled):hover {\n background: ").concat(dt2("button.text.secondary.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.secondary.color"), ";\n}\n\n.p-button-text.p-button-secondary:not(:disabled):active {\n background: ").concat(dt2("button.text.secondary.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.secondary.color"), ";\n}\n\n.p-button-text.p-button-success {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.success.color"), ";\n}\n\n.p-button-text.p-button-success:not(:disabled):hover {\n background: ").concat(dt2("button.text.success.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.success.color"), ";\n}\n\n.p-button-text.p-button-success:not(:disabled):active {\n background: ").concat(dt2("button.text.success.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.success.color"), ";\n}\n\n.p-button-text.p-button-info {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.info.color"), ";\n}\n\n.p-button-text.p-button-info:not(:disabled):hover {\n background: ").concat(dt2("button.text.info.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.info.color"), ";\n}\n\n.p-button-text.p-button-info:not(:disabled):active {\n background: ").concat(dt2("button.text.info.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.info.color"), ";\n}\n\n.p-button-text.p-button-warn {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.warn.color"), ";\n}\n\n.p-button-text.p-button-warn:not(:disabled):hover {\n background: ").concat(dt2("button.text.warn.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.warn.color"), ";\n}\n\n.p-button-text.p-button-warn:not(:disabled):active {\n background: ").concat(dt2("button.text.warn.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.warn.color"), ";\n}\n\n.p-button-text.p-button-help {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.help.color"), ";\n}\n\n.p-button-text.p-button-help:not(:disabled):hover {\n background: ").concat(dt2("button.text.help.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.help.color"), ";\n}\n\n.p-button-text.p-button-help:not(:disabled):active {\n background: ").concat(dt2("button.text.help.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.help.color"), ";\n}\n\n.p-button-text.p-button-danger {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.danger.color"), ";\n}\n\n.p-button-text.p-button-danger:not(:disabled):hover {\n background: ").concat(dt2("button.text.danger.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.danger.color"), ";\n}\n\n.p-button-text.p-button-danger:not(:disabled):active {\n background: ").concat(dt2("button.text.danger.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.danger.color"), ";\n}\n\n.p-button-text.p-button-plain {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.text.plain.color"), ";\n}\n\n.p-button-text.p-button-plain:not(:disabled):hover {\n background: ").concat(dt2("button.text.plain.hover.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.plain.color"), ";\n}\n\n.p-button-text.p-button-plain:not(:disabled):active {\n background: ").concat(dt2("button.text.plain.active.background"), ";\n border-color: transparent;\n color: ").concat(dt2("button.text.plain.color"), ";\n}\n\n.p-button-link {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.link.color"), ";\n}\n\n.p-button-link:not(:disabled):hover {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.link.hover.color"), ";\n}\n\n.p-button-link:not(:disabled):hover .p-button-label {\n text-decoration: underline;\n}\n\n.p-button-link:not(:disabled):active {\n background: transparent;\n border-color: transparent;\n color: ").concat(dt2("button.link.active.color"), ";\n}\n");
};
var classes$1 = {
root: function root4(_ref2) {
var instance = _ref2.instance, props = _ref2.props;
return ["p-button p-component", _defineProperty$2(_defineProperty$2(_defineProperty$2(_defineProperty$2(_defineProperty$2(_defineProperty$2(_defineProperty$2(_defineProperty$2(_defineProperty$2({
"p-button-icon-only": instance.hasIcon && !props.label && !props.badge,
"p-button-vertical": (props.iconPos === "top" || props.iconPos === "bottom") && props.label,
"p-button-loading": props.loading,
"p-button-link": props.link
}, "p-button-".concat(props.severity), props.severity), "p-button-raised", props.raised), "p-button-rounded", props.rounded), "p-button-text", props.text), "p-button-outlined", props.outlined), "p-button-sm", props.size === "small"), "p-button-lg", props.size === "large"), "p-button-plain", props.plain), "p-button-fluid", instance.hasFluid)];
},
loadingIcon: "p-button-loading-icon",
icon: function icon(_ref4) {
var props = _ref4.props;
return ["p-button-icon", _defineProperty$2({}, "p-button-icon-".concat(props.iconPos), props.label)];
},
label: "p-button-label"
};
var ButtonStyle = BaseStyle.extend({
name: "button",
theme: theme$1,
classes: classes$1
});
var script$1$1 = {
name: "BaseButton",
"extends": script$9,
props: {
label: {
type: String,
"default": null
},
icon: {
type: String,
"default": null
},
iconPos: {
type: String,
"default": "left"
},
iconClass: {
type: [String, Object],
"default": null
},
badge: {
type: String,
"default": null
},
badgeClass: {
type: [String, Object],
"default": null
},
badgeSeverity: {
type: String,
"default": "secondary"
},
loading: {
type: Boolean,
"default": false
},
loadingIcon: {
type: String,
"default": void 0
},
as: {
type: [String, Object],
"default": "BUTTON"
},
asChild: {
type: Boolean,
"default": false
},
link: {
type: Boolean,
"default": false
},
severity: {
type: String,
"default": null
},
raised: {
type: Boolean,
"default": false
},
rounded: {
type: Boolean,
"default": false
},
text: {
type: Boolean,
"default": false
},
outlined: {
type: Boolean,
"default": false
},
size: {
type: String,
"default": null
},
plain: {
type: Boolean,
"default": false
},
fluid: {
type: Boolean,
"default": null
}
},
style: ButtonStyle,
provide: function provide6() {
return {
$pcButton: this,
$parentInstance: this
};
}
};
var script$3 = {
name: "Button",
"extends": script$1$1,
inheritAttrs: false,
inject: {
$pcFluid: {
"default": null
}
},
methods: {
getPTOptions: function getPTOptions(key) {
var _ptm = key === "root" ? this.ptmi : this.ptm;
return _ptm(key, {
context: {
disabled: this.disabled
}
});
}
},
computed: {
disabled: function disabled() {
return this.$attrs.disabled || this.$attrs.disabled === "" || this.loading;
},
defaultAriaLabel: function defaultAriaLabel() {
return this.label ? this.label + (this.badge ? " " + this.badge : "") : this.$attrs.ariaLabel;
},
hasIcon: function hasIcon() {
return this.icon || this.$slots.icon;
},
attrs: function attrs() {
return mergeProps(this.asAttrs, this.a11yAttrs, this.getPTOptions("root"));
},
asAttrs: function asAttrs() {
return this.as === "BUTTON" ? {
type: "button",
disabled: this.disabled
} : void 0;
},
a11yAttrs: function a11yAttrs() {
return {
"aria-label": this.defaultAriaLabel,
"data-pc-name": "button",
"data-p-disabled": this.disabled,
"data-p-severity": this.severity
};
},
hasFluid: function hasFluid() {
return isEmpty(this.fluid) ? !!this.$pcFluid : this.fluid;
}
},
components: {
SpinnerIcon: script$5,
Badge: script$4
},
directives: {
ripple: Ripple
}
};
function render$2(_ctx, _cache, $props, $setup, $data, $options) {
var _component_SpinnerIcon = resolveComponent("SpinnerIcon");
var _component_Badge = resolveComponent("Badge");
var _directive_ripple = resolveDirective("ripple");
return !_ctx.asChild ? withDirectives((openBlock(), createBlock(resolveDynamicComponent(_ctx.as), mergeProps({
key: 0,
"class": _ctx.cx("root")
}, $options.attrs), {
"default": withCtx(function() {
return [renderSlot(_ctx.$slots, "default", {}, function() {
return [_ctx.loading ? renderSlot(_ctx.$slots, "loadingicon", {
key: 0,
"class": normalizeClass([_ctx.cx("loadingIcon"), _ctx.cx("icon")])
}, function() {
return [_ctx.loadingIcon ? (openBlock(), createElementBlock("span", mergeProps({
key: 0,
"class": [_ctx.cx("loadingIcon"), _ctx.cx("icon"), _ctx.loadingIcon]
}, _ctx.ptm("loadingIcon")), null, 16)) : (openBlock(), createBlock(_component_SpinnerIcon, mergeProps({
key: 1,
"class": [_ctx.cx("loadingIcon"), _ctx.cx("icon")],
spin: ""
}, _ctx.ptm("loadingIcon")), null, 16, ["class"]))];
}) : renderSlot(_ctx.$slots, "icon", {
key: 1,
"class": normalizeClass([_ctx.cx("icon")])
}, function() {
return [_ctx.icon ? (openBlock(), createElementBlock("span", mergeProps({
key: 0,
"class": [_ctx.cx("icon"), _ctx.icon, _ctx.iconClass]
}, _ctx.ptm("icon")), null, 16)) : createCommentVNode("", true)];
}), createBaseVNode("span", mergeProps({
"class": _ctx.cx("label")
}, _ctx.ptm("label")), toDisplayString(_ctx.label || " "), 17), _ctx.badge ? (openBlock(), createBlock(_component_Badge, {
key: 2,
value: _ctx.badge,
"class": normalizeClass(_ctx.badgeClass),
severity: _ctx.badgeSeverity,
unstyled: _ctx.unstyled,
pt: _ctx.ptm("pcBadge")
}, null, 8, ["value", "class", "severity", "unstyled", "pt"])) : createCommentVNode("", true)];
})];
}),
_: 3
}, 16, ["class"])), [[_directive_ripple]]) : renderSlot(_ctx.$slots, "default", {
key: 1,
"class": normalizeClass(_ctx.cx("root")),
a11yAttrs: $options.a11yAttrs
});
}
script$3.render = render$2;
const _hoisted_1$8 = { class: "characters" };
const _hoisted_2$4 = { key: 1 };
const _hoisted_3$4 = { key: 2 };
const _sfc_main$8 = /* @__PURE__ */ defineComponent({
__name: "TallyItem",
props: ["item"],
setup(__props) {
const indexStore = useIndexStore();
const op = ref();
onMounted(() => {
});
const toggle2 = (event) => {
op.value.toggle(event);
};
return (_ctx, _cache) => {
return openBlock(), createElementBlock(Fragment, null, [
createVNode(unref(script$3), {
class: normalizeClass(["tallyItem", __props.item.subject.type.toLowerCase()]),
onClick: toggle2
}, {
default: withCtx(() => [
createTextVNode(toDisplayString(__props.item.subject.characters), 1)
]),
_: 1
}, 8, ["class"]),
createVNode(unref(script$8), {
ref_key: "op",
ref: op
}, {
default: withCtx(() => [
createBaseVNode("div", null, [
unref(indexStore).debug ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
createBaseVNode("div", null, toDisplayString(__props.item), 1),
createVNode(unref(script$7))
], 64)) : createCommentVNode("", true),
createBaseVNode("div", null, [
createBaseVNode("span", _hoisted_1$8, toDisplayString(__props.item.subject.characters), 1)
]),
createVNode(unref(script$7)),
createBaseVNode("div", null, [
_cache[0] || (_cache[0] = createBaseVNode("span", null, "Meanings: ", -1)),
createBaseVNode("span", null, toDisplayString(__props.item.subject.meanings.join(", ")), 1)
]),
__props.item.subject.type == "Kanji" ? (openBlock(), createElementBlock("div", _hoisted_2$4, [
_cache[4] || (_cache[4] = createBaseVNode("span", null, "Readings: ", -1)),
createBaseVNode("ul", null, [
__props.item.subject.kunyomi.length > 0 ? (openBlock(), createElementBlock("li", {
key: 0,
class: normalizeClass(__props.item.subject.primary_reading_type == "kunyomi" ? "primary" : "secondary")
}, [
_cache[1] || (_cache[1] = createBaseVNode("span", { class: "title" }, "Kunyomi: ", -1)),
createBaseVNode("span", null, toDisplayString(__props.item.subject.kunyomi.join(", ")), 1)
], 2)) : createCommentVNode("", true),
__props.item.subject.onyomi.length > 0 ? (openBlock(), createElementBlock("li", {
key: 1,
class: normalizeClass(__props.item.subject.primary_reading_type == "onyomi" ? "primary" : "secondary")
}, [
_cache[2] || (_cache[2] = createBaseVNode("span", { class: "title" }, "Onyomi: ", -1)),
createBaseVNode("span", null, toDisplayString(__props.item.subject.onyomi.join(", ")), 1)
], 2)) : createCommentVNode("", true),
__props.item.subject.nanori.length > 0 ? (openBlock(), createElementBlock("li", {
key: 2,
class: normalizeClass(__props.item.subject.primary_reading_type == "nanori" ? "primary" : "secondary")
}, [
_cache[3] || (_cache[3] = createBaseVNode("span", { class: "title" }, "Nanori: ", -1)),
createBaseVNode("span", null, toDisplayString(__props.item.subject.nanori.join(", ")), 1)
], 2)) : createCommentVNode("", true)
])
])) : (openBlock(), createElementBlock("div", _hoisted_3$4, [
_cache[5] || (_cache[5] = createBaseVNode("span", null, "Readings: ", -1)),
createBaseVNode("span", null, toDisplayString(__props.item.subject.readings.map((r) => r.reading).join(", ")), 1)
])),
__props.item.subject.type == "Kanji" || __props.item.subject.type == "Vocabulary" ? (openBlock(), createElementBlock(Fragment, { key: 3 }, [
createBaseVNode("div", null, [
_cache[6] || (_cache[6] = createBaseVNode("span", null, "Incorrect Meaning Attempts: ", -1)),
createBaseVNode("span", null, toDisplayString(__props.item.stats.meaning.incorrect), 1)
]),
createBaseVNode("div", null, [
_cache[7] || (_cache[7] = createBaseVNode("span", null, "Incorrect Reading Attempts: ", -1)),
createBaseVNode("span", null, toDisplayString(__props.item.stats.reading.incorrect), 1)
])
], 64)) : createCommentVNode("", true)
])
]),
_: 1
}, 512)
], 64);
};
}
});
const _export_sfc = (sfc, props) => {
const target = sfc.__vccOpts || sfc;
for (const [key, val] of props) {
target[key] = val;
}
return target;
};
const TallyItem = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__scopeId", "data-v-07c47839"]]);
const _hoisted_1$7 = { id: "divTally" };
const _hoisted_2$3 = { id: "divTallyCorrect" };
const _hoisted_3$3 = { class: "percent" };
const _hoisted_4$1 = { class: "outOf" };
const _hoisted_5$1 = { class: "tallyList" };
const _hoisted_6$1 = { id: "divTallyIncorrect" };
const _hoisted_7$1 = { class: "percent" };
const _hoisted_8$1 = { class: "outOf" };
const _hoisted_9$1 = { class: "tallyList" };
const _sfc_main$7 = /* @__PURE__ */ defineComponent({
__name: "Tally",
setup(__props) {
const reviewStore = useReviewsStore();
useIndexStore();
onMounted(() => {
});
return (_ctx, _cache) => {
return openBlock(), createElementBlock("div", _hoisted_1$7, [
createBaseVNode("div", _hoisted_2$3, [
createBaseVNode("div", null, [
_cache[0] || (_cache[0] = createBaseVNode("span", { class: "label" }, "Correct: ", -1)),
createBaseVNode("span", _hoisted_3$3, toDisplayString(unref(reviewStore).reviews.length == 0 ? 0 : (unref(reviewStore).reviewsCorrects.length * 100 / unref(reviewStore).reviews.length).toFixed(
2
)) + "%", 1),
createBaseVNode("span", _hoisted_4$1, " (" + toDisplayString(unref(reviewStore).reviewsCorrects.length) + "/" + toDisplayString(unref(reviewStore).reviews.length) + ")", 1),
createVNode(unref(script$7))
]),
createBaseVNode("div", _hoisted_5$1, [
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(reviewStore).reviewsCorrects, (i) => {
return openBlock(), createBlock(TallyItem, {
key: i.subject.id,
item: i
}, null, 8, ["item"]);
}), 128))
])
]),
createVNode(unref(script$7)),
createBaseVNode("div", _hoisted_6$1, [
createBaseVNode("div", null, [
_cache[1] || (_cache[1] = createBaseVNode("span", { class: "label" }, "Incorrect: ", -1)),
createBaseVNode("span", _hoisted_7$1, toDisplayString(unref(reviewStore).reviews.length == 0 ? 0 : (unref(reviewStore).reviewsIncorrects.length * 100 / unref(reviewStore).reviews.length).toFixed()) + "%", 1),
createBaseVNode("span", _hoisted_8$1, " (" + toDisplayString(unref(reviewStore).reviewsIncorrects.length) + "/" + toDisplayString(unref(reviewStore).reviews.length) + ")", 1),
createVNode(unref(script$7))
]),
createBaseVNode("div", _hoisted_9$1, [
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(reviewStore).reviewsIncorrects, (i) => {
return openBlock(), createBlock(TallyItem, {
key: i.subject.id,
item: i
}, null, 8, ["item"]);
}), 128))
])
])
]);
};
}
});
const _hoisted_1$6 = { class: "primary" };
const _hoisted_2$2 = {
key: 0,
class: "secondary"
};
const _hoisted_3$2 = {
key: 1,
class: "primary"
};
const _sfc_main$6 = /* @__PURE__ */ defineComponent({
__name: "Answer",
setup(__props) {
const reviewStore = useReviewsStore();
const indexStore = useIndexStore();
onMounted(() => {
});
return (_ctx, _cache) => {
var _a, _b, _c;
return unref(indexStore).showAnswers ? (openBlock(), createBlock(Teleport, {
key: 0,
to: "#answerDiv"
}, [
unref(reviewStore).shouldShow ? (openBlock(), createElementBlock("div", {
key: 0,
id: "answerDiv2",
class: normalizeClass([
unref(reviewStore).reviewPassed ? "correct" : "incorrect",
unref(reviewStore).correctAnswer == "" ? "unanswered" : ""
])
}, [
((_a = unref(reviewStore).detail) == null ? void 0 : _a.subjectWithStats.subject.type) == "Kanji" && ((_b = unref(reviewStore).detail) == null ? void 0 : _b.questionType) == "reading" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
createBaseVNode("span", _hoisted_1$6, toDisplayString(unref(reviewStore).correctAnswer == void 0 ? "" : unref(reviewStore).correctAnswer[0]), 1),
((_c = unref(reviewStore).correctAnswer) == null ? void 0 : _c.length) == 2 ? (openBlock(), createElementBlock("span", _hoisted_2$2, [
_cache[0] || (_cache[0] = createBaseVNode("br", null, null, -1)),
createTextVNode(toDisplayString(unref(reviewStore).correctAnswer == void 0 ? "" : unref(reviewStore).correctAnswer.length < 2 ? "" : unref(reviewStore).correctAnswer[1]), 1)
])) : createCommentVNode("", true)
], 64)) : (openBlock(), createElementBlock("span", _hoisted_3$2, toDisplayString(unref(reviewStore).correctAnswer), 1))
], 2)) : createCommentVNode("", true)
])) : createCommentVNode("", true);
};
}
});
const _hoisted_1$5 = { id: "debugDiv2" };
const _sfc_main$5 = /* @__PURE__ */ defineComponent({
__name: "Debug",
setup(__props) {
const reviewStore = useReviewsStore();
const indexStore = useIndexStore();
onMounted(() => {
});
return (_ctx, _cache) => {
return unref(indexStore).debug ? (openBlock(), createBlock(Teleport, {
key: 0,
to: "#debugDiv"
}, [
createBaseVNode("div", _hoisted_1$5, [
createBaseVNode("span", null, "reviewStore.detail: " + toDisplayString(unref(reviewStore).detail), 1),
_cache[0] || (_cache[0] = createBaseVNode("br", null, null, -1)),
createBaseVNode("span", null, "Correct Answer: " + toDisplayString(unref(reviewStore).correctAnswer), 1),
_cache[1] || (_cache[1] = createBaseVNode("br", null, null, -1)),
createBaseVNode("span", null, "Should Show: " + toDisplayString(unref(reviewStore).shouldShow), 1),
_cache[2] || (_cache[2] = createBaseVNode("br", null, null, -1)),
createBaseVNode("span", null, "showTallyLive: " + toDisplayString(unref(indexStore).settings.tally.showTallyLive), 1)
])
])) : createCommentVNode("", true);
};
}
});
const _hoisted_1$4 = { class: "itemDetails" };
const _hoisted_2$1 = { class: "single" };
const _hoisted_3$1 = { class: "characters single" };
const _hoisted_4 = { class: "radicals" };
const _hoisted_5 = ["onClick"];
const _hoisted_6 = { class: "meanings" };
const _hoisted_7 = { class: "primary" };
const _hoisted_8 = {
key: 0,
class: "secondary"
};
const _hoisted_9 = { key: 1 };
const _hoisted_10 = { class: "meaningMnemonic" };
const _hoisted_11 = ["innerHTML"];
const _hoisted_12 = { class: "meaningHint" };
const _hoisted_13 = { class: "readingMnemonic" };
const _hoisted_14 = ["innerHTML"];
const _hoisted_15 = { class: "readingHint" };
const _hoisted_16 = { class: "more single" };
const _hoisted_17 = ["href"];
const _sfc_main$4 = /* @__PURE__ */ defineComponent({
__name: "ItemDetails",
props: { item: Object },
setup(__props) {
const props = __props;
const indexStore = useIndexStore();
const reviewStore = useReviewsStore();
const selectedRadical = ref();
const itemType = computed(() => {
var _a;
return (_a = props.item) == null ? void 0 : _a.object;
});
const htmlFix = (html) => {
html = html.replaceAll("<radical>", '<mark title="Radical" class="radical-highlight">');
html = html.replaceAll("<kanji>", '<mark title="Kanji" class="kanji-highlight">');
html = html.replaceAll("</radical>", "</mark>");
html = html.replaceAll("</kanji>", "</mark>");
return html;
};
const op2 = ref();
const toggle2 = (event, item) => {
selectedRadical.value = item;
op2.value.toggle(event);
};
onMounted(() => {
});
return (_ctx, _cache) => {
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
const _component_Divider = resolveComponent("Divider");
return openBlock(), createElementBlock("div", _hoisted_1$4, [
unref(indexStore).debug ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
createBaseVNode("span", _hoisted_2$1, toDisplayString(__props.item), 1),
createVNode(_component_Divider)
], 64)) : createCommentVNode("", true),
createBaseVNode("div", _hoisted_3$1, [
createBaseVNode("span", null, toDisplayString((_a = __props.item) == null ? void 0 : _a.data.characters), 1)
]),
createBaseVNode("div", _hoisted_4, [
itemType.value == "kanji" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
_cache[1] || (_cache[1] = createBaseVNode("span", { class: "header" }, "Radicals:", -1)),
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(reviewStore).getComponents(((_b = __props.item) == null ? void 0 : _b.data.component_subject_ids) ?? []), (comp) => {
return openBlock(), createElementBlock("span", {
class: "item",
key: comp.id,
onClick: ($event) => toggle2($event, comp)
}, [
createTextVNode(toDisplayString(comp.data.characters) + ": " + toDisplayString(comp.data.meanings[0].meaning), 1),
_cache[0] || (_cache[0] = createBaseVNode("br", null, null, -1))
], 8, _hoisted_5);
}), 128))
], 64)) : createCommentVNode("", true)
]),
createBaseVNode("div", _hoisted_6, [
_cache[2] || (_cache[2] = createBaseVNode("span", { class: "header" }, "Meanings:", -1)),
createBaseVNode("span", _hoisted_7, toDisplayString((_d = (_c = __props.item) == null ? void 0 : _c.data.meanings.find((k) => k.primary)) == null ? void 0 : _d.meaning), 1),
((_e = __props.item) == null ? void 0 : _e.data.meanings.filter((k) => !k.primary).length) ?? 0 > 0 ? (openBlock(), createElementBlock("span", _hoisted_8, " , " + toDisplayString((_f = __props.item) == null ? void 0 : _f.data.meanings.filter((k) => !k.primary).map((o) => o.meaning).join(", ")), 1)) : createCommentVNode("", true)
]),
((_h = (_g = __props.item) == null ? void 0 : _g.data) == null ? void 0 : _h.auxiliary_meanings.filter((u) => u.type != "blacklist").length) ?? 0 > 0 ? (openBlock(), createElementBlock("div", _hoisted_9, [
_cache[3] || (_cache[3] = createBaseVNode("span", { class: "header" }, "Auxiliary Meanings: ", -1)),
createBaseVNode("span", null, toDisplayString((_i = __props.item) == null ? void 0 : _i.data.auxiliary_meanings.filter((u) => u.type != "blacklist").map((o) => o.meaning).join(", ")), 1)
])) : createCommentVNode("", true),
createBaseVNode("div", _hoisted_10, [
_cache[4] || (_cache[4] = createBaseVNode("span", { class: "header" }, "Meaning Mnemonic: ", -1)),
createBaseVNode("span", {
innerHTML: htmlFix(((_j = __props.item) == null ? void 0 : _j.data.meaning_mnemonic) ?? "")
}, null, 8, _hoisted_11)
]),
createBaseVNode("div", _hoisted_12, [
itemType.value == "kanji" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
_cache[5] || (_cache[5] = createBaseVNode("span", { class: "header" }, "Meaning Hint: ", -1)),
createBaseVNode("span", null, toDisplayString((_k = __props.item) == null ? void 0 : _k.data.meaning_hint), 1)
], 64)) : createCommentVNode("", true)
]),
createBaseVNode("div", _hoisted_13, [
itemType.value == "kanji" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
_cache[6] || (_cache[6] = createBaseVNode("span", { class: "header" }, "Reading Mnemonic: ", -1)),
createBaseVNode("span", {
innerHTML: htmlFix(((_l = __props.item) == null ? void 0 : _l.data.reading_mnemonic) ?? "")
}, null, 8, _hoisted_14)
], 64)) : createCommentVNode("", true)
]),
createBaseVNode("div", _hoisted_15, [
itemType.value == "kanji" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
_cache[7] || (_cache[7] = createBaseVNode("span", { class: "header" }, "Reading Hint: ", -1)),
createBaseVNode("span", null, toDisplayString((_m = __props.item) == null ? void 0 : _m.data.reading_hint), 1)
], 64)) : createCommentVNode("", true)
]),
createVNode(_component_Divider),
createBaseVNode("div", _hoisted_16, [
createBaseVNode("a", {
href: (_n = __props.item) == null ? void 0 : _n.data.document_url,
target: "_blank"
}, "More Info", 8, _hoisted_17)
])
]);
};
}
});
const _hoisted_1$3 = {
key: 0,
id: "breakdownDiv2"
};
const _hoisted_2 = ["onClick"];
const _hoisted_3 = ["onClick"];
const _sfc_main$3 = /* @__PURE__ */ defineComponent({
__name: "Breakdown",
setup(__props) {
const reviewStore = useReviewsStore();
const indexStore = useIndexStore();
const op = ref();
const selectedItem = ref();
onMounted(() => {
});
const toggle2 = (event, item) => {
selectedItem.value = item;
};
return (_ctx, _cache) => {
return unref(indexStore).settings.breakdown.showBreakdown ? (openBlock(), createBlock(Teleport, {
key: 0,
to: "#breakdownDiv"
}, [
unref(reviewStore).shouldShowBreakdown ? (openBlock(), createElementBlock("div", _hoisted_1$3, [
unref(reviewStore).itemDetails ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
unref(reviewStore).itemDetails[0].object == "vocabulary" ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(unref(reviewStore).getComponents(
unref(reviewStore).itemDetails[0].data.component_subject_ids
), (comp) => {
return openBlock(), createElementBlock("span", {
key: comp.id,
onClick: ($event) => toggle2($event, comp)
}, [
createTextVNode(toDisplayString(comp.data.slug) + ": " + toDisplayString(comp.data.meanings[0].meaning), 1),
_cache[0] || (_cache[0] = createBaseVNode("br", null, null, -1))
], 8, _hoisted_2);
}), 128)) : unref(reviewStore).itemDetails[0].object == "kanji" ? (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(unref(reviewStore).getComponents(
unref(reviewStore).itemDetails[0].data.component_subject_ids
), (comp) => {
return openBlock(), createElementBlock("span", {
key: comp.id,
onClick: ($event) => toggle2($event, comp)
}, [
createTextVNode(toDisplayString(comp.data.characters) + ": " + toDisplayString(comp.data.meanings[0].meaning), 1),
_cache[1] || (_cache[1] = createBaseVNode("br", null, null, -1))
], 8, _hoisted_3);
}), 128)) : createCommentVNode("", true)
], 64)) : createCommentVNode("", true)
])) : createCommentVNode("", true),
createVNode(unref(script$8), {
ref_key: "op",
ref: op
}, {
default: withCtx(() => [
unref(reviewStore).itemDetails[0].object ? (openBlock(), createBlock(_sfc_main$4, {
key: 0,
item: selectedItem.value
}, null, 8, ["item"])) : unref(reviewStore).itemDetails[0].object == "kanji" ? (openBlock(), createBlock(_sfc_main$4, {
key: 1,
item: selectedItem.value
}, null, 8, ["item"])) : createCommentVNode("", true)
]),
_: 1
}, 512)
])) : createCommentVNode("", true);
};
}
});
const useChangelogStore = /* @__PURE__ */ defineStore(
"changelog",
() => {
const lastLoadedVersion = ref(0);
const currentVersion = ref(1.06);
const showLog = ref(false);
const showSince = ref(0);
const log = ref([
{
version: 1,
changes: [
"Breakdown only shows on meaning",
"Fix vocabulary breakdown for single character items"
]
},
{
version: 1.01,
changes: ["Support for Breeze Dark userstyle", "Fix NaN on tally before any reviews done"]
}
]);
function checkLog() {
showLog.value = currentVersion.value > lastLoadedVersion.value && lastLoadedVersion.value > 0;
showSince.value = lastLoadedVersion.value;
lastLoadedVersion.value = currentVersion.value;
const div = document.getElementById("reviewsPlusChangelog");
if (showLog.value && logSinceLast.value.length > 0) {
if (div == null ? void 0 : div.classList.contains("hidden")) {
div == null ? void 0 : div.classList.remove("hidden");
}
} else {
if (!(div == null ? void 0 : div.classList.contains("hidden"))) {
div == null ? void 0 : div.classList.add("hidden");
}
}
}
const logSinceLast = computed(
() => log.value.filter((i) => i.version > showSince.value)
);
return { log, checkLog, logSinceLast, showLog, lastLoadedVersion };
},
{
persist: {
key: "WaniKaniReviewsPlus",
pick: ["lastLoadedVersion"]
}
}
);
var script$2 = {
name: "TimesIcon",
"extends": script$6
};
function render$1(_ctx, _cache, $props, $setup, $data, $options) {
return openBlock(), createElementBlock("svg", mergeProps({
width: "14",
height: "14",
viewBox: "0 0 14 14",
fill: "none",
xmlns: "http://www.w3.org/2000/svg"
}, _ctx.pti()), _cache[0] || (_cache[0] = [createBaseVNode("path", {
d: "M8.01186 7.00933L12.27 2.75116C12.341 2.68501 12.398 2.60524 12.4375 2.51661C12.4769 2.42798 12.4982 2.3323 12.4999 2.23529C12.5016 2.13827 12.4838 2.0419 12.4474 1.95194C12.4111 1.86197 12.357 1.78024 12.2884 1.71163C12.2198 1.64302 12.138 1.58893 12.0481 1.55259C11.9581 1.51625 11.8617 1.4984 11.7647 1.50011C11.6677 1.50182 11.572 1.52306 11.4834 1.56255C11.3948 1.60204 11.315 1.65898 11.2488 1.72997L6.99067 5.98814L2.7325 1.72997C2.59553 1.60234 2.41437 1.53286 2.22718 1.53616C2.03999 1.53946 1.8614 1.61529 1.72901 1.74767C1.59663 1.88006 1.5208 2.05865 1.5175 2.24584C1.5142 2.43303 1.58368 2.61419 1.71131 2.75116L5.96948 7.00933L1.71131 11.2675C1.576 11.403 1.5 11.5866 1.5 11.7781C1.5 11.9696 1.576 12.1532 1.71131 12.2887C1.84679 12.424 2.03043 12.5 2.2219 12.5C2.41338 12.5 2.59702 12.424 2.7325 12.2887L6.99067 8.03052L11.2488 12.2887C11.3843 12.424 11.568 12.5 11.7594 12.5C11.9509 12.5 12.1346 12.424 12.27 12.2887C12.4053 12.1532 12.4813 11.9696 12.4813 11.7781C12.4813 11.5866 12.4053 11.403 12.27 11.2675L8.01186 7.00933Z",
fill: "currentColor"
}, null, -1)]), 16);
}
script$2.render = render$1;
var theme7 = function theme8(_ref) {
var dt2 = _ref.dt;
return "\n.p-message {\n border-radius: ".concat(dt2("message.border.radius"), ";\n outline-width: ").concat(dt2("message.border.width"), ";\n outline-style: solid;\n}\n\n.p-message-content {\n display: flex;\n align-items: center;\n padding: ").concat(dt2("message.content.padding"), ";\n gap: ").concat(dt2("message.content.gap"), ";\n height: 100%;\n}\n\n.p-message-icon {\n flex-shrink: 0;\n}\n\n.p-message-close-button {\n display: flex;\n align-items: center;\n justify-content: center;\n flex-shrink: 0;\n margin: 0 0 0 auto;\n overflow: hidden;\n position: relative;\n width: ").concat(dt2("message.close.button.width"), ";\n height: ").concat(dt2("message.close.button.height"), ";\n border-radius: ").concat(dt2("message.close.button.border.radius"), ";\n background: transparent;\n transition: background ").concat(dt2("message.transition.duration"), ", color ").concat(dt2("message.transition.duration"), ", outline-color ").concat(dt2("message.transition.duration"), ", box-shadow ").concat(dt2("message.transition.duration"), ", opacity 0.3s;\n outline-color: transparent;\n color: inherit;\n padding: 0;\n border: none;\n cursor: pointer;\n user-select: none;\n}\n\n.p-message-close-icon {\n font-size: ").concat(dt2("message.close.icon.size"), ";\n width: ").concat(dt2("message.close.icon.size"), ";\n height: ").concat(dt2("message.close.icon.size"), ";\n}\n\n.p-message-close-button:focus-visible {\n outline-width: ").concat(dt2("message.close.button.focus.ring.width"), ";\n outline-style: ").concat(dt2("message.close.button.focus.ring.style"), ";\n outline-offset: ").concat(dt2("message.close.button.focus.ring.offset"), ";\n}\n\n.p-message-info {\n background: ").concat(dt2("message.info.background"), ";\n outline-color: ").concat(dt2("message.info.border.color"), ";\n color: ").concat(dt2("message.info.color"), ";\n box-shadow: ").concat(dt2("message.info.shadow"), ";\n}\n\n.p-message-info .p-message-close-button:focus-visible {\n outline-color: ").concat(dt2("message.info.close.button.focus.ring.color"), ";\n box-shadow: ").concat(dt2("message.info.close.button.focus.ring.shadow"), ";\n}\n\n.p-message-info .p-message-close-button:hover {\n background: ").concat(dt2("message.info.close.button.hover.background"), ";\n}\n\n.p-message-success {\n background: ").concat(dt2("message.success.background"), ";\n outline-color: ").concat(dt2("message.success.border.color"), ";\n color: ").concat(dt2("message.success.color"), ";\n box-shadow: ").concat(dt2("message.success.shadow"), ";\n}\n\n.p-message-success .p-message-close-button:focus-visible {\n outline-color: ").concat(dt2("message.success.close.button.focus.ring.color"), ";\n box-shadow: ").concat(dt2("message.success.close.button.focus.ring.shadow"), ";\n}\n\n.p-message-success .p-message-close-button:hover {\n background: ").concat(dt2("message.success.close.button.hover.background"), ";\n}\n\n.p-message-warn {\n background: ").concat(dt2("message.warn.background"), ";\n outline-color: ").concat(dt2("message.warn.border.color"), ";\n color: ").concat(dt2("message.warn.color"), ";\n box-shadow: ").concat(dt2("message.warn.shadow"), ";\n}\n\n.p-message-warn .p-message-close-button:focus-visible {\n outline-color: ").concat(dt2("message.warn.close.button.focus.ring.color"), ";\n box-shadow: ").concat(dt2("message.warn.close.button.focus.ring.shadow"), ";\n}\n\n.p-message-warn .p-message-close-button:hover {\n background: ").concat(dt2("message.warn.close.button.hover.background"), ";\n}\n\n.p-message-error {\n background: ").concat(dt2("message.error.background"), ";\n outline-color: ").concat(dt2("message.error.border.color"), ";\n color: ").concat(dt2("message.error.color"), ";\n box-shadow: ").concat(dt2("message.error.shadow"), ";\n}\n\n.p-message-error .p-message-close-button:focus-visible {\n outline-color: ").concat(dt2("message.error.close.button.focus.ring.color"), ";\n box-shadow: ").concat(dt2("message.error.close.button.focus.ring.shadow"), ";\n}\n\n.p-message-error .p-message-close-button:hover {\n background: ").concat(dt2("message.error.close.button.hover.background"), ";\n}\n\n.p-message-secondary {\n background: ").concat(dt2("message.secondary.background"), ";\n outline-color: ").concat(dt2("message.secondary.border.color"), ";\n color: ").concat(dt2("message.secondary.color"), ";\n box-shadow: ").concat(dt2("message.secondary.shadow"), ";\n}\n\n.p-message-secondary .p-message-close-button:focus-visible {\n outline-color: ").concat(dt2("message.secondary.close.button.focus.ring.color"), ";\n box-shadow: ").concat(dt2("message.secondary.close.button.focus.ring.shadow"), ";\n}\n\n.p-message-secondary .p-message-close-button:hover {\n background: ").concat(dt2("message.secondary.close.button.hover.background"), ";\n}\n\n.p-message-contrast {\n background: ").concat(dt2("message.contrast.background"), ";\n outline-color: ").concat(dt2("message.contrast.border.color"), ";\n color: ").concat(dt2("message.contrast.color"), ";\n box-shadow: ").concat(dt2("message.contrast.shadow"), ";\n}\n\n.p-message-contrast .p-message-close-button:focus-visible {\n outline-color: ").concat(dt2("message.contrast.close.button.focus.ring.color"), ";\n box-shadow: ").concat(dt2("message.contrast.close.button.focus.ring.shadow"), ";\n}\n\n.p-message-contrast .p-message-close-button:hover {\n background: ").concat(dt2("message.contrast.close.button.hover.background"), ";\n}\n\n.p-message-text {\n font-size: ").concat(dt2("message.text.font.size"), ";\n font-weight: ").concat(dt2("message.text.font.weight"), ";\n}\n\n.p-message-icon {\n font-size: ").concat(dt2("message.icon.size"), ";\n width: ").concat(dt2("message.icon.size"), ";\n height: ").concat(dt2("message.icon.size"), ";\n}\n\n.p-message-enter-from {\n opacity: 0;\n}\n\n.p-message-enter-active {\n transition: opacity 0.3s;\n}\n\n.p-message.p-message-leave-from {\n max-height: 1000px;\n}\n\n.p-message.p-message-leave-to {\n max-height: 0;\n opacity: 0;\n margin: 0;\n}\n\n.p-message-leave-active {\n overflow: hidden;\n transition: max-height 0.45s cubic-bezier(0, 1, 0, 1), opacity 0.3s, margin 0.3s;\n}\n\n.p-message-leave-active .p-message-close-button {\n opacity: 0;\n}\n");
};
var classes = {
root: function root5(_ref2) {
var props = _ref2.props;
return "p-message p-component p-message-" + props.severity;
},
content: "p-message-content",
icon: "p-message-icon",
text: "p-message-text",
closeButton: "p-message-close-button",
closeIcon: "p-message-close-icon"
};
var MessageStyle = BaseStyle.extend({
name: "message",
theme: theme7,
classes
});
var script$1 = {
name: "BaseMessage",
"extends": script$9,
props: {
severity: {
type: String,
"default": "info"
},
closable: {
type: Boolean,
"default": false
},
life: {
type: Number,
"default": null
},
icon: {
type: String,
"default": void 0
},
closeIcon: {
type: String,
"default": void 0
},
closeButtonProps: {
type: null,
"default": null
}
},
style: MessageStyle,
provide: function provide7() {
return {
$pcMessage: this,
$parentInstance: this
};
}
};
var script = {
name: "Message",
"extends": script$1,
inheritAttrs: false,
emits: ["close", "life-end"],
timeout: null,
data: function data3() {
return {
visible: true
};
},
mounted: function mounted5() {
var _this = this;
if (this.life) {
setTimeout(function() {
_this.visible = false;
_this.$emit("life-end");
}, this.life);
}
},
methods: {
close: function close(event) {
this.visible = false;
this.$emit("close", event);
}
},
computed: {
closeAriaLabel: function closeAriaLabel() {
return this.$primevue.config.locale.aria ? this.$primevue.config.locale.aria.close : void 0;
}
},
directives: {
ripple: Ripple
},
components: {
TimesIcon: script$2
}
};
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof(o);
}
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
_defineProperty$1(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _defineProperty$1(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
if ("object" != _typeof(t) || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != _typeof(i)) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
var _hoisted_1$2 = ["aria-label"];
function render(_ctx, _cache, $props, $setup, $data, $options) {
var _component_TimesIcon = resolveComponent("TimesIcon");
var _directive_ripple = resolveDirective("ripple");
return openBlock(), createBlock(Transition, mergeProps({
name: "p-message",
appear: ""
}, _ctx.ptmi("transition")), {
"default": withCtx(function() {
return [withDirectives(createBaseVNode("div", mergeProps({
"class": _ctx.cx("root"),
role: "alert",
"aria-live": "assertive",
"aria-atomic": "true"
}, _ctx.ptm("root")), [_ctx.$slots.container ? renderSlot(_ctx.$slots, "container", {
key: 0,
closeCallback: $options.close
}) : (openBlock(), createElementBlock("div", mergeProps({
key: 1,
"class": _ctx.cx("content")
}, _ctx.ptm("content")), [renderSlot(_ctx.$slots, "icon", {
"class": normalizeClass(_ctx.cx("icon"))
}, function() {
return [(openBlock(), createBlock(resolveDynamicComponent(_ctx.icon ? "span" : null), mergeProps({
"class": [_ctx.cx("icon"), _ctx.icon]
}, _ctx.ptm("icon")), null, 16, ["class"]))];
}), _ctx.$slots["default"] ? (openBlock(), createElementBlock("div", mergeProps({
key: 0,
"class": _ctx.cx("text")
}, _ctx.ptm("text")), [renderSlot(_ctx.$slots, "default")], 16)) : createCommentVNode("", true), _ctx.closable ? withDirectives((openBlock(), createElementBlock("button", mergeProps({
key: 1,
"class": _ctx.cx("closeButton"),
"aria-label": $options.closeAriaLabel,
type: "button",
onClick: _cache[0] || (_cache[0] = function($event) {
return $options.close($event);
})
}, _objectSpread(_objectSpread({}, _ctx.closeButtonProps), _ctx.ptm("closeButton"))), [renderSlot(_ctx.$slots, "closeicon", {}, function() {
return [_ctx.closeIcon ? (openBlock(), createElementBlock("i", mergeProps({
key: 0,
"class": [_ctx.cx("closeIcon"), _ctx.closeIcon]
}, _ctx.ptm("closeIcon")), null, 16)) : (openBlock(), createBlock(_component_TimesIcon, mergeProps({
key: 1,
"class": [_ctx.cx("closeIcon"), _ctx.closeIcon]
}, _ctx.ptm("closeIcon")), null, 16, ["class"]))];
})], 16, _hoisted_1$2)), [[_directive_ripple]]) : createCommentVNode("", true)], 16))], 16), [[vShow, $data.visible]])];
}),
_: 3
}, 16);
}
script.render = render;
const _hoisted_1$1 = { class: "number" };
const _sfc_main$2 = /* @__PURE__ */ defineComponent({
__name: "Changelog",
setup(__props) {
const changelogStore = useChangelogStore();
onMounted(() => {
changelogStore.checkLog();
});
return (_ctx, _cache) => {
return openBlock(), createBlock(Teleport, { to: "#reviewsPlusChangelog" }, [
unref(changelogStore).showLog ? (openBlock(), createBlock(unref(script), {
key: 0,
closable: ""
}, {
default: withCtx(() => [
_cache[0] || (_cache[0] = createBaseVNode("span", { class: "title" }, "WaniKani Reviews Plus has been updated", -1)),
createBaseVNode("ul", null, [
(openBlock(true), createElementBlock(Fragment, null, renderList(unref(changelogStore).logSinceLast, (version2, index2) => {
return openBlock(), createElementBlock("li", {
class: "version",
key: index2
}, [
createBaseVNode("span", _hoisted_1$1, toDisplayString(version2.version.toFixed(2)) + ":", 1),
createBaseVNode("ul", null, [
(openBlock(true), createElementBlock(Fragment, null, renderList(version2.changes, (change, index22) => {
return openBlock(), createElementBlock("li", { key: index22 }, toDisplayString(change), 1);
}), 128))
])
]);
}), 128))
])
]),
_: 1
})) : createCommentVNode("", true)
]);
};
}
});
const Changelog = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-04434c1c"]]);
const _hoisted_1 = {
key: 1,
id: "dashboardTallyDiv"
};
const _sfc_main$1 = /* @__PURE__ */ defineComponent({
__name: "HomeView",
setup(__props) {
const reviewsStore = useReviewsStore();
const indexStore = useIndexStore();
onMounted(() => {
});
const closeTally = () => {
var _a;
document.querySelector("#turbo-body");
(_a = document.querySelector("#turbo-body")) == null ? void 0 : _a.classList.remove("hidden");
reviewsStore.reviews = [];
};
return (_ctx, _cache) => {
return openBlock(), createElementBlock("main", null, [
unref(reviewsStore).reviewsLoaded ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
createVNode(_sfc_main$6),
unref(indexStore).settings.tally.showTallyLive ? (openBlock(), createBlock(Teleport, {
key: 0,
to: "#tallyDiv"
}, [
createVNode(_sfc_main$7)
])) : createCommentVNode("", true),
createVNode(_sfc_main$3),
createVNode(_sfc_main$5)
], 64)) : createCommentVNode("", true),
unref(indexStore).dashboardLoaded && unref(reviewsStore).reviews.length > 0 ? (openBlock(), createElementBlock("div", _hoisted_1, [
createVNode(unref(script$3), {
onClick: closeTally,
id: "btnCloseTally"
}, {
default: withCtx(() => _cache[0] || (_cache[0] = [
createTextVNode("Close")
])),
_: 1
}),
createVNode(_sfc_main$7)
])) : createCommentVNode("", true),
unref(indexStore).dashboardLoaded ? (openBlock(), createBlock(Changelog, { key: 2 })) : createCommentVNode("", true)
]);
};
}
});
const router = createRouter({
// history: createWebHistory(import.meta.env.BASE_URL),
// history: createWebHashHistory(),
history: createMemoryHistory(),
routes: [
{
path: "/",
name: "home",
component: _sfc_main$1
}
]
});
const scriptName = "WaniKani Reviews Plus";
const scriptId = "waniKaniReviewsPlus";
let settingsDialog;
const wkofCheck = () => {
console.log("Checking for WaniKani Open Framework");
if (!window.wkof) {
if (confirm(
scriptName + " requires Wanikani Open Framework.\nDo you want to be forwarded to the installation instructions?"
)) {
window.location.href = "https://community.wanikani.com/t/instructions-installing-wanikani-open-framework/28549";
}
}
};
function installMenu() {
const config = {
name: scriptId,
submenu: "Settings",
title: scriptName,
on_click: openSettings
};
wkof.Menu.insert_script_link(config);
}
function loadSettings() {
const indexStore = useIndexStore();
wkof.Settings.load(indexStore.scriptId, indexStore.defaultSettings).then((ret) => {
indexStore.settings = ret;
});
}
function openSettings() {
const indexStore = useIndexStore();
const config = {
script_id: indexStore.scriptId,
title: indexStore.scriptName,
// pre_open: settings_pre_open,
// on_refresh: refresh_settings,
on_save: () => {
settingsDialog.save();
console.log("Settings saved!");
},
settings: {
answers: {
type: "group",
label: "Answers",
content: {
showOnWrong: {
type: "checkbox",
label: "Show On Wrong Answers",
path: "@answers.showOnWrong",
default: indexStore.defaultSettings.answers.showOnWrong
},
showOnRight: {
type: "checkbox",
label: "Show On Right Answers",
path: "@answers.showOnRight",
default: indexStore.defaultSettings.answers.showOnRight
},
showOnRightSolo: {
type: "checkbox",
label: "Even When A Single Answer",
path: "@answers.showOnRightSolo",
default: indexStore.defaultSettings.answers.showOnRightSolo
}
}
},
breakdown: {
type: "group",
label: "Breakdown",
content: {
showBreakdown: {
type: "checkbox",
label: "Show Breakdown",
path: "@breakdown.showBreakdown",
default: indexStore.defaultSettings.breakdown.showBreakdown
}
}
},
tally: {
type: "group",
label: "Tally (Experimental)",
content: {
showTally: {
type: "checkbox",
label: "Show Tally",
path: "@tally.showTally",
default: indexStore.defaultSettings.tally.showTally
},
showTallyLive: {
type: "checkbox",
label: "Show Tally Live",
path: "@tally.showTallyLive",
default: indexStore.defaultSettings.tally.showTallyLive
}
}
}
}
};
settingsDialog = new wkof.Settings(config);
settingsDialog.open();
}
const turboUrl = "https://update.greasyfork.org/scripts/501980/1426289/Wanikani%20Open%20Framework%20Turbo%20Events.user.js";
const loadTurbo = () => {
wkof.load_script(
turboUrl,
/* use_cache */
true
);
};
const scriptUrl = "https://update.greasyfork.org/scripts/501980/1426289/Wanikani%20Open%20Framework%20Turbo%20Events.user.js";
const setUpListeners = (callback) => {
wkof.load_script(
scriptUrl,
/* use_cache */
true
);
wkof.ready("TurboEvents").then(() => {
console.log("turbo events ready");
const urls = [
//@ts-ignore
wkof.turbo.common.locations.reviews,
//@ts-ignore
wkof.turbo.common.locations.lessons_quiz,
/^https:\/\/www\.wanikani\.com\/recent-mistakes\/[\d-]+\/quiz.*\/?$/,
/^https:\/\/www\.wanikani\.com\/subjects\/extra_study.*$/
];
wkof.turbo.add_typical_page_listener(callback, urls);
wkof.turbo.on.common.dashboard(() => {
const indexStore = useIndexStore();
indexStore.dashboardLoaded = false;
installMenu(), showResults();
indexStore.dashboardLoaded = true;
});
});
};
function showResults() {
const reviewsStore = useReviewsStore();
const indexStore = useIndexStore();
if (reviewsStore.reviews.length > 0 && indexStore.settings.tally.showTally) {
showTally();
}
}
function showTally() {
const spotBefore = document.querySelector("#turbo-body");
if (spotBefore == null) return;
spotBefore.classList.add("hidden");
window.addEventListener("keypress", function(e) {
if (e.key === "Enter") {
if (spotBefore.classList.contains("hidden")) {
const reviewsStore = useReviewsStore();
reviewsStore.reviews = [];
spotBefore.classList.remove("hidden");
}
}
});
}
function listCacheClear$1() {
this.__data__ = [];
this.size = 0;
}
var _listCacheClear = listCacheClear$1;
function eq$2(value, other) {
return value === other || value !== value && other !== other;
}
var eq_1 = eq$2;
var eq$1 = eq_1;
function assocIndexOf$4(array, key) {
var length = array.length;
while (length--) {
if (eq$1(array[length][0], key)) {
return length;
}
}
return -1;
}
var _assocIndexOf = assocIndexOf$4;
var assocIndexOf$3 = _assocIndexOf;
var arrayProto = Array.prototype;
var splice = arrayProto.splice;
function listCacheDelete$1(key) {
var data4 = this.__data__, index2 = assocIndexOf$3(data4, key);
if (index2 < 0) {
return false;
}
var lastIndex = data4.length - 1;
if (index2 == lastIndex) {
data4.pop();
} else {
splice.call(data4, index2, 1);
}
--this.size;
return true;
}
var _listCacheDelete = listCacheDelete$1;
var assocIndexOf$2 = _assocIndexOf;
function listCacheGet$1(key) {
var data4 = this.__data__, index2 = assocIndexOf$2(data4, key);
return index2 < 0 ? void 0 : data4[index2][1];
}
var _listCacheGet = listCacheGet$1;
var assocIndexOf$1 = _assocIndexOf;
function listCacheHas$1(key) {
return assocIndexOf$1(this.__data__, key) > -1;
}
var _listCacheHas = listCacheHas$1;
var assocIndexOf = _assocIndexOf;
function listCacheSet$1(key, value) {
var data4 = this.__data__, index2 = assocIndexOf(data4, key);
if (index2 < 0) {
++this.size;
data4.push([key, value]);
} else {
data4[index2][1] = value;
}
return this;
}
var _listCacheSet = listCacheSet$1;
var listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
function ListCache$4(entries) {
var index2 = -1, length = entries == null ? 0 : entries.length;
this.clear();
while (++index2 < length) {
var entry = entries[index2];
this.set(entry[0], entry[1]);
}
}
ListCache$4.prototype.clear = listCacheClear;
ListCache$4.prototype["delete"] = listCacheDelete;
ListCache$4.prototype.get = listCacheGet;
ListCache$4.prototype.has = listCacheHas;
ListCache$4.prototype.set = listCacheSet;
var _ListCache = ListCache$4;
var ListCache$3 = _ListCache;
function stackClear$1() {
this.__data__ = new ListCache$3();
this.size = 0;
}
var _stackClear = stackClear$1;
function stackDelete$1(key) {
var data4 = this.__data__, result = data4["delete"](key);
this.size = data4.size;
return result;
}
var _stackDelete = stackDelete$1;
function stackGet$1(key) {
return this.__data__.get(key);
}
var _stackGet = stackGet$1;
function stackHas$1(key) {
return this.__data__.has(key);
}
var _stackHas = stackHas$1;
var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
var _freeGlobal = freeGlobal$1;
var freeGlobal = _freeGlobal;
var freeSelf = typeof self == "object" && self && self.Object === Object && self;
var root$8 = freeGlobal || freeSelf || Function("return this")();
var _root = root$8;
var root$7 = _root;
var Symbol$4 = root$7.Symbol;
var _Symbol = Symbol$4;
var Symbol$3 = _Symbol;
var objectProto$c = Object.prototype;
var hasOwnProperty$9 = objectProto$c.hasOwnProperty;
var nativeObjectToString$1 = objectProto$c.toString;
var symToStringTag$1 = Symbol$3 ? Symbol$3.toStringTag : void 0;
function getRawTag$1(value) {
var isOwn = hasOwnProperty$9.call(value, symToStringTag$1), tag = value[symToStringTag$1];
try {
value[symToStringTag$1] = void 0;
var unmasked = true;
} catch (e) {
}
var result = nativeObjectToString$1.call(value);
if (unmasked) {
if (isOwn) {
value[symToStringTag$1] = tag;
} else {
delete value[symToStringTag$1];
}
}
return result;
}
var _getRawTag = getRawTag$1;
var objectProto$b = Object.prototype;
var nativeObjectToString = objectProto$b.toString;
function objectToString$1(value) {
return nativeObjectToString.call(value);
}
var _objectToString = objectToString$1;
var Symbol$2 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : void 0;
function baseGetTag$4(value) {
if (value == null) {
return value === void 0 ? undefinedTag : nullTag;
}
return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
}
var _baseGetTag = baseGetTag$4;
function isObject$5(value) {
var type = typeof value;
return value != null && (type == "object" || type == "function");
}
var isObject_1 = isObject$5;
var baseGetTag$3 = _baseGetTag, isObject$4 = isObject_1;
var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
function isFunction$2(value) {
if (!isObject$4(value)) {
return false;
}
var tag = baseGetTag$3(value);
return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
}
var isFunction_1 = isFunction$2;
var root$6 = _root;
var coreJsData$1 = root$6["__core-js_shared__"];
var _coreJsData = coreJsData$1;
var coreJsData = _coreJsData;
var maskSrcKey = function() {
var uid2 = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
return uid2 ? "Symbol(src)_1." + uid2 : "";
}();
function isMasked$1(func) {
return !!maskSrcKey && maskSrcKey in func;
}
var _isMasked = isMasked$1;
var funcProto$1 = Function.prototype;
var funcToString$1 = funcProto$1.toString;
function toSource$2(func) {
if (func != null) {
try {
return funcToString$1.call(func);
} catch (e) {
}
try {
return func + "";
} catch (e) {
}
}
return "";
}
var _toSource = toSource$2;
var isFunction$1 = isFunction_1, isMasked = _isMasked, isObject$3 = isObject_1, toSource$1 = _toSource;
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
var reIsHostCtor = /^\[object .+?Constructor\]$/;
var funcProto = Function.prototype, objectProto$a = Object.prototype;
var funcToString = funcProto.toString;
var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
var reIsNative = RegExp(
"^" + funcToString.call(hasOwnProperty$8).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
);
function baseIsNative$1(value) {
if (!isObject$3(value) || isMasked(value)) {
return false;
}
var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor;
return pattern.test(toSource$1(value));
}
var _baseIsNative = baseIsNative$1;
function getValue$1(object, key) {
return object == null ? void 0 : object[key];
}
var _getValue = getValue$1;
var baseIsNative = _baseIsNative, getValue = _getValue;
function getNative$7(object, key) {
var value = getValue(object, key);
return baseIsNative(value) ? value : void 0;
}
var _getNative = getNative$7;
var getNative$6 = _getNative, root$5 = _root;
var Map$4 = getNative$6(root$5, "Map");
var _Map = Map$4;
var getNative$5 = _getNative;
var nativeCreate$4 = getNative$5(Object, "create");
var _nativeCreate = nativeCreate$4;
var nativeCreate$3 = _nativeCreate;
function hashClear$1() {
this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
this.size = 0;
}
var _hashClear = hashClear$1;
function hashDelete$1(key) {
var result = this.has(key) && delete this.__data__[key];
this.size -= result ? 1 : 0;
return result;
}
var _hashDelete = hashDelete$1;
var nativeCreate$2 = _nativeCreate;
var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
var objectProto$9 = Object.prototype;
var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
function hashGet$1(key) {
var data4 = this.__data__;
if (nativeCreate$2) {
var result = data4[key];
return result === HASH_UNDEFINED$1 ? void 0 : result;
}
return hasOwnProperty$7.call(data4, key) ? data4[key] : void 0;
}
var _hashGet = hashGet$1;
var nativeCreate$1 = _nativeCreate;
var objectProto$8 = Object.prototype;
var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
function hashHas$1(key) {
var data4 = this.__data__;
return nativeCreate$1 ? data4[key] !== void 0 : hasOwnProperty$6.call(data4, key);
}
var _hashHas = hashHas$1;
var nativeCreate = _nativeCreate;
var HASH_UNDEFINED = "__lodash_hash_undefined__";
function hashSet$1(key, value) {
var data4 = this.__data__;
this.size += this.has(key) ? 0 : 1;
data4[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
return this;
}
var _hashSet = hashSet$1;
var hashClear = _hashClear, hashDelete = _hashDelete, hashGet = _hashGet, hashHas = _hashHas, hashSet = _hashSet;
function Hash$1(entries) {
var index2 = -1, length = entries == null ? 0 : entries.length;
this.clear();
while (++index2 < length) {
var entry = entries[index2];
this.set(entry[0], entry[1]);
}
}
Hash$1.prototype.clear = hashClear;
Hash$1.prototype["delete"] = hashDelete;
Hash$1.prototype.get = hashGet;
Hash$1.prototype.has = hashHas;
Hash$1.prototype.set = hashSet;
var _Hash = Hash$1;
var Hash = _Hash, ListCache$2 = _ListCache, Map$3 = _Map;
function mapCacheClear$1() {
this.size = 0;
this.__data__ = {
"hash": new Hash(),
"map": new (Map$3 || ListCache$2)(),
"string": new Hash()
};
}
var _mapCacheClear = mapCacheClear$1;
function isKeyable$1(value) {
var type = typeof value;
return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
}
var _isKeyable = isKeyable$1;
var isKeyable = _isKeyable;
function getMapData$4(map, key) {
var data4 = map.__data__;
return isKeyable(key) ? data4[typeof key == "string" ? "string" : "hash"] : data4.map;
}
var _getMapData = getMapData$4;
var getMapData$3 = _getMapData;
function mapCacheDelete$1(key) {
var result = getMapData$3(this, key)["delete"](key);
this.size -= result ? 1 : 0;
return result;
}
var _mapCacheDelete = mapCacheDelete$1;
var getMapData$2 = _getMapData;
function mapCacheGet$1(key) {
return getMapData$2(this, key).get(key);
}
var _mapCacheGet = mapCacheGet$1;
var getMapData$1 = _getMapData;
function mapCacheHas$1(key) {
return getMapData$1(this, key).has(key);
}
var _mapCacheHas = mapCacheHas$1;
var getMapData = _getMapData;
function mapCacheSet$1(key, value) {
var data4 = getMapData(this, key), size2 = data4.size;
data4.set(key, value);
this.size += data4.size == size2 ? 0 : 1;
return this;
}
var _mapCacheSet = mapCacheSet$1;
var mapCacheClear = _mapCacheClear, mapCacheDelete = _mapCacheDelete, mapCacheGet = _mapCacheGet, mapCacheHas = _mapCacheHas, mapCacheSet = _mapCacheSet;
function MapCache$1(entries) {
var index2 = -1, length = entries == null ? 0 : entries.length;
this.clear();
while (++index2 < length) {
var entry = entries[index2];
this.set(entry[0], entry[1]);
}
}
MapCache$1.prototype.clear = mapCacheClear;
MapCache$1.prototype["delete"] = mapCacheDelete;
MapCache$1.prototype.get = mapCacheGet;
MapCache$1.prototype.has = mapCacheHas;
MapCache$1.prototype.set = mapCacheSet;
var _MapCache = MapCache$1;
var ListCache$1 = _ListCache, Map$2 = _Map, MapCache = _MapCache;
var LARGE_ARRAY_SIZE = 200;
function stackSet$1(key, value) {
var data4 = this.__data__;
if (data4 instanceof ListCache$1) {
var pairs = data4.__data__;
if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
pairs.push([key, value]);
this.size = ++data4.size;
return this;
}
data4 = this.__data__ = new MapCache(pairs);
}
data4.set(key, value);
this.size = data4.size;
return this;
}
var _stackSet = stackSet$1;
var ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
function Stack$1(entries) {
var data4 = this.__data__ = new ListCache(entries);
this.size = data4.size;
}
Stack$1.prototype.clear = stackClear;
Stack$1.prototype["delete"] = stackDelete;
Stack$1.prototype.get = stackGet;
Stack$1.prototype.has = stackHas;
Stack$1.prototype.set = stackSet;
var _Stack = Stack$1;
function arrayEach$1(array, iteratee) {
var index2 = -1, length = array == null ? 0 : array.length;
while (++index2 < length) {
if (iteratee(array[index2], index2, array) === false) {
break;
}
}
return array;
}
var _arrayEach = arrayEach$1;
var getNative$4 = _getNative;
var defineProperty$1 = function() {
try {
var func = getNative$4(Object, "defineProperty");
func({}, "", {});
return func;
} catch (e) {
}
}();
var _defineProperty = defineProperty$1;
var defineProperty = _defineProperty;
function baseAssignValue$2(object, key, value) {
if (key == "__proto__" && defineProperty) {
defineProperty(object, key, {
"configurable": true,
"enumerable": true,
"value": value,
"writable": true
});
} else {
object[key] = value;
}
}
var _baseAssignValue = baseAssignValue$2;
var baseAssignValue$1 = _baseAssignValue, eq = eq_1;
var objectProto$7 = Object.prototype;
var hasOwnProperty$5 = objectProto$7.hasOwnProperty;
function assignValue$2(object, key, value) {
var objValue = object[key];
if (!(hasOwnProperty$5.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
baseAssignValue$1(object, key, value);
}
}
var _assignValue = assignValue$2;
var assignValue$1 = _assignValue, baseAssignValue = _baseAssignValue;
function copyObject$4(source, props, object, customizer) {
var isNew = !object;
object || (object = {});
var index2 = -1, length = props.length;
while (++index2 < length) {
var key = props[index2];
var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
if (newValue === void 0) {
newValue = source[key];
}
if (isNew) {
baseAssignValue(object, key, newValue);
} else {
assignValue$1(object, key, newValue);
}
}
return object;
}
var _copyObject = copyObject$4;
function baseTimes$1(n, iteratee) {
var index2 = -1, result = Array(n);
while (++index2 < n) {
result[index2] = iteratee(index2);
}
return result;
}
var _baseTimes = baseTimes$1;
function isObjectLike$5(value) {
return value != null && typeof value == "object";
}
var isObjectLike_1 = isObjectLike$5;
var baseGetTag$2 = _baseGetTag, isObjectLike$4 = isObjectLike_1;
var argsTag$2 = "[object Arguments]";
function baseIsArguments$1(value) {
return isObjectLike$4(value) && baseGetTag$2(value) == argsTag$2;
}
var _baseIsArguments = baseIsArguments$1;
var baseIsArguments = _baseIsArguments, isObjectLike$3 = isObjectLike_1;
var objectProto$6 = Object.prototype;
var hasOwnProperty$4 = objectProto$6.hasOwnProperty;
var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable;
var isArguments$1 = baseIsArguments(/* @__PURE__ */ function() {
return arguments;
}()) ? baseIsArguments : function(value) {
return isObjectLike$3(value) && hasOwnProperty$4.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
};
var isArguments_1 = isArguments$1;
var isArray$3 = Array.isArray;
var isArray_1 = isArray$3;
var isBuffer$2 = { exports: {} };
function stubFalse() {
return false;
}
var stubFalse_1 = stubFalse;
isBuffer$2.exports;
(function(module, exports) {
var root7 = _root, stubFalse2 = stubFalse_1;
var freeExports = exports && !exports.nodeType && exports;
var freeModule = freeExports && true && module && !module.nodeType && module;
var moduleExports = freeModule && freeModule.exports === freeExports;
var Buffer = moduleExports ? root7.Buffer : void 0;
var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
var isBuffer2 = nativeIsBuffer || stubFalse2;
module.exports = isBuffer2;
})(isBuffer$2, isBuffer$2.exports);
var isBufferExports = isBuffer$2.exports;
var MAX_SAFE_INTEGER$1 = 9007199254740991;
var reIsUint = /^(?:0|[1-9]\d*)$/;
function isIndex$1(value, length) {
var type = typeof value;
length = length == null ? MAX_SAFE_INTEGER$1 : length;
return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
}
var _isIndex = isIndex$1;
var MAX_SAFE_INTEGER = 9007199254740991;
function isLength$2(value) {
return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
}
var isLength_1 = isLength$2;
var baseGetTag$1 = _baseGetTag, isLength$1 = isLength_1, isObjectLike$2 = isObjectLike_1;
var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", errorTag$1 = "[object Error]", funcTag$1 = "[object Function]", mapTag$4 = "[object Map]", numberTag$2 = "[object Number]", objectTag$2 = "[object Object]", regexpTag$2 = "[object RegExp]", setTag$4 = "[object Set]", stringTag$2 = "[object String]", weakMapTag$2 = "[object WeakMap]";
var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$3 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
var typedArrayTags = {};
typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] = typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$4] = typedArrayTags[numberTag$2] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$2] = typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] = typedArrayTags[weakMapTag$2] = false;
function baseIsTypedArray$1(value) {
return isObjectLike$2(value) && isLength$1(value.length) && !!typedArrayTags[baseGetTag$1(value)];
}
var _baseIsTypedArray = baseIsTypedArray$1;
function baseUnary$3(func) {
return function(value) {
return func(value);
};
}
var _baseUnary = baseUnary$3;
var _nodeUtil = { exports: {} };
_nodeUtil.exports;
(function(module, exports) {
var freeGlobal2 = _freeGlobal;
var freeExports = exports && !exports.nodeType && exports;
var freeModule = freeExports && true && module && !module.nodeType && module;
var moduleExports = freeModule && freeModule.exports === freeExports;
var freeProcess = moduleExports && freeGlobal2.process;
var nodeUtil2 = function() {
try {
var types = freeModule && freeModule.require && freeModule.require("util").types;
if (types) {
return types;
}
return freeProcess && freeProcess.binding && freeProcess.binding("util");
} catch (e) {
}
}();
module.exports = nodeUtil2;
})(_nodeUtil, _nodeUtil.exports);
var _nodeUtilExports = _nodeUtil.exports;
var baseIsTypedArray = _baseIsTypedArray, baseUnary$2 = _baseUnary, nodeUtil$2 = _nodeUtilExports;
var nodeIsTypedArray = nodeUtil$2 && nodeUtil$2.isTypedArray;
var isTypedArray$1 = nodeIsTypedArray ? baseUnary$2(nodeIsTypedArray) : baseIsTypedArray;
var isTypedArray_1 = isTypedArray$1;
var baseTimes = _baseTimes, isArguments = isArguments_1, isArray$2 = isArray_1, isBuffer$1 = isBufferExports, isIndex = _isIndex, isTypedArray = isTypedArray_1;
var objectProto$5 = Object.prototype;
var hasOwnProperty$3 = objectProto$5.hasOwnProperty;
function arrayLikeKeys$2(value, inherited) {
var isArr = isArray$2(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
for (var key in value) {
if ((inherited || hasOwnProperty$3.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
(key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
isIndex(key, length)))) {
result.push(key);
}
}
return result;
}
var _arrayLikeKeys = arrayLikeKeys$2;
var objectProto$4 = Object.prototype;
function isPrototype$3(value) {
var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$4;
return value === proto;
}
var _isPrototype = isPrototype$3;
function overArg$2(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
var _overArg = overArg$2;
var overArg$1 = _overArg;
var nativeKeys$1 = overArg$1(Object.keys, Object);
var _nativeKeys = nativeKeys$1;
var isPrototype$2 = _isPrototype, nativeKeys = _nativeKeys;
var objectProto$3 = Object.prototype;
var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
function baseKeys$1(object) {
if (!isPrototype$2(object)) {
return nativeKeys(object);
}
var result = [];
for (var key in Object(object)) {
if (hasOwnProperty$2.call(object, key) && key != "constructor") {
result.push(key);
}
}
return result;
}
var _baseKeys = baseKeys$1;
var isFunction = isFunction_1, isLength = isLength_1;
function isArrayLike$2(value) {
return value != null && isLength(value.length) && !isFunction(value);
}
var isArrayLike_1 = isArrayLike$2;
var arrayLikeKeys$1 = _arrayLikeKeys, baseKeys = _baseKeys, isArrayLike$1 = isArrayLike_1;
function keys$3(object) {
return isArrayLike$1(object) ? arrayLikeKeys$1(object) : baseKeys(object);
}
var keys_1 = keys$3;
var copyObject$3 = _copyObject, keys$2 = keys_1;
function baseAssign$1(object, source) {
return object && copyObject$3(source, keys$2(source), object);
}
var _baseAssign = baseAssign$1;
function nativeKeysIn$1(object) {
var result = [];
if (object != null) {
for (var key in Object(object)) {
result.push(key);
}
}
return result;
}
var _nativeKeysIn = nativeKeysIn$1;
var isObject$2 = isObject_1, isPrototype$1 = _isPrototype, nativeKeysIn = _nativeKeysIn;
var objectProto$2 = Object.prototype;
var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
function baseKeysIn$1(object) {
if (!isObject$2(object)) {
return nativeKeysIn(object);
}
var isProto = isPrototype$1(object), result = [];
for (var key in object) {
if (!(key == "constructor" && (isProto || !hasOwnProperty$1.call(object, key)))) {
result.push(key);
}
}
return result;
}
var _baseKeysIn = baseKeysIn$1;
var arrayLikeKeys = _arrayLikeKeys, baseKeysIn = _baseKeysIn, isArrayLike = isArrayLike_1;
function keysIn$3(object) {
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
}
var keysIn_1 = keysIn$3;
var copyObject$2 = _copyObject, keysIn$2 = keysIn_1;
function baseAssignIn$1(object, source) {
return object && copyObject$2(source, keysIn$2(source), object);
}
var _baseAssignIn = baseAssignIn$1;
var _cloneBuffer = { exports: {} };
_cloneBuffer.exports;
(function(module, exports) {
var root7 = _root;
var freeExports = exports && !exports.nodeType && exports;
var freeModule = freeExports && true && module && !module.nodeType && module;
var moduleExports = freeModule && freeModule.exports === freeExports;
var Buffer = moduleExports ? root7.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
function cloneBuffer2(buffer, isDeep) {
if (isDeep) {
return buffer.slice();
}
var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
buffer.copy(result);
return result;
}
module.exports = cloneBuffer2;
})(_cloneBuffer, _cloneBuffer.exports);
var _cloneBufferExports = _cloneBuffer.exports;
function copyArray$1(source, array) {
var index2 = -1, length = source.length;
array || (array = Array(length));
while (++index2 < length) {
array[index2] = source[index2];
}
return array;
}
var _copyArray = copyArray$1;
function arrayFilter$1(array, predicate) {
var index2 = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
while (++index2 < length) {
var value = array[index2];
if (predicate(value, index2, array)) {
result[resIndex++] = value;
}
}
return result;
}
var _arrayFilter = arrayFilter$1;
function stubArray$2() {
return [];
}
var stubArray_1 = stubArray$2;
var arrayFilter = _arrayFilter, stubArray$1 = stubArray_1;
var objectProto$1 = Object.prototype;
var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
var getSymbols$3 = !nativeGetSymbols$1 ? stubArray$1 : function(object) {
if (object == null) {
return [];
}
object = Object(object);
return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
return propertyIsEnumerable.call(object, symbol);
});
};
var _getSymbols = getSymbols$3;
var copyObject$1 = _copyObject, getSymbols$2 = _getSymbols;
function copySymbols$1(source, object) {
return copyObject$1(source, getSymbols$2(source), object);
}
var _copySymbols = copySymbols$1;
function arrayPush$2(array, values) {
var index2 = -1, length = values.length, offset = array.length;
while (++index2 < length) {
array[offset + index2] = values[index2];
}
return array;
}
var _arrayPush = arrayPush$2;
var overArg = _overArg;
var getPrototype$2 = overArg(Object.getPrototypeOf, Object);
var _getPrototype = getPrototype$2;
var arrayPush$1 = _arrayPush, getPrototype$1 = _getPrototype, getSymbols$1 = _getSymbols, stubArray = stubArray_1;
var nativeGetSymbols = Object.getOwnPropertySymbols;
var getSymbolsIn$2 = !nativeGetSymbols ? stubArray : function(object) {
var result = [];
while (object) {
arrayPush$1(result, getSymbols$1(object));
object = getPrototype$1(object);
}
return result;
};
var _getSymbolsIn = getSymbolsIn$2;
var copyObject = _copyObject, getSymbolsIn$1 = _getSymbolsIn;
function copySymbolsIn$1(source, object) {
return copyObject(source, getSymbolsIn$1(source), object);
}
var _copySymbolsIn = copySymbolsIn$1;
var arrayPush = _arrayPush, isArray$1 = isArray_1;
function baseGetAllKeys$2(object, keysFunc, symbolsFunc) {
var result = keysFunc(object);
return isArray$1(object) ? result : arrayPush(result, symbolsFunc(object));
}
var _baseGetAllKeys = baseGetAllKeys$2;
var baseGetAllKeys$1 = _baseGetAllKeys, getSymbols = _getSymbols, keys$1 = keys_1;
function getAllKeys$1(object) {
return baseGetAllKeys$1(object, keys$1, getSymbols);
}
var _getAllKeys = getAllKeys$1;
var baseGetAllKeys = _baseGetAllKeys, getSymbolsIn = _getSymbolsIn, keysIn$1 = keysIn_1;
function getAllKeysIn$1(object) {
return baseGetAllKeys(object, keysIn$1, getSymbolsIn);
}
var _getAllKeysIn = getAllKeysIn$1;
var getNative$3 = _getNative, root$4 = _root;
var DataView$1 = getNative$3(root$4, "DataView");
var _DataView = DataView$1;
var getNative$2 = _getNative, root$3 = _root;
var Promise$2 = getNative$2(root$3, "Promise");
var _Promise = Promise$2;
var getNative$1 = _getNative, root$2 = _root;
var Set$2 = getNative$1(root$2, "Set");
var _Set = Set$2;
var getNative = _getNative, root$1 = _root;
var WeakMap$2 = getNative(root$1, "WeakMap");
var _WeakMap = WeakMap$2;
var DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$1 = _Set, WeakMap$1 = _WeakMap, baseGetTag = _baseGetTag, toSource = _toSource;
var mapTag$3 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$3 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
var dataViewTag$2 = "[object DataView]";
var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap$1);
var getTag$3 = baseGetTag;
if (DataView && getTag$3(new DataView(new ArrayBuffer(1))) != dataViewTag$2 || Map$1 && getTag$3(new Map$1()) != mapTag$3 || Promise$1 && getTag$3(Promise$1.resolve()) != promiseTag || Set$1 && getTag$3(new Set$1()) != setTag$3 || WeakMap$1 && getTag$3(new WeakMap$1()) != weakMapTag$1) {
getTag$3 = function(value) {
var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
if (ctorString) {
switch (ctorString) {
case dataViewCtorString:
return dataViewTag$2;
case mapCtorString:
return mapTag$3;
case promiseCtorString:
return promiseTag;
case setCtorString:
return setTag$3;
case weakMapCtorString:
return weakMapTag$1;
}
}
return result;
};
}
var _getTag = getTag$3;
var objectProto = Object.prototype;
var hasOwnProperty = objectProto.hasOwnProperty;
function initCloneArray$1(array) {
var length = array.length, result = new array.constructor(length);
if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
result.index = array.index;
result.input = array.input;
}
return result;
}
var _initCloneArray = initCloneArray$1;
var root6 = _root;
var Uint8Array$1 = root6.Uint8Array;
var _Uint8Array = Uint8Array$1;
var Uint8Array = _Uint8Array;
function cloneArrayBuffer$3(arrayBuffer) {
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
new Uint8Array(result).set(new Uint8Array(arrayBuffer));
return result;
}
var _cloneArrayBuffer = cloneArrayBuffer$3;
var cloneArrayBuffer$2 = _cloneArrayBuffer;
function cloneDataView$1(dataView, isDeep) {
var buffer = isDeep ? cloneArrayBuffer$2(dataView.buffer) : dataView.buffer;
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
}
var _cloneDataView = cloneDataView$1;
var reFlags = /\w*$/;
function cloneRegExp$1(regexp) {
var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
result.lastIndex = regexp.lastIndex;
return result;
}
var _cloneRegExp = cloneRegExp$1;
var Symbol$1 = _Symbol;
var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
function cloneSymbol$1(symbol) {
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
}
var _cloneSymbol = cloneSymbol$1;
var cloneArrayBuffer$1 = _cloneArrayBuffer;
function cloneTypedArray$1(typedArray, isDeep) {
var buffer = isDeep ? cloneArrayBuffer$1(typedArray.buffer) : typedArray.buffer;
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
}
var _cloneTypedArray = cloneTypedArray$1;
var cloneArrayBuffer = _cloneArrayBuffer, cloneDataView = _cloneDataView, cloneRegExp = _cloneRegExp, cloneSymbol = _cloneSymbol, cloneTypedArray = _cloneTypedArray;
var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]";
var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
function initCloneByTag$1(object, tag, isDeep) {
var Ctor = object.constructor;
switch (tag) {
case arrayBufferTag$1:
return cloneArrayBuffer(object);
case boolTag$1:
case dateTag$1:
return new Ctor(+object);
case dataViewTag$1:
return cloneDataView(object, isDeep);
case float32Tag$1:
case float64Tag$1:
case int8Tag$1:
case int16Tag$1:
case int32Tag$1:
case uint8Tag$1:
case uint8ClampedTag$1:
case uint16Tag$1:
case uint32Tag$1:
return cloneTypedArray(object, isDeep);
case mapTag$2:
return new Ctor();
case numberTag$1:
case stringTag$1:
return new Ctor(object);
case regexpTag$1:
return cloneRegExp(object);
case setTag$2:
return new Ctor();
case symbolTag$1:
return cloneSymbol(object);
}
}
var _initCloneByTag = initCloneByTag$1;
var isObject$1 = isObject_1;
var objectCreate = Object.create;
var baseCreate$1 = /* @__PURE__ */ function() {
function object() {
}
return function(proto) {
if (!isObject$1(proto)) {
return {};
}
if (objectCreate) {
return objectCreate(proto);
}
object.prototype = proto;
var result = new object();
object.prototype = void 0;
return result;
};
}();
var _baseCreate = baseCreate$1;
var baseCreate = _baseCreate, getPrototype = _getPrototype, isPrototype = _isPrototype;
function initCloneObject$1(object) {
return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
}
var _initCloneObject = initCloneObject$1;
var getTag$2 = _getTag, isObjectLike$1 = isObjectLike_1;
var mapTag$1 = "[object Map]";
function baseIsMap$1(value) {
return isObjectLike$1(value) && getTag$2(value) == mapTag$1;
}
var _baseIsMap = baseIsMap$1;
var baseIsMap = _baseIsMap, baseUnary$1 = _baseUnary, nodeUtil$1 = _nodeUtilExports;
var nodeIsMap = nodeUtil$1 && nodeUtil$1.isMap;
var isMap$1 = nodeIsMap ? baseUnary$1(nodeIsMap) : baseIsMap;
var isMap_1 = isMap$1;
var getTag$1 = _getTag, isObjectLike = isObjectLike_1;
var setTag$1 = "[object Set]";
function baseIsSet$1(value) {
return isObjectLike(value) && getTag$1(value) == setTag$1;
}
var _baseIsSet = baseIsSet$1;
var baseIsSet = _baseIsSet, baseUnary = _baseUnary, nodeUtil = _nodeUtilExports;
var nodeIsSet = nodeUtil && nodeUtil.isSet;
var isSet$1 = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
var isSet_1 = isSet$1;
var Stack = _Stack, arrayEach = _arrayEach, assignValue = _assignValue, baseAssign = _baseAssign, baseAssignIn = _baseAssignIn, cloneBuffer = _cloneBufferExports, copyArray = _copyArray, copySymbols = _copySymbols, copySymbolsIn = _copySymbolsIn, getAllKeys = _getAllKeys, getAllKeysIn = _getAllKeysIn, getTag = _getTag, initCloneArray = _initCloneArray, initCloneByTag = _initCloneByTag, initCloneObject = _initCloneObject, isArray = isArray_1, isBuffer = isBufferExports, isMap = isMap_1, isObject = isObject_1, isSet = isSet_1, keys = keys_1, keysIn = keysIn_1;
var CLONE_DEEP_FLAG$1 = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG$1 = 4;
var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]";
var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
var cloneableTags = {};
cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
function baseClone$1(value, bitmask, customizer, key, object, stack2) {
var result, isDeep = bitmask & CLONE_DEEP_FLAG$1, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG$1;
if (customizer) {
result = object ? customizer(value, key, object, stack2) : customizer(value);
}
if (result !== void 0) {
return result;
}
if (!isObject(value)) {
return value;
}
var isArr = isArray(value);
if (isArr) {
result = initCloneArray(value);
if (!isDeep) {
return copyArray(value, result);
}
} else {
var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
if (isBuffer(value)) {
return cloneBuffer(value, isDeep);
}
if (tag == objectTag || tag == argsTag || isFunc && !object) {
result = isFlat || isFunc ? {} : initCloneObject(value);
if (!isDeep) {
return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
}
} else {
if (!cloneableTags[tag]) {
return object ? value : {};
}
result = initCloneByTag(value, tag, isDeep);
}
}
stack2 || (stack2 = new Stack());
var stacked = stack2.get(value);
if (stacked) {
return stacked;
}
stack2.set(value, result);
if (isSet(value)) {
value.forEach(function(subValue) {
result.add(baseClone$1(subValue, bitmask, customizer, subValue, value, stack2));
});
} else if (isMap(value)) {
value.forEach(function(subValue, key2) {
result.set(key2, baseClone$1(subValue, bitmask, customizer, key2, value, stack2));
});
}
var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
var props = isArr ? void 0 : keysFunc(value);
arrayEach(props || value, function(subValue, key2) {
if (props) {
key2 = subValue;
subValue = value[key2];
}
assignValue(result, key2, baseClone$1(subValue, bitmask, customizer, key2, value, stack2));
});
return result;
}
var _baseClone = baseClone$1;
var baseClone = _baseClone;
var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
function cloneDeep(value) {
return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
}
var cloneDeep_1 = cloneDeep;
const cloneDeep$1 = /* @__PURE__ */ getDefaultExportFromCjs(cloneDeep_1);
const _sfc_main = /* @__PURE__ */ defineComponent({
__name: "App",
setup(__props) {
const reviewsStore = useReviewsStore();
const reviewStore = useReviewsStore();
const indexStore = useIndexStore();
const getItems = () => {
wkof.ItemData.get_items({
wk_items: {
options: {
assignments: true,
review_statistics: true,
study_materials: true,
subjects: true
}
}
}).then(processItems);
};
function makeAnswerDiv() {
const spotBefore = document.querySelector("#user-response");
if (spotBefore == null) return;
const newSpot = document.createElement("div");
newSpot.id = "answerDiv";
if (spotBefore == null) {
console.log("#user-response not found");
} else {
spotBefore.after(newSpot);
}
const reviewsStore2 = useReviewsStore();
reviewsStore2.reviewsLoaded = true;
indexStore.dashboardLoaded = false;
getItems();
}
function processItems(items) {
reviewStore.allItems = items;
}
function makeDebugDiv() {
const spotBefore = document.querySelector("#additional-content");
if (spotBefore == null) return;
const newSpot = document.createElement("div");
newSpot.id = "debugDiv";
if (spotBefore == null) {
console.log("#additional-content not found");
} else {
spotBefore.after(newSpot);
}
}
function makeLiveTallyDiv() {
const spotBefore = document.querySelector("#additional-content");
if (spotBefore == null) return;
const newSpot = document.createElement("div");
newSpot.id = "tallyDiv";
if (spotBefore == null) {
console.log("#additional-content not found");
} else {
spotBefore.after(newSpot);
}
}
function makeBreakdownDiv() {
const spotBefore = document.getElementsByClassName("character-header__characters")[0];
if (spotBefore == null) return;
const newSpot = document.createElement("div");
newSpot.id = "breakdownDiv";
if (spotBefore == null) {
console.log(".character-header__characters not found");
} else {
spotBefore.after(newSpot);
}
}
const handleDidAnswerQuestion = (event) => {
var _a;
reviewsStore.detail = cloneDeep$1(event.detail);
reviewStore.getItemDetails(
//@ts-ignore
document.getElementsByClassName("character-header__characters")[0].innerText,
//@ts-ignore
document.getElementsByClassName("quiz-input__question-category")[0].innerText
);
const questionWidth = document.getElementsByClassName("character-header__characters")[0].offsetWidth;
const newLeft = window.innerWidth / 2 + questionWidth / 2;
document.getElementById("breakdownDiv").style.left = newLeft.toString() + "px";
reviewStore.reviews = reviewStore.reviews.filter(
(r) => r.subject.id != event.detail.subjectWithStats.subject.id
);
let existing = reviewStore.reviews.find(
(r) => r.subject.id == event.detail.subjectWithStats.subject.id
);
if (existing == void 0) {
if (reviewsStore.detail != void 0) {
reviewStore.reviews.push(reviewsStore.detail.subjectWithStats);
}
} else {
existing = (_a = reviewsStore.detail) == null ? void 0 : _a.subjectWithStats;
}
};
function reset() {
const reviewsStore2 = useReviewsStore();
reviewsStore2.detail = null;
reviewsStore2.itemDetails = null;
}
const handleWillShowNextQuestion = (event) => {
reset();
};
onMounted(() => {
nextTick(() => {
setUpListeners(() => {
reviewsStore.reviewsLoaded = false;
nextTick(() => {
makeAnswerDiv();
makeBreakdownDiv();
makeLiveTallyDiv();
if (indexStore.debug) makeDebugDiv();
window.addEventListener("didAnswerQuestion", handleDidAnswerQuestion);
window.addEventListener("willShowNextQuestion", handleWillShowNextQuestion);
window.addEventListener("didUnanswerQuestion", handleUnanswerQuestion);
var style = getComputedStyle(document.body);
var BreezeDark = style.getPropertyValue("--radical-color") == "#3daee9";
if (BreezeDark) {
document.documentElement.classList.add("dark");
}
});
});
wkof.include("Settings,Menu,ItemData");
wkof.ready("Settings,Menu,ItemData").then(loadSettings).then(installMenu);
});
function handleUnanswerQuestion(event) {
reviewsStore.detail = null;
}
wkofCheck();
loadTurbo();
router.push("/");
});
return (_ctx, _cache) => {
return openBlock(), createBlock(unref(RouterView));
};
}
});
const App = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-75c58aa2"]]);
const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
function jsonParseTransform(key, value) {
if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
warnKeyDropped(key);
return;
}
return value;
}
function warnKeyDropped(key) {
console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
}
function destr(value, options = {}) {
if (typeof value !== "string") {
return value;
}
const _value = value.trim();
if (
// eslint-disable-next-line unicorn/prefer-at
value[0] === '"' && value.endsWith('"') && !value.includes("\\")
) {
return _value.slice(1, -1);
}
if (_value.length <= 9) {
const _lval = _value.toLowerCase();
if (_lval === "true") {
return true;
}
if (_lval === "false") {
return false;
}
if (_lval === "undefined") {
return void 0;
}
if (_lval === "null") {
return null;
}
if (_lval === "nan") {
return Number.NaN;
}
if (_lval === "infinity") {
return Number.POSITIVE_INFINITY;
}
if (_lval === "-infinity") {
return Number.NEGATIVE_INFINITY;
}
}
if (!JsonSigRx.test(value)) {
if (options.strict) {
throw new SyntaxError("[destr] Invalid JSON");
}
return value;
}
try {
if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
if (options.strict) {
throw new Error("[destr] Possible prototype pollution");
}
return JSON.parse(value, jsonParseTransform);
}
return JSON.parse(value);
} catch (error) {
if (options.strict) {
throw error;
}
return value;
}
}
function get(obj, path) {
if (obj == null)
return void 0;
let value = obj;
for (let i = 0; i < path.length; i++) {
if (value == null || value[path[i]] == null)
return void 0;
value = value[path[i]];
}
return value;
}
function set(obj, value, path) {
if (path.length === 0)
return value;
const idx = path[0];
if (path.length > 1) {
value = set(
typeof obj !== "object" || obj === null || !Object.prototype.hasOwnProperty.call(obj, idx) ? Number.isInteger(Number(path[1])) ? [] : {} : obj[idx],
value,
Array.prototype.slice.call(path, 1)
);
}
if (Number.isInteger(Number(idx)) && Array.isArray(obj))
return obj.slice()[idx];
return Object.assign({}, obj, { [idx]: value });
}
function unset(obj, path) {
if (obj == null || path.length === 0)
return obj;
if (path.length === 1) {
if (obj == null)
return obj;
if (Number.isInteger(path[0]) && Array.isArray(obj))
return Array.prototype.slice.call(obj, 0).splice(path[0], 1);
const result = {};
for (const p2 in obj)
result[p2] = obj[p2];
delete result[path[0]];
return result;
}
if (obj[path[0]] == null) {
if (Number.isInteger(path[0]) && Array.isArray(obj))
return Array.prototype.concat.call([], obj);
const result = {};
for (const p2 in obj)
result[p2] = obj[p2];
return result;
}
return set(
obj,
unset(
obj[path[0]],
Array.prototype.slice.call(path, 1)
),
[path[0]]
);
}
function deepPickUnsafe(obj, paths) {
return paths.map((p2) => p2.split(".")).map((p2) => [p2, get(obj, p2)]).filter((t) => t[1] !== void 0).reduce((acc, cur) => set(acc, cur[1], cur[0]), {});
}
function deepOmitUnsafe(obj, paths) {
return paths.map((p2) => p2.split(".")).reduce((acc, cur) => unset(acc, cur), obj);
}
function hydrateStore(store, {
storage,
serializer,
key,
debug,
pick,
omit,
beforeHydrate,
afterHydrate
}, context, runHooks = true) {
try {
if (runHooks)
beforeHydrate == null ? void 0 : beforeHydrate(context);
const fromStorage = storage.getItem(key);
if (fromStorage) {
const deserialized = serializer.deserialize(fromStorage);
const picked = pick ? deepPickUnsafe(deserialized, pick) : deserialized;
const omitted = omit ? deepOmitUnsafe(picked, omit) : picked;
store.$patch(omitted);
}
if (runHooks)
afterHydrate == null ? void 0 : afterHydrate(context);
} catch (error) {
if (debug)
console.error("[pinia-plugin-persistedstate]", error);
}
}
function persistState(state, {
storage,
serializer,
key,
debug,
pick,
omit
}) {
try {
const picked = pick ? deepPickUnsafe(state, pick) : state;
const omitted = omit ? deepOmitUnsafe(picked, omit) : picked;
const toStorage = serializer.serialize(omitted);
storage.setItem(key, toStorage);
} catch (error) {
if (debug)
console.error("[pinia-plugin-persistedstate]", error);
}
}
function createPersistence(context, optionsParser, auto) {
const { pinia: pinia2, store, options: { persist = auto } } = context;
if (!persist)
return;
if (!(store.$id in pinia2.state.value)) {
const originalStore = pinia2._s.get(store.$id.replace("__hot:", ""));
if (originalStore)
Promise.resolve().then(() => originalStore.$persist());
return;
}
const persistenceOptions = Array.isArray(persist) ? persist : persist === true ? [{}] : [persist];
const persistences = persistenceOptions.map(optionsParser);
store.$hydrate = ({ runHooks = true } = {}) => {
persistences.forEach((p2) => {
hydrateStore(store, p2, context, runHooks);
});
};
store.$persist = () => {
persistences.forEach((p2) => {
persistState(store.$state, p2);
});
};
persistences.forEach((p2) => {
hydrateStore(store, p2, context);
store.$subscribe(
(_mutation, state) => persistState(state, p2),
{ detached: true }
);
});
}
function createPersistedState(options = {}) {
return function(context) {
createPersistence(
context,
(p2) => ({
key: (options.key ? options.key : (x) => x)(p2.key ?? context.store.$id),
debug: p2.debug ?? options.debug ?? false,
serializer: p2.serializer ?? options.serializer ?? {
serialize: (data4) => JSON.stringify(data4),
deserialize: (data4) => destr(data4)
},
storage: p2.storage ?? options.storage ?? window.localStorage,
beforeHydrate: p2.beforeHydrate,
afterHydrate: p2.afterHydrate,
pick: p2.pick,
omit: p2.omit
}),
options.auto ?? false
);
};
}
var src_default = createPersistedState();
const MyPreset = definePreset(index, {
//Your customizations, see the following sections for examples
primitive: {
warning: "{yellow.500}"
},
semantic: {
primary: {
50: "{indigo.50}",
100: "{indigo.100}",
200: "{indigo.200}",
300: "{indigo.300}",
400: "{indigo.400}",
500: "{indigo.500}",
600: "{indigo.600}",
700: "{indigo.700}",
800: "{indigo.800}",
900: "{indigo.900}",
950: "{indigo.950}"
}
}
});
const app = createApp(App);
app.use(PrimeVue, {
theme: {
preset: MyPreset,
options: {
darkModeSelector: ".dark"
}
}
});
const pinia = createPinia();
pinia.use(src_default);
app.use(pinia);
app.use(router);
function addCorrectAnswerDiv() {
const newSpot = document.createElement("div");
const spotBefore = document.getElementById("turbo-body");
newSpot.id = "ReviewsPlus";
if (spotBefore == null) {
console.log("turbo-body not found");
} else {
spotBefore.after(newSpot);
}
}
function addChangelogDiv() {
const newSpot = document.createElement("div");
const spotBefore = document.getElementsByClassName("dashboard__content")[0];
newSpot.id = "reviewsPlusChangelog";
newSpot.classList.add("hidden");
if (spotBefore == null) {
console.log("Could not find dashboard__content");
} else {
spotBefore.before(newSpot);
}
}
function addTallyDiv() {
const spotBefore = document.querySelector("#turbo-body");
if (spotBefore == null) return;
const newSpot = document.createElement("div");
newSpot.id = "tallyDiv";
newSpot.classList.add("home");
if (spotBefore == null) {
console.log("Could not find #turbo-body");
} else {
spotBefore.after(newSpot);
}
}
{
addCorrectAnswerDiv();
addTallyDiv();
addChangelogDiv();
app.mount("#ReviewsPlus");
}
// Create our shared stylesheet:
const sheet = new CSSStyleSheet();
sheet.replaceSync(`
.quiz-input__input-container[correct=true] #user-response,
.quiz-input__input-container[correct=false] #user-response {
color: white;
}
#dashboardTallyDiv {
margin: 25px;
}
#dashboardTallyDiv #btnCloseTally {
cursor: pointer;
border: 1px solid black;
padding: 5px;
border-radius: 6px;
margin-bottom: 20px;
}
#divTallyCorrect, #divTallyIncorrect {
border-radius: 6px;
padding: 10px;
border: 2px solid darkgray;
}
#answerDiv2 {
width: 100%;
font-weight: 400;
line-height: 1.4;
text-shadow: 0 1px 0 #fff;
box-shadow: 3px 3px 0 #e1e1e1;
text-align: center;
padding: 10px;
appearance: none;
-webkit-appearance: none;
outline: none;
border: 2px solid rgba(0, 0, 0, 0);
background-color: var(--color-quiz-input-background);
}
#answerDiv2 .primary {
font-size: 22px;
}
#answerDiv2 .secondary {
font-size: 16px;
}
#answerDiv2.correct {
background-color: var(--color-quiz-correct-background);
}
.dark #answerDiv2.correct {
background-color: var(--color-quiz-correct-background-breeze-dark);
}
#answerDiv2.incorrect {
background-color: var(--color-quiz-incorrect-background);
}
.dark #answerDiv2.incorrect {
background-color: var(--color-quiz-incorrect-background-breeze-dark);
}
#answerDiv2.unanswered {
display: none;
}
#answerDiv2 span {
color: var(--color-quiz-correct-text-color);
text-shadow: var(--color-quiz-correct-text-shadow);
caret-color: var(--color-quiz-correct-background);
}
@supports (container-type: inline-size) {
@container (min-width: 768px) {
#answerDiv2 {
padding: var(--spacing-tight) var(--spacing-normal);
font-size: 22px;
}
}
}
@supports not (container-type: inline-size) {
@media only screen and (min-width: 768px) {
#answerDiv2 {
padding: var(--spacing-tight) var(--spacing-normal);
font-size: 22px;
}
}
}
#debugDiv {
color: red;
}
#reviewsPlusChangelog .p-message {
background: deeppink;
color: white;
padding: 20px;
border-radius: 6px;
margin-bottom: 20px;
}
#reviewsPlusChangelog .p-message .hidden {
display: none;
}
#reviewsPlusChangelog .p-message-close-button {
position: relative;
top: -40px;
right: -25px;
}
#breakdownDiv {
position: absolute;
}
#breakdownDiv #breakdownDiv2 {
padding: 10px;
min-width: 200px;
border-radius: 6px;
font-size: 22px;
min-height: 120px;
line-height: 1.2;
display: contents;
}
#breakdownDiv #breakdownDiv2 span {
margin-left: 10px;
}
#tallyDiv .hidden {
display: none;
}
#divTallyCorrect,
#divTallyIncorrect {
display: flex;
flex-direction: column;
word-break: keep-all;
}
#divTallyCorrect .label,
#divTallyIncorrect .label {
font-size: 25px;
font-weight: 500;
}
#divTallyCorrect .tallyList,
#divTallyIncorrect .tallyList {
display: flex;
flex-wrap: wrap;
}
#divTallyCorrect .tallyList .tallyItem,
#divTallyIncorrect .tallyList .tallyItem {
border: 2px solid gray !important;
border-radius: 6px !important;
margin: 0 var(--spacing-xtight) var(--spacing-tight) 0 !important;
color: white !important;
padding: var(--spacing-xtight) !important;
font-size: var(--font-size-large) !important;
box-shadow: 0 -3px 0 rgba(0, 0, 0, 0.2) inset, 0 0 10px rgba(255, 255, 255, 0.5);
min-width: calc(24px + 2 * var(--spacing-xtight)) !important;
text-align: center !important;
text-shadow: var(--text-shadow-dark) !important;
color: var(--color-character-text) !important;
}
#divTallyCorrect .tallyList .tallyItem.vocabulary,
#divTallyIncorrect .tallyList .tallyItem.vocabulary {
background-color: var(--color-vocabulary) !important;
background-image: var(--color-vocabulary-gradient) !important;
}
#divTallyCorrect .tallyList .tallyItem.kanji,
#divTallyIncorrect .tallyList .tallyItem.kanji {
background-color: var(--color-kanji) !important;
background-image: var(--color-kanji-gradient) !important;
}
#divTallyCorrect .tallyList .tallyItem.radical,
#divTallyIncorrect .tallyList .tallyItem.radical {
background-color: var(--color-radical) !important;
background-image: var(--color-radical-gradient) !important;
}
#turbo-body.hidden {
display: none;
}
.itemDetails .characters {
font-size: 4rem;
}
.itemDetails .header {
padding-right: 5px;
}
.itemDetails .radicals {
display: flex;
}
:root {
--color-quiz-incorrect-background-breeze-dark: #ed1515;
--color-quiz-correct-background-breeze-dark: #2ecc71;
}.characters[data-v-07c47839] {
font-size: 4rem;
}
.primary .title[data-v-07c47839] {
font-weight: bold;
}
.secondary[data-v-07c47839] {
font-size: 0.8rem;
}.title[data-v-04434c1c] {
font-size: 2rem;
}
.version[data-v-04434c1c] {
display: flex;
}
.version .number[data-v-04434c1c] {
padding-right: 10px;
}
/* header {
line-height: 1.5;
max-height: 100vh;
}
.logo {
display: block;
margin: 0 auto 2rem;
}
nav {
width: 100%;
font-size: 12px;
text-align: center;
margin-top: 2rem;
}
nav a.router-link-exact-active {
color: var(--color-text);
}
nav a.router-link-exact-active:hover {
background-color: transparent;
}
nav a {
display: inline-block;
padding: 0 1rem;
border-left: 1px solid var(--color-border);
}
nav a:first-of-type {
border: 0;
}
@media (min-width: 1024px) {
header {
display: flex;
place-items: center;
padding-right: calc(var(--section-gap) / 2);
}
.logo {
margin: 0 2rem 0 0;
}
header .wrapper {
display: flex;
place-items: flex-start;
flex-wrap: wrap;
}
nav {
text-align: left;
margin-left: -1rem;
font-size: 1rem;
padding: 1rem 0;
margin-top: 1rem;
}
} */
`);
// Apply the stylesheet to a document:
document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
