figureone 0.15.10 → 1.0.1

package/types/js/tools/geometry/angle.d.ts

@@ -0,0 +1,105 @@
+import { Point } from './Point';
+declare function deg(angle: number): number;
+/**
+ * Get the minimum absolute angle difference between two angles
+ *
+ * @example
+ * const minAngleDiff = Fig.minAngleDiff;
+ * const d1 = minAngleDiff(0.1, 0.2);
+ * console.log(d1);
+ * // -0.1
+ *
+ * const d2 = minAngleDiff(0.2, 0.1);
+ * console.log(d2);
+ * // 0.1
+ *
+ * const d3 = minAngleDiff(0.1, -0.1);
+ * console.log(d3);
+ * // 0.2
+ * @group 2D Geometry Tools
+ */
+declare function minAngleDiff(angle1: number, angle2: number): number;
+/**
+ * Clip and angle between 0 and 2π (`'0to360'`) or -π to π (`'-180to180'`).
+ * `null` will return the angle between -2π to 2π.
+ * @example
+ * const clipAngle = Fig.clipAngle
+ *
+ * const a1 = clipAngle(Math.PI / 2 * 5, '0to360');
+ * console.log(a1);
+ * // 1.5707963267948966
+ *
+ * const a2 = clipAngle(Math.PI / 4 * 5, '-180to180');
+ * console.log(a2);
+ * // -2.356194490192345
+ *
+ * const a3 = clipAngle(-Math.PI / 4 * 10, null);
+ * console.log(a3);
+ * // -1.5707963267948966
+ * @group 2D Geometry Tools
+ */
+declare function clipAngle(angleToClip: number, clipTo: '0to360' | '-180to180' | null | '-360to360' | '-360to0'): number;
+/**
+ * Normalize angle to between 0 and 2π.
+ * @group 2D Geometry Tools
+ */
+declare function normAngle(angle: number): number;
+declare function normAngleTo90(angle: number): number;
+/**
+ * TypeRotationDirection = 0 | 1 | 2 | -1 | null
+ *
+ * - 0: quickest direction
+ * - 1: positive direction (CCW in 2D)
+ * - -1: negative direction (CW in 2D)
+ * - 2: not through zero
+ * - null: returns numerical delta angle
+ * @group Misc Shapes
+ */
+export type TypeRotationDirection = 0 | 1 | 2 | -1 | null;
+/**
+ * Get angle delta based on direction
+ * @group 2D Geometry Tools
+ */
+declare function getDeltaAngle(startAngle: number, targetAngle: number, rotDirection?: TypeRotationDirection): number;
+/**
+ * Get delta angle of a Point where the x, y, z components are rotations
+ * around the x, y, and z axes.
+ * @group 2D Geometry Tools
+ */
+declare function getDeltaAngle3D(startAngle: Point, targetAngle: Point, rotDirection?: TypeRotationDirection | [TypeRotationDirection, TypeRotationDirection, TypeRotationDirection]): Point;
+/**
+ * Returns the angle from the line (p1, p2) to the line (p1, p3) in the positive
+ * rotation direction and normalized from 0 to Math.PI * 2.
+ *
+ * @example
+ * const threePointAngle = Fig.threePointAngle;
+ * const getPoint = Fig.getPoint;
+ *
+ * const p1 = threePointAngle(getPoint([1, 0]), getPoint([0, 0]), getPoint([0, 1]));
+ * console.log(p1);
+ * // 1.5707963267948966
+ *
+ * const p2 = threePointAngle(getPoint([0, 1]), getPoint([0, 0]), getPoint([1, 0]));
+ * console.log(p2);
+ * // 4.71238898038469
+ * @group 2D Geometry Tools
+ */
+declare function threePointAngle(p2: Point, p1: Point, p3: Point): number;
+/**
+ * Returns the minimum angle from the line (p1, p2) to the line (p1, p3).
+ *
+ * @example
+ * const threePointAngleMin = Fig.threePointAngleMin;
+ * const getPoint = Fig.getPoint;
+ *
+ * const p1 = threePointAngleMin(getPoint([1, 0]), getPoint([0, 0]), getPoint([0, 1]));
+ * console.log(p1);
+// 1.5707963267948966
+ *
+ * const p2 = threePointAngleMin(getPoint([0, 1]), getPoint([0, 0]), getPoint([1, 0]));
+ * console.log(p2);
+ * // -1.5707963267948966
+ * @group 2D Geometry Tools
+ */
+declare function threePointAngleMin(p2: Point, p1: Point, p3: Point): number;
+export { deg, minAngleDiff, getDeltaAngle3D, getDeltaAngle, normAngleTo90, threePointAngle, threePointAngleMin, clipAngle, normAngle, };

package/types/js/tools/geometry/common.d.ts

@@ -0,0 +1,9 @@
+import type { Type3Components } from './types';
+declare function getPrecision(options?: {
+    precision?: number;
+}, defaultPrecision?: number): number;
+declare function dotProduct(a: Type3Components, b: Type3Components): number;
+declare function quadraticBezier(P0: number, P1: number, P2: number, t: number): number;
+declare function cartesianToSpherical(x: number, y?: number, z?: number): [number, number, number];
+declare function sphericalToCartesian(r: number, theta: number, phi: number): [number, number, number];
+export { getPrecision, dotProduct, quadraticBezier, cartesianToSpherical, sphericalToCartesian, };

package/types/js/tools/geometry/coordinates.d.ts

@@ -0,0 +1,30 @@
+import { Point } from './Point';
+/**
+ * Polar coordinates to cartesian coordinates conversion
+ *
+ * @example
+ * const polarToRect = Fig.polarToRect;
+ * const p = polarToRect(Math.sqrt(2), Math.PI / 4);
+ * console.log(p);
+ * // Point {x: 1, y: 1)
+ * @group 2D Geometry Tools
+ */
+declare function polarToRect(mag: number, angle: number, theta?: number | null): Point;
+/**
+ * Cartesian coordinates to polar coordinates conversion
+ *
+ * @example
+* const rectToPolar = Fig.rectToPolar;
+* const p = rectToPolar(0, 1);
+* console.log(p);
+* // {mag: 1, angle: 1.5707963267948966}
+ * @group 2D Geometry Tools
+ */
+declare function rectToPolar(x: number | Point, y?: number, z?: number): {
+    angle: number;
+    mag: number;
+    phi: number;
+    r: number;
+    theta: number;
+};
+export { rectToPolar, polarToRect, };

package/types/js/tools/geometry/deceleration.d.ts

@@ -0,0 +1,13 @@
+import { Point } from './Point';
+import { RectBounds, RangeBounds, LineBounds } from './Bounds';
+declare function decelerateValue(valueIn: number, velocityIn: number, decelerationIn: number, deltaTimeIn?: number | null, bounds?: null | RangeBounds, bounceLossIn?: number, zeroVelocityThreshold?: number, precision?: number): {
+    velocity: number;
+    duration: null | number;
+    value: number;
+};
+declare function decelerateVector(positionIn: Point, velocityIn: Point, decelerationIn: number, deltaTimeIn?: number | null, bounds?: null | RectBounds | LineBounds, bounceLossIn?: number, zeroVelocityThreshold?: number, precision?: number): {
+    velocity: Point;
+    position: Point;
+    duration: number | null;
+};
+export { decelerateVector, decelerateValue, };

package/types/js/tools/geometry/polygon.d.ts

@@ -0,0 +1,4 @@
+import { Point } from './Point';
+declare function isPointInPolygon(point: Point, polygonCorners: Array<Point>): boolean;
+declare function isPointOnPolygon(point: Point, polygonCorners: Array<Point>): boolean;
+export { isPointInPolygon, isPointOnPolygon, };

package/types/js/tools/geometry/quaternion.d.ts

@@ -0,0 +1,15 @@
+import type { TypeParsablePoint, Point } from './Point';
+export type TypeQuaternion = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+declare function quaternion(a: number, b: number, c: number, d: number): TypeQuaternion;
+declare function quaternionFromPoint(p: TypeParsablePoint): TypeQuaternion;
+declare function quaternionFromAngleAxis(angle: number, x: number, y: number, z: number): TypeQuaternion;
+declare function mul(q1: TypeQuaternion, q2: TypeQuaternion): TypeQuaternion;
+declare function inverse(q: TypeQuaternion): TypeQuaternion;
+declare function transformPoint(p: TypeParsablePoint, q: TypeQuaternion): Point;
+declare function rotatePoint(p: TypeParsablePoint, angleOrRotations: number | Array<[number, TypeParsablePoint]>, axis?: TypeParsablePoint): Point;
+export { quaternion, quaternionFromPoint, quaternionFromAngleAxis, mul, inverse, transformPoint, rotatePoint, };

package/types/js/tools/geometry/scene.d.ts

@@ -0,0 +1,282 @@
+import type { TypeParsablePoint } from './Point';
+import { Point } from './Point';
+import { Plane } from './Plane';
+import type { Type3DMatrix } from '../m3';
+/**
+  * @property {'orthographic' | 'perspective' | '2D'} [style]
+  * @property {number} [left]
+  * @property {number} [right]
+  * @property {number} [bottom]
+  * @property {number} [top]
+  * @property {number} [aspectRatio]
+  * @property {number} [fieldOfView]
+  * @property {number} [near]
+  * @property {number} [far]
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_Projection = {
+    style?: 'orthographic' | 'perspective' | '2D';
+    left?: number;
+    right?: number;
+    bottom?: number;
+    top?: number;
+    aspectRatio?: number;
+    fieldOfView?: number;
+    near?: number;
+    far?: number;
+};
+export type OBJ_CameraDefined = {
+    position: TypeParsablePoint;
+    lookAt: TypeParsablePoint;
+    up: TypeParsablePoint;
+};
+/**
+ * @property {TypeParsablePoint} [position]
+ * @property {TypeParsablePoint} [lookAt]
+ * @property {TypeParsablePoint} [up]
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_Camera = {
+    position?: TypeParsablePoint;
+    lookAt?: TypeParsablePoint;
+    up?: TypeParsablePoint;
+};
+/**
+ * @property {TypeParsablePoint} [directional]
+ * @property {number} [ambient]
+ * @property {TypeParsablePoint} [point]
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_Light = {
+    directional?: TypeParsablePoint;
+    ambient?: number;
+    point?: TypeParsablePoint;
+};
+export type OBJ_LightDefined = {
+    directional: TypeParsablePoint;
+    ambient: number;
+    point: TypeParsablePoint;
+};
+/**
+ * The Scene options object defines how the elements within the figure are
+ * viewed.
+ *
+ * For 2D figures (`style: '2D'`), `left`, `right`, `bottom`, and `top` are
+ * required to define the x-y expanse to view. Any elements or portions of
+ * elements outside of this expanse will not be shown (be clipped).
+ *
+ * For 3D figures, a camera, lighting and the near/far clipping planes also
+ * need definition.
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_Scene = {
+    style?: '2D' | 'orthographic' | 'perspective';
+    left?: number;
+    right?: number;
+    bottom?: number;
+    top?: number;
+    near?: number;
+    far?: number;
+    aspectRatio?: number;
+    fieldOfView?: number;
+    light?: OBJ_Light;
+    camera?: OBJ_Camera;
+    zoom?: number;
+    pan?: Point;
+};
+/**
+  * @property {number} [left]
+  * @property {number} [right]
+  * @property {number} [bottom]
+  * @property {number} [top]
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_2DScene = {
+    left?: number;
+    right?: number;
+    bottom?: number;
+    top?: number;
+};
+/**
+  * @property {number} [left]
+  * @property {number} [right]
+  * @property {number} [bottom]
+  * @property {number} [top]
+  * @property {number} [near]
+  * @property {number} [far]
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_OrthographicScene = {
+    left?: number;
+    right?: number;
+    bottom?: number;
+    top?: number;
+    near?: number;
+    far?: number;
+};
+/**
+  * @property {aspectRatio} [number]
+  * @property {fieldOfView} [number]
+  * @property {near} [number]
+  * @property {far} [number]
+ * @interface
+ * @group Misc Shapes
+ */
+export type OBJ_PerspectiveScene = {
+    aspectRatio?: number;
+    fieldOfView?: number;
+    near?: number;
+    far?: number;
+};
+export type OBJ_SceneDefined = {
+    style: '2D' | 'orthographic' | 'perspective';
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+    near: number;
+    far: number;
+    camera: OBJ_Camera;
+    aspectRatio: number;
+    fieldOfView: number;
+    light: OBJ_Light;
+    projectionMatrix: Type3DMatrix;
+    viewMatrix: Type3DMatrix;
+};
+/**
+  * Scene.
+  *
+  * @param {OBJ_Scene} options scene definition options
+  * @param {null | (() => void)} onUpdate callback if scene is updated
+  * @group Misc Shapes
+  */
+export default class Scene {
+    style: '2D' | 'orthographic' | 'perspective';
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+    near: number;
+    far: number;
+    camera: OBJ_CameraDefined;
+    aspectRatio: number;
+    fieldOfView: number;
+    light: OBJ_LightDefined;
+    projectionMatrix: Type3DMatrix;
+    viewMatrix: Type3DMatrix;
+    cameraMatrix: Type3DMatrix;
+    viewProjectionMatrix: Type3DMatrix;
+    onUpdate: null | (() => void);
+    cameraPosition: Point;
+    cameraVector: Point;
+    inverseViewProjectionMatrix: Type3DMatrix;
+    rightVector: Point;
+    upVector: Point;
+    nearCenter: Point;
+    farCenter: Point;
+    nearPlane: Plane;
+    farPlane: Plane;
+    heightNear: number;
+    heightFar: number;
+    widthNear: number;
+    widthFar: number;
+    zoom: number;
+    pan: Point;
+    pannedCameraPosition: Point;
+    pannedLookAt: Point;
+    defaultOptions(): {
+        aspectRatio: number;
+        bottom: number;
+        camera: {
+            lookAt: number[] | TypeParsablePoint;
+            position: number[] | TypeParsablePoint;
+            up: number[] | TypeParsablePoint;
+        };
+        far: number;
+        fieldOfView: number;
+        left: number;
+        light: {
+            ambient: number;
+            directional: number[] | TypeParsablePoint;
+            point: number[] | TypeParsablePoint;
+        };
+        near: number;
+        right: number;
+        style: '2D' | 'orthographic' | 'perspective';
+        top: number;
+        zoom: number;
+        pan: Point;
+    };
+    constructor(options: OBJ_Scene, onUpdate?: null | (() => void));
+    reset(options: OBJ_Scene): void;
+    dup(): Scene;
+    calcProjectionMatrix(): void;
+    calcViewMatrix(): void;
+    calcViewProjectionMatrix(): void;
+    dupMatrix(matrix: Type3DMatrix): Type3DMatrix;
+    /**
+     * Set the pan and zoom of the scene.
+     *
+     * Pan is applied to `camera.position` and `camera.lookAt`, while
+     * zoom is applied to
+     * `camera.left`/`camera.bottom`/`camera.right`/`camera.top` (for 2D and
+     * orthographic) or `camera.fov` (for perspective)
+     *
+     * The camera and projection variables are not changed by pan and zoom, but
+     * the the view and projection matrices are.
+     *
+     * A pan in the positive direction will move the scene left and down.
+     *
+     * A zoom greater than 1 will reduce the left/right/bottom/top or fov
+     * effectively magnifying the scene.
+     *
+     * @param {Point} pan
+     * @param {number} zoom
+     */
+    setPanZoom(pan: Point, zoom: number): void;
+    /**
+     * Set the pan of the scene.
+     *
+     * Pan is applied to `camera.position` and `camera.lookAt`.
+     *
+     * The camera is changed by pan and zoom, but the resulting view matrix is.
+     *
+     * A pan in the positive direction will move the scene left and down.
+     *
+     * @param {Point} pan
+     */
+    setPan(pan: Point): void;
+    /**
+     * Set camera properties.
+     */
+    setCamera(options: OBJ_Camera): void;
+    setCameraProperties(options: OBJ_Camera): void;
+    /**
+     * Set projection properties.
+     */
+    setProjection(options: OBJ_Projection): void;
+    /**
+     * Set a 2D scene.
+     */
+    set2D(options: OBJ_2DScene): void;
+    /**
+     * Set an orthographic scene.
+     */
+    setOrthographic(options: OBJ_OrthographicScene): void;
+    /**
+     * Set a perspective scene.
+     */
+    setPerspective(options: OBJ_PerspectiveScene): void;
+    /**
+     * Set light properties
+     */
+    setLight(options: OBJ_Light): void;
+    figureToGL(figurePoint: TypeParsablePoint): Point;
+    glToFigure(glPoint: TypeParsablePoint): Point;
+}

package/types/js/tools/geometry/tools.d.ts

@@ -0,0 +1,8 @@
+import { Point } from './Point';
+declare function pointsToNumbers2(points: Point[]): number[];
+declare function pointsToNumbers(points: Point[], dimension?: 2 | 3): number[];
+declare function numbersToPoints2(numbers: number[]): Point[];
+declare function numbersToPoints(numbers: number[], dimension?: 2 | 3): Point[];
+declare function toNumbers(pointsOrNumbers: Point[] | number[][] | number[], dimension?: 2 | 3): number[];
+declare function toPoints(pointsOrNumbers: Point[] | number[], dimension?: 2 | 3): Point[];
+export { pointsToNumbers2, pointsToNumbers, numbersToPoints, numbersToPoints2, toNumbers, toPoints, };

package/types/js/tools/geometry/types.d.ts

@@ -0,0 +1,2 @@
+export type Type3Components = [number, number, number];
+export type Type2Components = [number, number];

package/types/js/tools/getCssColors.d.ts

@@ -0,0 +1 @@
+export default function getCSSColors(customColorNames?: Array<string>): Record<string, any>;

package/types/js/tools/getCssVariables.d.ts

@@ -0,0 +1,4 @@
+declare function searchObject(obj: Record<string, any>, path: string, text: string): string[];
+declare function getDefinedCSSVariables(idOrElement: string | HTMLElement, propertyNames: Array<string>, prefix?: string, makeFlat?: boolean, modifier?: (value: string | number) => string | number): Record<string, any>;
+declare function getCSSVariables(idOrElement: string | HTMLElement, prefix?: string, makeFlat?: boolean): Record<string, any>;
+export { getCSSVariables, getDefinedCSSVariables, searchObject };

package/types/js/tools/getImageData.d.ts

@@ -0,0 +1 @@
+export default function getImageData(image: HTMLImageElement): ImageDataArray;

package/types/js/tools/getScssColors.d.ts

@@ -0,0 +1,2 @@
+declare const getScssColors: (styles: Record<string, string>) => Record<string, number[]>;
+export default getScssColors;

package/types/js/tools/htmlGenerator.d.ts

@@ -0,0 +1,85 @@
+import type { TypeColor } from './types';
+declare function withClass(text: (string | Array<string>) | undefined, classText: string): string;
+declare function centerV(text?: string | Array<string>): string;
+declare function centerVH(text?: string | Array<string>): string;
+declare function centerH(text?: string | Array<string>): string;
+declare function style(options?: number | {
+    left?: number;
+    top?: number;
+    line?: number;
+    right?: number;
+    size?: number;
+    className?: string;
+    color?: TypeColor;
+    centerV?: boolean;
+    centerH?: boolean;
+    list?: 'ordered' | 'unordered' | null;
+    listStyleType?: string;
+    id?: string;
+}, text?: string | Array<string>): string;
+declare function itemSelector(items?: Array<string>, classes?: string, selectorIndex?: number): string;
+declare const unit: (deg: string, rad: string) => string;
+declare function toHTML(text?: string, id?: string, classes?: string, color?: TypeColor | null): {
+    replacementText: string;
+};
+declare function highlight(classesOrColor?: string | Array<number>): {
+    replacementText: (text: string) => {
+        replacementText: string;
+    };
+};
+declare function link(linkStr: string, colorOrOptions?: Array<number> | {
+    color?: Array<number> | null;
+    id?: string;
+    classes?: string;
+    text?: string | null;
+    newTab?: boolean | null;
+} | null): {
+    replacementText: (textIn: string) => {
+        replacementText: string;
+    };
+    id: () => string;
+};
+declare function highlightWord(text: string, classesOrColor?: string | Array<number>): {
+    replacementText: string;
+};
+declare function addClass(classes?: string): {
+    replacementText: (text: string) => {
+        replacementText: string;
+    };
+};
+declare function addId(id?: string): {
+    replacementText: (text: string) => {
+        replacementText: string;
+    };
+};
+declare function click(actionMethod: Function, bind: Array<any>, colorOrOptions?: Array<number> | {
+    color?: Array<number> | null;
+    interactive?: boolean;
+    id?: string;
+    classes?: string;
+    text?: string | null;
+} | null): {
+    replacementText: (textIn: string) => {
+        replacementText: string;
+    };
+    id: () => string;
+    actionMethod: Function;
+    bind: any[];
+};
+declare function clickW(textToUse: string, actionMethod: Function, bind: Array<any>, color?: TypeColor | null): {
+    replacementText: (textIn: string) => {
+        replacementText: string;
+    };
+    id: () => string;
+    actionMethod: Function;
+    bind: any[];
+};
+declare function actionWord(text: string, id?: string, classesOrColor?: string | Array<number> | null, interactive?: boolean): {
+    replacementText: string;
+    id: string;
+};
+declare function onClickId(id: string, actionMethod: Function, bind: Array<any>, additionalClassesToAdd?: string): void;
+declare function applyModifiers(text: string, modifiers: Record<string, any>, highlightClass?: string, monochrome?: boolean): string;
+declare function setOnClicks(modifiers: Record<string, any>, additionalClassesToAdd?: string): void;
+declare function setHTML(element: HTMLElement, text: string, modifiers?: Record<string, any>, classesToAdd?: string): void;
+export { actionWord, click, highlight, addClass, addId, onClickId, highlightWord, centerV, centerH, centerVH, toHTML, itemSelector, unit, applyModifiers, setOnClicks, setHTML, withClass, style, clickW, link, };

package/types/js/tools/m2.d.ts

@@ -0,0 +1,24 @@
+export type Type2DMatrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+declare function mul(a: Type2DMatrix, b: Type2DMatrix): Type2DMatrix;
+declare function t(a: Type2DMatrix): Type2DMatrix;
+declare function identity(): Type2DMatrix;
+declare function copy(a: Type2DMatrix): Type2DMatrix;
+declare function translationMatrix(tx: number, ty: number): Type2DMatrix;
+declare function translate(m: Type2DMatrix, tx: number, ty: number): Type2DMatrix;
+declare function rotationMatrix(angle: number): Type2DMatrix;
+declare function rotate(m: Type2DMatrix, angle: number): Type2DMatrix;
+declare function scaleMatrix(sx: number, sy: number): Type2DMatrix;
+declare function scale(m: Type2DMatrix, sx: number, sy: number): Type2DMatrix;
+declare function transform(m: Type2DMatrix, px: number, py: number): [number, number];
+declare function inverse(m: Type2DMatrix): Type2DMatrix;
+export { mul, identity, t, copy, translate, rotate, transform, scale, inverse, rotationMatrix, translationMatrix, scaleMatrix, };

package/types/js/tools/m3.d.ts

@@ -0,0 +1,71 @@
+export type Type3DMatrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export type Type3Matrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export type Type2DMatrix = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export type Type3Vector = [number, number, number];
+declare function mul(a: Type3DMatrix, b: Type3DMatrix): Type3DMatrix;
+declare function transpose(a: Type3DMatrix): Type3DMatrix;
+declare function identity(): Type3DMatrix;
+declare function copy(a: Type3DMatrix): Type3DMatrix;
+declare function translationMatrix(tx: number, ty: number, tz: number): Type3DMatrix;
+declare function translate(m: Type3DMatrix, tx: number, ty: number, tz: number): Type3DMatrix;
+declare function rotationMatrixX(angle: number): Type3DMatrix;
+declare function rotationMatrixY(angle: number): Type3DMatrix;
+declare function rotationMatrixZ(angle: number): Type3DMatrix;
+declare function rotationMatrixXYZ(rx: number, ry: number, rz: number): Type3DMatrix;
+declare function rotationMatrixUnitAxis(axis: [number, number, number], angle: number): Type3DMatrix;
+declare function rotationMatrixAxis(axis: [number, number, number], angle: number): Type3DMatrix;
+declare function rotationMatrixVectorToVector(fromVector: [number, number, number], toVector: [number, number, number]): Type3DMatrix;
+declare function rotationMatrixDirection(vector: [number, number, number]): Type3DMatrix;
+declare function directionToAxisAngle(vector: [number, number, number], axisIfCollinear?: [number, number, number]): [[number, number, number], number];
+declare function vectorToVectorToAxisAngle(fromVector: [number, number, number], toVector: [number, number, number], axisIfCollinear?: [number, number, number] | null): [[number, number, number], number];
+declare function rotate(m: Type3DMatrix, rx: number, ry: number, rz: number): Type3DMatrix;
+declare function scaleMatrix(sx: number, sy: number, sz: number): Type3DMatrix;
+declare function scale(m: Type3DMatrix, sx: number, sy: number, sz: number): Type3DMatrix;
+declare function transform(m: Type3DMatrix, px: number, py: number, pz: number): [number, number, number];
+declare function transformVectorT(m: Type3DMatrix, v: [number, number, number, number]): [number, number, number, number];
+declare function transformVector(m: Type3DMatrix, v: [number, number, number, number]): [number, number, number, number];
+declare function orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Type3DMatrix;
+declare function perspective(fieldOfView: number, aspectRatio: number, near: number, far: number): Type3DMatrix;
+declare function lookAt(cameraPosition: [number, number, number], target: [number, number, number], up: [number, number, number]): Type3DMatrix;
+declare function basisToBasisMatrix(from: [Type3Vector, Type3Vector, Type3Vector], to: [Type3Vector, Type3Vector, Type3Vector]): Type3DMatrix;
+declare function basisMatrix(i: Type3Vector, j: Type3Vector, k: Type3Vector): Type3DMatrix;
+declare function inverse(A: Type3DMatrix): Type3DMatrix;
+declare function dup(A: Type3DMatrix): Type3DMatrix;
+export { mul, identity, transpose, copy, translate, rotate, transform, scale, translationMatrix, scaleMatrix, rotationMatrixX, rotationMatrixY, rotationMatrixZ, basisToBasisMatrix, basisMatrix, rotationMatrixDirection, rotationMatrixXYZ, rotationMatrixAxis, rotationMatrixVectorToVector, rotationMatrixUnitAxis, inverse, orthographic, perspective, lookAt, transformVector, transformVectorT, dup, directionToAxisAngle, vectorToVectorToAxisAngle, };