@vueuse/integrations 6.3.3 → 6.6.1

package/index.cjs

@@ -6,7 +6,10 @@ var vueDemi = require('vue-demi');
 var axios = require('axios');
 var shared = require('@vueuse/shared');
 var Cookie = require('universal-cookie');
+var drauu = require('drauu');
+var core = require('@vueuse/core');
 var focusTrap = require('focus-trap');
+var Fuse = require('fuse.js');
 var jwt_decode = require('jwt-decode');
 var nprogress = require('nprogress');
 var QRCode = require('qrcode');
@@ -15,341 +18,436 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var Cookie__default = /*#__PURE__*/_interopDefaultLegacy(Cookie);
+var Fuse__default = /*#__PURE__*/_interopDefaultLegacy(Fuse);
 var jwt_decode__default = /*#__PURE__*/_interopDefaultLegacy(jwt_decode);
 var nprogress__default = /*#__PURE__*/_interopDefaultLegacy(nprogress);
 var QRCode__default = /*#__PURE__*/_interopDefaultLegacy(QRCode);
 
-/**
- * Wrapper for axios.
- *
- * @see https://vueuse.org/useAxios
- * @param url
- * @param config
- */
-function useAxios(url, ...args) {
-    let config = {};
-    let instance = axios__default['default'];
-    if (args.length > 0) {
-        /**
-         * Unable to use `instanceof` here becuase of (https://github.com/axios/axios/issues/737)
-         * so instead we are checking if there is a `requset` on the object to see if it is an
-         * axios instance
-         */
-        if ('request' in args[0])
-            instance = args[0];
-        else
-            config = args[0];
-    }
-    if (args.length > 1) {
-        if ('request' in args[1])
-            instance = args[1];
-    }
-    const response = vueDemi.shallowRef();
-    const data = vueDemi.shallowRef();
-    const isFinished = vueDemi.ref(false);
-    const isLoading = vueDemi.ref(true);
-    const aborted = vueDemi.ref(false);
-    const error = vueDemi.shallowRef();
-    const cancelToken = axios__default['default'].CancelToken.source();
-    const abort = (message) => {
-        if (isFinished.value || !isLoading.value)
-            return;
-        cancelToken.cancel(message);
-        aborted.value = true;
-        isLoading.value = false;
-        isFinished.value = false;
-    };
-    instance(url, Object.assign(Object.assign({}, config), { cancelToken: cancelToken.token }))
-        .then((r) => {
-        response.value = r;
-        data.value = r.data;
-    })
-        .catch((e) => {
-        error.value = e;
-    })
-        .finally(() => {
-        isLoading.value = false;
-        isFinished.value = true;
-    });
-    return {
-        response,
-        data,
-        error,
-        finished: isFinished,
-        loading: isLoading,
-        isFinished,
-        isLoading,
-        cancel: abort,
-        canceled: aborted,
-        aborted,
-        abort,
-    };
+var __defProp$3 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+function useAxios(url, ...args) {
+  let config = {};
+  let instance = axios__default["default"];
+  if (args.length > 0) {
+    if ("request" in args[0])
+      instance = args[0];
+    else
+      config = args[0];
+  }
+  if (args.length > 1) {
+    if ("request" in args[1])
+      instance = args[1];
+  }
+  const response = vueDemi.shallowRef();
+  const data = vueDemi.shallowRef();
+  const isFinished = vueDemi.ref(false);
+  const isLoading = vueDemi.ref(true);
+  const aborted = vueDemi.ref(false);
+  const error = vueDemi.shallowRef();
+  const cancelToken = axios__default["default"].CancelToken.source();
+  const abort = (message) => {
+    if (isFinished.value || !isLoading.value)
+      return;
+    cancelToken.cancel(message);
+    aborted.value = true;
+    isLoading.value = false;
+    isFinished.value = false;
+  };
+  instance(url, __spreadProps$1(__spreadValues$3({}, config), { cancelToken: cancelToken.token })).then((r) => {
+    response.value = r;
+    data.value = r.data;
+  }).catch((e) => {
+    error.value = e;
+  }).finally(() => {
+    isLoading.value = false;
+    isFinished.value = true;
+  });
+  return {
+    response,
+    data,
+    error,
+    finished: isFinished,
+    loading: isLoading,
+    isFinished,
+    isLoading,
+    cancel: abort,
+    canceled: aborted,
+    aborted,
+    abort
+  };
 }
 
-/**
- * Creates a new {@link useCookies} function
- * @param {Object} 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__default['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 {string[]|null|undefined} dependencies - array of watching cookie's names. Pass empty array if don't want to watch cookies changes.
- * @param {Object} options
- * @param {boolean} options.doNotParse - don't try parse value as JSON
- * @param {boolean} options.autoUpdateDependencies - automatically update watching dependencies
- * @param {Object} cookies - universal-cookie instance
- */
-function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new Cookie__default['default']()) {
-    const watchingDependencies = autoUpdateDependencies ? [...dependencies || []] : dependencies;
-    let previousCookies = cookies.getAll({ doNotParse: true });
-    /**
-     * Adds reactivity to get/getAll methods
-     */
-    const touches = vueDemi.ref(0);
-    const onChange = () => {
-        const newCookies = cookies.getAll({ doNotParse: true });
-        if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies))
-            touches.value++;
-        previousCookies = newCookies;
-    };
-    cookies.addChangeListener(onChange);
-    shared.tryOnScopeDispose(() => {
-        cookies.removeChangeListener(onChange);
-    });
-    return {
-        /**
-         * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
-         */
-        get: (...args) => {
-            /**
-             * Auto update watching dependencies if needed
-             */
-            if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0]))
-                watchingDependencies.push(args[0]);
-            // eslint-disable-next-line no-unused-expressions
-            touches.value; // adds reactivity to method
-            return cookies.get(args[0], Object.assign({ doNotParse }, args[1]));
-        },
-        /**
-         * Reactive get all cookies
-         */
-        getAll: (...args) => {
-            // eslint-disable-next-line no-unused-expressions
-            touches.value; // adds reactivity to method
-            return cookies.getAll(Object.assign({ 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;
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+function createCookies(req) {
+  const universalCookie = new Cookie__default["default"](req ? req.headers.cookie : null);
+  return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, { doNotParse, autoUpdateDependencies }, universalCookie);
 }
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
+function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new Cookie__default["default"]()) {
+  const watchingDependencies = autoUpdateDependencies ? [...dependencies || []] : dependencies;
+  let previousCookies = cookies.getAll({ doNotParse: true });
+  const touches = vueDemi.ref(0);
+  const onChange = () => {
+    const newCookies = cookies.getAll({ doNotParse: true });
+    if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies))
+      touches.value++;
+    previousCookies = newCookies;
+  };
+  cookies.addChangeListener(onChange);
+  shared.tryOnScopeDispose(() => {
+    cookies.removeChangeListener(onChange);
+  });
+  return {
+    get: (...args) => {
+      if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0]))
+        watchingDependencies.push(args[0]);
+      touches.value;
+      return cookies.get(args[0], __spreadValues$2({ doNotParse }, args[1]));
+    },
+    getAll: (...args) => {
+      touches.value;
+      return cookies.getAll(__spreadValues$2({ 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;
 }
 
-/**
- * Get the dom element of a ref of element or Vue component instance
- *
- * @param elRef
- */
-function unrefElement(elRef) {
-    var _a, _b;
-    const plain = vueDemi.unref(elRef);
-    return (_b = (_a = plain) === null || _a === void 0 ? void 0 : _a.$el) !== null && _b !== void 0 ? _b : plain;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+function useDrauu(target, options) {
+  const drauuInstance = vueDemi.ref();
+  let disposables = [];
+  const onChangedHook = core.createEventHook();
+  const onCanceledHook = core.createEventHook();
+  const onCommittedHook = core.createEventHook();
+  const onStartHook = core.createEventHook();
+  const onEndHook = core.createEventHook();
+  const canUndo = vueDemi.ref(false);
+  const canRedo = vueDemi.ref(false);
+  const altPressed = vueDemi.ref(false);
+  const shiftPressed = vueDemi.ref(false);
+  const brush = vueDemi.ref({
+    color: "black",
+    size: 3,
+    arrowEnd: false,
+    cornerRadius: 0,
+    dasharray: void 0,
+    fill: "transparent",
+    mode: "draw"
+  });
+  vueDemi.watch(brush, () => {
+    const instance = drauuInstance.value;
+    if (instance)
+      instance.brush = brush.value;
+  }, { deep: true });
+  const undo = () => {
+    var _a;
+    return (_a = drauuInstance.value) == null ? void 0 : _a.undo();
+  };
+  const redo = () => {
+    var _a;
+    return (_a = drauuInstance.value) == null ? void 0 : _a.redo();
+  };
+  const clear = () => {
+    var _a;
+    return (_a = drauuInstance.value) == null ? void 0 : _a.clear();
+  };
+  const cancel = () => {
+    var _a;
+    return (_a = drauuInstance.value) == null ? void 0 : _a.cancel();
+  };
+  const load = (svg) => {
+    var _a;
+    return (_a = drauuInstance.value) == null ? void 0 : _a.load(svg);
+  };
+  const dump = () => {
+    var _a;
+    return (_a = drauuInstance.value) == null ? void 0 : _a.dump();
+  };
+  const cleanup = () => {
+    var _a;
+    disposables.forEach((dispose) => dispose());
+    (_a = drauuInstance.value) == null ? void 0 : _a.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;
+    }
+  };
+  vueDemi.watch(() => core.unrefElement(target), (el) => {
+    if (!el || !(el instanceof SVGSVGElement))
+      return;
+    if (drauuInstance.value)
+      cleanup();
+    drauuInstance.value = drauu.createDrauu(__spreadValues$1({ el }, options));
+    syncStatus();
+    disposables = [
+      drauuInstance.value.on("canceled", () => onCanceledHook.trigger()),
+      drauuInstance.value.on("committed", () => onCommittedHook.trigger()),
+      drauuInstance.value.on("start", () => onStartHook.trigger()),
+      drauuInstance.value.on("end", () => onEndHook.trigger()),
+      drauuInstance.value.on("changed", () => {
+        syncStatus();
+        onChangedHook.trigger();
+      })
+    ];
+  }, { flush: "post" });
+  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
+  };
 }
 
-var SwipeDirection;
-(function (SwipeDirection) {
-    SwipeDirection["UP"] = "UP";
-    SwipeDirection["RIGHT"] = "RIGHT";
-    SwipeDirection["DOWN"] = "DOWN";
-    SwipeDirection["LEFT"] = "LEFT";
-    SwipeDirection["NONE"] = "NONE";
-})(SwipeDirection || (SwipeDirection = {}));
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function useFocusTrap(target, options = {}) {
+  let trap;
+  const _a = options, { immediate } = _a, focusTrapOptions = __objRest(_a, ["immediate"]);
+  const hasFocus = vueDemi.ref(false);
+  const isPaused = vueDemi.ref(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;
+    }
+  };
+  vueDemi.watch(() => core.unrefElement(target), (el) => {
+    if (!el)
+      return;
+    trap = focusTrap.createFocusTrap(el, __spreadProps(__spreadValues({}, focusTrapOptions), {
+      onActivate() {
+        hasFocus.value = true;
+        if (options.onActivate)
+          options.onActivate();
+      },
+      onDeactivate() {
+        hasFocus.value = false;
+        if (options.onDeactivate)
+          options.onDeactivate();
+      }
+    }));
+    if (immediate)
+      activate();
+  }, { flush: "post" });
+  core.tryOnScopeDispose(() => deactivate());
+  return {
+    hasFocus,
+    isPaused,
+    activate,
+    deactivate,
+    pause,
+    unpause
+  };
+}
 
-/**
- * Reactive focus-trap
- *
- * @see https://vueuse.org/useFocusTrap
- * @param target The target element to trap focus within
- * @param options Focus trap options
- * @param autoFocus Focus trap automatically when mounted
- */
-function useFocusTrap(target, options = {}) {
-    let trap;
-    const { immediate } = options, focusTrapOptions = __rest(options, ["immediate"]);
-    const hasFocus = vueDemi.ref(false);
-    const isPaused = vueDemi.ref(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;
-        }
-    };
-    vueDemi.watch(() => unrefElement(target), (el) => {
-        if (!el)
-            return;
-        trap = focusTrap.createFocusTrap(el, Object.assign(Object.assign({}, focusTrapOptions), { onActivate() {
-                hasFocus.value = true;
-                // Apply if user provided onActivate option
-                if (options.onActivate)
-                    options.onActivate();
-            },
-            onDeactivate() {
-                hasFocus.value = false;
-                // Apply if user provided onDeactivate option
-                if (options.onDeactivate)
-                    options.onDeactivate();
-            } }));
-        // Focus if immediate is set to true
-        if (immediate)
-            activate();
-    }, { flush: 'post' });
-    // Cleanup on unmount
-    shared.tryOnScopeDispose(() => deactivate());
-    return {
-        hasFocus,
-        isPaused,
-        activate,
-        deactivate,
-        pause,
-        unpause,
-    };
+function useFuse(search, data, options) {
+  var _a;
+  const createFuse = (data2, options2) => {
+    var _a2;
+    const _options = options2;
+    return new Fuse__default["default"]((_a2 = vueDemi.unref(data2)) != null ? _a2 : [], _options);
+  };
+  const fuse = vueDemi.ref(createFuse(data, (_a = vueDemi.unref(options)) == null ? void 0 : _a.fuseOptions));
+  vueDemi.watch(() => {
+    var _a2;
+    return (_a2 = vueDemi.unref(options)) == null ? void 0 : _a2.fuseOptions;
+  }, (newOptions) => {
+    fuse.value = createFuse(data, newOptions);
+  }, { deep: true });
+  vueDemi.watch(() => vueDemi.unref(data), (newData) => {
+    fuse.value.setCollection(newData);
+  }, { deep: true });
+  const results = vueDemi.computed(() => {
+    var _a2, _b;
+    if (((_a2 = vueDemi.unref(options)) == null ? void 0 : _a2.matchAllWhenSearchEmpty) && !vueDemi.unref(search))
+      return vueDemi.unref(data).map((item, index) => ({ item, refIndex: index }));
+    const limit = (_b = vueDemi.unref(options)) == null ? void 0 : _b.resultLimit;
+    return fuse.value.search(vueDemi.unref(search), limit ? { limit } : void 0);
+  });
+  return {
+    results
+  };
 }
 
-/**
- * Reactive decoded jwt token.
- *
- * @see https://vueuse.org/useJwt
- * @param jwt
- */
-function useJwt(encodedJwt, options = {}) {
-    const encodedJwtRef = vueDemi.ref(encodedJwt);
-    const { onError, fallbackValue = null, } = options;
-    const decodeWithFallback = (encodedJwt, options) => {
-        try {
-            return jwt_decode__default['default'](encodedJwt, options);
-        }
-        catch (err) {
-            onError === null || onError === void 0 ? void 0 : onError(err);
-            return fallbackValue;
-        }
-    };
-    const header = vueDemi.computed(() => decodeWithFallback(encodedJwtRef.value, { header: true }));
-    const payload = vueDemi.computed(() => decodeWithFallback(encodedJwtRef.value));
-    return {
-        header,
-        payload,
-    };
+function useJwt(encodedJwt, options = {}) {
+  const encodedJwtRef = vueDemi.ref(encodedJwt);
+  const {
+    onError,
+    fallbackValue = null
+  } = options;
+  const decodeWithFallback = (encodedJwt2, options2) => {
+    try {
+      return jwt_decode__default["default"](encodedJwt2, options2);
+    } catch (err) {
+      onError == null ? void 0 : onError(err);
+      return fallbackValue;
+    }
+  };
+  const header = vueDemi.computed(() => decodeWithFallback(encodedJwtRef.value, { header: true }));
+  const payload = vueDemi.computed(() => decodeWithFallback(encodedJwtRef.value));
+  return {
+    header,
+    payload
+  };
 }
 
-/**
- * Reactive progress bar.
- *
- * @see https://vueuse.org/useNProgress
- * @param currentProgress
- * @param options
- */
-function useNProgress(currentProgress = null, options) {
-    const progress = vueDemi.isRef(currentProgress)
-        ? currentProgress
-        : vueDemi.ref(currentProgress);
-    const isLoading = vueDemi.computed({
-        set: load => load ? nprogress__default['default'].start() : nprogress__default['default'].done(),
-        get: () => shared.isNumber(progress.value) && progress.value < 1,
-    });
-    if (options)
-        nprogress__default['default'].configure(options);
-    const setProgress = nprogress__default['default'].set;
-    nprogress__default['default'].set = (n) => {
-        progress.value = n;
-        return setProgress.call(nprogress__default['default'], n);
-    };
-    vueDemi.watchEffect(() => {
-        if (shared.isNumber(progress.value))
-            setProgress.call(nprogress__default['default'], progress.value);
-    });
-    shared.tryOnScopeDispose(nprogress__default['default'].remove);
-    return {
-        isLoading,
-        progress,
-        start: nprogress__default['default'].start,
-        done: nprogress__default['default'].done,
-        remove: () => {
-            progress.value = null;
-            nprogress__default['default'].remove();
-        },
-    };
+function useNProgress(currentProgress = null, options) {
+  const progress = vueDemi.isRef(currentProgress) ? currentProgress : vueDemi.ref(currentProgress);
+  const isLoading = vueDemi.computed({
+    set: (load) => load ? nprogress__default["default"].start() : nprogress__default["default"].done(),
+    get: () => shared.isNumber(progress.value) && progress.value < 1
+  });
+  if (options)
+    nprogress__default["default"].configure(options);
+  const setProgress = nprogress__default["default"].set;
+  nprogress__default["default"].set = (n) => {
+    progress.value = n;
+    return setProgress.call(nprogress__default["default"], n);
+  };
+  vueDemi.watchEffect(() => {
+    if (shared.isNumber(progress.value))
+      setProgress.call(nprogress__default["default"], progress.value);
+  });
+  shared.tryOnScopeDispose(nprogress__default["default"].remove);
+  return {
+    isLoading,
+    progress,
+    start: nprogress__default["default"].start,
+    done: nprogress__default["default"].done,
+    remove: () => {
+      progress.value = null;
+      nprogress__default["default"].remove();
+    }
+  };
 }
 
-/**
- * Wrapper for qrcode.
- *
- * @see https://vueuse.org/useQRCode
- * @param text
- * @param options
- */
-function useQRCode(text, options) {
-    const src = vueDemi.ref(text);
-    const result = vueDemi.ref('');
-    vueDemi.watch(src, async (value) => {
-        if (src.value && shared.isClient)
-            result.value = await QRCode__default['default'].toDataURL(value, options);
-    }, { immediate: true });
-    return result;
+function useQRCode(text, options) {
+  const src = vueDemi.ref(text);
+  const result = vueDemi.ref("");
+  vueDemi.watch(src, async (value) => {
+    if (src.value && shared.isClient)
+      result.value = await QRCode__default["default"].toDataURL(value, options);
+  }, { immediate: true });
+  return result;
 }
 
 exports.createCookies = createCookies;
 exports.useAxios = useAxios;
 exports.useCookies = useCookies;
+exports.useDrauu = useDrauu;
 exports.useFocusTrap = useFocusTrap;
+exports.useFuse = useFuse;
 exports.useJwt = useJwt;
 exports.useNProgress = useNProgress;
 exports.useQRCode = useQRCode;