@vueuse/integrations 6.3.3 → 6.6.1

package/index.iife.js

@@ -59,352 +59,447 @@
   window.VueDemi = VueDemi
 })(window)
 ;
-;(function (exports, vueDemi, axios, shared, Cookie, focusTrap, jwt_decode, nprogress, QRCode) {
+;(function (exports, vueDemi, axios, shared, Cookie, drauu, core, focusTrap, Fuse, jwt_decode, nprogress, QRCode) {
   'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
   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;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-}(this.VueUse = this.VueUse || {}, VueDemi, axios, VueUse, UniversalCookie, focusTrap, jwt_decode, nprogress, QRCode));
+})(this.VueUse = this.VueUse || {}, VueDemi, axios, VueUse, UniversalCookie, Drauu, VueUse, focusTrap, Fuse, jwt_decode, nprogress, QRCode);