ranuts 0.1.0-alpha.11 → 0.1.0-alpha.13

package/dist/src/utils/totp/sha/sha.d.ts

@@ -0,0 +1,103 @@
+import type { CSHAKEOptionsEncodingType, CSHAKEOptionsNoEncodingType, EncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, KMACOptionsEncodingType, KMACOptionsNoEncodingType, SHAKEOptionsEncodingType, SHAKEOptionsNoEncodingType } from './custom_types';
+type FixedLengthVariantType = 'SHA-1' | 'SHA-224' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512';
+export default class jsSHA {
+    private readonly shaObj;
+    /**
+     * @param variant The desired SHA variant (SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA3-224, SHA3-256, SHA3-256,
+     *   SHA3-384, SHA3-512, SHAKE128, SHAKE256, CSHAKE128, CSHAKE256, KMAC128, or KMAC256) as a string.
+     * @param inputFormat The input format to be used in future `update` calls (TEXT, HEX, B64, BYTES, ARRAYBUFFER,
+     *   or UINT8ARRAY) as a string.
+     * @param options Options in the form of { encoding?: "UTF8" | "UTF16BE" | "UTF16LE"; numRounds?: number }.
+     *   `encoding` is for only TEXT input (defaults to UTF8) and `numRounds` defaults to 1.
+     *   `numRounds` is not valid for any of the MAC or CSHAKE variants.
+     *   * If the variant supports HMAC, `options` may have an additional `hmacKey` key which must be in the form of
+     *     {value: <INPUT>, format: <FORMAT>, encoding?: "UTF8" | "UTF16BE" | "UTF16LE"} where <FORMAT> takes the same
+     *     values as `inputFormat` and <INPUT> can be a `string | ArrayBuffer | Uint8Array` depending on <FORMAT>.
+     *     Supplying this key switches to HMAC calculation and replaces the now deprecated call to `setHMACKey`.
+     *   * If the variant is CSHAKE128 or CSHAKE256, `options` may have two additional keys, `customization` and `funcName`,
+     *     which are the NIST customization and function-name strings.  Both must be in the same form as `hmacKey`.
+     *   * If the variant is KMAC128 or KMAC256, `options` can include the `customization` key from CSHAKE variants and
+     *     *must* have a `kmacKey` key that takes the same form as the `customization` key.
+     */
+    constructor(variant: FixedLengthVariantType, inputFormat: 'TEXT', options?: FixedLengthOptionsEncodingType);
+    constructor(variant: FixedLengthVariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    constructor(variant: 'SHAKE128' | 'SHAKE256', inputFormat: 'TEXT', options?: SHAKEOptionsEncodingType);
+    constructor(variant: 'SHAKE128' | 'SHAKE256', inputFormat: FormatNoTextType, options?: SHAKEOptionsNoEncodingType);
+    constructor(variant: 'CSHAKE128' | 'CSHAKE256', inputFormat: 'TEXT', options?: CSHAKEOptionsEncodingType);
+    constructor(variant: 'CSHAKE128' | 'CSHAKE256', inputFormat: FormatNoTextType, options?: CSHAKEOptionsNoEncodingType);
+    constructor(variant: 'KMAC128' | 'KMAC256', inputFormat: 'TEXT', options: KMACOptionsEncodingType);
+    constructor(variant: 'KMAC128' | 'KMAC256', inputFormat: FormatNoTextType, options: KMACOptionsNoEncodingType);
+    /**
+     * Takes `input` and hashes as many blocks as possible. Stores the rest for either a future `update` or `getHash` call.
+     *
+     * @param input The input to be hashed.
+     * @returns A reference to the object.
+     */
+    update(input: string | ArrayBuffer | Uint8Array): this;
+    /**
+     * Returns the desired SHA or MAC (if a HMAC/KMAC key was specified) hash of the input fed in via `update` calls.
+     *
+     * @param format The desired output formatting (B64, HEX, BYTES, ARRAYBUFFER, or UINT8ARRAY) as a string.
+     * @param options Options in the form of { outputUpper?: boolean; b64Pad?: string; outputLen?: number;  }.
+     *   `outputLen` is required for variable length output variants (this option was previously called `shakeLen` which
+     *    is now deprecated).
+     *   `outputUpper` is only for HEX output (defaults to false) and b64pad is only for B64 output (defaults to "=").
+     * @returns The hash in the format specified.
+     */
+    getHash(format: 'HEX', options?: {
+        outputUpper?: boolean;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: 'B64', options?: {
+        b64Pad?: string;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: 'BYTES', options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: 'UINT8ARRAY', options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): Uint8Array;
+    getHash(format: 'ARRAYBUFFER', options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): ArrayBuffer;
+    /**
+     * Sets the HMAC key for an eventual `getHMAC` call.  Must be called immediately after jsSHA object instantiation.
+     * Now deprecated in favor of setting the `hmacKey` at object instantiation.
+     *
+     * @param key The key used to calculate the HMAC
+     * @param inputFormat The format of key (HEX, TEXT, B64, BYTES, ARRAYBUFFER, or UINT8ARRAY) as a string.
+     * @param options Options in the form of { encoding?: "UTF8" | "UTF16BE" | "UTF16LE }.  `encoding` is only for TEXT
+     *   and defaults to UTF8.
+     */
+    setHMACKey(key: string, inputFormat: 'TEXT', options?: {
+        encoding?: EncodingType;
+    }): void;
+    setHMACKey(key: string, inputFormat: 'B64' | 'HEX' | 'BYTES'): void;
+    setHMACKey(key: ArrayBuffer, inputFormat: 'ARRAYBUFFER'): void;
+    setHMACKey(key: Uint8Array, inputFormat: 'UINT8ARRAY'): void;
+    /**
+     * Returns the the HMAC in the specified format using the key given by a previous `setHMACKey` call. Now deprecated
+     * in favor of just calling `getHash`.
+     *
+     * @param format The desired output formatting (B64, HEX, BYTES, ARRAYBUFFER, or UINT8ARRAY) as a string.
+     * @param options Options in the form of { outputUpper?: boolean; b64Pad?: string }. `outputUpper` is only for HEX
+     *   output (defaults to false) and `b64pad` is only for B64 output (defaults to "=").
+     * @returns The HMAC in the format specified.
+     */
+    getHMAC(format: 'HEX', options?: {
+        outputUpper?: boolean;
+    }): string;
+    getHMAC(format: 'B64', options?: {
+        b64Pad?: string;
+    }): string;
+    getHMAC(format: 'BYTES'): string;
+    getHMAC(format: 'UINT8ARRAY'): Uint8Array;
+    getHMAC(format: 'ARRAYBUFFER'): ArrayBuffer;
+}
+export {};

package/dist/src/utils/totp/sha/sha1.d.ts

@@ -0,0 +1,18 @@
+import { jsSHABase } from './common';
+import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from './custom_types';
+export default class jsSHA extends jsSHABase<number[], 'SHA-1'> {
+    intermediateState: number[];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: number[]) => number[];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: number[]) => number[];
+    stateCloneFunc: (state: number[]) => number[];
+    newStateFunc: (variant: 'SHA-1') => number[];
+    getMAC: () => number[];
+    constructor(variant: 'SHA-1', inputFormat: 'TEXT', options?: FixedLengthOptionsEncodingType);
+    constructor(variant: 'SHA-1', inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+}

package/dist/src/utils/totp/sha/sha256.d.ts

@@ -0,0 +1,20 @@
+import { jsSHABase } from './common';
+import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from './custom_types';
+type VariantType = 'SHA-224' | 'SHA-256';
+export default class jsSHA extends jsSHABase<number[], VariantType> {
+    intermediateState: number[];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: number[]) => number[];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: number[]) => number[];
+    stateCloneFunc: (state: number[]) => number[];
+    newStateFunc: (variant: VariantType) => number[];
+    getMAC: () => number[];
+    constructor(variant: VariantType, inputFormat: 'TEXT', options?: FixedLengthOptionsEncodingType);
+    constructor(variant: VariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+}
+export {};

package/dist/src/utils/totp/sha/sha3.d.ts

@@ -0,0 +1,53 @@
+import { jsSHABase } from './common';
+import type { CSHAKEOptionsEncodingType, CSHAKEOptionsNoEncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, KMACOptionsEncodingType, KMACOptionsNoEncodingType, SHAKEOptionsEncodingType, SHAKEOptionsNoEncodingType, packedValue } from './custom_types';
+import { Int_64 } from './primitives_64';
+type FixedLengthVariantType = 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512' | 'SHAKE128' | 'SHAKE256';
+type VariantType = FixedLengthVariantType | 'SHAKE128' | 'SHAKE256' | 'CSHAKE128' | 'CSHAKE256' | 'KMAC128' | 'KMAC256';
+export default class jsSHA extends jsSHABase<Int_64[][], VariantType> {
+    intermediateState: Int_64[][];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: Int_64[][]) => Int_64[][];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: Int_64[][], outputLen: number) => number[];
+    stateCloneFunc: (state: Int_64[][]) => Int_64[][];
+    newStateFunc: (variant: VariantType) => Int_64[][];
+    getMAC: ((options: {
+        outputLen: number;
+    }) => number[]) | null;
+    constructor(variant: FixedLengthVariantType, inputFormat: 'TEXT', options?: FixedLengthOptionsEncodingType);
+    constructor(variant: FixedLengthVariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    constructor(variant: 'SHAKE128' | 'SHAKE256', inputFormat: 'TEXT', options?: SHAKEOptionsEncodingType);
+    constructor(variant: 'SHAKE128' | 'SHAKE256', inputFormat: FormatNoTextType, options?: SHAKEOptionsNoEncodingType);
+    constructor(variant: 'CSHAKE128' | 'CSHAKE256', inputFormat: 'TEXT', options?: CSHAKEOptionsEncodingType);
+    constructor(variant: 'CSHAKE128' | 'CSHAKE256', inputFormat: FormatNoTextType, options?: CSHAKEOptionsNoEncodingType);
+    constructor(variant: 'KMAC128' | 'KMAC256', inputFormat: 'TEXT', options: KMACOptionsEncodingType);
+    constructor(variant: 'KMAC128' | 'KMAC256', inputFormat: FormatNoTextType, options: KMACOptionsNoEncodingType);
+    /**
+     * Initialize CSHAKE variants.
+     *
+     * @param options Options containing CSHAKE params.
+     * @param funcNameOverride Overrides any "funcName" present in `options` (used with KMAC)
+     * @returns The delimiter to be used
+     */
+    protected _initializeCSHAKE(options?: CSHAKEOptionsNoEncodingType, funcNameOverride?: packedValue): number;
+    /**
+     * Initialize KMAC variants.
+     *
+     * @param options Options containing KMAC params.
+     */
+    protected _initializeKMAC(options: KMACOptionsNoEncodingType): void;
+    /**
+     * Returns the the KMAC in the specified format.
+     *
+     * @param options Hashmap of extra outputs options. `outputLen` must be specified.
+     * @returns The KMAC in the format specified.
+     */
+    protected _getKMAC(options: {
+        outputLen: number;
+    }): number[];
+}
+export {};

package/dist/src/utils/totp/sha/sha512.d.ts

@@ -0,0 +1,21 @@
+import { jsSHABase } from './common';
+import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from './custom_types';
+import { Int_64 } from './primitives_64';
+type VariantType = 'SHA-384' | 'SHA-512';
+export default class jsSHA extends jsSHABase<Int_64[], VariantType> {
+    intermediateState: Int_64[];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: Int_64[]) => Int_64[];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: Int_64[]) => number[];
+    stateCloneFunc: (state: Int_64[]) => Int_64[];
+    newStateFunc: (variant: VariantType) => Int_64[];
+    getMAC: () => number[];
+    constructor(variant: VariantType, inputFormat: 'TEXT', options?: FixedLengthOptionsEncodingType);
+    constructor(variant: VariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+}
+export {};

package/dist/src/utils/totp/totp.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @param {string} [digits=6]
+ * @param {string} [algorithm="SHA-1"]
+ * @param {string} [period=30]
+ * @param {string} [timestamp=Date.now()]
+ */
+type Options = {
+    digits?: number;
+    algorithm?: 'SHA-1' | 'SHA-224' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512';
+    period?: number;
+    timestamp?: number;
+};
+export declare class TOTP {
+    static generate(key: string, options?: Options): {
+        otp: string;
+        expires: number;
+    };
+    private static hex2dec;
+    private static dec2hex;
+    private static base32tohex;
+    private static leftpad;
+}
+export {};

package/dist/src/utils/visual/application.d.ts

@@ -0,0 +1,10 @@
+import { Container } from '@/utils/visual/vertex/container';
+import type { IApplicationOptions } from '@/utils/visual/types';
+export declare class Application {
+    private renderer;
+    stage: Container;
+    view: HTMLCanvasElement;
+    constructor(options: IApplicationOptions);
+    private render;
+    private start;
+}

package/dist/src/utils/visual/demo/index.d.ts

@@ -0,0 +1 @@
+export * from '@/utils/visual/demo/sankey';

package/dist/src/utils/visual/demo/sankey.d.ts

@@ -0,0 +1,2 @@
+export declare class Sankey {
+}

package/dist/src/utils/visual/enums.d.ts

@@ -0,0 +1,21 @@
+export declare enum ShapeType {
+    Rectangle = "rectangle",
+    Polygon = "polygon",
+    Circle = "circle",
+    Ellipse = "ellipse",
+    RoundedRectangle = "rounded rectangle"
+}
+export declare enum LineCap {
+    Butt = "butt",
+    Round = "round",
+    Square = "square"
+}
+export declare enum LineJoin {
+    Miter = "miter",
+    Bevel = "bevel",
+    Round = "round"
+}
+export declare enum RendererType {
+    WebGl = "webgl",
+    Canvas = "canvas"
+}

package/dist/src/utils/visual/event/boundary.d.ts

@@ -0,0 +1,22 @@
+import type { Container } from '@/utils/visual/vertex/container';
+import type { Cursor, FederatedMouseEvent } from '@/utils/visual/event/types';
+export declare class EventBoundary {
+    private rootContainer;
+    private hasFoundTarget;
+    private hitTarget;
+    cursor: Cursor;
+    private eventHandlerMap;
+    private pressTargetsMap;
+    overTargets: Container[];
+    constructor(stage: Container);
+    private hitTestRecursive;
+    private hitTest;
+    fireEvent: (event: FederatedMouseEvent) => void;
+    private fireMouseMove;
+    private fireMouseDown;
+    private fireMouseUp;
+    private notifyTarget;
+    private propagate;
+    private dispatchEvent;
+    private composePath;
+}

package/dist/src/utils/visual/event/event.d.ts

@@ -0,0 +1,14 @@
+import type { Container } from '@/utils/visual/vertex/container';
+export declare class EventSystem {
+    private canvasEle;
+    private eventBoundary;
+    private rootEvent;
+    constructor(canvasEle: HTMLCanvasElement, stage: Container);
+    private addEvents;
+    private onPointerMove;
+    private onPointerLeave;
+    private onPointerDown;
+    private onPointerup;
+    private bootstrapEvent;
+    private setCursor;
+}

package/dist/src/utils/visual/event/index.d.ts

@@ -0,0 +1,3 @@
+export * from '@/utils/visual/event/boundary';
+export * from '@/utils/visual/event/event';
+export * from '@/utils/visual/event/types';

package/dist/src/utils/visual/event/types.d.ts

@@ -0,0 +1,32 @@
+import { Point } from '@/utils/visual/vertex/point';
+import { Container } from '@/utils/visual/vertex/container';
+export declare enum EventPhase {
+    NONE = 0,
+    CAPTURING = 1,
+    AT_TARGET = 2,
+    BUBBLING = 3
+}
+export declare class FederatedMouseEvent {
+    isTrusted: boolean;
+    timeStamp: number;
+    type: keyof FederatedEventMap;
+    button: number;
+    buttons: number;
+    global: Point;
+    propagationStopped: boolean;
+    eventPhase: EventPhase;
+    target: Container;
+    currentTarget: Container;
+    stopPropagation(): void;
+}
+export type FederatedEventMap = {
+    mousedown: FederatedMouseEvent;
+    mouseup: FederatedMouseEvent;
+    click: FederatedMouseEvent;
+    mouseenter: FederatedMouseEvent;
+    mouseleave: FederatedMouseEvent;
+    mousemove: FederatedMouseEvent;
+    mouseout: FederatedMouseEvent;
+    mouseover: FederatedMouseEvent;
+};
+export type Cursor = 'auto' | 'default' | 'none' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ns-resize' | 'ew-resize' | 'nesw-resize' | 'col-resize' | 'nwse-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'grab' | 'grabbing';

package/dist/src/utils/visual/graphics/graphics.d.ts

@@ -0,0 +1,19 @@
+import { Container } from "@/utils/visual/vertex/container";
+import { Polygon } from "@/utils/visual/shape/polygon";
+import type { Shape } from "@/utils/visual/shape/shape";
+import type { CanvasRenderer } from '@/utils/visual/render/canvasRenderer';
+export declare class Graphics extends Container {
+    private _lineStyle;
+    private _fillStyle;
+    private _geometry;
+    currentPath: Polygon | null;
+    constructor();
+    protected drawShape(shape: Shape): Graphics;
+    /**
+   * 清空已有的 path，开始新的 path
+   */
+    protected startPoly(): void;
+    beginFill(color?: string, alpha?: number): Graphics;
+    drawRect(x: number, y: number, width: number, height: number): Graphics;
+    protected renderCanvas(render: CanvasRenderer): void;
+}

package/dist/src/utils/visual/graphics/graphicsData.d.ts

@@ -0,0 +1,10 @@
+import type { Shape } from "@/utils/visual/shape/shape";
+import type { Fill } from "@/utils/visual/style/fill";
+import type { Line } from "@/utils/visual/style/line";
+export declare class GraphicsData {
+    shape: Shape;
+    lineStyle: Line;
+    fillStyle: Fill;
+    points: number[];
+    constructor(shape: Shape, fillStyle: Fill, lineStyle: Line);
+}

package/dist/src/utils/visual/graphics/graphicsGeometry.d.ts

@@ -0,0 +1,10 @@
+import type { Shape } from "@/utils/visual/shape/shape";
+import type { Fill } from "@/utils/visual/style/fill";
+import type { Line } from "@/utils/visual/style/line";
+import { GraphicsData } from '@/utils/visual/graphics/graphicsData';
+export declare class GraphicsGeometry {
+    graphicsData: GraphicsData[];
+    constructor();
+    drawShape(shape: Shape, fillStyle: Fill, lineStyle: Line): void;
+    clear(): void;
+}

package/dist/src/utils/visual/graphics/index.d.ts

@@ -0,0 +1,3 @@
+export * from '@/utils/visual/graphics/graphics';
+export * from '@/utils/visual/graphics/graphicsData';
+export * from '@/utils/visual/graphics/graphicsGeometry';

package/dist/src/utils/visual/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@/utils/visual/application';
+export * from '@/utils/visual/vertex/container';
+export * from '@/utils/visual/graphics/graphics';
+export * from '@/utils/visual/enums';

package/dist/src/utils/visual/math/bezier.d.ts

@@ -0,0 +1,2 @@
+export declare const getBezierLength: (P0X: number, P0Y: number, P1X: number, P1Y: number, P2X: number, P2Y: number, P3X: number, P3Y: number) => number;
+export declare const getQuadraticBezierLength: (P0X: number, P0Y: number, P1X: number, P1Y: number, P2X: number, P2Y: number) => number;

package/dist/src/utils/visual/math/enums.d.ts

@@ -0,0 +1,2 @@
+export declare const DEG_TO_RAD: number;
+export declare const RAD_TO_DEG: number;

package/dist/src/utils/visual/math/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@/utils/visual/math/bezier';
+export * from '@/utils/visual/math/enums';
+export * from '@/utils/visual/math/matrix';
+export * from '@/utils/visual/math/transform';

package/dist/src/utils/visual/math/matrix.d.ts

@@ -0,0 +1,32 @@
+import { Point } from '@/utils/visual/vertex/point';
+export declare class Matrix {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    tx: number;
+    ty: number;
+    constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+    set(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix;
+    /**
+     * 将当前矩阵右乘一个矩阵
+     */
+    append(m: Matrix): Matrix;
+    /**
+     * 对某个点应用当前的变换矩阵
+     * @param p 某个点
+     * @returns {Point} 点 p 应用当前变换矩阵后得到的一个新的点
+     */
+    apply(p: Point): Point;
+    /**
+     * 对某个点应用当前的变换矩阵的逆矩阵
+     * @param p 某个点
+     * @returns {Point} 点 p 应用当前变换矩阵的逆矩阵后得到的一个新的点
+     */
+    applyInverse(p: Point): Point;
+    /**
+     * 将当前矩阵左乘一个矩阵
+     */
+    prepend(m: Matrix): Matrix;
+    clone(): Matrix;
+}

package/dist/src/utils/visual/math/transform.d.ts

@@ -0,0 +1,27 @@
+import { Matrix } from '@/utils/visual/math/matrix';
+import { ObservablePoint } from '@/utils/visual/vertex/point';
+export declare class Transform {
+    localTransform: Matrix;
+    worldTransform: Matrix;
+    position: ObservablePoint;
+    scale: ObservablePoint;
+    pivot: ObservablePoint;
+    skew: ObservablePoint;
+    _rotation: number;
+    private transformMatrix;
+    shouldUpdateLocalTransform: boolean;
+    shouldUpdateWorldTransform: boolean;
+    constructor();
+    get rotation(): number;
+    set rotation(r: number);
+    private onChange;
+    /**
+     * 更新 localTransform
+     */
+    private updateLocalTransform;
+    /**
+     * @returns {boolean} true 说明 worldTransform 发生了改变，false 说明 worldTransform 没有发生改变
+     */
+    updateTransform(parentTransform: Transform): boolean;
+    setFromMatrix(matrix: Matrix): void;
+}

package/dist/src/utils/visual/render/canvasRenderer.d.ts

@@ -0,0 +1,9 @@
+import { Renderer } from '@/utils/visual/render/render';
+import type { IApplicationOptions } from '@/utils/visual/types';
+import type { Container } from '@/utils/visual/vertex/container';
+export declare class CanvasRenderer extends Renderer {
+    ctx: CanvasRenderingContext2D;
+    private background;
+    constructor(options: IApplicationOptions);
+    render(container: Container): void;
+}

package/dist/src/utils/visual/render/index.d.ts

@@ -0,0 +1,3 @@
+import type { Renderer } from '@/utils/visual/render/render';
+import type { IApplicationOptions } from '@/utils/visual/types';
+export declare const getRenderer: (options: IApplicationOptions) => Renderer;

package/dist/src/utils/visual/render/render.d.ts

@@ -0,0 +1,10 @@
+import type { Container } from '@/utils/visual/vertex/container';
+import { Rectangle } from '@/utils/visual/shape/rectangle';
+import type { IApplicationOptions } from '@/utils/visual/types';
+export declare class Renderer {
+    canvasEle: HTMLCanvasElement;
+    screen: Rectangle;
+    constructor(options: IApplicationOptions);
+    resizeView(width: number, height: number): void;
+    render(container: Container): void;
+}

package/dist/src/utils/visual/render/webGlRenderer.d.ts

@@ -0,0 +1,7 @@
+import { Renderer } from '@/utils/visual/render/render';
+import type { IApplicationOptions } from '@/utils/visual/types';
+import type { Container } from '@/utils/visual/vertex/container';
+export declare class WebGlRenderer extends Renderer {
+    constructor(options: IApplicationOptions);
+    render(container: Container): void;
+}

package/dist/src/utils/visual/shape/circle.d.ts

@@ -0,0 +1,11 @@
+import { Shape } from '@/utils/visual/shape/shape';
+import { ShapeType } from '@/utils/visual/enums';
+import type { Point } from '@/utils/visual/vertex/point';
+export declare class Circle extends Shape {
+    x: number;
+    y: number;
+    radius: number;
+    readonly type = ShapeType.Circle;
+    constructor(x?: number, y?: number, radius?: number);
+    contains(point: Point): boolean;
+}

package/dist/src/utils/visual/shape/ellipse.d.ts

@@ -0,0 +1,12 @@
+import { Shape } from '@/utils/visual/shape/shape';
+import { ShapeType } from '@/utils/visual/enums';
+import type { Point } from '@/utils/visual/vertex/point';
+export declare class Ellipse extends Shape {
+    x: number;
+    y: number;
+    radiusX: number;
+    radiusY: number;
+    readonly type = ShapeType.Ellipse;
+    constructor(x?: number, y?: number, radiusX?: number, radiusY?: number);
+    contains(p: Point): boolean;
+}

package/dist/src/utils/visual/shape/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@/utils/visual/shape/circle';
+export * from '@/utils/visual/shape/ellipse';
+export * from '@/utils/visual/shape/polygon';
+export * from '@/utils/visual/shape/rectangle';
+export * from '@/utils/visual/shape/shape';

package/dist/src/utils/visual/shape/polygon.d.ts

@@ -0,0 +1,10 @@
+import { Shape } from '@/utils/visual/shape/shape';
+import { ShapeType } from '@/utils/visual/enums';
+import type { Point } from '@/utils/visual/vertex/point';
+export declare class Polygon extends Shape {
+    points: number[];
+    closeStroke: boolean;
+    type: ShapeType;
+    constructor();
+    contains(point: Point): boolean;
+}

package/dist/src/utils/visual/shape/rectangle.d.ts

@@ -0,0 +1,12 @@
+import { Shape } from '@/utils/visual/shape/shape';
+import { ShapeType } from '@/utils/visual/enums';
+import type { Point } from '@/utils/visual/vertex/point';
+export declare class Rectangle extends Shape {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    type: ShapeType;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    contains(point: Point): boolean;
+}

package/dist/src/utils/visual/shape/shape.d.ts

@@ -0,0 +1,7 @@
+import type { ShapeType } from "@/utils/visual/enums";
+import type { Point } from "@/utils/visual/vertex/point";
+export declare abstract class Shape {
+    abstract type: ShapeType;
+    constructor();
+    abstract contains(point: Point): boolean;
+}

package/dist/src/utils/visual/style/fill.d.ts

@@ -0,0 +1,8 @@
+export declare class Fill {
+    color: string;
+    alpha: number;
+    visible: boolean;
+    constructor();
+    clone(): Fill;
+    reset(): void;
+}

package/dist/src/utils/visual/style/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@/utils/visual/style/fill';
+export * from '@/utils/visual/style/line';

package/dist/src/utils/visual/style/line.d.ts

@@ -0,0 +1,9 @@
+import { LineCap, LineJoin } from '@/utils/visual/enums';
+import { Fill } from '@/utils/visual/style/fill';
+export declare class Line extends Fill {
+    width: number;
+    cap: LineCap;
+    join: LineJoin;
+    clone(): Line;
+    reset(): void;
+}

package/dist/src/utils/visual/types.d.ts

@@ -0,0 +1,6 @@
+import type { RendererType } from '@/utils/visual/enums';
+export interface IApplicationOptions {
+    rendererType?: RendererType;
+    view: HTMLCanvasElement;
+    backgroundColor?: string;
+}