@ntf/math 1.4.1 → 1.4.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/index.d.mts +741 -727
  2. package/dist/index.d.ts +741 -727
  3. package/dist/index.js +1 -3204
  4. package/dist/index.mjs +1 -3181
  5. package/package.json +6 -9
package/dist/index.d.mts CHANGED
@@ -1,201 +1,206 @@
1
- import { IToString, NodeJSCustomInspect, FixedArray } from '@ntf/types';
1
+ import { FixedArray, IToString, NodeJSCustomInspect } from "@ntf/types";
2
2
 
3
+ //#region source/geometry/object.d.ts
3
4
  interface IGeometryObject extends IToString {
4
- readonly area: number;
5
- readonly perimeter: number;
5
+ readonly area: number;
6
+ readonly perimeter: number;
6
7
  }
7
-
8
+ //#endregion
9
+ //#region source/geometry/size.d.ts
8
10
  interface ISize {
9
- width: number;
10
- height: number;
11
+ width: number;
12
+ height: number;
11
13
  }
12
14
  interface IToSize {
13
- toSize(): SizeLike;
15
+ toSize(): SizeLike;
14
16
  }
15
17
  type SizeArray = [number, number];
16
18
  type SizeString = `${number}x${number}`;
17
19
  type SizeLike = ISize | SizeArray | SizeString | number | IToSize;
18
20
  type SizeArguments = [size: SizeLike] | SizeArray;
19
21
  declare class Size implements ISize, IGeometryObject, IToVec2 {
20
- width: number;
21
- height: number;
22
- get aspectRatio(): number;
23
- get area(): number;
24
- get perimeter(): number;
25
- static resolve(a: unknown): Size;
26
- static resolveArgs(args: SizeArguments): Size;
27
- static cast(a: unknown): Size | undefined;
28
- static is(a: unknown): a is SizeLike;
29
- constructor(width: number, height: number);
30
- toArray(): SizeArray;
31
- toString(): SizeString;
32
- get [Symbol.toStringTag](): string;
33
- [NodeJSCustomInspect](): string;
34
- toJSON(): ISize;
35
- clone(): Size;
36
- equals(size: SizeLike): boolean;
37
- equals(width: number, height: number): boolean;
38
- toVec2(): Vec2Like;
39
- }
40
-
22
+ width: number;
23
+ height: number;
24
+ get aspectRatio(): number;
25
+ get area(): number;
26
+ get perimeter(): number;
27
+ static resolve(a: unknown): Size;
28
+ static resolveArgs(args: SizeArguments): Size;
29
+ static cast(a: unknown): Size | undefined;
30
+ static is(a: unknown): a is SizeLike;
31
+ constructor(width: number, height: number);
32
+ toArray(): SizeArray;
33
+ toString(): SizeString;
34
+ get [Symbol.toStringTag](): string;
35
+ [NodeJSCustomInspect](): string;
36
+ toJSON(): ISize;
37
+ clone(): Size;
38
+ equals(size: SizeLike): boolean;
39
+ equals(width: number, height: number): boolean;
40
+ toVec2(): Vec2Like;
41
+ }
42
+ //#endregion
43
+ //#region source/geometry/circle.d.ts
41
44
  interface ICircle extends IVec2 {
42
- radius: number;
45
+ radius: number;
43
46
  }
44
47
  interface IToCircle {
45
- toCircle(): CircleLike;
48
+ toCircle(): CircleLike;
46
49
  }
47
50
  type CircleArray = [...Vec2Array, number];
48
51
  type CircleString = `${Vec2String}|${number}`;
49
52
  type CircleLike = ICircle | CircleArray | CircleString | IToCircle;
50
53
  type CircleArguments = [circle: CircleLike] | [position: Vec2Like, radius: number] | CircleArray;
51
54
  declare class Circle implements ICircle, IGeometryObject, IToVec2 {
52
- radius: number;
53
- get perimeter(): number;
54
- get area(): number;
55
- position: Vec2;
56
- get x(): number;
57
- set x(val: number);
58
- get y(): number;
59
- set y(val: number);
60
- get w(): number;
61
- set w(val: number);
62
- static resolve(a: unknown): Circle;
63
- static resolveArgs(args: CircleArguments): Circle;
64
- static cast(a: unknown): Circle | undefined;
65
- static is(a: unknown): a is CircleLike;
66
- constructor(position: Vec2Like, radius: number);
67
- toArray(): CircleArray;
68
- toJSON(): ICircle;
69
- toString(): CircleString;
70
- get [Symbol.toStringTag](): string;
71
- [NodeJSCustomInspect](): string;
72
- clone(): Circle;
73
- toVec2(): Vec2Like;
74
- equals(circle: CircleLike): boolean;
75
- equals(x: number, y: number, radius: number): boolean;
76
- equals(position: Vec2Like, radius: number): boolean;
77
- inside(circle: CircleLike): boolean;
78
- inside(x: number, y: number, radius: number): boolean;
79
- inside(position: Vec2Like, radius: number): boolean;
80
- insidePoint(point: Vec2Like): boolean;
81
- insidePoint(x: number, y: number): boolean;
82
- }
83
-
84
- interface IRectangle extends IVec2, ISize {
85
- }
55
+ radius: number;
56
+ get perimeter(): number;
57
+ get area(): number;
58
+ position: Vec2;
59
+ get x(): number;
60
+ set x(val: number);
61
+ get y(): number;
62
+ set y(val: number);
63
+ get w(): number;
64
+ set w(val: number);
65
+ static resolve(a: unknown): Circle;
66
+ static resolveArgs(args: CircleArguments): Circle;
67
+ static cast(a: unknown): Circle | undefined;
68
+ static is(a: unknown): a is CircleLike;
69
+ constructor(position: Vec2Like, radius: number);
70
+ toArray(): CircleArray;
71
+ toJSON(): ICircle;
72
+ toString(): CircleString;
73
+ get [Symbol.toStringTag](): string;
74
+ [NodeJSCustomInspect](): string;
75
+ clone(): Circle;
76
+ toVec2(): Vec2Like;
77
+ equals(circle: CircleLike): boolean;
78
+ equals(x: number, y: number, radius: number): boolean;
79
+ equals(position: Vec2Like, radius: number): boolean;
80
+ inside(circle: CircleLike): boolean;
81
+ inside(x: number, y: number, radius: number): boolean;
82
+ inside(position: Vec2Like, radius: number): boolean;
83
+ insidePoint(point: Vec2Like): boolean;
84
+ insidePoint(x: number, y: number): boolean;
85
+ }
86
+ //#endregion
87
+ //#region source/geometry/rectangle.d.ts
88
+ interface IRectangle extends IVec2, ISize {}
86
89
  interface IToRectangle {
87
- toRectangle(): RectangleLike;
90
+ toRectangle(): RectangleLike;
88
91
  }
89
92
  type RectangleArray = [...Vec2Array, ...SizeArray];
90
93
  type RectangleString = `${Vec2String}|${SizeString}`;
91
94
  type RectangleLike = IRectangle | RectangleArray | RectangleString | IToRectangle;
92
95
  type RectangleArguments = [rectangle: RectangleLike] | [position: Vec2Like, size: SizeLike] | RectangleArray;
93
96
  declare class Rectangle implements IRectangle, IGeometryObject, IToBoundingBox, IToVec2, IToSize {
94
- position: Vec2;
95
- size: Size;
96
- get area(): number;
97
- get perimeter(): number;
98
- get x(): number;
99
- set x(val: number);
100
- get y(): number;
101
- set y(val: number);
102
- get w(): number;
103
- set w(val: number);
104
- get width(): number;
105
- set width(val: number);
106
- get height(): number;
107
- set height(val: number);
108
- static resolve(a: unknown): Rectangle;
109
- static resolveArgs(args: RectangleArguments): Rectangle;
110
- static cast(a: unknown): Rectangle | undefined;
111
- static is(a: unknown): a is RectangleLike;
112
- constructor(pos: Vec2Like, size: SizeLike);
113
- toArray(w?: boolean): RectangleArray;
114
- toString(w?: boolean): RectangleString;
115
- get [Symbol.toStringTag](): string;
116
- [NodeJSCustomInspect](): string;
117
- toJSON(): IRectangle;
118
- toBoundingBox(): BoundingBoxLike;
119
- toVec2(): Vec2Like;
120
- toSize(): SizeLike;
121
- clone(): Rectangle;
122
- equals(rectangle: RectangleLike): boolean;
123
- equals(position: Vec2Like, size: SizeLike): boolean;
124
- equals(x: number, y: number, width: number, height: number): boolean;
125
- }
126
-
97
+ position: Vec2;
98
+ size: Size;
99
+ get area(): number;
100
+ get perimeter(): number;
101
+ get x(): number;
102
+ set x(val: number);
103
+ get y(): number;
104
+ set y(val: number);
105
+ get w(): number;
106
+ set w(val: number);
107
+ get width(): number;
108
+ set width(val: number);
109
+ get height(): number;
110
+ set height(val: number);
111
+ static resolve(a: unknown): Rectangle;
112
+ static resolveArgs(args: RectangleArguments): Rectangle;
113
+ static cast(a: unknown): Rectangle | undefined;
114
+ static is(a: unknown): a is RectangleLike;
115
+ constructor(pos: Vec2Like, size: SizeLike);
116
+ toArray(w?: boolean): RectangleArray;
117
+ toString(w?: boolean): RectangleString;
118
+ get [Symbol.toStringTag](): string;
119
+ [NodeJSCustomInspect](): string;
120
+ toJSON(): IRectangle;
121
+ toBoundingBox(): BoundingBoxLike;
122
+ toVec2(): Vec2Like;
123
+ toSize(): SizeLike;
124
+ clone(): Rectangle;
125
+ equals(rectangle: RectangleLike): boolean;
126
+ equals(position: Vec2Like, size: SizeLike): boolean;
127
+ equals(x: number, y: number, width: number, height: number): boolean;
128
+ }
129
+ //#endregion
130
+ //#region source/geometry/bbox.d.ts
127
131
  interface IBoundingBox {
128
- left: number;
129
- right: number;
130
- top: number;
131
- bottom: number;
132
+ left: number;
133
+ right: number;
134
+ top: number;
135
+ bottom: number;
132
136
  }
133
137
  interface IToBoundingBox {
134
- toBoundingBox(): BoundingBoxLike;
138
+ toBoundingBox(): BoundingBoxLike;
135
139
  }
136
140
  type BoundingBoxArray = [number, number, number, number];
137
141
  type BoundingBoxString = `${number},${number},${number},${number}`;
138
- type BoundingBoxLike = IBoundingBox | BoundingBoxArray | BoundingBoxString | IToBoundingBox;
142
+ type BoundingBoxLike = IBoundingBox | BoundingBoxArray | BoundingBoxString | IToBoundingBox | number;
139
143
  type BoundingBoxArgs = [bbox: BoundingBoxLike] | BoundingBoxArray;
140
144
  declare class BoundingBox implements IBoundingBox, IRectangle, IToRectangle, IToString {
141
- left: number;
142
- right: number;
143
- top: number;
144
- bottom: number;
145
- get width(): number;
146
- set width(val: number);
147
- get height(): number;
148
- set height(val: number);
149
- get x(): number;
150
- set x(x: number);
151
- get y(): number;
152
- set y(y: number);
153
- w: number;
154
- static resolve(a: unknown): BoundingBox;
155
- static resolveArgs(args: BoundingBoxArgs): BoundingBox;
156
- static cast(a: unknown): BoundingBox | undefined;
157
- static is(a: unknown): a is BoundingBoxLike;
158
- constructor(left: number, right: number, top: number, bottom: number);
159
- toArray(): BoundingBoxArray;
160
- toString(): BoundingBoxString;
161
- get [Symbol.toStringTag](): string;
162
- [NodeJSCustomInspect](): string;
163
- toJSON(): IBoundingBox;
164
- clone(): BoundingBox;
165
- equals(bbox: BoundingBoxLike): boolean;
166
- equals(left: number, right: number, top: number, bottom: number): boolean;
167
- toSize(): SizeLike;
168
- toVec2(): Vec2Like;
169
- toRectangle(): RectangleLike;
170
- inside(bbox: BoundingBoxLike): boolean;
171
- inside(left: number, right: number, top: number, bottom: number): boolean;
172
- insidePoint(point: Vec2Like): boolean;
173
- insidePoint(x: number, y: number): boolean;
174
- insideCircle(circle: CircleLike): boolean;
175
- insideCircle(x: number, y: number, radius: number): boolean;
176
- insideCircle(position: Vec2Like, radius: number): boolean;
177
- }
178
-
145
+ left: number;
146
+ right: number;
147
+ top: number;
148
+ bottom: number;
149
+ get width(): number;
150
+ set width(val: number);
151
+ get height(): number;
152
+ set height(val: number);
153
+ get x(): number;
154
+ set x(x: number);
155
+ get y(): number;
156
+ set y(y: number);
157
+ w: number;
158
+ static resolve(a: unknown): BoundingBox;
159
+ static resolveArgs(args: BoundingBoxArgs): BoundingBox;
160
+ static cast(a: unknown): BoundingBox | undefined;
161
+ static is(a: unknown): a is BoundingBoxLike;
162
+ constructor(left: number, right: number, top: number, bottom: number);
163
+ toArray(): BoundingBoxArray;
164
+ toString(): BoundingBoxString;
165
+ get [Symbol.toStringTag](): string;
166
+ [NodeJSCustomInspect](): string;
167
+ toJSON(): IBoundingBox;
168
+ clone(): BoundingBox;
169
+ equals(bbox: BoundingBoxLike): boolean;
170
+ equals(left: number, right: number, top: number, bottom: number): boolean;
171
+ toSize(): SizeLike;
172
+ toVec2(): Vec2Like;
173
+ toRectangle(): RectangleLike;
174
+ inside(bbox: BoundingBoxLike): boolean;
175
+ inside(left: number, right: number, top: number, bottom: number): boolean;
176
+ insidePoint(point: Vec2Like): boolean;
177
+ insidePoint(x: number, y: number): boolean;
178
+ insideCircle(circle: CircleLike): boolean;
179
+ insideCircle(x: number, y: number, radius: number): boolean;
180
+ insideCircle(position: Vec2Like, radius: number): boolean;
181
+ }
182
+ //#endregion
183
+ //#region source/matrices/mat4.d.ts
179
184
  interface IMat4 {
180
- m00: number;
181
- m01: number;
182
- m02: number;
183
- m03: number;
184
- m10: number;
185
- m11: number;
186
- m12: number;
187
- m13: number;
188
- m20: number;
189
- m21: number;
190
- m22: number;
191
- m23: number;
192
- m30: number;
193
- m31: number;
194
- m32: number;
195
- m33: number;
185
+ m00: number;
186
+ m01: number;
187
+ m02: number;
188
+ m03: number;
189
+ m10: number;
190
+ m11: number;
191
+ m12: number;
192
+ m13: number;
193
+ m20: number;
194
+ m21: number;
195
+ m22: number;
196
+ m23: number;
197
+ m30: number;
198
+ m31: number;
199
+ m32: number;
200
+ m33: number;
196
201
  }
197
202
  interface IToMat4 {
198
- toMat4(): Mat4Like;
203
+ toMat4(): Mat4Like;
199
204
  }
200
205
  type Mat4Array = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
201
206
  type Mat4NestedArray = [[number, number, number, number], [number, number, number, number], [number, number, number, number], [number, number, number, number]];
@@ -203,91 +208,92 @@ type Mat4String = `${number},${number},${number},${number},${number},${number},$
203
208
  type Mat4Like = IMat4 | Mat4Array | Mat4NestedArray | Mat4String | number | IToMat4;
204
209
  type Mat4Arguments = [mat: Mat4Like] | Mat4Array;
205
210
  declare class Mat4 implements IMat4, IToMat3, IToString {
206
- protected _raw: Mat4Array;
207
- get m00(): number;
208
- set m00(val: number);
209
- get m01(): number;
210
- set m01(val: number);
211
- get m02(): number;
212
- set m02(val: number);
213
- get m03(): number;
214
- set m03(val: number);
215
- get m10(): number;
216
- set m10(val: number);
217
- get m11(): number;
218
- set m11(val: number);
219
- get m12(): number;
220
- set m12(val: number);
221
- get m13(): number;
222
- set m13(val: number);
223
- get m20(): number;
224
- set m20(val: number);
225
- get m21(): number;
226
- set m21(val: number);
227
- get m22(): number;
228
- set m22(val: number);
229
- get m23(): number;
230
- set m23(val: number);
231
- get m30(): number;
232
- set m30(val: number);
233
- get m31(): number;
234
- set m31(val: number);
235
- get m32(): number;
236
- set m32(val: number);
237
- get m33(): number;
238
- set m33(val: number);
239
- static resolve(a: unknown): Mat4;
240
- static resolveArgs(args: Mat4Arguments): Mat4;
241
- static cast(a: unknown): Mat4 | undefined;
242
- static is(a: unknown): a is Mat4Like;
243
- static orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
244
- static orthographic(bbox: BoundingBoxLike, near: number, far: number): Mat4;
245
- static perspective(fov: number, aspect: number, near: number, far: number): Mat4;
246
- static pointAt(position: Vec3Like, target: Vec3Like, up: Vec3Like): Mat4;
247
- constructor(init?: Mat4Array);
248
- toArray(): Mat4Array;
249
- toNestetArray(): Mat4NestedArray;
250
- toJSON(): IMat4;
251
- toString(): Mat4String;
252
- get [Symbol.toStringTag](): string;
253
- [NodeJSCustomInspect](): string;
254
- clone(): Mat4;
255
- equals(mat: Mat4Like): boolean;
256
- equals(...mat: Mat4Array): boolean;
257
- add(mat: Mat4Like): Mat4;
258
- add(...mat: Mat4Array): Mat4;
259
- subtract(mat: Mat4Like): Mat4;
260
- subtract(...mat: Mat4Array): Mat4;
261
- multiply(mat: Mat4Like): Mat4;
262
- multiply(...mat: Mat4Array): Mat4;
263
- multiply(scalar: number): Mat4;
264
- multiply(vec: Vec3Like): Vec3;
265
- translate(x: number, y: number, z: number): Mat4;
266
- translate(vec: Vec3Like): Mat4;
267
- rotateX(angle: number): Mat4;
268
- rotateY(angle: number): Mat4;
269
- rotateZ(angle: number): Mat4;
270
- rotate(x: number, y: number, z: number): Mat4;
271
- rotate(vec: Vec3Like): Mat4;
272
- scale(x: number, y: number, z: number): Mat4;
273
- scale(vec: Vec3Like): Mat4;
274
- inverse(): Mat4;
275
- toMat3(): Mat3Like;
276
- }
277
-
211
+ protected _raw: Mat4Array;
212
+ get m00(): number;
213
+ set m00(val: number);
214
+ get m01(): number;
215
+ set m01(val: number);
216
+ get m02(): number;
217
+ set m02(val: number);
218
+ get m03(): number;
219
+ set m03(val: number);
220
+ get m10(): number;
221
+ set m10(val: number);
222
+ get m11(): number;
223
+ set m11(val: number);
224
+ get m12(): number;
225
+ set m12(val: number);
226
+ get m13(): number;
227
+ set m13(val: number);
228
+ get m20(): number;
229
+ set m20(val: number);
230
+ get m21(): number;
231
+ set m21(val: number);
232
+ get m22(): number;
233
+ set m22(val: number);
234
+ get m23(): number;
235
+ set m23(val: number);
236
+ get m30(): number;
237
+ set m30(val: number);
238
+ get m31(): number;
239
+ set m31(val: number);
240
+ get m32(): number;
241
+ set m32(val: number);
242
+ get m33(): number;
243
+ set m33(val: number);
244
+ static resolve(a: unknown): Mat4;
245
+ static resolveArgs(args: Mat4Arguments): Mat4;
246
+ static cast(a: unknown): Mat4 | undefined;
247
+ static is(a: unknown): a is Mat4Like;
248
+ static orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
249
+ static orthographic(bbox: BoundingBoxLike, near: number, far: number): Mat4;
250
+ static perspective(fov: number, aspect: number, near: number, far: number): Mat4;
251
+ static pointAt(position: Vec3Like, target: Vec3Like, up: Vec3Like): Mat4;
252
+ constructor(init?: Mat4Array);
253
+ toArray(): Mat4Array;
254
+ toNestetArray(): Mat4NestedArray;
255
+ toJSON(): IMat4;
256
+ toString(): Mat4String;
257
+ get [Symbol.toStringTag](): string;
258
+ [NodeJSCustomInspect](): string;
259
+ clone(): Mat4;
260
+ equals(mat: Mat4Like): boolean;
261
+ equals(...mat: Mat4Array): boolean;
262
+ add(mat: Mat4Like): Mat4;
263
+ add(...mat: Mat4Array): Mat4;
264
+ subtract(mat: Mat4Like): Mat4;
265
+ subtract(...mat: Mat4Array): Mat4;
266
+ multiply(mat: Mat4Like): Mat4;
267
+ multiply(...mat: Mat4Array): Mat4;
268
+ multiply(scalar: number): Mat4;
269
+ multiply(vec: Vec3Like): Vec3;
270
+ translate(x: number, y: number, z: number): Mat4;
271
+ translate(vec: Vec3Like): Mat4;
272
+ rotateX(angle: number): Mat4;
273
+ rotateY(angle: number): Mat4;
274
+ rotateZ(angle: number): Mat4;
275
+ rotate(x: number, y: number, z: number): Mat4;
276
+ rotate(vec: Vec3Like): Mat4;
277
+ scale(x: number, y: number, z: number): Mat4;
278
+ scale(vec: Vec3Like): Mat4;
279
+ inverse(): Mat4;
280
+ toMat3(): Mat3Like;
281
+ }
282
+ //#endregion
283
+ //#region source/matrices/mat3.d.ts
278
284
  interface IMat3 {
279
- m00: number;
280
- m01: number;
281
- m02: number;
282
- m10: number;
283
- m11: number;
284
- m12: number;
285
- m20: number;
286
- m21: number;
287
- m22: number;
285
+ m00: number;
286
+ m01: number;
287
+ m02: number;
288
+ m10: number;
289
+ m11: number;
290
+ m12: number;
291
+ m20: number;
292
+ m21: number;
293
+ m22: number;
288
294
  }
289
295
  interface IToMat3 {
290
- toMat3(): Mat3Like;
296
+ toMat3(): Mat3Like;
291
297
  }
292
298
  type Mat3Array = [number, number, number, number, number, number, number, number, number];
293
299
  type Mat3NestedArray = [[number, number, number], [number, number, number], [number, number, number]];
@@ -295,196 +301,209 @@ type Mat3String = `${number},${number},${number},${number},${number},${number},$
295
301
  type Mat3Like = IMat3 | Mat3Array | Mat3NestedArray | Mat3String | number | IToMat3;
296
302
  type Mat3Arguments = [mat: Mat3Like] | Mat3Array;
297
303
  declare class Mat3 implements IMat3, IToMat4, IToString {
298
- protected _raw: Mat3Array;
299
- get m00(): number;
300
- set m00(val: number);
301
- get m01(): number;
302
- set m01(val: number);
303
- get m02(): number;
304
- set m02(val: number);
305
- get m10(): number;
306
- set m10(val: number);
307
- get m11(): number;
308
- set m11(val: number);
309
- get m12(): number;
310
- set m12(val: number);
311
- get m20(): number;
312
- set m20(val: number);
313
- get m21(): number;
314
- set m21(val: number);
315
- get m22(): number;
316
- set m22(val: number);
317
- static resolve(a: unknown): Mat3;
318
- static resolveArgs(args: Mat3Arguments): Mat3;
319
- static cast(a: unknown): Mat3 | undefined;
320
- static is(a: unknown): a is Mat3Like;
321
- static projection(width: number, height: number): Mat3;
322
- constructor(init?: Mat3Array);
323
- toArray(): Mat3Array;
324
- toNestetArray(): Mat3NestedArray;
325
- toJSON(): IMat3;
326
- toString(): Mat3String;
327
- get [Symbol.toStringTag](): string;
328
- [NodeJSCustomInspect](): string;
329
- clone(): Mat3;
330
- equals(mat: Mat3Like): boolean;
331
- equals(...mat: Mat3Array): boolean;
332
- add(mat: Mat3Like): Mat3;
333
- add(...mat: Mat3Array): Mat3;
334
- subtract(mat: Mat3Like): Mat3;
335
- subtract(...mat: Mat3Array): Mat3;
336
- multiply(mat: Mat3Like): Mat3;
337
- multiply(...mat: Mat3Array): Mat3;
338
- multiply(scalar: number): Mat3;
339
- translate(x: number, y: number): Mat3;
340
- translate(vec: Vec2Like): Mat3;
341
- rotate(angle: number): Mat3;
342
- scale(x: number, y: number): Mat3;
343
- scale(vec: Vec2Like): Mat3;
344
- determinant(): number;
345
- inverse(): Mat3;
346
- toMat4(): Mat4Like;
347
- }
348
-
304
+ protected _raw: Mat3Array;
305
+ get m00(): number;
306
+ set m00(val: number);
307
+ get m01(): number;
308
+ set m01(val: number);
309
+ get m02(): number;
310
+ set m02(val: number);
311
+ get m10(): number;
312
+ set m10(val: number);
313
+ get m11(): number;
314
+ set m11(val: number);
315
+ get m12(): number;
316
+ set m12(val: number);
317
+ get m20(): number;
318
+ set m20(val: number);
319
+ get m21(): number;
320
+ set m21(val: number);
321
+ get m22(): number;
322
+ set m22(val: number);
323
+ static resolve(a: unknown): Mat3;
324
+ static resolveArgs(args: Mat3Arguments): Mat3;
325
+ static cast(a: unknown): Mat3 | undefined;
326
+ static is(a: unknown): a is Mat3Like;
327
+ static projection(width: number, height: number): Mat3;
328
+ constructor(init?: Mat3Array);
329
+ toArray(): Mat3Array;
330
+ toNestetArray(): Mat3NestedArray;
331
+ toJSON(): IMat3;
332
+ toString(): Mat3String;
333
+ get [Symbol.toStringTag](): string;
334
+ [NodeJSCustomInspect](): string;
335
+ clone(): Mat3;
336
+ equals(mat: Mat3Like): boolean;
337
+ equals(...mat: Mat3Array): boolean;
338
+ add(mat: Mat3Like): Mat3;
339
+ add(...mat: Mat3Array): Mat3;
340
+ subtract(mat: Mat3Like): Mat3;
341
+ subtract(...mat: Mat3Array): Mat3;
342
+ multiply(mat: Mat3Like): Mat3;
343
+ multiply(...mat: Mat3Array): Mat3;
344
+ multiply(scalar: number): Mat3;
345
+ translate(x: number, y: number): Mat3;
346
+ translate(vec: Vec2Like): Mat3;
347
+ rotate(angle: number): Mat3;
348
+ scale(x: number, y: number): Mat3;
349
+ scale(vec: Vec2Like): Mat3;
350
+ determinant(): number;
351
+ inverse(): Mat3;
352
+ toMat4(): Mat4Like;
353
+ }
354
+ //#endregion
355
+ //#region source/algebra/quaternion.d.ts
349
356
  interface IQuaternion {
350
- w: number;
351
- x: number;
352
- y: number;
353
- z: number;
357
+ w: number;
358
+ x: number;
359
+ y: number;
360
+ z: number;
354
361
  }
355
362
  interface IToQuaternion {
356
- toQuaternion(): QuaternionLike;
363
+ toQuaternion(): QuaternionLike;
357
364
  }
358
365
  type QuaternionArray = [number, number, number, number];
359
366
  type QuaternionString = `${number} + ${number}i + ${number}j + ${number}k`;
360
- type QuaternionLike = IQuaternion | QuaternionArray | QuaternionString | IToQuaternion;
367
+ type QuaternionLike = IQuaternion | QuaternionArray | QuaternionString | IToQuaternion | number;
361
368
  type QuaternionArguments = QuaternionArray | [quaternion: QuaternionLike];
362
369
  declare class Quaternion implements IToVec3, IToMat3, IToMat4, IToString {
363
- w: number;
364
- x: number;
365
- y: number;
366
- z: number;
367
- static is(a: unknown): a is IQuaternion;
368
- static resolve(a: unknown): Quaternion;
369
- static resolveArgs(args: QuaternionArguments): Quaternion;
370
- static cast(a: unknown): Quaternion | undefined;
371
- static fromAxisAngle(axis: Vec3Like, angle: number): Quaternion;
372
- static fromAxisAngle(x: number, y: number, z: number, angle: number): Quaternion;
373
- static fromEuler(x: number, y: number, z: number): Quaternion;
374
- static fromEuler(vec: Vec3Like): Quaternion;
375
- static get zero(): Quaternion;
376
- constructor(w: number, x: number, y: number, z: number);
377
- toArray(): QuaternionArray;
378
- toString(): QuaternionString;
379
- get [Symbol.toStringTag](): string;
380
- [NodeJSCustomInspect](): string;
381
- toJSON(): IQuaternion;
382
- clone(): Quaternion;
383
- add(quaternion: QuaternionLike): Quaternion;
384
- add(...quaternion: QuaternionArray): Quaternion;
385
- offset(quaternion: QuaternionLike): this;
386
- offset(...quaternion: QuaternionArray): this;
387
- subtract(quaternion: QuaternionLike): Quaternion;
388
- subtract(...quaternion: QuaternionArray): Quaternion;
389
- negative(): Quaternion;
390
- length(sqrt?: boolean): number;
391
- normalize(): Quaternion;
392
- multiply(quaternion: QuaternionLike): Quaternion;
393
- multiply(...quaternion: QuaternionArray): Quaternion;
394
- multiplyVector(x: number, y: number, z: number): Vec3;
395
- multiplyVector(vec: Vec3Like): Vec3;
396
- scale(scalar: number): Quaternion;
397
- dot(quaternion: QuaternionLike): number;
398
- dot(...quaternion: QuaternionArray): number;
399
- inverse(): Quaternion;
400
- divide(quaternion: QuaternionLike): Quaternion;
401
- divide(...quaternion: QuaternionArray): Quaternion;
402
- conjugate(): Quaternion;
403
- exp(): Quaternion;
404
- log(): Quaternion;
405
- toVec3(): Vec3Like;
406
- toAxisAngle(): Vec3;
407
- toEuler(): Vec3;
408
- toMat3(): Mat3Like;
409
- toMat4(): Mat4Like;
410
- }
411
-
370
+ w: number;
371
+ x: number;
372
+ y: number;
373
+ z: number;
374
+ static is(a: unknown): a is IQuaternion;
375
+ static resolve(a: unknown): Quaternion;
376
+ static resolveArgs(args: QuaternionArguments): Quaternion;
377
+ static cast(a: unknown): Quaternion | undefined;
378
+ static fromAxisAngle(axis: Vec3Like, angle: number): Quaternion;
379
+ static fromAxisAngle(x: number, y: number, z: number, angle: number): Quaternion;
380
+ static fromEuler(x: number, y: number, z: number): Quaternion;
381
+ static fromEuler(vec: Vec3Like): Quaternion;
382
+ static get zero(): Quaternion;
383
+ constructor(w: number, x: number, y: number, z: number);
384
+ toArray(): QuaternionArray;
385
+ toString(): QuaternionString;
386
+ get [Symbol.toStringTag](): string;
387
+ [NodeJSCustomInspect](): string;
388
+ toJSON(): IQuaternion;
389
+ clone(): Quaternion;
390
+ add(quaternion: QuaternionLike): Quaternion;
391
+ add(...quaternion: QuaternionArray): Quaternion;
392
+ offset(quaternion: QuaternionLike): this;
393
+ offset(...quaternion: QuaternionArray): this;
394
+ subtract(quaternion: QuaternionLike): Quaternion;
395
+ subtract(...quaternion: QuaternionArray): Quaternion;
396
+ negative(): Quaternion;
397
+ length(sqrt?: boolean): number;
398
+ normalize(): Quaternion;
399
+ multiply(quaternion: QuaternionLike): Quaternion;
400
+ multiply(...quaternion: QuaternionArray): Quaternion;
401
+ multiplyVector(x: number, y: number, z: number): Vec3;
402
+ multiplyVector(vec: Vec3Like): Vec3;
403
+ scale(scalar: number): Quaternion;
404
+ dot(quaternion: QuaternionLike): number;
405
+ dot(...quaternion: QuaternionArray): number;
406
+ inverse(): Quaternion;
407
+ divide(quaternion: QuaternionLike): Quaternion;
408
+ divide(...quaternion: QuaternionArray): Quaternion;
409
+ conjugate(): Quaternion;
410
+ exp(): Quaternion;
411
+ log(): Quaternion;
412
+ toVec3(): Vec3Like;
413
+ toAxisAngle(): Vec3;
414
+ toEuler(): Vec3;
415
+ toMat3(): Mat3Like;
416
+ toMat4(): Mat4Like;
417
+ }
418
+ //#endregion
419
+ //#region source/color/utils.d.ts
420
+ declare function numberToRGB(number: number): FixedArray<number, 3>;
421
+ declare function numberToRGBA(number: number): FixedArray<number, 4>;
422
+ type HexColorPrefix = "$" | "#" | "0x";
423
+ type HexColor = `${HexColorPrefix}${string}`;
424
+ declare function isHexNumber(hex: string): hex is HexColor;
425
+ declare function hasHexNumberAlpha(hex: string): boolean;
426
+ declare function hexNumberToRGB(hex: HexColor): FixedArray<number, 3>;
427
+ declare function hexNumberToRGBA(hex: HexColor): FixedArray<number, 4>;
428
+ //#endregion
429
+ //#region source/color/rgb.d.ts
412
430
  interface IRGB {
413
- red: number;
414
- green: number;
415
- blue: number;
431
+ red: number;
432
+ green: number;
433
+ blue: number;
416
434
  }
417
435
  interface IToRGB {
418
- toRGB(): RGBLike;
436
+ toRGB(): RGBLike;
419
437
  }
420
438
  type RGBArray = [number, number, number];
421
439
  type RGBString = `rgb(${number},${number},${number})`;
422
440
  type RGBLike = IRGB | RGBArray | RGBString | IToRGB;
423
441
  type RGBArguments = [rgb: RGBLike] | RGBArray;
424
442
  interface IRBBA extends IRGB {
425
- alpha: number;
443
+ alpha: number;
426
444
  }
427
445
  interface IToRGBA {
428
- toRGBA(): RGBALike;
446
+ toRGBA(): RGBALike;
429
447
  }
430
448
  type RGBAArray = [number, number, number, number];
431
449
  type RGBAString = `rgba(${number},${number},${number},${number})`;
432
- type RGBALike = IRBBA | RGBAArray | RGBAString | IToRGBA;
450
+ type RGBALike = IRBBA | RGBAArray | RGBAString | IToRGBA | HexColor;
433
451
  type RGBAArguments = [rgba: RGBALike] | RGBAArray;
434
452
  type IAnyRGB = IRGB | IRBBA;
435
453
  type AnyRGBArray = RGBArray | RGBAArray;
436
454
  type AnyRGBString = RGBString | RGBAString;
437
455
  type IAnyToRGB = IToRGB | IToRGBA;
438
- type AnyRGBLike = IAnyRGB | AnyRGBArray | AnyRGBString | number | IAnyToRGB;
456
+ type AnyRGBLike = IAnyRGB | AnyRGBArray | AnyRGBString | number | IAnyToRGB | HexColor;
439
457
  type AnyRGBArguments = RGBArguments | RGBAArguments;
440
458
  declare class RGBA implements IRBBA, IToVec2, IToVec3, IToHSL, IToHSLA, IToString {
441
- private _red;
442
- get red(): number;
443
- set red(val: number);
444
- private _green;
445
- get green(): number;
446
- set green(val: number);
447
- private _blue;
448
- get blue(): number;
449
- set blue(val: number);
450
- private _alpha;
451
- get alpha(): number;
452
- set alpha(val: number);
453
- static resolve(a: unknown): RGBA;
454
- static resolveArgs(args: AnyRGBArguments): RGBA;
455
- static cast(a: unknown): RGBA | undefined;
456
- static is(a: unknown): a is AnyRGBLike;
457
- constructor(red: number, green: number, blue: number, alpha?: number);
458
- toArray(withAlpha?: boolean): AnyRGBArray;
459
- toJSON(withAlpha?: boolean): IAnyRGB;
460
- toString(withAlpha?: boolean): AnyRGBString;
461
- get [Symbol.toStringTag](): string;
462
- [NodeJSCustomInspect](): string;
463
- toVec2(): Vec2Like;
464
- toVec3(): Vec3Like;
465
- toHSL(withAlpha?: false): HSLLike;
466
- toHSL(withAlpha?: true): HSLALike;
467
- toHSLA(): HSLALike;
468
- invert(withAlpha?: boolean): RGBA;
469
- }
470
-
459
+ private _red;
460
+ get red(): number;
461
+ set red(val: number);
462
+ private _green;
463
+ get green(): number;
464
+ set green(val: number);
465
+ private _blue;
466
+ get blue(): number;
467
+ set blue(val: number);
468
+ private _alpha;
469
+ get alpha(): number;
470
+ set alpha(val: number);
471
+ static resolve(a: unknown): RGBA;
472
+ static resolveArgs(args: AnyRGBArguments): RGBA;
473
+ static cast(a: unknown): RGBA | undefined;
474
+ static is(a: unknown): a is AnyRGBLike;
475
+ constructor(red: number, green: number, blue: number, alpha?: number);
476
+ toArray(withAlpha?: boolean): AnyRGBArray;
477
+ toJSON(withAlpha?: boolean): IAnyRGB;
478
+ toString(withAlpha?: boolean): AnyRGBString;
479
+ get [Symbol.toStringTag](): string;
480
+ [NodeJSCustomInspect](): string;
481
+ toVec2(): Vec2Like;
482
+ toVec3(): Vec3Like;
483
+ toHSL(withAlpha?: false): HSLLike;
484
+ toHSL(withAlpha?: true): HSLALike;
485
+ toHSLA(): HSLALike;
486
+ invert(withAlpha?: boolean): RGBA;
487
+ }
488
+ //#endregion
489
+ //#region source/color/hsl.d.ts
471
490
  interface IHSL {
472
- hue: number;
473
- saturation: number;
474
- luminace: number;
491
+ hue: number;
492
+ saturation: number;
493
+ luminace: number;
475
494
  }
476
495
  interface IToHSL {
477
- toHSL(): HSLLike;
496
+ toHSL(): HSLLike;
478
497
  }
479
498
  type HSLArray = [number, number, number];
480
499
  type HSLString = `hsl(${number},${number},${number})`;
481
- type HSLLike = IHSL | HSLArray | HSLString | IToHSL;
500
+ type HSLLike = IHSL | HSLArray | HSLString | IToHSL | HexColor;
482
501
  type HSLArguments = HSLArray | [hsl: HSLLike];
483
502
  interface IHSLA extends IHSL {
484
- alpha: number;
503
+ alpha: number;
485
504
  }
486
505
  interface IToHSLA {
487
- toHSLA(): HSLALike;
506
+ toHSLA(): HSLALike;
488
507
  }
489
508
  type HSLAArray = [number, number, number, number];
490
509
  type HSLAString = `hsla(${number},${number},${number},${number})`;
@@ -497,196 +516,200 @@ type IAnyToHSL = IToHSL | IToHSLA;
497
516
  type AnyHSLLike = IAnyHSL | AnyHSLArray | AnyHSLString | number | IAnyToHSL;
498
517
  type AnyHSLArguments = HSLArguments | HSLAArguments;
499
518
  declare class HSLA implements IHSLA, IToRGB, IToRGBA, IToVec2, IToVec3, IToString {
500
- private _hue;
501
- get hue(): number;
502
- set hue(val: number);
503
- private _saturation;
504
- get saturation(): number;
505
- set saturation(val: number);
506
- private _luminace;
507
- get luminace(): number;
508
- set luminace(val: number);
509
- private _alpha;
510
- get alpha(): number;
511
- set alpha(val: number);
512
- static resolve(a: unknown): HSLA;
513
- static resolveArgs(args: AnyHSLArguments): HSLA;
514
- static cast(a: unknown): HSLA | undefined;
515
- static is(a: unknown): a is AnyHSLLike;
516
- constructor(hue: number, saturation: number, luminace: number, alpha?: number);
517
- toArray(withAlpha?: boolean): AnyHSLArray;
518
- toJSON(withAlpha?: boolean): IAnyHSL;
519
- toString(withAlpha?: boolean): AnyHSLString;
520
- get [Symbol.toStringTag](): string;
521
- [NodeJSCustomInspect](): string;
522
- toRGB(withAlpha?: true): RGBALike;
523
- toRGB(withAlpha?: false): RGBLike;
524
- toRGBA(): RGBALike;
525
- toVec2(): Vec2Like;
526
- toVec3(): Vec3Like;
527
- invert(withAlpha?: boolean): HSLA;
528
- }
529
-
519
+ private _hue;
520
+ get hue(): number;
521
+ set hue(val: number);
522
+ private _saturation;
523
+ get saturation(): number;
524
+ set saturation(val: number);
525
+ private _luminace;
526
+ get luminace(): number;
527
+ set luminace(val: number);
528
+ private _alpha;
529
+ get alpha(): number;
530
+ set alpha(val: number);
531
+ static resolve(a: unknown): HSLA;
532
+ static resolveArgs(args: AnyHSLArguments): HSLA;
533
+ static cast(a: unknown): HSLA | undefined;
534
+ static is(a: unknown): a is AnyHSLLike;
535
+ constructor(hue: number, saturation: number, luminace: number, alpha?: number);
536
+ toArray(withAlpha?: boolean): AnyHSLArray;
537
+ toJSON(withAlpha?: boolean): IAnyHSL;
538
+ toString(withAlpha?: boolean): AnyHSLString;
539
+ get [Symbol.toStringTag](): string;
540
+ [NodeJSCustomInspect](): string;
541
+ toRGB(withAlpha?: true): RGBALike;
542
+ toRGB(withAlpha?: false): RGBLike;
543
+ toRGBA(): RGBALike;
544
+ toVec2(): Vec2Like;
545
+ toVec3(): Vec3Like;
546
+ invert(withAlpha?: boolean): HSLA;
547
+ }
548
+ //#endregion
549
+ //#region source/vectors/vec3.d.ts
530
550
  interface IVec3 extends IVec2 {
531
- z: number;
551
+ z: number;
532
552
  }
533
553
  interface IToVec3 {
534
- toVec3(): Vec3Like;
554
+ toVec3(): Vec3Like;
535
555
  }
536
556
  type Vec3Array = [number, number, number] | [number, number, number, number];
537
557
  type Vec3String = `${number},${number},${number}` | `${number},${number},${number};${number}`;
538
558
  type Vec3Like = IVec3 | Vec3Array | Vec3String | number | IToVec3;
539
559
  type Vec3Arguments = [Vec3Like] | [number, number, number];
540
560
  declare class Vec3 implements IVec3, IToVec2, IToRGB, IToRGBA, IToHSL, IToHSLA, IToQuaternion, IToString {
541
- x: number;
542
- y: number;
543
- z: number;
544
- w: number;
545
- static resolve(a: unknown): Vec3;
546
- static cast(a: unknown): Vec3 | undefined;
547
- static resolveArgs(args: Vec3Arguments): Vec3;
548
- static is(a: unknown): a is Vec3Like;
549
- static fromPoints(a: Vec3Like, b: Vec3Like): Vec3;
550
- static clamp(value: Vec3Like, min: Vec3Like, max: Vec3Like): Vec3;
551
- static intersectPlane(planeP: Vec3Like, planeN: Vec3Like, lineStart: Vec3Like, lineEnd: Vec3Like, t: number): Vec3;
552
- static get zero(): Vec3;
553
- static get one(): Vec3;
554
- constructor(x: number, y: number, z: number, w?: number);
555
- toArray(w?: boolean): Vec3Array;
556
- toJSON(): IVec3;
557
- toString(w?: boolean): Vec3String;
558
- get [Symbol.toStringTag](): string;
559
- [NodeJSCustomInspect](): string;
560
- toVec2(): Vec2Like;
561
- toRGB(): RGBLike;
562
- toRGBA(): RGBALike;
563
- toHSL(): HSLLike;
564
- toHSLA(): HSLALike;
565
- toQuaternion(): QuaternionLike;
566
- clone(): Vec3;
567
- equals(vec: Vec3Like): boolean;
568
- equals(x: number, y: number, z: number): boolean;
569
- setX(x: number): this;
570
- setY(y: number): this;
571
- setZ(z: number): this;
572
- set(x: number, y: number, z: number): this;
573
- set(vec: Vec3Like): this;
574
- add(x: number, y: number, z: number): Vec3;
575
- add(vec: Vec3Like): Vec3;
576
- offset(x: number, y: number, z: number): this;
577
- offset(vec: Vec3Like): this;
578
- subtract(x: number, y: number, z: number): Vec3;
579
- subtract(vec: Vec3Like): Vec3;
580
- multiply(scalar: number): Vec3;
581
- naiveMultiply(x: number, y: number, z: number): Vec3;
582
- naiveMultiply(vec: Vec3Like): Vec3;
583
- divide(x: number, y: number, z: number): Vec3;
584
- divide(scalar: number): Vec3;
585
- divide(vec: Vec3Like): Vec3;
586
- dot(x: number, y: number, z: number): number;
587
- dot(vec: Vec3Like): number;
588
- cross(x: number, y: number, z: number): Vec3;
589
- cross(vec: Vec3Like): Vec3;
590
- distance(x: number, y: number, z: number): number;
591
- distance(vec: Vec3Like): number;
592
- distanceSquare(x: number, y: number, z: number): number;
593
- distanceSquare(vec: Vec3Like): number;
594
- length(): number;
595
- normalize(): Vec3;
596
- invert(): Vec3;
597
- round(): Vec3;
598
- }
599
-
561
+ x: number;
562
+ y: number;
563
+ z: number;
564
+ w: number;
565
+ static resolve(a: unknown): Vec3;
566
+ static cast(a: unknown): Vec3 | undefined;
567
+ static resolveArgs(args: Vec3Arguments): Vec3;
568
+ static is(a: unknown): a is Vec3Like;
569
+ static fromPoints(a: Vec3Like, b: Vec3Like): Vec3;
570
+ static clamp(value: Vec3Like, min: Vec3Like, max: Vec3Like): Vec3;
571
+ static intersectPlane(planeP: Vec3Like, planeN: Vec3Like, lineStart: Vec3Like, lineEnd: Vec3Like, t: number): Vec3;
572
+ static get zero(): Vec3;
573
+ static get one(): Vec3;
574
+ constructor(x: number, y: number, z: number, w?: number);
575
+ toArray(w?: boolean): Vec3Array;
576
+ toJSON(): IVec3;
577
+ toString(w?: boolean): Vec3String;
578
+ get [Symbol.toStringTag](): string;
579
+ [NodeJSCustomInspect](): string;
580
+ toVec2(): Vec2Like;
581
+ toRGB(): RGBLike;
582
+ toRGBA(): RGBALike;
583
+ toHSL(): HSLLike;
584
+ toHSLA(): HSLALike;
585
+ toQuaternion(): QuaternionLike;
586
+ clone(): Vec3;
587
+ equals(vec: Vec3Like): boolean;
588
+ equals(x: number, y: number, z: number): boolean;
589
+ setX(x: number): this;
590
+ setY(y: number): this;
591
+ setZ(z: number): this;
592
+ set(x: number, y: number, z: number): this;
593
+ set(vec: Vec3Like): this;
594
+ add(x: number, y: number, z: number): Vec3;
595
+ add(vec: Vec3Like): Vec3;
596
+ offset(x: number, y: number, z: number): this;
597
+ offset(vec: Vec3Like): this;
598
+ subtract(x: number, y: number, z: number): Vec3;
599
+ subtract(vec: Vec3Like): Vec3;
600
+ multiply(scalar: number): Vec3;
601
+ naiveMultiply(x: number, y: number, z: number): Vec3;
602
+ naiveMultiply(vec: Vec3Like): Vec3;
603
+ divide(x: number, y: number, z: number): Vec3;
604
+ divide(scalar: number): Vec3;
605
+ divide(vec: Vec3Like): Vec3;
606
+ dot(x: number, y: number, z: number): number;
607
+ dot(vec: Vec3Like): number;
608
+ cross(x: number, y: number, z: number): Vec3;
609
+ cross(vec: Vec3Like): Vec3;
610
+ distance(x: number, y: number, z: number): number;
611
+ distance(vec: Vec3Like): number;
612
+ distanceSquare(x: number, y: number, z: number): number;
613
+ distanceSquare(vec: Vec3Like): number;
614
+ length(): number;
615
+ normalize(): Vec3;
616
+ invert(): Vec3;
617
+ round(): Vec3;
618
+ }
619
+ //#endregion
620
+ //#region source/vectors/vec2.d.ts
600
621
  interface IVec2 {
601
- x: number;
602
- y: number;
603
- w: number;
622
+ x: number;
623
+ y: number;
624
+ w: number;
604
625
  }
605
626
  interface IToVec2 {
606
- toVec2(): Vec2Like;
627
+ toVec2(): Vec2Like;
607
628
  }
608
629
  type Vec2Array = [number, number] | [number, number, number];
609
630
  type Vec2String = `${number},${number}` | `${number},${number};${number}`;
610
631
  type Vec2Like = IVec2 | Vec2Array | Vec2String | number | IToVec2;
611
632
  type Vec2Arguments = [Vec2Like] | [number, number];
612
633
  declare class Vec2 implements IVec2, IToVec3, IToSize, IToRGB, IToRGBA, IToHSL, IToHSLA, IToString {
613
- x: number;
614
- y: number;
615
- w: number;
616
- static resolve(a: unknown): Vec2;
617
- static cast(a: unknown): Vec2 | undefined;
618
- static resolveArgs(args: Vec2Arguments): Vec2;
619
- static is(a: unknown): a is Vec2Like;
620
- static fromPoints(a: Vec2Like, b: Vec2Like): Vec2;
621
- static clamp(value: Vec2Like, min: Vec2Like, max: Vec2Like): Vec2;
622
- static get zero(): Vec2;
623
- static get one(): Vec2;
624
- constructor(x: number, y: number, w?: number);
625
- toArray(w?: boolean): Vec2Array;
626
- toJSON(): IVec2;
627
- toString(w?: boolean): Vec2String;
628
- get [Symbol.toStringTag](): string;
629
- [NodeJSCustomInspect](): string;
630
- toSize(): SizeLike;
631
- toVec3(z?: number): Vec3Like;
632
- toRGB(): RGBLike;
633
- toRGBA(): RGBALike;
634
- toHSL(): HSLLike;
635
- toHSLA(): HSLALike;
636
- clone(): Vec2;
637
- equals(vec: Vec2Like): boolean;
638
- equals(x: number, y: number): boolean;
639
- setX(x: number): this;
640
- setY(y: number): this;
641
- setW(w: number): this;
642
- set(x: number, y: number): this;
643
- set(vec: Vec2Like): this;
644
- add(x: number, y: number): Vec2;
645
- add(vec: Vec2Like): Vec2;
646
- offset(x: number, y: number): this;
647
- offset(vec: Vec2Like): this;
648
- subtract(x: number, y: number): Vec2;
649
- subtract(vec: Vec2Like): Vec2;
650
- multiply(scalar: number): Vec2;
651
- naiveMultiply(x: number, y: number): Vec2;
652
- naiveMultiply(vec: Vec2Like): Vec2;
653
- divide(x: number, y: number): Vec2;
654
- divide(scalar: number): Vec2;
655
- divide(vec: Vec2Like): Vec2;
656
- dot(x: number, y: number): number;
657
- dot(vec: Vec2Like): number;
658
- distance(x: number, y: number): number;
659
- distance(vec: Vec2Like): number;
660
- distanceSquare(x: number, y: number): number;
661
- distanceSquare(vec: Vec2Like): number;
662
- length(): number;
663
- cartesianify(): Vec2;
664
- polarify(): Vec2;
665
- normalize(): Vec2;
666
- invert(): Vec2;
667
- round(): Vec2;
668
- }
669
-
634
+ x: number;
635
+ y: number;
636
+ w: number;
637
+ static resolve(a: unknown): Vec2;
638
+ static cast(a: unknown): Vec2 | undefined;
639
+ static resolveArgs(args: Vec2Arguments): Vec2;
640
+ static is(a: unknown): a is Vec2Like;
641
+ static fromPoints(a: Vec2Like, b: Vec2Like): Vec2;
642
+ static clamp(value: Vec2Like, min: Vec2Like, max: Vec2Like): Vec2;
643
+ static get zero(): Vec2;
644
+ static get one(): Vec2;
645
+ constructor(x: number, y: number, w?: number);
646
+ toArray(w?: boolean): Vec2Array;
647
+ toJSON(): IVec2;
648
+ toString(w?: boolean): Vec2String;
649
+ get [Symbol.toStringTag](): string;
650
+ [NodeJSCustomInspect](): string;
651
+ toSize(): SizeLike;
652
+ toVec3(z?: number): Vec3Like;
653
+ toRGB(): RGBLike;
654
+ toRGBA(): RGBALike;
655
+ toHSL(): HSLLike;
656
+ toHSLA(): HSLALike;
657
+ clone(): Vec2;
658
+ equals(vec: Vec2Like): boolean;
659
+ equals(x: number, y: number): boolean;
660
+ setX(x: number): this;
661
+ setY(y: number): this;
662
+ setW(w: number): this;
663
+ set(x: number, y: number): this;
664
+ set(vec: Vec2Like): this;
665
+ add(x: number, y: number): Vec2;
666
+ add(vec: Vec2Like): Vec2;
667
+ offset(x: number, y: number): this;
668
+ offset(vec: Vec2Like): this;
669
+ subtract(x: number, y: number): Vec2;
670
+ subtract(vec: Vec2Like): Vec2;
671
+ multiply(scalar: number): Vec2;
672
+ naiveMultiply(x: number, y: number): Vec2;
673
+ naiveMultiply(vec: Vec2Like): Vec2;
674
+ divide(x: number, y: number): Vec2;
675
+ divide(scalar: number): Vec2;
676
+ divide(vec: Vec2Like): Vec2;
677
+ dot(x: number, y: number): number;
678
+ dot(vec: Vec2Like): number;
679
+ distance(x: number, y: number): number;
680
+ distance(vec: Vec2Like): number;
681
+ distanceSquare(x: number, y: number): number;
682
+ distanceSquare(vec: Vec2Like): number;
683
+ length(): number;
684
+ cartesianify(): Vec2;
685
+ polarify(): Vec2;
686
+ normalize(): Vec2;
687
+ invert(): Vec2;
688
+ round(): Vec2;
689
+ }
690
+ //#endregion
691
+ //#region source/algebra/function.d.ts
670
692
  /**
671
693
  * An abstract class of a mathematical function
672
694
  * @template Input The amount of input values the function can use
673
695
  */
674
696
  declare abstract class MathFunction<Input extends Array<number> = Array<number>> implements IToString {
675
- /**
676
- * Calculate y with input values
677
- * @param args The input values
678
- * @returns The y value from the input values
679
- */
680
- abstract get(...args: Input): number;
681
- /**
682
- * Get the root points of this function
683
- * @returns The root points, this can be an empty array if no root points have been found
684
- */
685
- abstract roots(): Array<Vec2>;
686
- abstract get [Symbol.toStringTag](): string;
687
- abstract [NodeJSCustomInspect](): string;
688
- }
689
-
697
+ /**
698
+ * Calculate y with input values
699
+ * @param args The input values
700
+ * @returns The y value from the input values
701
+ */
702
+ abstract get(...args: Input): number;
703
+ /**
704
+ * Get the root points of this function
705
+ * @returns The root points, this can be an empty array if no root points have been found
706
+ */
707
+ abstract roots(): Array<Vec2>;
708
+ abstract get [Symbol.toStringTag](): string;
709
+ abstract [NodeJSCustomInspect](): string;
710
+ }
711
+ //#endregion
712
+ //#region source/algebra/linear.d.ts
690
713
  /**
691
714
  * The string representation of a linear function
692
715
  */
@@ -695,34 +718,35 @@ type LinearFunctionString = `f(x) = ${number} * x ${"+" | "-"} ${number}` | `f(x
695
718
  * A class that implements a linear function with `m`, `b` and `x`
696
719
  */
697
720
  declare class LinearFunction extends MathFunction<[number]> {
698
- /**
699
- * The factor of the linear function
700
- */
701
- m: number;
702
- /**
703
- * The height of the linear function
704
- */
705
- b: number;
706
- /**
707
- * Create a linear function from two points
708
- * @param a A point
709
- * @param b A point
710
- * @returns A linear function from two points
711
- */
712
- static fromPoints(a: Vec2Like, b: Vec2Like): LinearFunction;
713
- /**
714
- * Create a linear function with a factor and height
715
- * @param m The factor
716
- * @param b The height
717
- */
718
- constructor(m: number, b: number);
719
- get(x: number): number;
720
- roots(): Array<Vec2>;
721
- toString(): LinearFunctionString;
722
- get [Symbol.toStringTag](): string;
723
- [NodeJSCustomInspect](): string;
724
- }
725
-
721
+ /**
722
+ * The factor of the linear function
723
+ */
724
+ m: number;
725
+ /**
726
+ * The height of the linear function
727
+ */
728
+ b: number;
729
+ /**
730
+ * Create a linear function from two points
731
+ * @param a A point
732
+ * @param b A point
733
+ * @returns A linear function from two points
734
+ */
735
+ static fromPoints(a: Vec2Like, b: Vec2Like): LinearFunction;
736
+ /**
737
+ * Create a linear function with a factor and height
738
+ * @param m The factor
739
+ * @param b The height
740
+ */
741
+ constructor(m: number, b: number);
742
+ get(x: number): number;
743
+ roots(): Array<Vec2>;
744
+ toString(): LinearFunctionString;
745
+ get [Symbol.toStringTag](): string;
746
+ [NodeJSCustomInspect](): string;
747
+ }
748
+ //#endregion
749
+ //#region source/common/sign.d.ts
726
750
  /**
727
751
  * A type that represents the sign of a number
728
752
  */
@@ -732,7 +756,8 @@ type SignCharacter = "-" | "+";
732
756
  * @param num A number
733
757
  */
734
758
  declare function signCharacter(num: number | bigint): SignCharacter | undefined;
735
-
759
+ //#endregion
760
+ //#region source/algebra/quad.d.ts
736
761
  /**
737
762
  * The various types of how a quad function can be represented
738
763
  */
@@ -741,7 +766,7 @@ type QuadFunctionType = "standard";
741
766
  * A typed map of each quad function representations
742
767
  */
743
768
  type QuadFunctionString = {
744
- "standard": `f(x) = ${number}x^2 ${SignCharacter} ${number}x ${SignCharacter} ${number}` | `f(x) = ${number}x^2 ${SignCharacter} ${number}x` | `f(x) = ${number}x^2`;
769
+ "standard": `f(x) = ${number}x^2 ${SignCharacter} ${number}x ${SignCharacter} ${number}` | `f(x) = ${number}x^2 ${SignCharacter} ${number}x` | `f(x) = ${number}x^2`;
745
770
  };
746
771
  /**
747
772
  * A string representation of a quad function
@@ -751,35 +776,34 @@ type QuadFunctionStrings = QuadFunctionString[QuadFunctionType];
751
776
  * A class that implements a quad function with `a`, `b` and `c`
752
777
  */
753
778
  declare class QuadFunction extends MathFunction<[number]> {
754
- a: number;
755
- b: number;
756
- c: number;
757
- static get(a: number, b: number, c: number, x: number): number;
758
- constructor(a: number, b: number, c: number);
759
- get(x: number): number;
760
- roots(): Array<Vec2>;
761
- toString<T extends QuadFunctionType>(type?: T): QuadFunctionString[T];
762
- get [Symbol.toStringTag](): string;
763
- [NodeJSCustomInspect](): string;
764
- }
765
-
766
- declare function numberToRGB(number: number): FixedArray<number, 3>;
767
- declare function numberToRGBA(number: number): FixedArray<number, 4>;
768
-
779
+ a: number;
780
+ b: number;
781
+ c: number;
782
+ static get(a: number, b: number, c: number, x: number): number;
783
+ constructor(a: number, b: number, c: number);
784
+ get(x: number): number;
785
+ roots(): Array<Vec2>;
786
+ toString<T extends QuadFunctionType>(type?: T): QuadFunctionString[T];
787
+ get [Symbol.toStringTag](): string;
788
+ [NodeJSCustomInspect](): string;
789
+ }
790
+ //#endregion
791
+ //#region source/common/error.d.ts
769
792
  /**
770
793
  * A error when a value wasn't able to be resolved to another type
771
794
  */
772
795
  declare class ResolveError extends Error {
773
- readonly target: string;
774
- readonly value: unknown;
775
- /**
776
- * Create a resolve exception
777
- * @param target The target type name
778
- * @param value A value
779
- */
780
- constructor(target: string, value: unknown);
781
- }
782
-
796
+ readonly target: string;
797
+ readonly value: unknown;
798
+ /**
799
+ * Create a resolve exception
800
+ * @param target The target type name
801
+ * @param value A value
802
+ */
803
+ constructor(target: string, value: unknown);
804
+ }
805
+ //#endregion
806
+ //#region source/crypto/hash.d.ts
783
807
  declare const DJB2_OFFSET = 5381n;
784
808
  declare function djb2<V>(value: V): bigint;
785
809
  declare const FNV1_OFFSET = 14695981039346656037n;
@@ -787,144 +811,134 @@ declare const FNV1_PRIME = 1099511628211n;
787
811
  declare function fnv1<V>(value: V): bigint;
788
812
  declare function sdbm<V>(value: V): bigint;
789
813
  interface IHash extends IToString {
790
- update(input: Uint8Array): this;
791
- digest(): Uint8Array;
792
- }
793
-
794
- declare class MD2 implements IHash {
795
- static readonly BLOCK_SIZE = 16;
796
- private _data;
797
- private _state;
798
- private _checksum;
799
- private _length;
800
- constructor();
801
- update(input: Uint8Array): this;
802
- private _transform;
803
- digest(): Uint8Array;
804
- toString(): string;
805
- get [Symbol.toStringTag](): string;
806
- [NodeJSCustomInspect](): string;
814
+ update(input: Uint8Array): this;
815
+ digest(): Uint8Array;
807
816
  }
808
-
817
+ //#endregion
818
+ //#region source/geometry/angle.d.ts
809
819
  declare const MAX_ANGLE_DEGREE = 360;
810
820
  declare const clampAngleDegree: (angle: number) => number;
811
821
  declare const clampAngleRadian: (angle: number) => number;
812
822
  declare const radianToDegree: (angle: number) => number;
813
823
  declare const degreeToRadian: (angle: number) => number;
814
-
824
+ //#endregion
825
+ //#region source/geometry/triangle.d.ts
815
826
  interface ITriangle extends IGeometryObject {
816
- readonly a: number;
817
- readonly b: number;
818
- readonly c: number;
819
- readonly alpha: number;
820
- readonly beta: number;
821
- readonly gamma: number;
822
- readonly semiperimeter: number;
823
- readonly height: number;
824
- readonly base: number;
827
+ readonly a: number;
828
+ readonly b: number;
829
+ readonly c: number;
830
+ readonly alpha: number;
831
+ readonly beta: number;
832
+ readonly gamma: number;
833
+ readonly semiperimeter: number;
834
+ readonly height: number;
835
+ readonly base: number;
825
836
  }
826
837
  declare abstract class Triangle<T> implements ITriangle {
827
- A: T;
828
- B: T;
829
- C: T;
830
- abstract get a(): number;
831
- abstract get b(): number;
832
- abstract get c(): number;
833
- constructor(A: T, B: T, C: T);
834
- get alpha(): number;
835
- get beta(): number;
836
- get gamma(): number;
837
- get perimeter(): number;
838
- get semiperimeter(): number;
839
- get area(): number;
840
- get base(): number;
841
- get height(): number;
842
- toString(): string;
843
- get [Symbol.toStringTag](): string;
844
- [NodeJSCustomInspect](): string;
838
+ A: T;
839
+ B: T;
840
+ C: T;
841
+ abstract get a(): number;
842
+ abstract get b(): number;
843
+ abstract get c(): number;
844
+ constructor(A: T, B: T, C: T);
845
+ get alpha(): number;
846
+ get beta(): number;
847
+ get gamma(): number;
848
+ get perimeter(): number;
849
+ get semiperimeter(): number;
850
+ get area(): number;
851
+ get base(): number;
852
+ get height(): number;
853
+ toString(): string;
854
+ get [Symbol.toStringTag](): string;
855
+ [NodeJSCustomInspect](): string;
845
856
  }
846
857
  declare class Triangle2D extends Triangle<Vec2> {
847
- get a(): number;
848
- get b(): number;
849
- get c(): number;
858
+ get a(): number;
859
+ get b(): number;
860
+ get c(): number;
850
861
  }
851
862
  declare class Triangle3D extends Triangle<Vec3> {
852
- get a(): number;
853
- get b(): number;
854
- get c(): number;
863
+ get a(): number;
864
+ get b(): number;
865
+ get c(): number;
855
866
  }
856
-
867
+ //#endregion
868
+ //#region source/color.d.ts
869
+ type AnyColor = RGBA | HSLA;
857
870
  type AnyColorArray = AnyRGBArray | AnyHSLArray;
858
871
  type AnyColorString = AnyRGBString | AnyHSLString;
859
872
  type IAnyColor = IAnyRGB | IAnyHSL;
860
873
  type IAnyToColor = IAnyToRGB | IAnyToHSL;
861
- type AnyColorLike = AnyColorArray | AnyColorString | IAnyColor | number;
874
+ type AnyColorLike = AnyColorArray | AnyColorString | IAnyColor | number | HexColor;
862
875
  type AnyColorArguments = AnyColorArray | [color: AnyColorLike];
863
- type AnyColor = RGBA | HSLA;
864
876
  declare namespace AnyColor {
865
- function cast(a: unknown, preferHSL?: boolean): AnyColor | undefined;
866
- function resolve(a: unknown, preferHSL?: boolean): AnyColor;
867
- function resolveArgs(args: AnyColorArguments, preferHSL?: boolean): AnyColor;
877
+ function cast(a: unknown, preferHSL?: boolean): AnyColor | undefined;
878
+ function resolve(a: unknown, preferHSL?: boolean): AnyColor;
879
+ function resolveArgs(args: AnyColorArguments, preferHSL?: boolean): AnyColor;
868
880
  }
869
-
881
+ //#endregion
882
+ //#region source/transform.d.ts
870
883
  declare class Transform2D implements IToMat3, IToString {
871
- parent?: Transform2D | undefined;
872
- origin: Vec2;
873
- localPosition: Vec2;
874
- localRotation: number;
875
- get localRotationDegree(): number;
876
- set localRotationDegree(v: number);
877
- localScale: Vec2;
878
- get globalPosition(): Vec2;
879
- get globalRotation(): number;
880
- get globalRotationDegree(): number;
881
- get globalScale(): Vec2;
882
- constructor(position: Vec2Like, rotation: number, scale: Vec2Like, parent?: Transform2D | undefined);
883
- toString(): string;
884
- get [Symbol.toStringTag](): string;
885
- [NodeJSCustomInspect](): string;
886
- toMat3(): Mat3;
887
- toGlobalMat3(): Mat3;
884
+ parent?: Transform2D | undefined;
885
+ origin: Vec2;
886
+ localPosition: Vec2;
887
+ localRotation: number;
888
+ get localRotationDegree(): number;
889
+ set localRotationDegree(v: number);
890
+ localScale: Vec2;
891
+ get globalPosition(): Vec2;
892
+ get globalRotation(): number;
893
+ get globalRotationDegree(): number;
894
+ get globalScale(): Vec2;
895
+ constructor(position: Vec2Like, rotation: number, scale: Vec2Like, parent?: Transform2D | undefined);
896
+ toString(): string;
897
+ get [Symbol.toStringTag](): string;
898
+ [NodeJSCustomInspect](): string;
899
+ toMat3(): Mat3;
900
+ toGlobalMat3(): Mat3;
888
901
  }
889
902
  /**
890
903
  * Represents a 3D transform for 3D graphics
891
904
  */
892
905
  declare class Transform3D implements IToMat4, IToString {
893
- parent?: Transform3D | undefined;
894
- origin: Vec3;
895
- /**
896
- * The local position
897
- */
898
- localPosition: Vec3;
899
- /**
900
- * The local rotation
901
- */
902
- localRotation: Quaternion;
903
- /**
904
- * The local scale
905
- */
906
- localScale: Vec3;
907
- get globalPosition(): Vec3;
908
- get globalRotation(): Quaternion;
909
- get globalScale(): Vec3;
910
- /**
911
- * Create a new transform with `position`, `rotation` and `scale`
912
- * @param position The position as a Vec3
913
- * @param rotation The rotation as a Quaternion
914
- * @param scale The scale as a Vec3
915
- */
916
- constructor(position: Vec3Like, rotation: QuaternionLike, scale: Vec3Like, parent?: Transform3D | undefined);
917
- toString(): string;
918
- get [Symbol.toStringTag](): string;
919
- [NodeJSCustomInspect](): string;
920
- /**
921
- * Convert the transform into a 4x3 matrix
922
- * @returns A 4x4 matrix from the transform
923
- */
924
- toMat4(): Mat4;
925
- toGlobalMat4(): Mat4;
926
- }
927
-
906
+ parent?: Transform3D | undefined;
907
+ origin: Vec3;
908
+ /**
909
+ * The local position
910
+ */
911
+ localPosition: Vec3;
912
+ /**
913
+ * The local rotation
914
+ */
915
+ localRotation: Quaternion;
916
+ /**
917
+ * The local scale
918
+ */
919
+ localScale: Vec3;
920
+ get globalPosition(): Vec3;
921
+ get globalRotation(): Quaternion;
922
+ get globalScale(): Vec3;
923
+ /**
924
+ * Create a new transform with `position`, `rotation` and `scale`
925
+ * @param position The position as a Vec3
926
+ * @param rotation The rotation as a Quaternion
927
+ * @param scale The scale as a Vec3
928
+ */
929
+ constructor(position: Vec3Like, rotation: QuaternionLike, scale: Vec3Like, parent?: Transform3D | undefined);
930
+ toString(): string;
931
+ get [Symbol.toStringTag](): string;
932
+ [NodeJSCustomInspect](): string;
933
+ /**
934
+ * Convert the transform into a 4x3 matrix
935
+ * @returns A 4x4 matrix from the transform
936
+ */
937
+ toMat4(): Mat4;
938
+ toGlobalMat4(): Mat4;
939
+ }
940
+ //#endregion
941
+ //#region source/utils.d.ts
928
942
  /**
929
943
  * Clamp `value` between `min` and `max`
930
944
  * @param value The input value
@@ -942,5 +956,5 @@ declare function clamp<T extends number | bigint>(value: T, min: T, max: T): T;
942
956
  declare function logHypot(a: number, b: number): number;
943
957
  declare const EPSILON = 1e-16;
944
958
  declare const lerp: <T extends number | bigint>(a: T, b: T, t: T) => number;
945
-
946
- export { AnyColor, type AnyColorArguments, type AnyColorArray, type AnyColorLike, type AnyColorString, type AnyHSLArguments, type AnyHSLArray, type AnyHSLLike, type AnyHSLString, type AnyRGBArguments, type AnyRGBArray, type AnyRGBLike, type AnyRGBString, BoundingBox, type BoundingBoxArgs, type BoundingBoxArray, type BoundingBoxLike, type BoundingBoxString, Circle, type CircleArguments, type CircleArray, type CircleLike, type CircleString, DJB2_OFFSET, EPSILON, FNV1_OFFSET, FNV1_PRIME, HSLA, type HSLAArguments, type HSLAArray, type HSLALike, type HSLAString, type HSLArguments, type HSLArray, type HSLLike, type HSLString, type IAnyColor, type IAnyHSL, type IAnyRGB, type IAnyToColor, type IAnyToHSL, type IAnyToRGB, type IBoundingBox, type ICircle, type IGeometryObject, type IHSL, type IHSLA, type IHash, type IMat3, type IMat4, type IQuaternion, type IRBBA, type IRGB, type IRectangle, type ISize, type IToBoundingBox, type IToCircle, type IToHSL, type IToHSLA, type IToMat3, type IToMat4, type IToQuaternion, type IToRGB, type IToRGBA, type IToRectangle, type IToSize, type IToVec2, type IToVec3, type ITriangle, type IVec2, type IVec3, LinearFunction, type LinearFunctionString, MAX_ANGLE_DEGREE, MD2, Mat3, type Mat3Arguments, type Mat3Array, type Mat3Like, type Mat3NestedArray, type Mat3String, Mat4, type Mat4Arguments, type Mat4Array, type Mat4Like, type Mat4NestedArray, type Mat4String, MathFunction, QuadFunction, type QuadFunctionString, type QuadFunctionStrings, type QuadFunctionType, Quaternion, type QuaternionArguments, type QuaternionArray, type QuaternionLike, type QuaternionString, RGBA, type RGBAArguments, type RGBAArray, type RGBALike, type RGBAString, type RGBArguments, type RGBArray, type RGBLike, type RGBString, Rectangle, type RectangleArguments, type RectangleArray, type RectangleLike, type RectangleString, ResolveError, type SignCharacter, Size, type SizeArguments, type SizeArray, type SizeLike, type SizeString, Transform2D, Transform3D, Triangle, Triangle2D, Triangle3D, Vec2, type Vec2Arguments, type Vec2Array, type Vec2Like, type Vec2String, Vec3, type Vec3Arguments, type Vec3Array, type Vec3Like, type Vec3String, clamp, clampAngleDegree, clampAngleRadian, degreeToRadian, djb2, fnv1, lerp, logHypot, numberToRGB, numberToRGBA, radianToDegree, sdbm, signCharacter };
959
+ //#endregion
960
+ export { AnyColor, AnyColorArguments, AnyColorArray, AnyColorLike, AnyColorString, AnyHSLArguments, AnyHSLArray, AnyHSLLike, AnyHSLString, AnyRGBArguments, AnyRGBArray, AnyRGBLike, AnyRGBString, BoundingBox, BoundingBoxArgs, BoundingBoxArray, BoundingBoxLike, BoundingBoxString, Circle, CircleArguments, CircleArray, CircleLike, CircleString, DJB2_OFFSET, EPSILON, FNV1_OFFSET, FNV1_PRIME, HSLA, HSLAArguments, HSLAArray, HSLALike, HSLAString, HSLArguments, HSLArray, HSLLike, HSLString, HexColor, HexColorPrefix, IAnyColor, IAnyHSL, IAnyRGB, IAnyToColor, IAnyToHSL, IAnyToRGB, IBoundingBox, ICircle, IGeometryObject, IHSL, IHSLA, IHash, IMat3, IMat4, IQuaternion, IRBBA, IRGB, IRectangle, ISize, IToBoundingBox, IToCircle, IToHSL, IToHSLA, IToMat3, IToMat4, IToQuaternion, IToRGB, IToRGBA, IToRectangle, IToSize, IToVec2, IToVec3, ITriangle, IVec2, IVec3, LinearFunction, LinearFunctionString, MAX_ANGLE_DEGREE, Mat3, Mat3Arguments, Mat3Array, Mat3Like, Mat3NestedArray, Mat3String, Mat4, Mat4Arguments, Mat4Array, Mat4Like, Mat4NestedArray, Mat4String, MathFunction, QuadFunction, QuadFunctionString, QuadFunctionStrings, QuadFunctionType, Quaternion, QuaternionArguments, QuaternionArray, QuaternionLike, QuaternionString, RGBA, RGBAArguments, RGBAArray, RGBALike, RGBAString, RGBArguments, RGBArray, RGBLike, RGBString, Rectangle, RectangleArguments, RectangleArray, RectangleLike, RectangleString, ResolveError, SignCharacter, Size, SizeArguments, SizeArray, SizeLike, SizeString, Transform2D, Transform3D, Triangle, Triangle2D, Triangle3D, Vec2, Vec2Arguments, Vec2Array, Vec2Like, Vec2String, Vec3, Vec3Arguments, Vec3Array, Vec3Like, Vec3String, clamp, clampAngleDegree, clampAngleRadian, degreeToRadian, djb2, fnv1, hasHexNumberAlpha, hexNumberToRGB, hexNumberToRGBA, isHexNumber, lerp, logHypot, numberToRGB, numberToRGBA, radianToDegree, sdbm, signCharacter };