first commit

node_modules/@vueuse/integrations/dist/index-BBxze4rb.d.ts

@@ -0,0 +1,33 @@
+import { Ref, ShallowRef } from "vue";
+import { EventHookOn, MaybeComputedElementRef } from "@vueuse/core";
+import { Brush, Drauu, Options } from "drauu";
+
+//#region useDrauu/index.d.ts
+type UseDrauuOptions = Omit<Options, 'el'>;
+interface UseDrauuReturn {
+  drauuInstance: Ref<Drauu | undefined>;
+  load: (svg: string) => void;
+  dump: () => string | undefined;
+  clear: () => void;
+  cancel: () => void;
+  undo: () => boolean | undefined;
+  redo: () => boolean | undefined;
+  canUndo: ShallowRef<boolean>;
+  canRedo: ShallowRef<boolean>;
+  brush: Ref<Brush>;
+  onChanged: EventHookOn;
+  onCommitted: EventHookOn;
+  onStart: EventHookOn;
+  onEnd: EventHookOn;
+  onCanceled: EventHookOn;
+}
+/**
+ * Reactive drauu
+ *
+ * @see https://vueuse.org/useDrauu
+ * @param target The target svg element
+ * @param options Drauu Options
+ */
+declare function useDrauu(target: MaybeComputedElementRef, options?: UseDrauuOptions): UseDrauuReturn;
+//#endregion
+export { UseDrauuReturn as n, useDrauu as r, UseDrauuOptions as t };

node_modules/@vueuse/integrations/dist/index-BLffOygZ.d.ts

@@ -0,0 +1,21 @@
+import * as vue2 from "vue";
+import { MaybeRefOrGetter } from "vue";
+import nprogress, { NProgressOptions } from "nprogress";
+
+//#region useNProgress/index.d.ts
+type UseNProgressOptions = Partial<NProgressOptions>;
+/**
+ * Reactive progress bar.
+ *
+ * @see https://vueuse.org/useNProgress
+ */
+declare function useNProgress(currentProgress?: MaybeRefOrGetter<number | null | undefined>, options?: UseNProgressOptions): {
+  isLoading: vue2.WritableComputedRef<boolean, boolean>;
+  progress: vue2.Ref<number | null | undefined, number | null | undefined>;
+  start: () => nprogress.NProgress;
+  done: (force?: boolean) => nprogress.NProgress;
+  remove: () => void;
+};
+type UseNProgressReturn = ReturnType<typeof useNProgress>;
+//#endregion
+export { UseNProgressReturn as n, useNProgress as r, UseNProgressOptions as t };

node_modules/@vueuse/integrations/dist/index-BgoBW25H.d.ts

@@ -0,0 +1,48 @@
+import { Rules, ValidateError, ValidateOption } from "async-validator";
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region useAsyncValidator/index.d.ts
+type AsyncValidatorError = Error & {
+  errors: ValidateError[];
+  fields: Record<string, ValidateError[]>;
+};
+interface UseAsyncValidatorExecuteReturn {
+  pass: boolean;
+  errors: AsyncValidatorError['errors'] | undefined;
+  errorInfo: AsyncValidatorError | null;
+  errorFields: AsyncValidatorError['fields'] | undefined;
+}
+interface UseAsyncValidatorReturn {
+  pass: ShallowRef<boolean>;
+  isFinished: ShallowRef<boolean>;
+  errors: ComputedRef<AsyncValidatorError['errors'] | undefined>;
+  errorInfo: ShallowRef<AsyncValidatorError | null>;
+  errorFields: ComputedRef<AsyncValidatorError['fields'] | undefined>;
+  execute: () => Promise<UseAsyncValidatorExecuteReturn>;
+}
+interface UseAsyncValidatorOptions {
+  /**
+   * @see https://github.com/yiminghe/async-validator#options
+   */
+  validateOption?: ValidateOption;
+  /**
+   * The validation will be triggered right away for the first time.
+   * Only works when `manual` is not set to true.
+   *
+   * @default true
+   */
+  immediate?: boolean;
+  /**
+   * If set to true, the validation will not be triggered automatically.
+   */
+  manual?: boolean;
+}
+/**
+ * Wrapper for async-validator.
+ *
+ * @see https://vueuse.org/useAsyncValidator
+ * @see https://github.com/yiminghe/async-validator
+ */
+declare function useAsyncValidator(value: MaybeRefOrGetter<Record<string, any>>, rules: MaybeRefOrGetter<Rules>, options?: UseAsyncValidatorOptions): UseAsyncValidatorReturn & PromiseLike<UseAsyncValidatorReturn>;
+//#endregion
+export { useAsyncValidator as a, UseAsyncValidatorReturn as i, UseAsyncValidatorExecuteReturn as n, UseAsyncValidatorOptions as r, AsyncValidatorError as t };

node_modules/@vueuse/integrations/dist/index-C0C_B0mW.d.ts

@@ -0,0 +1,64 @@
+import * as universal_cookie0 from "universal-cookie";
+import Cookie from "universal-cookie";
+import { IncomingMessage } from "node:http";
+
+//#region useCookies/index.d.ts
+
+/**
+ * Creates a new {@link useCookies} function
+ * @param req - incoming http request (for SSR)
+ * @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+ * @description Creates universal-cookie instance using request (default is window.document.cookie) and returns {@link useCookies} function with provided universal-cookie instance
+ */
+declare function createCookies(req?: IncomingMessage): (dependencies?: string[] | null, {
+  doNotParse,
+  autoUpdateDependencies
+}?: {
+  doNotParse?: boolean | undefined;
+  autoUpdateDependencies?: boolean | undefined;
+}) => {
+  /**
+   * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
+   */
+  get: <T = any>(name: string, options?: universal_cookie0.CookieGetOptions | undefined) => T;
+  /**
+   * Reactive get all cookies
+   */
+  getAll: <T = any>(options?: universal_cookie0.CookieGetOptions | undefined) => T;
+  set: (name: string, value: any, options?: universal_cookie0.CookieSetOptions | undefined) => void;
+  remove: (name: string, options?: universal_cookie0.CookieSetOptions | undefined) => void;
+  addChangeListener: (callback: universal_cookie0.CookieChangeListener) => void;
+  removeChangeListener: (callback: universal_cookie0.CookieChangeListener) => void;
+};
+/**
+ * Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
+ * @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+ * @param options
+ * @param options.doNotParse - don't try parse value as JSON
+ * @param options.autoUpdateDependencies - automatically update watching dependencies
+ * @param cookies - universal-cookie instance
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare function useCookies(dependencies?: string[] | null, {
+  doNotParse,
+  autoUpdateDependencies
+}?: {
+  doNotParse?: boolean | undefined;
+  autoUpdateDependencies?: boolean | undefined;
+}, cookies?: Cookie): {
+  /**
+   * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
+   */
+  get: <T = any>(name: string, options?: universal_cookie0.CookieGetOptions | undefined) => T;
+  /**
+   * Reactive get all cookies
+   */
+  getAll: <T = any>(options?: universal_cookie0.CookieGetOptions | undefined) => T;
+  set: (name: string, value: any, options?: universal_cookie0.CookieSetOptions | undefined) => void;
+  remove: (name: string, options?: universal_cookie0.CookieSetOptions | undefined) => void;
+  addChangeListener: (callback: universal_cookie0.CookieChangeListener) => void;
+  removeChangeListener: (callback: universal_cookie0.CookieChangeListener) => void;
+};
+//#endregion
+export { useCookies as n, createCookies as t };

node_modules/@vueuse/integrations/dist/index-CDFJRy7j.d.ts

@@ -0,0 +1,41 @@
+import { MaybeRef, MaybeRefOrGetter } from "vue";
+import { ConfigurableDocument, MaybeElement } from "@vueuse/core";
+import Sortable, { Options } from "sortablejs";
+
+//#region useSortable/index.d.ts
+interface UseSortableReturn {
+  /**
+   * start sortable instance
+   */
+  start: () => void;
+  /**
+   * destroy sortable instance
+   */
+  stop: () => void;
+  /**
+   * Options getter/setter
+   * @param name a Sortable.Options property.
+   * @param value a value.
+   */
+  option: (<K extends keyof Sortable.Options>(name: K, value: Sortable.Options[K]) => void) & (<K extends keyof Sortable.Options>(name: K) => Sortable.Options[K]);
+}
+type UseSortableOptions = Options & ConfigurableDocument;
+declare function useSortable<T>(selector: string, list: MaybeRef<T[]>, options?: UseSortableOptions): UseSortableReturn;
+declare function useSortable<T>(el: MaybeRefOrGetter<MaybeElement>, list: MaybeRef<T[]>, options?: UseSortableOptions): UseSortableReturn;
+/**
+ * Inserts a element into the DOM at a given index.
+ * @param parentElement
+ * @param element
+ * @param {number} index
+ * @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L81C1-L94C2
+ */
+declare function insertNodeAt(parentElement: Element, element: Element, index: number): void;
+/**
+ * Removes a node from the DOM.
+ * @param {Node} node
+ * @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L96C1-L102C2
+ */
+declare function removeNode(node: Node): void;
+declare function moveArrayElement<T>(list: MaybeRef<T[]>, from: number, to: number, e?: Sortable.SortableEvent | null): void;
+//#endregion
+export { removeNode as a, moveArrayElement as i, UseSortableReturn as n, useSortable as o, insertNodeAt as r, UseSortableOptions as t };

node_modules/@vueuse/integrations/dist/index-CJw_eFkJ.d.ts

@@ -0,0 +1,55 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+import { Arrayable, Fn, MaybeComputedElementRef } from "@vueuse/core";
+import { ActivateOptions, DeactivateOptions, Options } from "focus-trap";
+
+//#region useFocusTrap/index.d.ts
+interface UseFocusTrapOptions extends Options {
+  /**
+   * Immediately activate the trap
+   */
+  immediate?: boolean;
+}
+interface UseFocusTrapReturn {
+  /**
+   * Indicates if the focus trap is currently active
+   */
+  hasFocus: ShallowRef<boolean>;
+  /**
+   * Indicates if the focus trap is currently paused
+   */
+  isPaused: ShallowRef<boolean>;
+  /**
+   * Activate the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trapactivateactivateoptions
+   * @param opts Activate focus trap options
+   */
+  activate: (opts?: ActivateOptions) => void;
+  /**
+   * Deactivate the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trapdeactivatedeactivateoptions
+   * @param opts Deactivate focus trap options
+   */
+  deactivate: (opts?: DeactivateOptions) => void;
+  /**
+   * Pause the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trappause
+   */
+  pause: Fn;
+  /**
+   * Unpauses the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trapunpause
+   */
+  unpause: Fn;
+}
+/**
+ * Reactive focus-trap
+ *
+ * @see https://vueuse.org/useFocusTrap
+ */
+declare function useFocusTrap(target: MaybeRefOrGetter<Arrayable<MaybeRefOrGetter<string> | MaybeComputedElementRef>>, options?: UseFocusTrapOptions): UseFocusTrapReturn;
+//#endregion
+export { UseFocusTrapReturn as n, useFocusTrap as r, UseFocusTrapOptions as t };

node_modules/@vueuse/integrations/dist/index-CxO-Pb3x.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, WritableComputedRef } from "vue";
+import * as changeCase from "change-case";
+import { Options } from "change-case";
+
+//#region useChangeCase/index.d.ts
+type EndsWithCase<T> = T extends `${infer _}Case` ? T : never;
+type FilterKeys<T> = { [K in keyof T as K extends string ? K : never]: EndsWithCase<K> };
+type ChangeCaseKeys = FilterKeys<typeof changeCase>;
+type ChangeCaseType = ChangeCaseKeys[keyof ChangeCaseKeys];
+declare function useChangeCase(input: MaybeRef<string>, type: MaybeRefOrGetter<ChangeCaseType>, options?: MaybeRefOrGetter<Options> | undefined): WritableComputedRef<string>;
+declare function useChangeCase(input: MaybeRefOrGetter<string>, type: MaybeRefOrGetter<ChangeCaseType>, options?: MaybeRefOrGetter<Options> | undefined): ComputedRef<string>;
+//#endregion
+export { useChangeCase as n, ChangeCaseType as t };

node_modules/@vueuse/integrations/dist/index-DfI2VwxT.d.ts

@@ -0,0 +1,52 @@
+import { ConfigurableFlush, RemovableRef } from "@vueuse/shared";
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region useIDBKeyval/index.d.ts
+interface Serializer<T> {
+  read: (raw: unknown) => T;
+  write: (value: T) => unknown;
+}
+interface UseIDBOptions<T> extends ConfigurableFlush {
+  /**
+   * Watch for deep changes
+   *
+   * @default true
+   */
+  deep?: boolean;
+  /**
+   * On error callback
+   *
+   * Default log error to `console.error`
+   */
+  onError?: (error: unknown) => void;
+  /**
+   * Use shallow ref as reference
+   *
+   * @default false
+   */
+  shallow?: boolean;
+  /**
+   * Write the default value to the storage when it does not exist
+   *
+   * @default true
+   */
+  writeDefaults?: boolean;
+  /**
+   * Custom data serialization
+   */
+  serializer?: Serializer<T>;
+}
+interface UseIDBKeyvalReturn<T> {
+  data: RemovableRef<T>;
+  isFinished: ShallowRef<boolean>;
+  set: (value: T) => Promise<void>;
+}
+/**
+ *
+ * @param key
+ * @param initialValue
+ * @param options
+ */
+declare function useIDBKeyval<T>(key: IDBValidKey, initialValue: MaybeRefOrGetter<T>, options?: UseIDBOptions<T>): UseIDBKeyvalReturn<T>;
+//#endregion
+export { UseIDBOptions as n, useIDBKeyval as r, UseIDBKeyvalReturn as t };

node_modules/@vueuse/integrations/dist/index-HJW_ZBEz.d.ts

@@ -0,0 +1,33 @@
+import * as vue1 from "vue";
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+import * as fuse_js0 from "fuse.js";
+import Fuse, { FuseResult, IFuseOptions } from "fuse.js";
+
+//#region useFuse/index.d.ts
+type FuseOptions<T> = IFuseOptions<T>;
+interface UseFuseOptions<T> {
+  fuseOptions?: FuseOptions<T>;
+  resultLimit?: number;
+  matchAllWhenSearchEmpty?: boolean;
+}
+declare function useFuse<DataItem>(search: MaybeRefOrGetter<string>, data: MaybeRefOrGetter<DataItem[]>, options?: MaybeRefOrGetter<UseFuseOptions<DataItem>>): {
+  fuse: vue1.Ref<{
+    search: <R = DataItem>(pattern: string | fuse_js0.Expression, options?: fuse_js0.FuseSearchOptions) => FuseResult<R>[];
+    setCollection: (docs: readonly DataItem[], index?: fuse_js0.FuseIndex<DataItem> | undefined) => void;
+    add: (doc: DataItem) => void;
+    remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
+    removeAt: (idx: number) => void;
+    getIndex: () => fuse_js0.FuseIndex<DataItem>;
+  }, Fuse<DataItem> | {
+    search: <R = DataItem>(pattern: string | fuse_js0.Expression, options?: fuse_js0.FuseSearchOptions) => FuseResult<R>[];
+    setCollection: (docs: readonly DataItem[], index?: fuse_js0.FuseIndex<DataItem> | undefined) => void;
+    add: (doc: DataItem) => void;
+    remove: (predicate: (doc: DataItem, idx: number) => boolean) => DataItem[];
+    removeAt: (idx: number) => void;
+    getIndex: () => fuse_js0.FuseIndex<DataItem>;
+  }>;
+  results: ComputedRef<FuseResult<DataItem>[]>;
+};
+type UseFuseReturn = ReturnType<typeof useFuse>;
+//#endregion
+export { useFuse as i, UseFuseOptions as n, UseFuseReturn as r, FuseOptions as t };

node_modules/@vueuse/integrations/dist/index-ch2MM_8w.d.ts

@@ -0,0 +1,107 @@
+import { Ref, ShallowRef } from "vue";
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
+
+//#region useAxios/index.d.ts
+interface UseAxiosReturn<T, R = AxiosResponse<T>, _D = any, O extends UseAxiosOptions = UseAxiosOptions<T>> {
+  /**
+   * Axios Response
+   */
+  response: ShallowRef<R | undefined>;
+  /**
+   * Axios response data
+   */
+  data: O extends UseAxiosOptionsWithInitialData<T> ? Ref<T> : Ref<T | undefined>;
+  /**
+   * Indicates if the request has finished
+   */
+  isFinished: Ref<boolean>;
+  /**
+   * Indicates if the request is currently loading
+   */
+  isLoading: Ref<boolean>;
+  /**
+   * Indicates if the request was canceled
+   */
+  isAborted: Ref<boolean>;
+  /**
+   * Any errors that may have occurred
+   */
+  error: ShallowRef<unknown | undefined>;
+  /**
+   * Aborts the current request
+   */
+  abort: (message?: string | undefined) => void;
+  /**
+   * Alias to `abort`
+   */
+  cancel: (message?: string | undefined) => void;
+  /**
+   * Alias to `isAborted`
+   */
+  isCanceled: Ref<boolean>;
+}
+interface StrictUseAxiosReturn<T, R, D, O extends UseAxiosOptions = UseAxiosOptions<T>> extends UseAxiosReturn<T, R, D, O> {
+  /**
+   * Manually call the axios request
+   */
+  execute: (url?: string | AxiosRequestConfig<D>, config?: AxiosRequestConfig<D>) => Promise<StrictUseAxiosReturn<T, R, D, O>>;
+}
+interface EasyUseAxiosReturn<T, R, D> extends UseAxiosReturn<T, R, D> {
+  /**
+   * Manually call the axios request
+   */
+  execute: (url: string, config?: AxiosRequestConfig<D>) => Promise<EasyUseAxiosReturn<T, R, D>>;
+}
+interface UseAxiosOptionsBase<T = any> {
+  /**
+   * Will automatically run axios request when `useAxios` is used
+   *
+   */
+  immediate?: boolean;
+  /**
+   * Use shallowRef.
+   *
+   * @default true
+   */
+  shallow?: boolean;
+  /**
+   * Abort previous request when a new request is made.
+   *
+   * @default true
+   */
+  abortPrevious?: boolean;
+  /**
+   * Callback when error is caught.
+   */
+  onError?: (e: unknown) => void;
+  /**
+   * Callback when success is caught.
+   */
+  onSuccess?: (data: T) => void;
+  /**
+   * Sets the state to initialState before executing the promise.
+   */
+  resetOnExecute?: boolean;
+  /**
+   * Callback when request is finished.
+   */
+  onFinish?: () => void;
+}
+interface UseAxiosOptionsWithInitialData<T> extends UseAxiosOptionsBase<T> {
+  /**
+   * Initial data
+   */
+  initialData: T;
+}
+type UseAxiosOptions<T = any> = UseAxiosOptionsBase<T> | UseAxiosOptionsWithInitialData<T>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseAxiosOptionsWithInitialData<T> = UseAxiosOptionsWithInitialData<T>>(url: string, config?: AxiosRequestConfig<D>, options?: O): StrictUseAxiosReturn<T, R, D, O> & Promise<StrictUseAxiosReturn<T, R, D, O>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseAxiosOptionsWithInitialData<T> = UseAxiosOptionsWithInitialData<T>>(url: string, instance?: AxiosInstance, options?: O): StrictUseAxiosReturn<T, R, D, O> & Promise<StrictUseAxiosReturn<T, R, D, O>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseAxiosOptionsWithInitialData<T> = UseAxiosOptionsWithInitialData<T>>(url: string, config: AxiosRequestConfig<D>, instance: AxiosInstance, options?: O): StrictUseAxiosReturn<T, R, D, O> & Promise<StrictUseAxiosReturn<T, R, D, O>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseAxiosOptionsBase<T> = UseAxiosOptionsBase<T>>(url: string, config?: AxiosRequestConfig<D>, options?: O): StrictUseAxiosReturn<T, R, D, O> & Promise<StrictUseAxiosReturn<T, R, D, O>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseAxiosOptionsBase<T> = UseAxiosOptionsBase<T>>(url: string, instance?: AxiosInstance, options?: O): StrictUseAxiosReturn<T, R, D, O> & Promise<StrictUseAxiosReturn<T, R, D, O>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any, O extends UseAxiosOptionsBase<T> = UseAxiosOptionsBase<T>>(url: string, config: AxiosRequestConfig<D>, instance: AxiosInstance, options?: O): StrictUseAxiosReturn<T, R, D, O> & Promise<StrictUseAxiosReturn<T, R, D, O>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+declare function useAxios<T = any, R = AxiosResponse<T>, D = any>(config?: AxiosRequestConfig<D>, instance?: AxiosInstance): EasyUseAxiosReturn<T, R, D> & Promise<EasyUseAxiosReturn<T, R, D>>;
+//#endregion
+export { UseAxiosOptionsWithInitialData as a, UseAxiosOptionsBase as i, StrictUseAxiosReturn as n, UseAxiosReturn as o, UseAxiosOptions as r, useAxios as s, EasyUseAxiosReturn as t };

node_modules/@vueuse/integrations/dist/index-is9DY6jN.d.ts

@@ -0,0 +1,28 @@
+import { ComputedRef, MaybeRefOrGetter } from "vue";
+import { JwtHeader, JwtPayload } from "jwt-decode";
+
+//#region useJwt/index.d.ts
+interface UseJwtOptions<Fallback> {
+  /**
+   * Value returned when encounter error on decoding
+   *
+   * @default null
+   */
+  fallbackValue?: Fallback;
+  /**
+   * Error callback for decoding
+   */
+  onError?: (error: unknown) => void;
+}
+interface UseJwtReturn<Payload, Header, Fallback> {
+  header: ComputedRef<Header | Fallback>;
+  payload: ComputedRef<Payload | Fallback>;
+}
+/**
+ * Reactive decoded jwt token.
+ *
+ * @see https://vueuse.org/useJwt
+ */
+declare function useJwt<Payload extends object = JwtPayload, Header extends object = JwtHeader, Fallback = null>(encodedJwt: MaybeRefOrGetter<string>, options?: UseJwtOptions<Fallback>): UseJwtReturn<Payload, Header, Fallback>;
+//#endregion
+export { UseJwtReturn as n, useJwt as r, UseJwtOptions as t };

node_modules/@vueuse/integrations/dist/index-oNla9-Bg.d.ts

@@ -0,0 +1,16 @@
+import * as vue6 from "vue";
+import { MaybeRefOrGetter } from "vue";
+import QRCode from "qrcode";
+
+//#region useQRCode/index.d.ts
+
+/**
+ * Wrapper for qrcode.
+ *
+ * @see https://vueuse.org/useQRCode
+ * @param text
+ * @param options
+ */
+declare function useQRCode(text: MaybeRefOrGetter<string>, options?: QRCode.QRCodeToDataURLOptions): vue6.ShallowRef<string, string>;
+//#endregion
+export { useQRCode as t };

node_modules/@vueuse/integrations/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { a as useAsyncValidator, i as UseAsyncValidatorReturn, n as UseAsyncValidatorExecuteReturn, r as UseAsyncValidatorOptions, t as AsyncValidatorError } from "./index-BgoBW25H.js";
+import { a as UseAxiosOptionsWithInitialData, i as UseAxiosOptionsBase, n as StrictUseAxiosReturn, o as UseAxiosReturn, r as UseAxiosOptions, s as useAxios, t as EasyUseAxiosReturn } from "./index-ch2MM_8w.js";
+import { n as useChangeCase, t as ChangeCaseType } from "./index-CxO-Pb3x.js";
+import { n as useCookies, t as createCookies } from "./index-C0C_B0mW.js";
+import { n as UseDrauuReturn, r as useDrauu, t as UseDrauuOptions } from "./index-BBxze4rb.js";
+import { n as UseFocusTrapReturn, r as useFocusTrap, t as UseFocusTrapOptions } from "./index-CJw_eFkJ.js";
+import { i as useFuse, n as UseFuseOptions, r as UseFuseReturn, t as FuseOptions } from "./index-HJW_ZBEz.js";
+import { n as UseIDBOptions, r as useIDBKeyval, t as UseIDBKeyvalReturn } from "./index-DfI2VwxT.js";
+import { n as UseJwtReturn, r as useJwt, t as UseJwtOptions } from "./index-is9DY6jN.js";
+import { n as UseNProgressReturn, r as useNProgress, t as UseNProgressOptions } from "./index-BLffOygZ.js";
+import { t as useQRCode } from "./index-oNla9-Bg.js";
+import { a as removeNode, i as moveArrayElement, n as UseSortableReturn, o as useSortable, r as insertNodeAt, t as UseSortableOptions } from "./index-CDFJRy7j.js";
+export { AsyncValidatorError, ChangeCaseType, EasyUseAxiosReturn, FuseOptions, StrictUseAxiosReturn, UseAsyncValidatorExecuteReturn, UseAsyncValidatorOptions, UseAsyncValidatorReturn, UseAxiosOptions, UseAxiosOptionsBase, UseAxiosOptionsWithInitialData, UseAxiosReturn, UseDrauuOptions, UseDrauuReturn, UseFocusTrapOptions, UseFocusTrapReturn, UseFuseOptions, UseFuseReturn, UseIDBKeyvalReturn, UseIDBOptions, UseJwtOptions, UseJwtReturn, UseNProgressOptions, UseNProgressReturn, UseSortableOptions, UseSortableReturn, createCookies, insertNodeAt, moveArrayElement, removeNode, useAsyncValidator, useAxios, useChangeCase, useCookies, useDrauu, useFocusTrap, useFuse, useIDBKeyval, useJwt, useNProgress, useQRCode, useSortable };

node_modules/@vueuse/integrations/dist/index.iife.js

@@ -0,0 +1,764 @@
+(function(exports, __vueuse_shared, async_validator, vue, axios, change_case, universal_cookie, __vueuse_core, drauu, focus_trap, fuse_js, idb_keyval, jwt_decode, nprogress, qrcode, sortablejs) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+async_validator = __toESM(async_validator);
+vue = __toESM(vue);
+axios = __toESM(axios);
+change_case = __toESM(change_case);
+universal_cookie = __toESM(universal_cookie);
+__vueuse_core = __toESM(__vueuse_core);
+drauu = __toESM(drauu);
+focus_trap = __toESM(focus_trap);
+fuse_js = __toESM(fuse_js);
+idb_keyval = __toESM(idb_keyval);
+jwt_decode = __toESM(jwt_decode);
+nprogress = __toESM(nprogress);
+qrcode = __toESM(qrcode);
+sortablejs = __toESM(sortablejs);
+
+//#region useAsyncValidator/index.ts
+	const AsyncValidatorSchema = async_validator.default.default || async_validator.default;
+	/**
+	* Wrapper for async-validator.
+	*
+	* @see https://vueuse.org/useAsyncValidator
+	* @see https://github.com/yiminghe/async-validator
+	*/
+	function useAsyncValidator(value, rules, options = {}) {
+		const { validateOption = {}, immediate = true, manual = false } = options;
+		const valueRef = (0, __vueuse_shared.toRef)(value);
+		const errorInfo = (0, vue.shallowRef)(null);
+		const isFinished = (0, vue.shallowRef)(true);
+		const pass = (0, vue.shallowRef)(!immediate || manual);
+		const errors = (0, vue.computed)(() => {
+			var _errorInfo$value;
+			return ((_errorInfo$value = errorInfo.value) === null || _errorInfo$value === void 0 ? void 0 : _errorInfo$value.errors) || [];
+		});
+		const errorFields = (0, vue.computed)(() => {
+			var _errorInfo$value2;
+			return ((_errorInfo$value2 = errorInfo.value) === null || _errorInfo$value2 === void 0 ? void 0 : _errorInfo$value2.fields) || {};
+		});
+		const validator = (0, vue.computed)(() => new AsyncValidatorSchema((0, vue.toValue)(rules)));
+		const execute = async () => {
+			isFinished.value = false;
+			pass.value = false;
+			try {
+				await validator.value.validate(valueRef.value, validateOption);
+				pass.value = true;
+				errorInfo.value = null;
+			} catch (err) {
+				errorInfo.value = err;
+			} finally {
+				isFinished.value = true;
+			}
+			return {
+				pass: pass.value,
+				errorInfo: errorInfo.value,
+				errors: errors.value,
+				errorFields: errorFields.value
+			};
+		};
+		if (!manual) (0, vue.watch)([valueRef, validator], () => execute(), {
+			immediate,
+			deep: true
+		});
+		const shell = {
+			isFinished,
+			pass,
+			errors,
+			errorInfo,
+			errorFields,
+			execute
+		};
+		function waitUntilFinished() {
+			return new Promise((resolve, reject) => {
+				(0, __vueuse_shared.until)(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
+			});
+		}
+		return {
+			...shell,
+			then(onFulfilled, onRejected) {
+				return waitUntilFinished().then(onFulfilled, onRejected);
+			}
+		};
+	}
+
+//#endregion
+//#region useAxios/index.ts
+/**
+	* Wrapper for axios.
+	*
+	* @see https://vueuse.org/useAxios
+	*/
+	function useAxios(...args) {
+		const url = typeof args[0] === "string" ? args[0] : void 0;
+		const argsPlaceholder = typeof url === "string" ? 1 : 0;
+		const defaultOptions = {
+			immediate: !!argsPlaceholder,
+			shallow: true,
+			abortPrevious: true
+		};
+		let defaultConfig = {};
+		let instance = axios.default;
+		let options = defaultOptions;
+		const isAxiosInstance = (val) => !!(val === null || val === void 0 ? void 0 : val.request);
+		if (args.length > 0 + argsPlaceholder)
+ /**
+		* Unable to use `instanceof` here because of (https://github.com/axios/axios/issues/737)
+		* so instead we are checking if there is a `request` on the object to see if it is an
+		* axios instance
+		*/
+		if (isAxiosInstance(args[0 + argsPlaceholder])) instance = args[0 + argsPlaceholder];
+		else defaultConfig = args[0 + argsPlaceholder];
+		if (args.length > 1 + argsPlaceholder) {
+			if (isAxiosInstance(args[1 + argsPlaceholder])) instance = args[1 + argsPlaceholder];
+		}
+		if (args.length === 2 + argsPlaceholder && !isAxiosInstance(args[1 + argsPlaceholder]) || args.length === 3 + argsPlaceholder) options = args[args.length - 1] || defaultOptions;
+		const { shallow, onSuccess = __vueuse_shared.noop, onError = __vueuse_shared.noop, immediate, resetOnExecute = false } = options;
+		const initialData = options.initialData;
+		const response = (0, vue.shallowRef)();
+		const data = (shallow ? vue.shallowRef : vue.ref)(initialData);
+		const isFinished = (0, vue.shallowRef)(false);
+		const isLoading = (0, vue.shallowRef)(false);
+		const isAborted = (0, vue.shallowRef)(false);
+		const error = (0, vue.shallowRef)();
+		let abortController = new AbortController();
+		const abort = (message) => {
+			if (isFinished.value || !isLoading.value) return;
+			abortController.abort(message);
+			abortController = new AbortController();
+			isAborted.value = true;
+			isLoading.value = false;
+			isFinished.value = false;
+		};
+		const loading = (loading$1) => {
+			isLoading.value = loading$1;
+			isFinished.value = !loading$1;
+		};
+		/**
+		* Reset data to initialData
+		*/
+		const resetData = () => {
+			if (resetOnExecute) data.value = initialData;
+		};
+		const waitUntilFinished = () => new Promise((resolve, reject) => {
+			(0, __vueuse_shared.until)(isFinished).toBe(true).then(() => error.value ? reject(error.value) : resolve(result));
+		});
+		const promise = {
+			then: (...args$1) => waitUntilFinished().then(...args$1),
+			catch: (...args$1) => waitUntilFinished().catch(...args$1)
+		};
+		let executeCounter = 0;
+		const execute = (executeUrl = url, config = {}) => {
+			error.value = void 0;
+			const _url = typeof executeUrl === "string" ? executeUrl : url !== null && url !== void 0 ? url : config.url;
+			if (_url === void 0) {
+				error.value = new axios.AxiosError(axios.AxiosError.ERR_INVALID_URL);
+				isFinished.value = true;
+				return promise;
+			}
+			resetData();
+			if (options.abortPrevious !== false) abort();
+			loading(true);
+			executeCounter += 1;
+			const currentExecuteCounter = executeCounter;
+			isAborted.value = false;
+			instance(_url, {
+				...defaultConfig,
+				...typeof executeUrl === "object" ? executeUrl : config,
+				signal: abortController.signal
+			}).then((r) => {
+				if (isAborted.value) return;
+				response.value = r;
+				const result$1 = r.data;
+				data.value = result$1;
+				onSuccess(result$1);
+			}).catch((e) => {
+				error.value = e;
+				onError(e);
+			}).finally(() => {
+				var _options$onFinish;
+				(_options$onFinish = options.onFinish) === null || _options$onFinish === void 0 || _options$onFinish.call(options);
+				if (currentExecuteCounter === executeCounter) loading(false);
+			});
+			return promise;
+		};
+		if (immediate && url) execute();
+		const result = {
+			response,
+			data,
+			error,
+			isFinished,
+			isLoading,
+			cancel: abort,
+			isAborted,
+			isCanceled: isAborted,
+			abort,
+			execute
+		};
+		return {
+			...result,
+			...promise
+		};
+	}
+
+//#endregion
+//#region useChangeCase/index.ts
+	const changeCaseTransforms = /* @__PURE__ */ Object.entries(change_case).filter(([name, fn]) => typeof fn === "function" && name.endsWith("Case")).reduce((acc, [name, fn]) => {
+		acc[name] = fn;
+		return acc;
+	}, {});
+	/**
+	* Reactive wrapper for `change-case`
+	*
+	* @see https://vueuse.org/useChangeCase
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useChangeCase(input, type, options) {
+		const typeRef = (0, vue.computed)(() => {
+			const t = (0, vue.toValue)(type);
+			if (!changeCaseTransforms[t]) throw new Error(`Invalid change case type "${t}"`);
+			return t;
+		});
+		if (typeof input === "function") return (0, vue.computed)(() => changeCaseTransforms[typeRef.value]((0, vue.toValue)(input), (0, vue.toValue)(options)));
+		const text = (0, vue.ref)(input);
+		return (0, vue.computed)({
+			get() {
+				return changeCaseTransforms[typeRef.value](text.value, (0, vue.toValue)(options));
+			},
+			set(value) {
+				text.value = value;
+			}
+		});
+	}
+
+//#endregion
+//#region useCookies/index.ts
+/**
+	* Creates a new {@link useCookies} function
+	* @param req - incoming http request (for SSR)
+	* @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+	* @description Creates universal-cookie instance using request (default is window.document.cookie) and returns {@link useCookies} function with provided universal-cookie instance
+	*/
+	function createCookies(req) {
+		const universalCookie = new universal_cookie.default(req ? req.headers.cookie : null);
+		return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, {
+			doNotParse,
+			autoUpdateDependencies
+		}, universalCookie);
+	}
+	/**
+	* Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
+	* @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+	* @param options
+	* @param options.doNotParse - don't try parse value as JSON
+	* @param options.autoUpdateDependencies - automatically update watching dependencies
+	* @param cookies - universal-cookie instance
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new universal_cookie.default()) {
+		const watchingDependencies = autoUpdateDependencies ? [...dependencies || []] : dependencies;
+		let previousCookies = cookies.getAll({ doNotParse: true });
+		/**
+		* Adds reactivity to get/getAll methods
+		*/
+		const touches = (0, vue.shallowRef)(0);
+		const onChange = () => {
+			const newCookies = cookies.getAll({ doNotParse: true });
+			if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies)) touches.value++;
+			previousCookies = newCookies;
+		};
+		cookies.addChangeListener(onChange);
+		(0, __vueuse_shared.tryOnScopeDispose)(() => {
+			cookies.removeChangeListener(onChange);
+		});
+		return {
+			get: (...args) => {
+				/**
+				* Auto update watching dependencies if needed
+				*/
+				if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0])) watchingDependencies.push(args[0]);
+				touches.value;
+				return cookies.get(args[0], {
+					doNotParse,
+					...args[1]
+				});
+			},
+			getAll: (...args) => {
+				touches.value;
+				return cookies.getAll({
+					doNotParse,
+					...args[0]
+				});
+			},
+			set: (...args) => cookies.set(...args),
+			remove: (...args) => cookies.remove(...args),
+			addChangeListener: (...args) => cookies.addChangeListener(...args),
+			removeChangeListener: (...args) => cookies.removeChangeListener(...args)
+		};
+	}
+	function shouldUpdate(dependencies, newCookies, oldCookies) {
+		if (!dependencies) return true;
+		for (const dependency of dependencies) if (newCookies[dependency] !== oldCookies[dependency]) return true;
+		return false;
+	}
+
+//#endregion
+//#region useDrauu/index.ts
+/**
+	* Reactive drauu
+	*
+	* @see https://vueuse.org/useDrauu
+	* @param target The target svg element
+	* @param options Drauu Options
+	*/
+	function useDrauu(target, options) {
+		const drauuInstance = (0, vue.ref)();
+		let disposables = [];
+		const onChangedHook = (0, __vueuse_core.createEventHook)();
+		const onCanceledHook = (0, __vueuse_core.createEventHook)();
+		const onCommittedHook = (0, __vueuse_core.createEventHook)();
+		const onStartHook = (0, __vueuse_core.createEventHook)();
+		const onEndHook = (0, __vueuse_core.createEventHook)();
+		const canUndo = (0, vue.shallowRef)(false);
+		const canRedo = (0, vue.shallowRef)(false);
+		const altPressed = (0, vue.shallowRef)(false);
+		const shiftPressed = (0, vue.shallowRef)(false);
+		const brush = (0, vue.ref)({
+			color: "black",
+			size: 3,
+			arrowEnd: false,
+			cornerRadius: 0,
+			dasharray: void 0,
+			fill: "transparent",
+			mode: "draw",
+			...options === null || options === void 0 ? void 0 : options.brush
+		});
+		(0, vue.watch)(brush, () => {
+			const instance = drauuInstance.value;
+			if (instance) {
+				instance.brush = brush.value;
+				instance.mode = brush.value.mode;
+			}
+		}, { deep: true });
+		const undo = () => {
+			var _drauuInstance$value;
+			return (_drauuInstance$value = drauuInstance.value) === null || _drauuInstance$value === void 0 ? void 0 : _drauuInstance$value.undo();
+		};
+		const redo = () => {
+			var _drauuInstance$value2;
+			return (_drauuInstance$value2 = drauuInstance.value) === null || _drauuInstance$value2 === void 0 ? void 0 : _drauuInstance$value2.redo();
+		};
+		const clear = () => {
+			var _drauuInstance$value3;
+			return (_drauuInstance$value3 = drauuInstance.value) === null || _drauuInstance$value3 === void 0 ? void 0 : _drauuInstance$value3.clear();
+		};
+		const cancel = () => {
+			var _drauuInstance$value4;
+			return (_drauuInstance$value4 = drauuInstance.value) === null || _drauuInstance$value4 === void 0 ? void 0 : _drauuInstance$value4.cancel();
+		};
+		const load = (svg) => {
+			var _drauuInstance$value5;
+			return (_drauuInstance$value5 = drauuInstance.value) === null || _drauuInstance$value5 === void 0 ? void 0 : _drauuInstance$value5.load(svg);
+		};
+		const dump = () => {
+			var _drauuInstance$value6;
+			return (_drauuInstance$value6 = drauuInstance.value) === null || _drauuInstance$value6 === void 0 ? void 0 : _drauuInstance$value6.dump();
+		};
+		const cleanup = () => {
+			var _drauuInstance$value7;
+			disposables.forEach((dispose) => dispose());
+			(_drauuInstance$value7 = drauuInstance.value) === null || _drauuInstance$value7 === void 0 || _drauuInstance$value7.unmount();
+		};
+		const syncStatus = () => {
+			if (drauuInstance.value) {
+				canUndo.value = drauuInstance.value.canUndo();
+				canRedo.value = drauuInstance.value.canRedo();
+				altPressed.value = drauuInstance.value.altPressed;
+				shiftPressed.value = drauuInstance.value.shiftPressed;
+			}
+		};
+		(0, vue.watch)(() => (0, __vueuse_core.unrefElement)(target), (el) => {
+			if (!el || typeof SVGSVGElement === "undefined" || !(el instanceof SVGSVGElement)) return;
+			if (drauuInstance.value) cleanup();
+			drauuInstance.value = (0, drauu.createDrauu)({
+				el,
+				...options
+			});
+			syncStatus();
+			disposables = [
+				drauuInstance.value.on("canceled", () => onCanceledHook.trigger()),
+				drauuInstance.value.on("committed", (node) => onCommittedHook.trigger(node)),
+				drauuInstance.value.on("start", () => onStartHook.trigger()),
+				drauuInstance.value.on("end", () => onEndHook.trigger()),
+				drauuInstance.value.on("changed", () => {
+					syncStatus();
+					onChangedHook.trigger();
+				})
+			];
+		}, { flush: "post" });
+		(0, __vueuse_shared.tryOnScopeDispose)(() => cleanup());
+		return {
+			drauuInstance,
+			load,
+			dump,
+			clear,
+			cancel,
+			undo,
+			redo,
+			canUndo,
+			canRedo,
+			brush,
+			onChanged: onChangedHook.on,
+			onCommitted: onCommittedHook.on,
+			onStart: onStartHook.on,
+			onEnd: onEndHook.on,
+			onCanceled: onCanceledHook.on
+		};
+	}
+
+//#endregion
+//#region useFocusTrap/index.ts
+/**
+	* Reactive focus-trap
+	*
+	* @see https://vueuse.org/useFocusTrap
+	*/
+	function useFocusTrap(target, options = {}) {
+		let trap;
+		const { immediate,...focusTrapOptions } = options;
+		const hasFocus = (0, vue.shallowRef)(false);
+		const isPaused = (0, vue.shallowRef)(false);
+		const activate = (opts) => trap && trap.activate(opts);
+		const deactivate = (opts) => trap && trap.deactivate(opts);
+		const pause = () => {
+			if (trap) {
+				trap.pause();
+				isPaused.value = true;
+			}
+		};
+		const unpause = () => {
+			if (trap) {
+				trap.unpause();
+				isPaused.value = false;
+			}
+		};
+		(0, vue.watch)((0, vue.computed)(() => {
+			return (0, __vueuse_core.toArray)((0, vue.toValue)(target)).map((el) => {
+				const _el = (0, vue.toValue)(el);
+				return typeof _el === "string" ? _el : (0, __vueuse_core.unrefElement)(_el);
+			}).filter(__vueuse_shared.notNullish);
+		}), (els) => {
+			if (!els.length) return;
+			if (!trap) {
+				trap = (0, focus_trap.createFocusTrap)(els, {
+					...focusTrapOptions,
+					onActivate() {
+						hasFocus.value = true;
+						if (options.onActivate) options.onActivate();
+					},
+					onDeactivate() {
+						hasFocus.value = false;
+						if (options.onDeactivate) options.onDeactivate();
+					}
+				});
+				if (immediate) activate();
+			} else {
+				const isActive = trap === null || trap === void 0 ? void 0 : trap.active;
+				trap === null || trap === void 0 || trap.updateContainerElements(els);
+				if (!isActive && immediate) activate();
+			}
+		}, { flush: "post" });
+		(0, __vueuse_core.tryOnScopeDispose)(() => deactivate());
+		return {
+			hasFocus,
+			isPaused,
+			activate,
+			deactivate,
+			pause,
+			unpause
+		};
+	}
+
+//#endregion
+//#region useFuse/index.ts
+	function useFuse(search, data, options) {
+		const createFuse = () => {
+			var _toValue, _toValue2;
+			return new fuse_js.default((_toValue = (0, vue.toValue)(data)) !== null && _toValue !== void 0 ? _toValue : [], (_toValue2 = (0, vue.toValue)(options)) === null || _toValue2 === void 0 ? void 0 : _toValue2.fuseOptions);
+		};
+		const fuse = (0, vue.ref)(createFuse());
+		(0, vue.watch)(() => {
+			var _toValue3;
+			return (_toValue3 = (0, vue.toValue)(options)) === null || _toValue3 === void 0 ? void 0 : _toValue3.fuseOptions;
+		}, () => {
+			fuse.value = createFuse();
+		}, { deep: true });
+		(0, vue.watch)(() => (0, vue.toValue)(data), (newData) => {
+			fuse.value.setCollection(newData);
+		}, { deep: true });
+		return {
+			fuse,
+			results: (0, vue.computed)(() => {
+				const resolved = (0, vue.toValue)(options);
+				if ((resolved === null || resolved === void 0 ? void 0 : resolved.matchAllWhenSearchEmpty) && !(0, vue.toValue)(search)) return (0, vue.toValue)(data).map((item, index) => ({
+					item,
+					refIndex: index
+				}));
+				const limit = resolved === null || resolved === void 0 ? void 0 : resolved.resultLimit;
+				return fuse.value.search((0, vue.toValue)(search), limit ? { limit } : void 0);
+			})
+		};
+	}
+
+//#endregion
+//#region useIDBKeyval/index.ts
+/**
+	*
+	* @param key
+	* @param initialValue
+	* @param options
+	*/
+	function useIDBKeyval(key, initialValue, options = {}) {
+		const { flush = "pre", deep = true, shallow = false, onError = (e) => {
+			console.error(e);
+		}, writeDefaults = true, serializer = {
+			read: (raw) => raw,
+			write: (value) => value
+		} } = options;
+		const isFinished = (0, vue.shallowRef)(false);
+		const data = (shallow ? vue.shallowRef : vue.ref)(initialValue);
+		const rawInit = (0, vue.toValue)(initialValue);
+		async function read() {
+			try {
+				const rawValue = await (0, idb_keyval.get)(key);
+				if (rawValue === void 0) {
+					if (rawInit !== void 0 && rawInit !== null && writeDefaults) await (0, idb_keyval.set)(key, serializer.write(rawInit));
+				} else data.value = serializer.read(rawValue);
+			} catch (e) {
+				onError(e);
+			}
+			isFinished.value = true;
+		}
+		read();
+		async function write() {
+			try {
+				if (data.value == null) await (0, idb_keyval.del)(key);
+				else {
+					const rawValue = (0, vue.toRaw)(data.value);
+					const serializedValue = serializer.write(rawValue);
+					await (0, idb_keyval.update)(key, () => serializedValue);
+				}
+			} catch (e) {
+				onError(e);
+			}
+		}
+		const { pause: pauseWatch, resume: resumeWatch } = (0, __vueuse_core.watchPausable)(data, () => write(), {
+			flush,
+			deep
+		});
+		async function setData(value) {
+			pauseWatch();
+			data.value = value;
+			await write();
+			resumeWatch();
+		}
+		return {
+			set: setData,
+			isFinished,
+			data
+		};
+	}
+
+//#endregion
+//#region useJwt/index.ts
+/**
+	* Reactive decoded jwt token.
+	*
+	* @see https://vueuse.org/useJwt
+	*/
+	function useJwt(encodedJwt, options = {}) {
+		const { onError, fallbackValue = null } = options;
+		const decodeWithFallback = (encodedJwt$1, options$1) => {
+			try {
+				return (0, jwt_decode.jwtDecode)(encodedJwt$1, options$1);
+			} catch (err) {
+				onError === null || onError === void 0 || onError(err);
+				return fallbackValue;
+			}
+		};
+		return {
+			header: (0, vue.computed)(() => decodeWithFallback((0, vue.toValue)(encodedJwt), { header: true })),
+			payload: (0, vue.computed)(() => decodeWithFallback((0, vue.toValue)(encodedJwt)))
+		};
+	}
+
+//#endregion
+//#region useNProgress/index.ts
+/**
+	* Reactive progress bar.
+	*
+	* @see https://vueuse.org/useNProgress
+	*/
+	function useNProgress(currentProgress = null, options) {
+		const progress = (0, __vueuse_shared.toRef)(currentProgress);
+		const isLoading = (0, vue.computed)({
+			set: (load) => load ? nprogress.default.start() : nprogress.default.done(),
+			get: () => typeof progress.value === "number" && progress.value < 1
+		});
+		if (options) nprogress.default.configure(options);
+		const setProgress = nprogress.default.set;
+		nprogress.default.set = (n) => {
+			progress.value = n;
+			return setProgress.call(nprogress.default, n);
+		};
+		(0, vue.watchEffect)(() => {
+			if (typeof progress.value === "number" && __vueuse_shared.isClient) setProgress.call(nprogress.default, progress.value);
+		});
+		(0, __vueuse_shared.tryOnScopeDispose)(nprogress.default.remove);
+		return {
+			isLoading,
+			progress,
+			start: nprogress.default.start,
+			done: nprogress.default.done,
+			remove: () => {
+				progress.value = null;
+				nprogress.default.remove();
+			}
+		};
+	}
+
+//#endregion
+//#region useQRCode/index.ts
+/**
+	* Wrapper for qrcode.
+	*
+	* @see https://vueuse.org/useQRCode
+	* @param text
+	* @param options
+	*/
+	function useQRCode(text, options) {
+		const src = (0, __vueuse_shared.toRef)(text);
+		const result = (0, vue.shallowRef)("");
+		(0, vue.watch)(src, async (value) => {
+			if (src.value && __vueuse_shared.isClient) result.value = await qrcode.default.toDataURL(value, options);
+		}, { immediate: true });
+		return result;
+	}
+
+//#endregion
+//#region useSortable/index.ts
+/**
+	* Wrapper for sortablejs.
+	* @param el
+	* @param list
+	* @param options
+	*/
+	function useSortable(el, list, options = {}) {
+		let sortable;
+		const { document = __vueuse_core.defaultDocument,...resetOptions } = options;
+		const defaultOptions = { onUpdate: (e) => {
+			moveArrayElement(list, e.oldIndex, e.newIndex, e);
+		} };
+		const start = () => {
+			const target = typeof el === "string" ? document === null || document === void 0 ? void 0 : document.querySelector(el) : (0, __vueuse_core.unrefElement)(el);
+			if (!target || sortable !== void 0) return;
+			sortable = new sortablejs.default(target, {
+				...defaultOptions,
+				...resetOptions
+			});
+		};
+		const stop = () => {
+			sortable === null || sortable === void 0 || sortable.destroy();
+			sortable = void 0;
+		};
+		const option = (name, value) => {
+			if (value !== void 0) sortable === null || sortable === void 0 || sortable.option(name, value);
+			else return sortable === null || sortable === void 0 ? void 0 : sortable.option(name);
+		};
+		(0, __vueuse_core.tryOnMounted)(start);
+		(0, __vueuse_core.tryOnScopeDispose)(stop);
+		return {
+			stop,
+			start,
+			option
+		};
+	}
+	/**
+	* Inserts a element into the DOM at a given index.
+	* @param parentElement
+	* @param element
+	* @param {number} index
+	* @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L81C1-L94C2
+	*/
+	function insertNodeAt(parentElement, element, index) {
+		const refElement = parentElement.children[index];
+		parentElement.insertBefore(element, refElement);
+	}
+	/**
+	* Removes a node from the DOM.
+	* @param {Node} node
+	* @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L96C1-L102C2
+	*/
+	function removeNode(node) {
+		if (node.parentNode) node.parentNode.removeChild(node);
+	}
+	function moveArrayElement(list, from, to, e = null) {
+		if (e != null) {
+			removeNode(e.item);
+			insertNodeAt(e.from, e.item, from);
+		}
+		const _valueIsRef = (0, vue.isRef)(list);
+		const array = _valueIsRef ? [...(0, vue.toValue)(list)] : (0, vue.toValue)(list);
+		if (to >= 0 && to < array.length) {
+			const element = array.splice(from, 1)[0];
+			(0, vue.nextTick)(() => {
+				array.splice(to, 0, element);
+				if (_valueIsRef) list.value = array;
+			});
+		}
+	}
+
+//#endregion
+exports.createCookies = createCookies;
+exports.insertNodeAt = insertNodeAt;
+exports.moveArrayElement = moveArrayElement;
+exports.removeNode = removeNode;
+exports.useAsyncValidator = useAsyncValidator;
+exports.useAxios = useAxios;
+exports.useChangeCase = useChangeCase;
+exports.useCookies = useCookies;
+exports.useDrauu = useDrauu;
+exports.useFocusTrap = useFocusTrap;
+exports.useFuse = useFuse;
+exports.useIDBKeyval = useIDBKeyval;
+exports.useJwt = useJwt;
+exports.useNProgress = useNProgress;
+exports.useQRCode = useQRCode;
+exports.useSortable = useSortable;
+})(this.VueUse = this.VueUse || {}, VueUse, AsyncValidator, Vue, axios, changeCase, UniversalCookie, VueUse, Drauu, focusTrap, Fuse, idbKeyval, jwt_decode, nprogress, QRCode, Sortable);

node_modules/@vueuse/integrations/dist/index.js

@@ -0,0 +1,14 @@
+import { t as useAsyncValidator } from "./useAsyncValidator-pcZPyeq7.js";
+import { t as useAxios } from "./useAxios-D34f-L7j.js";
+import { t as useChangeCase } from "./useChangeCase-CdpkIhHH.js";
+import { n as useCookies, t as createCookies } from "./useCookies-Bv215dgK.js";
+import { t as useDrauu } from "./useDrauu-DgG1pWis.js";
+import { t as useFocusTrap } from "./useFocusTrap-lXZ_YG-8.js";
+import { t as useFuse } from "./useFuse-CWPfSDMU.js";
+import { t as useIDBKeyval } from "./useIDBKeyval-D_wVPeQ7.js";
+import { t as useJwt } from "./useJwt-BB8OIN1z.js";
+import { t as useNProgress } from "./useNProgress-ClU-n87O.js";
+import { t as useQRCode } from "./useQRCode-DtYpMi-Z.js";
+import { i as useSortable, n as moveArrayElement, r as removeNode, t as insertNodeAt } from "./useSortable-jtnNPDb0.js";
+
+export { createCookies, insertNodeAt, moveArrayElement, removeNode, useAsyncValidator, useAxios, useChangeCase, useCookies, useDrauu, useFocusTrap, useFuse, useIDBKeyval, useJwt, useNProgress, useQRCode, useSortable };

node_modules/@vueuse/integrations/dist/useAsyncValidator-pcZPyeq7.js

@@ -0,0 +1,73 @@
+import { toRef, until } from "@vueuse/shared";
+import Schema from "async-validator";
+import { computed, shallowRef, toValue, watch } from "vue";
+
+//#region useAsyncValidator/index.ts
+const AsyncValidatorSchema = Schema.default || Schema;
+/**
+* Wrapper for async-validator.
+*
+* @see https://vueuse.org/useAsyncValidator
+* @see https://github.com/yiminghe/async-validator
+*/
+function useAsyncValidator(value, rules, options = {}) {
+	const { validateOption = {}, immediate = true, manual = false } = options;
+	const valueRef = toRef(value);
+	const errorInfo = shallowRef(null);
+	const isFinished = shallowRef(true);
+	const pass = shallowRef(!immediate || manual);
+	const errors = computed(() => {
+		var _errorInfo$value;
+		return ((_errorInfo$value = errorInfo.value) === null || _errorInfo$value === void 0 ? void 0 : _errorInfo$value.errors) || [];
+	});
+	const errorFields = computed(() => {
+		var _errorInfo$value2;
+		return ((_errorInfo$value2 = errorInfo.value) === null || _errorInfo$value2 === void 0 ? void 0 : _errorInfo$value2.fields) || {};
+	});
+	const validator = computed(() => new AsyncValidatorSchema(toValue(rules)));
+	const execute = async () => {
+		isFinished.value = false;
+		pass.value = false;
+		try {
+			await validator.value.validate(valueRef.value, validateOption);
+			pass.value = true;
+			errorInfo.value = null;
+		} catch (err) {
+			errorInfo.value = err;
+		} finally {
+			isFinished.value = true;
+		}
+		return {
+			pass: pass.value,
+			errorInfo: errorInfo.value,
+			errors: errors.value,
+			errorFields: errorFields.value
+		};
+	};
+	if (!manual) watch([valueRef, validator], () => execute(), {
+		immediate,
+		deep: true
+	});
+	const shell = {
+		isFinished,
+		pass,
+		errors,
+		errorInfo,
+		errorFields,
+		execute
+	};
+	function waitUntilFinished() {
+		return new Promise((resolve, reject) => {
+			until(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
+		});
+	}
+	return {
+		...shell,
+		then(onFulfilled, onRejected) {
+			return waitUntilFinished().then(onFulfilled, onRejected);
+		}
+	};
+}
+
+//#endregion
+export { useAsyncValidator as t };

node_modules/@vueuse/integrations/dist/useAsyncValidator.d.ts

@@ -0,0 +1,2 @@
+import { a as useAsyncValidator, i as UseAsyncValidatorReturn, n as UseAsyncValidatorExecuteReturn, r as UseAsyncValidatorOptions, t as AsyncValidatorError } from "./index-BgoBW25H.js";
+export { AsyncValidatorError, UseAsyncValidatorExecuteReturn, UseAsyncValidatorOptions, UseAsyncValidatorReturn, useAsyncValidator };

node_modules/@vueuse/integrations/dist/useAsyncValidator.iife.js

@@ -0,0 +1,99 @@
+(function(exports, __vueuse_shared, async_validator, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+async_validator = __toESM(async_validator);
+vue = __toESM(vue);
+
+//#region useAsyncValidator/index.ts
+	const AsyncValidatorSchema = async_validator.default.default || async_validator.default;
+	/**
+	* Wrapper for async-validator.
+	*
+	* @see https://vueuse.org/useAsyncValidator
+	* @see https://github.com/yiminghe/async-validator
+	*/
+	function useAsyncValidator(value, rules, options = {}) {
+		const { validateOption = {}, immediate = true, manual = false } = options;
+		const valueRef = (0, __vueuse_shared.toRef)(value);
+		const errorInfo = (0, vue.shallowRef)(null);
+		const isFinished = (0, vue.shallowRef)(true);
+		const pass = (0, vue.shallowRef)(!immediate || manual);
+		const errors = (0, vue.computed)(() => {
+			var _errorInfo$value;
+			return ((_errorInfo$value = errorInfo.value) === null || _errorInfo$value === void 0 ? void 0 : _errorInfo$value.errors) || [];
+		});
+		const errorFields = (0, vue.computed)(() => {
+			var _errorInfo$value2;
+			return ((_errorInfo$value2 = errorInfo.value) === null || _errorInfo$value2 === void 0 ? void 0 : _errorInfo$value2.fields) || {};
+		});
+		const validator = (0, vue.computed)(() => new AsyncValidatorSchema((0, vue.toValue)(rules)));
+		const execute = async () => {
+			isFinished.value = false;
+			pass.value = false;
+			try {
+				await validator.value.validate(valueRef.value, validateOption);
+				pass.value = true;
+				errorInfo.value = null;
+			} catch (err) {
+				errorInfo.value = err;
+			} finally {
+				isFinished.value = true;
+			}
+			return {
+				pass: pass.value,
+				errorInfo: errorInfo.value,
+				errors: errors.value,
+				errorFields: errorFields.value
+			};
+		};
+		if (!manual) (0, vue.watch)([valueRef, validator], () => execute(), {
+			immediate,
+			deep: true
+		});
+		const shell = {
+			isFinished,
+			pass,
+			errors,
+			errorInfo,
+			errorFields,
+			execute
+		};
+		function waitUntilFinished() {
+			return new Promise((resolve, reject) => {
+				(0, __vueuse_shared.until)(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
+			});
+		}
+		return {
+			...shell,
+			then(onFulfilled, onRejected) {
+				return waitUntilFinished().then(onFulfilled, onRejected);
+			}
+		};
+	}
+
+//#endregion
+exports.useAsyncValidator = useAsyncValidator;
+})(this.VueUse = this.VueUse || {}, VueUse, AsyncValidator, Vue);

node_modules/@vueuse/integrations/dist/useAsyncValidator.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);let f=n.default.default||n.default;function p(e,n,i={}){let{validateOption:a={},immediate:o=!0,manual:s=!1}=i,c=(0,t.toRef)(e),l=(0,r.shallowRef)(null),u=(0,r.shallowRef)(!0),d=(0,r.shallowRef)(!o||s),p=(0,r.computed)(()=>{var e;return((e=l.value)==null?void 0:e.errors)||[]}),m=(0,r.computed)(()=>{var e;return((e=l.value)==null?void 0:e.fields)||{}}),h=(0,r.computed)(()=>new f((0,r.toValue)(n))),g=async()=>{u.value=!1,d.value=!1;try{await h.value.validate(c.value,a),d.value=!0,l.value=null}catch(e){l.value=e}finally{u.value=!0}return{pass:d.value,errorInfo:l.value,errors:p.value,errorFields:m.value}};s||(0,r.watch)([c,h],()=>g(),{immediate:o,deep:!0});let _={isFinished:u,pass:d,errors:p,errorInfo:l,errorFields:m,execute:g};function v(){return new Promise((e,n)=>{(0,t.until)(u).toBe(!0).then(()=>e(_)).catch(e=>n(e))})}return{..._,then(e,t){return v().then(e,t)}}}e.useAsyncValidator=p})(this.VueUse=this.VueUse||{},VueUse,AsyncValidator,Vue);

node_modules/@vueuse/integrations/dist/useAsyncValidator.js

@@ -0,0 +1,3 @@
+import { t as useAsyncValidator } from "./useAsyncValidator-pcZPyeq7.js";
+
+export { useAsyncValidator };

node_modules/@vueuse/integrations/dist/useAsyncValidator/component.d.ts

@@ -0,0 +1,19 @@
+import { i as UseAsyncValidatorReturn, r as UseAsyncValidatorOptions } from "../index-BgoBW25H.js";
+import { Rules } from "async-validator";
+import * as vue0 from "vue";
+import { Reactive, SlotsType } from "vue";
+
+//#region useAsyncValidator/component.d.ts
+interface UseAsyncValidatorProps {
+  form: Record<string, any>;
+  rules: Rules;
+  options?: UseAsyncValidatorOptions;
+}
+interface UseAsyncValidatorSlots {
+  default: (data: Reactive<UseAsyncValidatorReturn>) => any;
+}
+declare const UseAsyncValidator: vue0.DefineSetupFnComponent<UseAsyncValidatorProps, Record<string, never>, SlotsType<UseAsyncValidatorSlots>, UseAsyncValidatorProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue0.PublicProps>;
+//#endregion
+export { UseAsyncValidator, UseAsyncValidatorProps };

node_modules/@vueuse/integrations/dist/useAsyncValidator/component.js

@@ -0,0 +1,20 @@
+import { t as useAsyncValidator } from "../useAsyncValidator-pcZPyeq7.js";
+import { defineComponent, reactive } from "vue";
+
+//#region useAsyncValidator/component.ts
+const UseAsyncValidator = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	const data = reactive(useAsyncValidator(props.form, props.rules));
+	return () => {
+		if (slots.default) return slots.default(data);
+	};
+}, {
+	name: "UseAsyncValidator",
+	props: [
+		"form",
+		"options",
+		"rules"
+	]
+});
+
+//#endregion
+export { UseAsyncValidator };

node_modules/@vueuse/integrations/dist/useAxios-D34f-L7j.js

@@ -0,0 +1,124 @@
+import { noop, until } from "@vueuse/shared";
+import { ref, shallowRef } from "vue";
+import axios, { AxiosError } from "axios";
+
+//#region useAxios/index.ts
+/**
+* Wrapper for axios.
+*
+* @see https://vueuse.org/useAxios
+*/
+function useAxios(...args) {
+	const url = typeof args[0] === "string" ? args[0] : void 0;
+	const argsPlaceholder = typeof url === "string" ? 1 : 0;
+	const defaultOptions = {
+		immediate: !!argsPlaceholder,
+		shallow: true,
+		abortPrevious: true
+	};
+	let defaultConfig = {};
+	let instance = axios;
+	let options = defaultOptions;
+	const isAxiosInstance = (val) => !!(val === null || val === void 0 ? void 0 : val.request);
+	if (args.length > 0 + argsPlaceholder)
+ /**
+	* Unable to use `instanceof` here because of (https://github.com/axios/axios/issues/737)
+	* so instead we are checking if there is a `request` on the object to see if it is an
+	* axios instance
+	*/
+	if (isAxiosInstance(args[0 + argsPlaceholder])) instance = args[0 + argsPlaceholder];
+	else defaultConfig = args[0 + argsPlaceholder];
+	if (args.length > 1 + argsPlaceholder) {
+		if (isAxiosInstance(args[1 + argsPlaceholder])) instance = args[1 + argsPlaceholder];
+	}
+	if (args.length === 2 + argsPlaceholder && !isAxiosInstance(args[1 + argsPlaceholder]) || args.length === 3 + argsPlaceholder) options = args[args.length - 1] || defaultOptions;
+	const { shallow, onSuccess = noop, onError = noop, immediate, resetOnExecute = false } = options;
+	const initialData = options.initialData;
+	const response = shallowRef();
+	const data = (shallow ? shallowRef : ref)(initialData);
+	const isFinished = shallowRef(false);
+	const isLoading = shallowRef(false);
+	const isAborted = shallowRef(false);
+	const error = shallowRef();
+	let abortController = new AbortController();
+	const abort = (message) => {
+		if (isFinished.value || !isLoading.value) return;
+		abortController.abort(message);
+		abortController = new AbortController();
+		isAborted.value = true;
+		isLoading.value = false;
+		isFinished.value = false;
+	};
+	const loading = (loading$1) => {
+		isLoading.value = loading$1;
+		isFinished.value = !loading$1;
+	};
+	/**
+	* Reset data to initialData
+	*/
+	const resetData = () => {
+		if (resetOnExecute) data.value = initialData;
+	};
+	const waitUntilFinished = () => new Promise((resolve, reject) => {
+		until(isFinished).toBe(true).then(() => error.value ? reject(error.value) : resolve(result));
+	});
+	const promise = {
+		then: (...args$1) => waitUntilFinished().then(...args$1),
+		catch: (...args$1) => waitUntilFinished().catch(...args$1)
+	};
+	let executeCounter = 0;
+	const execute = (executeUrl = url, config = {}) => {
+		error.value = void 0;
+		const _url = typeof executeUrl === "string" ? executeUrl : url !== null && url !== void 0 ? url : config.url;
+		if (_url === void 0) {
+			error.value = new AxiosError(AxiosError.ERR_INVALID_URL);
+			isFinished.value = true;
+			return promise;
+		}
+		resetData();
+		if (options.abortPrevious !== false) abort();
+		loading(true);
+		executeCounter += 1;
+		const currentExecuteCounter = executeCounter;
+		isAborted.value = false;
+		instance(_url, {
+			...defaultConfig,
+			...typeof executeUrl === "object" ? executeUrl : config,
+			signal: abortController.signal
+		}).then((r) => {
+			if (isAborted.value) return;
+			response.value = r;
+			const result$1 = r.data;
+			data.value = result$1;
+			onSuccess(result$1);
+		}).catch((e) => {
+			error.value = e;
+			onError(e);
+		}).finally(() => {
+			var _options$onFinish;
+			(_options$onFinish = options.onFinish) === null || _options$onFinish === void 0 || _options$onFinish.call(options);
+			if (currentExecuteCounter === executeCounter) loading(false);
+		});
+		return promise;
+	};
+	if (immediate && url) execute();
+	const result = {
+		response,
+		data,
+		error,
+		isFinished,
+		isLoading,
+		cancel: abort,
+		isAborted,
+		isCanceled: isAborted,
+		abort,
+		execute
+	};
+	return {
+		...result,
+		...promise
+	};
+}
+
+//#endregion
+export { useAxios as t };

node_modules/@vueuse/integrations/dist/useAxios.d.ts

@@ -0,0 +1,2 @@
+import { a as UseAxiosOptionsWithInitialData, i as UseAxiosOptionsBase, n as StrictUseAxiosReturn, o as UseAxiosReturn, r as UseAxiosOptions, s as useAxios, t as EasyUseAxiosReturn } from "./index-ch2MM_8w.js";
+export { EasyUseAxiosReturn, StrictUseAxiosReturn, UseAxiosOptions, UseAxiosOptionsBase, UseAxiosOptionsWithInitialData, UseAxiosReturn, useAxios };

node_modules/@vueuse/integrations/dist/useAxios.iife.js

@@ -0,0 +1,150 @@
+(function(exports, __vueuse_shared, axios, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+axios = __toESM(axios);
+vue = __toESM(vue);
+
+//#region useAxios/index.ts
+/**
+	* Wrapper for axios.
+	*
+	* @see https://vueuse.org/useAxios
+	*/
+	function useAxios(...args) {
+		const url = typeof args[0] === "string" ? args[0] : void 0;
+		const argsPlaceholder = typeof url === "string" ? 1 : 0;
+		const defaultOptions = {
+			immediate: !!argsPlaceholder,
+			shallow: true,
+			abortPrevious: true
+		};
+		let defaultConfig = {};
+		let instance = axios.default;
+		let options = defaultOptions;
+		const isAxiosInstance = (val) => !!(val === null || val === void 0 ? void 0 : val.request);
+		if (args.length > 0 + argsPlaceholder)
+ /**
+		* Unable to use `instanceof` here because of (https://github.com/axios/axios/issues/737)
+		* so instead we are checking if there is a `request` on the object to see if it is an
+		* axios instance
+		*/
+		if (isAxiosInstance(args[0 + argsPlaceholder])) instance = args[0 + argsPlaceholder];
+		else defaultConfig = args[0 + argsPlaceholder];
+		if (args.length > 1 + argsPlaceholder) {
+			if (isAxiosInstance(args[1 + argsPlaceholder])) instance = args[1 + argsPlaceholder];
+		}
+		if (args.length === 2 + argsPlaceholder && !isAxiosInstance(args[1 + argsPlaceholder]) || args.length === 3 + argsPlaceholder) options = args[args.length - 1] || defaultOptions;
+		const { shallow, onSuccess = __vueuse_shared.noop, onError = __vueuse_shared.noop, immediate, resetOnExecute = false } = options;
+		const initialData = options.initialData;
+		const response = (0, vue.shallowRef)();
+		const data = (shallow ? vue.shallowRef : vue.ref)(initialData);
+		const isFinished = (0, vue.shallowRef)(false);
+		const isLoading = (0, vue.shallowRef)(false);
+		const isAborted = (0, vue.shallowRef)(false);
+		const error = (0, vue.shallowRef)();
+		let abortController = new AbortController();
+		const abort = (message) => {
+			if (isFinished.value || !isLoading.value) return;
+			abortController.abort(message);
+			abortController = new AbortController();
+			isAborted.value = true;
+			isLoading.value = false;
+			isFinished.value = false;
+		};
+		const loading = (loading$1) => {
+			isLoading.value = loading$1;
+			isFinished.value = !loading$1;
+		};
+		/**
+		* Reset data to initialData
+		*/
+		const resetData = () => {
+			if (resetOnExecute) data.value = initialData;
+		};
+		const waitUntilFinished = () => new Promise((resolve, reject) => {
+			(0, __vueuse_shared.until)(isFinished).toBe(true).then(() => error.value ? reject(error.value) : resolve(result));
+		});
+		const promise = {
+			then: (...args$1) => waitUntilFinished().then(...args$1),
+			catch: (...args$1) => waitUntilFinished().catch(...args$1)
+		};
+		let executeCounter = 0;
+		const execute = (executeUrl = url, config = {}) => {
+			error.value = void 0;
+			const _url = typeof executeUrl === "string" ? executeUrl : url !== null && url !== void 0 ? url : config.url;
+			if (_url === void 0) {
+				error.value = new axios.AxiosError(axios.AxiosError.ERR_INVALID_URL);
+				isFinished.value = true;
+				return promise;
+			}
+			resetData();
+			if (options.abortPrevious !== false) abort();
+			loading(true);
+			executeCounter += 1;
+			const currentExecuteCounter = executeCounter;
+			isAborted.value = false;
+			instance(_url, {
+				...defaultConfig,
+				...typeof executeUrl === "object" ? executeUrl : config,
+				signal: abortController.signal
+			}).then((r) => {
+				if (isAborted.value) return;
+				response.value = r;
+				const result$1 = r.data;
+				data.value = result$1;
+				onSuccess(result$1);
+			}).catch((e) => {
+				error.value = e;
+				onError(e);
+			}).finally(() => {
+				var _options$onFinish;
+				(_options$onFinish = options.onFinish) === null || _options$onFinish === void 0 || _options$onFinish.call(options);
+				if (currentExecuteCounter === executeCounter) loading(false);
+			});
+			return promise;
+		};
+		if (immediate && url) execute();
+		const result = {
+			response,
+			data,
+			error,
+			isFinished,
+			isLoading,
+			cancel: abort,
+			isAborted,
+			isCanceled: isAborted,
+			abort,
+			execute
+		};
+		return {
+			...result,
+			...promise
+		};
+	}
+
+//#endregion
+exports.useAxios = useAxios;
+})(this.VueUse = this.VueUse || {}, VueUse, axios, Vue);

node_modules/@vueuse/integrations/dist/useAxios.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);function f(...e){let i=typeof e[0]==`string`?e[0]:void 0,a=typeof i==`string`?1:0,o={immediate:!!a,shallow:!0,abortPrevious:!0},s={},c=n.default,l=o,u=e=>!!(e!=null&&e.request);e.length>0+a&&(u(e[0+a])?c=e[0+a]:s=e[0+a]),e.length>1+a&&u(e[1+a])&&(c=e[1+a]),(e.length===2+a&&!u(e[1+a])||e.length===3+a)&&(l=e[e.length-1]||o);let{shallow:d,onSuccess:f=t.noop,onError:p=t.noop,immediate:m,resetOnExecute:h=!1}=l,g=l.initialData,_=(0,r.shallowRef)(),v=(d?r.shallowRef:r.ref)(g),y=(0,r.shallowRef)(!1),b=(0,r.shallowRef)(!1),x=(0,r.shallowRef)(!1),S=(0,r.shallowRef)(),C=new AbortController,w=e=>{y.value||!b.value||(C.abort(e),C=new AbortController,x.value=!0,b.value=!1,y.value=!1)},T=e=>{b.value=e,y.value=!e},E=()=>{h&&(v.value=g)},D=()=>new Promise((e,n)=>{(0,t.until)(y).toBe(!0).then(()=>S.value?n(S.value):e(j))}),O={then:(...e)=>D().then(...e),catch:(...e)=>D().catch(...e)},k=0,A=(e=i,t={})=>{S.value=void 0;let r=typeof e==`string`?e:i==null?t.url:i;if(r===void 0)return S.value=new n.AxiosError(n.AxiosError.ERR_INVALID_URL),y.value=!0,O;E(),l.abortPrevious!==!1&&w(),T(!0),k+=1;let a=k;return x.value=!1,c(r,{...s,...typeof e==`object`?e:t,signal:C.signal}).then(e=>{if(x.value)return;_.value=e;let t=e.data;v.value=t,f(t)}).catch(e=>{S.value=e,p(e)}).finally(()=>{var e;(e=l.onFinish)==null||e.call(l),a===k&&T(!1)}),O};m&&i&&A();let j={response:_,data:v,error:S,isFinished:y,isLoading:b,cancel:w,isAborted:x,isCanceled:x,abort:w,execute:A};return{...j,...O}}e.useAxios=f})(this.VueUse=this.VueUse||{},VueUse,axios,Vue);

node_modules/@vueuse/integrations/dist/useAxios.js

@@ -0,0 +1,3 @@
+import { t as useAxios } from "./useAxios-D34f-L7j.js";
+
+export { useAxios };

node_modules/@vueuse/integrations/dist/useChangeCase-CdpkIhHH.js

@@ -0,0 +1,35 @@
+import { computed, ref, toValue } from "vue";
+import * as changeCase from "change-case";
+
+//#region useChangeCase/index.ts
+const changeCaseTransforms = /* @__PURE__ */ Object.entries(changeCase).filter(([name, fn]) => typeof fn === "function" && name.endsWith("Case")).reduce((acc, [name, fn]) => {
+	acc[name] = fn;
+	return acc;
+}, {});
+/**
+* Reactive wrapper for `change-case`
+*
+* @see https://vueuse.org/useChangeCase
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useChangeCase(input, type, options) {
+	const typeRef = computed(() => {
+		const t = toValue(type);
+		if (!changeCaseTransforms[t]) throw new Error(`Invalid change case type "${t}"`);
+		return t;
+	});
+	if (typeof input === "function") return computed(() => changeCaseTransforms[typeRef.value](toValue(input), toValue(options)));
+	const text = ref(input);
+	return computed({
+		get() {
+			return changeCaseTransforms[typeRef.value](text.value, toValue(options));
+		},
+		set(value) {
+			text.value = value;
+		}
+	});
+}
+
+//#endregion
+export { useChangeCase as t };

node_modules/@vueuse/integrations/dist/useChangeCase.d.ts

@@ -0,0 +1,2 @@
+import { n as useChangeCase, t as ChangeCaseType } from "./index-CxO-Pb3x.js";
+export { ChangeCaseType, useChangeCase };

node_modules/@vueuse/integrations/dist/useChangeCase.iife.js

@@ -0,0 +1,61 @@
+(function(exports, change_case, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+change_case = __toESM(change_case);
+vue = __toESM(vue);
+
+//#region useChangeCase/index.ts
+	const changeCaseTransforms = /* @__PURE__ */ Object.entries(change_case).filter(([name, fn]) => typeof fn === "function" && name.endsWith("Case")).reduce((acc, [name, fn]) => {
+		acc[name] = fn;
+		return acc;
+	}, {});
+	/**
+	* Reactive wrapper for `change-case`
+	*
+	* @see https://vueuse.org/useChangeCase
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useChangeCase(input, type, options) {
+		const typeRef = (0, vue.computed)(() => {
+			const t = (0, vue.toValue)(type);
+			if (!changeCaseTransforms[t]) throw new Error(`Invalid change case type "${t}"`);
+			return t;
+		});
+		if (typeof input === "function") return (0, vue.computed)(() => changeCaseTransforms[typeRef.value]((0, vue.toValue)(input), (0, vue.toValue)(options)));
+		const text = (0, vue.ref)(input);
+		return (0, vue.computed)({
+			get() {
+				return changeCaseTransforms[typeRef.value](text.value, (0, vue.toValue)(options));
+			},
+			set(value) {
+				text.value = value;
+			}
+		});
+	}
+
+//#endregion
+exports.useChangeCase = useChangeCase;
+})(this.VueUse = this.VueUse || {}, changeCase, Vue);

node_modules/@vueuse/integrations/dist/useChangeCase.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n){var r=Object.create,i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.getPrototypeOf,c=Object.prototype.hasOwnProperty,l=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var s=o(t),l=0,u=s.length,d;l<u;l++)d=s[l],!c.call(e,d)&&d!==n&&i(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=a(t,d))||r.enumerable});return e},u=(e,t,n)=>(n=e==null?{}:r(s(e)),l(t||!e||!e.__esModule?i(n,`default`,{value:e,enumerable:!0}):n,e));t=u(t),n=u(n);let d=Object.entries(t).filter(([e,t])=>typeof t==`function`&&e.endsWith(`Case`)).reduce((e,[t,n])=>(e[t]=n,e),{});function f(e,t,r){let i=(0,n.computed)(()=>{let e=(0,n.toValue)(t);if(!d[e])throw Error(`Invalid change case type "${e}"`);return e});if(typeof e==`function`)return(0,n.computed)(()=>d[i.value]((0,n.toValue)(e),(0,n.toValue)(r)));let a=(0,n.ref)(e);return(0,n.computed)({get(){return d[i.value](a.value,(0,n.toValue)(r))},set(e){a.value=e}})}e.useChangeCase=f})(this.VueUse=this.VueUse||{},changeCase,Vue);

node_modules/@vueuse/integrations/dist/useChangeCase.js

@@ -0,0 +1,3 @@
+import { t as useChangeCase } from "./useChangeCase-CdpkIhHH.js";
+
+export { useChangeCase };

node_modules/@vueuse/integrations/dist/useCookies-Bv215dgK.js

@@ -0,0 +1,77 @@
+import { tryOnScopeDispose } from "@vueuse/shared";
+import { shallowRef } from "vue";
+import Cookie from "universal-cookie";
+
+//#region useCookies/index.ts
+/**
+* Creates a new {@link useCookies} function
+* @param req - incoming http request (for SSR)
+* @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+* @description Creates universal-cookie instance using request (default is window.document.cookie) and returns {@link useCookies} function with provided universal-cookie instance
+*/
+function createCookies(req) {
+	const universalCookie = new Cookie(req ? req.headers.cookie : null);
+	return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, {
+		doNotParse,
+		autoUpdateDependencies
+	}, universalCookie);
+}
+/**
+* Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
+* @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+* @param options
+* @param options.doNotParse - don't try parse value as JSON
+* @param options.autoUpdateDependencies - automatically update watching dependencies
+* @param cookies - universal-cookie instance
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new Cookie()) {
+	const watchingDependencies = autoUpdateDependencies ? [...dependencies || []] : dependencies;
+	let previousCookies = cookies.getAll({ doNotParse: true });
+	/**
+	* Adds reactivity to get/getAll methods
+	*/
+	const touches = shallowRef(0);
+	const onChange = () => {
+		const newCookies = cookies.getAll({ doNotParse: true });
+		if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies)) touches.value++;
+		previousCookies = newCookies;
+	};
+	cookies.addChangeListener(onChange);
+	tryOnScopeDispose(() => {
+		cookies.removeChangeListener(onChange);
+	});
+	return {
+		get: (...args) => {
+			/**
+			* Auto update watching dependencies if needed
+			*/
+			if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0])) watchingDependencies.push(args[0]);
+			touches.value;
+			return cookies.get(args[0], {
+				doNotParse,
+				...args[1]
+			});
+		},
+		getAll: (...args) => {
+			touches.value;
+			return cookies.getAll({
+				doNotParse,
+				...args[0]
+			});
+		},
+		set: (...args) => cookies.set(...args),
+		remove: (...args) => cookies.remove(...args),
+		addChangeListener: (...args) => cookies.addChangeListener(...args),
+		removeChangeListener: (...args) => cookies.removeChangeListener(...args)
+	};
+}
+function shouldUpdate(dependencies, newCookies, oldCookies) {
+	if (!dependencies) return true;
+	for (const dependency of dependencies) if (newCookies[dependency] !== oldCookies[dependency]) return true;
+	return false;
+}
+
+//#endregion
+export { useCookies as n, createCookies as t };

node_modules/@vueuse/integrations/dist/useCookies.d.ts

@@ -0,0 +1,2 @@
+import { n as useCookies, t as createCookies } from "./index-C0C_B0mW.js";
+export { createCookies, useCookies };

node_modules/@vueuse/integrations/dist/useCookies.iife.js

@@ -0,0 +1,104 @@
+(function(exports, __vueuse_shared, universal_cookie, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+universal_cookie = __toESM(universal_cookie);
+vue = __toESM(vue);
+
+//#region useCookies/index.ts
+/**
+	* Creates a new {@link useCookies} function
+	* @param req - incoming http request (for SSR)
+	* @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+	* @description Creates universal-cookie instance using request (default is window.document.cookie) and returns {@link useCookies} function with provided universal-cookie instance
+	*/
+	function createCookies(req) {
+		const universalCookie = new universal_cookie.default(req ? req.headers.cookie : null);
+		return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, {
+			doNotParse,
+			autoUpdateDependencies
+		}, universalCookie);
+	}
+	/**
+	* Reactive methods to work with cookies (use {@link createCookies} method instead if you are using SSR)
+	* @param dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
+	* @param options
+	* @param options.doNotParse - don't try parse value as JSON
+	* @param options.autoUpdateDependencies - automatically update watching dependencies
+	* @param cookies - universal-cookie instance
+	*
+	* @__NO_SIDE_EFFECTS__
+	*/
+	function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new universal_cookie.default()) {
+		const watchingDependencies = autoUpdateDependencies ? [...dependencies || []] : dependencies;
+		let previousCookies = cookies.getAll({ doNotParse: true });
+		/**
+		* Adds reactivity to get/getAll methods
+		*/
+		const touches = (0, vue.shallowRef)(0);
+		const onChange = () => {
+			const newCookies = cookies.getAll({ doNotParse: true });
+			if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies)) touches.value++;
+			previousCookies = newCookies;
+		};
+		cookies.addChangeListener(onChange);
+		(0, __vueuse_shared.tryOnScopeDispose)(() => {
+			cookies.removeChangeListener(onChange);
+		});
+		return {
+			get: (...args) => {
+				/**
+				* Auto update watching dependencies if needed
+				*/
+				if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0])) watchingDependencies.push(args[0]);
+				touches.value;
+				return cookies.get(args[0], {
+					doNotParse,
+					...args[1]
+				});
+			},
+			getAll: (...args) => {
+				touches.value;
+				return cookies.getAll({
+					doNotParse,
+					...args[0]
+				});
+			},
+			set: (...args) => cookies.set(...args),
+			remove: (...args) => cookies.remove(...args),
+			addChangeListener: (...args) => cookies.addChangeListener(...args),
+			removeChangeListener: (...args) => cookies.removeChangeListener(...args)
+		};
+	}
+	function shouldUpdate(dependencies, newCookies, oldCookies) {
+		if (!dependencies) return true;
+		for (const dependency of dependencies) if (newCookies[dependency] !== oldCookies[dependency]) return true;
+		return false;
+	}
+
+//#endregion
+exports.createCookies = createCookies;
+exports.useCookies = useCookies;
+})(this.VueUse = this.VueUse || {}, VueUse, UniversalCookie, Vue);

node_modules/@vueuse/integrations/dist/useCookies.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);function f(e){let t=new n.default(e?e.headers.cookie:null);return(e,{doNotParse:n=!1,autoUpdateDependencies:r=!1}={})=>p(e,{doNotParse:n,autoUpdateDependencies:r},t)}function p(e,{doNotParse:i=!1,autoUpdateDependencies:a=!1}={},o=new n.default){let s=a?[...e||[]]:e,c=o.getAll({doNotParse:!0}),l=(0,r.shallowRef)(0),u=()=>{let e=o.getAll({doNotParse:!0});m(s||null,e,c)&&l.value++,c=e};return o.addChangeListener(u),(0,t.tryOnScopeDispose)(()=>{o.removeChangeListener(u)}),{get:(...e)=>(a&&s&&!s.includes(e[0])&&s.push(e[0]),l.value,o.get(e[0],{doNotParse:i,...e[1]})),getAll:(...e)=>(l.value,o.getAll({doNotParse:i,...e[0]})),set:(...e)=>o.set(...e),remove:(...e)=>o.remove(...e),addChangeListener:(...e)=>o.addChangeListener(...e),removeChangeListener:(...e)=>o.removeChangeListener(...e)}}function m(e,t,n){if(!e)return!0;for(let r of e)if(t[r]!==n[r])return!0;return!1}e.createCookies=f,e.useCookies=p})(this.VueUse=this.VueUse||{},VueUse,UniversalCookie,Vue);

node_modules/@vueuse/integrations/dist/useCookies.js

@@ -0,0 +1,3 @@
+import { n as useCookies, t as createCookies } from "./useCookies-Bv215dgK.js";
+
+export { createCookies, useCookies };

node_modules/@vueuse/integrations/dist/useDrauu-DgG1pWis.js

@@ -0,0 +1,120 @@
+import { tryOnScopeDispose } from "@vueuse/shared";
+import { ref, shallowRef, watch } from "vue";
+import { createEventHook, unrefElement } from "@vueuse/core";
+import { createDrauu } from "drauu";
+
+//#region useDrauu/index.ts
+/**
+* Reactive drauu
+*
+* @see https://vueuse.org/useDrauu
+* @param target The target svg element
+* @param options Drauu Options
+*/
+function useDrauu(target, options) {
+	const drauuInstance = ref();
+	let disposables = [];
+	const onChangedHook = createEventHook();
+	const onCanceledHook = createEventHook();
+	const onCommittedHook = createEventHook();
+	const onStartHook = createEventHook();
+	const onEndHook = createEventHook();
+	const canUndo = shallowRef(false);
+	const canRedo = shallowRef(false);
+	const altPressed = shallowRef(false);
+	const shiftPressed = shallowRef(false);
+	const brush = ref({
+		color: "black",
+		size: 3,
+		arrowEnd: false,
+		cornerRadius: 0,
+		dasharray: void 0,
+		fill: "transparent",
+		mode: "draw",
+		...options === null || options === void 0 ? void 0 : options.brush
+	});
+	watch(brush, () => {
+		const instance = drauuInstance.value;
+		if (instance) {
+			instance.brush = brush.value;
+			instance.mode = brush.value.mode;
+		}
+	}, { deep: true });
+	const undo = () => {
+		var _drauuInstance$value;
+		return (_drauuInstance$value = drauuInstance.value) === null || _drauuInstance$value === void 0 ? void 0 : _drauuInstance$value.undo();
+	};
+	const redo = () => {
+		var _drauuInstance$value2;
+		return (_drauuInstance$value2 = drauuInstance.value) === null || _drauuInstance$value2 === void 0 ? void 0 : _drauuInstance$value2.redo();
+	};
+	const clear = () => {
+		var _drauuInstance$value3;
+		return (_drauuInstance$value3 = drauuInstance.value) === null || _drauuInstance$value3 === void 0 ? void 0 : _drauuInstance$value3.clear();
+	};
+	const cancel = () => {
+		var _drauuInstance$value4;
+		return (_drauuInstance$value4 = drauuInstance.value) === null || _drauuInstance$value4 === void 0 ? void 0 : _drauuInstance$value4.cancel();
+	};
+	const load = (svg) => {
+		var _drauuInstance$value5;
+		return (_drauuInstance$value5 = drauuInstance.value) === null || _drauuInstance$value5 === void 0 ? void 0 : _drauuInstance$value5.load(svg);
+	};
+	const dump = () => {
+		var _drauuInstance$value6;
+		return (_drauuInstance$value6 = drauuInstance.value) === null || _drauuInstance$value6 === void 0 ? void 0 : _drauuInstance$value6.dump();
+	};
+	const cleanup = () => {
+		var _drauuInstance$value7;
+		disposables.forEach((dispose) => dispose());
+		(_drauuInstance$value7 = drauuInstance.value) === null || _drauuInstance$value7 === void 0 || _drauuInstance$value7.unmount();
+	};
+	const syncStatus = () => {
+		if (drauuInstance.value) {
+			canUndo.value = drauuInstance.value.canUndo();
+			canRedo.value = drauuInstance.value.canRedo();
+			altPressed.value = drauuInstance.value.altPressed;
+			shiftPressed.value = drauuInstance.value.shiftPressed;
+		}
+	};
+	watch(() => unrefElement(target), (el) => {
+		if (!el || typeof SVGSVGElement === "undefined" || !(el instanceof SVGSVGElement)) return;
+		if (drauuInstance.value) cleanup();
+		drauuInstance.value = createDrauu({
+			el,
+			...options
+		});
+		syncStatus();
+		disposables = [
+			drauuInstance.value.on("canceled", () => onCanceledHook.trigger()),
+			drauuInstance.value.on("committed", (node) => onCommittedHook.trigger(node)),
+			drauuInstance.value.on("start", () => onStartHook.trigger()),
+			drauuInstance.value.on("end", () => onEndHook.trigger()),
+			drauuInstance.value.on("changed", () => {
+				syncStatus();
+				onChangedHook.trigger();
+			})
+		];
+	}, { flush: "post" });
+	tryOnScopeDispose(() => cleanup());
+	return {
+		drauuInstance,
+		load,
+		dump,
+		clear,
+		cancel,
+		undo,
+		redo,
+		canUndo,
+		canRedo,
+		brush,
+		onChanged: onChangedHook.on,
+		onCommitted: onCommittedHook.on,
+		onStart: onStartHook.on,
+		onEnd: onEndHook.on,
+		onCanceled: onCanceledHook.on
+	};
+}
+
+//#endregion
+export { useDrauu as t };

node_modules/@vueuse/integrations/dist/useDrauu.d.ts

@@ -0,0 +1,2 @@
+import { n as UseDrauuReturn, r as useDrauu, t as UseDrauuOptions } from "./index-BBxze4rb.js";
+export { UseDrauuOptions, UseDrauuReturn, useDrauu };

node_modules/@vueuse/integrations/dist/useDrauu.iife.js

@@ -0,0 +1,146 @@
+(function(exports, __vueuse_core, __vueuse_shared, drauu, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_core = __toESM(__vueuse_core);
+__vueuse_shared = __toESM(__vueuse_shared);
+drauu = __toESM(drauu);
+vue = __toESM(vue);
+
+//#region useDrauu/index.ts
+/**
+	* Reactive drauu
+	*
+	* @see https://vueuse.org/useDrauu
+	* @param target The target svg element
+	* @param options Drauu Options
+	*/
+	function useDrauu(target, options) {
+		const drauuInstance = (0, vue.ref)();
+		let disposables = [];
+		const onChangedHook = (0, __vueuse_core.createEventHook)();
+		const onCanceledHook = (0, __vueuse_core.createEventHook)();
+		const onCommittedHook = (0, __vueuse_core.createEventHook)();
+		const onStartHook = (0, __vueuse_core.createEventHook)();
+		const onEndHook = (0, __vueuse_core.createEventHook)();
+		const canUndo = (0, vue.shallowRef)(false);
+		const canRedo = (0, vue.shallowRef)(false);
+		const altPressed = (0, vue.shallowRef)(false);
+		const shiftPressed = (0, vue.shallowRef)(false);
+		const brush = (0, vue.ref)({
+			color: "black",
+			size: 3,
+			arrowEnd: false,
+			cornerRadius: 0,
+			dasharray: void 0,
+			fill: "transparent",
+			mode: "draw",
+			...options === null || options === void 0 ? void 0 : options.brush
+		});
+		(0, vue.watch)(brush, () => {
+			const instance = drauuInstance.value;
+			if (instance) {
+				instance.brush = brush.value;
+				instance.mode = brush.value.mode;
+			}
+		}, { deep: true });
+		const undo = () => {
+			var _drauuInstance$value;
+			return (_drauuInstance$value = drauuInstance.value) === null || _drauuInstance$value === void 0 ? void 0 : _drauuInstance$value.undo();
+		};
+		const redo = () => {
+			var _drauuInstance$value2;
+			return (_drauuInstance$value2 = drauuInstance.value) === null || _drauuInstance$value2 === void 0 ? void 0 : _drauuInstance$value2.redo();
+		};
+		const clear = () => {
+			var _drauuInstance$value3;
+			return (_drauuInstance$value3 = drauuInstance.value) === null || _drauuInstance$value3 === void 0 ? void 0 : _drauuInstance$value3.clear();
+		};
+		const cancel = () => {
+			var _drauuInstance$value4;
+			return (_drauuInstance$value4 = drauuInstance.value) === null || _drauuInstance$value4 === void 0 ? void 0 : _drauuInstance$value4.cancel();
+		};
+		const load = (svg) => {
+			var _drauuInstance$value5;
+			return (_drauuInstance$value5 = drauuInstance.value) === null || _drauuInstance$value5 === void 0 ? void 0 : _drauuInstance$value5.load(svg);
+		};
+		const dump = () => {
+			var _drauuInstance$value6;
+			return (_drauuInstance$value6 = drauuInstance.value) === null || _drauuInstance$value6 === void 0 ? void 0 : _drauuInstance$value6.dump();
+		};
+		const cleanup = () => {
+			var _drauuInstance$value7;
+			disposables.forEach((dispose) => dispose());
+			(_drauuInstance$value7 = drauuInstance.value) === null || _drauuInstance$value7 === void 0 || _drauuInstance$value7.unmount();
+		};
+		const syncStatus = () => {
+			if (drauuInstance.value) {
+				canUndo.value = drauuInstance.value.canUndo();
+				canRedo.value = drauuInstance.value.canRedo();
+				altPressed.value = drauuInstance.value.altPressed;
+				shiftPressed.value = drauuInstance.value.shiftPressed;
+			}
+		};
+		(0, vue.watch)(() => (0, __vueuse_core.unrefElement)(target), (el) => {
+			if (!el || typeof SVGSVGElement === "undefined" || !(el instanceof SVGSVGElement)) return;
+			if (drauuInstance.value) cleanup();
+			drauuInstance.value = (0, drauu.createDrauu)({
+				el,
+				...options
+			});
+			syncStatus();
+			disposables = [
+				drauuInstance.value.on("canceled", () => onCanceledHook.trigger()),
+				drauuInstance.value.on("committed", (node) => onCommittedHook.trigger(node)),
+				drauuInstance.value.on("start", () => onStartHook.trigger()),
+				drauuInstance.value.on("end", () => onEndHook.trigger()),
+				drauuInstance.value.on("changed", () => {
+					syncStatus();
+					onChangedHook.trigger();
+				})
+			];
+		}, { flush: "post" });
+		(0, __vueuse_shared.tryOnScopeDispose)(() => cleanup());
+		return {
+			drauuInstance,
+			load,
+			dump,
+			clear,
+			cancel,
+			undo,
+			redo,
+			canUndo,
+			canRedo,
+			brush,
+			onChanged: onChangedHook.on,
+			onCommitted: onCommittedHook.on,
+			onStart: onStartHook.on,
+			onEnd: onEndHook.on,
+			onCanceled: onCanceledHook.on
+		};
+	}
+
+//#endregion
+exports.useDrauu = useDrauu;
+})(this.VueUse = this.VueUse || {}, VueUse, VueUse, Drauu, Vue);

node_modules/@vueuse/integrations/dist/useDrauu.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r,i){var a=Object.create,o=Object.defineProperty,s=Object.getOwnPropertyDescriptor,c=Object.getOwnPropertyNames,l=Object.getPrototypeOf,u=Object.prototype.hasOwnProperty,d=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=c(t),a=0,l=i.length,d;a<l;a++)d=i[a],!u.call(e,d)&&d!==n&&o(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=s(t,d))||r.enumerable});return e},f=(e,t,n)=>(n=e==null?{}:a(l(e)),d(t||!e||!e.__esModule?o(n,`default`,{value:e,enumerable:!0}):n,e));t=f(t),n=f(n),r=f(r),i=f(i);function p(e,a){let o=(0,i.ref)(),s=[],c=(0,t.createEventHook)(),l=(0,t.createEventHook)(),u=(0,t.createEventHook)(),d=(0,t.createEventHook)(),f=(0,t.createEventHook)(),p=(0,i.shallowRef)(!1),m=(0,i.shallowRef)(!1),h=(0,i.shallowRef)(!1),g=(0,i.shallowRef)(!1),_=(0,i.ref)({color:`black`,size:3,arrowEnd:!1,cornerRadius:0,dasharray:void 0,fill:`transparent`,mode:`draw`,...a==null?void 0:a.brush});(0,i.watch)(_,()=>{let e=o.value;e&&(e.brush=_.value,e.mode=_.value.mode)},{deep:!0});let v=()=>{var e;return(e=o.value)==null?void 0:e.undo()},y=()=>{var e;return(e=o.value)==null?void 0:e.redo()},b=()=>{var e;return(e=o.value)==null?void 0:e.clear()},x=()=>{var e;return(e=o.value)==null?void 0:e.cancel()},S=e=>{var t;return(t=o.value)==null?void 0:t.load(e)},C=()=>{var e;return(e=o.value)==null?void 0:e.dump()},w=()=>{var e;s.forEach(e=>e()),(e=o.value)==null||e.unmount()},T=()=>{o.value&&(p.value=o.value.canUndo(),m.value=o.value.canRedo(),h.value=o.value.altPressed,g.value=o.value.shiftPressed)};return(0,i.watch)(()=>(0,t.unrefElement)(e),e=>{!e||typeof SVGSVGElement>`u`||!(e instanceof SVGSVGElement)||(o.value&&w(),o.value=(0,r.createDrauu)({el:e,...a}),T(),s=[o.value.on(`canceled`,()=>l.trigger()),o.value.on(`committed`,e=>u.trigger(e)),o.value.on(`start`,()=>d.trigger()),o.value.on(`end`,()=>f.trigger()),o.value.on(`changed`,()=>{T(),c.trigger()})])},{flush:`post`}),(0,n.tryOnScopeDispose)(()=>w()),{drauuInstance:o,load:S,dump:C,clear:b,cancel:x,undo:v,redo:y,canUndo:p,canRedo:m,brush:_,onChanged:c.on,onCommitted:u.on,onStart:d.on,onEnd:f.on,onCanceled:l.on}}e.useDrauu=p})(this.VueUse=this.VueUse||{},VueUse,VueUse,Drauu,Vue);

node_modules/@vueuse/integrations/dist/useDrauu.js

@@ -0,0 +1,3 @@
+import { t as useDrauu } from "./useDrauu-DgG1pWis.js";
+
+export { useDrauu };

node_modules/@vueuse/integrations/dist/useFocusTrap-lXZ_YG-8.js

@@ -0,0 +1,69 @@
+import { notNullish } from "@vueuse/shared";
+import { computed, shallowRef, toValue, watch } from "vue";
+import { toArray, tryOnScopeDispose as tryOnScopeDispose$1, unrefElement } from "@vueuse/core";
+import { createFocusTrap } from "focus-trap";
+
+//#region useFocusTrap/index.ts
+/**
+* Reactive focus-trap
+*
+* @see https://vueuse.org/useFocusTrap
+*/
+function useFocusTrap(target, options = {}) {
+	let trap;
+	const { immediate,...focusTrapOptions } = options;
+	const hasFocus = shallowRef(false);
+	const isPaused = shallowRef(false);
+	const activate = (opts) => trap && trap.activate(opts);
+	const deactivate = (opts) => trap && trap.deactivate(opts);
+	const pause = () => {
+		if (trap) {
+			trap.pause();
+			isPaused.value = true;
+		}
+	};
+	const unpause = () => {
+		if (trap) {
+			trap.unpause();
+			isPaused.value = false;
+		}
+	};
+	watch(computed(() => {
+		return toArray(toValue(target)).map((el) => {
+			const _el = toValue(el);
+			return typeof _el === "string" ? _el : unrefElement(_el);
+		}).filter(notNullish);
+	}), (els) => {
+		if (!els.length) return;
+		if (!trap) {
+			trap = createFocusTrap(els, {
+				...focusTrapOptions,
+				onActivate() {
+					hasFocus.value = true;
+					if (options.onActivate) options.onActivate();
+				},
+				onDeactivate() {
+					hasFocus.value = false;
+					if (options.onDeactivate) options.onDeactivate();
+				}
+			});
+			if (immediate) activate();
+		} else {
+			const isActive = trap === null || trap === void 0 ? void 0 : trap.active;
+			trap === null || trap === void 0 || trap.updateContainerElements(els);
+			if (!isActive && immediate) activate();
+		}
+	}, { flush: "post" });
+	tryOnScopeDispose$1(() => deactivate());
+	return {
+		hasFocus,
+		isPaused,
+		activate,
+		deactivate,
+		pause,
+		unpause
+	};
+}
+
+//#endregion
+export { useFocusTrap as t };

node_modules/@vueuse/integrations/dist/useFocusTrap.d.ts

@@ -0,0 +1,2 @@
+import { n as UseFocusTrapReturn, r as useFocusTrap, t as UseFocusTrapOptions } from "./index-CJw_eFkJ.js";
+export { UseFocusTrapOptions, UseFocusTrapReturn, useFocusTrap };

node_modules/@vueuse/integrations/dist/useFocusTrap.iife.js

@@ -0,0 +1,95 @@
+(function(exports, __vueuse_core, __vueuse_shared, focus_trap, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_core = __toESM(__vueuse_core);
+__vueuse_shared = __toESM(__vueuse_shared);
+focus_trap = __toESM(focus_trap);
+vue = __toESM(vue);
+
+//#region useFocusTrap/index.ts
+/**
+	* Reactive focus-trap
+	*
+	* @see https://vueuse.org/useFocusTrap
+	*/
+	function useFocusTrap(target, options = {}) {
+		let trap;
+		const { immediate,...focusTrapOptions } = options;
+		const hasFocus = (0, vue.shallowRef)(false);
+		const isPaused = (0, vue.shallowRef)(false);
+		const activate = (opts) => trap && trap.activate(opts);
+		const deactivate = (opts) => trap && trap.deactivate(opts);
+		const pause = () => {
+			if (trap) {
+				trap.pause();
+				isPaused.value = true;
+			}
+		};
+		const unpause = () => {
+			if (trap) {
+				trap.unpause();
+				isPaused.value = false;
+			}
+		};
+		(0, vue.watch)((0, vue.computed)(() => {
+			return (0, __vueuse_core.toArray)((0, vue.toValue)(target)).map((el) => {
+				const _el = (0, vue.toValue)(el);
+				return typeof _el === "string" ? _el : (0, __vueuse_core.unrefElement)(_el);
+			}).filter(__vueuse_shared.notNullish);
+		}), (els) => {
+			if (!els.length) return;
+			if (!trap) {
+				trap = (0, focus_trap.createFocusTrap)(els, {
+					...focusTrapOptions,
+					onActivate() {
+						hasFocus.value = true;
+						if (options.onActivate) options.onActivate();
+					},
+					onDeactivate() {
+						hasFocus.value = false;
+						if (options.onDeactivate) options.onDeactivate();
+					}
+				});
+				if (immediate) activate();
+			} else {
+				const isActive = trap === null || trap === void 0 ? void 0 : trap.active;
+				trap === null || trap === void 0 || trap.updateContainerElements(els);
+				if (!isActive && immediate) activate();
+			}
+		}, { flush: "post" });
+		(0, __vueuse_core.tryOnScopeDispose)(() => deactivate());
+		return {
+			hasFocus,
+			isPaused,
+			activate,
+			deactivate,
+			pause,
+			unpause
+		};
+	}
+
+//#endregion
+exports.useFocusTrap = useFocusTrap;
+})(this.VueUse = this.VueUse || {}, VueUse, VueUse, focusTrap, Vue);

node_modules/@vueuse/integrations/dist/useFocusTrap.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r,i){var a=Object.create,o=Object.defineProperty,s=Object.getOwnPropertyDescriptor,c=Object.getOwnPropertyNames,l=Object.getPrototypeOf,u=Object.prototype.hasOwnProperty,d=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=c(t),a=0,l=i.length,d;a<l;a++)d=i[a],!u.call(e,d)&&d!==n&&o(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=s(t,d))||r.enumerable});return e},f=(e,t,n)=>(n=e==null?{}:a(l(e)),d(t||!e||!e.__esModule?o(n,`default`,{value:e,enumerable:!0}):n,e));t=f(t),n=f(n),r=f(r),i=f(i);function p(e,a={}){let o,{immediate:s,...c}=a,l=(0,i.shallowRef)(!1),u=(0,i.shallowRef)(!1),d=e=>o&&o.activate(e),f=e=>o&&o.deactivate(e);return(0,i.watch)((0,i.computed)(()=>(0,t.toArray)((0,i.toValue)(e)).map(e=>{let n=(0,i.toValue)(e);return typeof n==`string`?n:(0,t.unrefElement)(n)}).filter(n.notNullish)),e=>{if(e.length)if(!o)o=(0,r.createFocusTrap)(e,{...c,onActivate(){l.value=!0,a.onActivate&&a.onActivate()},onDeactivate(){l.value=!1,a.onDeactivate&&a.onDeactivate()}}),s&&d();else{let t=o==null?void 0:o.active;o==null||o.updateContainerElements(e),!t&&s&&d()}},{flush:`post`}),(0,t.tryOnScopeDispose)(()=>f()),{hasFocus:l,isPaused:u,activate:d,deactivate:f,pause:()=>{o&&(o.pause(),u.value=!0)},unpause:()=>{o&&(o.unpause(),u.value=!1)}}}e.useFocusTrap=p})(this.VueUse=this.VueUse||{},VueUse,VueUse,focusTrap,Vue);

node_modules/@vueuse/integrations/dist/useFocusTrap.js

@@ -0,0 +1,3 @@
+import { t as useFocusTrap } from "./useFocusTrap-lXZ_YG-8.js";
+
+export { useFocusTrap };

node_modules/@vueuse/integrations/dist/useFocusTrap/component.d.ts

@@ -0,0 +1,21 @@
+import { n as UseFocusTrapReturn, t as UseFocusTrapOptions } from "../index-CJw_eFkJ.js";
+import * as vue4 from "vue";
+import { Reactive, SlotsType } from "vue";
+import { RenderableComponent } from "@vueuse/core";
+
+//#region useFocusTrap/component.d.ts
+interface UseFocusTrapProps extends RenderableComponent {
+  options?: UseFocusTrapOptions;
+}
+/**
+ * @deprecated
+ */
+interface ComponentUseFocusTrapOptions extends UseFocusTrapProps {}
+interface UseFocusTrapSlots {
+  default: (data: Reactive<UseFocusTrapReturn>) => any;
+}
+declare const UseFocusTrap: vue4.DefineSetupFnComponent<UseFocusTrapProps, Record<string, never>, SlotsType<UseFocusTrapSlots>, UseFocusTrapProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue4.PublicProps>;
+//#endregion
+export { ComponentUseFocusTrapOptions, UseFocusTrap, UseFocusTrapProps };

node_modules/@vueuse/integrations/dist/useFocusTrap/component.js

@@ -0,0 +1,17 @@
+import { t as useFocusTrap } from "../useFocusTrap-lXZ_YG-8.js";
+import { defineComponent, h, reactive, shallowRef } from "vue";
+
+//#region useFocusTrap/component.ts
+const UseFocusTrap = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	const target = shallowRef();
+	const data = reactive(useFocusTrap(target, props.options));
+	return () => {
+		if (slots.default) return h(props.as || "div", { ref: target }, slots.default(data));
+	};
+}, {
+	name: "UseFocusTrap",
+	props: ["as", "options"]
+});
+
+//#endregion
+export { UseFocusTrap };

node_modules/@vueuse/integrations/dist/useFuse-CWPfSDMU.js

@@ -0,0 +1,35 @@
+import { computed, ref, toValue, watch } from "vue";
+import Fuse from "fuse.js";
+
+//#region useFuse/index.ts
+function useFuse(search, data, options) {
+	const createFuse = () => {
+		var _toValue, _toValue2;
+		return new Fuse((_toValue = toValue(data)) !== null && _toValue !== void 0 ? _toValue : [], (_toValue2 = toValue(options)) === null || _toValue2 === void 0 ? void 0 : _toValue2.fuseOptions);
+	};
+	const fuse = ref(createFuse());
+	watch(() => {
+		var _toValue3;
+		return (_toValue3 = toValue(options)) === null || _toValue3 === void 0 ? void 0 : _toValue3.fuseOptions;
+	}, () => {
+		fuse.value = createFuse();
+	}, { deep: true });
+	watch(() => toValue(data), (newData) => {
+		fuse.value.setCollection(newData);
+	}, { deep: true });
+	return {
+		fuse,
+		results: computed(() => {
+			const resolved = toValue(options);
+			if ((resolved === null || resolved === void 0 ? void 0 : resolved.matchAllWhenSearchEmpty) && !toValue(search)) return toValue(data).map((item, index) => ({
+				item,
+				refIndex: index
+			}));
+			const limit = resolved === null || resolved === void 0 ? void 0 : resolved.resultLimit;
+			return fuse.value.search(toValue(search), limit ? { limit } : void 0);
+		})
+	};
+}
+
+//#endregion
+export { useFuse as t };

node_modules/@vueuse/integrations/dist/useFuse.d.ts

@@ -0,0 +1,2 @@
+import { i as useFuse, n as UseFuseOptions, r as UseFuseReturn, t as FuseOptions } from "./index-HJW_ZBEz.js";
+export { FuseOptions, UseFuseOptions, UseFuseReturn, useFuse };

node_modules/@vueuse/integrations/dist/useFuse.iife.js

@@ -0,0 +1,61 @@
+(function(exports, fuse_js, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+fuse_js = __toESM(fuse_js);
+vue = __toESM(vue);
+
+//#region useFuse/index.ts
+	function useFuse(search, data, options) {
+		const createFuse = () => {
+			var _toValue, _toValue2;
+			return new fuse_js.default((_toValue = (0, vue.toValue)(data)) !== null && _toValue !== void 0 ? _toValue : [], (_toValue2 = (0, vue.toValue)(options)) === null || _toValue2 === void 0 ? void 0 : _toValue2.fuseOptions);
+		};
+		const fuse = (0, vue.ref)(createFuse());
+		(0, vue.watch)(() => {
+			var _toValue3;
+			return (_toValue3 = (0, vue.toValue)(options)) === null || _toValue3 === void 0 ? void 0 : _toValue3.fuseOptions;
+		}, () => {
+			fuse.value = createFuse();
+		}, { deep: true });
+		(0, vue.watch)(() => (0, vue.toValue)(data), (newData) => {
+			fuse.value.setCollection(newData);
+		}, { deep: true });
+		return {
+			fuse,
+			results: (0, vue.computed)(() => {
+				const resolved = (0, vue.toValue)(options);
+				if ((resolved === null || resolved === void 0 ? void 0 : resolved.matchAllWhenSearchEmpty) && !(0, vue.toValue)(search)) return (0, vue.toValue)(data).map((item, index) => ({
+					item,
+					refIndex: index
+				}));
+				const limit = resolved === null || resolved === void 0 ? void 0 : resolved.resultLimit;
+				return fuse.value.search((0, vue.toValue)(search), limit ? { limit } : void 0);
+			})
+		};
+	}
+
+//#endregion
+exports.useFuse = useFuse;
+})(this.VueUse = this.VueUse || {}, Fuse, Vue);

node_modules/@vueuse/integrations/dist/useFuse.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n){var r=Object.create,i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.getPrototypeOf,c=Object.prototype.hasOwnProperty,l=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var s=o(t),l=0,u=s.length,d;l<u;l++)d=s[l],!c.call(e,d)&&d!==n&&i(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=a(t,d))||r.enumerable});return e},u=(e,t,n)=>(n=e==null?{}:r(s(e)),l(t||!e||!e.__esModule?i(n,`default`,{value:e,enumerable:!0}):n,e));t=u(t),n=u(n);function d(e,r,i){let a=()=>{var e,a;return new t.default((e=(0,n.toValue)(r))==null?[]:e,(a=(0,n.toValue)(i))==null?void 0:a.fuseOptions)},o=(0,n.ref)(a());return(0,n.watch)(()=>{var e;return(e=(0,n.toValue)(i))==null?void 0:e.fuseOptions},()=>{o.value=a()},{deep:!0}),(0,n.watch)(()=>(0,n.toValue)(r),e=>{o.value.setCollection(e)},{deep:!0}),{fuse:o,results:(0,n.computed)(()=>{let t=(0,n.toValue)(i);if(t!=null&&t.matchAllWhenSearchEmpty&&!(0,n.toValue)(e))return(0,n.toValue)(r).map((e,t)=>({item:e,refIndex:t}));let a=t==null?void 0:t.resultLimit;return o.value.search((0,n.toValue)(e),a?{limit:a}:void 0)})}}e.useFuse=d})(this.VueUse=this.VueUse||{},Fuse,Vue);

node_modules/@vueuse/integrations/dist/useFuse.js

@@ -0,0 +1,3 @@
+import { t as useFuse } from "./useFuse-CWPfSDMU.js";
+
+export { useFuse };

node_modules/@vueuse/integrations/dist/useIDBKeyval-D_wVPeQ7.js

@@ -0,0 +1,64 @@
+import { ref, shallowRef, toRaw, toValue } from "vue";
+import { watchPausable } from "@vueuse/core";
+import { del, get, set, update } from "idb-keyval";
+
+//#region useIDBKeyval/index.ts
+/**
+*
+* @param key
+* @param initialValue
+* @param options
+*/
+function useIDBKeyval(key, initialValue, options = {}) {
+	const { flush = "pre", deep = true, shallow = false, onError = (e) => {
+		console.error(e);
+	}, writeDefaults = true, serializer = {
+		read: (raw) => raw,
+		write: (value) => value
+	} } = options;
+	const isFinished = shallowRef(false);
+	const data = (shallow ? shallowRef : ref)(initialValue);
+	const rawInit = toValue(initialValue);
+	async function read() {
+		try {
+			const rawValue = await get(key);
+			if (rawValue === void 0) {
+				if (rawInit !== void 0 && rawInit !== null && writeDefaults) await set(key, serializer.write(rawInit));
+			} else data.value = serializer.read(rawValue);
+		} catch (e) {
+			onError(e);
+		}
+		isFinished.value = true;
+	}
+	read();
+	async function write() {
+		try {
+			if (data.value == null) await del(key);
+			else {
+				const rawValue = toRaw(data.value);
+				const serializedValue = serializer.write(rawValue);
+				await update(key, () => serializedValue);
+			}
+		} catch (e) {
+			onError(e);
+		}
+	}
+	const { pause: pauseWatch, resume: resumeWatch } = watchPausable(data, () => write(), {
+		flush,
+		deep
+	});
+	async function setData(value) {
+		pauseWatch();
+		data.value = value;
+		await write();
+		resumeWatch();
+	}
+	return {
+		set: setData,
+		isFinished,
+		data
+	};
+}
+
+//#endregion
+export { useIDBKeyval as t };

node_modules/@vueuse/integrations/dist/useIDBKeyval.d.ts

@@ -0,0 +1,2 @@
+import { n as UseIDBOptions, r as useIDBKeyval, t as UseIDBKeyvalReturn } from "./index-DfI2VwxT.js";
+export { UseIDBKeyvalReturn, UseIDBOptions, useIDBKeyval };

node_modules/@vueuse/integrations/dist/useIDBKeyval.iife.js

@@ -0,0 +1,90 @@
+(function(exports, __vueuse_core, idb_keyval, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_core = __toESM(__vueuse_core);
+idb_keyval = __toESM(idb_keyval);
+vue = __toESM(vue);
+
+//#region useIDBKeyval/index.ts
+/**
+	*
+	* @param key
+	* @param initialValue
+	* @param options
+	*/
+	function useIDBKeyval(key, initialValue, options = {}) {
+		const { flush = "pre", deep = true, shallow = false, onError = (e) => {
+			console.error(e);
+		}, writeDefaults = true, serializer = {
+			read: (raw) => raw,
+			write: (value) => value
+		} } = options;
+		const isFinished = (0, vue.shallowRef)(false);
+		const data = (shallow ? vue.shallowRef : vue.ref)(initialValue);
+		const rawInit = (0, vue.toValue)(initialValue);
+		async function read() {
+			try {
+				const rawValue = await (0, idb_keyval.get)(key);
+				if (rawValue === void 0) {
+					if (rawInit !== void 0 && rawInit !== null && writeDefaults) await (0, idb_keyval.set)(key, serializer.write(rawInit));
+				} else data.value = serializer.read(rawValue);
+			} catch (e) {
+				onError(e);
+			}
+			isFinished.value = true;
+		}
+		read();
+		async function write() {
+			try {
+				if (data.value == null) await (0, idb_keyval.del)(key);
+				else {
+					const rawValue = (0, vue.toRaw)(data.value);
+					const serializedValue = serializer.write(rawValue);
+					await (0, idb_keyval.update)(key, () => serializedValue);
+				}
+			} catch (e) {
+				onError(e);
+			}
+		}
+		const { pause: pauseWatch, resume: resumeWatch } = (0, __vueuse_core.watchPausable)(data, () => write(), {
+			flush,
+			deep
+		});
+		async function setData(value) {
+			pauseWatch();
+			data.value = value;
+			await write();
+			resumeWatch();
+		}
+		return {
+			set: setData,
+			isFinished,
+			data
+		};
+	}
+
+//#endregion
+exports.useIDBKeyval = useIDBKeyval;
+})(this.VueUse = this.VueUse || {}, VueUse, idbKeyval, Vue);

node_modules/@vueuse/integrations/dist/useIDBKeyval.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);function f(e,i,a={}){let{flush:o=`pre`,deep:s=!0,shallow:c=!1,onError:l=e=>{console.error(e)},writeDefaults:u=!0,serializer:d={read:e=>e,write:e=>e}}=a,f=(0,r.shallowRef)(!1),p=(c?r.shallowRef:r.ref)(i),m=(0,r.toValue)(i);async function h(){try{let t=await(0,n.get)(e);t===void 0?m!=null&&u&&await(0,n.set)(e,d.write(m)):p.value=d.read(t)}catch(e){l(e)}f.value=!0}h();async function g(){try{if(p.value==null)await(0,n.del)(e);else{let t=(0,r.toRaw)(p.value),i=d.write(t);await(0,n.update)(e,()=>i)}}catch(e){l(e)}}let{pause:_,resume:v}=(0,t.watchPausable)(p,()=>g(),{flush:o,deep:s});async function y(e){_(),p.value=e,await g(),v()}return{set:y,isFinished:f,data:p}}e.useIDBKeyval=f})(this.VueUse=this.VueUse||{},VueUse,idbKeyval,Vue);

node_modules/@vueuse/integrations/dist/useIDBKeyval.js

@@ -0,0 +1,3 @@
+import { t as useIDBKeyval } from "./useIDBKeyval-D_wVPeQ7.js";
+
+export { useIDBKeyval };

node_modules/@vueuse/integrations/dist/useJwt-BB8OIN1z.js

@@ -0,0 +1,27 @@
+import { computed, toValue } from "vue";
+import { jwtDecode } from "jwt-decode";
+
+//#region useJwt/index.ts
+/**
+* Reactive decoded jwt token.
+*
+* @see https://vueuse.org/useJwt
+*/
+function useJwt(encodedJwt, options = {}) {
+	const { onError, fallbackValue = null } = options;
+	const decodeWithFallback = (encodedJwt$1, options$1) => {
+		try {
+			return jwtDecode(encodedJwt$1, options$1);
+		} catch (err) {
+			onError === null || onError === void 0 || onError(err);
+			return fallbackValue;
+		}
+	};
+	return {
+		header: computed(() => decodeWithFallback(toValue(encodedJwt), { header: true })),
+		payload: computed(() => decodeWithFallback(toValue(encodedJwt)))
+	};
+}
+
+//#endregion
+export { useJwt as t };

node_modules/@vueuse/integrations/dist/useJwt.d.ts

@@ -0,0 +1,2 @@
+import { n as UseJwtReturn, r as useJwt, t as UseJwtOptions } from "./index-is9DY6jN.js";
+export { UseJwtOptions, UseJwtReturn, useJwt };

node_modules/@vueuse/integrations/dist/useJwt.iife.js

@@ -0,0 +1,53 @@
+(function(exports, jwt_decode, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+jwt_decode = __toESM(jwt_decode);
+vue = __toESM(vue);
+
+//#region useJwt/index.ts
+/**
+	* Reactive decoded jwt token.
+	*
+	* @see https://vueuse.org/useJwt
+	*/
+	function useJwt(encodedJwt, options = {}) {
+		const { onError, fallbackValue = null } = options;
+		const decodeWithFallback = (encodedJwt$1, options$1) => {
+			try {
+				return (0, jwt_decode.jwtDecode)(encodedJwt$1, options$1);
+			} catch (err) {
+				onError === null || onError === void 0 || onError(err);
+				return fallbackValue;
+			}
+		};
+		return {
+			header: (0, vue.computed)(() => decodeWithFallback((0, vue.toValue)(encodedJwt), { header: true })),
+			payload: (0, vue.computed)(() => decodeWithFallback((0, vue.toValue)(encodedJwt)))
+		};
+	}
+
+//#endregion
+exports.useJwt = useJwt;
+})(this.VueUse = this.VueUse || {}, jwt_decode, Vue);

node_modules/@vueuse/integrations/dist/useJwt.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n){var r=Object.create,i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.getPrototypeOf,c=Object.prototype.hasOwnProperty,l=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var s=o(t),l=0,u=s.length,d;l<u;l++)d=s[l],!c.call(e,d)&&d!==n&&i(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=a(t,d))||r.enumerable});return e},u=(e,t,n)=>(n=e==null?{}:r(s(e)),l(t||!e||!e.__esModule?i(n,`default`,{value:e,enumerable:!0}):n,e));t=u(t),n=u(n);function d(e,r={}){let{onError:i,fallbackValue:a=null}=r,o=(e,n)=>{try{return(0,t.jwtDecode)(e,n)}catch(e){return i==null||i(e),a}};return{header:(0,n.computed)(()=>o((0,n.toValue)(e),{header:!0})),payload:(0,n.computed)(()=>o((0,n.toValue)(e)))}}e.useJwt=d})(this.VueUse=this.VueUse||{},jwt_decode,Vue);

node_modules/@vueuse/integrations/dist/useJwt.js

@@ -0,0 +1,3 @@
+import { t as useJwt } from "./useJwt-BB8OIN1z.js";
+
+export { useJwt };

node_modules/@vueuse/integrations/dist/useNProgress-ClU-n87O.js

@@ -0,0 +1,40 @@
+import { isClient, toRef, tryOnScopeDispose } from "@vueuse/shared";
+import { computed, watchEffect } from "vue";
+import nprogress from "nprogress";
+
+//#region useNProgress/index.ts
+/**
+* Reactive progress bar.
+*
+* @see https://vueuse.org/useNProgress
+*/
+function useNProgress(currentProgress = null, options) {
+	const progress = toRef(currentProgress);
+	const isLoading = computed({
+		set: (load) => load ? nprogress.start() : nprogress.done(),
+		get: () => typeof progress.value === "number" && progress.value < 1
+	});
+	if (options) nprogress.configure(options);
+	const setProgress = nprogress.set;
+	nprogress.set = (n) => {
+		progress.value = n;
+		return setProgress.call(nprogress, n);
+	};
+	watchEffect(() => {
+		if (typeof progress.value === "number" && isClient) setProgress.call(nprogress, progress.value);
+	});
+	tryOnScopeDispose(nprogress.remove);
+	return {
+		isLoading,
+		progress,
+		start: nprogress.start,
+		done: nprogress.done,
+		remove: () => {
+			progress.value = null;
+			nprogress.remove();
+		}
+	};
+}
+
+//#endregion
+export { useNProgress as t };

node_modules/@vueuse/integrations/dist/useNProgress.d.ts

@@ -0,0 +1,2 @@
+import { n as UseNProgressReturn, r as useNProgress, t as UseNProgressOptions } from "./index-BLffOygZ.js";
+export { UseNProgressOptions, UseNProgressReturn, useNProgress };

node_modules/@vueuse/integrations/dist/useNProgress.iife.js

@@ -0,0 +1,66 @@
+(function(exports, __vueuse_shared, nprogress, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+nprogress = __toESM(nprogress);
+vue = __toESM(vue);
+
+//#region useNProgress/index.ts
+/**
+	* Reactive progress bar.
+	*
+	* @see https://vueuse.org/useNProgress
+	*/
+	function useNProgress(currentProgress = null, options) {
+		const progress = (0, __vueuse_shared.toRef)(currentProgress);
+		const isLoading = (0, vue.computed)({
+			set: (load) => load ? nprogress.default.start() : nprogress.default.done(),
+			get: () => typeof progress.value === "number" && progress.value < 1
+		});
+		if (options) nprogress.default.configure(options);
+		const setProgress = nprogress.default.set;
+		nprogress.default.set = (n) => {
+			progress.value = n;
+			return setProgress.call(nprogress.default, n);
+		};
+		(0, vue.watchEffect)(() => {
+			if (typeof progress.value === "number" && __vueuse_shared.isClient) setProgress.call(nprogress.default, progress.value);
+		});
+		(0, __vueuse_shared.tryOnScopeDispose)(nprogress.default.remove);
+		return {
+			isLoading,
+			progress,
+			start: nprogress.default.start,
+			done: nprogress.default.done,
+			remove: () => {
+				progress.value = null;
+				nprogress.default.remove();
+			}
+		};
+	}
+
+//#endregion
+exports.useNProgress = useNProgress;
+})(this.VueUse = this.VueUse || {}, VueUse, nprogress, Vue);

node_modules/@vueuse/integrations/dist/useNProgress.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);function f(e=null,i){let a=(0,t.toRef)(e),o=(0,r.computed)({set:e=>e?n.default.start():n.default.done(),get:()=>typeof a.value==`number`&&a.value<1});i&&n.default.configure(i);let s=n.default.set;return n.default.set=e=>(a.value=e,s.call(n.default,e)),(0,r.watchEffect)(()=>{typeof a.value==`number`&&t.isClient&&s.call(n.default,a.value)}),(0,t.tryOnScopeDispose)(n.default.remove),{isLoading:o,progress:a,start:n.default.start,done:n.default.done,remove:()=>{a.value=null,n.default.remove()}}}e.useNProgress=f})(this.VueUse=this.VueUse||{},VueUse,nprogress,Vue);

node_modules/@vueuse/integrations/dist/useNProgress.js

@@ -0,0 +1,3 @@
+import { t as useNProgress } from "./useNProgress-ClU-n87O.js";
+
+export { useNProgress };

node_modules/@vueuse/integrations/dist/useQRCode-DtYpMi-Z.js

@@ -0,0 +1,23 @@
+import { isClient, toRef } from "@vueuse/shared";
+import { shallowRef, watch } from "vue";
+import QRCode from "qrcode";
+
+//#region useQRCode/index.ts
+/**
+* Wrapper for qrcode.
+*
+* @see https://vueuse.org/useQRCode
+* @param text
+* @param options
+*/
+function useQRCode(text, options) {
+	const src = toRef(text);
+	const result = shallowRef("");
+	watch(src, async (value) => {
+		if (src.value && isClient) result.value = await QRCode.toDataURL(value, options);
+	}, { immediate: true });
+	return result;
+}
+
+//#endregion
+export { useQRCode as t };

node_modules/@vueuse/integrations/dist/useQRCode.d.ts

@@ -0,0 +1,2 @@
+import { t as useQRCode } from "./index-oNla9-Bg.js";
+export { useQRCode };

node_modules/@vueuse/integrations/dist/useQRCode.iife.js

@@ -0,0 +1,49 @@
+(function(exports, __vueuse_shared, qrcode, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_shared = __toESM(__vueuse_shared);
+qrcode = __toESM(qrcode);
+vue = __toESM(vue);
+
+//#region useQRCode/index.ts
+/**
+	* Wrapper for qrcode.
+	*
+	* @see https://vueuse.org/useQRCode
+	* @param text
+	* @param options
+	*/
+	function useQRCode(text, options) {
+		const src = (0, __vueuse_shared.toRef)(text);
+		const result = (0, vue.shallowRef)("");
+		(0, vue.watch)(src, async (value) => {
+			if (src.value && __vueuse_shared.isClient) result.value = await qrcode.default.toDataURL(value, options);
+		}, { immediate: true });
+		return result;
+	}
+
+//#endregion
+exports.useQRCode = useQRCode;
+})(this.VueUse = this.VueUse || {}, VueUse, QRCode, Vue);

node_modules/@vueuse/integrations/dist/useQRCode.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);function f(e,i){let a=(0,t.toRef)(e),o=(0,r.shallowRef)(``);return(0,r.watch)(a,async e=>{a.value&&t.isClient&&(o.value=await n.default.toDataURL(e,i))},{immediate:!0}),o}e.useQRCode=f})(this.VueUse=this.VueUse||{},VueUse,QRCode,Vue);

node_modules/@vueuse/integrations/dist/useQRCode.js

@@ -0,0 +1,3 @@
+import { t as useQRCode } from "./useQRCode-DtYpMi-Z.js";
+
+export { useQRCode };

node_modules/@vueuse/integrations/dist/useSortable-jtnNPDb0.js

@@ -0,0 +1,78 @@
+import { isRef, nextTick, toValue } from "vue";
+import { defaultDocument, tryOnMounted, tryOnScopeDispose, unrefElement } from "@vueuse/core";
+import Sortable from "sortablejs";
+
+//#region useSortable/index.ts
+/**
+* Wrapper for sortablejs.
+* @param el
+* @param list
+* @param options
+*/
+function useSortable(el, list, options = {}) {
+	let sortable;
+	const { document = defaultDocument,...resetOptions } = options;
+	const defaultOptions = { onUpdate: (e) => {
+		moveArrayElement(list, e.oldIndex, e.newIndex, e);
+	} };
+	const start = () => {
+		const target = typeof el === "string" ? document === null || document === void 0 ? void 0 : document.querySelector(el) : unrefElement(el);
+		if (!target || sortable !== void 0) return;
+		sortable = new Sortable(target, {
+			...defaultOptions,
+			...resetOptions
+		});
+	};
+	const stop = () => {
+		sortable === null || sortable === void 0 || sortable.destroy();
+		sortable = void 0;
+	};
+	const option = (name, value) => {
+		if (value !== void 0) sortable === null || sortable === void 0 || sortable.option(name, value);
+		else return sortable === null || sortable === void 0 ? void 0 : sortable.option(name);
+	};
+	tryOnMounted(start);
+	tryOnScopeDispose(stop);
+	return {
+		stop,
+		start,
+		option
+	};
+}
+/**
+* Inserts a element into the DOM at a given index.
+* @param parentElement
+* @param element
+* @param {number} index
+* @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L81C1-L94C2
+*/
+function insertNodeAt(parentElement, element, index) {
+	const refElement = parentElement.children[index];
+	parentElement.insertBefore(element, refElement);
+}
+/**
+* Removes a node from the DOM.
+* @param {Node} node
+* @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L96C1-L102C2
+*/
+function removeNode(node) {
+	if (node.parentNode) node.parentNode.removeChild(node);
+}
+function moveArrayElement(list, from, to, e = null) {
+	if (e != null) {
+		removeNode(e.item);
+		insertNodeAt(e.from, e.item, from);
+	}
+	const _valueIsRef = isRef(list);
+	const array = _valueIsRef ? [...toValue(list)] : toValue(list);
+	if (to >= 0 && to < array.length) {
+		const element = array.splice(from, 1)[0];
+		nextTick(() => {
+			array.splice(to, 0, element);
+			if (_valueIsRef) list.value = array;
+		});
+	}
+}
+
+//#endregion
+export { useSortable as i, moveArrayElement as n, removeNode as r, insertNodeAt as t };

node_modules/@vueuse/integrations/dist/useSortable.d.ts

@@ -0,0 +1,2 @@
+import { a as removeNode, i as moveArrayElement, n as UseSortableReturn, o as useSortable, r as insertNodeAt, t as UseSortableOptions } from "./index-CDFJRy7j.js";
+export { UseSortableOptions, UseSortableReturn, insertNodeAt, moveArrayElement, removeNode, useSortable };

node_modules/@vueuse/integrations/dist/useSortable.iife.js

@@ -0,0 +1,107 @@
+(function(exports, __vueuse_core, sortablejs, vue) {
+
+//#region rolldown:runtime
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+
+//#endregion
+__vueuse_core = __toESM(__vueuse_core);
+sortablejs = __toESM(sortablejs);
+vue = __toESM(vue);
+
+//#region useSortable/index.ts
+/**
+	* Wrapper for sortablejs.
+	* @param el
+	* @param list
+	* @param options
+	*/
+	function useSortable(el, list, options = {}) {
+		let sortable;
+		const { document = __vueuse_core.defaultDocument,...resetOptions } = options;
+		const defaultOptions = { onUpdate: (e) => {
+			moveArrayElement(list, e.oldIndex, e.newIndex, e);
+		} };
+		const start = () => {
+			const target = typeof el === "string" ? document === null || document === void 0 ? void 0 : document.querySelector(el) : (0, __vueuse_core.unrefElement)(el);
+			if (!target || sortable !== void 0) return;
+			sortable = new sortablejs.default(target, {
+				...defaultOptions,
+				...resetOptions
+			});
+		};
+		const stop = () => {
+			sortable === null || sortable === void 0 || sortable.destroy();
+			sortable = void 0;
+		};
+		const option = (name, value) => {
+			if (value !== void 0) sortable === null || sortable === void 0 || sortable.option(name, value);
+			else return sortable === null || sortable === void 0 ? void 0 : sortable.option(name);
+		};
+		(0, __vueuse_core.tryOnMounted)(start);
+		(0, __vueuse_core.tryOnScopeDispose)(stop);
+		return {
+			stop,
+			start,
+			option
+		};
+	}
+	/**
+	* Inserts a element into the DOM at a given index.
+	* @param parentElement
+	* @param element
+	* @param {number} index
+	* @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L81C1-L94C2
+	*/
+	function insertNodeAt(parentElement, element, index) {
+		const refElement = parentElement.children[index];
+		parentElement.insertBefore(element, refElement);
+	}
+	/**
+	* Removes a node from the DOM.
+	* @param {Node} node
+	* @see https://github.com/Alfred-Skyblue/vue-draggable-plus/blob/a3829222095e1949bf2c9a20979d7b5930e66f14/src/utils/index.ts#L96C1-L102C2
+	*/
+	function removeNode(node) {
+		if (node.parentNode) node.parentNode.removeChild(node);
+	}
+	function moveArrayElement(list, from, to, e = null) {
+		if (e != null) {
+			removeNode(e.item);
+			insertNodeAt(e.from, e.item, from);
+		}
+		const _valueIsRef = (0, vue.isRef)(list);
+		const array = _valueIsRef ? [...(0, vue.toValue)(list)] : (0, vue.toValue)(list);
+		if (to >= 0 && to < array.length) {
+			const element = array.splice(from, 1)[0];
+			(0, vue.nextTick)(() => {
+				array.splice(to, 0, element);
+				if (_valueIsRef) list.value = array;
+			});
+		}
+	}
+
+//#endregion
+exports.insertNodeAt = insertNodeAt;
+exports.moveArrayElement = moveArrayElement;
+exports.removeNode = removeNode;
+exports.useSortable = useSortable;
+})(this.VueUse = this.VueUse || {}, VueUse, Sortable, Vue);

node_modules/@vueuse/integrations/dist/useSortable.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e},d=(e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule?a(n,`default`,{value:e,enumerable:!0}):n,e));t=d(t),n=d(n),r=d(r);function f(e,r,i={}){let a,{document:o=t.defaultDocument,...s}=i,c={onUpdate:e=>{h(r,e.oldIndex,e.newIndex,e)}},l=()=>{let r=typeof e==`string`?o==null?void 0:o.querySelector(e):(0,t.unrefElement)(e);!r||a!==void 0||(a=new n.default(r,{...c,...s}))},u=()=>{a==null||a.destroy(),a=void 0};return(0,t.tryOnMounted)(l),(0,t.tryOnScopeDispose)(u),{stop:u,start:l,option:(e,t)=>{if(t!==void 0)a==null||a.option(e,t);else return a==null?void 0:a.option(e)}}}function p(e,t,n){let r=e.children[n];e.insertBefore(t,r)}function m(e){e.parentNode&&e.parentNode.removeChild(e)}function h(e,t,n,i=null){i!=null&&(m(i.item),p(i.from,i.item,t));let a=(0,r.isRef)(e),o=a?[...(0,r.toValue)(e)]:(0,r.toValue)(e);if(n>=0&&n<o.length){let i=o.splice(t,1)[0];(0,r.nextTick)(()=>{o.splice(n,0,i),a&&(e.value=o)})}}e.insertNodeAt=p,e.moveArrayElement=h,e.removeNode=m,e.useSortable=f})(this.VueUse=this.VueUse||{},VueUse,Sortable,Vue);

node_modules/@vueuse/integrations/dist/useSortable.js

@@ -0,0 +1,3 @@
+import { i as useSortable, n as moveArrayElement, r as removeNode, t as insertNodeAt } from "./useSortable-jtnNPDb0.js";
+
+export { insertNodeAt, moveArrayElement, removeNode, useSortable };

node_modules/@vueuse/integrations/dist/useSortable/component.d.ts

@@ -0,0 +1,18 @@
+import { n as UseSortableReturn, t as UseSortableOptions } from "../index-CDFJRy7j.js";
+import * as vue7 from "vue";
+import { Reactive, SlotsType } from "vue";
+import { RenderableComponent } from "@vueuse/core";
+
+//#region useSortable/component.d.ts
+interface UseSortableProps extends RenderableComponent {
+  modelValue: any[];
+  options?: UseSortableOptions;
+}
+interface UseSortableSlots {
+  default: (data: Reactive<UseSortableReturn>) => any;
+}
+declare const UseSortable: vue7.DefineSetupFnComponent<UseSortableProps, Record<string, never>, SlotsType<UseSortableSlots>, UseSortableProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: unknown[]) => any) | undefined;
+}, vue7.PublicProps>;
+//#endregion
+export { UseSortable, UseSortableProps };

node_modules/@vueuse/integrations/dist/useSortable/component.js

@@ -0,0 +1,23 @@
+import { i as useSortable } from "../useSortable-jtnNPDb0.js";
+import { defineComponent, h, reactive, shallowRef } from "vue";
+import { useVModel } from "@vueuse/core";
+
+//#region useSortable/component.ts
+const UseSortable = /* @__PURE__ */ defineComponent((props, { slots }) => {
+	const list = useVModel(props, "modelValue");
+	const target = shallowRef();
+	const data = reactive(useSortable(target, list, props.options));
+	return () => {
+		if (slots.default) return h(props.as || "div", { ref: target }, slots.default(data));
+	};
+}, {
+	name: "UseSortable",
+	props: [
+		"as",
+		"modelValue",
+		"options"
+	]
+});
+
+//#endregion
+export { UseSortable };