@hairy/react-lib-composition 1.47.0 → 1.49.0

package/dist/index.cjs

@@ -1,487 +1,566 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Fragment: () => import_react9.Fragment,
-  TransitionGroup: () => TransitionGroup,
-  computed: () => computed,
-  customRef: () => customRef,
-  defineComponent: () => defineComponent,
-  effectScope: () => effectScope,
-  getCurrentInstance: () => getCurrentInstance,
-  getCurrentScope: () => getCurrentScope,
-  h: () => import_react9.createElement,
-  hasInjectionContext: () => hasInjectionContext,
-  inject: () => inject,
-  isProxy: () => import_reactivity8.isProxy,
-  isReactive: () => import_reactivity8.isReactive,
-  isReadonly: () => import_reactivity8.isReadonly,
-  isRef: () => import_reactivity8.isRef,
-  isShallow: () => import_reactivity8.isShallow,
-  markRaw: () => import_reactivity8.markRaw,
-  nextTick: () => nextTick,
-  onBeforeMount: () => onBeforeMount,
-  onBeforeUnmount: () => onBeforeUnmount,
-  onBeforeUpdate: () => onBeforeUpdate,
-  onMounted: () => onMounted,
-  onScopeDispose: () => onScopeDispose,
-  onUnmounted: () => onUnmounted,
-  onUpdated: () => onUpdated,
-  provide: () => provide,
-  reactive: () => reactive,
-  reactivity: () => reactivity,
-  readonly: () => readonly,
-  ref: () => ref,
-  shallowReactive: () => shallowReactive,
-  shallowReadonly: () => shallowReadonly,
-  shallowRef: () => shallowRef,
-  toRaw: () => import_reactivity8.toRaw,
-  toReactive: () => import_reactivity8.toReactive,
-  toReadonly: () => import_reactivity8.toReadonly,
-  toRef: () => import_reactivity8.toRef,
-  toRefs: () => import_reactivity8.toRefs,
-  toValue: () => import_reactivity8.toValue,
-  unref: () => import_reactivity8.unref,
-  watch: () => watch,
-  watchEffect: () => watchEffect,
-  withEffectScope: () => withEffectScope
-});
-module.exports = __toCommonJS(index_exports);
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var freeGlobal_default = freeGlobal;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = freeGlobal_default || freeSelf || Function("return this")();
-var root_default = root;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
-var Symbol2 = root_default.Symbol;
-var Symbol_default = Symbol2;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var nativeObjectToString = objectProto.toString;
-var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  try {
-    value[symToStringTag] = void 0;
-    var unmasked = true;
-  } catch (e) {
-  }
-  var result = nativeObjectToString.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag] = tag;
-    } else {
-      delete value[symToStringTag];
-    }
-  }
-  return result;
-}
-var getRawTag_default = getRawTag;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
-var objectProto2 = Object.prototype;
-var nativeObjectToString2 = objectProto2.toString;
-function objectToString(value) {
-  return nativeObjectToString2.call(value);
-}
-var objectToString_default = objectToString;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
-var nullTag = "[object Null]";
-var undefinedTag = "[object Undefined]";
-var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
-function baseGetTag(value) {
-  if (value == null) {
-    return value === void 0 ? undefinedTag : nullTag;
-  }
-  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
-}
-var baseGetTag_default = baseGetTag;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js
-function isObject(value) {
-  var type = typeof value;
-  return value != null && (type == "object" || type == "function");
-}
-var isObject_default = isObject;
-
-// ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isFunction.js
-var asyncTag = "[object AsyncFunction]";
-var funcTag = "[object Function]";
-var genTag = "[object GeneratorFunction]";
-var proxyTag = "[object Proxy]";
-function isFunction(value) {
-  if (!isObject_default(value)) {
-    return false;
-  }
-  var tag = baseGetTag_default(value);
-  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
-}
-var isFunction_default = isFunction;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _hairy_utils = require("@hairy/utils");
+let react = require("react");
+let _vue_reactivity = require("@vue/reactivity");
 
-// ../util-core/src/util/noop.ts
-var noop = () => {
-};
-
-// ../lib-react/src/hooks/tryUseCallback.ts
-var import_react = require("react");
-var tryUseCallback = (callback, deps) => {
-  try {
-    return (0, import_react.useCallback)(callback, deps);
-  } catch {
-    return callback;
-  }
+//#region ../lib-react/src/hooks/tryUseCallback.ts
+const tryUseCallback = (callback, deps) => {
+	try {
+		return (0, react.useCallback)(callback, deps);
+	} catch {
+		return callback;
+	}
 };
 
-// ../lib-react/src/hooks/tryUseEffect.ts
-var import_react2 = require("react");
-var tryUseEffect = (effect, deps) => {
-  try {
-    (0, import_react2.useEffect)(effect, deps);
-  } catch {
-  }
+//#endregion
+//#region ../lib-react/src/hooks/tryUseEffect.ts
+const tryUseEffect = (effect, deps) => {
+	try {
+		(0, react.useEffect)(effect, deps);
+	} catch {}
 };
 
-// ../lib-react/src/hooks/tryUseInsertionEffect.ts
-var import_react3 = require("react");
-var tryUseInsertionEffect = (callback, deps) => {
-  try {
-    (0, import_react3.useInsertionEffect)(callback, deps);
-  } catch {
-  }
+//#endregion
+//#region ../lib-react/src/hooks/tryUseInsertionEffect.ts
+const tryUseInsertionEffect = (callback, deps) => {
+	try {
+		(0, react.useInsertionEffect)(callback, deps);
+	} catch {}
 };
 
-// ../lib-react/src/hooks/tryUseReducer.ts
-var import_react4 = require("react");
-var tryUseReducer = (reducer, initializerArg, initializer) => {
-  try {
-    return (0, import_react4.useReducer)(reducer, initializerArg, initializer);
-  } catch {
-    return [initializerArg, () => {
-    }];
-  }
+//#endregion
+//#region ../lib-react/src/hooks/tryUseReducer.ts
+const tryUseReducer = (reducer, initializerArg, initializer) => {
+	try {
+		return (0, react.useReducer)(reducer, initializerArg, initializer);
+	} catch {
+		return [initializerArg, () => {}];
+	}
 };
 
-// ../lib-react/src/hooks/tryUseRef.ts
-var import_react5 = require("react");
-var tryUseRef = (initialValue) => {
-  try {
-    return (0, import_react5.useRef)(initialValue);
-  } catch {
-    return { current: initialValue };
-  }
+//#endregion
+//#region ../lib-react/src/hooks/tryUseRef.ts
+const tryUseRef = (initialValue) => {
+	try {
+		return (0, react.useRef)(initialValue);
+	} catch {
+		return { current: initialValue };
+	}
 };
 
-// ../lib-react/src/hooks/tryUseState.ts
-var import_react6 = require("react");
-var tryUseState = (initialState) => {
-  try {
-    return (0, import_react6.useState)(initialState);
-  } catch {
-    return [isFunction_default(initialState) ? initialState() : initialState, noop];
-  }
+//#endregion
+//#region ../lib-react/src/hooks/tryUseState.ts
+const tryUseState = (initialState) => {
+	try {
+		return (0, react.useState)(initialState);
+	} catch {
+		return [(0, _hairy_utils.isFunction)(initialState) ? initialState() : initialState, _hairy_utils.noop];
+	}
 };
 
-// ../lib-react/src/hooks/useUpdate.ts
-var updateReducer = (num) => (num + 1) % 1e6;
+//#endregion
+//#region ../lib-react/src/hooks/useUpdate.ts
+const updateReducer = (num) => (num + 1) % 1e6;
 function useUpdate() {
-  const [, update] = tryUseReducer(updateReducer, 0);
-  return update;
+	const [, update] = tryUseReducer(updateReducer, 0);
+	return update;
 }
 
-// ../lib-react/src/hooks/tryUseUpdate.ts
+//#endregion
+//#region ../lib-react/src/hooks/tryUseUpdate.ts
 function tryUseUpdate() {
-  try {
-    return useUpdate();
-  } catch {
-    return () => {
-    };
-  }
+	try {
+		return useUpdate();
+	} catch {
+		return () => {};
+	}
 }
 
-// src/computed.ts
-var import_reactivity2 = require("@vue/reactivity");
-
-// src/watch.ts
-var import_reactivity = require("@vue/reactivity");
-
-// src/lifecycle.ts
+//#endregion
+//#region src/lifecycle.ts
+/**
+* The function is called right after the component is mounted.
+*
+* @param fn
+* @see {@link https://react.dev/reference/react/Component#componentdidmount React `componentDidMount()`}
+*/
 function onMounted(fn) {
-  tryUseEffect(() => {
-    fn();
-  }, []);
+	tryUseEffect(() => {
+		fn();
+	}, []);
 }
 function onBeforeMount(fn) {
-  const isMounted = tryUseRef(false);
-  if (!isMounted.current) {
-    fn();
-    isMounted.current = true;
-  }
+	const isMounted = tryUseRef(false);
+	if (!isMounted.current) {
+		fn();
+		isMounted.current = true;
+	}
 }
+/**
+* The function is called right before the component is unmounted.
+*
+* @param fn
+* @see {@link https://react.dev/reference/react/Component#componentwillunmount React `componentWillUnmount()`}
+*/
 function onBeforeUnmount(fn) {
-  tryUseEffect(() => {
-    return () => {
-      fn();
-    };
-  }, []);
+	tryUseEffect(() => {
+		return () => {
+			fn();
+		};
+	}, []);
 }
 function onUnmounted(fn) {
-  onBeforeUnmount(() => setTimeout(fn, 0));
+	onBeforeUnmount(() => setTimeout(fn, 0));
 }
+/**
+* The function is called immediately after the component is re-rendered with updated props or state.
+* This method is not invoked during the initial render.
+*
+* @param fn
+* @see {@link https://react.dev/reference/react/Component#componentdidupdate React `componentDidUpdate()`}
+*/
 function onUpdated(fn) {
-  const isMounted = tryUseRef(false);
-  tryUseEffect(() => {
-    isMounted.current ? fn() : isMounted.current = true;
-  });
+	const isMounted = tryUseRef(false);
+	tryUseEffect(() => {
+		isMounted.current ? fn() : isMounted.current = true;
+	});
 }
 function onBeforeUpdate(fn) {
-  tryUseInsertionEffect(fn);
+	tryUseInsertionEffect(fn);
 }
 
-// src/watch.ts
+//#endregion
+//#region src/watch.ts
 function watch(source, callback, options = {}) {
-  const handle = tryUseRef(void 0);
-  const cancel = tryUseCallback(() => {
-    if (!handle.current)
-      return;
-    handle.current();
-    handle.current = void 0;
-  }, []);
-  const create = tryUseCallback(() => {
-    handle.current && cancel();
-    handle.current = (0, import_reactivity.watch)(
-      source,
-      callback,
-      {
-        ...options,
-        scheduler: (job) => job()
-      }
-    );
-    cancel.pause = handle.current.pause;
-    cancel.resume = handle.current.resume;
-    cancel.stop = handle.current.stop;
-  }, []);
-  !handle.current && create();
-  onMounted(create);
-  onBeforeUnmount(cancel);
-  return cancel;
+	const handle = tryUseRef(void 0);
+	const cancel = tryUseCallback(() => {
+		if (!handle.current) return;
+		handle.current();
+		handle.current = void 0;
+	}, []);
+	const create = tryUseCallback(() => {
+		handle.current && cancel();
+		handle.current = (0, _vue_reactivity.watch)(source, callback, {
+			...options,
+			scheduler: (job) => job()
+		});
+		cancel.pause = handle.current.pause;
+		cancel.resume = handle.current.resume;
+		cancel.stop = handle.current.stop;
+	}, []);
+	!handle.current && create();
+	onMounted(create);
+	onBeforeUnmount(cancel);
+	return cancel;
 }
 
-// src/computed.ts
+//#endregion
+//#region src/computed.ts
 function computed(arg1, arg2) {
-  const [ref2] = tryUseState(() => (0, import_reactivity2.computed)(arg1, arg2));
-  watch(ref2, tryUseUpdate());
-  return ref2;
+	const [ref] = tryUseState(() => (0, _vue_reactivity.computed)(arg1, arg2));
+	watch(ref, tryUseUpdate());
+	return ref;
 }
 
-// src/effectScope.ts
-var import_reactivity3 = require("@vue/reactivity");
-var import_react7 = require("react");
-var activeEffectScope;
+//#endregion
+//#region src/effectScope.ts
+let activeEffectScope;
 function createVueEffectScope(...args) {
-  const scope = (0, import_reactivity3.effectScope)(...args);
-  Reflect.set(scope, "parent", activeEffectScope);
-  if (!args[0] && activeEffectScope) {
-    const scopes = activeEffectScope.scopes || (activeEffectScope.scopes = []);
-    Reflect.set(scope, "index", scopes.push(scope) - 1);
-  }
-  return scope;
+	const scope = (0, _vue_reactivity.effectScope)(...args);
+	Reflect.set(scope, "parent", activeEffectScope);
+	if (!args[0] && activeEffectScope) {
+		const scopes = activeEffectScope.scopes || (activeEffectScope.scopes = []);
+		Reflect.set(scope, "index", scopes.push(scope) - 1);
+	}
+	return scope;
 }
+/**
+* Creates an effect scope object which can capture the reactive effects (i.e.
+* computed and watchers) created within it so that these effects can be
+* disposed together. For detailed use cases of this API, please consult its
+* corresponding {@link https://github.com/vuejs/rfcs/blob/master/active-rfcs/0041-reactivity-effect-scope.md | RFC}.
+*
+* @param detached - Can be used to create a "detached" effect scope.
+* @see {@link https://vuejs.org/api/reactivity-advanced.html#effectscope Vue `effectScope()`}
+*/
 function effectScope(...args) {
-  const hasRun = tryUseRef(false);
-  const [scope] = tryUseState(() => createVueEffectScope(...args));
-  const originalRunRef = tryUseRef(scope.run);
-  const runFn = tryUseCallback((fn) => {
-    if (!hasRun.current) {
-      hasRun.current = true;
-      return originalRunRef.current.bind(scope)(fn);
-    } else {
-      return void 0;
-    }
-  }, []);
-  scope.run = runFn;
-  return scope;
+	const hasRun = tryUseRef(false);
+	const [scope] = tryUseState(() => createVueEffectScope(...args));
+	const originalRunRef = tryUseRef(scope.run);
+	scope.run = tryUseCallback((fn) => {
+		if (!hasRun.current) {
+			hasRun.current = true;
+			return originalRunRef.current.bind(scope)(fn);
+		} else return;
+	}, []);
+	return scope;
 }
 function withEffectScope(fn, detached) {
-  let currentEffectScope;
-  return (...props) => {
-    const scope = effectScope(detached);
-    const element = (0, import_react7.createElement)(fn, ...props);
-    onBeforeMount(() => {
-      currentEffectScope = activeEffectScope;
-      activeEffectScope = scope;
-    });
-    onMounted(() => activeEffectScope = currentEffectScope);
-    onUnmounted(() => scope.stop());
-    return element;
-  };
+	let currentEffectScope;
+	return ((...props) => {
+		const scope = effectScope(detached);
+		const element = (0, react.createElement)(fn, ...props);
+		onBeforeMount(() => {
+			currentEffectScope = activeEffectScope;
+			activeEffectScope = scope;
+		});
+		onMounted(() => activeEffectScope = currentEffectScope);
+		onUnmounted(() => scope.stop());
+		return element;
+	});
 }
+/**
+* Returns the current active effect scope if there is one.
+*
+* @see {@link https://vuejs.org/api/reactivity-advanced.html#getcurrentscope}
+*/
 function getCurrentScope() {
-  const [effectScope2] = tryUseState(() => activeEffectScope || (0, import_reactivity3.getCurrentScope)());
-  return effectScope2;
+	const [effectScope] = tryUseState(() => activeEffectScope || (0, _vue_reactivity.getCurrentScope)());
+	return effectScope;
 }
+/**
+* Registers a dispose callback on the current active effect scope. The
+* callback will be invoked when the associated effect scope is stopped.
+*
+* @param fn - The callback function to attach to the scope's cleanup.
+* @see {@link https://vuejs.org/api/reactivity-advanced.html#onscopedispose}
+*/
 function onScopeDispose(fn, _failSilently = false) {
-  if (activeEffectScope)
-    Reflect.get(activeEffectScope, "cleanups")?.push(fn);
+	if (activeEffectScope) Reflect.get(activeEffectScope, "cleanups")?.push(fn);
 }
 
-// src/reactive.ts
-var import_reactivity4 = require("@vue/reactivity");
-var import_react8 = require("react");
+//#endregion
+//#region src/reactive.ts
 function reactive(target) {
-  const [value] = (0, import_react8.useState)(() => (0, import_reactivity4.reactive)(target));
-  watch(value, tryUseUpdate());
-  return value;
+	const [value] = (0, react.useState)(() => (0, _vue_reactivity.reactive)(target));
+	watch(value, tryUseUpdate());
+	return value;
 }
+/**
+* Shallow version of {@link reactive()}.
+*
+* Unlike {@link reactive()}, there is no deep conversion: only root-level
+* properties are reactive for a shallow reactive object. Property values are
+* stored and exposed as-is - this also means properties with ref values will
+* not be automatically unwrapped.
+*
+* @param target - The source object.
+* @see {@link https://vuejs.org/api/reactivity-advanced.html#shallowreactive Vue `shallowReactive()`}
+*
+* @example
+* ```js
+* const state = shallowReactive({
+*   foo: 1,
+*   nested: {
+*     bar: 2
+*   }
+* })
+*
+* // mutating state's own properties is reactive
+* state.foo++
+*
+* // ...but does not convert nested objects
+* isReactive(state.nested) // false
+*
+* // NOT reactive
+* state.nested.bar++
+* ```
+*/
 function shallowReactive(target) {
-  const [value] = (0, import_react8.useState)(() => (0, import_reactivity4.shallowReactive)(target));
-  watch(value, tryUseUpdate());
-  return value;
+	const [value] = (0, react.useState)(() => (0, _vue_reactivity.shallowReactive)(target));
+	watch(value, tryUseUpdate());
+	return value;
 }
 
-// src/reactivity.ts
+//#endregion
+//#region src/reactivity.ts
+/**
+* Converts some of the 'raw Vue' data, which is not already wrapped in a hook,
+* into reactive hook data to ensure proper reactivity within the component.
+*
+* @param getter - A function that returns the data to be deeply watched.
+* @example
+* ```tsx
+* import React from 'react'
+* import { ref, reactivity } from 'veact'
+*
+* const countRef = ref(0)
+*
+* export const Component: React.FC = () => {
+*   // Convert to a reactivity hook
+*   const count = reactivity(() => countRef)
+*   const increment = () => {
+*     count.value++
+*   }
+*
+*   return (
+*     <div>
+*       <span>{count.value}</span>
+*       <button onClick={increment}>Increment</button>
+*     </div>
+*   )
+* }
+* ```
+*/
 function reactivity(getter) {
-  watch(() => getter(), tryUseUpdate(), { deep: true });
-  return getter();
+	watch(() => getter(), tryUseUpdate(), { deep: true });
+	return getter();
 }
 
-// src/readonly.ts
-var import_reactivity5 = require("@vue/reactivity");
+//#endregion
+//#region src/readonly.ts
+/**
+* Takes an object (reactive or plain) or a ref and returns a readonly proxy to
+* the original.
+*
+* A readonly proxy is deep: any nested property accessed will be readonly as
+* well. It also has the same ref-unwrapping behavior as {@link reactive()},
+* except the unwrapped values will also be made readonly.
+*
+* @param target - The source object.
+* @see {@link https://vuejs.org/api/reactivity-core.html#readonly Vue `readonly()`}
+*
+* @example
+* ```js
+* const original = reactive({ count: 0 })
+* const copy = readonly(original)
+*
+* useWatchEffect(() => {
+*   // works for reactivity tracking
+*   console.log(copy.count)
+* })
+*
+* // mutating original will trigger watchers relying on the copy
+* original.count++
+*
+* // mutating the copy will fail and result in a warning
+* copy.count++ // warning!
+* ```
+*/
 function readonly(target) {
-  const [value] = tryUseState(() => (0, import_reactivity5.readonly)(target));
-  watch(value, tryUseUpdate());
-  return value;
+	const [value] = tryUseState(() => (0, _vue_reactivity.readonly)(target));
+	watch(value, tryUseUpdate());
+	return value;
 }
+/**
+* Shallow version of {@link readonly()}.
+*
+* Unlike {@link readonly()}, there is no deep conversion: only root-level
+* properties are made readonly. Property values are stored and exposed as-is -
+* this also means properties with ref values will not be automatically
+* unwrapped.
+*
+* @param target - The source object.
+* @see {@link https://vuejs.org/api/reactivity-advanced.html#shallowreadonly Vue `shallowReadonly()`}
+*
+* @example
+* ```js
+* const state = shallowReadonly({
+*   foo: 1,
+*   nested: {
+*     bar: 2
+*   }
+* })
+*
+* // mutating state's own properties will fail
+* state.foo++
+*
+* // ...but works on nested objects
+* isReadonly(state.nested) // false
+*
+* // works
+* state.nested.bar++
+* ```
+*/
 function shallowReadonly(target) {
-  const [value] = tryUseState(() => (0, import_reactivity5.shallowReadonly)(target));
-  watch(value, tryUseUpdate());
-  return value;
+	const [value] = tryUseState(() => (0, _vue_reactivity.shallowReadonly)(target));
+	watch(value, tryUseUpdate());
+	return value;
 }
 
-// src/ref.ts
-var import_reactivity6 = require("@vue/reactivity");
+//#endregion
+//#region src/ref.ts
 function ref(initValue) {
-  const [ref2] = tryUseState(() => {
-    const r = (0, import_reactivity6.ref)(initValue);
-    Object.defineProperty(r, "current", { set: (value) => r.value = value });
-    return r;
-  });
-  watch(ref2, tryUseUpdate(), { deep: true });
-  return ref2;
+	const [ref] = tryUseState(() => {
+		const r = (0, _vue_reactivity.ref)(initValue);
+		Object.defineProperty(r, "current", { set: (value) => r.value = value });
+		return r;
+	});
+	watch(ref, tryUseUpdate(), { deep: true });
+	return ref;
 }
+/**
+* Creates a customized ref with explicit control over its dependency tracking
+* and updates triggering.
+*
+* @param factory - The function that receives the `track` and `trigger` callbacks.
+* @see {@link https://vuejs.org/api/reactivity-advanced.html#customref Vue `customRef()`}
+*/
 function customRef(factory) {
-  const [ref2] = tryUseState(() => (0, import_reactivity6.customRef)(factory));
-  watch(ref2, tryUseUpdate());
-  return ref2;
+	const [ref] = tryUseState(() => (0, _vue_reactivity.customRef)(factory));
+	watch(ref, tryUseUpdate());
+	return ref;
 }
 function shallowRef(initValue) {
-  const [ref2] = tryUseState(() => (0, import_reactivity6.shallowRef)(initValue));
-  watch(ref2, tryUseUpdate());
-  return ref2;
+	const [ref] = tryUseState(() => (0, _vue_reactivity.shallowRef)(initValue));
+	watch(ref, tryUseUpdate());
+	return ref;
 }
 
-// src/watchEffect.ts
-var import_reactivity7 = require("@vue/reactivity");
+//#endregion
+//#region src/watchEffect.ts
+/**
+* Runs a function immediately while reactively tracking its dependencies and re-runs it whenever the dependencies are changed.
+*
+* @param effect - The effect function to run.
+* @param options - An optional options object that can be used to adjust the effect's flush timing or to debug the effect's dependencies; the `flush` option is not supported compared to Vue (3.5.0).
+* @see {@link https://vuejs.org/api/reactivity-core.html#watcheffect Vue `watchEffect()`}
+*
+* @example
+* ```js
+* const count = useRef(0)
+* watchEffect(() => console.log(count.value))
+* // -> logs 0
+*
+* count.value++
+* // -> logs 1
+* ```
+*/
 function watchEffect(effect, options = {}) {
-  const [watchHandle] = tryUseState(() => (0, import_reactivity7.watch)(effect, null, {
-    ...options,
-    scheduler: (job) => job()
-  }));
-  onBeforeUnmount(() => watchHandle.stop());
-  return watchHandle;
+	const [watchHandle] = tryUseState(() => (0, _vue_reactivity.watch)(effect, null, {
+		...options,
+		scheduler: (job) => job()
+	}));
+	onBeforeUnmount(() => watchHandle.stop());
+	return watchHandle;
 }
 
-// src/index.ts
-var import_reactivity8 = require("@vue/reactivity");
-var import_react9 = require("react");
-var getCurrentInstance = noop;
-var hasInjectionContext = noop;
-var inject = noop;
-var provide = noop;
-var nextTick = noop;
-var defineComponent = noop;
-var TransitionGroup = noop;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Fragment,
-  TransitionGroup,
-  computed,
-  customRef,
-  defineComponent,
-  effectScope,
-  getCurrentInstance,
-  getCurrentScope,
-  h,
-  hasInjectionContext,
-  inject,
-  isProxy,
-  isReactive,
-  isReadonly,
-  isRef,
-  isShallow,
-  markRaw,
-  nextTick,
-  onBeforeMount,
-  onBeforeUnmount,
-  onBeforeUpdate,
-  onMounted,
-  onScopeDispose,
-  onUnmounted,
-  onUpdated,
-  provide,
-  reactive,
-  reactivity,
-  readonly,
-  ref,
-  shallowReactive,
-  shallowReadonly,
-  shallowRef,
-  toRaw,
-  toReactive,
-  toReadonly,
-  toRef,
-  toRefs,
-  toValue,
-  unref,
-  watch,
-  watchEffect,
-  withEffectScope
-});
-/*! Bundled license information:
+//#endregion
+//#region src/index.ts
+const getCurrentInstance = _hairy_utils.noop;
+const hasInjectionContext = _hairy_utils.noop;
+const inject = _hairy_utils.noop;
+const provide = _hairy_utils.noop;
+const nextTick = _hairy_utils.noop;
+const defineComponent = _hairy_utils.noop;
+const TransitionGroup = _hairy_utils.noop;
 
-lodash-es/lodash.js:
-  (**
-   * @license
-   * Lodash (Custom Build) <https://lodash.com/>
-   * Build: `lodash modularize exports="es" -o ./`
-   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
-   * Released under MIT license <https://lodash.com/license>
-   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
-   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-   *)
-*/
+//#endregion
+Object.defineProperty(exports, 'Fragment', {
+  enumerable: true,
+  get: function () {
+    return react.Fragment;
+  }
+});
+exports.TransitionGroup = TransitionGroup;
+exports.computed = computed;
+exports.customRef = customRef;
+exports.defineComponent = defineComponent;
+exports.effectScope = effectScope;
+exports.getCurrentInstance = getCurrentInstance;
+exports.getCurrentScope = getCurrentScope;
+Object.defineProperty(exports, 'h', {
+  enumerable: true,
+  get: function () {
+    return react.createElement;
+  }
+});
+exports.hasInjectionContext = hasInjectionContext;
+exports.inject = inject;
+Object.defineProperty(exports, 'isProxy', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.isProxy;
+  }
+});
+Object.defineProperty(exports, 'isReactive', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.isReactive;
+  }
+});
+Object.defineProperty(exports, 'isReadonly', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.isReadonly;
+  }
+});
+Object.defineProperty(exports, 'isRef', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.isRef;
+  }
+});
+Object.defineProperty(exports, 'isShallow', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.isShallow;
+  }
+});
+Object.defineProperty(exports, 'markRaw', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.markRaw;
+  }
+});
+exports.nextTick = nextTick;
+exports.onBeforeMount = onBeforeMount;
+exports.onBeforeUnmount = onBeforeUnmount;
+exports.onBeforeUpdate = onBeforeUpdate;
+exports.onMounted = onMounted;
+exports.onScopeDispose = onScopeDispose;
+exports.onUnmounted = onUnmounted;
+exports.onUpdated = onUpdated;
+exports.provide = provide;
+exports.reactive = reactive;
+exports.reactivity = reactivity;
+exports.readonly = readonly;
+exports.ref = ref;
+exports.shallowReactive = shallowReactive;
+exports.shallowReadonly = shallowReadonly;
+exports.shallowRef = shallowRef;
+Object.defineProperty(exports, 'toRaw', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.toRaw;
+  }
+});
+Object.defineProperty(exports, 'toReactive', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.toReactive;
+  }
+});
+Object.defineProperty(exports, 'toReadonly', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.toReadonly;
+  }
+});
+Object.defineProperty(exports, 'toRef', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.toRef;
+  }
+});
+Object.defineProperty(exports, 'toRefs', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.toRefs;
+  }
+});
+Object.defineProperty(exports, 'toValue', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.toValue;
+  }
+});
+Object.defineProperty(exports, 'unref', {
+  enumerable: true,
+  get: function () {
+    return _vue_reactivity.unref;
+  }
+});
+exports.watch = watch;
+exports.watchEffect = watchEffect;
+exports.withEffectScope = withEffectScope;