@reause/math 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hairyf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,585 @@
+//#region useProjection/index.d.ts
+/**
+ * Projection function type — `ProjectorFunction<F, T>` maps an input from the
+ * source domain to the target domain.
+ */
+export type ProjectorFunction<F, T> = (input: F, from: readonly [F, F], to: readonly [T, T]) => T;
+/**
+ * React port of VueUse's `useProjection`.
+ *
+ * Map from @vueuse/math `useProjection`
+ * Mapping: `ComputedRef<number>` → plain number recomputed from the current
+ * value on every render; pure derived value — no reactive `.value`, the caller
+ * drives re-renders.
+ *
+ * React divergence: `input`, `fromDomain` and `toDomain` are all plain
+ * read-only values, not upstream's `MaybeRefOrGetter<...>`. In particular the
+ * getter form (`() => number`) is NOT accepted — getters as data sources are
+ * rejected repo-wide (issue #462). The caller re-renders with new values (e.g.
+ * from `useState`) and the hook recomputes. Like upstream, the projection is
+ * delegated to `createProjection` (its default projector is the linear numeric
+ * projector), so the projector function is not duplicated here.
+ *
+ * @param input - The input value to project.
+ * @param fromDomain - The source domain (a plain `readonly [number, number]`).
+ * @param toDomain - The target domain (a plain `readonly [number, number]`).
+ * @param projector - The projector function (defaults to the linear numeric projector).
+ * @returns The projected number.
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const projected = useProjection(5, [0, 10], [0, 100]) // 50
+ */
+export declare function useProjection(input: number, fromDomain: readonly [number, number], toDomain: readonly [number, number], projector?: ProjectorFunction<number, number>): number;
+//#endregion
+//#region createGenericProjection/index.d.ts
+/**
+ * A projector built by `createGenericProjection`: takes the input value and
+ * returns the projected value of type `T`.
+ */
+export type UseProjection<F, T> = (input: F) => T;
+/**
+ * React port of VueUse's `createGenericProjection`.
+ *
+ * Map from @vueuse/math `createGenericProjection`
+ * Mapping: `ComputedRef<T>` → a plain projector function returning a plain `T`.
+ * React has no reactive graph, so the returned projector recomputes the
+ * projection on every call (nothing is memoized) and the caller drives
+ * re-renders. Domains and input are plain values (`MaybeRefOrGetter` is not
+ * supported) — re-create the projector when a domain changes.
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const projector = createGenericProjection(
+ *   [0, 10],
+ *   ['low', 'high'],
+ *   (input, from, to) => (input > (from[0] + from[1]) / 2 ? to[1] : to[0]),
+ * )
+ * projector(8) // 'high'
+ */
+export declare function createGenericProjection<F = number, T = number>(fromDomain: readonly [F, F], toDomain: readonly [T, T], projector: ProjectorFunction<F, T>): UseProjection<F, T>;
+//#endregion
+//#region createProjection/index.d.ts
+/**
+ * React port of VueUse's `createProjection`.
+ *
+ * Map from @vueuse/math `createProjection`
+ * Mapping: `ComputedRef<number>` → a plain projector function returning a plain
+ * `number`. React has no reactive graph, so the returned projector recomputes
+ * the numeric projection on every call and the caller drives re-renders; the
+ * domains are plain values (`MaybeRefOrGetter` is not supported) — re-create the
+ * projector when a domain changes. Delegates to `createGenericProjection` with
+ * the default numeric projector.
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const projector = createProjection([0, 10], [0, 100])
+ * projector(5) // 50
+ */
+export declare function createProjection(fromDomain: readonly [number, number], toDomain: readonly [number, number], projector?: ProjectorFunction<number, number>): UseProjection<number, number>;
+//#endregion
+//#region logicAnd/index.d.ts
+/**
+ * `AND` condition for values — `true` only when every argument is truthy.
+ *
+ * Map from @vueuse/math `logicAnd`
+ * (`source/vueuse/packages/math/logicAnd/`). Upstream wraps the evaluation in
+ * `computed(() => ...)` and returns a `ComputedRef<boolean>`; the reause
+ * version is a pure function that evaluates every plain argument and returns a
+ * plain `boolean` on each call — there is no reactivity, so re-renders (or
+ * effects) drive re-evaluation (SSR-safe).
+ *
+ * React divergence: arguments are plain values, not upstream's
+ * `MaybeRefOrGetter<any>[]`.
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * logicAnd(true, 1, 'foo') // true
+ * logicAnd(true, false) // false
+ *
+ * @param args - Values to test.
+ * @returns `true` when every argument is truthy, `false` otherwise.
+ */
+export declare function logicAnd(...args: any[]): boolean;
+//#endregion
+//#region logicNot/index.d.ts
+/**
+ * `NOT` condition for values — the logical complement of the given value.
+ *
+ * Map from @vueuse/math `logicNot`
+ * (`source/vueuse/packages/math/logicNot/`). Upstream wraps the evaluation in
+ * `computed(() => ...)` and returns a `ComputedRef<boolean>`; the reause
+ * version is a pure function that evaluates the plain argument and returns a
+ * plain `boolean` on each call — there is no reactivity, so re-renders (or
+ * effects) drive re-evaluation (SSR-safe).
+ *
+ * React divergence: the argument is a plain value, not upstream's
+ * `MaybeRefOrGetter<any>`.
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * logicNot(true) // false
+ * logicNot(0) // true
+ * logicNot('foo') // false
+ *
+ * @param v - A value to negate.
+ * @returns `true` when the value is falsy, `false` otherwise.
+ */
+export declare function logicNot(v: any): boolean;
+//#endregion
+//#region logicOr/index.d.ts
+/**
+ * `OR` conditions for values.
+ *
+ * Map from @vueuse/math `logicOr`
+ * (`source/vueuse/packages/math/logicOr/`). Compute the logical `OR` of any
+ * number of values.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<boolean>`; the reause version is a pure utility
+ * function — all plain arguments are evaluated on every call and the plain
+ * boolean result is returned directly, with no effects and no `.value` wrapper
+ * (SSR-safe). The caller re-invokes it to react to changing values.
+ *
+ * React divergence: arguments are plain values, not upstream's
+ * `MaybeRefOrGetter<any>[]`.
+ *
+ * @see https://vueuse.org/math/logicOr/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * logicOr(true, false) // true
+ * logicOr(false, 0, '') // false
+ *
+ * @param args - Values to evaluate.
+ * @returns `true` if any argument is truthy, `false` otherwise.
+ */
+export declare function logicOr(...args: any[]): boolean;
+//#endregion
+//#region useAbs/index.d.ts
+/**
+ * React port of VueUse's `useAbs`.
+ *
+ * Map from @vueuse/math `useAbs`
+ * (`source/vueuse/packages/math/useAbs/`). Reactive `Math.abs`.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain `number` argument is read at render time and `Math.abs` is
+ * applied directly, with no effects and no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: `value` is a plain read-only `number`, not upstream's
+ * `MaybeRefOrGetter<number>`. The caller re-renders with a new value (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useAbs/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const result = useAbs(-23) // 23
+ *
+ * @param value - The number to compute the absolute value of.
+ * @returns The absolute value of the value.
+ */
+export declare function useAbs(value: number): number;
+//#endregion
+//#region useAverage/index.d.ts
+/**
+ * React port of VueUse's `useAverage`.
+ *
+ * Map from @vueuse/math `useAverage`
+ * (`source/vueuse/packages/math/useAverage/`). Reactively get the average of values.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain numbers (variadic arguments or a single `readonly number[]`)
+ * are read at render time and the average is returned directly as a `number`,
+ * with no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: arguments are plain read-only numbers, not upstream's
+ * `MaybeRefOrGetter<number>[]`. The caller re-renders with new values (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useAverage/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const array = [1, 2, 3, 4]
+ * const average = useAverage(array) // 2.5
+ *
+ * const average2 = useAverage(1, 3, 2) // 2
+ *
+ * @param array - An array of numbers.
+ * @returns The average of the given numbers (`0` when called with no arguments).
+ */
+export declare function useAverage(array: readonly number[]): number;
+export declare function useAverage(...args: number[]): number;
+//#endregion
+//#region useCeil/index.d.ts
+/**
+ * React port of VueUse's `useCeil`.
+ *
+ * Map from @vueuse/math `useCeil`
+ * (`source/vueuse/packages/math/useCeil/`). Reactive `Math.ceil`.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain `number` argument is read at render time and `Math.ceil` is
+ * applied directly, with no effects and no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: `value` is a plain read-only `number`, not upstream's
+ * `MaybeRefOrGetter<number>`. The caller re-renders with a new value (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useCeil/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const result = useCeil(0.95) // 1
+ *
+ * @param value - The number to ceil.
+ * @returns The ceil of the value.
+ */
+export declare function useCeil(value: number): number;
+//#endregion
+//#region useClamp/index.d.ts
+/**
+ * Reactively clamp a value between two other values.
+ *
+ * Map from @vueuse/math `useClamp`
+ * (`source/vueuse/packages/math/useClamp/`). React port of VueUse's writable
+ * `useClamp` — returns a `[value, setValue]` tuple whose setter clamps on
+ * write. `value`, `min` and `max` are plain read-only numbers resolved on every
+ * render: `value` seeds the hook's internal state (and re-syncs when it
+ * changes), and bounds are re-resolved on every render and on every set, so
+ * shrinking `max` / raising `min` re-clamps the current value automatically.
+ *
+ * React divergence: all three parameters are plain `number`, not upstream's
+ * `MaybeRefOrGetter<number>`. The caller re-renders with new values (e.g. from
+ * `useState`) instead of passing a ref/getter. Upstream's writable computed
+ * also writes the clamped value back into its internal ref on every read, so an
+ * out-of-bounds seed stays clamped even after the bounds loosen; here `value`
+ * is a plain prop that re-seeds internal state when it changes and the raw seed
+ * is re-clamped on every render, so loosening the bounds re-exposes the raw
+ * seed until the next `setValue`.
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const [value, setValue] = useClamp(0, 0, 10)
+ * setValue(15) // value is 10
+ * setValue(-5) // value is 0
+ *
+ * @param value - The value to clamp.
+ * @param min - The lower bound.
+ * @param max - The upper bound.
+ * @returns A `[value, setValue]` pair; `setValue` clamps into `[min, max]`.
+ */
+export declare function useClamp(value: number, min: number, max: number): [number, (value: number) => void];
+//#endregion
+//#region useFloor/index.d.ts
+/**
+ * React port of VueUse's `useFloor`.
+ *
+ * Map from @vueuse/math `useFloor`
+ * (`source/vueuse/packages/math/useFloor/`). Reactive `Math.floor`.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain `number` argument is read at render time and `Math.floor` is
+ * applied directly, with no effects and no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: `value` is a plain read-only `number`, not upstream's
+ * `MaybeRefOrGetter<number>`. The caller re-renders with a new value (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useFloor/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const result = useFloor(45.95) // 45
+ *
+ * @param value - The number to floor.
+ * @returns The floor of the value.
+ */
+export declare function useFloor(value: number): number;
+//#endregion
+//#region useMath/index.d.ts
+/** String keys of `Math` that are methods (callables), mirroring upstream's `UseMathKeys`. */
+export type UseMathKeys = keyof { [K in keyof Math as Math[K] extends ((...args: any) => any) ? K : never]: unknown; };
+/**
+ * Return type — `Math` methods always return a `number`. The arguments stay
+ * plain values (see `PlainMathMethod`), not upstream's reactified ones.
+ */
+export type UseMathReturn<K extends keyof Math> = ReturnType<PlainMathMethod<Math[K]>>;
+/**
+ * Arguments of a plain function — a local copy of VueUse shared's
+ * `ArgumentsType` (reause has no shared equivalent).
+ */
+type ArgumentsType<T> = T extends ((...args: infer U) => any) ? U : never;
+/**
+ * A `Math` method whose arguments stay plain values — deliberately NOT VueUse's
+ * `Reactified<T, Computed>` (which wraps every argument in `MaybeRefOrGetter`
+ * and resolves getters via `toValue`). Getters as data sources are rejected
+ * repo-wide (rule 1, issue #462); the reause hook reads the plain arguments at
+ * render time and returns the computed `number` directly.
+ */
+type PlainMathMethod<T> = T extends ((...args: infer A) => infer R) ? (...args: A) => R : never;
+/**
+ * React port of VueUse's `useMath`.
+ *
+ * Map from @vueuse/math `useMath`
+ * (`source/vueuse/packages/math/useMath/`). Reactive `Math` methods — pass a
+ * `Math` method name as the key and its plain numeric arguments; the result is
+ * recomputed on every render and returned directly, with no `.value` wrapper
+ * and no effects (SSR-safe).
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * via `reactify` and returns a `ComputedRef<number>`; the reause version is a
+ * pure derived hook — `key` and every argument are read at render time and
+ * `Math[key]` is invoked immediately, so the returned number always reflects
+ * the latest values.
+ *
+ * React divergence: arguments are plain numbers, not upstream's
+ * `MaybeRefOrGetter`. In particular the getter form (`() => number`) is NOT
+ * accepted — getters as data sources are rejected repo-wide (issue #462). The
+ * caller re-renders with new values (e.g. from `useState`).
+ *
+ * @see https://vueuse.org/math/useMath/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const result = useMath('pow', 2, 3) // 8
+ *
+ * const power = useMath('pow', 2, 3) // 8
+ *
+ * const root = useMath('sqrt', 4) // 2
+ *
+ * const rounded = useMath('round', 2.5) // 3
+ *
+ * @param key - The `Math` method name to call (e.g. `'pow'`, `'sqrt'`).
+ * @param args - Plain numeric arguments to pass to the `Math` method.
+ * @returns The result of calling `Math[key]` with the arguments.
+ */
+export declare function useMath<K extends keyof Math>(key: K, ...args: ArgumentsType<PlainMathMethod<Math[K]>>): UseMathReturn<K>;
+//#endregion
+//#region useMax/index.d.ts
+/**
+ * React port of VueUse's `useMax`.
+ *
+ * Map from @vueuse/math `useMax`
+ * (`source/vueuse/packages/math/useMax/`). Reactively get maximum of values.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain numbers (variadic arguments or a single `readonly number[]`)
+ * are read at render time and the maximum is returned directly as a `number`,
+ * with no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: arguments are plain read-only numbers, not upstream's
+ * `MaybeRefOrGetter<number>[]`. The caller re-renders with new values (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useMax/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const array = [1, 2, 3, 4]
+ * const max = useMax(array) // 4
+ *
+ * const max2 = useMax(1, 3, 2) // 3
+ *
+ * @param array - An array of values.
+ * @returns The maximum of the given values (`Number.NEGATIVE_INFINITY` when
+ * called with no arguments).
+ */
+export declare function useMax(array: readonly number[]): number;
+export declare function useMax(...args: number[]): number;
+//#endregion
+//#region useMin/index.d.ts
+/**
+ * React port of VueUse's `useMin`.
+ *
+ * Map from @vueuse/math `useMin`
+ * (`source/vueuse/packages/math/useMin/`). Reactively calculate the minimum of
+ * the given numbers — the React analog of reactive `Math.min`.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain numbers (variadic arguments or a single `readonly number[]`)
+ * are read at render time and the minimum is returned directly, with no effects
+ * and no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: arguments are plain read-only numbers, not upstream's
+ * `MaybeRefOrGetter<number>[]`. The caller re-renders with new values (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useMin/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const array = [1, 2, 3, 4]
+ * const min = useMin(array) // 1
+ *
+ * const min2 = useMin(1, 3, 2) // 1
+ *
+ * @param array - A set of numbers to find the minimum of.
+ * @returns The minimum of the given numbers, or `Number.POSITIVE_INFINITY` when
+ * no arguments are passed (matching `Math.min()` semantics).
+ */
+export declare function useMin(array: readonly number[]): number;
+export declare function useMin(...args: number[]): number;
+//#endregion
+//#region usePrecision/index.d.ts
+export interface UsePrecisionOptions {
+  /**
+   * Method to use for rounding.
+   *
+   * @default 'round'
+   */
+  math?: 'floor' | 'ceil' | 'round';
+}
+/**
+ * React port of VueUse's `usePrecision`.
+ *
+ * Map from @vueuse/math `usePrecision`
+ * (`source/vueuse/packages/math/usePrecision/`). Reactively set the precision
+ * of a number.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain `value`, `digits` and `options` are read at render time and
+ * the precision-adjusted number is memoized and returned directly, with no
+ * effects and no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: parameters are plain read-only values, not upstream's
+ * `MaybeRefOrGetter<...>`. The caller re-renders with new values (e.g. from
+ * `useState`).
+ *
+ * @see https://vueuse.org/math/usePrecision/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const result = usePrecision(3.1415, 2) // 3.14
+ *
+ * const ceilResult = usePrecision(3.1415, 2, {
+ *   math: 'ceil',
+ * }) // 3.15
+ *
+ * const floorResult = usePrecision(3.1415, 3, {
+ *   math: 'floor',
+ * }) // 3.141
+ *
+ * @param value - The value to set the precision of.
+ * @param digits - The number of digits to keep.
+ * @param options - The rounding method to use (`round` by default).
+ * @returns The value with the applied precision.
+ */
+export declare function usePrecision(value: number, digits: number, options?: UsePrecisionOptions): number;
+//#endregion
+//#region useRound/index.d.ts
+/**
+ * React port of VueUse's `useRound`.
+ *
+ * Map from @vueuse/math `useRound`
+ * (`source/vueuse/packages/math/useRound/`). Reactive `Math.round`.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain `number` argument is read at render time and `Math.round` is
+ * applied directly, with no effects and no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: `value` is a plain read-only `number`, not upstream's
+ * `MaybeRefOrGetter<number>`. The caller re-renders with a new value (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useRound/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const result = useRound(20.49) // 20
+ *
+ * @param value - The number to round.
+ * @returns The value rounded to the nearest integer.
+ */
+export declare function useRound(value: number): number;
+//#endregion
+//#region useSum/index.d.ts
+/**
+ * React port of VueUse's `useSum`.
+ *
+ * Map from @vueuse/math `useSum`
+ * (`source/vueuse/packages/math/useSum/`). Reactively get the sum of values.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain numbers (variadic arguments or a single `readonly number[]`)
+ * are read at render time and the sum is returned directly as a `number`, with
+ * no `.value` wrapper (SSR-safe).
+ *
+ * React divergence: arguments are plain read-only numbers, not upstream's
+ * `MaybeRefOrGetter<number>[]`. In particular, the getter form (`() => number`)
+ * is NOT accepted — getters as data sources are rejected repo-wide (issue #462)
+ * — so the upstream getter test is intentionally not ported. The caller
+ * re-renders with new values (e.g. from `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useSum/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const array = [1, 2, 3, 4]
+ * const sum = useSum(array) // 10
+ *
+ * const [a, setA] = useState(1)
+ * const [b, setB] = useState(3)
+ * const sum2 = useSum(a, b, 2) // 6
+ *
+ * @param array - An array of numbers.
+ * @returns The sum of the given numbers (`0` when called with no arguments).
+ */
+export declare function useSum(array: readonly number[]): number;
+export declare function useSum(...args: number[]): number;
+//#endregion
+//#region useTrunc/index.d.ts
+/**
+ * React port of VueUse's `useTrunc`.
+ *
+ * Map from @vueuse/math `useTrunc`
+ * (`source/vueuse/packages/math/useTrunc/`). Reactively truncates a number,
+ * removing the fractional digits toward zero.
+ *
+ * Adjustment for React: upstream wraps the computation in `computed(() => ...)`
+ * and returns a `ComputedRef<number>`; the reause version is a pure derived
+ * hook — the plain `number` argument is read at render time and the truncated
+ * number is returned directly, with no effects and no `.value` wrapper
+ * (SSR-safe).
+ *
+ * React divergence: `value` is a plain read-only `number`, not upstream's
+ * `MaybeRefOrGetter<number>`. The caller re-renders with a new value (e.g. from
+ * `useState`) and the hook recomputes.
+ *
+ * @see https://vueuse.org/math/useTrunc/
+ *
+ * @__NO_SIDE_EFFECTS__
+ *
+ * @example
+ * const result = useTrunc(0.95) // 0
+ *
+ * @param value - The number to truncate.
+ * @returns The truncated number.
+ */
+export declare function useTrunc(value: number): number;
+//#endregion