@wilboerht/blog-template
Version:
A modern bilingual blog template built with VitePress
1,837 lines (1,835 loc) • 267 kB
JavaScript
import {
del,
isVue2,
isVue3,
set
} from "./chunk-O3YQPVDG.js";
import {
Fragment,
TransitionGroup,
computed,
customRef,
defineComponent,
effectScope,
getCurrentInstance,
getCurrentScope,
h,
inject,
isReactive,
isReadonly,
isRef,
markRaw,
nextTick,
onBeforeMount,
onBeforeUnmount,
onBeforeUpdate,
onMounted,
onScopeDispose,
onUnmounted,
onUpdated,
provide,
reactive,
readonly,
ref,
shallowReactive,
shallowRef,
toRaw,
toRef,
toRefs,
unref,
version,
watch,
watchEffect
} from "./chunk-LW4I4DCF.js";
// node_modules/vitepress/node_modules/@vueuse/shared/index.mjs
function computedEager(fn, options) {
var _a;
const result = shallowRef();
watchEffect(() => {
result.value = fn();
}, {
...options,
flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
});
return readonly(result);
}
function computedWithControl(source, fn) {
let v = void 0;
let track;
let trigger;
const dirty = ref(true);
const update = () => {
dirty.value = true;
trigger();
};
watch(source, update, { flush: "sync" });
const get2 = typeof fn === "function" ? fn : fn.get;
const set3 = typeof fn === "function" ? void 0 : fn.set;
const result = customRef((_track, _trigger) => {
track = _track;
trigger = _trigger;
return {
get() {
if (dirty.value) {
v = get2(v);
dirty.value = false;
}
track();
return v;
},
set(v2) {
set3 == null ? void 0 : set3(v2);
}
};
});
if (Object.isExtensible(result))
result.trigger = update;
return result;
}
function tryOnScopeDispose(fn) {
if (getCurrentScope()) {
onScopeDispose(fn);
return true;
}
return false;
}
function createEventHook() {
const fns = /* @__PURE__ */ new Set();
const off = (fn) => {
fns.delete(fn);
};
const on = (fn) => {
fns.add(fn);
const offFn = () => off(fn);
tryOnScopeDispose(offFn);
return {
off: offFn
};
};
const trigger = (...args) => {
return Promise.all(Array.from(fns).map((fn) => fn(...args)));
};
return {
on,
off,
trigger
};
}
function createGlobalState(stateFactory) {
let initialized = false;
let state;
const scope = effectScope(true);
return (...args) => {
if (!initialized) {
state = scope.run(() => stateFactory(...args));
initialized = true;
}
return state;
};
}
var localProvidedStateMap = /* @__PURE__ */ new WeakMap();
var injectLocal = (...args) => {
var _a;
const key = args[0];
const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
if (instance == null)
throw new Error("injectLocal must be called in setup");
if (localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance))
return localProvidedStateMap.get(instance)[key];
return inject(...args);
};
var provideLocal = (key, value) => {
var _a;
const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
if (instance == null)
throw new Error("provideLocal must be called in setup");
if (!localProvidedStateMap.has(instance))
localProvidedStateMap.set(instance, /* @__PURE__ */ Object.create(null));
const localProvidedState = localProvidedStateMap.get(instance);
localProvidedState[key] = value;
provide(key, value);
};
function createInjectionState(composable, options) {
const key = (options == null ? void 0 : options.injectionKey) || Symbol(composable.name || "InjectionState");
const defaultValue = options == null ? void 0 : options.defaultValue;
const useProvidingState = (...args) => {
const state = composable(...args);
provideLocal(key, state);
return state;
};
const useInjectedState = () => injectLocal(key, defaultValue);
return [useProvidingState, useInjectedState];
}
function createSharedComposable(composable) {
let subscribers = 0;
let state;
let scope;
const dispose = () => {
subscribers -= 1;
if (scope && subscribers <= 0) {
scope.stop();
state = void 0;
scope = void 0;
}
};
return (...args) => {
subscribers += 1;
if (!scope) {
scope = effectScope(true);
state = scope.run(() => composable(...args));
}
tryOnScopeDispose(dispose);
return state;
};
}
function extendRef(ref2, extend, { enumerable = false, unwrap = true } = {}) {
if (!isVue3 && !version.startsWith("2.7.")) {
if (true)
throw new Error("[VueUse] extendRef only works in Vue 2.7 or above.");
return;
}
for (const [key, value] of Object.entries(extend)) {
if (key === "value")
continue;
if (isRef(value) && unwrap) {
Object.defineProperty(ref2, key, {
get() {
return value.value;
},
set(v) {
value.value = v;
},
enumerable
});
} else {
Object.defineProperty(ref2, key, { value, enumerable });
}
}
return ref2;
}
function get(obj, key) {
if (key == null)
return unref(obj);
return unref(obj)[key];
}
function isDefined(v) {
return unref(v) != null;
}
function makeDestructurable(obj, arr) {
if (typeof Symbol !== "undefined") {
const clone = { ...obj };
Object.defineProperty(clone, Symbol.iterator, {
enumerable: false,
value() {
let index = 0;
return {
next: () => ({
value: arr[index++],
done: index > arr.length
})
};
}
});
return clone;
} else {
return Object.assign([...arr], obj);
}
}
function toValue(r) {
return typeof r === "function" ? r() : unref(r);
}
var resolveUnref = toValue;
function reactify(fn, options) {
const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? unref : toValue;
return function(...args) {
return computed(() => fn.apply(this, args.map((i) => unrefFn(i))));
};
}
function reactifyObject(obj, optionsOrKeys = {}) {
let keys2 = [];
let options;
if (Array.isArray(optionsOrKeys)) {
keys2 = optionsOrKeys;
} else {
options = optionsOrKeys;
const { includeOwnProperties = true } = optionsOrKeys;
keys2.push(...Object.keys(obj));
if (includeOwnProperties)
keys2.push(...Object.getOwnPropertyNames(obj));
}
return Object.fromEntries(
keys2.map((key) => {
const value = obj[key];
return [
key,
typeof value === "function" ? reactify(value.bind(obj), options) : value
];
})
);
}
function toReactive(objectRef) {
if (!isRef(objectRef))
return reactive(objectRef);
const proxy = new Proxy({}, {
get(_, p, receiver) {
return unref(Reflect.get(objectRef.value, p, receiver));
},
set(_, p, value) {
if (isRef(objectRef.value[p]) && !isRef(value))
objectRef.value[p].value = value;
else
objectRef.value[p] = value;
return true;
},
deleteProperty(_, p) {
return Reflect.deleteProperty(objectRef.value, p);
},
has(_, p) {
return Reflect.has(objectRef.value, p);
},
ownKeys() {
return Object.keys(objectRef.value);
},
getOwnPropertyDescriptor() {
return {
enumerable: true,
configurable: true
};
}
});
return reactive(proxy);
}
function reactiveComputed(fn) {
return toReactive(computed(fn));
}
function reactiveOmit(obj, ...keys2) {
const flatKeys = keys2.flat();
const predicate = flatKeys[0];
return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs(obj)).filter(([k, v]) => !predicate(toValue(v), k))) : Object.fromEntries(Object.entries(toRefs(obj)).filter((e) => !flatKeys.includes(e[0]))));
}
var directiveHooks = {
mounted: isVue3 ? "mounted" : "inserted",
updated: isVue3 ? "updated" : "componentUpdated",
unmounted: isVue3 ? "unmounted" : "unbind"
};
var isClient = typeof window !== "undefined" && typeof document !== "undefined";
var isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
var isDef = (val) => typeof val !== "undefined";
var notNullish = (val) => val != null;
var assert = (condition, ...infos) => {
if (!condition)
console.warn(...infos);
};
var toString = Object.prototype.toString;
var isObject = (val) => toString.call(val) === "[object Object]";
var now = () => Date.now();
var timestamp = () => +Date.now();
var clamp = (n, min, max) => Math.min(max, Math.max(min, n));
var noop = () => {
};
var rand = (min, max) => {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
};
var hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);
var isIOS = getIsIOS();
function getIsIOS() {
var _a, _b;
return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
}
function createFilterWrapper(filter, fn) {
function wrapper(...args) {
return new Promise((resolve, reject) => {
Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);
});
}
return wrapper;
}
var bypassFilter = (invoke2) => {
return invoke2();
};
function debounceFilter(ms, options = {}) {
let timer;
let maxTimer;
let lastRejector = noop;
const _clearTimeout = (timer2) => {
clearTimeout(timer2);
lastRejector();
lastRejector = noop;
};
const filter = (invoke2) => {
const duration = toValue(ms);
const maxDuration = toValue(options.maxWait);
if (timer)
_clearTimeout(timer);
if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
if (maxTimer) {
_clearTimeout(maxTimer);
maxTimer = null;
}
return Promise.resolve(invoke2());
}
return new Promise((resolve, reject) => {
lastRejector = options.rejectOnCancel ? reject : resolve;
if (maxDuration && !maxTimer) {
maxTimer = setTimeout(() => {
if (timer)
_clearTimeout(timer);
maxTimer = null;
resolve(invoke2());
}, maxDuration);
}
timer = setTimeout(() => {
if (maxTimer)
_clearTimeout(maxTimer);
maxTimer = null;
resolve(invoke2());
}, duration);
});
};
return filter;
}
function throttleFilter(...args) {
let lastExec = 0;
let timer;
let isLeading = true;
let lastRejector = noop;
let lastValue;
let ms;
let trailing;
let leading;
let rejectOnCancel;
if (!isRef(args[0]) && typeof args[0] === "object")
({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]);
else
[ms, trailing = true, leading = true, rejectOnCancel = false] = args;
const clear = () => {
if (timer) {
clearTimeout(timer);
timer = void 0;
lastRejector();
lastRejector = noop;
}
};
const filter = (_invoke) => {
const duration = toValue(ms);
const elapsed = Date.now() - lastExec;
const invoke2 = () => {
return lastValue = _invoke();
};
clear();
if (duration <= 0) {
lastExec = Date.now();
return invoke2();
}
if (elapsed > duration && (leading || !isLeading)) {
lastExec = Date.now();
invoke2();
} else if (trailing) {
lastValue = new Promise((resolve, reject) => {
lastRejector = rejectOnCancel ? reject : resolve;
timer = setTimeout(() => {
lastExec = Date.now();
isLeading = true;
resolve(invoke2());
clear();
}, Math.max(0, duration - elapsed));
});
}
if (!leading && !timer)
timer = setTimeout(() => isLeading = true, duration);
isLeading = false;
return lastValue;
};
return filter;
}
function pausableFilter(extendFilter = bypassFilter) {
const isActive = ref(true);
function pause() {
isActive.value = false;
}
function resume() {
isActive.value = true;
}
const eventFilter = (...args) => {
if (isActive.value)
extendFilter(...args);
};
return { isActive: readonly(isActive), pause, resume, eventFilter };
}
function cacheStringFunction(fn) {
const cache = /* @__PURE__ */ Object.create(null);
return (str) => {
const hit = cache[str];
return hit || (cache[str] = fn(str));
};
}
var hyphenateRE = /\B([A-Z])/g;
var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
var camelizeRE = /-(\w)/g;
var camelize = cacheStringFunction((str) => {
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
});
function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
return new Promise((resolve, reject) => {
if (throwOnTimeout)
setTimeout(() => reject(reason), ms);
else
setTimeout(resolve, ms);
});
}
function identity(arg) {
return arg;
}
function createSingletonPromise(fn) {
let _promise;
function wrapper() {
if (!_promise)
_promise = fn();
return _promise;
}
wrapper.reset = async () => {
const _prev = _promise;
_promise = void 0;
if (_prev)
await _prev;
};
return wrapper;
}
function invoke(fn) {
return fn();
}
function containsProp(obj, ...props) {
return props.some((k) => k in obj);
}
function increaseWithUnit(target, delta) {
var _a;
if (typeof target === "number")
return target + delta;
const value = ((_a = target.match(/^-?\d+\.?\d*/)) == null ? void 0 : _a[0]) || "";
const unit = target.slice(value.length);
const result = Number.parseFloat(value) + delta;
if (Number.isNaN(result))
return target;
return result + unit;
}
function objectPick(obj, keys2, omitUndefined = false) {
return keys2.reduce((n, k) => {
if (k in obj) {
if (!omitUndefined || obj[k] !== void 0)
n[k] = obj[k];
}
return n;
}, {});
}
function objectOmit(obj, keys2, omitUndefined = false) {
return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
return (!omitUndefined || value !== void 0) && !keys2.includes(key);
}));
}
function objectEntries(obj) {
return Object.entries(obj);
}
function getLifeCycleTarget(target) {
return target || getCurrentInstance();
}
function toRef2(...args) {
if (args.length !== 1)
return toRef(...args);
const r = args[0];
return typeof r === "function" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);
}
var resolveRef = toRef2;
function reactivePick(obj, ...keys2) {
const flatKeys = keys2.flat();
const predicate = flatKeys[0];
return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(toRefs(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef2(obj, k)])));
}
function refAutoReset(defaultValue, afterMs = 1e4) {
return customRef((track, trigger) => {
let value = toValue(defaultValue);
let timer;
const resetAfter = () => setTimeout(() => {
value = toValue(defaultValue);
trigger();
}, toValue(afterMs));
tryOnScopeDispose(() => {
clearTimeout(timer);
});
return {
get() {
track();
return value;
},
set(newValue) {
value = newValue;
trigger();
clearTimeout(timer);
timer = resetAfter();
}
};
});
}
function useDebounceFn(fn, ms = 200, options = {}) {
return createFilterWrapper(
debounceFilter(ms, options),
fn
);
}
function refDebounced(value, ms = 200, options = {}) {
const debounced = ref(value.value);
const updater = useDebounceFn(() => {
debounced.value = value.value;
}, ms, options);
watch(value, () => updater());
return debounced;
}
function refDefault(source, defaultValue) {
return computed({
get() {
var _a;
return (_a = source.value) != null ? _a : defaultValue;
},
set(value) {
source.value = value;
}
});
}
function useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {
return createFilterWrapper(
throttleFilter(ms, trailing, leading, rejectOnCancel),
fn
);
}
function refThrottled(value, delay = 200, trailing = true, leading = true) {
if (delay <= 0)
return value;
const throttled = ref(value.value);
const updater = useThrottleFn(() => {
throttled.value = value.value;
}, delay, trailing, leading);
watch(value, () => updater());
return throttled;
}
function refWithControl(initial, options = {}) {
let source = initial;
let track;
let trigger;
const ref2 = customRef((_track, _trigger) => {
track = _track;
trigger = _trigger;
return {
get() {
return get2();
},
set(v) {
set3(v);
}
};
});
function get2(tracking = true) {
if (tracking)
track();
return source;
}
function set3(value, triggering = true) {
var _a, _b;
if (value === source)
return;
const old = source;
if (((_a = options.onBeforeChange) == null ? void 0 : _a.call(options, value, old)) === false)
return;
source = value;
(_b = options.onChanged) == null ? void 0 : _b.call(options, value, old);
if (triggering)
trigger();
}
const untrackedGet = () => get2(false);
const silentSet = (v) => set3(v, false);
const peek = () => get2(false);
const lay = (v) => set3(v, false);
return extendRef(
ref2,
{
get: get2,
set: set3,
untrackedGet,
silentSet,
peek,
lay
},
{ enumerable: true }
);
}
var controlledRef = refWithControl;
function set2(...args) {
if (args.length === 2) {
const [ref2, value] = args;
ref2.value = value;
}
if (args.length === 3) {
if (isVue2) {
set(...args);
} else {
const [target, key, value] = args;
target[key] = value;
}
}
}
function watchWithFilter(source, cb, options = {}) {
const {
eventFilter = bypassFilter,
...watchOptions
} = options;
return watch(
source,
createFilterWrapper(
eventFilter,
cb
),
watchOptions
);
}
function watchPausable(source, cb, options = {}) {
const {
eventFilter: filter,
...watchOptions
} = options;
const { eventFilter, pause, resume, isActive } = pausableFilter(filter);
const stop = watchWithFilter(
source,
cb,
{
...watchOptions,
eventFilter
}
);
return { stop, pause, resume, isActive };
}
function syncRef(left, right, ...[options]) {
const {
flush = "sync",
deep = false,
immediate = true,
direction = "both",
transform = {}
} = options || {};
const watchers = [];
const transformLTR = "ltr" in transform && transform.ltr || ((v) => v);
const transformRTL = "rtl" in transform && transform.rtl || ((v) => v);
if (direction === "both" || direction === "ltr") {
watchers.push(watchPausable(
left,
(newValue) => {
watchers.forEach((w) => w.pause());
right.value = transformLTR(newValue);
watchers.forEach((w) => w.resume());
},
{ flush, deep, immediate }
));
}
if (direction === "both" || direction === "rtl") {
watchers.push(watchPausable(
right,
(newValue) => {
watchers.forEach((w) => w.pause());
left.value = transformRTL(newValue);
watchers.forEach((w) => w.resume());
},
{ flush, deep, immediate }
));
}
const stop = () => {
watchers.forEach((w) => w.stop());
};
return stop;
}
function syncRefs(source, targets, options = {}) {
const {
flush = "sync",
deep = false,
immediate = true
} = options;
if (!Array.isArray(targets))
targets = [targets];
return watch(
source,
(newValue) => targets.forEach((target) => target.value = newValue),
{ flush, deep, immediate }
);
}
function toRefs2(objectRef, options = {}) {
if (!isRef(objectRef))
return toRefs(objectRef);
const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
for (const key in objectRef.value) {
result[key] = customRef(() => ({
get() {
return objectRef.value[key];
},
set(v) {
var _a;
const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;
if (replaceRef) {
if (Array.isArray(objectRef.value)) {
const copy = [...objectRef.value];
copy[key] = v;
objectRef.value = copy;
} else {
const newObject = { ...objectRef.value, [key]: v };
Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));
objectRef.value = newObject;
}
} else {
objectRef.value[key] = v;
}
}
}));
}
return result;
}
function tryOnBeforeMount(fn, sync = true, target) {
const instance = getLifeCycleTarget(target);
if (instance)
onBeforeMount(fn, target);
else if (sync)
fn();
else
nextTick(fn);
}
function tryOnBeforeUnmount(fn, target) {
const instance = getLifeCycleTarget(target);
if (instance)
onBeforeUnmount(fn, target);
}
function tryOnMounted(fn, sync = true, target) {
const instance = getLifeCycleTarget();
if (instance)
onMounted(fn, target);
else if (sync)
fn();
else
nextTick(fn);
}
function tryOnUnmounted(fn, target) {
const instance = getLifeCycleTarget(target);
if (instance)
onUnmounted(fn, target);
}
function createUntil(r, isNot = false) {
function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
let stop = null;
const watcher = new Promise((resolve) => {
stop = watch(
r,
(v) => {
if (condition(v) !== isNot) {
if (stop)
stop();
else
nextTick(() => stop == null ? void 0 : stop());
resolve(v);
}
},
{
flush,
deep,
immediate: true
}
);
});
const promises = [watcher];
if (timeout != null) {
promises.push(
promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop())
);
}
return Promise.race(promises);
}
function toBe(value, options) {
if (!isRef(value))
return toMatch((v) => v === value, options);
const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
let stop = null;
const watcher = new Promise((resolve) => {
stop = watch(
[r, value],
([v1, v2]) => {
if (isNot !== (v1 === v2)) {
if (stop)
stop();
else
nextTick(() => stop == null ? void 0 : stop());
resolve(v1);
}
},
{
flush,
deep,
immediate: true
}
);
});
const promises = [watcher];
if (timeout != null) {
promises.push(
promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
stop == null ? void 0 : stop();
return toValue(r);
})
);
}
return Promise.race(promises);
}
function toBeTruthy(options) {
return toMatch((v) => Boolean(v), options);
}
function toBeNull(options) {
return toBe(null, options);
}
function toBeUndefined(options) {
return toBe(void 0, options);
}
function toBeNaN(options) {
return toMatch(Number.isNaN, options);
}
function toContains(value, options) {
return toMatch((v) => {
const array = Array.from(v);
return array.includes(value) || array.includes(toValue(value));
}, options);
}
function changed(options) {
return changedTimes(1, options);
}
function changedTimes(n = 1, options) {
let count = -1;
return toMatch(() => {
count += 1;
return count >= n;
}, options);
}
if (Array.isArray(toValue(r))) {
const instance = {
toMatch,
toContains,
changed,
changedTimes,
get not() {
return createUntil(r, !isNot);
}
};
return instance;
} else {
const instance = {
toMatch,
toBe,
toBeTruthy,
toBeNull,
toBeNaN,
toBeUndefined,
changed,
changedTimes,
get not() {
return createUntil(r, !isNot);
}
};
return instance;
}
}
function until(r) {
return createUntil(r);
}
function defaultComparator(value, othVal) {
return value === othVal;
}
function useArrayDifference(...args) {
var _a;
const list = args[0];
const values = args[1];
let compareFn = (_a = args[2]) != null ? _a : defaultComparator;
if (typeof compareFn === "string") {
const key = compareFn;
compareFn = (value, othVal) => value[key] === othVal[key];
}
return computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));
}
function useArrayEvery(list, fn) {
return computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));
}
function useArrayFilter(list, fn) {
return computed(() => toValue(list).map((i) => toValue(i)).filter(fn));
}
function useArrayFind(list, fn) {
return computed(() => toValue(
toValue(list).find((element, index, array) => fn(toValue(element), index, array))
));
}
function useArrayFindIndex(list, fn) {
return computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));
}
function findLast(arr, cb) {
let index = arr.length;
while (index-- > 0) {
if (cb(arr[index], index, arr))
return arr[index];
}
return void 0;
}
function useArrayFindLast(list, fn) {
return computed(() => toValue(
!Array.prototype.findLast ? findLast(toValue(list), (element, index, array) => fn(toValue(element), index, array)) : toValue(list).findLast((element, index, array) => fn(toValue(element), index, array))
));
}
function isArrayIncludesOptions(obj) {
return isObject(obj) && containsProp(obj, "formIndex", "comparator");
}
function useArrayIncludes(...args) {
var _a;
const list = args[0];
const value = args[1];
let comparator = args[2];
let formIndex = 0;
if (isArrayIncludesOptions(comparator)) {
formIndex = (_a = comparator.fromIndex) != null ? _a : 0;
comparator = comparator.comparator;
}
if (typeof comparator === "string") {
const key = comparator;
comparator = (element, value2) => element[key] === toValue(value2);
}
comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);
return computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(
toValue(element),
toValue(value),
index,
toValue(array)
)));
}
function useArrayJoin(list, separator) {
return computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));
}
function useArrayMap(list, fn) {
return computed(() => toValue(list).map((i) => toValue(i)).map(fn));
}
function useArrayReduce(list, reducer, ...args) {
const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);
return computed(() => {
const resolved = toValue(list);
return args.length ? resolved.reduce(reduceCallback, typeof args[0] === "function" ? toValue(args[0]()) : toValue(args[0])) : resolved.reduce(reduceCallback);
});
}
function useArraySome(list, fn) {
return computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));
}
function uniq(array) {
return Array.from(new Set(array));
}
function uniqueElementsBy(array, fn) {
return array.reduce((acc, v) => {
if (!acc.some((x) => fn(v, x, array)))
acc.push(v);
return acc;
}, []);
}
function useArrayUnique(list, compareFn) {
return computed(() => {
const resolvedList = toValue(list).map((element) => toValue(element));
return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);
});
}
function useCounter(initialValue = 0, options = {}) {
let _initialValue = unref(initialValue);
const count = ref(initialValue);
const {
max = Number.POSITIVE_INFINITY,
min = Number.NEGATIVE_INFINITY
} = options;
const inc = (delta = 1) => count.value = Math.max(Math.min(max, count.value + delta), min);
const dec = (delta = 1) => count.value = Math.min(Math.max(min, count.value - delta), max);
const get2 = () => count.value;
const set3 = (val) => count.value = Math.max(min, Math.min(max, val));
const reset = (val = _initialValue) => {
_initialValue = val;
return set3(val);
};
return { count, inc, dec, get: get2, set: set3, reset };
}
var REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[T\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/i;
var REGEX_FORMAT = /[YMDHhms]o|\[([^\]]+)\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
function defaultMeridiem(hours, minutes, isLowercase, hasPeriod) {
let m = hours < 12 ? "AM" : "PM";
if (hasPeriod)
m = m.split("").reduce((acc, curr) => acc += `${curr}.`, "");
return isLowercase ? m.toLowerCase() : m;
}
function formatOrdinal(num) {
const suffixes = ["th", "st", "nd", "rd"];
const v = num % 100;
return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);
}
function formatDate(date, formatStr, options = {}) {
var _a;
const years = date.getFullYear();
const month = date.getMonth();
const days = date.getDate();
const hours = date.getHours();
const minutes = date.getMinutes();
const seconds = date.getSeconds();
const milliseconds = date.getMilliseconds();
const day = date.getDay();
const meridiem = (_a = options.customMeridiem) != null ? _a : defaultMeridiem;
const matches = {
Yo: () => formatOrdinal(years),
YY: () => String(years).slice(-2),
YYYY: () => years,
M: () => month + 1,
Mo: () => formatOrdinal(month + 1),
MM: () => `${month + 1}`.padStart(2, "0"),
MMM: () => date.toLocaleDateString(toValue(options.locales), { month: "short" }),
MMMM: () => date.toLocaleDateString(toValue(options.locales), { month: "long" }),
D: () => String(days),
Do: () => formatOrdinal(days),
DD: () => `${days}`.padStart(2, "0"),
H: () => String(hours),
Ho: () => formatOrdinal(hours),
HH: () => `${hours}`.padStart(2, "0"),
h: () => `${hours % 12 || 12}`.padStart(1, "0"),
ho: () => formatOrdinal(hours % 12 || 12),
hh: () => `${hours % 12 || 12}`.padStart(2, "0"),
m: () => String(minutes),
mo: () => formatOrdinal(minutes),
mm: () => `${minutes}`.padStart(2, "0"),
s: () => String(seconds),
so: () => formatOrdinal(seconds),
ss: () => `${seconds}`.padStart(2, "0"),
SSS: () => `${milliseconds}`.padStart(3, "0"),
d: () => day,
dd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "narrow" }),
ddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "short" }),
dddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: "long" }),
A: () => meridiem(hours, minutes),
AA: () => meridiem(hours, minutes, false, true),
a: () => meridiem(hours, minutes, true),
aa: () => meridiem(hours, minutes, true, true)
};
return formatStr.replace(REGEX_FORMAT, (match, $1) => {
var _a2, _b;
return (_b = $1 != null ? $1 : (_a2 = matches[match]) == null ? void 0 : _a2.call(matches)) != null ? _b : match;
});
}
function normalizeDate(date) {
if (date === null)
return new Date(Number.NaN);
if (date === void 0)
return /* @__PURE__ */ new Date();
if (date instanceof Date)
return new Date(date);
if (typeof date === "string" && !/Z$/i.test(date)) {
const d = date.match(REGEX_PARSE);
if (d) {
const m = d[2] - 1 || 0;
const ms = (d[7] || "0").substring(0, 3);
return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
}
}
return new Date(date);
}
function useDateFormat(date, formatStr = "HH:mm:ss", options = {}) {
return computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));
}
function useIntervalFn(cb, interval = 1e3, options = {}) {
const {
immediate = true,
immediateCallback = false
} = options;
let timer = null;
const isActive = ref(false);
function clean() {
if (timer) {
clearInterval(timer);
timer = null;
}
}
function pause() {
isActive.value = false;
clean();
}
function resume() {
const intervalValue = toValue(interval);
if (intervalValue <= 0)
return;
isActive.value = true;
if (immediateCallback)
cb();
clean();
if (isActive.value)
timer = setInterval(cb, intervalValue);
}
if (immediate && isClient)
resume();
if (isRef(interval) || typeof interval === "function") {
const stopWatch = watch(interval, () => {
if (isActive.value && isClient)
resume();
});
tryOnScopeDispose(stopWatch);
}
tryOnScopeDispose(pause);
return {
isActive,
pause,
resume
};
}
function useInterval(interval = 1e3, options = {}) {
const {
controls: exposeControls = false,
immediate = true,
callback
} = options;
const counter = ref(0);
const update = () => counter.value += 1;
const reset = () => {
counter.value = 0;
};
const controls = useIntervalFn(
callback ? () => {
update();
callback(counter.value);
} : update,
interval,
{ immediate }
);
if (exposeControls) {
return {
counter,
reset,
...controls
};
} else {
return counter;
}
}
function useLastChanged(source, options = {}) {
var _a;
const ms = ref((_a = options.initialValue) != null ? _a : null);
watch(
source,
() => ms.value = timestamp(),
options
);
return ms;
}
function useTimeoutFn(cb, interval, options = {}) {
const {
immediate = true
} = options;
const isPending = ref(false);
let timer = null;
function clear() {
if (timer) {
clearTimeout(timer);
timer = null;
}
}
function stop() {
isPending.value = false;
clear();
}
function start(...args) {
clear();
isPending.value = true;
timer = setTimeout(() => {
isPending.value = false;
timer = null;
cb(...args);
}, toValue(interval));
}
if (immediate) {
isPending.value = true;
if (isClient)
start();
}
tryOnScopeDispose(stop);
return {
isPending: readonly(isPending),
start,
stop
};
}
function useTimeout(interval = 1e3, options = {}) {
const {
controls: exposeControls = false,
callback
} = options;
const controls = useTimeoutFn(
callback != null ? callback : noop,
interval,
options
);
const ready = computed(() => !controls.isPending.value);
if (exposeControls) {
return {
ready,
...controls
};
} else {
return ready;
}
}
function useToNumber(value, options = {}) {
const {
method = "parseFloat",
radix,
nanToZero
} = options;
return computed(() => {
let resolved = toValue(value);
if (typeof resolved === "string")
resolved = Number[method](resolved, radix);
if (nanToZero && Number.isNaN(resolved))
resolved = 0;
return resolved;
});
}
function useToString(value) {
return computed(() => `${toValue(value)}`);
}
function useToggle(initialValue = false, options = {}) {
const {
truthyValue = true,
falsyValue = false
} = options;
const valueIsRef = isRef(initialValue);
const _value = ref(initialValue);
function toggle(value) {
if (arguments.length) {
_value.value = value;
return _value.value;
} else {
const truthy = toValue(truthyValue);
_value.value = _value.value === truthy ? toValue(falsyValue) : truthy;
return _value.value;
}
}
if (valueIsRef)
return toggle;
else
return [_value, toggle];
}
function watchArray(source, cb, options) {
let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)];
return watch(source, (newList, _, onCleanup) => {
const oldListRemains = Array.from({ length: oldList.length });
const added = [];
for (const obj of newList) {
let found = false;
for (let i = 0; i < oldList.length; i++) {
if (!oldListRemains[i] && obj === oldList[i]) {
oldListRemains[i] = true;
found = true;
break;
}
}
if (!found)
added.push(obj);
}
const removed = oldList.filter((_2, i) => !oldListRemains[i]);
cb(newList, oldList, added, removed, onCleanup);
oldList = [...newList];
}, options);
}
function watchAtMost(source, cb, options) {
const {
count,
...watchOptions
} = options;
const current = ref(0);
const stop = watchWithFilter(
source,
(...args) => {
current.value += 1;
if (current.value >= toValue(count))
nextTick(() => stop());
cb(...args);
},
watchOptions
);
return { count: current, stop };
}
function watchDebounced(source, cb, options = {}) {
const {
debounce = 0,
maxWait = void 0,
...watchOptions
} = options;
return watchWithFilter(
source,
cb,
{
...watchOptions,
eventFilter: debounceFilter(debounce, { maxWait })
}
);
}
function watchDeep(source, cb, options) {
return watch(
source,
cb,
{
...options,
deep: true
}
);
}
function watchIgnorable(source, cb, options = {}) {
const {
eventFilter = bypassFilter,
...watchOptions
} = options;
const filteredCb = createFilterWrapper(
eventFilter,
cb
);
let ignoreUpdates;
let ignorePrevAsyncUpdates;
let stop;
if (watchOptions.flush === "sync") {
const ignore = ref(false);
ignorePrevAsyncUpdates = () => {
};
ignoreUpdates = (updater) => {
ignore.value = true;
updater();
ignore.value = false;
};
stop = watch(
source,
(...args) => {
if (!ignore.value)
filteredCb(...args);
},
watchOptions
);
} else {
const disposables = [];
const ignoreCounter = ref(0);
const syncCounter = ref(0);
ignorePrevAsyncUpdates = () => {
ignoreCounter.value = syncCounter.value;
};
disposables.push(
watch(
source,
() => {
syncCounter.value++;
},
{ ...watchOptions, flush: "sync" }
)
);
ignoreUpdates = (updater) => {
const syncCounterPrev = syncCounter.value;
updater();
ignoreCounter.value += syncCounter.value - syncCounterPrev;
};
disposables.push(
watch(
source,
(...args) => {
const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;
ignoreCounter.value = 0;
syncCounter.value = 0;
if (ignore)
return;
filteredCb(...args);
},
watchOptions
)
);
stop = () => {
disposables.forEach((fn) => fn());
};
}
return { stop, ignoreUpdates, ignorePrevAsyncUpdates };
}
function watchImmediate(source, cb, options) {
return watch(
source,
cb,
{
...options,
immediate: true
}
);
}
function watchOnce(source, cb, options) {
const stop = watch(source, (...args) => {
nextTick(() => stop());
return cb(...args);
}, options);
return stop;
}
function watchThrottled(source, cb, options = {}) {
const {
throttle = 0,
trailing = true,
leading = true,
...watchOptions
} = options;
return watchWithFilter(
source,
cb,
{
...watchOptions,
eventFilter: throttleFilter(throttle, trailing, leading)
}
);
}
function watchTriggerable(source, cb, options = {}) {
let cleanupFn;
function onEffect() {
if (!cleanupFn)
return;
const fn = cleanupFn;
cleanupFn = void 0;
fn();
}
function onCleanup(callback) {
cleanupFn = callback;
}
const _cb = (value, oldValue) => {
onEffect();
return cb(value, oldValue, onCleanup);
};
const res = watchIgnorable(source, _cb, options);
const { ignoreUpdates } = res;
const trigger = () => {
let res2;
ignoreUpdates(() => {
res2 = _cb(getWatchSources(source), getOldValue(source));
});
return res2;
};
return {
...res,
trigger
};
}
function getWatchSources(sources) {
if (isReactive(sources))
return sources;
if (Array.isArray(sources))
return sources.map((item) => toValue(item));
return toValue(sources);
}
function getOldValue(source) {
return Array.isArray(source) ? source.map(() => void 0) : void 0;
}
function whenever(source, cb, options) {
const stop = watch(
source,
(v, ov, onInvalidate) => {
if (v) {
if (options == null ? void 0 : options.once)
nextTick(() => stop());
cb(v, ov, onInvalidate);
}
},
{
...options,
once: false
}
);
return stop;
}
// node_modules/vitepress/node_modules/@vueuse/core/index.mjs
function computedAsync(evaluationCallback, initialState, optionsOrRef) {
let options;
if (isRef(optionsOrRef)) {
options = {
evaluating: optionsOrRef
};
} else {
options = optionsOrRef || {};
}
const {
lazy = false,
evaluating = void 0,
shallow = true,
onError = noop
} = options;
const started = ref(!lazy);
const current = shallow ? shallowRef(initialState) : ref(initialState);
let counter = 0;
watchEffect(async (onInvalidate) => {
if (!started.value)
return;
counter++;
const counterAtBeginning = counter;
let hasFinished = false;
if (evaluating) {
Promise.resolve().then(() => {
evaluating.value = true;
});
}
try {
const result = await evaluationCallback((cancelCallback) => {
onInvalidate(() => {
if (evaluating)
evaluating.value = false;
if (!hasFinished)
cancelCallback();
});
});
if (counterAtBeginning === counter)
current.value = result;
} catch (e) {
onError(e);
} finally {
if (evaluating && counterAtBeginning === counter)
evaluating.value = false;
hasFinished = true;
}
});
if (lazy) {
return computed(() => {
started.value = true;
return current.value;
});
} else {
return current;
}
}
function computedInject(key, options, defaultSource, treatDefaultAsFactory) {
let source = inject(key);
if (defaultSource)
source = inject(key, defaultSource);
if (treatDefaultAsFactory)
source = inject(key, defaultSource, treatDefaultAsFactory);
if (typeof options === "function") {
return computed((ctx) => options(source, ctx));
} else {
return computed({
get: (ctx) => options.get(source, ctx),
set: options.set
});
}
}
function createReusableTemplate(options = {}) {
if (!isVue3 && !version.startsWith("2.7.")) {
if (true)
throw new Error("[VueUse] createReusableTemplate only works in Vue 2.7 or above.");
return;
}
const {
inheritAttrs = true
} = options;
const render = shallowRef();
const define = defineComponent({
setup(_, { slots }) {
return () => {
render.value = slots.default;
};
}
});
const reuse = defineComponent({
inheritAttrs,
setup(_, { attrs, slots }) {
return () => {
var _a;
if (!render.value && true)
throw new Error("[VueUse] Failed to find the definition of reusable template");
const vnode = (_a = render.value) == null ? void 0 : _a.call(render, { ...keysToCamelKebabCase(attrs), $slots: slots });
return inheritAttrs && (vnode == null ? void 0 : vnode.length) === 1 ? vnode[0] : vnode;
};
}
});
return makeDestructurable(
{ define, reuse },
[define, reuse]
);
}
function keysToCamelKebabCase(obj) {
const newObj = {};
for (const key in obj)
newObj[camelize(key)] = obj[key];
return newObj;
}
function createTemplatePromise(options = {}) {
if (!isVue3) {
if (true)
throw new Error("[VueUse] createTemplatePromise only works in Vue 3 or above.");
return;
}
let index = 0;
const instances = ref([]);
function create(...args) {
const props = shallowReactive({
key: index++,
args,
promise: void 0,
resolve: () => {
},
reject: () => {
},
isResolving: false,
options
});
instances.value.push(props);
props.promise = new Promise((_resolve, _reject) => {
props.resolve = (v) => {
props.isResolving = true;
return _resolve(v);
};
props.reject = _reject;
}).finally(() => {
props.promise = void 0;
const index2 = instances.value.indexOf(props);
if (index2 !== -1)
instances.value.splice(index2, 1);
});
return props.promise;
}
function start(...args) {
if (options.singleton && instances.value.length > 0)
return instances.value[0].promise;
return create(...args);
}
const component = defineComponent((_, { slots }) => {
const renderList = () => instances.value.map((props) => {
var _a;
return h(Fragment, { key: props.key }, (_a = slots.default) == null ? void 0 : _a.call(slots, props));
});
if (options.transition)
return () => h(TransitionGroup, options.transition, renderList);
return renderList;
});
component.start = start;
return component;
}
function createUnrefFn(fn) {
return function(...args) {
return fn.apply(this, args.map((i) => toValue(i)));
};
}
var defaultWindow = isClient ? window : void 0;
var defaultDocument = isClient ? window.document : void 0;
var defaultNavigator = isClient ? window.navigator : void 0;
var defaultLocation = isClient ? window.location : void 0;
function unrefElement(elRef) {
var _a;
const plain = toValue(elRef);
return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
}
function useEventListener(...args) {
let target;
let events2;
let listeners;
let options;
if (typeof args[0] === "string" || Array.isArray(args[0])) {
[events2, listeners, options] = args;
target = defaultWindow;
} else {
[target, events2, listeners, options] = args;
}
if (!target)
return noop;
if (!Array.isArray(events2))
events2 = [events2];
if (!Array.isArray(listeners))
listeners = [listeners];
const cleanups = [];
const cleanup = () => {
cleanups.forEach((fn) => fn());
cleanups.length = 0;
};
const register = (el, event, listener, options2) => {
el.addEventListener(event, listener, options2);
return () => el.removeEventListener(event, listener, options2);
};
const stopWatch = watch(
() => [unrefElement(target), toValue(options)],
([el, options2]) => {
cleanup();
if (!el)
return;
const optionsClone = isObject(options2) ? { ...options2 } : options2;
cleanups.push(
...events2.flatMap((event) => {
return listeners.map((listener) => register(el, event, listener, optionsClone));
})
);
},
{ immediate: true, flush: "post" }
);
const stop = () => {
stopWatch();
cleanup();
};
tryOnScopeDispose(stop);
return stop;
}
var _iOSWorkaround = false;
function onClickOutside(target, handler, options = {}) {
const { window: window2 = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;
if (!window2)
return noop;
if (isIOS && !_iOSWorkaround) {
_iOSWorkaround = true;
Array.from(window2.document.body.children).forEach((el) => el.addEventListener("click", noop));
window2.document.documentElement.addEventListener("click", noop);
}
let shouldListen = true;
const shouldIgnore = (event) => {
return toValue(ignore).some((target2) => {
if (typeof target2 === "string") {
return Array.from(window2.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
} else {
const el = unrefElement(target2);
return el && (event.target === el || event.composedPath().includes(el));
}
});
};
function hasMultipleRoots(target2) {
const vm = toValue(target2);
return vm && vm.$.subTree.shapeFlag === 16;
}
function checkMultipleRoots(target2, event) {
const vm = toValue(target2);
const children = vm.$.subTree && vm.$.subTree.children;
if (children == null || !Array.isArray(children))
return false;
return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
}
const listener = (event) => {
const el = unrefElement(target);
if (event.target == null)
return;
if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event))
return;
if (!el || el === event.target || event.composedPath().includes(el))
return;
if (event.detail === 0)
shouldListen = !shouldIgnore(event);
if (!shouldListen) {
shouldListen = true;
return;
}
handler(event);
};
let isProcessingClick = false;
const cleanup = [
useEventListener(window2, "click", (event) => {
if (!isProcessingClick) {
isProcessingClick = true;
setTimeout(() => {
isProcessingClick = false;
}, 0);
listener(event);
}
}, { passive: true, capture }),
useEventListener(window2, "pointerdown", (e) => {
const el = unrefElement(target);
shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().