@reause/integrations 0.1.2

package/dist/index.iife.js

@@ -0,0 +1,1621 @@
+(function(exports, async_validator, react, _reause_shared, axios, change_case, universal_cookie, drauu, focus_trap, fuse_js, idb_keyval, jwt_decode, nprogress, qrcode, sortablejs) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	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 || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	//#endregion
+	async_validator = __toESM(async_validator, 1);
+	axios = __toESM(axios, 1);
+	change_case = __toESM(change_case, 1);
+	universal_cookie = __toESM(universal_cookie, 1);
+	fuse_js = __toESM(fuse_js, 1);
+	nprogress = __toESM(nprogress, 1);
+	qrcode = __toESM(qrcode, 1);
+	sortablejs = __toESM(sortablejs, 1);
+	//#region useAsyncValidator/index.tsx
+	const AsyncValidatorSchema = async_validator.default.default || async_validator.default;
+	/**
+	* React port of VueUse's `useAsyncValidator` — a wrapper around
+	* [`async-validator`](https://github.com/yiminghe/async-validator).
+	*
+	* Map from @vueuse/integrations `useAsyncValidator`
+	* (`source/vueuse/packages/integrations/useAsyncValidator/`). The upstream
+	* object return is preserved (`{ pass, isFinished, errors, errorInfo,
+	* errorFields, execute }`) with the refs unwrapped: every member is a plain
+	* value (no `.value`), `pass` starts as `!immediate || manual`, `execute()`
+	* flips `isFinished` to `false`, awaits
+	* `validator.validate(value, validateOption)` and settles with
+	* `pass`, `errorInfo`, `errors` and `errorFields`; `errors` is
+	* `errorInfo?.errors || []` and `errorFields` is `errorInfo?.fields || {}`.
+	* `value` and `rules` are the hook's **read-only value sources** and take
+	* plain values (`Record<string, any>` and `Rules`; upstream:
+	* `MaybeRefOrGetter`); the returned
+	* object is promise-like (`await useAsyncValidator(...)` resolves with the
+	* current snapshot), mirroring `useAsyncState`.
+	*
+	* Adjustment for React:
+	* - upstream re-runs validation from
+	*   `watch([valueRef, validator], execute, { immediate, deep: true })`. React
+	*   has no deep observation, so this port re-runs from an effect keyed on the
+	*   identity of `value` / `rules` and skips it entirely when
+	*   `manual` is `true`. Consequence: mutating the SAME object in place does NOT
+	*   re-trigger validation — pass a new object (or new `rules`) or call
+	*   `execute()` yourself. In React StrictMode dev builds the initial
+	*   validation may run twice (the effect is double-invoked); the extra run is
+	*   idempotent.
+	* - `errors` and `errorFields` are derived during render from `errorInfo`
+	*   (upstream uses `computed`); `execute` is stable and ignores results that
+	*   arrive after unmount.
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const { pass, isFinished, errors, errorFields, execute } = useAsyncValidator(
+	*   form,
+	*   { name: { type: 'string', min: 5, max: 20 }, age: { type: 'number' } },
+	* )
+	* // `pass` becomes true once the initial validation resolves
+	*
+	* @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 valueValue = value;
+		const rulesValue = rules;
+		const [errorInfo, setErrorInfo] = (0, react.useState)(null);
+		const [isFinished, setIsFinished] = (0, react.useState)(true);
+		const [pass, setPass] = (0, react.useState)(!immediate || manual);
+		const validator = (0, react.useMemo)(() => new AsyncValidatorSchema(rulesValue), [rulesValue]);
+		const valueRef = (0, react.useRef)(value);
+		valueRef.current = value;
+		const validatorRef = (0, react.useRef)(validator);
+		validatorRef.current = validator;
+		const validateOptionRef = (0, react.useRef)(validateOption);
+		validateOptionRef.current = validateOption;
+		const liveRef = (0, react.useRef)({
+			pass,
+			isFinished,
+			errorInfo
+		});
+		liveRef.current.pass = pass;
+		liveRef.current.isFinished = isFinished;
+		liveRef.current.errorInfo = errorInfo;
+		const mountedRef = (0, react.useRef)(true);
+		const finishedRef = (0, react.useRef)(isFinished);
+		const waitersRef = (0, react.useRef)([]);
+		const execute = (0, react.useCallback)(async () => {
+			finishedRef.current = false;
+			liveRef.current.pass = false;
+			liveRef.current.isFinished = false;
+			setPass(false);
+			setIsFinished(false);
+			let nextPass = false;
+			let nextErrorInfo = null;
+			try {
+				await validatorRef.current.validate(valueRef.current, validateOptionRef.current);
+				nextPass = true;
+				nextErrorInfo = null;
+			} catch (err) {
+				nextErrorInfo = err;
+			}
+			const result = {
+				pass: nextPass,
+				errorInfo: nextErrorInfo,
+				errors: (nextErrorInfo === null || nextErrorInfo === void 0 ? void 0 : nextErrorInfo.errors) || [],
+				errorFields: (nextErrorInfo === null || nextErrorInfo === void 0 ? void 0 : nextErrorInfo.fields) || {}
+			};
+			if (!mountedRef.current) return result;
+			finishedRef.current = true;
+			liveRef.current.pass = nextPass;
+			liveRef.current.isFinished = true;
+			liveRef.current.errorInfo = nextErrorInfo;
+			setPass(nextPass);
+			setErrorInfo(nextErrorInfo);
+			setIsFinished(true);
+			return result;
+		}, []);
+		const lastValueRef = (0, react.useRef)(valueValue);
+		const lastRulesRef = (0, react.useRef)(rulesValue);
+		const hasAutoRunRef = (0, react.useRef)(false);
+		(0, react.useEffect)(() => {
+			if (manual) return;
+			const first = !hasAutoRunRef.current;
+			if (!(first || lastValueRef.current !== valueValue || lastRulesRef.current !== rulesValue)) return;
+			hasAutoRunRef.current = true;
+			lastValueRef.current = valueValue;
+			lastRulesRef.current = rulesValue;
+			if (first && !immediate) return;
+			execute();
+		});
+		(0, react.useEffect)(() => {
+			mountedRef.current = true;
+			return () => {
+				mountedRef.current = false;
+			};
+		}, []);
+		const baseRef = (0, react.useRef)(void 0);
+		const base = {
+			get pass() {
+				return liveRef.current.pass;
+			},
+			get isFinished() {
+				return liveRef.current.isFinished;
+			},
+			get errorInfo() {
+				return liveRef.current.errorInfo;
+			},
+			get errors() {
+				var _liveRef$current$erro;
+				return ((_liveRef$current$erro = liveRef.current.errorInfo) === null || _liveRef$current$erro === void 0 ? void 0 : _liveRef$current$erro.errors) || [];
+			},
+			get errorFields() {
+				var _liveRef$current$erro2;
+				return ((_liveRef$current$erro2 = liveRef.current.errorInfo) === null || _liveRef$current$erro2 === void 0 ? void 0 : _liveRef$current$erro2.fields) || {};
+			},
+			execute
+		};
+		baseRef.current = base;
+		const waitUntilFinished = (0, react.useCallback)(() => {
+			return new Promise((resolve) => {
+				if (finishedRef.current) {
+					resolve(baseRef.current);
+					return;
+				}
+				waitersRef.current.push({ resolve });
+			});
+		}, []);
+		(0, react.useEffect)(() => {
+			if (!isFinished) return;
+			const waiters = waitersRef.current;
+			waitersRef.current = [];
+			waiters.forEach((waiter) => waiter.resolve(baseRef.current));
+		}, [isFinished]);
+		const shell = Object.create(base);
+		shell.then = function then(onFulfilled, onRejected) {
+			return waitUntilFinished().then(onFulfilled, onRejected);
+		};
+		return shell;
+	}
+	//#endregion
+	//#region useAxios/index.tsx
+	/**
+	* React port of VueUse's `useAxios` — wrapper for
+	* [`axios`](https://github.com/axios/axios).
+	*
+	* Map from @vueuse/integrations `useAxios`
+	* (`source/vueuse/packages/integrations/useAxios/`). All 12 upstream overloads
+	* are kept verbatim (`(url, config?, options?)`, `(url, instance?, options?)`,
+	* `(url, config, instance, options?)`, `(config)`, `(instance)`,
+	* `(config, instance)`); the url-ful forms expose `execute(url?, config?)`,
+	* the url-less forms require `execute(url, config?)`. The returned object
+	* mirrors the upstream members — `response`, `data`, `isFinished`,
+	* `isLoading`, `isAborted`/`isCanceled`, `error`, `abort`/`cancel`, `execute` —
+	* but the members are plain values backed by live getters instead of refs
+	* (no `.value`), and the object is thenable (`await useAxios(url)` resolves
+	* with the shell once the request settled, rejecting when it failed).
+	*
+	* Adjustment for React:
+	* - the returned object is built with `Object.create` over a getter base whose
+	*   members read a synchronously-updated live mirror of the state, so a shell
+	*   captured earlier (e.g. the value `await` resolved with) still exposes
+	*   fresh values — the same shape `useAsyncState` uses. The base itself is
+	*   deliberately NOT thenable, so resolving it can never re-adopt `then`;
+	* - `execute` returns the shared thenable shell (upstream `return promise`):
+	*   `await execute()` resolves with the shell once the request finished,
+	*   rejecting with the request error on failure, and a bare unawaited
+	*   `execute()` never settles eagerly — so no unhandled rejection can
+	*   escape. `immediate` requests fire from a mount effect (upstream fires
+	*   during setup), and the shell is never left without a rejection handler
+	*   there;
+	* - a pending request is aborted on unmount (React-safety deviation: upstream
+	*   only relies on the `isAborted` guard), so a late response can never
+	*   populate `data`/`response` after the component is gone;
+	* - `shallow` is accepted for API parity but has no effect: React state is
+	*   never deep-wrapped, so there is no `shallowRef`/`ref` distinction here.
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const { data, isLoading, isFinished, execute, abort } = useAxios('/api/posts')
+	* await execute('/api/posts/2')
+	*
+	* @see https://vueuse.org/integrations/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 { onSuccess = _reause_shared.noop, onError = _reause_shared.noop, immediate, resetOnExecute = false } = options;
+		const initialData = options.initialData;
+		const urlRef = (0, react.useRef)(url);
+		urlRef.current = url;
+		const configRef = (0, react.useRef)(defaultConfig);
+		configRef.current = defaultConfig;
+		const instanceRef = (0, react.useRef)(instance);
+		instanceRef.current = instance;
+		const optionsRef = (0, react.useRef)(options);
+		optionsRef.current = options;
+		const immediateRef = (0, react.useRef)(immediate);
+		immediateRef.current = immediate;
+		const resetOnExecuteRef = (0, react.useRef)(resetOnExecute);
+		resetOnExecuteRef.current = resetOnExecute;
+		const initialDataRef = (0, react.useRef)(initialData);
+		initialDataRef.current = initialData;
+		const onSuccessRef = (0, react.useRef)(onSuccess);
+		onSuccessRef.current = onSuccess;
+		const onErrorRef = (0, react.useRef)(onError);
+		onErrorRef.current = onError;
+		const onFinishRef = (0, react.useRef)(options.onFinish);
+		onFinishRef.current = options.onFinish;
+		const [response, setResponse] = (0, react.useState)(void 0);
+		const [data, setData] = (0, react.useState)(initialData);
+		const [isFinished, setIsFinished] = (0, react.useState)(false);
+		const [isLoading, setIsLoading] = (0, react.useState)(false);
+		const [isAborted, setIsAborted] = (0, react.useState)(false);
+		const [error, setError] = (0, react.useState)(void 0);
+		const liveRef = (0, react.useRef)({
+			response,
+			data,
+			isFinished,
+			isLoading,
+			isAborted,
+			error
+		});
+		const abortControllerRef = (0, react.useRef)(null);
+		if (abortControllerRef.current === null) abortControllerRef.current = new AbortController();
+		const executeCounterRef = (0, react.useRef)(0);
+		const waitersRef = (0, react.useRef)([]);
+		const baseRef = (0, react.useRef)(null);
+		const shellRef = (0, react.useRef)(null);
+		const abort = (0, react.useCallback)((message) => {
+			var _abortControllerRef$c;
+			if (liveRef.current.isFinished || !liveRef.current.isLoading) return;
+			(_abortControllerRef$c = abortControllerRef.current) === null || _abortControllerRef$c === void 0 || _abortControllerRef$c.abort(message);
+			abortControllerRef.current = new AbortController();
+			liveRef.current.isAborted = true;
+			liveRef.current.isLoading = false;
+			liveRef.current.isFinished = false;
+			setIsAborted(true);
+			setIsLoading(false);
+			setIsFinished(false);
+		}, []);
+		const loading = (0, react.useCallback)((value) => {
+			liveRef.current.isLoading = value;
+			liveRef.current.isFinished = !value;
+			setIsLoading(value);
+			setIsFinished(!value);
+		}, []);
+		/**
+		* Reset data to initialData
+		*/
+		const resetData = (0, react.useCallback)(() => {
+			if (!resetOnExecuteRef.current) return;
+			liveRef.current.data = initialDataRef.current;
+			setData(initialDataRef.current);
+		}, []);
+		const drainWaiters = (0, react.useCallback)(() => {
+			const waiters = waitersRef.current;
+			if (waiters.length === 0) return;
+			waitersRef.current = [];
+			const currentError = liveRef.current.error;
+			const result = baseRef.current;
+			waiters.forEach(({ resolve, reject }) => {
+				if (currentError) reject(currentError);
+				else resolve(result);
+			});
+		}, []);
+		const execute = (0, react.useCallback)((executeUrl = urlRef.current, config = {}) => {
+			var _urlRef$current, _abortControllerRef$c2;
+			liveRef.current.error = void 0;
+			setError(void 0);
+			const _url = typeof executeUrl === "string" ? executeUrl : (_urlRef$current = urlRef.current) !== null && _urlRef$current !== void 0 ? _urlRef$current : config.url;
+			if (_url === void 0) {
+				const invalidUrlError = new axios.AxiosError(axios.AxiosError.ERR_INVALID_URL);
+				liveRef.current.error = invalidUrlError;
+				liveRef.current.isFinished = true;
+				setError(invalidUrlError);
+				setIsFinished(true);
+				return shellRef.current;
+			}
+			resetData();
+			if (optionsRef.current.abortPrevious !== false) abort();
+			loading(true);
+			executeCounterRef.current += 1;
+			const currentExecuteCounter = executeCounterRef.current;
+			liveRef.current.isAborted = false;
+			setIsAborted(false);
+			instanceRef.current(_url, {
+				...configRef.current,
+				...typeof executeUrl === "object" ? executeUrl : config,
+				signal: (_abortControllerRef$c2 = abortControllerRef.current) === null || _abortControllerRef$c2 === void 0 ? void 0 : _abortControllerRef$c2.signal
+			}).then((result) => {
+				if (liveRef.current.isAborted) return;
+				liveRef.current.response = result;
+				setResponse(result);
+				const payload = result === null || result === void 0 ? void 0 : result.data;
+				liveRef.current.data = payload;
+				setData(payload);
+				onSuccessRef.current(payload);
+			}).catch((e) => {
+				liveRef.current.error = e;
+				setError(e);
+				onErrorRef.current(e);
+			}).finally(() => {
+				var _onFinishRef$current;
+				(_onFinishRef$current = onFinishRef.current) === null || _onFinishRef$current === void 0 || _onFinishRef$current.call(onFinishRef);
+				if (currentExecuteCounter === executeCounterRef.current) {
+					loading(false);
+					drainWaiters();
+				}
+			});
+			return shellRef.current;
+		}, [
+			abort,
+			drainWaiters,
+			loading,
+			resetData
+		]);
+		const base = {
+			get response() {
+				return liveRef.current.response;
+			},
+			get data() {
+				return liveRef.current.data;
+			},
+			get isFinished() {
+				return liveRef.current.isFinished;
+			},
+			get isLoading() {
+				return liveRef.current.isLoading;
+			},
+			get isAborted() {
+				return liveRef.current.isAborted;
+			},
+			get isCanceled() {
+				return liveRef.current.isAborted;
+			},
+			get error() {
+				return liveRef.current.error;
+			},
+			abort,
+			cancel: abort,
+			execute
+		};
+		baseRef.current = base;
+		const waitUntilFinished = (0, react.useCallback)(() => {
+			return new Promise((resolve, reject) => {
+				if (!liveRef.current.isLoading) {
+					const currentError = liveRef.current.error;
+					if (currentError) reject(currentError);
+					else resolve(baseRef.current);
+					return;
+				}
+				waitersRef.current.push({
+					resolve,
+					reject
+				});
+			});
+		}, []);
+		(0, react.useEffect)(() => {
+			if (immediateRef.current && urlRef.current) execute().catch(_reause_shared.noop);
+		}, [execute]);
+		(0, react.useEffect)(() => () => {
+			var _abortControllerRef$c3;
+			(_abortControllerRef$c3 = abortControllerRef.current) === null || _abortControllerRef$c3 === void 0 || _abortControllerRef$c3.abort();
+		}, []);
+		(0, react.useEffect)(() => {
+			if (isLoading) return;
+			drainWaiters();
+		}, [isLoading, drainWaiters]);
+		const shell = Object.create(base);
+		shell.then = function then(onFulfilled, onRejected) {
+			return waitUntilFinished().then(onFulfilled, onRejected);
+		};
+		shell.catch = function catchFn(onRejected) {
+			return waitUntilFinished().catch(onRejected);
+		};
+		shellRef.current = shell;
+		return shell;
+	}
+	//#endregion
+	//#region useChangeCase/index.tsx
+	const changeCaseTransforms = /* @__PURE__ */ Object.entries(change_case).filter((entry) => {
+		const [name, fn] = entry;
+		return typeof fn === "function" && name.endsWith("Case");
+	}).reduce((acc, [name, fn]) => {
+		acc[name] = fn;
+		return acc;
+	}, {});
+	/**
+	* React port of VueUse's `useChangeCase`.
+	*
+	* Map from @vueuse/integrations `useChangeCase`
+	* (`source/vueuse/packages/integrations/useChangeCase/`), a reactive wrapper
+	* around the `change-case` package. Upstream returns a writable
+	* `WritableComputedRef<string>`; here the writable computed ref maps to a
+	* `[value, setValue]` tuple: `value` is the transformed string (`change-case`
+	* applied to the internal input state with the current `type`), and
+	* `setValue` updates that internal input state like a controlled `useState`.
+	* `input` is the hook's **read-only value source** and takes a plain `string`
+	* (upstream: `MaybeRef<string>` / `MaybeRefOrGetter<string>`); `type` and
+	* `options` stay `RefOrValue` (format knobs, upstream `MaybeRefOrGetter`) and
+	* are resolved with `toValue` from `@reause/shared`.
+	*
+	* Adjustment for React:
+	* - upstream's writable computed captures a plain `input` once at setup. Here
+	*   a changed `input` prop re-syncs the internal state on the next render, so
+	*   a parent re-render with a new string is reflected; a `setValue` write is
+	*   never clobbered while the `input` prop is unchanged (the baseline records
+	*   the last externally synced value);
+	* - writes are **not** propagated back to the caller: `setValue` updates the
+	*   internal input state only (upstream's writable computed writes through to
+	*   a ref input). A changed `input` prop always wins over the internal state;
+	* - `setValue` writes the RAW string; the transform is re-applied on the next
+	*   render (the upstream computed's `get` re-derives from the ref on access).
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const [changeCase, setChangeCase] = useChangeCase('hello world', 'camelCase')
+	* changeCase // 'helloWorld'
+	* setChangeCase('vue use')
+	* changeCase // 'vueUse'
+	*/
+	function useChangeCase(input, type, options) {
+		const [text, setText] = (0, react.useState)(input);
+		const lastExternalRef = (0, react.useRef)(input);
+		(0, react.useEffect)(() => {
+			if (!Object.is(input, lastExternalRef.current)) {
+				lastExternalRef.current = input;
+				setText(input);
+			}
+		});
+		const typeName = (0, _reause_shared.toValue)(type);
+		const resolvedOptions = (0, _reause_shared.toValue)(options);
+		return [(0, react.useMemo)(() => {
+			const transform = changeCaseTransforms[typeName];
+			if (!transform) throw new Error(`Invalid change case type "${typeName}"`);
+			return transform(text, resolvedOptions);
+		}, [
+			text,
+			typeName,
+			resolvedOptions
+		]), setText];
+	}
+	//#endregion
+	//#region useCookies/index.tsx
+	/**
+	* React port of VueUse's `createCookies` — creates a `universal-cookie`
+	* instance from a request (default is `window.document.cookie`) and returns a
+	* {@link useCookies} bound to that instance.
+	*
+	* Map from @vueuse/integrations `createCookies`
+	* (`source/vueuse/packages/integrations/useCookies/index.ts`).
+	*
+	* @param req - incoming request (for SSR); a plain `cookie` header string is
+	* also accepted for convenience
+	* @see https://github.com/reactivestack/cookies/tree/master/packages/universal-cookie universal-cookie
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const useSsrCookies = createCookies({ headers: { cookie: 'locale=en-US' } })
+	* const { get } = useSsrCookies(['locale'])
+	* get('locale') // 'en-US'
+	*/
+	function createCookies(req) {
+		var _req$headers$cookie, _req$headers;
+		const universalCookie = new universal_cookie.default(typeof req === "string" ? req : (_req$headers$cookie = req === null || req === void 0 || (_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers.cookie) !== null && _req$headers$cookie !== void 0 ? _req$headers$cookie : null);
+		return (dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}) => useCookies(dependencies, {
+			doNotParse,
+			autoUpdateDependencies
+		}, universalCookie);
+	}
+	/**
+	* React port of VueUse's `useCookies` — reactive methods to work with cookies
+	* (use {@link createCookies} instead if you are using SSR).
+	*
+	* Map from @vueuse/integrations `useCookies`
+	* (`source/vueuse/packages/integrations/useCookies/index.ts`).
+	*
+	* Adjustment for React:
+	* - upstream returns a **method object** (`get`, `getAll`, `set`, `remove`,
+	*   `addChangeListener`, `removeChangeListener`), not a piece of writable
+	*   state, so the port returns the same object instead of a tuple (§2B);
+	* - upstream's `shallowRef(0)` "touches" counter is a `useState` counter read
+	*   in the render body, so a watched cookie change re-renders the component
+	*   and the `get`/`getAll` closures from that render observe the new value;
+	* - `previousCookies` and the mutable watch list live in refs so they persist
+	*   across renders exactly as upstream's local variables do;
+	* - upstream's `tryOnScopeDispose` maps to a `useEffect` cleanup that removes
+	*   the change listener.
+	*
+	* @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__
+	* @example
+	* const { get, set } = useCookies(['locale'])
+	* get('locale') // reads reactively
+	* set('locale', 'en-US')
+	*/
+	function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new universal_cookie.default()) {
+		const watchingDependenciesRef = (0, react.useRef)(autoUpdateDependencies ? [...dependencies || []] : dependencies);
+		const previousCookiesRef = (0, react.useRef)(null);
+		if (previousCookiesRef.current === null) previousCookiesRef.current = cookies.getAll({ doNotParse: true });
+		const [touches, setTouches] = (0, react.useState)(0);
+		const previousDependenciesRef = (0, react.useRef)(dependencies);
+		(0, react.useEffect)(() => {
+			if (previousDependenciesRef.current === dependencies) return;
+			previousDependenciesRef.current = dependencies;
+			if (!autoUpdateDependencies) watchingDependenciesRef.current = dependencies;
+		}, [dependencies, autoUpdateDependencies]);
+		const onChange = (0, react.useCallback)(() => {
+			var _watchingDependencies;
+			const newCookies = cookies.getAll({ doNotParse: true });
+			const previous = previousCookiesRef.current;
+			if (previous === null) {
+				previousCookiesRef.current = newCookies;
+				return;
+			}
+			if (shouldUpdate((_watchingDependencies = watchingDependenciesRef.current) !== null && _watchingDependencies !== void 0 ? _watchingDependencies : null, newCookies, previous)) setTouches((n) => n + 1);
+			previousCookiesRef.current = newCookies;
+		}, [cookies]);
+		(0, react.useEffect)(() => {
+			cookies.addChangeListener(onChange);
+			return () => {
+				cookies.removeChangeListener(onChange);
+			};
+		}, [cookies, onChange]);
+		return {
+			get: (name, options) => {
+				const watchingDependencies = watchingDependenciesRef.current;
+				/**
+				* Auto update watching dependencies if needed
+				*/
+				if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(name)) watchingDependencies.push(name);
+				return cookies.get(name, {
+					doNotParse,
+					...options
+				});
+			},
+			getAll: (options) => cookies.getAll({
+				doNotParse,
+				...options
+			}),
+			set: (name, value, options) => cookies.set(name, value, options),
+			remove: (name, options) => cookies.remove(name, options),
+			addChangeListener: (callback) => cookies.addChangeListener(callback),
+			removeChangeListener: (callback) => cookies.removeChangeListener(callback)
+		};
+	}
+	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.tsx
+	/**
+	* Resolve the target to a DOM element — a plain element, a React ref-like
+	* object (`{ current }`), or `null` when it cannot be resolved. Upstream
+	* resolves elements with `unrefElement` (`@vueuse/core`); the React port
+	* composes the same unwrapping from `toValue` / `isRefLike` (`@reause/shared`)
+	* — one pass unwraps a ref-like object, a second one covers a ref-like object
+	* holding another ref-like (`{ current: { current: element } }`).
+	*/
+	function resolveElement$2(value) {
+		let el = (0, _reause_shared.toValue)(value);
+		if ((0, _reause_shared.isRefLike)(el)) el = (0, _reause_shared.toValue)(el);
+		if (typeof el === "object" && el !== null && (el instanceof HTMLElement || el instanceof SVGElement)) return el;
+		return null;
+	}
+	/** Default brush — upstream's `brush` ref defaults (draw / black / size 3). */
+	const DEFAULT_BRUSH = {
+		color: "black",
+		size: 3,
+		arrowEnd: false,
+		cornerRadius: 0,
+		dasharray: void 0,
+		fill: "transparent",
+		mode: "draw"
+	};
+	/**
+	* Minimal event hook — mirrors `@reause/shared`'s `createEventHook` shape
+	* (`on` / `trigger`) while staying identity-stable across renders: the
+	* listener set lives in a ref, so `on` never changes identity and
+	* `useListener(on, cb)` does not re-register on every render. Upstream
+	* allocates its `createEventHook()` once per setup; React has no setup phase,
+	* so the ref is the equivalent.
+	*/
+	function useEventHook() {
+		const fnsRef = (0, react.useRef)(/* @__PURE__ */ new Set());
+		return {
+			on: (0, react.useCallback)((fn) => {
+				fnsRef.current.add(fn);
+				return { off: () => {
+					fnsRef.current.delete(fn);
+				} };
+			}, []),
+			trigger: (0, react.useCallback)((...args) => {
+				Array.from(fnsRef.current).forEach((fn) => fn(...args));
+			}, [])
+		};
+	}
+	/**
+	* React port of VueUse's `useDrauu` — reactive instance for
+	* [drauu](https://github.com/antfu/drauu).
+	*
+	* Map from @vueuse/integrations `useDrauu`
+	* (`source/vueuse/packages/integrations/useDrauu/`), which creates a drauu
+	* instance for an `<svg>` element and exposes the drawing API plus its events.
+	* Upstream has no test file — the co-located `useDrauu.test.tsx` is authored
+	* for this port.
+	*
+	* Adjustment for React (upstream returns `Ref` / `ShallowRef` / `EventHookOn`):
+	* - the return is an OBJECT with a paired setter for every caller-writable
+	*   value (return-shape rule 5). `brush` is the only such value — upstream's
+	*   writable `Ref<Brush>` — and it is paired with `setBrush`, the React state
+	*   setter (`Dispatch<SetStateAction<Brush>>`), so `setBrush(next)` and
+	*   `setBrush(prev => next)` both work; `setBrush` writes the state AND the
+	*   mounted instance's brush / mode, mirroring upstream's deep watcher;
+	* - `drauuInstance`, `canUndo` and `canRedo` are plain values from state
+	*   instead of refs and stay read-only outputs without paired setters: the
+	*   hook owns the instance lifecycle and re-reads the undo / redo status from
+	*   the instance on every drauu `changed` event, so a caller write would be
+	*   overwritten (upstream returns them as writable `Ref` / `ShallowRef`s;
+	*   precedent: `useFileSystemAccess`'s `file`, `useAsyncState`'s `isReady` /
+	*   `error`, `useTextareaAutosize`'s `textarea`);
+	* - the five `on*` members are §2D registrars — `(fn) => ({ off })` typed
+	*   `ListenerOn<T>` (`@reause/shared`), consumable as
+	*   `useListener(onChanged, cb)` for automatic cleanup on unmount, and `off()`
+	*   removes exactly that listener and is idempotent;
+	* - the instance is created in an effect keyed on the resolved element's
+	*   identity (upstream: `watch(() => unrefElement(target), ..., { flush: 'post' })`)
+	*   and unmounted on cleanup (`tryOnScopeDispose`); an element-identity change
+	*   destroys and recreates the instance. **Divergence:** resolving to `null` —
+	*   a React ref whose element left the tree — destroys the instance and frees
+	*   drauu's window listeners, where upstream keeps the last instance alive
+	*   until scope dispose. Destroying is deliberate in React: a `null` ref means
+	*   the element is gone, and a stale live instance would keep drawing on a
+	*   detached `<svg>`; the co-located test pins this behavior;
+	* - the element is resolved locally from `@reause/shared`'s `toValue` /
+	*   `isRefLike` (precedent: `useFocusTrap.ts`), never from `@reause/core` —
+	*   `packages/integrations` must not depend on core (eslint
+	*   `no-restricted-imports`). Only an `SVGSVGElement` target mounts, matching
+	*   upstream's guard.
+	*
+	* @param target - the target `<svg>` element or a React ref-like object (`{ current }`)
+	* @param options - drauu options (`Omit<Options, 'el'>`); `brush` is merged over the defaults
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const target = useRef<SVGSVGElement>(null)
+	* const { undo, redo, canUndo, canRedo, brush, setBrush } = useDrauu(target)
+	* setBrush(prev => ({ ...prev, color: '#ef4444' }))
+	* return <svg ref={target} />
+	*/
+	function useDrauu(target, options) {
+		const [drauuInstance, setDrauuInstance] = (0, react.useState)(void 0);
+		const [canUndo, setCanUndo] = (0, react.useState)(false);
+		const [canRedo, setCanRedo] = (0, react.useState)(false);
+		const [brush, setBrushState] = (0, react.useState)(() => ({
+			...DEFAULT_BRUSH,
+			...options === null || options === void 0 ? void 0 : options.brush
+		}));
+		const instanceRef = (0, react.useRef)(null);
+		const disposablesRef = (0, react.useRef)([]);
+		const elementRef = (0, react.useRef)(null);
+		const targetRef = (0, react.useRef)(target);
+		targetRef.current = target;
+		const optionsRef = (0, react.useRef)(options);
+		optionsRef.current = options;
+		const brushRef = (0, react.useRef)(brush);
+		brushRef.current = brush;
+		const { on: onChanged, trigger: triggerChanged } = useEventHook();
+		const { on: onCommitted, trigger: triggerCommitted } = useEventHook();
+		const { on: onStart, trigger: triggerStart } = useEventHook();
+		const { on: onEnd, trigger: triggerEnd } = useEventHook();
+		const { on: onCanceled, trigger: triggerCanceled } = useEventHook();
+		const syncStatus = (0, react.useCallback)(() => {
+			const instance = instanceRef.current;
+			if (!instance) return;
+			setCanUndo(instance.canUndo());
+			setCanRedo(instance.canRedo());
+		}, []);
+		const destroyInstance = (0, react.useCallback)(() => {
+			const instance = instanceRef.current;
+			if (instance) {
+				disposablesRef.current.forEach((dispose) => dispose());
+				disposablesRef.current = [];
+				instance.unmount();
+				instanceRef.current = null;
+			}
+			setDrauuInstance(void 0);
+			setCanUndo(false);
+			setCanRedo(false);
+		}, []);
+		(0, react.useEffect)(() => {
+			const el = resolveElement$2(targetRef.current);
+			const svgEl = typeof SVGSVGElement === "undefined" || !(el instanceof SVGSVGElement) ? null : el;
+			if (svgEl === elementRef.current) return;
+			elementRef.current = svgEl;
+			destroyInstance();
+			if (!svgEl) return;
+			const instance = (0, drauu.createDrauu)({
+				...optionsRef.current,
+				el: svgEl,
+				brush: brushRef.current
+			});
+			instanceRef.current = instance;
+			disposablesRef.current = [
+				instance.on("canceled", () => triggerCanceled()),
+				instance.on("committed", (node) => triggerCommitted(node)),
+				instance.on("start", () => triggerStart()),
+				instance.on("end", () => triggerEnd()),
+				instance.on("changed", () => {
+					syncStatus();
+					triggerChanged();
+				})
+			];
+			syncStatus();
+			setDrauuInstance(instance);
+		});
+		(0, react.useEffect)(() => () => {
+			destroyInstance();
+			elementRef.current = null;
+		}, [destroyInstance]);
+		return {
+			drauuInstance,
+			load: (0, react.useCallback)((svg) => {
+				var _instanceRef$current;
+				(_instanceRef$current = instanceRef.current) === null || _instanceRef$current === void 0 || _instanceRef$current.load(svg);
+			}, []),
+			dump: (0, react.useCallback)(() => {
+				var _instanceRef$current2;
+				return (_instanceRef$current2 = instanceRef.current) === null || _instanceRef$current2 === void 0 ? void 0 : _instanceRef$current2.dump();
+			}, []),
+			clear: (0, react.useCallback)(() => {
+				var _instanceRef$current3;
+				(_instanceRef$current3 = instanceRef.current) === null || _instanceRef$current3 === void 0 || _instanceRef$current3.clear();
+			}, []),
+			cancel: (0, react.useCallback)(() => {
+				var _instanceRef$current4;
+				(_instanceRef$current4 = instanceRef.current) === null || _instanceRef$current4 === void 0 || _instanceRef$current4.cancel();
+			}, []),
+			undo: (0, react.useCallback)(() => {
+				var _instanceRef$current5;
+				return (_instanceRef$current5 = instanceRef.current) === null || _instanceRef$current5 === void 0 ? void 0 : _instanceRef$current5.undo();
+			}, []),
+			redo: (0, react.useCallback)(() => {
+				var _instanceRef$current6;
+				return (_instanceRef$current6 = instanceRef.current) === null || _instanceRef$current6 === void 0 ? void 0 : _instanceRef$current6.redo();
+			}, []),
+			canUndo,
+			canRedo,
+			brush,
+			setBrush: (0, react.useCallback)((next) => {
+				const value = typeof next === "function" ? next(brushRef.current) : next;
+				brushRef.current = value;
+				setBrushState(value);
+				const instance = instanceRef.current;
+				if (instance) {
+					instance.brush = value;
+					if (value.mode) instance.mode = value.mode;
+				}
+			}, []),
+			onChanged,
+			onCommitted,
+			onStart,
+			onEnd,
+			onCanceled
+		};
+	}
+	//#endregion
+	//#region useFocusTrap/index.tsx
+	/**
+	* Resolve one target item to a focus-trap container: a selector string, a DOM
+	* element, or `null` when it cannot be resolved. Upstream resolves elements
+	* with `unrefElement` (`@vueuse/core`); the React port composes the same
+	* unwrapping from `toValue` / `isRefLike` (`@reause/shared`) — one pass
+	* unwraps a ref-like object, a second one covers a ref-like object holding
+	* another ref-like (`{ current: { current: element } }`).
+	*/
+	function resolveElement$1(value) {
+		let el = (0, _reause_shared.toValue)(value);
+		if (typeof el !== "string" && (0, _reause_shared.isRefLike)(el)) el = (0, _reause_shared.toValue)(el);
+		if (typeof el === "string") return el;
+		if (typeof el === "object" && el !== null && (el instanceof HTMLElement || el instanceof SVGElement)) return el;
+		return null;
+	}
+	/**
+	* React port of VueUse's `useFocusTrap` — trap focus within one or more
+	* elements.
+	*
+	* Map from @vueuse/integrations `useFocusTrap`
+	* (`source/vueuse/packages/integrations/useFocusTrap/`), a reactive wrapper
+	* around the [`focus-trap`](https://github.com/focus-trap/focus-trap) library
+	* that keeps focus trapped inside the target element(s) while the trap is
+	* active.
+	*
+	* Adjustment for React: upstream creates the trap inside a `watch` over the
+	* resolved targets and exposes `ShallowRef`s for `hasFocus` / `isPaused`. The
+	* React port creates the `createFocusTrap` instance in an effect keyed on the
+	* resolved targets (mirroring the `watch`), keeps it for the lifetime of the
+	* component — target changes go through `updateContainerElements` — and
+	* deactivates it on unmount (`tryOnScopeDispose`). `hasFocus` / `isPaused`
+	* are plain booleans driven by focus-trap's `onActivate` / `onDeactivate`
+	* events plus the pause / unpause calls, and `activate` / `deactivate` /
+	* `pause` / `unpause` are stable callbacks delegating to the current trap
+	* instance. The `immediate` option activates the trap as soon as the target
+	* elements are available.
+	*
+	* SSR-safe: no `window` or DOM access at module scope — the trap is created
+	* lazily inside the effect.
+	*
+	* @param target - element, React ref object (`{ current }`), selector string,
+	*   or an array of them
+	* @param options - focus-trap options (see
+	*   https://github.com/focus-trap/focus-trap#createoptions) plus the
+	*   `immediate` shortcut
+	*
+	* @example
+	* const target = useRef<HTMLDivElement>(null)
+	* const { hasFocus, isPaused, activate, deactivate, pause, unpause } = useFocusTrap(target)
+	* activate() // traps focus inside target
+	*/
+	function useFocusTrap(target, options = {}) {
+		const [hasFocus, setHasFocus] = (0, react.useState)(false);
+		const [isPaused, setIsPaused] = (0, react.useState)(false);
+		const trapRef = (0, react.useRef)(null);
+		const targetRef = (0, react.useRef)(target);
+		targetRef.current = target;
+		const optionsRef = (0, react.useRef)(options);
+		optionsRef.current = options;
+		const resolvedTargetsRef = (0, react.useRef)(null);
+		(0, react.useEffect)(() => {
+			const targets = (0, _reause_shared.toArray)((0, _reause_shared.toValue)(targetRef.current)).map(resolveElement$1).filter((el) => el != null);
+			const previous = resolvedTargetsRef.current;
+			resolvedTargetsRef.current = targets;
+			if (previous && targets.length === previous.length && targets.every((el, index) => el === previous[index])) return;
+			if (!targets.length) return;
+			const trap = trapRef.current;
+			if (!trap) {
+				const { immediate, ...focusTrapOptions } = optionsRef.current;
+				trapRef.current = (0, focus_trap.createFocusTrap)(targets, {
+					...focusTrapOptions,
+					onActivate(params) {
+						var _optionsRef$current$o, _optionsRef$current;
+						setHasFocus(true);
+						(_optionsRef$current$o = (_optionsRef$current = optionsRef.current).onActivate) === null || _optionsRef$current$o === void 0 || _optionsRef$current$o.call(_optionsRef$current, params);
+					},
+					onDeactivate(params) {
+						var _optionsRef$current$o2, _optionsRef$current2;
+						setHasFocus(false);
+						(_optionsRef$current$o2 = (_optionsRef$current2 = optionsRef.current).onDeactivate) === null || _optionsRef$current$o2 === void 0 || _optionsRef$current$o2.call(_optionsRef$current2, params);
+					}
+				});
+				if (immediate) trapRef.current.activate();
+			} else {
+				const isActive = trap.active;
+				trap.updateContainerElements(targets);
+				if (!isActive && optionsRef.current.immediate) trap.activate();
+			}
+		});
+		(0, react.useEffect)(() => () => {
+			var _trapRef$current;
+			(_trapRef$current = trapRef.current) === null || _trapRef$current === void 0 || _trapRef$current.deactivate();
+			trapRef.current = null;
+		}, []);
+		return {
+			hasFocus,
+			isPaused,
+			activate: (0, react.useCallback)((opts) => {
+				var _trapRef$current2;
+				(_trapRef$current2 = trapRef.current) === null || _trapRef$current2 === void 0 || _trapRef$current2.activate(opts);
+			}, []),
+			deactivate: (0, react.useCallback)((opts) => {
+				var _trapRef$current3;
+				(_trapRef$current3 = trapRef.current) === null || _trapRef$current3 === void 0 || _trapRef$current3.deactivate(opts);
+			}, []),
+			pause: (0, react.useCallback)(() => {
+				if (trapRef.current) {
+					trapRef.current.pause();
+					setIsPaused(true);
+				}
+			}, []),
+			unpause: (0, react.useCallback)(() => {
+				if (trapRef.current) {
+					trapRef.current.unpause();
+					setIsPaused(false);
+				}
+			}, [])
+		};
+	}
+	//#endregion
+	//#region useFuse/index.tsx
+	/**
+	* React port of VueUse's `useFuse` — easily implement fuzzy search with
+	* [Fuse.js](https://github.com/krisk/fuse).
+	*
+	* Map from @vueuse/integrations `useFuse`
+	* (`source/vueuse/packages/integrations/useFuse/`), a reactive wrapper around
+	* a `Fuse` instance. `search` and `data` are the hook's **read-only value
+	* sources** and take plain values (`string` and `readonly DataItem[]`; upstream:
+	* `MaybeRefOrGetter`). `options` stays `RefOrValue` (a config object, upstream
+	* `MaybeRefOrGetter`).
+	*
+	* Adjustment for React:
+	* - upstream returns `{ fuse: Ref<Fuse>, results: ComputedRef<FuseResult[]> }`;
+	*   here both are plain values read during render — `fuse` is the `Fuse`
+	*   instance itself (no `.value`), `results` is a plain array;
+	* - upstream rebuilds the index in `watch(() => toValue(options)?.fuseOptions,
+	*   …, { deep: true })` and refreshes the collection in `watch(() => toValue(data), …)`.
+	*   React has no deep watcher, and serializing `fuseOptions` to compare them by
+	*   value would break function-valued options (`sortFn`, `getFn`, `keys[].getFn`),
+	*   so the `Fuse` instance is memoized on the identity of the `data`
+	*   array and of `fuseOptions` instead: pass a NEW array reference when the data
+	*   changes, and a memoized `fuseOptions` object for best performance. Mutating
+	*   the data array in place is not detected (upstream's deep watch was);
+	* - `results` is memoized on the search string and the `data` identity, so a
+	*   changed `search`/`data` prop recomputes on the next render;
+	* - `options` is NOT widened: it is a config object (upstream
+	*   `MaybeRefOrGetter`, a maintainer decision), so a plain options object, a
+	*   ref-like `{ current }` object or a getter are the accepted forms.
+	*
+	* @param search - the search query
+	* @param data - the collection to search
+	* @param options - `fuseOptions` (forwarded to `new Fuse()`), `resultLimit`,
+	*   `matchAllWhenSearchEmpty`
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const { fuse, results } = useFuse(input, data, {
+	*   fuseOptions: { keys: ['firstName', 'lastName'] },
+	*   resultLimit: 10,
+	*   matchAllWhenSearchEmpty: true,
+	* })
+	* results[0].item // the best match
+	* fuse.search('john') // search the same index directly
+	*/
+	function useFuse(search, data, options) {
+		const dataValue = data;
+		const optionsValue = (0, _reause_shared.toValue)(options);
+		const fuse = (0, react.useMemo)(() => new fuse_js.default(dataValue, optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.fuseOptions), [dataValue, optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.fuseOptions]);
+		const searchValue = search;
+		return {
+			fuse,
+			results: (0, react.useMemo)(() => {
+				if ((optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.matchAllWhenSearchEmpty) && !searchValue) return dataValue.map((item, index) => ({
+					item,
+					refIndex: index
+				}));
+				const limit = optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.resultLimit;
+				return fuse.search(searchValue, limit ? { limit } : void 0);
+			}, [
+				dataValue,
+				fuse,
+				optionsValue,
+				searchValue
+			])
+		};
+	}
+	//#endregion
+	//#region useIDBKeyval/index.tsx
+	function defaultOnError(error) {
+		console.error(error);
+	}
+	function defaultSerializer() {
+		return {
+			read: (raw) => raw,
+			write: (value) => value
+		};
+	}
+	/**
+	* Reactive [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API)
+	* store — React port of VueUse's `useIDBKeyval`.
+	*
+	* Map from @vueuse/integrations `useIDBKeyval`
+	* (`source/vueuse/packages/integrations/useIDBKeyval/`), a reactive wrapper
+	* around [`idb-keyval`](https://github.com/jakearchibald/idb-keyval). The value
+	* is persisted under `key`, read once on mount and kept in sync across tabs
+	* through a `BroadcastChannel`.
+	*
+	* React divergences:
+	* - the upstream object return `{ data, isFinished, isSupported, set }` becomes
+	*   the state-like tuple `[data, setData, controls]` (§2B), mirroring
+	*   `useStorage`: `data` is `T | null` (`null` = removed) and `setData(null)`
+	*   deletes the key through `del`;
+	* - **there is no deep watcher.** Upstream writes on *any* mutation of
+	*   `data.value` (`watchPausable(data, write, { deep: true })`), so
+	*   `data.value.count++` persists by itself. React state has no deep
+	*   observation, so writes happen **explicitly through `setData`** — that is
+	*   the React contract. Mutating an object held in `data` in place does *not*
+	*   persist; call `setData(next)` with a new value instead. The `deep` /
+	*   `shallow` / `flush` options are accepted for parity and have no effect;
+	* - `isFinished` / `isSupported` live in the third tuple slot as plain
+	*   booleans (upstream: `ShallowRef` / `ComputedRef`), and `isSupported` is
+	*   computed synchronously (`typeof window !== 'undefined' && 'BroadcastChannel'
+	*   in window`) instead of going through `useSupported`, so a `BroadcastChannel`
+	*   is available on the first mount effect;
+	* - `initialValue` is the hook's **read-only value source** and takes a plain
+	*   `T` (upstream: `MaybeRefOrGetter<T>`); it is resolved once at mount, as
+	*   upstream's `toValue(initialValue)` is — the hook owns writes, so later
+	*   prop changes are ignored;
+	* - a `delete` message from another tab resets `data` to the initial value
+	*   (upstream parity) but does not re-write the store: incoming syncs never
+	*   write back, mirroring upstream's paused watcher;
+	* - the async read and the channel listener never set state after unmount.
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const [data, setData, { isFinished, isSupported }] = useIDBKeyval('my-store', { count: 0 })
+	*
+	* // explicit write (no deep watcher)
+	* setData({ count: 1 })
+	*
+	* // remove the key
+	* await setData(null)
+	*
+	* @see https://vueuse.org/integrations/useIDBKeyval/
+	*/
+	function useIDBKeyval(key, initialValue, options = {}) {
+		var _rawInitRef$current, _optionsRef$current$w;
+		const optionsRef = (0, react.useRef)(options);
+		const rawInitRef = (0, react.useRef)(void 0);
+		(_rawInitRef$current = rawInitRef.current) !== null && _rawInitRef$current !== void 0 || (rawInitRef.current = { value: initialValue });
+		const [data, setDataState] = (0, react.useState)(() => initialValue !== null && initialValue !== void 0 ? initialValue : null);
+		const [isFinished, setIsFinished] = (0, react.useState)(false);
+		const dataRef = (0, react.useRef)(data);
+		const channelRef = (0, react.useRef)(void 0);
+		const mountedRef = (0, react.useRef)(true);
+		const targetWindow = (_optionsRef$current$w = optionsRef.current.window) !== null && _optionsRef$current$w !== void 0 ? _optionsRef$current$w : typeof window !== "undefined" ? window : void 0;
+		const isSupported = !!targetWindow && "BroadcastChannel" in targetWindow;
+		const keyRef = (0, react.useRef)(key);
+		keyRef.current = key;
+		const getSerializer = (0, react.useCallback)(() => {
+			var _optionsRef$current$s;
+			return (_optionsRef$current$s = optionsRef.current.serializer) !== null && _optionsRef$current$s !== void 0 ? _optionsRef$current$s : defaultSerializer();
+		}, []);
+		const read = (0, react.useCallback)(async () => {
+			const { onError = defaultOnError, writeDefaults = true } = optionsRef.current;
+			const rawInit = rawInitRef.current.value;
+			const currentKey = key;
+			try {
+				const rawValue = await (0, idb_keyval.get)(currentKey);
+				if (!mountedRef.current || keyRef.current !== currentKey) return;
+				if (rawValue === void 0) {
+					if (rawInit !== void 0 && rawInit !== null && writeDefaults) await (0, idb_keyval.set)(currentKey, getSerializer().write(rawInit));
+				} else {
+					const value = getSerializer().read(rawValue);
+					dataRef.current = value;
+					setDataState(value);
+				}
+			} catch (error) {
+				if (mountedRef.current) onError(error);
+			}
+			if (mountedRef.current) setIsFinished(true);
+		}, [key, getSerializer]);
+		const write = (0, react.useCallback)(async (value) => {
+			const { onError = defaultOnError } = optionsRef.current;
+			try {
+				if (value == null) {
+					var _channelRef$current;
+					await (0, idb_keyval.del)(key);
+					(_channelRef$current = channelRef.current) === null || _channelRef$current === void 0 || _channelRef$current.postMessage({ type: "delete" });
+				} else {
+					var _channelRef$current2;
+					const serializedValue = getSerializer().write(value);
+					await (0, idb_keyval.update)(key, () => serializedValue);
+					(_channelRef$current2 = channelRef.current) === null || _channelRef$current2 === void 0 || _channelRef$current2.postMessage({
+						type: "set",
+						value: serializedValue
+					});
+				}
+			} catch (error) {
+				onError(error);
+			}
+		}, [key, getSerializer]);
+		const setData = (0, react.useCallback)(async (value) => {
+			dataRef.current = value;
+			if (mountedRef.current) setDataState(value);
+			await write(value);
+		}, [write]);
+		(0, react.useEffect)(() => {
+			mountedRef.current = true;
+			read();
+			return () => {
+				mountedRef.current = false;
+			};
+		}, [read]);
+		(0, react.useEffect)(() => {
+			const { onError = defaultOnError, listenToStorageChanges = true } = optionsRef.current;
+			if (!listenToStorageChanges || !isSupported) return;
+			const channel = new BroadcastChannel(`vueuse-idb-${JSON.stringify(key)}`);
+			channelRef.current = channel;
+			const onMessageEvent = (event) => {
+				var _event$data;
+				const { type, value } = (_event$data = event.data) !== null && _event$data !== void 0 ? _event$data : {};
+				try {
+					if (type === "delete") {
+						var _value;
+						const rawInit = (_value = rawInitRef.current.value) !== null && _value !== void 0 ? _value : null;
+						dataRef.current = rawInit;
+						setDataState(rawInit);
+					} else if (type === "set") {
+						const next = getSerializer().read(value);
+						dataRef.current = next;
+						setDataState(next);
+					}
+				} catch (error) {
+					onError(error);
+				}
+			};
+			channel.addEventListener("message", onMessageEvent, { passive: true });
+			return () => {
+				channel.removeEventListener("message", onMessageEvent);
+				if (channelRef.current === channel) channelRef.current = void 0;
+				channel.close();
+			};
+		}, [
+			key,
+			isSupported,
+			getSerializer
+		]);
+		return [
+			data,
+			setData,
+			{
+				isFinished,
+				isSupported
+			}
+		];
+	}
+	//#endregion
+	//#region useJwt/index.tsx
+	/**
+	* React port of VueUse's `useJwt`.
+	*
+	* Map from @vueuse/integrations `useJwt`
+	* (`source/vueuse/packages/integrations/useJwt/`), a wrapper for
+	* [`jwt-decode`](https://github.com/auth0/jwt-decode). `encodedJwt` is the
+	* hook's **read-only value source** and takes a plain string (upstream:
+	* `MaybeRefOrGetter<string>`); the decode is memoized on the token, so a
+	* stable token keeps `header`/`payload` referentially stable across renders.
+	*
+	* Adjustment for React:
+	* - upstream returns `{ header, payload }` as `ComputedRef`s; here the two
+	*   fields are plain decoded values (the issue's own `const { header, payload }
+	*   = useJwt(encodedJwt)` shape), so read them directly instead of `.value`;
+	* - `fallbackValue` defaults to `null`, and `onError` is kept in a ref so an
+	*   inline arrow callback does not churn the memo dependencies;
+	* - decoding happens during render, so under React StrictMode's dev
+	*   double-render a bad token may invoke `onError` twice. This is unavoidable
+	*   while decoding during render; guard the callback if it must fire once.
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @see https://vueuse.org/useJwt
+	* @example
+	* const { header, payload } = useJwt(encodedJwt)
+	* header.alg // 'HS256'
+	* payload.sub // '1234567890'
+	*/
+	function useJwt(encodedJwt, options = {}) {
+		const { onError, fallbackValue = null } = options;
+		const onErrorRef = (0, react.useRef)(onError);
+		onErrorRef.current = onError;
+		const fallbackValueRef = (0, react.useRef)(fallbackValue);
+		fallbackValueRef.current = fallbackValue;
+		const token = encodedJwt;
+		const decodeWithFallback = (value, jwtOptions) => {
+			try {
+				return (0, jwt_decode.jwtDecode)(value, jwtOptions);
+			} catch (err) {
+				var _onErrorRef$current;
+				(_onErrorRef$current = onErrorRef.current) === null || _onErrorRef$current === void 0 || _onErrorRef$current.call(onErrorRef, err);
+				return fallbackValueRef.current;
+			}
+		};
+		return {
+			header: (0, react.useMemo)(() => decodeWithFallback(token, { header: true }), [token]),
+			payload: (0, react.useMemo)(() => decodeWithFallback(token), [token])
+		};
+	}
+	//#endregion
+	//#region useNProgress/index.tsx
+	/**
+	* React port of VueUse's `useNProgress`.
+	*
+	* Map from @vueuse/integrations `useNProgress`
+	* (`source/vueuse/packages/integrations/useNProgress/index.ts`), a reactive
+	* wrapper around the [`nprogress`](https://github.com/rstacruz/nprogress)
+	* progress bar. `currentProgress` is the hook's **read-only value source** and
+	* takes a plain `number | null | undefined` (upstream: `MaybeRefOrGetter`).
+	*
+	* Adjustment for React:
+	* - the writable `WritableComputedRef<boolean>` `isLoading` and the
+	*   `Ref<number | null | undefined>` `progress` become plain state: `isLoading`
+	*   is derived (`typeof progress === 'number' && progress < 1`) and written
+	*   through `setIsLoading`, `progress` is a plain number written through
+	*   `setProgress`; the object return mirrors upstream's object of refs with
+	*   every writable value paired with its setter —
+	*   `{ progress, setProgress, isLoading, setIsLoading, start, done, remove }`;
+	* - the setters are React `Dispatch<SetStateAction<...>>`: each accepts a plain
+	*   value or a functional updater (`prev => next`), like a `useState` setter;
+	* - upstream monkey-patches the module-singleton `nprogress.set` so that its
+	*   internal `set` calls (`start` → `set(0)`, `done` → `set(1)`) write back
+	*   into `progress.value`, which is what makes `isLoading` flip. This port
+	*   never touches the global `nprogress.set`: `setProgress(n)` only sets the
+	*   state and the progress effect pushes the number into the bar once per
+	*   render, while `start` / `done` / `setIsLoading` mirror the same write-back
+	*   by hand (upstream's `start` only calls `set(0)` when the bar was idle, and
+	*   `done` only calls `set(1)` when it actually progresses) — so `isLoading`
+	*   flips exactly as upstream, without global pollution and safely with
+	*   concurrent hook instances;
+	* - `options` are applied once on mount (`nprogress.configure`), like
+	*   upstream's setup-time `if (options) nprogress.configure(options)`; later
+	*   `options` changes are not re-applied, matching the upstream setup
+	*   semantics;
+	* - a provided `currentProgress` is mirrored into the internal state (upstream's
+	*   `toRef`): a changed plain number re-syncs between renders, and a write
+	*   through `setProgress` / `start` / `done` is only superseded by a genuine
+	*   external change. Writes are **not** propagated back to the caller
+	*   (upstream's `toRef` writes through to a ref input); the source is
+	*   read-only here;
+	* - unmount runs `nprogress.remove()`, mirroring upstream's
+	*   `tryOnScopeDispose(nprogress.remove)`. `nprogress` is a module singleton,
+	*   so unmounting one hook instance removes the shared bar — the same
+	*   semantics as upstream.
+	*
+	* SSR-safe: `nprogress.set` is only called when `isClient` (upstream's
+	* `watchEffect` guard).
+	*
+	* @param currentProgress - initial progress percentage (`0..1`); a changed
+	*   plain value re-syncs on the next render
+	* @param options - `nprogress.configure` options, applied once on mount
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const { progress, setProgress, isLoading, setIsLoading, done, remove } = useNProgress()
+	* setIsLoading(true) // starts the bar, isLoading === true
+	* setProgress(0.5) // progress === 0.5, the bar renders at 50%
+	* setProgress(prev => (prev ?? 0) + 0.1) // functional updater, like a useState setter
+	* done() // progress === 1, isLoading === false
+	* remove() // progress === null, the #nprogress element is gone
+	*/
+	function useNProgress(currentProgress = null, options) {
+		const [progress, setProgressState] = (0, react.useState)(currentProgress);
+		const progressRef = (0, react.useRef)(currentProgress);
+		const updateProgress = (0, react.useCallback)((next) => {
+			progressRef.current = next;
+			setProgressState(next);
+		}, []);
+		const lastExternalRef = (0, react.useRef)(currentProgress);
+		(0, react.useEffect)(() => {
+			if (!Object.is(currentProgress, lastExternalRef.current)) {
+				lastExternalRef.current = currentProgress;
+				updateProgress(currentProgress);
+			}
+		});
+		const optionsRef = (0, react.useRef)(options);
+		optionsRef.current = options;
+		(0, react.useEffect)(() => {
+			if (optionsRef.current) nprogress.default.configure(optionsRef.current);
+		}, []);
+		(0, react.useEffect)(() => {
+			if (typeof progress === "number" && _reause_shared.isClient) nprogress.default.set(progress);
+		}, [progress]);
+		(0, react.useEffect)(() => () => {
+			nprogress.default.remove();
+		}, []);
+		const setProgress = (0, react.useCallback)((updater) => {
+			const next = typeof updater === "function" ? updater(progressRef.current) : updater;
+			updateProgress(next);
+		}, [updateProgress]);
+		const start = (0, react.useCallback)(() => {
+			const wasStarted = nprogress.default.isStarted();
+			const result = nprogress.default.start();
+			if (!wasStarted) updateProgress(0);
+			return result;
+		}, [updateProgress]);
+		const done = (0, react.useCallback)((force) => {
+			const status = nprogress.default.status;
+			const result = nprogress.default.done(force);
+			if (force || status) updateProgress(1);
+			return result;
+		}, [updateProgress]);
+		const setIsLoading = (0, react.useCallback)((updater) => {
+			if (typeof updater === "function" ? updater(typeof progressRef.current === "number" && progressRef.current < 1) : updater) start();
+			else done();
+		}, [start, done]);
+		const remove = (0, react.useCallback)(() => {
+			updateProgress(null);
+			nprogress.default.remove();
+		}, [updateProgress]);
+		return {
+			progress,
+			setProgress,
+			isLoading: typeof progress === "number" && progress < 1,
+			setIsLoading,
+			start,
+			done,
+			remove
+		};
+	}
+	//#endregion
+	//#region useQRCode/index.tsx
+	/**
+	* React port of VueUse's `useQRCode`.
+	*
+	* Map from @vueuse/integrations `useQRCode`
+	* (`source/vueuse/packages/integrations/useQRCode/`), a reactive wrapper
+	* around the `qrcode` package: it encodes `text` into a PNG data URL.
+	*
+	* Adjustment for React:
+	* - upstream returns a `shallowRef<string>` holding the data URL; in React the
+	*   asynchronous result is state, so the hook returns the plain `string` data
+	*   URL directly (no `.value`, no tuple) — `''` until the first encode
+	*   resolves. Exactly like upstream, an empty `text` never encodes, so the
+	*   previous data URL is kept (it is not cleared);
+	* - `text` is the hook's **read-only value source** and takes a plain string
+	*   (upstream: `MaybeRefOrGetter<string>`); a changed `text` prop re-encodes
+	*   on the next render;
+	* - the encode is `await`-free but guarded by a `cancelled` flag: when `text`
+	*   (or `options`) changes or the component unmounts while an encode is still
+	*   pending, the stale promise is ignored, so the last write always wins;
+	* - **pass a memoized `options` object** (`useMemo`/module constant). React has
+	*   no dependency-tracking equivalent of Vue's `watch` source, so `options` is
+	*   compared by identity: a fresh literal on every render re-runs the effect
+	*   and re-encodes the QR code. Options are deliberately not serialized — they
+	*   may contain non-JSON values (`toSJISFunc`, `color` functions…), which
+	*   serialization would break.
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @see https://vueuse.org/useQRCode
+	* @param text - the text to encode (plain string)
+	* @param options - `qrcode` `toDataURL` options, memoized by the caller
+	* @example
+	* const qrcode = useQRCode('https://vueuse.org')
+	* qrcode // '' at first, then 'data:image/png;base64,…'
+	*/
+	function useQRCode(text, options) {
+		const value = text;
+		const [result, setResult] = (0, react.useState)("");
+		(0, react.useEffect)(() => {
+			if (!value || !_reause_shared.isClient) return;
+			let cancelled = false;
+			qrcode.toDataURL(value, options).then((url) => {
+				if (!cancelled) setResult(url);
+			});
+			return () => {
+				cancelled = true;
+			};
+		}, [value, options]);
+		return result;
+	}
+	//#endregion
+	//#region useSortable/index.tsx
+	/**
+	* Resolve a target to a DOM element, or `null` when it cannot be resolved.
+	* Upstream resolves elements with `unrefElement` (`@vueuse/core`); the React
+	* port composes the same unwrapping from `toValue` / `isRefLike`
+	* (`@reause/shared`) — one pass unwraps a ref-like object, a second one
+	* covers a ref-like object holding another ref-like
+	* (`{ current: { current: element } }`).
+	*/
+	function resolveElement(value) {
+		let el = (0, _reause_shared.toValue)(value);
+		if ((0, _reause_shared.isRefLike)(el)) el = (0, _reause_shared.toValue)(el);
+		if (typeof el === "object" && el !== null && (el instanceof HTMLElement || el instanceof SVGElement)) return el;
+		return null;
+	}
+	/**
+	* React port of VueUse's `useSortable` — wrapper for
+	* [`sortablejs`](https://github.com/SortableJS/Sortable).
+	*
+	* Map from @vueuse/integrations `useSortable`
+	* (`source/vueuse/packages/integrations/useSortable/`), a reactive wrapper
+	* around the `sortablejs` package.
+	*
+	* Adjustment for React: the list is **immutable**. Upstream's
+	* `moveArrayElement` mutates the caller's array in place (deferring the splice
+	* through `nextTick` when the list is a ref), which cannot work in React —
+	* an in-place mutation does not re-render. The reause
+	* `moveArrayElement(list, from, to, e)` is pure: it returns a NEW reordered
+	* array (and still performs upstream's DOM fixup when an event is given), and
+	* the hook forwards that array to `options.onUpdate`.
+	*
+	* Adjustment for React: sortablejs manipulates DOM nodes directly, so the
+	* component must be a controlled list that re-renders from `onUpdate` — stable
+	* `key`s recommended — otherwise React and the DOM desync. Upstream's
+	* `onMounted` maps to a mount effect, `onScopeDispose` to the effect cleanup,
+	* and `watchElement` to an effect keyed on the resolved element identity.
+	*
+	* @param el target element, React ref object (`{ current }`), or CSS selector
+	* @param list current list items, in render order (never mutated)
+	* @param options sortablejs options plus `watchElement` / `document` / `onUpdate`
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @see https://github.com/SortableJS/Sortable#options
+	*/
+	function useSortable(el, list, options = {}) {
+		const { document = globalThis.document, watchElement = false, onUpdate, ...resetOptions } = options;
+		const instanceRef = (0, react.useRef)(void 0);
+		const listRef = (0, react.useRef)(list);
+		const onUpdateRef = (0, react.useRef)(onUpdate);
+		const optionsRef = (0, react.useRef)(resetOptions);
+		listRef.current = list;
+		onUpdateRef.current = onUpdate;
+		optionsRef.current = resetOptions;
+		const cleanup = (0, react.useCallback)(() => {
+			var _instanceRef$current;
+			(_instanceRef$current = instanceRef.current) === null || _instanceRef$current === void 0 || _instanceRef$current.destroy();
+			instanceRef.current = void 0;
+		}, []);
+		const initSortable = (0, react.useCallback)((target) => {
+			if (!target || instanceRef.current !== void 0) return;
+			instanceRef.current = new sortablejs.default(target, {
+				onUpdate: (e) => {
+					var _onUpdateRef$current;
+					const newList = moveArrayElement(listRef.current, e.oldIndex, e.newIndex, e);
+					(_onUpdateRef$current = onUpdateRef.current) === null || _onUpdateRef$current === void 0 || _onUpdateRef$current.call(onUpdateRef, newList, e);
+				},
+				...optionsRef.current
+			});
+		}, []);
+		const start = (0, react.useCallback)(() => {
+			const target = typeof el === "string" ? document === null || document === void 0 ? void 0 : document.querySelector(el) : resolveElement(el);
+			if (target) initSortable(target);
+		}, [
+			document,
+			el,
+			initSortable
+		]);
+		const stop = (0, react.useCallback)(() => {
+			cleanup();
+		}, [cleanup]);
+		const option = (0, react.useCallback)((name, value) => {
+			var _instanceRef$current2, _instanceRef$current3;
+			if (value !== void 0) (_instanceRef$current2 = instanceRef.current) === null || _instanceRef$current2 === void 0 || _instanceRef$current2.option(name, value);
+			else return (_instanceRef$current3 = instanceRef.current) === null || _instanceRef$current3 === void 0 ? void 0 : _instanceRef$current3.option(name);
+		}, []);
+		const resolved = typeof el === "string" ? el : resolveElement(el);
+		(0, react.useEffect)(() => {
+			if (!watchElement || typeof resolved === "string") return;
+			cleanup();
+			if (resolved) initSortable(resolved);
+			return cleanup;
+		}, [
+			cleanup,
+			initSortable,
+			resolved,
+			watchElement
+		]);
+		(0, react.useEffect)(() => {
+			if (watchElement && typeof el !== "string") return;
+			start();
+			return cleanup;
+		}, [
+			cleanup,
+			start,
+			watchElement,
+			el
+		]);
+		return {
+			start,
+			stop,
+			option
+		};
+	}
+	/**
+	* Inserts an 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);
+	}
+	/**
+	* Move an element of `list` from `from` to `to`, returning a NEW array.
+	*
+	* Map from @vueuse/integrations `useSortable`'s `moveArrayElement`, with one
+	* deliberate deviation: upstream mutates the caller's array in place (and
+	* defers the splice with `nextTick` when the list is a ref), which cannot work
+	* in React — an in-place mutation does not re-render. This implementation is
+	* pure: the input array is never mutated and the moved copy is returned. The
+	* move only happens when `to` is in range (`to >= 0 && to < list.length`,
+	* exactly upstream's bounds check); otherwise a copy of `list` is returned
+	* unchanged.
+	*
+	* The DOM fixup of upstream is kept for compatibility: when `e` is given (a
+	* sortablejs event), `e.item` is removed from the DOM and re-inserted at
+	* `from` inside `e.from`. That fixup runs regardless of the bounds check, as
+	* upstream does — note the upstream quirk of inserting at `from` rather than
+	* `to`. Pass `null` (or omit `e`) to only compute the array.
+	*
+	* @param list the current list — never mutated
+	* @param from source index
+	* @param to destination index
+	* @param e the sortablejs event to apply the DOM fixup for, if any
+	* @returns a new array with the element moved
+	*/
+	function moveArrayElement(list, from, to, e) {
+		if (e != null) {
+			removeNode(e.item);
+			insertNodeAt(e.from, e.item, from);
+		}
+		const array = [...list];
+		if (to >= 0 && to < array.length) {
+			const element = array.splice(from, 1)[0];
+			array.splice(to, 0, element);
+		}
+		return 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.reause = this.reause || {}, AsyncValidator, React, reause, axios, changeCase, UniversalCookie, Drauu, focusTrap, Fuse, idbKeyval, jwt_decode, nprogress, QRCode, Sortable);