@jarenjs/core 0.9.2

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

@@ -0,0 +1,346 @@
+export declare class Vec2f64 {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    /**
+     * Create a new 2 dimensional vector
+     * @param {number | Vec2f64} x a floating point number or a Vec2f64 instance
+     * @param {number | undefined} y a fl
+     * @returns {Vec2f64} a new vector structure
+     */
+    static new(x?: number | Vec2f64, y?: number | undefined): Vec2f64;
+    static neg(v?: Readonly<Vec2f64>): Vec2f64;
+    static add(a?: Readonly<Vec2f64>, b?: Readonly<Vec2f64>): Vec2f64;
+    static adds(v?: Readonly<Vec2f64>, scalar?: number): Vec2f64;
+    static addms(a?: Readonly<Vec2f64>, b?: Readonly<Vec2f64>, scalar?: number): Vec2f64;
+    static sub(a?: Readonly<Vec2f64>, b?: Readonly<Vec2f64>): Vec2f64;
+    static subs(v?: Readonly<Vec2f64>, scalar?: number): Vec2f64;
+    static mul(a?: Readonly<Vec2f64>, b?: Readonly<Vec2f64>): Vec2f64;
+    static muls(v?: Readonly<Vec2f64>, scalar?: number): Vec2f64;
+    static div(a?: Readonly<Vec2f64>, b?: Readonly<Vec2f64>): Vec2f64;
+    static divs(v?: Readonly<Vec2f64>, scalar?: number): Vec2f64;
+    static inv(v?: Readonly<Vec2f64>): Vec2f64;
+    static ceil(v?: Readonly<Vec2f64>): Vec2f64;
+    static floor(v?: Readonly<Vec2f64>): Vec2f64;
+    static round(v?: Readonly<Vec2f64>): Vec2f64;
+    /**
+     * Returns the minimum of two vectors
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {Vec2f64} the new minimum of two vectors
+     */
+    static min(a?: Vec2f64, b?: Vec2f64): Vec2f64;
+    /**
+     * Returns the maximum of two vectors
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {Vec2f64} the new maximum of two vectors
+     */
+    static max(a?: Vec2f64, b?: Vec2f64): Vec2f64;
+    /**
+     * Returns true if two vectors are strictly equal
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {boolean} true if two vectors are strictly equal
+     */
+    static eqstrict(a?: Vec2f64, b?: Vec2f64): boolean;
+    /**
+     * Returns true if two vectors are equal within a small epsilon
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {boolean} true if two vectors are equal within a small epsilon
+     */
+    static equals(a?: Vec2f64, b?: Vec2f64): boolean;
+    /**
+     * Returns the square of the magnitude of the vector
+     * @param {Vec2f64} v the vector
+     * @returns {number} the square of the magnitude of the vector
+     */
+    static mag2(v?: Vec2f64): number;
+    /**
+     * Returns the magnitude of the vector
+     * @param {Vec2f64} v the vector
+     * @returns {number} the magnitude of the vector
+     */
+    static mag(v?: Vec2f64): number;
+    /**
+     * Returns the square of the distance between two vectors
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {number} the square of the distance between two vectors
+     */
+    static dist2(a?: Vec2f64, b?: Vec2f64): number;
+    /**
+     * Returns the distance between two vectors
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {number} the distance between two vectors
+     */
+    static dist(a?: Vec2f64, b?: Vec2f64): number;
+    /**
+     * Returns the dot product of two vectors
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {number} the dot product of two vectors
+     */
+    static dot(a?: Vec2f64, b?: Vec2f64): number;
+    /**
+     * Returns the cross-product of two vectors
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {number} the cross-product of two vectors
+     */
+    static cross(a?: Vec2f64, b?: Vec2f64): number;
+    /**
+     * Returns the cross-product of three vectors
+     *
+     * You can determine which side of a line a point is on
+     * by converting the line to hyperplane form (implicitly
+     * or explicitly) and then computing the perpendicular
+     * (pseudo)distance from the point to the hyperplane.
+     *
+     * With the cross-product of two vectors A and B being the vector
+     *
+     * AxB = (AyBz − AzBy, AzBx − AxBz, AxBy − AyBx)
+     * with Az and Bz being zero you are left with the third component of that vector
+     *
+     *    AxBy - AyBx
+     *
+     * With A being the vector from point a to b, and B being the vector from point a to c means
+     *
+     *    Ax = (b[x]-a[x])
+     *    Ay = (b[y]-a[y])
+     *    Bx = (c[x]-a[x])
+     *    By = (c[y]-a[y])
+     *
+     * giving
+     *
+     *    AxBy - AyBx = (b[x]-a[x])*(c[y]-a[y])-(b[y]-a[y])*(c[x]-a[x])
+     *
+     * which is a scalar, the sign of that scalar will tell you wether point c
+     * lies to the left or right of vector ab
+     *
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the pivot vector
+     * @param {Vec2f64} c the target vector
+     * @returns {number} the cross-product of three vectors
+     */
+    static cross3(a?: Vec2f64, b?: Vec2f64, c?: Vec2f64): number;
+    /**
+     * Returns the angle in radians of its vector
+     * @param {Vec2f64} v the base vector
+     * @returns {number} the angle in radians of its vector
+     */
+    static theta(v?: Vec2f64): number;
+    /**
+     * Returns the angle in radians of its vector
+     * @param {Vec2f64} v the base vector
+     * @returns {number} the angle in radians of its vector
+     */
+    static phi(v?: Vec2f64): number;
+    /**
+     * Returns the unit vector of its vector
+     * @param {Vec2f64} v the base vector
+     * @returns {Vec2f64} the new unit vector of its vector
+     */
+    static unit(v?: Vec2f64): Vec2f64;
+    /**
+     * Returns the vector rotated 90 degrees counter-clockwise
+     * @param {Vec2f64} v the base vector
+     * @returns {Vec2f64} the new vector rotated 90 degrees counter-clockwise
+     */
+    static rotn90(v?: Vec2f64): Vec2f64;
+    /**
+     * Returns the vector rotated 90 degrees clockwise
+     * @param {Vec2f64} v the base vector
+     * @returns {Vec2f64} the new vector rotated 90 degrees clockwise
+     */
+    static rot90(v?: Vec2f64): Vec2f64;
+    /**
+     * Rotates a vector by the specified angle in radians
+     * @param {Vec2f64} v the base vector
+     * @param {number} radians the angle in radians
+     * @returns {Vec2f64} transformed output vector
+     */
+    static rotate(v?: Vec2f64, radians?: number): Vec2f64;
+    /**
+     * Rotates a vector by the specified angle in radians about a specified vector
+     * @param {Vec2f64} a the base vector to rotate
+     * @param {Vec2f64} b the pivot vector to rotate about
+     * @param {number} radians the angle in radians
+     * @returns {Vec2f64} the new transformed output vector
+     */
+    static about(a?: Vec2f64, b?: Vec2f64, radians?: number): Vec2f64;
+    /**
+     * Linearly interpolates between two vectors
+     * @param {number} norm the interpolation factor
+     * @param {Vec2f64} a the base vector
+     * @param {Vec2f64} b the target vector
+     * @returns {Vec2f64} the new interpolated vector
+     */
+    static lerp(norm?: number, a?: Vec2f64, b?: Vec2f64): Vec2f64;
+    /**
+     * Negates the vector in place
+     * @returns {Vec2f64} the negated vector
+     */
+    ineg(): Vec2f64;
+    /**
+     * Adds a vector to the vector in place
+     * @param {Vec2f64} v the target vector
+     * @returns {Vec2f64} the sum of the vectors
+     */
+    iadd(v?: Vec2f64): Vec2f64;
+    /**
+     * Adds a scalar to the vector in place
+     * @param {number} scalar
+     * @returns {Vec2f64} the vector with the scalar added
+     */
+    iadds(scalar?: number): Vec2f64;
+    /**
+     * Adds a vector scaled by a scalar to the vector in place
+     * @param {Vec2f64} v the target vector
+     * @param {number} scalar
+     * @returns {Vec2f64} the vector with the vector scaled by the scalar added
+     */
+    iaddms(v?: Vec2f64, scalar?: number): Vec2f64;
+    /**
+     * Subtracts a vector from the vector in place
+     * @param {Vec2f64} v the target vector
+     * @returns {Vec2f64} the difference of the vectors
+     */
+    isub(v?: Vec2f64): Vec2f64;
+    /**
+     * Subtracts a scalar from the vector in place
+     * @param {number} scalar
+     * @returns {Vec2f64} the vector with the scalar subtracted
+     */
+    isubs(scalar?: number): Vec2f64;
+    /**
+     * Multiplies the vector by a vector in place
+     * @param {Vec2f64} v the target vector
+     * @returns {Vec2f64} the product of the vectors
+     */
+    imul(v?: Vec2f64): Vec2f64;
+    /**
+     * Multiplies the vector by a scalar in place
+     * @param {number} scalar
+     * @returns {Vec2f64} the vector with the scalar multiplied
+     */
+    imuls(scalar?: number): Vec2f64;
+    /**
+     * Divides the vector by a vector in place
+     * @param {Vec2f64} v the target vector
+     * @returns {Vec2f64} the quotient of the vectors
+     */
+    idiv(v?: Vec2f64): Vec2f64;
+    /**
+     * Divides a vector by a scalar in place
+     * @param {number} scalar
+     * @returns {Vec2f64} the vector with the scalar divided
+     */
+    idivs(scalar?: number): Vec2f64;
+    /**
+     * Inverts the vector in place
+     * @returns {Vec2f64} the inverted vector
+     */
+    iinv(): Vec2f64;
+    /**
+     * Rounds the vector in place
+     * @returns {Vec2f64} the rounded vector
+     */
+    iceil(): Vec2f64;
+    /**
+     * Floors the vector in place
+     * @returns {Vec2f64} the floored vector
+     */
+    ifloor(): Vec2f64;
+    /**
+     * Rounds the vector in place
+     * @returns {Vec2f64} the rounded vector
+     */
+    iround(): Vec2f64;
+    /**
+     * Returns the minimum of two vectors in place
+     * @param {Vec2f64} v the target vector
+     * @returns {Vec2f64} the minimum of two vectors
+     */
+    imin(v?: Vec2f64): Vec2f64;
+    /**
+     * Returns the maximum of two vectors in place
+     * @param {Vec2f64} v the target vector
+     * @returns {Vec2f64} the maximum of two vectors
+     */
+    imax(v?: Vec2f64): Vec2f64;
+    /**
+     * Returns the square of the magnitude of the vector
+     * @returns {number} the square of the magnitude of the vector
+     */
+    mag2(): number;
+    /**
+     * Returns the magnitude of the vector
+     * @returns {number} the magnitude of the vector
+     */
+    mag(): number;
+    /**
+     * Returns the angle in radians of its vector
+     * @returns {number} the angle in radians of its vector
+     */
+    phi(): number;
+    /**
+     * Returns the dot product of this vector and the target vector
+     * @param {Vec2f64} v the target vector
+     * @returns {number} the dot product of two vectors
+     */
+    dot(v?: Vec2f64): number;
+    /**
+     * Returns the cross-product of this vector and the target vector
+     * @param {Vec2f64} v the target vector
+     * @returns {number} The cross product of two vectors
+     */
+    cross(v?: Vec2f64): number;
+    /**
+     * Returns the cross-product of three vectors
+     * @param {Vec2f64} a B
+     * @param {Vec2f64} b C
+     * @returns {number} The cross product of three vectors
+     *
+     */
+    cross3(a?: Vec2f64, b?: Vec2f64): number;
+    /**
+     * Returns the angle in radians of its vector
+     *
+     * Math.atan2(dy, dx) === Math.asin(dy/Math.sqrt(dx*dx + dy*dy))
+     *
+     * @returns {number} the angle in radians of its vector
+     */
+    theta(): number;
+    /**
+     * Returns the unit vector of its vector in place
+     * @returns {Vec2f64} the unit vector of its vector
+     */
+    iunit(): Vec2f64;
+    /**
+     * Rotates a vector 90 degrees counter-clockwise in place
+     * @returns {Vec2f64} the vector rotated 90 degrees counter-clockwise
+     */
+    irotn90(): Vec2f64;
+    /**
+     * Rotates a vector 90 degrees clockwise in place
+     * @returns {Vec2f64} the vector rotated 90 degrees clockwise
+     */
+    irot90(): Vec2f64;
+    /**
+     * Rotates a vector by the specified angle in radians in place
+     * @param {number} radians  angle in radians
+     * @returns {Vec2f64} transformed output vector
+     */
+    irotate(radians?: number): Vec2f64;
+    /**
+     * Rotates a vector by the specified angle in radians about a specified vector in place
+     * @param {Vec2f64} v the pivot vector
+     * @param {number} radians the angle in radians to rotate by
+     * @returns {Vec2f64} transformed output vector
+     */
+    iabout(v?: Vec2f64, radians?: number): Vec2f64;
+}
+export declare const def_Vec2f64: Readonly<Vec2f64>;

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

@@ -0,0 +1,43 @@
+export declare class Vec2i32 {
+    x: number;
+    y: number;
+    /**
+     * @param {number | undefined} x
+     * @param {number | undefined} y
+     */
+    constructor(x?: number | undefined, y?: number | undefined);
+    static new(x?: number, y?: number): Vec2i32;
+    new(): Vec2i32;
+    static neg(v?: Readonly<Vec2i32>): Vec2i32;
+    static add(a?: Readonly<Vec2i32>, b?: Readonly<Vec2i32>): Vec2i32;
+    static adds(v?: Readonly<Vec2i32>, scalar?: number): Vec2i32;
+    static sub(a?: Readonly<Vec2i32>, b?: Readonly<Vec2i32>): Vec2i32;
+    static subs(a?: Readonly<Vec2i32>, scalar?: number): Vec2i32;
+    static mul(a?: Readonly<Vec2i32>, b?: Readonly<Vec2i32>): Vec2i32;
+    static muls(v?: Readonly<Vec2i32>, scalar?: number): Vec2i32;
+    static div(a?: Readonly<Vec2i32>, b?: Readonly<Vec2i32>): Vec2i32;
+    static divs(v?: Readonly<Vec2i32>, scalar?: number): Vec2i32;
+    static mag2(v?: Readonly<Vec2i32>): number;
+    static mag(v?: Readonly<Vec2i32>): number;
+    static dot(a?: Readonly<Vec2i32>, b?: Readonly<Vec2i32>): number;
+    static cross(a?: Readonly<Vec2i32>, b?: Readonly<Vec2i32>): number;
+    static cross3(a?: Readonly<Vec2i32>, b?: Readonly<Vec2i32>, c?: Readonly<Vec2i32>): number;
+    static thetaEx(v?: Readonly<Vec2i32>): number;
+    static phiEx(v?: Readonly<Vec2i32>): number;
+    static norm(v?: Readonly<Vec2i32>): Vec2i32;
+    static rotn90(v?: Readonly<Vec2i32>): Vec2i32;
+    static rot90(v?: Readonly<Vec2i32>): Vec2i32;
+    ineg(): this;
+    iadd(v?: Readonly<Vec2i32>): this;
+    iadds(scalar?: number): this;
+    isub(v?: Readonly<Vec2i32>): this;
+    isubs(scalar?: number): this;
+    imul(v?: Readonly<Vec2i32>): this;
+    imuls(scalar?: number): this;
+    idiv(v?: Readonly<Vec2i32>): this;
+    idivs(scalar?: number): this;
+    inorm(): this;
+    irotn90(): this;
+    irot90(): this;
+}
+export declare const def_Vec2i32: Readonly<Vec2i32>;

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

@@ -0,0 +1,61 @@
+import { Vec2f64 } from './vec2f64.js';
+/**
+ * @class Vec3f64
+ * @classdesc A 3-dimensional vector of float64 values
+ * @property {double} x - The x component of the vector
+ * @property {double} y - The y component of the vector
+ * @property {double} z - The z component of the vector
+ */
+export declare class Vec3f64 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    /**
+     * Create a new 3 dimensional vector
+     * @param {number | Vec3f64 | Vec2f64} x a floating point number or a Vec3f64 instance or a vec2f64 instance
+     * @param {number | undefined} y a floating point number
+     * @param {number | undefined} z a floating point number
+     * @returns {Vec3f64} a new vector structure
+     */
+    static new(x?: number | Vec3f64 | Vec2f64, y?: number | undefined, z?: number | undefined): Vec3f64;
+    static add(a?: Readonly<Vec3f64>, b?: Readonly<Vec3f64>): Vec3f64;
+    static adds(a?: Readonly<Vec3f64>, scalar?: number): Vec3f64;
+    static sub(a?: Readonly<Vec3f64>, b?: Readonly<Vec3f64>): Vec3f64;
+    static subs(a?: Readonly<Vec3f64>, scalar?: number): Vec3f64;
+    static div(a?: Readonly<Vec3f64>, b?: Readonly<Vec3f64>): Vec3f64;
+    static divs(v?: Readonly<Vec3f64>, scalar?: number): Vec3f64;
+    static mul(a?: Readonly<Vec3f64>, b?: Readonly<Vec3f64>): Vec3f64;
+    static muls(v?: Readonly<Vec3f64>, scalar?: number): Vec3f64;
+    /**
+     * Returns the dot product of two 3d vectors
+     * @param {Vec3f64} a the base vector
+     * @param {Vec3f64} b the target vector
+     * @returns {number} the dot product of two vectors
+     */
+    static dot(a?: Vec3f64, b?: Vec3f64): number;
+    /**
+     * Returns the cross product of two 3d vectors
+     * @param {Vec3f64} a the base vector
+     * @param {Vec3f64} b the target vector
+     * @returns {Vec3f64} the cross product of two vectors
+     */
+    static cross(a?: Vec3f64, b?: Vec3f64): Vec3f64;
+    static mag2(v?: Readonly<Vec3f64>): number;
+    static mag(v?: Readonly<Vec3f64>): number;
+    static unit(v?: Readonly<Vec3f64>): Vec3f64;
+    iadd(v?: Readonly<Vec3f64>): this;
+    iadds(scalar?: number): this;
+    isub(v?: Readonly<Vec3f64>): this;
+    isubs(scalar?: number): this;
+    idiv(v?: Readonly<Vec3f64>): this;
+    idivs(scalar?: number): this;
+    imul(v?: Readonly<Vec3f64>): this;
+    imuls(scalar?: number): this;
+    dot(v?: Readonly<Vec3f64>): number;
+    icross(v?: Readonly<Vec3f64>): this;
+    mag2(): number;
+    mag(): number;
+    iunit(): this;
+}
+export declare const def_Vec3f64: Readonly<Vec3f64>;

package/dist/types/number.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Checks if the given data is of boolean type or boolean-like (the strings 'true' or 'false').
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is boolean or boolean-like, otherwise false.
+ */
+export declare function isBoolishType(data: any): boolean;
+/**
+ * Checks if the given object is a boolean type or a boolean-like string ('true' or 'false') 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 or boolean-like string.
+ * @returns {boolean|undefined} - The boolean/boolean-like value or the default value.
+ */
+export declare function getBoolishType(obj: any, def?: boolean | undefined): boolean | undefined;
+/**
+ * Checks if the given data is number-like (can be converted to a number).
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is number-like, otherwise false.
+ */
+export declare function isNumbishType(data: any): boolean;
+/**
+ * Checks if the given data is an integer-like type.
+ * @param {any} data - The data to check.
+ * @returns {boolean} - True if the data is an integer-like type, otherwise false.
+ */
+export declare function isIntishType(data: any): boolean;
+/**
+ * Checks if the given object is a number-like type and returns it as a number, 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-like type.
+ * @returns {number|undefined} - The number value or the default value.
+ */
+export declare function getNumbishType(obj: any, def?: number | undefined): number | undefined;
+/**
+ * Checks if the given object is an integer-like type and returns it as a number, 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-like type.
+ * @returns {number|undefined} - The integer value or the default value.
+ */
+export declare function getIntishType(obj: any, def?: number | undefined): number | undefined;

package/dist/types/object.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Deep equality comparison for arbitrary values.
+ *
+ * Generic JavaScript equality: understands Maps, Sets, RegExps,
+ * functions, typed arrays and class instances (constructors must
+ * match). Not the same as `equalsJson`, which compares JSON values
+ * only and is the hot-path variant — keep both.
+ * @param {any} target
+ * @param {any} source
+ * @returns {boolean}
+ */
+export declare function equalsDeep(target: any, source: any): boolean;
+/**
+ * Structural equality of two JSON values per RFC 9535 section 2.3.5.2.2.
+ *
+ * JSON-only equality: objects compare by own enumerable keys, arrays by
+ * index, primitives by `===` (so `1 === 1.0`, and `NaN` is never equal).
+ * Anything a JSON value cannot be — Map, Set, RegExp, function, class
+ * instance — compares by identity only. Deliberately not the same as
+ * `equalsDeep`, the generic JavaScript variant: this is the hot-path
+ * comparator of the JSONPath engine — do not merge the two.
+ * @param {any} a
+ * @param {any} b
+ * @returns {boolean}
+ */
+export declare function equalsJson(a: any, b: any): boolean;
+/**
+ * Check if all items in an array are unique using deep equality
+ * @param {any[]} arr - The array to check
+ * @returns {boolean} True if all items are unique
+ */
+export declare function isUniqueDeepArray(arr: any[]): boolean;
+/**
+ *
+ * @param {Map<any, any>} map
+ * @param {...Map<any, any>} iterables
+ */
+export declare function mergeMap(map: Map<any, any>, ...iterables: Map<any, any>[]): void;
+/**
+ *
+ * @param {Set<any>} set
+ * @param  {...Array<Set<any>>} iterables
+ */
+export declare function mergeSet(set: Set<any>, ...iterables: Array<Set<any>>[]): void;

package/dist/types/scan.d.ts

@@ -0,0 +1,64 @@
+export declare const CC_TAB = 9;
+export declare const CC_LF = 10;
+export declare const CC_CR = 13;
+export declare const CC_SPACE = 32;
+export declare const CC_BANG = 33;
+export declare const CC_DQUOTE = 34;
+export declare const CC_HASH = 35;
+export declare const CC_DOLLAR = 36;
+export declare const CC_PERCENT = 37;
+export declare const CC_AMP = 38;
+export declare const CC_SQUOTE = 39;
+export declare const CC_LPAREN = 40;
+export declare const CC_RPAREN = 41;
+export declare const CC_STAR = 42;
+export declare const CC_COMMA = 44;
+export declare const CC_MINUS = 45;
+export declare const CC_DOT = 46;
+export declare const CC_SLASH = 47;
+export declare const CC_0 = 48;
+export declare const CC_1 = 49;
+export declare const CC_9 = 57;
+export declare const CC_COLON = 58;
+export declare const CC_LT = 60;
+export declare const CC_EQ = 61;
+export declare const CC_GT = 62;
+export declare const CC_QUESTION = 63;
+export declare const CC_AT = 64;
+export declare const CC_LBRACKET = 91;
+export declare const CC_BACKSLASH = 92;
+export declare const CC_RBRACKET = 93;
+export declare const CC_UNDERSCORE = 95;
+export declare const CC_PIPE = 124;
+export declare const CC_TILDE = 126;
+/**
+ * Checks if a char code is an ASCII digit (0-9).
+ * @param {number} c - The char code
+ * @returns {boolean}
+ */
+export declare function isDigitCode(c: number): boolean;
+/**
+ * Checks if a char code is an ASCII hexadecimal digit (0-9, A-F, a-f).
+ * @param {number} c - The char code
+ * @returns {boolean}
+ */
+export declare function isHexDigitCode(c: number): boolean;
+/**
+ * Checks if a char code is blank space per RFC 9535 (space, tab,
+ * line feed or carriage return).
+ * @param {number} c - The char code
+ * @returns {boolean}
+ */
+export declare function isWhitespaceCode(c: number): boolean;
+/**
+ * Checks if a char code is an ASCII lowercase letter (a-z).
+ * @param {number} c - The char code
+ * @returns {boolean}
+ */
+export declare function isAsciiLowerCode(c: number): boolean;
+/**
+ * Checks if a char code is an ASCII uppercase letter (A-Z).
+ * @param {number} c - The char code
+ * @returns {boolean}
+ */
+export declare function isAsciiUpperCode(c: number): boolean;

package/dist/types/string.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @param {string | null | undefined} data
+ * @returns {boolean}
+ */
+export declare function isStringEmpty(data: string | null | undefined): boolean;
+/**
+ * @param {string | null | undefined} data
+ * @returns {boolean}
+ */
+export declare function isStringWhiteSpace(data: string | null | undefined): boolean;
+/**
+ * @param {string} str
+ * @returns {boolean}
+ */
+export declare function isStringUpperCase(str: string): boolean;
+/**
+ * @param {string} str
+ * @returns {boolean}
+ */
+export declare function isStringLowerCase(str: string): boolean;
+/**
+ * @param {unknown} data
+ * @returns {data is RegExp}
+ */
+export declare function isRegExpType(data: unknown): data is RegExp;
+/**
+ * @param {string | RegExp | null | undefined } data
+ * @returns {boolean}
+ */
+export declare function isStringRegExp(data: string | RegExp | null | undefined): boolean;
+/**
+ * @param {string | RegExp | null | undefined } pattern
+ * @returns {RegExp | undefined}
+ */
+export declare function createRegExp(pattern: string | RegExp | null | undefined): RegExp | undefined;
+export declare function getSegmenter(): Intl.Segmenter;
+/**
+ * @param {string} str
+ * @returns {boolean}
+ */
+export declare function isAsciiString(str: string): boolean;
+/**
+ * @param {string} str
+ * @param {boolean} [useGrapheme=false]
+ * @returns {number}
+ */
+export declare function getStringLength(str: string, useGrapheme?: boolean): number;
+/**
+ * Count the Unicode code points of a string (surrogate-pair aware;
+ * a lone surrogate counts as one code point).
+ * @param {string} str
+ * @returns {number}
+ */
+export declare function countCodePoints(str: string): number;
+/**
+ * Compare two strings by Unicode scalar values (code points), per
+ * RFC 9535 section 2.3.5.2.2. This differs from JavaScript's native
+ * `<`, which compares UTF-16 code units and orders surrogate pairs
+ * (U+10000 and up) below unpaired BMP characters in U+E000-U+FFFF.
+ * When one string is a prefix of the other, the shorter sorts first.
+ * @param {string} a
+ * @param {string} b
+ * @returns {number} -1 when a < b, 0 when equal, 1 when a > b
+ */
+export declare function compareCodePoints(a: string, b: string): number;

package/dist/types/text/base64.d.ts

@@ -0,0 +1,4 @@
+export declare function isValidBase64Full(str: any): boolean;
+export declare function isValidBase64Old(str: any): boolean;
+export declare function isValidBase64(str: any): boolean;
+export declare function isValidBase64Fast(str: any): boolean;

package/dist/types/text/basic.d.ts

@@ -0,0 +1,5 @@
+export declare function isValidAlpha(str: any): boolean;
+export declare function isValidAlphaNumeric(str: any): boolean;
+export declare function isValidNumeric(str: any): boolean;
+export declare function isValidHexaDecimal(str: any): boolean;
+export declare function isValidHexColor(str: any): boolean;

package/dist/types/text/email.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidEmail(str: any): boolean;
+export declare function isValidEmailFull(str: any): boolean;
+export declare function isValidIdnEmail(str: any): boolean;