@flighthq/math 0.1.0

package/dist/angle.d.ts

@@ -0,0 +1,13 @@
+/** Convert `degrees` to radians. */
+export declare function degToRad(degrees: number): number;
+/** Return the shortest signed difference between angles `from` and `to` (radians).
+ *
+ *  The result is in `(-π, π]`. Useful for rotating a value toward a target by
+ *  the minimum arc.
+ */
+export declare function deltaAngle(from: number, to: number): number;
+/** Wrap `radians` to the range `[-π, π)`. */
+export declare function normalizeAngle(radians: number): number;
+/** Convert `radians` to degrees. */
+export declare function radToDeg(radians: number): number;
+//# sourceMappingURL=angle.d.ts.map

package/dist/angle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../src/angle.ts"],"names":[],"mappings":"AAEA,oCAAoC;AACpC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAG3D;AAED,6CAA6C;AAC7C,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,oCAAoC;AACpC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/angle.js

@@ -0,0 +1,24 @@
+import { DEG_TO_RAD, RAD_TO_DEG, TAU } from './constants';
+/** Convert `degrees` to radians. */
+export function degToRad(degrees) {
+    return degrees * DEG_TO_RAD;
+}
+/** Return the shortest signed difference between angles `from` and `to` (radians).
+ *
+ *  The result is in `(-π, π]`. Useful for rotating a value toward a target by
+ *  the minimum arc.
+ */
+export function deltaAngle(from, to) {
+    const diff = (((to - from) % TAU) + TAU) % TAU;
+    return diff > Math.PI ? diff - TAU : diff;
+}
+/** Wrap `radians` to the range `[-π, π)`. */
+export function normalizeAngle(radians) {
+    const wrapped = ((radians % TAU) + TAU) % TAU;
+    return wrapped >= Math.PI ? wrapped - TAU : wrapped;
+}
+/** Convert `radians` to degrees. */
+export function radToDeg(radians) {
+    return radians * RAD_TO_DEG;
+}
+//# sourceMappingURL=angle.js.map

package/dist/angle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"angle.js","sourceRoot":"","sources":["../src/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAE1D,oCAAoC;AACpC,MAAM,UAAU,QAAQ,CAAC,OAAe;IACtC,OAAO,OAAO,GAAG,UAAU,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,EAAU;IACjD,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;IAC/C,OAAO,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAC5C,CAAC;AAED,6CAA6C;AAC7C,MAAM,UAAU,cAAc,CAAC,OAAe;IAC5C,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;IAC9C,OAAO,OAAO,IAAI,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC;AACtD,CAAC;AAED,oCAAoC;AACpC,MAAM,UAAU,QAAQ,CAAC,OAAe;IACtC,OAAO,OAAO,GAAG,UAAU,CAAC;AAC9B,CAAC"}

package/dist/clamp.d.ts

@@ -0,0 +1,15 @@
+/** Clamp `value` to the inclusive range `[min, max]`.
+ *
+ *  When `min > max` the result is `min`. NaN propagates unchanged.
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/** Return `true` if `value` is within the inclusive range `[min, max]`. */
+export declare function inRange(value: number, min: number, max: number): boolean;
+/** Clamp `value` to `[0, 1]`. Equivalent to `clamp(value, 0, 1)`.
+ *
+ *  Named `saturate` after the GPU HLSL/GLSL convention. Follows GPU semantics:
+ *  NaN returns 0 (unlike `clamp`, which propagates NaN). Safe in hot loops,
+ *  no allocation.
+ */
+export declare function saturate(value: number): number;
+//# sourceMappingURL=clamp.d.ts.map

package/dist/clamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.d.ts","sourceRoot":"","sources":["../src/clamp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG9C"}

package/dist/clamp.js

@@ -0,0 +1,23 @@
+/** Clamp `value` to the inclusive range `[min, max]`.
+ *
+ *  When `min > max` the result is `min`. NaN propagates unchanged.
+ */
+export function clamp(value, min, max) {
+    return value < min ? min : value > max ? max : value;
+}
+/** Return `true` if `value` is within the inclusive range `[min, max]`. */
+export function inRange(value, min, max) {
+    return value >= min && value <= max;
+}
+/** Clamp `value` to `[0, 1]`. Equivalent to `clamp(value, 0, 1)`.
+ *
+ *  Named `saturate` after the GPU HLSL/GLSL convention. Follows GPU semantics:
+ *  NaN returns 0 (unlike `clamp`, which propagates NaN). Safe in hot loops,
+ *  no allocation.
+ */
+export function saturate(value) {
+    if (value !== value)
+        return 0;
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+//# sourceMappingURL=clamp.js.map

package/dist/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clamp.js","sourceRoot":"","sources":["../src/clamp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa,EAAE,GAAW,EAAE,GAAW;IAC3D,OAAO,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;AACvD,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,OAAO,CAAC,KAAa,EAAE,GAAW,EAAE,GAAW;IAC7D,OAAO,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,GAAG,CAAC;AACtC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/C,CAAC"}

package/dist/comparison.d.ts

@@ -0,0 +1,17 @@
+/** Return `true` if `|a - b| <= epsilon`.
+ *
+ *  Uses an absolute epsilon, appropriate for values near zero. For magnitudes
+ *  much larger than 1, use `approxEqualRelative`. Defaults to the SDK `EPSILON`.
+ */
+export declare function approxEqual(a: number, b: number, epsilon?: number): boolean;
+/** Return `true` if `a` and `b` agree to within a relative tolerance.
+ *
+ *  Uses `|a - b| <= relativeEpsilon * max(|a|, |b|)`, which scales with
+ *  magnitude and is appropriate for large numbers where absolute epsilon
+ *  comparisons fail. For values near zero, falls back to `EPSILON`
+ *  (absolute). Defaults to `EPSILON` for `relativeEpsilon`.
+ */
+export declare function approxEqualRelative(a: number, b: number, relativeEpsilon?: number): boolean;
+/** Return `true` if `|value| <= epsilon`. */
+export declare function approxZero(value: number, epsilon?: number): boolean;
+//# sourceMappingURL=comparison.d.ts.map

package/dist/comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.d.ts","sourceRoot":"","sources":["../src/comparison.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,MAAgB,GAAG,OAAO,CAEpF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,eAAe,GAAE,MAAgB,GAAG,OAAO,CAIpG;AAED,6CAA6C;AAC7C,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,MAAgB,GAAG,OAAO,CAE5E"}

package/dist/comparison.js

@@ -0,0 +1,26 @@
+import { EPSILON } from './constants';
+/** Return `true` if `|a - b| <= epsilon`.
+ *
+ *  Uses an absolute epsilon, appropriate for values near zero. For magnitudes
+ *  much larger than 1, use `approxEqualRelative`. Defaults to the SDK `EPSILON`.
+ */
+export function approxEqual(a, b, epsilon = EPSILON) {
+    return Math.abs(a - b) <= epsilon;
+}
+/** Return `true` if `a` and `b` agree to within a relative tolerance.
+ *
+ *  Uses `|a - b| <= relativeEpsilon * max(|a|, |b|)`, which scales with
+ *  magnitude and is appropriate for large numbers where absolute epsilon
+ *  comparisons fail. For values near zero, falls back to `EPSILON`
+ *  (absolute). Defaults to `EPSILON` for `relativeEpsilon`.
+ */
+export function approxEqualRelative(a, b, relativeEpsilon = EPSILON) {
+    const diff = Math.abs(a - b);
+    const largest = Math.max(Math.abs(a), Math.abs(b));
+    return diff <= Math.max(relativeEpsilon * largest, EPSILON);
+}
+/** Return `true` if `|value| <= epsilon`. */
+export function approxZero(value, epsilon = EPSILON) {
+    return Math.abs(value) <= epsilon;
+}
+//# sourceMappingURL=comparison.js.map

package/dist/comparison.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison.js","sourceRoot":"","sources":["../src/comparison.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,CAAS,EAAE,CAAS,EAAE,UAAkB,OAAO;IACzE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,OAAO,CAAC;AACpC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,CAAS,EAAE,CAAS,EAAE,kBAA0B,OAAO;IACzF,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnD,OAAO,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,eAAe,GAAG,OAAO,EAAE,OAAO,CAAC,CAAC;AAC9D,CAAC;AAED,6CAA6C;AAC7C,MAAM,UAAU,UAAU,CAAC,KAAa,EAAE,UAAkB,OAAO;IACjE,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC;AACpC,CAAC"}

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+/** Smallest positive number distinguishable from zero in floating-point comparisons. */
+export declare const EPSILON = 0.000001;
+/** Full circle in radians (2π). Prefer `TAU` over `2 * Math.PI` for clarity. */
+export declare const TAU: number;
+/** Half of π (π / 2). */
+export declare const HALF_PI: number;
+/** Multiply degrees by this constant to get radians. */
+export declare const DEG_TO_RAD: number;
+/** Multiply radians by this constant to get degrees. */
+export declare const RAD_TO_DEG: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,eAAO,MAAM,OAAO,WAAO,CAAC;AAE5B,gFAAgF;AAChF,eAAO,MAAM,GAAG,QAAc,CAAC;AAE/B,yBAAyB;AACzB,eAAO,MAAM,OAAO,QAAc,CAAC;AAEnC,wDAAwD;AACxD,eAAO,MAAM,UAAU,QAAgB,CAAC;AAExC,wDAAwD;AACxD,eAAO,MAAM,UAAU,QAAgB,CAAC"}

package/dist/constants.js

@@ -0,0 +1,11 @@
+/** Smallest positive number distinguishable from zero in floating-point comparisons. */
+export const EPSILON = 1e-6;
+/** Full circle in radians (2π). Prefer `TAU` over `2 * Math.PI` for clarity. */
+export const TAU = Math.PI * 2;
+/** Half of π (π / 2). */
+export const HALF_PI = Math.PI / 2;
+/** Multiply degrees by this constant to get radians. */
+export const DEG_TO_RAD = Math.PI / 180;
+/** Multiply radians by this constant to get degrees. */
+export const RAD_TO_DEG = 180 / Math.PI;
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,MAAM,CAAC,MAAM,OAAO,GAAG,IAAI,CAAC;AAE5B,gFAAgF;AAChF,MAAM,CAAC,MAAM,GAAG,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;AAE/B,yBAAyB;AACzB,MAAM,CAAC,MAAM,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;AAEnC,wDAAwD;AACxD,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC;AAExC,wDAAwD;AACxD,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC"}

package/dist/hash.d.ts

@@ -0,0 +1,35 @@
+import type { RandomSource } from '@flighthq/types';
+/** Create a `RandomSource` seeded from a deterministic hash of `x` and `y`.
+ *
+ *  Connects the stateless hash layer to the seeded-PRNG layer — each grid
+ *  cell gets an independent reproducible random stream.
+ *
+ *  ```ts
+ *  const rng = createRandomSourceFromHash(tileX, tileY);
+ *  const treasure = rng() < 0.05; // 5% chance, reproducible per tile
+ *  ```
+ */
+export declare function createRandomSourceFromHash(x: number, y: number): RandomSource;
+/** Stateless position-seeded hash over a 2D integer grid.
+ *
+ *  Returns a deterministic `number` in `[0, 2³²)`. Suitable for procedural
+ *  tile/cell content and gradient noise seed generation.
+ */
+export declare function hash2D(x: number, y: number): number;
+/** Stateless position-seeded hash over a 3D integer grid. */
+export declare function hash3D(x: number, y: number, z: number): number;
+/** Combine a running hash `seed` with a new `value` using a Murmur3-inspired mix.
+ *
+ *  Used to build multi-dimensional hashes from `hashUint32`:
+ *  ```ts
+ *  const h = hashCombine(hashUint32(x), y);
+ *  ```
+ */
+export declare function hashCombine(seed: number, value: number): number;
+/** Finalise an arbitrary 32-bit integer through the fmix32 finalizer (Murmur3).
+ *
+ *  Produces a deterministic, well-distributed 32-bit unsigned integer from any
+ *  input. Useful as a stateless hash function for individual values.
+ */
+export declare function hashUint32(value: number): number;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAE7E;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,6DAA6D;AAC7D,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQhD"}

package/dist/hash.js

@@ -0,0 +1,51 @@
+import { createRandomSource } from './random';
+/** Create a `RandomSource` seeded from a deterministic hash of `x` and `y`.
+ *
+ *  Connects the stateless hash layer to the seeded-PRNG layer — each grid
+ *  cell gets an independent reproducible random stream.
+ *
+ *  ```ts
+ *  const rng = createRandomSourceFromHash(tileX, tileY);
+ *  const treasure = rng() < 0.05; // 5% chance, reproducible per tile
+ *  ```
+ */
+export function createRandomSourceFromHash(x, y) {
+    return createRandomSource(hash2D(x, y));
+}
+/** Stateless position-seeded hash over a 2D integer grid.
+ *
+ *  Returns a deterministic `number` in `[0, 2³²)`. Suitable for procedural
+ *  tile/cell content and gradient noise seed generation.
+ */
+export function hash2D(x, y) {
+    return hashCombine(hashUint32(x | 0), y | 0);
+}
+/** Stateless position-seeded hash over a 3D integer grid. */
+export function hash3D(x, y, z) {
+    return hashCombine(hash2D(x, y), z | 0);
+}
+/** Combine a running hash `seed` with a new `value` using a Murmur3-inspired mix.
+ *
+ *  Used to build multi-dimensional hashes from `hashUint32`:
+ *  ```ts
+ *  const h = hashCombine(hashUint32(x), y);
+ *  ```
+ */
+export function hashCombine(seed, value) {
+    return hashUint32(seed ^ (value + 0x9e3779b9 + (seed << 6) + (seed >> 2)));
+}
+/** Finalise an arbitrary 32-bit integer through the fmix32 finalizer (Murmur3).
+ *
+ *  Produces a deterministic, well-distributed 32-bit unsigned integer from any
+ *  input. Useful as a stateless hash function for individual values.
+ */
+export function hashUint32(value) {
+    let h = value | 0;
+    h ^= h >>> 16;
+    h = Math.imul(h, 0x85ebca6b) | 0;
+    h ^= h >>> 13;
+    h = Math.imul(h, 0xc2b2ae35) | 0;
+    h ^= h >>> 16;
+    return h >>> 0;
+}
+//# sourceMappingURL=hash.js.map

package/dist/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,UAAU,0BAA0B,CAAC,CAAS,EAAE,CAAS;IAC7D,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,MAAM,CAAC,CAAS,EAAE,CAAS;IACzC,OAAO,WAAW,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/C,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,MAAM,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS;IACpD,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,KAAa;IACrD,OAAO,UAAU,CAAC,IAAI,GAAG,CAAC,KAAK,GAAG,UAAU,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;IAClB,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IACd,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IACd,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IACd,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from './angle';
+export * from './clamp';
+export * from './comparison';
+export * from './constants';
+export * from './hash';
+export * from './interpolation';
+export * from './interpolationAdvanced';
+export * from './nextPowerOfTwo';
+export * from './numberTheory';
+export * from './random';
+export * from './randomDistributions';
+export * from './randomRange';
+export * from './rounding';
+export * from './scalar';
+export * from './statistics';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,16 @@
+export * from './angle';
+export * from './clamp';
+export * from './comparison';
+export * from './constants';
+export * from './hash';
+export * from './interpolation';
+export * from './interpolationAdvanced';
+export * from './nextPowerOfTwo';
+export * from './numberTheory';
+export * from './random';
+export * from './randomDistributions';
+export * from './randomRange';
+export * from './rounding';
+export * from './scalar';
+export * from './statistics';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC"}

package/dist/interpolation.d.ts

@@ -0,0 +1,27 @@
+/** Return the `t` value that maps to `value` in the range `[a, b]`.
+ *
+ *  The inverse of `lerp`: `inverseLerp(lerp(a, b, t), a, b) === t` when
+ *  `a !== b`. Returns `0` when `a === b` to avoid division by zero.
+ */
+export declare function inverseLerp(a: number, b: number, value: number): number;
+/** Linearly interpolate between `a` and `b` by factor `t`.
+ *
+ *  `t = 0` returns `a`; `t = 1` returns `b`. `t` is not clamped — pass a
+ *  saturated `t` for clamped behaviour. Safe in hot loops, no allocation.
+ */
+export declare function lerp(a: number, b: number, t: number): number;
+/** Linearly interpolate `value` from `[inMin, inMax]` into `[outMin, outMax]`.
+ *
+ *  Equivalent to `lerp(outMin, outMax, inverseLerp(inMin, inMax, value))`.
+ *  Input range is not clamped. Returns `outMin` when `inMin === inMax`.
+ */
+export declare function remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+/** Hermite interpolation between `edge0` and `edge1` with a smooth ease curve.
+ *
+ *  Returns 0 for `x <= edge0`, 1 for `x >= edge1`, and smoothly interpolates
+ *  in between using `3t² - 2t³`. This is the same `smoothstep` found in GLSL.
+ */
+export declare function smoothStep(edge0: number, edge1: number, x: number): number;
+/** Returns 0 if `x < edge`, otherwise 1. The scalar step function from GLSL. */
+export declare function step(edge: number, x: number): number;
+//# sourceMappingURL=interpolation.d.ts.map

package/dist/interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolation.d.ts","sourceRoot":"","sources":["../src/interpolation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGvE;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAIzG;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAI1E;AAED,gFAAgF;AAChF,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/interpolation.js

@@ -0,0 +1,43 @@
+/** Return the `t` value that maps to `value` in the range `[a, b]`.
+ *
+ *  The inverse of `lerp`: `inverseLerp(lerp(a, b, t), a, b) === t` when
+ *  `a !== b`. Returns `0` when `a === b` to avoid division by zero.
+ */
+export function inverseLerp(a, b, value) {
+    const range = b - a;
+    return range === 0 ? 0 : (value - a) / range;
+}
+/** Linearly interpolate between `a` and `b` by factor `t`.
+ *
+ *  `t = 0` returns `a`; `t = 1` returns `b`. `t` is not clamped — pass a
+ *  saturated `t` for clamped behaviour. Safe in hot loops, no allocation.
+ */
+export function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+/** Linearly interpolate `value` from `[inMin, inMax]` into `[outMin, outMax]`.
+ *
+ *  Equivalent to `lerp(outMin, outMax, inverseLerp(inMin, inMax, value))`.
+ *  Input range is not clamped. Returns `outMin` when `inMin === inMax`.
+ */
+export function remap(value, inMin, inMax, outMin, outMax) {
+    const inRange = inMax - inMin;
+    if (inRange === 0)
+        return outMin;
+    return outMin + ((value - inMin) / inRange) * (outMax - outMin);
+}
+/** Hermite interpolation between `edge0` and `edge1` with a smooth ease curve.
+ *
+ *  Returns 0 for `x <= edge0`, 1 for `x >= edge1`, and smoothly interpolates
+ *  in between using `3t² - 2t³`. This is the same `smoothstep` found in GLSL.
+ */
+export function smoothStep(edge0, edge1, x) {
+    const t = (x - edge0) / (edge1 - edge0);
+    const s = t < 0 ? 0 : t > 1 ? 1 : t;
+    return s * s * (3 - 2 * s);
+}
+/** Returns 0 if `x < edge`, otherwise 1. The scalar step function from GLSL. */
+export function step(edge, x) {
+    return x < edge ? 0 : 1;
+}
+//# sourceMappingURL=interpolation.js.map

package/dist/interpolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolation.js","sourceRoot":"","sources":["../src/interpolation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,CAAS,EAAE,CAAS,EAAE,KAAa;IAC7D,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;AAC/C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,IAAI,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS;IAClD,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa,EAAE,KAAa,EAAE,KAAa,EAAE,MAAc,EAAE,MAAc;IAC/F,MAAM,OAAO,GAAG,KAAK,GAAG,KAAK,CAAC;IAC9B,IAAI,OAAO,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IACjC,OAAO,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AAClE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,KAAa,EAAE,KAAa,EAAE,CAAS;IAChE,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;IACxC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7B,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,CAAS;IAC1C,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1B,CAAC"}

package/dist/interpolationAdvanced.d.ts

@@ -0,0 +1,42 @@
+/** Frame-rate-independent exponential decay toward `target`.
+ *
+ *  Equivalent to `lerp(current, target, 1 - exp(-lambda * deltaTime))`.
+ *  Higher `lambda` = faster convergence. This is the classic "damp" function
+ *  from Freya Holmér / Game Math — it does not overshoot and is independent of
+ *  frame rate. `deltaTime` should be in seconds.
+ *
+ *  Returns `current` when `deltaTime <= 0` or `lambda <= 0`.
+ */
+export declare function damp(current: number, target: number, lambda: number, deltaTime: number): number;
+/** Linearly interpolate between two angles `a` and `b` (radians) by factor `t`,
+ *  taking the shortest arc.
+ *
+ *  `t` is not clamped. The result wraps naturally; there is no explicit
+ *  `normalizeAngle` call on the output — callers that need the result in a
+ *  specific range should normalize it themselves.
+ */
+export declare function lerpAngle(a: number, b: number, t: number): number;
+/** Move `current` toward `target` by at most `maxDelta`, without overshooting.
+ *
+ *  `maxDelta` should be positive; passing a negative `maxDelta` moves away
+ *  from `target` instead.
+ */
+export declare function moveTowards(current: number, target: number, maxDelta: number): number;
+/** Bounce `t` back and forth over `[0, length]` like a ping-pong ball.
+ *
+ *  `pingPong(t, 1)` cycles: 0 → 1 → 0 → 1 → …
+ */
+export declare function pingPong(t: number, length: number): number;
+/** Wrap `t` over `[0, length)`.
+ *
+ *  `repeat(1.6, 1)` → `0.6`. Analogous to Unity's `Mathf.Repeat`.
+ */
+export declare function repeat(t: number, length: number): number;
+/** Hermite interpolation with a smoother quintic ease curve (Ken Perlin).
+ *
+ *  Uses `6t⁵ - 15t⁴ + 10t³` — has zero first- _and_ second-derivative at the
+ *  edges, making it smoother than the cubic `smoothStep`. Commonly called
+ *  `smootherstep`. Returns 0 for `x <= edge0`, 1 for `x >= edge1`.
+ */
+export declare function smootherStep(edge0: number, edge1: number, x: number): number;
+//# sourceMappingURL=interpolationAdvanced.d.ts.map

package/dist/interpolationAdvanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolationAdvanced.d.ts","sourceRoot":"","sources":["../src/interpolationAdvanced.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG/F;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKjE;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIrF;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK1D;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAI5E"}

package/dist/interpolationAdvanced.js

@@ -0,0 +1,71 @@
+/** Frame-rate-independent exponential decay toward `target`.
+ *
+ *  Equivalent to `lerp(current, target, 1 - exp(-lambda * deltaTime))`.
+ *  Higher `lambda` = faster convergence. This is the classic "damp" function
+ *  from Freya Holmér / Game Math — it does not overshoot and is independent of
+ *  frame rate. `deltaTime` should be in seconds.
+ *
+ *  Returns `current` when `deltaTime <= 0` or `lambda <= 0`.
+ */
+export function damp(current, target, lambda, deltaTime) {
+    if (deltaTime <= 0 || lambda <= 0)
+        return current;
+    return target + (current - target) * Math.exp(-lambda * deltaTime);
+}
+/** Linearly interpolate between two angles `a` and `b` (radians) by factor `t`,
+ *  taking the shortest arc.
+ *
+ *  `t` is not clamped. The result wraps naturally; there is no explicit
+ *  `normalizeAngle` call on the output — callers that need the result in a
+ *  specific range should normalize it themselves.
+ */
+export function lerpAngle(a, b, t) {
+    const TAU = Math.PI * 2;
+    let diff = (((b - a) % TAU) + TAU) % TAU;
+    if (diff > Math.PI)
+        diff -= TAU;
+    return a + diff * t;
+}
+/** Move `current` toward `target` by at most `maxDelta`, without overshooting.
+ *
+ *  `maxDelta` should be positive; passing a negative `maxDelta` moves away
+ *  from `target` instead.
+ */
+export function moveTowards(current, target, maxDelta) {
+    const delta = target - current;
+    if (Math.abs(delta) <= maxDelta)
+        return target;
+    return current + Math.sign(delta) * maxDelta;
+}
+/** Bounce `t` back and forth over `[0, length]` like a ping-pong ball.
+ *
+ *  `pingPong(t, 1)` cycles: 0 → 1 → 0 → 1 → …
+ */
+export function pingPong(t, length) {
+    if (length <= 0)
+        return 0;
+    const cycle = 2 * length;
+    const mod = ((t % cycle) + cycle) % cycle;
+    return mod <= length ? mod : cycle - mod;
+}
+/** Wrap `t` over `[0, length)`.
+ *
+ *  `repeat(1.6, 1)` → `0.6`. Analogous to Unity's `Mathf.Repeat`.
+ */
+export function repeat(t, length) {
+    if (length <= 0)
+        return 0;
+    return ((t % length) + length) % length;
+}
+/** Hermite interpolation with a smoother quintic ease curve (Ken Perlin).
+ *
+ *  Uses `6t⁵ - 15t⁴ + 10t³` — has zero first- _and_ second-derivative at the
+ *  edges, making it smoother than the cubic `smoothStep`. Commonly called
+ *  `smootherstep`. Returns 0 for `x <= edge0`, 1 for `x >= edge1`.
+ */
+export function smootherStep(edge0, edge1, x) {
+    const t = (x - edge0) / (edge1 - edge0);
+    const s = t < 0 ? 0 : t > 1 ? 1 : t;
+    return s * s * s * (s * (s * 6 - 15) + 10);
+}
+//# sourceMappingURL=interpolationAdvanced.js.map

package/dist/interpolationAdvanced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolationAdvanced.js","sourceRoot":"","sources":["../src/interpolationAdvanced.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,UAAU,IAAI,CAAC,OAAe,EAAE,MAAc,EAAE,MAAc,EAAE,SAAiB;IACrF,IAAI,SAAS,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,OAAO,CAAC;IAClD,OAAO,MAAM,GAAG,CAAC,OAAO,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS;IACvD,MAAM,GAAG,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;IACxB,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;IACzC,IAAI,IAAI,GAAG,IAAI,CAAC,EAAE;QAAE,IAAI,IAAI,GAAG,CAAC;IAChC,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;AACtB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe,EAAE,MAAc,EAAE,QAAgB;IAC3E,MAAM,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAC/B,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,QAAQ;QAAE,OAAO,MAAM,CAAC;IAC/C,OAAO,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC;AAC/C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAS,EAAE,MAAc;IAChD,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IAC1B,MAAM,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC;IACzB,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC;IAC1C,OAAO,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC;AAC3C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,MAAM,CAAC,CAAS,EAAE,MAAc;IAC9C,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IAC1B,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC;AAC1C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAa,EAAE,KAAa,EAAE,CAAS;IAClE,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;IACxC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAC7C,CAAC"}

package/dist/nextPowerOfTwo.d.ts

@@ -0,0 +1,22 @@
+/** Return `true` if `n` is an integer power of two (i.e. 1, 2, 4, 8, …).
+ *
+ *  Returns `false` for `n <= 0`.
+ */
+export declare function isPowerOfTwo(n: number): boolean;
+/** Round `value` up to the nearest multiple of `multiple`.
+ *
+ *  `nextMultipleOf(7, 4)` → `8`. When `multiple <= 0` the result is `value`.
+ */
+export declare function nextMultipleOf(value: number, multiple: number): number;
+/** Round `n` up to the next power of two.
+ *
+ *  Uses integer bit-twiddling for stability on large values. Returns `1` for
+ *  `n <= 1`.
+ */
+export declare function nextPowerOfTwo(n: number): number;
+/** Round `n` down to the largest power of two that is `<= n`.
+ *
+ *  `previousPowerOfTwo(6)` → `4`. Returns `1` for `n <= 1`.
+ */
+export declare function previousPowerOfTwo(n: number): number;
+//# sourceMappingURL=nextPowerOfTwo.d.ts.map

package/dist/nextPowerOfTwo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextPowerOfTwo.d.ts","sourceRoot":"","sources":["../src/nextPowerOfTwo.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAItE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAWhD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAUpD"}

package/dist/nextPowerOfTwo.js

@@ -0,0 +1,52 @@
+/** Return `true` if `n` is an integer power of two (i.e. 1, 2, 4, 8, …).
+ *
+ *  Returns `false` for `n <= 0`.
+ */
+export function isPowerOfTwo(n) {
+    return n > 0 && (n & (n - 1)) === 0;
+}
+/** Round `value` up to the nearest multiple of `multiple`.
+ *
+ *  `nextMultipleOf(7, 4)` → `8`. When `multiple <= 0` the result is `value`.
+ */
+export function nextMultipleOf(value, multiple) {
+    if (multiple <= 0)
+        return value;
+    const remainder = value % multiple;
+    return remainder === 0 ? value : value + multiple - remainder;
+}
+/** Round `n` up to the next power of two.
+ *
+ *  Uses integer bit-twiddling for stability on large values. Returns `1` for
+ *  `n <= 1`.
+ */
+export function nextPowerOfTwo(n) {
+    if (n <= 1)
+        return 1;
+    // Decrement so exact powers of two are unchanged, then propagate the
+    // highest set bit downward and add 1 to get the next power.
+    n = (n - 1) | 0;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    return (n + 1) >>> 0;
+}
+/** Round `n` down to the largest power of two that is `<= n`.
+ *
+ *  `previousPowerOfTwo(6)` → `4`. Returns `1` for `n <= 1`.
+ */
+export function previousPowerOfTwo(n) {
+    if (n <= 1)
+        return 1;
+    // Fill all bits below the highest set bit, then shift right by 1.
+    n = n | 0;
+    n |= n >> 1;
+    n |= n >> 2;
+    n |= n >> 4;
+    n |= n >> 8;
+    n |= n >> 16;
+    return (n + 1) >> 1;
+}
+//# sourceMappingURL=nextPowerOfTwo.js.map

package/dist/nextPowerOfTwo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextPowerOfTwo.js","sourceRoot":"","sources":["../src/nextPowerOfTwo.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,CAAS;IACpC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACtC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa,EAAE,QAAgB;IAC5D,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IAChC,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;IACnC,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;AAChE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACrB,qEAAqE;IACrE,4DAA4D;IAC5D,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACb,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,CAAS;IAC1C,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IACrB,kEAAkE;IAClE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACV,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACZ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACb,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;AACtB,CAAC"}