figureone 0.15.10 → 1.0.0

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

@@ -0,0 +1,623 @@
+import { Point } from './Point';
+import type { Type3DMatrix } from '../m3';
+import type { TypeParsablePoint } from './Point';
+import type { OBJ_TranslationPath } from './Path';
+/**
+ * Orthonormal basis definition. Use either (i, j, k), (x, y, z) or
+ * (right, top, normal). They are identical, but different terminology may
+ * be useful for different contexts.
+ * @property {TypeParsablePoint} [i]
+ * @property {TypeParsablePoint} [j]
+ * @property {TypeParsablePoint} [k]
+ * @property {TypeParsablePoint} [x]
+ * @property {TypeParsablePoint} [y]
+ * @property {TypeParsablePoint} [z]
+ * @property {TypeParsablePoint} [right]
+ * @property {TypeParsablePoint} [top]
+ * @property {TypeParsablePoint} [normal]
+ * @interface
+ * @group Misc Geometry
+ */
+export type TypeBasisObjectDefinition = {
+    i?: TypeParsablePoint;
+    j?: TypeParsablePoint;
+    k?: TypeParsablePoint;
+    x?: TypeParsablePoint;
+    y?: TypeParsablePoint;
+    z?: TypeParsablePoint;
+    right?: TypeParsablePoint;
+    top?: TypeParsablePoint;
+    normal?: TypeParsablePoint;
+};
+/**
+ * Rotation transform component definition. First number is the rotation value
+ * an the next three numbers define the x, y, and z components of the axis
+ * vector.
+ *
+ * `['r', number, number, number, number]`
+ * @group Misc Geometry
+ */
+export type TypeTransformRotation = ['r', number, number, number, number];
+/**
+ * Direction transform component. The numbers are the xyz components of the
+ * vector to direct to.
+ *
+ * This is equivalent to an axis rotation where the axis is the normal
+ * to the plane formed by [1, 0, 0] and `d`
+ *
+ * `['d', number, number, number]`
+ * @group Misc Geometry
+ */
+export type TypeTransformDirection = ['d', number, number, number];
+/**
+ * Translation transform component. The numbers are the xy(z) components of the
+ * translation.
+ *
+ * `['t', number, number, number]`
+ * @group Misc Geometry
+ */
+export type TypeTransformTranslation = ['t', number, number, number];
+/**
+ * Scale transform component. Using just a single number scales xyz components
+ * equally. Using two numbers scales the xy components and sets z to 1. Using
+ * three numbers defines each xyz component.
+ *
+ * `['s', number, number, number] | ['s', number, number] | ['s', number]`
+ * @group Misc Geometry
+ */
+export type TypeTransformScale = ['s', number, number, number];
+/**
+ * Custom transform component defined by a 4x4 matrix.
+ *
+ * `['c', number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]`
+ * @group Misc Geometry
+ */
+export type TypeTransformCustom = ['c', number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+/**
+ * Change of basis transform component definition. This is a change of basis
+ * from the standard basis: i: (1, 0, 0), j: (0, 1, 0), k: (0, 0, 1).
+ *
+ * `['b', number, number, number, number, number, number, number, number, number]`
+ * @group Misc Geometry
+ */
+export type TypeTransformBasis = ['b', number, number, number, number, number, number, number, number, number];
+/**
+ * Change of basis transform component definition relative to a specified
+ * initial basis.
+ *
+ * `['bb', number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]`
+ * @group Misc Geometry
+ */
+export type TypeTransformBasisToBasis = ['bb', number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+/**
+ * Change of basis transform component definition. This is a change of basis
+ * from the standard basis: i: (1, 0, 0), j: (0, 1, 0), k: (0, 0, 1).
+ *
+ * A basis can be defined with either the definition object
+ * {@link TypeBasisObjectDefinition} where only two vectors need to be defined
+ * (the third will be automatically calculated), or with 9 numbers where all
+ * three vectors need to be defined in (ix, iy, iz, jx, jy, jz, kx, ky, kz)
+ * order.
+ *
+ * ` ['b', `{@link TypeBasisObjectDefinition}`] | ` {@link TypeTransformBasis}
+ * @group Misc Geometry
+ */
+export type TypeTransformBasisUserDefinition = ['b', TypeBasisObjectDefinition] | TypeTransformBasis;
+/**
+ * Change of basis transform component definition relative to a specified
+ * initial basis.
+ *
+ * A basis can be defined with either the definition object
+ * {@link TypeBasisObjectDefinition} where only two vectors need to be defined
+ * (the third will be automatically calculated), or with 9 numbers where all
+ * three vectors need to be defined in (ix, iy, iz, jx, jy, jz, kx, ky, kz)
+ * order.
+ *
+ * In either case, the first object or nine numbers define the initial basis
+ * and the second object or nin numbers define the basis to move to.
+ *
+ * ` ['bb', `{@link TypeBasisObjectDefinition}`, `{@link TypeBasisObjectDefinition}`] | ` {@link TypeTransformBasisToBasis}
+ * @group Misc Geometry
+ */
+export type TypeTransformBasisToBasisUserDefinition = ['bb', TypeBasisObjectDefinition, TypeBasisObjectDefinition] | TypeTransformBasisToBasis;
+/**
+ * Transform Component.
+ *
+ * {@link TypeTransformRotation} | {@link TypeTransformDirection} | {@link TypeTransformTranslation} | {@link TypeTransformScale} | {@link TypeTransformCustom} | {@link TypeTransformBasis} | {@link TypeTransformBasisToBasis}
+ * @group Misc Geometry
+*/
+export type TypeTransformComponent = TypeTransformRotation | TypeTransformDirection | TypeTransformTranslation | TypeTransformScale | TypeTransformCustom | TypeTransformBasis | TypeTransformBasisToBasis;
+/**
+ * Transform component defined by a user.
+ *
+ * {@link TypeTransformRotation} | {@link TypeTransformDirection} | {@link TypeTransformTranslation} | {@link TypeTransformScale} | {@link TypeTransformCustom} | {@link TypeTransformBasisUserDefinition} | {@link TypeTransformBasisToBasisUserDefinition}
+ * @group Misc Geometry
+*/
+export type TypeTransformComponentUserDefinition = TypeTransformRotation | TypeTransformDirection | TypeTransformTranslation | TypeTransformScale | TypeTransformCustom | TypeTransformBasisUserDefinition | TypeTransformBasisToBasisUserDefinition | ['r', number] | ['t', number, number] | ['s', number] | ['s', number, number];
+/**
+ * Transform array definition.
+ *
+ *
+ *
+ * `Array<`{@link TypeTransformComponent}`>`
+ * @group Misc Geometry
+ */
+export type TypeTransformDefinition = Array<TypeTransformComponent>;
+/**
+ * Transform array user definition.
+ *
+ * `Array<`{@link TypeTransformComponent}` | `{@link TypeTransformBasisUserDefinition}` | `{@link TypeTransformBasisToBasisUserDefinition}`>`
+ * @group Misc Geometry
+ */
+export type TypeTransformUserDefinition = Array<TypeTransformComponentUserDefinition>;
+/**
+ * Transform state definition of a {@link Transform} that represents an array
+ * of transform components.
+ *
+ * ```
+ * {
+ *   f1Type: 'pl',
+ *   state: TypeTransformDefinition
+ * }
+ * ```
+ * @see {@link TypeTransformDefinition}
+ * @group Misc Geometry
+ */
+export type TypeF1DefTransform = {
+    f1Type: 'tf';
+    state: TypeTransformDefinition;
+};
+export type TypeTransformComponentName = 't' | 's' | 'b' | 'bb' | 'c' | 'd' | 'r';
+/**
+ * A transform is defined with either:
+ * - an instantiated {@link Transform}
+ * - an array of transform components {@link TypeTransformUserDefinition}
+ * - a single transform component {@link TypeTransformComponentUserDefinition}
+ * - a recorder state definition {@link TypeF1DefTransform}
+ * - A string representation of all options except the first
+ *
+ * @example
+ * // t1, t2 and t3 are all equal transforms
+ * const t1 = new Fig.Transform().scale(2).rotate(Math.PI / 2).translate(1, 1);
+ * const t2 = new Fig.Transform([['s', 2], ['r', Math.PI / 2], ['t', 1, 1]]);
+ * const t3 = Fig.getTransform([['s', 2], ['r', Math.PI / 2], ['t', 1, 1]]);
+ *
+ * @see See {@link Transform} for a summary of transfom components available.
+ * @group Geometry
+ */
+export type TypeParsableTransform = TypeTransformUserDefinition | TypeTransformComponentUserDefinition | Transform | TypeF1DefTransform;
+export type TypeTransformValue = number | Array<number> | {
+    scale?: number;
+    position?: number;
+    translation?: number;
+    rotation?: number;
+    custom?: number;
+};
+/**
+ * A Transform is a chain or cascade of transform components, such as rotations
+ * and translations.
+ *
+ * The transform components cascade to form a single 3D transform matrix in
+ * homogenous coordinates - meaning the result is a 4x4 matrix. This matrix can
+ * be used to transform a point in space.
+ *
+ * There are several built in transform components:
+ *
+ * - Translation
+ * - Scale
+ * - Rotation
+ * - Direction transform
+ * - Custom (where a specific matrix can be defined)
+ * - Change of basis from standard basis
+ * - Change of basis from an initial basis
+ *
+ * Matrix multiplication is not commutative, and so chaining transforms is not
+ * commutative. This means the order of components is important.
+ *
+ * For example, if a point (1, 0) is first translated by (1, 0) and then
+ * rotated by π / 2, then it will start at (1, 0), then move to (2, 0), then
+ * rotate to (0, 2).
+ *
+ * In comparison if the same point is first rotated by π / 2 then translated by
+ * (1, 0) it will start at (1, 0), then rotate to (0, 1), then move to (1, 1).
+ *
+ * In this Transform object, the order that components are defined, is the order
+ * the resulting transform will represent.
+ *
+ * A transform can be created by either chaining transform component methods on
+ * an instantiated Transform object, or using an array definition of
+ * components. For example the following two transforms are the same:
+ * ```
+ * const t1 = new Transform().scale(1).translate(1, 0);
+ * const t2 = new Transform([['s', 1], ['t', 1, 0]]);
+ * ```
+ *
+ * @see See {@link TypeParsableTransform} for the different ways to define a transform.
+ * @group Geometry
+ */
+declare class Transform {
+    def: TypeTransformDefinition;
+    mat: Type3DMatrix;
+    translationIndex: number;
+    _type: 'transform';
+    /**
+     * @param {TypeParsableTransform} chain chain of transform components.
+     */
+    constructor(chain?: TypeParsableTransform);
+    _state(options?: {
+        precision: number;
+    }): {
+        f1Type: string;
+        state: TypeTransformDefinition;
+    };
+    /**
+     * Query if transform has a specific component.
+     * @param {TypeTransformComponentName} componentName
+     * @return {boolean} `true` if component name exists
+     */
+    hasComponent(componentName: TypeTransformComponentName): boolean;
+    /**
+     * Set a component at a speicific index of the transform definition.
+     *
+     * @param {number} index index to set component
+     * @param {TypeTransformComponent} def component definition
+     *
+     * @return {Transform} this transform
+     */
+    setComponent(index: number, def: TypeTransformComponent): this;
+    /**
+     * Add a transform component to the chain
+     *
+     * @param {TypeTransformComponent} def component definition
+     * @return {Transform} this transform
+     */
+    addComponent(def: TypeTransformComponent): this;
+    /**
+     * Return a duplicate transform with an added translation component.
+     *
+     * The translation can either be defined as:
+     *
+     * * A point
+     * * x, y values (z will be automatically set to 0)
+     * * x, y, and z values
+     *
+     * @param {number | TypeParsablePoint} xOrTranslation
+     * @param {number} y
+     * @param {number} z
+     *
+     * @return {Transform}
+     */
+    translate(xOrTranslation?: number | TypeParsablePoint, y?: number, z?: number): this;
+    /**
+     * Return a duplicate transform with an added rotation component.
+     * @param {number} rotation
+     * @param {number | TypeParsablePoint | 'x' | 'y' | 'z'} axisOrX (`z`)
+     * @param {number} y (`0`)
+     * @param {number} z (`0`)
+     * @return {Transform}
+     */
+    rotate(rotation: number, axisOrX?: number | TypeParsablePoint | 'x' | 'y' | 'z', y?: number, z?: number): this;
+    /**
+     * Return a duplicate transform with an added direction transform component.
+     *
+     * @param {number | TypeParsablePoint} xOrDirection
+     * @param {number} y
+     * @param {number} z
+     * @return {Transform}
+     */
+    direction(xOrDirection: number | TypeParsablePoint, y?: number, z?: number): this;
+    /**
+     * Return a duplicate transform with an added change of basis from the
+     * standard basis transform component.
+     *
+     * @param {TypeBasisObjectDefinition} toBasis
+     * @return {Transform}
+     */
+    basis(toBasis: TypeBasisObjectDefinition): this;
+    /**
+     * Return a duplicate transform with an added change of basis transform
+     * component.
+     *
+     * @param {TypeBasisObjectDefinition} fromeBasis
+     * @param {TypeBasisObjectDefinition} toBasis
+     * @return {Transform}
+     */
+    basisToBasis(fromBasis: TypeBasisObjectDefinition, toBasis: TypeBasisObjectDefinition): this;
+    /**
+     * Return a duplicate transform with an added custom transform
+     * component.
+     *
+     * @param {Type3DMatrix} matrix
+     * @return {Transform}
+     */
+    custom(matrix: Type3DMatrix): this;
+    /**
+     * Return a duplicate transform with an added scale transform component
+     * @param {number | TypeParsablePoint} sOrSxOrPoint
+     * @param {number} sy
+     * @param {number} sz
+     * @return {Transform}
+     */
+    scale(sOrSxOrPoint: number | TypeParsablePoint, sy?: number | null, sz?: number): this;
+    calcMatrix(defStart?: number, defEnd?: number): Type3DMatrix;
+    calcAndSetMatrix(): void;
+    /**
+     * Get the nth transform component index of `type`.
+     * @param {TypeTransformComponentName} type
+     * @param {number} n (`0`)
+     * @return {number} index of component
+     */
+    getComponentIndex(type: TypeTransformComponentName | Array<TypeTransformComponentName>, n?: number): number;
+    /**
+     * Clip all rotation (2D, axis, x, y, z rotations) transform components
+     * within this transform chain angles between 0º-360º, -180º-180º, or not at
+     * all (`null`)
+     *
+     * Only angle values are clipped. The axis values of the axis rotation is not
+     * changed.
+     *
+     * @param {'0to360' | '-180to180' | null} clipTo
+     */
+    clipRotation(clipTo: '0to360' | '-180to180' | null): void;
+    /**
+     * Update the nth translation transform component with a new translation.
+     * @param {TypeParsablePoint} translation
+     * @param {number} n
+     * @return {Transform}
+     */
+    updateTranslation(translation: TypeParsablePoint, n?: number): this;
+    updateComponent(def: TypeTransformComponent, n: number): this;
+    /**
+     * Return a linearly interpolated transform between this transform and
+     * `delta` at some `percent` between the two.
+     *
+     * For translation transform components, interpolation can either be
+     * `'linear'` or '`curved'`.
+     * @param {Transform} delta delta transform
+     * @param {number} percent percent to interpolate where 0 is this transform
+     * and 1 is delta transform
+     * @param {'linear' | 'curved' | 'curve' = 'linear'} translationStyle
+     * translation style for translation components only
+     * @param {OBJ_TranslationPath = {}} translationOptions
+     * translation options for translation components only
+     * @return {Transform}
+     */
+    toDelta(delta: Transform, percent: number, translationStyle?: 'linear' | 'curved' | 'curve', translationOptions?: OBJ_TranslationPath): Transform;
+    /**
+     * Retrieve the nth translation transform component.
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    t(n?: number): Point | null;
+    /**
+     * Retrieve the nth scale transform component.
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    s(n?: number): Point | null;
+    /**
+     * Retrieve the nth rotation transform component rotation value.
+     *
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    r(n?: number): number;
+    /**
+     * Retrieve the nth rotation transform component axis.
+     *
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    ra(n?: number): Point;
+    /**
+     * Retrieve the nth direction transform component.
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    d(n?: number): (number | "r")[] | (number | "d")[] | (number | "t")[] | (number | "s")[] | (number | "c")[] | (number | "b")[] | (number | "bb")[];
+    /**
+     * Retrieve the nth custom transform component.
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    c(n?: number): (number | "r")[] | (number | "d")[] | (number | "t")[] | (number | "s")[] | (number | "c")[] | (number | "b")[] | (number | "bb")[];
+    /**
+     * Retrieve the nth change of basis from standard basis transform component.
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    b(n?: number): (number | "r")[] | (number | "d")[] | (number | "t")[] | (number | "s")[] | (number | "c")[] | (number | "b")[] | (number | "bb")[];
+    /**
+     * Retrieve the nth change of basis transform component.
+     * @param {number} n (`0`)
+     * @return {Point}
+     */
+    bb(n?: number): (number | "r")[] | (number | "d")[] | (number | "t")[] | (number | "s")[] | (number | "c")[] | (number | "b")[] | (number | "bb")[];
+    /**
+     * Update the nth scale transform component with a new scale.
+     * @param {TypeParsablePoint} scale
+     * @param {number} n
+     * @return {Transform}
+     */
+    updateScale(scale: number | TypeParsablePoint, n?: number): this;
+    /**
+     * Update the nth rotation transform component.
+     * @param {number} r
+     * @param {TypeParsablePoint} axis
+     * @param {number} n
+     * @return {Transform}
+     */
+    updateRotation(r: number, axis?: TypeParsablePoint | null, n?: number): this;
+    /**
+     * Update the nth direction transform component.
+     * @param {number} d
+     * @param {number} n
+     * @return {Transform}
+     */
+    updateDirection(d: TypeParsablePoint, n?: number): this;
+    /**
+     * Update the nth custom transform component.
+     * @param {Type3DMatrix} c
+     * @param {number} n
+     * @return {Transform}
+     */
+    updateCustom(c: Type3DMatrix, n?: number): this;
+    /**
+     * Update the nth change of basis from the standard basis transform component.
+     * @param {TypeBasisObjectDefinition} b
+     * @param {number} n
+     * @return {Transform}
+     */
+    updateBasis(b: TypeBasisObjectDefinition, n?: number): this;
+    /**
+     * Update the nth change of basis transform component.
+     * @param {TypeBasisObjectDefinition} fromBasis
+     * @param {TypeBasisObjectDefinition} toBasis
+     * @param {number} n
+     * @return {Transform}
+     */
+    updateBasisToBasis(fromBasis: TypeBasisObjectDefinition, toBasis: TypeBasisObjectDefinition, n?: number): this;
+    /**
+     * Return the matrix that respresents the cascaded transform chain
+     * @return {Type3DMatrix}
+     */
+    m(): Type3DMatrix;
+    /**
+     * Return the matrix that respresents the cascaded transform chain
+     * @param {number | null} precision round the matrix to some precision or
+     * `null` for no rounding (`null`)
+     * @return {Type3DMatrix}
+     */
+    matrix(precision?: number | null): Type3DMatrix;
+    /**
+     * `true` if `transformToCompare` has the same order of transform components.
+     * @param {TypeParsableTransform} transformToCompare
+     * @return {boolean}
+     */
+    isEqualShapeTo(transformToCompare: TypeParsableTransform): boolean;
+    /**
+     * `true` if `transformToCompare` is equal to this transform within some
+     * `precision`.
+     * @param {TypeParsableTransform} transformToCompare
+     * @return {boolean}
+     */
+    isEqualTo(transformToCompare: TypeParsableTransform, precision?: number): boolean;
+    /**
+     * `true` if `transformToCompare` is wihtin some `delta` of this transform.
+     * `isEqualTo` rounds the values to some precision to compare values. In
+     * comparison this will directly compare the delta between values. This may
+     * be more useful than rounding when values are close to rounding thresholds.
+     * @param {TypeParsableTransform} transformToCompare
+     * @return {boolean}
+     */
+    isWithinDelta(transformToCompare: TypeParsableTransform, delta?: number): boolean;
+    /**
+     * Subtract each corresponding transform component. Both transforms must
+     * have the same shape.
+     *
+     * @param {TypeParsableTransform} transformToSubtract
+     * @see <a href="#transformisequalshapeto">Transform.isEqualShapeTo</a>
+     */
+    sub(transformToSubtract?: TypeParsableTransform): Transform;
+    /**
+     * Subtract each corresponding transform component. Both transforms must
+     * have the same shape.
+     *
+     * @param {TypeParsableTransform} transformToAdd
+     * @see <a href="#transformisequalshapeto">Transform.isEqualShapeTo</a>
+     */
+    add(transformToAdd?: TypeParsableTransform): Transform;
+    /**
+     * Multiply each corresponding transform component. Both transforms must
+     * have the same shape.
+     *
+     * @param {TypeParsableTransform} transformToMultiply
+     * @see <a href="#transformisequalshapeto">Transform.isEqualShapeTo</a>
+     */
+    mul(transformToMultiply?: TypeParsableTransform): Transform;
+    /**
+     * Cascade two transforms together such that this transform transforms
+     * the input transform. In other words, the transform components of the
+     * input transform will performed first before this transform.
+     *
+     * @param {TypeParsableTransform} transform
+     * @return {Transform}
+     */
+    transform(transform: TypeParsableTransform): Transform;
+    /**
+     * Cascade two transforms together such that this transform is transformed
+     * by the input transform. In other words, the this transform's components
+     * of will performed first before the input transform transform.
+     *
+     * @param {TypeParsableTransform} transform
+     * @return {Transform}
+     */
+    transformBy(transform: TypeParsableTransform): Transform;
+    /**
+     * Return a duplicate transform with all values rounded to some precision.
+     *
+     * @param {number} precision (`8`)
+     * @return Transform
+     */
+    round(precision?: number): Transform;
+    clipMag(zeroThresholdTransform: TypeTransformValue, maxTransform: TypeTransformValue, vector?: boolean): Transform;
+    constant(constant?: number): Transform;
+    zero(): Transform;
+    /**
+     * `true` if all transforms within the transform chain are below the
+     * `zeroThreshold`
+     *
+     * @param {number} zeroThreshold (`0`)
+     * @return {boolean}
+     */
+    isZero(zeroThreshold?: number): boolean;
+    /**
+     * Return a duplicate transform.
+     * @return {Transform}
+     */
+    _dup(): Transform;
+    velocity(previousTransform: Transform, deltaTime: number, zeroThreshold: TypeTransformValue, maxTransform: TypeTransformValue): Transform;
+    /**
+     * Return a duplicate transform chain where all transform components are
+     * the same component type but with identity values.
+     * @return {Transform}
+     */
+    identity(): Transform;
+}
+/**
+ * Test if a value can be parsed to create a transform.
+ *
+ * @see {@link TypeParsableTransform}
+ * @param {any} value
+ * @return {boolean}
+ * @group Misc Geometry
+ */
+declare function isParsableTransform(value: any): boolean;
+declare function getMatrix(matrixOrTransform: TypeParsableTransform | Type3DMatrix): Type3DMatrix;
+/**
+ * Convert a parsable transform definition to a Transform.
+ * @param {TypeParsableTransform} t
+ * @return {Transform}
+ * @group Misc Geometry
+ */
+declare function getTransform(t: TypeParsableTransform): Transform;
+declare function transformValueToArray(transformValue: TypeTransformValue, transform: Transform): Array<number>;
+declare function directionToAxisAngle(direction: TypeParsablePoint | TypeTransformDirection, axisIfCollinear?: TypeParsablePoint): {
+    angle: number;
+    axis: Point;
+};
+/**
+ * Calculate the rotation axis and angle required to move from one
+ * vector to another.
+ *
+ * @param {TypeParsablePoint} fromVector
+ * @param {TypeParsablePoint} toVector
+ * @param {TypeParsablePoint | null} axisIfCollinear
+ * @return {{axis: Point, angle: number}}
+ * @group Misc Geometry
+ */
+declare function angleFromVectors(fromVector: TypeParsablePoint | TypeTransformDirection, toVector: TypeParsablePoint | TypeTransformDirection, axisIfCollinear?: TypeParsablePoint | null): {
+    angle: number;
+    axis: Point;
+};
+export { getTransform, Transform, isParsableTransform, transformValueToArray, getMatrix, angleFromVectors, directionToAxisAngle, };