ranuts 0.1.0-alpha.8 → 0.2.0-alpha.0

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

@@ -0,0 +1,116 @@
+/**
+ * Int_64 is a object for 2 32-bit numbers emulating a 64-bit number.
+ */
+export declare class Int_64 {
+    /**
+     * @param msint_32 The most significant 32-bits of a 64-bit number.
+     * @param lsint_32 The least significant 32-bits of a 64-bit number.
+     */
+    readonly highOrder: number;
+    readonly lowOrder: number;
+    constructor(msint_32: number, lsint_32: number);
+}
+/**
+ * The 64-bit implementation of circular rotate left.
+ *
+ * This does not work for n >= 64 or n == 32 but those are never done.
+ *
+ * @param x The 64-bit integer argument.
+ * @param n The number of bits to shift.
+ * @returns `x` shifted left circularly by `n` bits.
+ */
+export declare function rotl_64(x: Int_64, n: number): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Ch function.
+ *
+ * @param x The first 64-bit integer argument.
+ * @param y The second 64-bit integer argument.
+ * @param z The third 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function ch_64(x: Int_64, y: Int_64, z: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Maj function.
+ *
+ * @param x The first 64-bit integer argument.
+ * @param y The second 64-bit integer argument.
+ * @param z The third 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function maj_64(x: Int_64, y: Int_64, z: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Sigma0 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function sigma0_64(x: Int_64): Int_64;
+/**
+ * Add two 64-bit integers.
+ *
+ * @param x The first 64-bit integer argument to be added.
+ * @param y The second 64-bit integer argument to be added.
+ * @returns The sum of `x` + `y`.
+ */
+export declare function safeAdd_64_2(x: Int_64, y: Int_64): Int_64;
+/**
+ * Add four 64-bit integers.
+ *
+ * @param a The first 64-bit integer argument to be added.
+ * @param b The second 64-bit integer argument to be added.
+ * @param c The third 64-bit integer argument to be added.
+ * @param d The fouth 64-bit integer argument to be added.
+ * @returns The sum of `a` + `b` + `c` + `d`.
+ */
+export declare function safeAdd_64_4(a: Int_64, b: Int_64, c: Int_64, d: Int_64): Int_64;
+/**
+ * Add five 64-bit integers.
+ *
+ * @param a The first 64-bit integer argument to be added.
+ * @param b The second 64-bit integer argument to be added.
+ * @param c The third 64-bit integer argument to be added.
+ * @param d The fouth 64-bit integer argument to be added.
+ * @param e The fifth 64-bit integer argument to be added.
+ * @returns The sum of `a` + `b` + `c` + `d` + `e`.
+ */
+export declare function safeAdd_64_5(a: Int_64, b: Int_64, c: Int_64, d: Int_64, e: Int_64): Int_64;
+/**
+ * XORs two given arguments.
+ *
+ * @param a The first argument to be XORed.
+ * @param b The second argument to be XORed.
+ * @returns The The XOR `a` and `b`
+ */
+export declare function xor_64_2(a: Int_64, b: Int_64): Int_64;
+/**
+ * XORs five given arguments.
+ *
+ * @param a The first argument to be XORed.
+ * @param b The second argument to be XORed.
+ * @param c The third argument to be XORed.
+ * @param d The fourth argument to be XORed.
+ * @param e The fifth argument to be XORed.
+ * @returns The XOR of `a`, `b`, `c`, `d`, and `e`.
+ */
+export declare function xor_64_5(a: Int_64, b: Int_64, c: Int_64, d: Int_64, e: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Gamma1 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function gamma1_64(x: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Gamma0 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function gamma0_64(x: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Sigma1 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function sigma1_64(x: Int_64): Int_64;

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,27 @@
+import { Container } from '@/utils/visual/vertex/container';
+import { EventSystem } from '@/utils/visual/event';
+import type { IApplicationOptions } from '@/utils/visual/types';
+export declare class Application {
+    private readonly renderer;
+    readonly stage: Container;
+    readonly view: HTMLCanvasElement;
+    private animationFrameId;
+    eventSystem: EventSystem;
+    constructor(options: IApplicationOptions);
+    /**
+     * 创建并初始化一个 Application。
+     *
+     * 推荐使用此异步工厂而非 `new Application()`：WebGPU 后端的设备初始化是异步的，
+     * 必须在首次 render 之前 await 完成。Canvas / WebGL 后端的 init 会立即 resolve，
+     * 因此该工厂对所有后端都是安全且一致的。
+     *
+     * @example
+     * const app = await Application.create({ view, prefer: RENDERER_TYPE.WEB_GPU });
+     * app.stage.addChild(graphics);
+     * app.start();
+     */
+    static create(options: IApplicationOptions): Promise<Application>;
+    render(): void;
+    start(): void;
+    stop(): void;
+}

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

@@ -0,0 +1,27 @@
+export declare enum SHAPE_TYPE {
+    RECTANGLE = "rectangle",// 矩形
+    POLYGON = "polygon",// 多边形
+    CIRCLE = "circle",// 圆形
+    ELLIPSE = "ellipse",// 椭圆
+    ROUNDED_RECTANGLE = "rounded rectangle"
+}
+export declare enum LINE_CAP {
+    BUTT = "butt",
+    ROUND = "round",
+    SQUARE = "square"
+}
+export declare enum LINE_JOIN {
+    MITER = "miter",
+    BEVEL = "bevel",
+    ROUND = "round"
+}
+export declare enum RENDERER_TYPE {
+    WEB_GL = "webgl",
+    CANVAS = "canvas",
+    WEB_GPU = "webgpu"
+}
+export declare const MAX_VERTEX_COUNT = 65536;
+export declare const BYTES_PER_VERTEX = 12;
+export declare const CONTAINER = "container";
+export declare const GRAPHICS = "graphics";
+export declare const OBJECT = "object";

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,6 @@
+import { EventBoundary } from '@/utils/visual/event/boundary';
+import { EventSystem } from '@/utils/visual/event/event';
+import { EventPhase, FederatedMouseEvent } from '@/utils/visual/event/types';
+import type { Cursor, FederatedEventMap } from '@/utils/visual/event/types';
+export { EventBoundary, EventSystem, EventPhase, FederatedMouseEvent };
+export type { FederatedEventMap, Cursor };

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,81 @@
+import { Container } from '@/utils/visual/vertex/container';
+import { Polygon } from '@/utils/visual/shape/polygon';
+import { GraphicsGeometry } from '@/utils/visual/graphics/graphicsGeometry';
+import type { Shape } from '@/utils/visual/shape/shape';
+import type { BatchRenderer } from '@/utils/visual/render/batchRenderer';
+import type { ILineStyleOptions } from '@/utils/visual/types';
+import type { CanvasRenderer } from '@/utils/visual/render/canvasRenderer';
+import type { Point } from '@/utils/visual/vertex/point';
+export declare class Graphics extends Container {
+    private _lineStyle;
+    private _fillStyle;
+    geometry: GraphicsGeometry;
+    currentPath: Polygon;
+    type: string;
+    constructor();
+    lineStyle(width: number, color?: string, alpha?: number): Graphics;
+    lineStyle(options: ILineStyleOptions): Graphics;
+    resetLineStyle: () => void;
+    protected drawShape: (shape: Shape) => Graphics;
+    /**
+     * 清空已有的 path，开始新的 path
+     */
+    protected startPoly: () => void;
+    beginFill: (color?: string, alpha?: number) => Graphics;
+    /**
+     * 结束填充模式
+     */
+    endFill: () => Graphics;
+    /**
+     * 画矩形
+     * @param x x 坐标
+     * @param y y 坐标
+     * @param width 宽度
+     * @param height 高度
+     */
+    drawRect: (x: number, y: number, width: number, height: number) => Graphics;
+    /**
+     * 画圆
+     * @param x 圆心 X 坐标
+     * @param y 圆心 Y 坐标
+     * @param radius 半径
+     */
+    drawCircle: (x: number, y: number, radius: number) => Graphics;
+    /**
+     * 画圆角矩形
+     * @param x x 坐标
+     * @param y y 坐标
+     * @param width 宽度
+     * @param height 高度
+     * @param radius 圆角半径
+     */
+    drawRoundedRect: (x: number, y: number, width: number, height: number, radius: number) => Graphics;
+    /**
+     * 画椭圆
+     * @param x 椭圆中心 x 坐标
+     * @param y 椭圆中心 y 坐标
+     * @param radiusX 椭圆 x 轴半径
+     * @param radiusY 椭圆 y 轴半径
+     */
+    drawEllipse: (x: number, y: number, radiusX: number, radiusY: number) => Graphics;
+    /**
+     * 画多边形
+     * @param points 多边形顶点坐标数组，每 2 个元素算一组 (x,y)
+     */
+    drawPolygon: (points: number[]) => Graphics;
+    moveTo: (x: number, y: number) => Graphics;
+    lineTo: (x: number, y: number) => Graphics;
+    closePath: () => Graphics;
+    containsPoint: (p: Point) => boolean;
+    quadraticCurveTo: (cpX: number, cpY: number, toX: number, toY: number) => Graphics;
+    bezierCurveTo: (cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number) => Graphics;
+    arc: (cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean) => Graphics;
+    arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => Graphics;
+    clear: () => Graphics;
+    /**
+     * 调用 canvas API 绘制自身
+     */
+    protected renderCanvas: (render: CanvasRenderer) => void;
+    buildBatches: (batchRenderer: BatchRenderer) => void;
+    updateBatches: (floatView: Float32Array) => void;
+}

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

@@ -0,0 +1,13 @@
+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;
+    /**
+     * 顶点数组，每 2 个元素代表一个顶点
+     */
+    vertices: number[];
+    constructor(shape: Shape, fillStyle: Fill, lineStyle: Line);
+}

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

@@ -0,0 +1,35 @@
+import { GraphicsData } from '@/utils/visual/graphics/graphicsData';
+import { CustomFloatArray, CustomIntArray } from '@/utils/visual/render/utils/float';
+import type { Point } from '@/utils/visual/vertex/point';
+import type { BatchPart } from '@/utils/visual/render/utils/batch';
+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 GraphicsGeometry {
+    graphicsData: GraphicsData[];
+    private dirty;
+    shapeIndex: number;
+    /**
+     * 每个 batchPart 代表一个 fill 或者一个 stroke
+     */
+    batchParts: BatchPart[];
+    /**
+     * 顶点数组，每 2 个元素代表一个顶点
+     */
+    vertices: CustomFloatArray;
+    /**
+     * 顶点下标数组，每个元素代表一个顶点下标
+     */
+    indices: CustomIntArray;
+    drawShape(shape: Shape, fillStyle: Fill, lineStyle: Line): void;
+    /**
+     * @param p 待检测点
+     * @returns {boolean} 待检测点是否落在某一个子图形内
+     */
+    containsPoint(p: Point): boolean;
+    /**
+     * 将所有子图形都转化成顶点并且进行三角剖分
+     */
+    buildVerticesAndTriangulate(): void;
+    clear(): void;
+}

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

@@ -0,0 +1,4 @@
+import { Graphics } from '@/utils/visual/graphics/graphics';
+import { GraphicsData } from '@/utils/visual/graphics/graphicsData';
+import { GraphicsGeometry } from '@/utils/visual/graphics/graphicsGeometry';
+export { Graphics, GraphicsData, GraphicsGeometry };

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

@@ -0,0 +1,7 @@
+import { Application } from '@/utils/visual/application';
+import { Container } from '@/utils/visual/vertex/container';
+import { Graphics } from '@/utils/visual/graphics/graphics';
+import { BYTES_PER_VERTEX, LINE_CAP, LINE_JOIN, MAX_VERTEX_COUNT, RENDERER_TYPE, SHAPE_TYPE } from '@/utils/visual/enums';
+import type { IApplicationOptions, IFillStyleOptions, ILineStyleOptions } from '@/utils/visual/types';
+export { Application, Container, Graphics, SHAPE_TYPE, LINE_CAP, LINE_JOIN, RENDERER_TYPE, MAX_VERTEX_COUNT, BYTES_PER_VERTEX, };
+export type { IApplicationOptions, IFillStyleOptions, ILineStyleOptions };