@jarenjs/core 0.9.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Joham
+
+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/README.md

@@ -0,0 +1,68 @@
+# @jarenjs/core
+
+The zero-dependency foundation of [Jaren](https://github.com/jklarenbeek/jarenjs). Everything the validator, the formats package and the forms package are built on lives here — type guards, Unicode-aware string handling, a large text-validation toolbox, number range helpers, and fixed-point and vector math.
+
+None of it depends on JSON Schema: every module can be used standalone in any JavaScript project.
+
+## Modules
+
+| Import | Contents |
+|---|---|
+| `@jarenjs/core` | type guards and getters (`isStringType`, `isObjectClass`, `getIntegerType`, ...) |
+| `@jarenjs/core/array` | array helpers (`isUniqueArray`, `getUniqueArray`, `includesAll`, ...) |
+| `@jarenjs/core/object` | deep equality (`equalsDeep`, JSON-only `equalsJson`), map/set merging |
+| `@jarenjs/core/string` | Unicode string helpers (`countCodePoints`, `compareCodePoints`, ...), cached regex compilation |
+| `@jarenjs/core/scan` | char-code constants and predicates for recursive-descent parsers |
+| `@jarenjs/core/number` | boolean/number/integer coercion helpers (`isIntishType`, ...) |
+| `@jarenjs/core/integer` | `int8` ... `uint64` ranges and validators |
+| `@jarenjs/core/float` | `float16` ... `float64` constants, validators, increment/decrement |
+| `@jarenjs/core/bigint` | bigint helpers (`BigInt_min`, `BigInt_MinMax`, ...) |
+| `@jarenjs/core/dates` | RFC 3339 / ISO 8601 date-time parsing and validation |
+| `@jarenjs/core/text` | text validators: emails, hostnames, IPs, URIs/IRIs, UUIDs, punycode, ... |
+| `@jarenjs/core/math` | int32/float64 math and 2D/3D vector classes |
+
+Deep imports work too (`@jarenjs/core/text/email`, `@jarenjs/core/math/vec2f64`, ...).
+
+## Strings and Unicode
+
+`@jarenjs/core/string` counts string length the way JSON Schema expects — by grapheme cluster, not UTF-16 code units — without paying for `Intl.Segmenter` unless the string actually needs it:
+
+```javascript
+import { getStringLength, isAsciiString, createRegExp } from '@jarenjs/core/string';
+
+getStringLength('hello', true);       // 5  (ASCII fast path: str.length)
+getStringLength('héllo', true);       // 5  (surrogate-aware code point count)
+getStringLength('👨‍👩‍👧‍👦', true); // 1  (grapheme segmentation, only when clusters can form)
+getStringLength('👨‍👩‍👧‍👦');       // 11 (default: plain UTF-16 length)
+
+createRegExp('^\\p{L}+$');            // cached, unicode-flagged RegExp
+```
+
+## Text validation
+
+`@jarenjs/core/text` is a validation toolbox that backs the [`@jarenjs/formats`](../formats) package but stands on its own — every function takes a string and returns a boolean, with cheap common-case fast paths before comprehensive parsing:
+
+```javascript
+import { isValidEmail, isValidIdnHostname, isValidIPv6, isValidUriTemplate } from '@jarenjs/core/text';
+
+isValidEmail('"joe bloggs"@example.com'); // true (RFC 5321, quoted-string form)
+isValidIdnHostname('실례.테스트');          // true (IDNA contextual rules included)
+isValidIPv6('::ffff:192.168.0.1');        // true
+isValidUriTemplate('/users{/id}{?q}');    // true (RFC 6570)
+```
+
+Grouped by file: `email` (RFC 5321 + internationalized addresses), `host` (hostnames, IDN hostnames, IPv4/IPv6, MAC, URI/URL/IRI and references, URI templates), `identifiers` (UUID, GUID, C/HTML/CSS identifiers), `iregexp` (I-Regexp / RFC 9485 validation and translation to `RegExp`: `isValidIRegexp`, `compileIRegexp`), `base64`, `basic` (alpha, numeric, hex, web colors), `misc` (ISBN-10/13, ISO 3166 country codes, IBAN), `i18n` (Unicode script tests and IDNA context checks) and a complete `punycode` implementation.
+
+## Dates, numbers and math
+
+- `dates` — RFC 3339 date/time/date-time validation and parsing into `Date` (leap years and month lengths included), ISO 8601 durations, and the more lenient ISO date-time forms.
+- `integer`/`float`/`bigint` — range constants and validators for every fixed-width type from `int8` to `uint64` and `float16` to `float64`, including float increment/decrement in representable steps.
+- `math` — asm.js-style typed math (`Int32`, `Float64`) and vector classes (`Vec2i32`, `Vec2f64`, `Vec3f64`) with a fast integer sine approximation.
+
+## JSON addressing standards
+
+The JSON addressing and query standards — JSON validation helpers, JSON Pointer (RFC 6901), the compiling JSONPath engine (RFC 9535), and the Jaren JSON Query language with its XQuery front-end — live in [`@jarenjs/json`](../json). This package supplies their foundations: the char-code scanner (`@jarenjs/core/scan`), `equalsJson` deep equality, code-point ordering, and the I-Regexp (RFC 9485) toolbox.
+
+## Development
+
+Unit tests live in `test/core/` at the repository root (`npm run test:core`). This package's internals are described in its own [ARCHITECTURE](./ARCHITECTURE.md) document; see the repository [README](../../README.md) and [ARCHITECTURE](../../ARCHITECTURE.md) for the monorepo picture, and the [ROADMAP](../../ROADMAP.md) for planned work.

package/dist/types/array.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @brief test if object is instanceof Array, Set or TypedArray!
+ * @param {*} data the data to test
+ * @returns boolean
+ */
+export declare function isArrayish(data: any): boolean;
+/**
+ * Returns a new array containing only the unique elements from the input array.
+ * If the input is an array, it filters out duplicate elements.
+ * If the input is a Set, it converts it to an array.
+ * @param {Array|Set} arr - The input array or Set.
+ * @param {Array|undefined} [def=undefined] - The default value to return if the input is neither an array nor a Set.
+ * @returns {Array|undefined} A new array with unique elements, or the default value if the input is not an array or Set.
+ */
+export declare function getUniqueArray(arr: any[] | Set<any>, def?: any[] | undefined): any[] | undefined;
+/**
+ * Checks if all elements in the input array are unique.
+ * @param {Array} arr - The input array to check for uniqueness.
+ * @returns {boolean} True if all elements are unique, false otherwise.
+ */
+export declare function isUniqueArray(arr: any[]): boolean;
+/**
+ * Checks if all elements in the 'values' array are included in the 'arr' array.
+ * @param {Array} arr - The array to check against.
+ * @param {Array} values - The array of values to check for inclusion.
+ * @returns {boolean} True if all 'values' are included in 'arr', false otherwise.
+ */
+export declare function includesAll(arr: any[], values: any[]): boolean;

package/dist/types/bigint.d.ts

@@ -0,0 +1,5 @@
+export declare function isBigIntishType(data: any): boolean;
+export declare function getBigIntishType(obj: any, def?: undefined): any;
+export declare function BigInt_min(...args: any[]): any;
+export declare function BigInt_max(...args: any[]): any;
+export declare function BigInt_MinMax(...args: any[]): any;

package/dist/types/dates.d.ts

@@ -0,0 +1,79 @@
+export declare const CONST_TICKS_SECOND = 1000;
+export declare const CONST_TICKS_HOUR: number;
+export declare const CONST_TICKS_DAY: number;
+export declare const CONST_TIME_INSERTDATE = "1970-01-01T";
+export declare const CONST_DATE_APPENDTIME = "T00:00:00Z";
+export declare const CONST_RFC3339_DAYS: readonly number[];
+export declare const CONST_RFC3339_REGEX_ISDATE: RegExp;
+export declare const CONST_RFC3339_REGEX_ISTIME: RegExp;
+export declare function isDateType(data: any): boolean;
+export declare function isDateishType(data: any): boolean;
+export declare function isLeapYear(year: any): boolean;
+export declare function isDateOnlyInRange(year?: number, month?: number, day?: number): boolean;
+export declare function isDateOnlyRFC3339(str: any): boolean;
+export declare function isTimeOnlyInRange(hrs?: number, min?: number, sec?: number, tzh?: number, tzm?: number, tzSign?: number): boolean;
+export declare function isTimeOnlyRFC3339(str: any): boolean;
+export declare function isDateTimeRFC3339(str: any): boolean;
+export declare function getDateTypeOfDateOnlyRFC3339(str: any, def?: undefined): Date | undefined;
+export declare function getDateTypeOfTimeOnlyRFC3339(str: any, def?: undefined): Date | undefined;
+export declare function getDateTypeOfDateTimeRFC3339(str: any, def?: undefined): Date | undefined;
+/**
+ * Validates a duration string per RFC 3339.
+ * Duration format: P[n]Y[n]M[n]DT[n]H[n]M[n]S or P[n]W
+ *
+ * @param {string} str - The duration string to validate
+ * @returns {boolean} - True if the string is a valid duration
+ * @example
+ * isValidDuration('P1Y2M3DT4H5M6S'); // true (1 year, 2 months, 3 days, 4 hours, 5 minutes, 6 seconds)
+ * isValidDuration('P1W'); // true (1 week)
+ * isValidDuration('PT1H'); // true (1 hour)
+ * isValidDuration('P1Y'); // true (1 year)
+ * isValidDuration('P'); // false (empty duration)
+ * isValidDuration('1Y'); // false (missing P)
+ */
+export declare function isValidDuration(str: string): boolean;
+/**
+ * Validates an ISO 8601 date-time string with optional timezone.
+ * Unlike RFC 3339, the timezone is optional.
+ *
+ * @param {string} str - The date-time string to validate
+ * @returns {boolean} - True if the string is a valid ISO date-time
+ * @example
+ * isValidISODateTime('2024-01-15T12:30:00Z'); // true
+ * isValidISODateTime('2024-01-15T12:30:00+01:00'); // true
+ * isValidISODateTime('2024-01-15T12:30:00'); // true (no timezone)
+ * isValidISODateTime('2024-01-15 12:30:00'); // true (space separator)
+ * isValidISODateTime('2024-13-15T12:30:00'); // false (invalid month)
+ */
+export declare function isValidISODateTime(str: string): boolean;
+/**
+ * Validates an ISO 8601 time string with optional timezone.
+ * Unlike RFC 3339, the timezone is optional.
+ *
+ * @param {string} str - The time string to validate
+ * @returns {boolean} - True if the string is a valid ISO time
+ * @example
+ * isValidISOTime('12:30:00Z'); // true
+ * isValidISOTime('12:30:00+01:00'); // true
+ * isValidISOTime('12:30:00'); // true (no timezone)
+ * isValidISOTime('25:00:00'); // false (invalid hour)
+ */
+export declare function isValidISOTime(str: string): boolean;
+/**
+ * Parses an ISO 8601 date-time string with optional timezone.
+ * Returns a Date object if valid, otherwise undefined.
+ *
+ * @param {string} str - The date-time string to parse
+ * @param {any} [def=undefined] - Default value to return if invalid
+ * @returns {Date|undefined} - The parsed Date or default value
+ */
+export declare function getDateTypeOfISODateTime(str: string, def?: any): Date | undefined;
+/**
+ * Parses an ISO 8601 time string with optional timezone.
+ * Returns a Date object (with 1970-01-01 as date) if valid, otherwise undefined.
+ *
+ * @param {string} str - The time string to parse
+ * @param {any} [def=undefined] - Default value to return if invalid
+ * @returns {Date|undefined} - The parsed Date or default value
+ */
+export declare function getDateTypeOfISOTime(str: string, def?: any): Date | undefined;

package/dist/types/float.d.ts

@@ -0,0 +1,32 @@
+export declare const FLOAT16_MAX = 65504;
+export declare const FLOAT16_MIN = 0.00006103515625;
+export declare const FLOAT16_EPS = 0.0009765625;
+export declare const FLOAT16_EXBITS = 5;
+export declare const FLOAT16_FRBITS = 10;
+export declare function isValidFloat16(value: any): boolean;
+export declare function getValidFloat16(value: any, defVal?: number): any;
+export declare function Float16_increment(value: any): any;
+export declare function Float16_decrement(value: any): number;
+export declare const FLOAT32_MAX = 3.4028234663852886e+38;
+export declare const FLOAT32_MIN = 1.1754943508222875e-38;
+export declare const FLOAT32_EPS = 1.1920928955078125e-7;
+export declare const FLOAT32_EXBITS = 8;
+export declare const FLOAT32_FRBITS = 23;
+export declare function isValidFloat32(value: any): boolean;
+export declare function getValidFloat32(value: any, defVal?: number): any;
+export declare function Float32_increment(value: any): any;
+export declare function Float32_decrement(value: any): number;
+export declare const FLOAT64_MAX: number;
+export declare const FLOAT64_MIN: number;
+export declare const FLOAT64_EPS: number;
+export declare const FLOAT64_EXBITS = 11;
+export declare const FLOAT64_FRBITS = 52;
+export declare function isValidFloat64(value: any): boolean;
+export declare function getValidFloat64(value: any, defVal?: number): any;
+export declare function Float64_increment(value: any): any;
+export declare function Float64_decrement(value: any): number;
+export declare const FLOAT128_MAX = 0;
+export declare const FLOAT128_MIN = 0;
+export declare const FLOAT128_EPS = 0;
+export declare const FLOAT128_EXBITS = 15;
+export declare const FLOAT128_FRBITS = 112;

package/dist/types/function.d.ts

@@ -0,0 +1,22 @@
+/**
+ * trueThat
+ * acts as a dummy validator that always returns true
+ * @param {any} whatever any json data input
+ * @param {string | undefined} _path the current json path to the data
+ * @param {any | undefined} _root  the root of the json data
+ * @param {string | string[] | undefined} _key a key or an array of keys
+ * @returns {boolean} returns always true
+ */
+export declare function trueThat(whatever: any, _path?: string | undefined, _root?: any | undefined, _key?: string | string[] | undefined): boolean;
+/**
+ * falseThat
+ * acts as a dummy validator that always returns false
+ * @param {any} whatever any json data input
+ * @param {string | undefined} _path the current json path to the data
+ * @param {any | undefined} _root  the root of the json data
+ * @param {string | string[] | undefined} _key a key or an array of keys
+ * @returns {boolean} returns always true
+ */
+export declare function falseThat(whatever: any, _path?: string | undefined, _root?: any | undefined, _key?: string | string[] | undefined): boolean;
+export declare function fallbackFn(compiled: any, fallback?: typeof trueThat): any;
+export declare function addFunctionToArray(arr: any[] | undefined, fn: any): any[];

package/dist/types/index.d.ts

@@ -0,0 +1,119 @@
+export declare function isFn(data: any): boolean;
+export declare function isScalarType(data: any): boolean;
+export declare function isStringType(data: any): data is string;
+/**
+ * Checks if the given data is of boolean type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is a boolean, otherwise false.
+ */
+export declare function isBooleanType(data: any): boolean;
+/**
+ * Checks if the given data is of number type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is a number, otherwise false.
+ */
+export declare function isNumberType(data: any): boolean;
+/**
+ * Checks if the given data is an integer type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is an integer, otherwise false.
+ */
+export declare function isIntegerType(data: any): boolean;
+export declare function isBigIntType(data: any): data is bigint;
+/**
+ * Returns the string type of the input object if it is a string; otherwise, returns the default value.
+ *
+ * @param {any} obj - The input object to check its type.
+ * @param {string|undefined} [def=undefined] - The default value to return if the input object is not a string.
+ * @returns {string} The string type of the input object or the default value.
+ */
+export declare function getStringType(obj: any, def?: string | undefined): string;
+/**
+ * Checks if the given object is a boolean type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {boolean|undefined} [def=undefined] - The default value to return if the object is not a boolean.
+ * @returns {boolean|undefined} - The boolean value or the default value.
+ */
+export declare function getBooleanType(obj: any, def?: boolean | undefined): boolean | undefined;
+/**
+ * Checks if the given object is a number type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {number|undefined} [def=undefined] - The default value to return if the object is not a number.
+ * @returns {number|undefined} - The number value or the default value.
+ */
+export declare function getNumberType(obj: any, def?: number | undefined): number | undefined;
+/**
+ * Checks if the given object is an integer type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {number|undefined} [def=undefined] - The default value to return if the object is not an integer.
+ * @returns {number|undefined} - The integer value or the default value.
+ */
+export declare function getIntegerType(obj: any, def?: number | undefined): number | undefined;
+/**
+ * Checks if the given object is a bigint type and returns it, otherwise returns the default value.
+ * @param {any} obj - The object to check.
+ * @param {bigint|undefined} [def=undefined] - The default value to return if the object is not a bigint.
+ * @returns {bigint|undefined} - The bigint value or the default value.
+ */
+export declare function getBigIntType(obj: any, def?: bigint | undefined): bigint | undefined;
+/**
+ * Checks if the input data is null.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is null, otherwise false.
+ */
+export declare function isNullValue(data: any): boolean;
+/**
+ * Checks if the given data is an object of a specific class.
+ *
+ * @param {any} data - The data to check.
+ * @param {Function} type - The class type to compare against.
+ * @returns {boolean} Returns true if the data is an object of the specified class; otherwise, false.
+ */
+export declare function isObjectOfClass(data: any, type: Function): boolean;
+/**
+ * @brief test if data is an object literal
+ * @param {*} data the data to test
+ * @returns boolean
+ */
+export declare function isObjectClass(data: any): boolean;
+/**
+ * Checks if the input data is of type Map.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is an instance of the Map class, otherwise false.
+ */
+export declare function isMapClass(data: any): boolean;
+/**
+ * @brief test if data is typeof object but not an Array
+ * @param {*} data the data to test
+ * @returns boolean
+ */
+export declare function isObjectType(data: any): boolean;
+/**
+ * Checks if the input data is of type Array.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is an instance of the Array class, otherwise false.
+ */
+export declare function isArrayClass(data: any): boolean;
+/**
+ * Checks if the input data is of type Set.
+ *
+ * @param {any} data - The data to be checked.
+ * @returns {boolean} - Returns true if the data is an instance of the Set class, otherwise false.
+ */
+export declare function isSetClass(data: any): boolean;
+export declare const TypedArray: any;
+export declare function isTypedArray(data: any): boolean;
+export declare function getObjectType(obj: any, def?: undefined): any;
+export declare function getArrayClass(obj: any, def?: undefined): any;
+/**
+ * Calculates the inclusive and exclusive bounds based on the provided parameters.
+ *
+ * @param {function} getType - A function to determine the type of the inclusive and exclusive bounds.
+ * @param {number|string|undefined} inclusive - The inclusive bound value.
+ * @param {number|string|boolean|undefined} exclusive - The exclusive bound value.
+ * @returns {Array} An array containing the inclusive and exclusive bounds.
+ */
+export declare function getInclusiveExclusiveBounds(getType: Function, inclusive: number | string | undefined, exclusive: number | string | boolean | undefined): any[];

package/dist/types/integer.d.ts

@@ -0,0 +1,24 @@
+export declare const INT8_MIN = -128;
+export declare const INT8_MAX = 127;
+export declare function isValidInt8(value: any): boolean;
+export declare const UINT8_MIN = 0;
+export declare const UINT8_MAX = 255;
+export declare function isValidUInt8(value: any): boolean;
+export declare const INT16_MIN = -32768;
+export declare const INT16_MAX = 32767;
+export declare function isValidInt16(value: any): boolean;
+export declare const UINT16_MIN = 0;
+export declare const UINT16_MAX = 65535;
+export declare function isValidUInt16(value: any): boolean;
+export declare const INT32_MIN: number;
+export declare const INT32_MAX: number;
+export declare function isValidInt32(value: any): boolean;
+export declare const UINT32_MIN = 0;
+export declare const UINT32_MAX: number;
+export declare function isValidUInt32(value: any): boolean;
+export declare const INT64_MIN: number;
+export declare const INT64_MAX: number;
+export declare function isValidInt64(value: any): boolean;
+export declare const UINT64_MIN = 0;
+export declare const UINT64_MAX: number;
+export declare function isValidUInt64(value: any): boolean;

package/dist/types/math/float64.d.ts

@@ -0,0 +1,121 @@
+export declare const mathf64_abs: (x: number) => number;
+export declare const mathf64_sqrt: (x: number) => number;
+export declare const mathf64_pow: (x: number, y: number) => number;
+export declare const mathf64_sin: (x: number) => number;
+export declare const mathf64_cos: (x: number) => number;
+export declare const mathf64_atan2: (y: number, x: number) => number;
+export declare const mathf64_asin: (x: number) => number;
+export declare const mathf64_ceil: (x: number) => number;
+export declare const mathf64_floor: (x: number) => number;
+export declare const mathf64_round: (x: number) => number;
+export declare const mathf64_min: (...values: number[]) => number;
+export declare const mathf64_max: (...values: number[]) => number;
+export declare const mathf64_random: () => number;
+export declare const mathf64_EPSILON = 0.000001;
+export declare const mathf64_SQRTFIVE: number;
+export declare const mathf64_PI: number;
+export declare const mathf64_PI2: number;
+export declare const mathf64_PI1H: number;
+export declare const mathf64_PI41: number;
+export declare const mathf64_PI42: number;
+export declare class Float64 {
+    static gcd(a?: number, b?: number): any;
+    static sqrt(n?: number): number;
+    /**
+     *
+     * The Cross Product Magnitude
+     * a × b of two vectors is another vector that is at right angles to both:
+     * The magnitude (length) of the cross product equals the area
+     * of a parallelogram with vectors a and b for sides:
+     *
+     * We can calculate the Cross Product this way:
+     *
+     *    a × b = |a| |b| sin(θ) n
+     *
+     * or as
+     *
+     *    a × b = ax × by - bx × ay
+     *
+     * Another useful property of the cross product is,
+     * that its magnitude is related to the sine of
+     * the angle between the two vectors:
+     *
+     *    | a x b | = |a| . |b| . sine(theta)
+     *
+     * or
+     *
+     *    sine(theta) = | a x b | / (|a| . |b|)
+     *
+     * So, in implementation 1 above, if a and b are known in advance
+     * to be unit vectors then the result of that function is exactly that sine() value.
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} bx
+     * @param {number} by
+     */
+    static cross(ax?: number, ay?: number, bx?: number, by?: number): number;
+    /**
+     *
+     * We can calculate the Dot Product of two vectors this way:
+     *
+     *    a · b = |a| × |b| × cos(θ)
+     *
+     * or in this implementation as:
+     *
+     *    a · b = ax × bx + ay × by
+     *
+     * When two vectors are at right angles to each other the dot product is zero.
+     *
+     * @param {number} ax vector A x velocity
+     * @param {number} ay vector A y velocity
+     * @param {number} bx vector B x velocity
+     * @param {number} by vector B y velocity
+     * @returns {number} scalar of the dot product
+     */
+    static dot(ax?: number, ay?: number, bx?: number, by?: number): number;
+    static mag2(dx?: number, dy?: number): number;
+    static mag(dx?: number, dy?: number): number;
+    static isqrt(n?: number): number;
+    static fib(n?: number): number;
+    static fib2(value?: number): number;
+    static norm(value?: number, min?: number, max?: number): number;
+    static lerp(norm?: number, min?: number, max?: number): number;
+    static map(value?: number, smin?: number, smax?: number, dmin?: number, dmax?: number): number;
+    /**
+     * Clamps a value between a checked boundary.
+     * and can therefor handle swapped min/max arguments
+     *
+     * @param {number} value input value
+     * @param {number} min minimum bounds
+     * @param {number} max maximum bounds
+     * @returns {number} clamped value
+     */
+    static clamp(value?: number, min?: number, max?: number): number;
+    /**
+     * Clamps a value between an unchecked boundary
+     * this function needs min < max!!
+     * (see Float64.clamp for a checked boundary)
+     *
+     * @param {number} value input value
+     * @param {number} min minimum bounds
+     * @param {number} max maximum bounds
+     * @returns {number} clamped value
+     */
+    static clampu(value?: number, min?: number, max?: number): number;
+    static inRange(value?: number, min?: number, max?: number): number;
+    static intersectsRange(smin?: number, smax?: number, dmin?: number, dmax?: number): number;
+    static intersectsRect(ax?: number, ay?: number, aw?: number, ah?: number, bx?: number, by?: number, bw?: number, bh?: number): number;
+    static toRadian(degrees?: number): number;
+    static toDegrees(radians?: number): number;
+    static wrapRadians(r?: number): number;
+    static sinLpEx(r?: number): number;
+    static sinLp(r?: number): number;
+    static cosLp(r?: number): number;
+    static cosHp(r?: number): void;
+    static sinMpEx(r?: number): number;
+    static sinMp(r?: number): number;
+    static cosMp(r?: number): number;
+    static theta(x?: number, y?: number): number;
+    static angle(x?: number, y?: number): number;
+    static phi(y?: number, len?: number): number;
+}

package/dist/types/math/index.d.ts

@@ -0,0 +1,5 @@
+export * from './int32.js';
+export * from './vec2i32.js';
+export * from './float64.js';
+export * from './vec2f64.js';
+export * from './vec3f64.js';

package/dist/types/math/int32.d.ts

@@ -0,0 +1,41 @@
+export declare const mathi32_MULTIPLIER = 10000;
+export declare const mathi32_abs: (x: number) => number;
+export declare const mathi32_round: (x: number) => number;
+export declare const mathi32_ceil: (x: number) => number;
+export declare const mathi32_floor: (x: number) => number;
+export declare const mathi32_min: (...values: number[]) => number;
+export declare const mathi32_max: (...values: number[]) => number;
+export declare const mathi32_sqrt: (x: number) => number;
+export declare const mathi32_asin: (x: number) => number;
+export declare const mathi32_atan2: (y: number, x: number) => number;
+export declare const mathi32_PI: number;
+export declare const mathi32_PI2: number;
+export declare const mathi32_PI1H: number;
+export declare const mathi32_PI41: number;
+export declare const mathi32_PI42: number;
+export declare class Int32 {
+    static random(): number;
+    static sqrt(n?: number): number;
+    static sqrtEx(n?: number): number;
+    static fib(n?: number): number;
+    static mag2(dx?: number, dy?: number): number;
+    static hypot(dx?: number, dy?: number): number;
+    static hypotEx(dx?: number, dy?: number): number;
+    static dot(ax?: number, ay?: number, bx?: number, by?: number): number;
+    static cross(ax?: number, ay?: number, bx?: number, by?: number): number;
+    static norm(value?: number, min?: number, max?: number): number;
+    static lerp(norm?: number, min?: number, max?: number): number;
+    static map(value?: number, smin?: number, smax?: number, dmin?: number, dmax?: number): number;
+    static clamp(value?: number, min?: number, max?: number): number;
+    static clampu(value?: number, min?: number, max?: number): number;
+    static clampu_u8a(value?: number): number;
+    static clampu_u8b(value?: number): number;
+    static inRange(value?: number, min?: number, max?: number): boolean;
+    static intersectsRange(smin?: number, smax?: number, dmin?: number, dmax?: number): boolean;
+    static intersectsRect(ax?: number, ay?: number, aw?: number, ah?: number, bx?: number, by?: number, bw?: number, bh?: number): boolean;
+    static toRadianEx(degrees?: number): number;
+    static toDegreesEx(radians?: number): number;
+    static wrapRadians(r?: number): number;
+    static sinLpEx(r?: number): number;
+    static sinLp(r?: number): number;
+}