@plait/core 0.91.0 → 0.92.0-next.0

package/index.d.ts

@@ -1,5 +1,1466 @@
+import { RoughSVG } from 'roughjs/bin/svg';
+import { Options } from 'roughjs/bin/core';
+import * as _plait_core from '@plait/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
  */
-/// <amd-module name="@plait/core" />
-export * from './public-api';
+declare const MAC_ENTER = 3;
+declare const BACKSPACE = 8;
+declare const TAB = 9;
+declare const NUM_CENTER = 12;
+declare const ENTER = 13;
+declare const SHIFT = 16;
+declare const CONTROL = 17;
+declare const ALT = 18;
+declare const PAUSE = 19;
+declare const CAPS_LOCK = 20;
+declare const ESCAPE = 27;
+declare const SPACE = 32;
+declare const PAGE_UP = 33;
+declare const PAGE_DOWN = 34;
+declare const END = 35;
+declare const HOME = 36;
+declare const LEFT_ARROW = 37;
+declare const UP_ARROW = 38;
+declare const RIGHT_ARROW = 39;
+declare const DOWN_ARROW = 40;
+declare const PLUS_SIGN = 43;
+declare const PRINT_SCREEN = 44;
+declare const INSERT = 45;
+declare const DELETE = 46;
+declare const ZERO = 48;
+declare const ONE = 49;
+declare const TWO = 50;
+declare const THREE = 51;
+declare const FOUR = 52;
+declare const FIVE = 53;
+declare const SIX = 54;
+declare const SEVEN = 55;
+declare const EIGHT = 56;
+declare const NINE = 57;
+declare const FF_SEMICOLON = 59;
+declare const FF_EQUALS = 61;
+declare const QUESTION_MARK = 63;
+declare const AT_SIGN = 64;
+declare const A = 65;
+declare const B = 66;
+declare const C = 67;
+declare const D = 68;
+declare const E = 69;
+declare const F = 70;
+declare const G = 71;
+declare const H = 72;
+declare const I = 73;
+declare const J = 74;
+declare const K = 75;
+declare const L = 76;
+declare const M = 77;
+declare const N = 78;
+declare const O = 79;
+declare const P = 80;
+declare const Q = 81;
+declare const R = 82;
+declare const S = 83;
+declare const T = 84;
+declare const U = 85;
+declare const V = 86;
+declare const W = 87;
+declare const X = 88;
+declare const Y = 89;
+declare const Z = 90;
+declare const META = 91;
+declare const MAC_WK_CMD_LEFT = 91;
+declare const MAC_WK_CMD_RIGHT = 93;
+declare const CONTEXT_MENU = 93;
+declare const NUMPAD_ZERO = 96;
+declare const NUMPAD_ONE = 97;
+declare const NUMPAD_TWO = 98;
+declare const NUMPAD_THREE = 99;
+declare const NUMPAD_FOUR = 100;
+declare const NUMPAD_FIVE = 101;
+declare const NUMPAD_SIX = 102;
+declare const NUMPAD_SEVEN = 103;
+declare const NUMPAD_EIGHT = 104;
+declare const NUMPAD_NINE = 105;
+declare const NUMPAD_MULTIPLY = 106;
+declare const NUMPAD_PLUS = 107;
+declare const NUMPAD_MINUS = 109;
+declare const NUMPAD_PERIOD = 110;
+declare const NUMPAD_DIVIDE = 111;
+declare const F1 = 112;
+declare const F2 = 113;
+declare const F3 = 114;
+declare const F4 = 115;
+declare const F5 = 116;
+declare const F6 = 117;
+declare const F7 = 118;
+declare const F8 = 119;
+declare const F9 = 120;
+declare const F10 = 121;
+declare const F11 = 122;
+declare const F12 = 123;
+declare const NUM_LOCK = 144;
+declare const SCROLL_LOCK = 145;
+declare const FIRST_MEDIA = 166;
+declare const FF_MINUS = 173;
+declare const MUTE = 173;
+declare const VOLUME_DOWN = 174;
+declare const VOLUME_UP = 175;
+declare const FF_MUTE = 181;
+declare const FF_VOLUME_DOWN = 182;
+declare const LAST_MEDIA = 183;
+declare const FF_VOLUME_UP = 183;
+declare const SEMICOLON = 186;
+declare const EQUALS = 187;
+declare const COMMA = 188;
+declare const DASH = 189;
+declare const PERIOD = 190;
+declare const SLASH = 191;
+declare const APOSTROPHE = 192;
+declare const TILDE = 192;
+declare const OPEN_SQUARE_BRACKET = 219;
+declare const BACKSLASH = 220;
+declare const CLOSE_SQUARE_BRACKET = 221;
+declare const SINGLE_QUOTE = 222;
+declare const MAC_META = 224;
+
+declare enum ResizeCursorClass {
+    ew = "ew-resize",
+    ns = "ns-resize",
+    nesw = "nesw-resize",
+    nwse = "nwse-resize"
+}
+declare enum CursorClass {
+    crosshair = "crosshair"
+}
+declare const RESIZE_CURSORS: ResizeCursorClass[];
+
+declare const ATTACHED_ELEMENT_CLASS_NAME = "plait-board-attached";
+declare const ACTIVE_STROKE_WIDTH = 1;
+declare const SNAPPING_STROKE_WIDTH = 2;
+declare const SELECTION_RECTANGLE_CLASS_NAME = "selection-rectangle";
+declare const SELECTION_RECTANGLE_BOUNDING_CLASS_NAME = "selection-rectangle-bounding";
+
+declare const ZOOM_STEP = 0.1;
+declare const MIN_ZOOM = 0.1;
+declare const MAX_ZOOM = 4;
+
+declare const HOST_CLASS_NAME = "plait-board-container";
+declare const ACTIVE_MOVING_CLASS_NAME = "active-with-moving";
+declare const ROTATE_HANDLE_CLASS_NAME = "rotate-handle";
+declare const RESIZE_HANDLE_CLASS_NAME = "resize-handle";
+declare const SCROLL_BAR_WIDTH = 20;
+declare const MAX_RADIUS = 16;
+declare const POINTER_BUTTON: {
+    readonly MAIN: 0;
+    readonly WHEEL: 1;
+    readonly SECONDARY: 2;
+    readonly TOUCH: -1;
+};
+declare const PRESS_AND_MOVE_BUFFER = 3;
+declare const DRAG_SELECTION_PRESS_AND_MOVE_BUFFER = 10;
+declare const HIT_DISTANCE_BUFFER = 5;
+
+declare enum PlaitPointerType {
+    'hand' = "hand",
+    'selection' = "selection"
+}
+
+interface XYPosition {
+    x: number;
+    y: number;
+}
+type Point = [number, number];
+declare const Point: {
+    isEquals(point?: Point, otherPoint?: Point): boolean | undefined;
+    isHorizontal(point?: Point, otherPoint?: Point, tolerance?: number): boolean | undefined;
+    isOverHorizontal(points: Point[], tolerance?: number): boolean;
+    isVertical(point?: Point, otherPoint?: Point, tolerance?: number): boolean | undefined;
+    isOverVertical(points: Point[], tolerance?: number): boolean;
+    isAlign(points: Point[], tolerance?: number): boolean;
+    getOffsetX(point1: Point, point2: Point): number;
+    getOffsetY(point1: Point, point2: Point): number;
+};
+
+/**
+ * store the instance ref for element
+ */
+interface PlaitElementRef {
+}
+
+interface PlaitElement {
+    [key: string]: any;
+    id: string;
+    children?: PlaitElement[];
+    points?: Point[];
+    type?: string;
+    groupId?: string;
+    angle?: number;
+}
+declare const PlaitElement: {
+    isRootElement(value: PlaitElement): boolean;
+    getElementRef<T extends PlaitElementRef = PlaitElementRef>(value: PlaitElement): T;
+    getElementG(value: PlaitElement): SVGGElement;
+    hasMounted(element: PlaitElement): boolean;
+    getContainerG<T extends boolean>(value: PlaitElement, options: {
+        suppressThrow: T;
+    }): T extends true ? SVGGElement | null : SVGGElement;
+};
+interface ComponentType<T> {
+    new (...args: any[]): T;
+}
+interface ImageEntry {
+    url: string;
+    file: File;
+}
+
+interface PlaitPluginElementContext<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard> {
+    element: T;
+    parent: T | K;
+    selected: boolean;
+    board: K;
+    index: number;
+    hasThemeChanged: boolean;
+}
+interface PlaitChildrenContext<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard> {
+    board: K;
+    parentG: SVGGElement;
+    parent: T | K;
+}
+
+interface PathLevelsOptions {
+    reverse?: boolean;
+}
+type Path = number[];
+declare const Path: {
+    /**
+     * Get a list of ancestor paths for a given path.
+     *
+     * The paths are sorted from shallowest to deepest ancestor. However, if the
+     * `reverse: true` option is passed, they are reversed.
+     */
+    ancestors(path: Path, options?: PathLevelsOptions): Path[];
+    /**
+     * Get a list of paths at every level down to a path. Note: this is the same
+     * as `Path.ancestors`, but including the path itself.
+     *
+     * The paths are sorted from shallowest to deepest. However, if the `reverse:
+     * true` option is passed, they are reversed.
+     */
+    levels(path: Path, options?: PathLevelsOptions): Path[];
+    parent(path: Path): Path;
+    next(path: Path): Path;
+    hasPrevious(path: Path): boolean;
+    previous(path: Path): Path;
+    /**
+     * Check if a path is an ancestor of another.
+     */
+    isAncestor(path: Path, another: Path): boolean;
+    /**
+     * Compare a path to another, returning an integer indicating whether the path
+     * was before, at, or after the other.
+     *
+     * Note: Two paths of unequal length can still receive a `0` result if one is
+     * directly above or below the other. If you want exact matching, use
+     * [[Path.equals]] instead.
+     */
+    compare(path: Path, another: Path): -1 | 0 | 1;
+    /**
+     * Check if a path is exactly equal to another.
+     */
+    equals(path: Path, another: Path): boolean;
+    /**
+     * Check if a path ends before one of the indexes in another.
+     */
+    endsBefore(path: Path, another: Path): boolean;
+    /**
+     * Check if a path is a sibling of another.
+     */
+    isSibling(path: Path, another: Path): boolean;
+    transform(path: Path | null, operation: PlaitOperation): Path | null;
+};
+
+type Ancestor = PlaitBoard | PlaitElement;
+interface NodeParentsOptions {
+    reverse?: boolean;
+}
+type PlaitNode = PlaitElement;
+declare const PlaitNode: {
+    parent: (board: PlaitBoard, path: Path) => PlaitElement;
+    /**
+     * Return a generator of all the ancestor nodes above a specific path.
+     *
+     * By default the order is top-down, from highest to lowest ancestor in
+     * the tree, but you can pass the `reverse: true` option to go bottom-up.
+     */
+    parents(root: PlaitBoard, path: Path, options?: NodeParentsOptions): Generator<PlaitNode, void, undefined>;
+    get<T extends PlaitNode = PlaitElement>(root: PlaitBoard, path: Path): T;
+    last(board: PlaitBoard, path: Path): PlaitElement;
+    first(board: PlaitBoard, path: Path): PlaitElement;
+};
+
+declare const SELECTION_BORDER_COLOR = "#6698FF";
+declare const SELECTION_FILL_COLOR = "#6698FF25";
+interface Selection {
+    anchor: Point;
+    focus: Point;
+}
+declare const Selection: {
+    isCollapsed(selection: Selection): boolean;
+};
+
+interface PlaitTheme {
+    themeColorMode: ThemeColorMode;
+}
+interface ThemeColor {
+    mode: ThemeColorMode | string;
+    boardBackground?: string;
+    textColor: string;
+}
+declare enum ThemeColorMode {
+    'default' = "default",
+    'colorful' = "colorful",
+    'soft' = "soft",
+    'retro' = "retro",
+    'dark' = "dark",
+    'starry' = "starry"
+}
+declare const DEFAULT_COLOR = "#333333";
+declare const DefaultThemeColor: ThemeColor;
+declare const ColorfulThemeColor: ThemeColor;
+declare const SoftThemeColor: ThemeColor;
+declare const RetroThemeColor: ThemeColor;
+declare const DarkThemeColor: ThemeColor;
+declare const StarryThemeColor: ThemeColor;
+declare const ThemeColors: ThemeColor[];
+
+/**
+ * Extendable Custom Types Interface
+ */
+type ExtendableTypes = 'Viewport' | 'SetViewportOperation' | 'SetSelectionOperation';
+interface CustomTypes {
+    [key: string]: unknown;
+}
+type ExtendedType<K extends ExtendableTypes, B> = unknown extends CustomTypes[K] ? B : CustomTypes[K];
+
+interface BaseViewport {
+    [key: string]: any;
+    zoom: number;
+    origination?: Point;
+}
+interface ViewportInterface {
+    isViewport: (value: any) => value is Viewport;
+}
+type Viewport = ExtendedType<'Viewport', BaseViewport>;
+declare const Viewport: ViewportInterface;
+interface FitViewportOptions {
+    maxWidth?: number;
+    limitHeight: number;
+    autoFitPadding: number;
+    containerClass: string;
+}
+
+type InsertNodeOperation = {
+    type: 'insert_node';
+    path: Path;
+    node: PlaitNode;
+};
+type RemoveNodeOperation = {
+    type: 'remove_node';
+    path: Path;
+    node: PlaitNode;
+};
+type MoveNodeOperation = {
+    type: 'move_node';
+    path: Path;
+    newPath: Path;
+};
+type SetThemeOperation = {
+    type: 'set_theme';
+    properties: Partial<PlaitTheme>;
+    newProperties: Partial<PlaitTheme>;
+};
+type SetViewportOperation = {
+    type: 'set_viewport';
+    properties: Partial<Viewport>;
+    newProperties: Partial<Viewport>;
+};
+type SetSelectionOperation = {
+    type: 'set_selection';
+    properties: Selection | null;
+    newProperties: Selection | null;
+};
+type SetNodeOperation = {
+    type: 'set_node';
+    path: Path;
+    properties: Partial<PlaitNode>;
+    newProperties: Partial<PlaitNode>;
+};
+interface PlaitOperationInterface {
+    inverse: (op: PlaitOperation) => PlaitOperation;
+    isSetViewportOperation: (value: PlaitOperation) => boolean;
+    isSetSelectionOperation: (value: PlaitOperation) => boolean;
+    isSetThemeOperation: (value: PlaitOperation) => boolean;
+}
+declare const isSetViewportOperation: (value: any) => value is SetViewportOperation;
+declare const isSetSelectionOperation: (value: any) => value is SetSelectionOperation;
+declare const isSetThemeOperation: (value: any) => value is SetThemeOperation;
+declare const inverse: (op: PlaitOperation) => PlaitOperation;
+type PlaitOperation = InsertNodeOperation | SetViewportOperation | SetSelectionOperation | SetNodeOperation | RemoveNodeOperation | MoveNodeOperation | SetThemeOperation;
+declare const PlaitOperation: PlaitOperationInterface;
+
+interface PlaitHistory {
+    redos: PlaitOperation[][];
+    undos: PlaitOperation[][];
+}
+declare const SAVING: WeakMap<PlaitBoard, boolean | undefined>;
+declare const MERGING: WeakMap<PlaitBoard, boolean | undefined>;
+declare const HISTORY: WeakMap<PlaitBoard, History>;
+declare const SPLITTING_ONCE: WeakMap<PlaitBoard, boolean | undefined>;
+
+/**
+ * [x, y] x,y between 0 and 1
+ * represents a point in the rectangle
+ */
+type PointOfRectangle = [number, number];
+interface RectangleClient {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare const RectangleClient: {
+    isHit: (origin: RectangleClient, target: RectangleClient) => boolean;
+    isHitX: (origin: RectangleClient, target: RectangleClient) => boolean;
+    isHitY: (origin: RectangleClient, target: RectangleClient) => boolean;
+    getPoints(rectangle: RectangleClient): [Point, Point];
+    getRectangleByCenterPoint(point: Point, width: number, height: number): RectangleClient;
+    getRectangleByPoint(point: Point, width: number, height: number): RectangleClient;
+    getRectangleByPoints(points: Point[] | Point[][]): RectangleClient;
+    getCornerPointsByPoints(points: Point[]): [Point, Point, Point, Point];
+    getOutlineRectangle: (rectangle: RectangleClient, offset: number) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    inflate: (rectangle: RectangleClient, delta: number) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    isEqual: (rectangle: RectangleClient, otherRectangle: RectangleClient) => boolean;
+    getCornerPoints: (rectangle: RectangleClient) => [Point, Point, Point, Point];
+    getCenterPoint: (rectangle: RectangleClient) => Point;
+    getCenterPointByPoints: (points: Point[]) => Point;
+    getEdgeCenterPoints: (rectangle: RectangleClient) => [Point, Point, Point, Point];
+    getConnectionPoint: (rectangle: RectangleClient, point: PointOfRectangle) => Point;
+    expand(rectangle: RectangleClient, left: number, top?: number, right?: number, bottom?: number): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    getGapCenter(rectangle1: RectangleClient, rectangle2: RectangleClient, isHorizontal: boolean): number;
+    isPointInRectangle(rectangle: RectangleClient, point: Point): boolean;
+    getBoundingRectangle(rectangles: RectangleClient[]): RectangleClient;
+};
+
+interface PathRefOptions {
+    affinity?: 'forward' | 'backward' | null;
+}
+interface PathRef {
+    current: Path | null;
+    affinity: 'forward' | 'backward' | null;
+    unref(): Path | null;
+}
+declare const PathRef: {
+    transform(ref: PathRef, op: PlaitOperation): void;
+};
+
+type ViewBox = {
+    minX: number;
+    minY: number;
+    width: number;
+    height: number;
+    viewportWidth: number;
+    viewportHeight: number;
+};
+declare function isInPlaitBoard(board: PlaitBoard, x: number, y: number): boolean;
+declare function getRealScrollBarWidth(board: PlaitBoard): number;
+
+declare const NS = "http://www.w3.org/2000/svg";
+declare function createG(): SVGGElement;
+declare function createPath(): SVGPathElement;
+declare function createRect(rectangle: RectangleClient, options?: Options): SVGRectElement;
+declare const setStrokeLinecap: (g: SVGGElement, value: "round" | "square") => void;
+declare const setPathStrokeLinecap: (g: SVGGElement, value: "round" | "square") => void;
+declare function createMask(): SVGMaskElement;
+declare function createSVG(): SVGSVGElement;
+declare function createText(x: number, y: number, fill: string, textContent: string): SVGTextElement;
+/**
+ * Check if a DOM node is an element node.
+ */
+declare const isDOMElement: (value: any) => value is Element;
+/**
+ * Check if a value is a DOM node.
+ */
+declare const isDOMNode: (value: any) => value is Node;
+declare const hasInputOrTextareaTarget: (target: EventTarget | null) => boolean;
+declare const isSecondaryPointer: (event: MouseEvent) => boolean;
+declare const isMainPointer: (event: MouseEvent) => boolean;
+declare const isWheelPointer: (event: MouseEvent) => boolean;
+
+declare function createForeignObject(x: number, y: number, width: number, height: number): SVGForeignObjectElement;
+declare function updateForeignObject(target: SVGForeignObjectElement | SVGGElement, width: number, height: number, x: number, y: number): void;
+declare function updateForeignObjectWidth(target: SVGForeignObjectElement | SVGGElement, width: number): void;
+
+declare const IS_MAC: boolean;
+
+declare const IS_IOS: boolean;
+declare const IS_APPLE: boolean;
+declare const IS_FIREFOX: boolean;
+declare const IS_SAFARI: boolean;
+declare const IS_EDGE_LEGACY: boolean;
+declare const IS_CHROME: boolean;
+declare const IS_CHROME_LEGACY: boolean;
+declare const IS_WINDOWS: boolean;
+
+declare function isNullOrUndefined(value: any): boolean;
+/**
+ * get {x,y} point
+ * @param point
+ * @returns point
+ */
+declare function normalizePoint(point: number[]): {
+    x: number;
+    y: number;
+};
+declare const rgbaToHEX: (rgb: string, opacity: number) => string;
+declare function isContextmenu(event: MouseEvent): boolean;
+declare function uniqueById(elements: PlaitElement[]): any[];
+declare const findLastIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
+declare const findIndex: <T>(array: readonly T[], cb: (element: T, index: number, array: readonly T[]) => boolean, fromIndex?: number) => number;
+declare const isIndicesContinuous: (indexes: number[]) => boolean;
+
+/**
+ * Check whether to merge an operation into the previous operation.
+ */
+declare const shouldMerge: (op: PlaitOperation, prev: PlaitOperation | undefined) => boolean;
+/**
+ * Check whether an operation needs to be saved to the history.
+ */
+declare const shouldSave: (op: PlaitOperation, prev: PlaitOperation | undefined) => boolean;
+/**
+ * Check whether an operation should clear the redos stack.
+ */
+declare const shouldClear: (op: PlaitOperation) => boolean;
+declare const PlaitHistoryBoard: {
+    /**
+     * Get the saving flag's current value.
+     */
+    isSaving(board: PlaitBoard): boolean | undefined;
+    /**
+     * Get the merge flag's current value.
+     */
+    isMerging(board: PlaitBoard): boolean | undefined;
+    /**
+     * Get the splitting once flag's current value.
+     */
+    isSplittingOnce(board: PlaitBoard): boolean | undefined;
+    setSplittingOnce(board: PlaitBoard, value: boolean | undefined): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, These operations will
+     * be merged into the previous history.
+     */
+    withMerging(board: PlaitBoard, fn: () => void): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, ensuring that the first
+     * operation starts a new batch in the history. Subsequent operations will be
+     * merged as usual.
+     */
+    withNewBatch(board: PlaitBoard, fn: () => void): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, without merging any of
+     * the new operations into previous save point in the history.
+     */
+    withoutMerging(board: PlaitBoard, fn: () => void): void;
+    /**
+     * Apply a series of changes inside a synchronous `fn`, without saving any of
+     * their operations into the history.
+     */
+    withoutSaving(board: PlaitBoard, fn: () => void): void;
+};
+
+/**
+ * Hotkeys.
+ */
+declare const hotkeys: {
+    isBold: (event: KeyboardEvent) => boolean;
+    isCompose: (event: KeyboardEvent) => boolean;
+    isArrow: (event: KeyboardEvent) => boolean;
+    isMoveBackward: (event: KeyboardEvent) => boolean;
+    isMoveForward: (event: KeyboardEvent) => boolean;
+    isMoveUp: (event: KeyboardEvent) => boolean;
+    isMoveDown: (event: KeyboardEvent) => boolean;
+    isDeleteBackward: (event: KeyboardEvent) => boolean;
+    isDeleteForward: (event: KeyboardEvent) => boolean;
+    isDeleteLineBackward: (event: KeyboardEvent) => boolean;
+    isDeleteLineForward: (event: KeyboardEvent) => boolean;
+    isDeleteWordBackward: (event: KeyboardEvent) => boolean;
+    isDeleteWordForward: (event: KeyboardEvent) => boolean;
+    isExtendBackward: (event: KeyboardEvent) => boolean;
+    isExtendForward: (event: KeyboardEvent) => boolean;
+    isExtendUp: (event: KeyboardEvent) => boolean;
+    isExtendDown: (event: KeyboardEvent) => boolean;
+    isExtendArrow: (event: KeyboardEvent) => boolean;
+    isExtendLineBackward: (event: KeyboardEvent) => boolean;
+    isExtendLineForward: (event: KeyboardEvent) => boolean;
+    isItalic: (event: KeyboardEvent) => boolean;
+    isMoveLineBackward: (event: KeyboardEvent) => boolean;
+    isMoveLineForward: (event: KeyboardEvent) => boolean;
+    isMoveWordBackward: (event: KeyboardEvent) => boolean;
+    isMoveWordForward: (event: KeyboardEvent) => boolean;
+    isRedo: (event: KeyboardEvent) => boolean;
+    isSplitBlock: (event: KeyboardEvent) => boolean;
+    isTransposeCharacter: (event: KeyboardEvent) => boolean;
+    isUndo: (event: KeyboardEvent) => boolean;
+    isShift: (event: KeyboardEvent) => boolean;
+};
+
+declare function idCreator(length?: number): string;
+
+declare function distanceBetweenPointAndSegment(x: number, y: number, x1: number, y1: number, x2: number, y2: number): number;
+declare function getNearestPointBetweenPointAndSegment(point: Point, linePoints: [Point, Point]): Point;
+declare function distanceBetweenPointAndSegments(point: Point, points: Point[]): number;
+declare function getNearestPointBetweenPointAndSegments(point: Point, points: Point[], isClose?: Boolean): Point;
+declare function getNearestPointBetweenPointAndDiscreteSegments(point: Point, segments: [Point, Point][]): Point;
+declare function getNearestPointBetweenPointAndEllipse(point: Point, center: Point, rx: number, ry: number): Point;
+declare function rotate(x1: number, y1: number, x2: number, y2: number, angle: number): number[];
+declare function distanceBetweenPointAndPoint(x1: number, y1: number, x2: number, y2: number): number;
+declare function distanceBetweenPointAndRectangle(x: number, y: number, rect: RectangleClient): number;
+declare const isLineHitLine: (a: Point, b: Point, c: Point, d: Point) => boolean;
+declare const isLineHitRectangle: (points: Point[], rectangle: RectangleClient) => boolean;
+declare const isLineHitRectangleEdge: (points: Point[], rectangle: RectangleClient, isClose?: boolean) => boolean;
+declare const isSingleLineHitRectangleEdge: (p1: Point, p2: Point, rectangle: RectangleClient) => boolean;
+declare const isPointInPolygon: (point: Point, points: Point[]) => boolean;
+declare const isPointInEllipse: (point: Point, center: Point, rx: number, ry: number, angle?: number) => boolean;
+declare const isPointInRoundRectangle: (point: Point, rectangle: RectangleClient, radius: number, angle?: number) => boolean;
+declare const catmullRomFitting: (points: Point[]) => Point[];
+/**
+ * the result of slope is based on Cartesian coordinate system
+ * x, y are based on the position in the Cartesian coordinate system
+ */
+declare function getEllipseTangentSlope(x: number, y: number, a: number, b: number): number;
+/**
+ * x, y are based on the position in the Cartesian coordinate system
+ */
+declare function getVectorFromPointAndSlope(x: number, y: number, slope: number): Point;
+/**
+ * The DOM likes values to be fixed to 3 decimal places
+ */
+declare function toDomPrecision(v: number): number;
+declare function toFixed(v: number): number;
+declare function ceilToDecimal(value: number, decimalPlaces: number): number;
+/**
+ * Whether two numbers numbers a and b are approximately equal.
+ *
+ * @param a - The first point.
+ * @param b - The second point.
+ * @public
+ */
+declare function approximately(a: number, b: number, precision?: number): boolean;
+declare function getCrossingPointsBetweenEllipseAndSegment(startPoint: Point, endPoint: Point, cx: number, cy: number, rx: number, ry: number, segment_only?: boolean): number[][];
+/**
+ * Get a point between two points.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ * @param d Normalized
+ */
+declare function getPointBetween(x0: number, y0: number, x1: number, y1: number, d?: number): number[];
+/**
+ * 获取点到半椭圆弧段的最近点
+ * @param point 目标点
+ * @param startPoint 弧段起点
+ * @param arcCommand SVG 弧形命令参数
+ */
+/**
+ * 计算椭圆弧的中心点和实际半径
+ */
+declare function getEllipseArcCenter(startPoint: Point, arcCommand: SVGArcCommand): {
+    center: Point;
+    rx: number;
+    ry: number;
+};
+declare function getNearestPointBetweenPointAndArc(point: Point, startPoint: Point, arcCommand: SVGArcCommand): Point;
+
+declare class PlaitBoardContext {
+    private uploadingFiles;
+    getUploadingFile(url: string): ImageEntry | undefined;
+    setUploadingFile(file: ImageEntry): number;
+    removeUploadingFile(fileEntry: ImageEntry): void;
+}
+
+declare const IS_BOARD_CACHE: WeakMap<Object, boolean>;
+declare const FLUSHING: WeakMap<PlaitBoard, boolean>;
+declare const NODE_TO_INDEX: WeakMap<PlaitElement, number>;
+declare const NODE_TO_PARENT: WeakMap<PlaitElement, Ancestor>;
+declare const KEY_TO_ELEMENT_MAP: WeakMap<PlaitBoard, Map<String, PlaitElement>>;
+declare const NODE_TO_G: WeakMap<PlaitElement, SVGGElement>;
+declare const NODE_TO_CONTAINER_G: WeakMap<PlaitElement, SVGGElement>;
+declare const IS_TEXT_EDITABLE: WeakMap<PlaitBoard, boolean>;
+declare const BOARD_TO_ON_CHANGE: WeakMap<PlaitBoard, () => void>;
+declare const BOARD_TO_AFTER_CHANGE: WeakMap<PlaitBoard, () => void>;
+declare const BOARD_TO_ROUGH_SVG: WeakMap<PlaitBoard, RoughSVG>;
+declare const BOARD_TO_HOST: WeakMap<PlaitBoard, SVGSVGElement>;
+declare const BOARD_TO_CONTEXT: WeakMap<PlaitBoard, PlaitBoardContext>;
+declare const IS_BOARD_ALIVE: WeakMap<PlaitBoard, boolean>;
+declare const BOARD_TO_ELEMENT_HOST: WeakMap<PlaitBoard, {
+    lowerHost: SVGGElement;
+    host: SVGGElement;
+    upperHost: SVGGElement;
+    topHost: SVGGElement;
+    activeHost: SVGGElement;
+    container: HTMLElement;
+    viewportContainer: HTMLElement;
+}>;
+declare const BOARD_TO_SELECTED_ELEMENT: WeakMap<PlaitBoard, PlaitElement[]>;
+declare const BOARD_TO_MOVING_POINT_IN_BOARD: WeakMap<PlaitBoard, Point>;
+declare const BOARD_TO_MOVING_POINT: WeakMap<PlaitBoard, Point>;
+declare const BOARD_TO_VIEWPORT_ORIGINATION: WeakMap<PlaitBoard, Point>;
+declare const BOARD_TO_IS_SELECTION_MOVING: WeakMap<PlaitBoard, boolean>;
+declare const BOARD_TO_TEMPORARY_ELEMENTS: WeakMap<PlaitBoard, {
+    elements: PlaitElement[];
+    timeoutId: any;
+}>;
+declare const BOARD_TO_MOVING_ELEMENT: WeakMap<PlaitBoard, PlaitElement[]>;
+declare const PATH_REFS: WeakMap<PlaitBoard, Set<PathRef>>;
+declare const ELEMENT_TO_REF: WeakMap<PlaitElement, PlaitElementRef>;
+
+type PlaitPlugin = (board: PlaitBoard) => PlaitBoard;
+interface WithPluginOptions {
+    disabled?: boolean;
+}
+interface WithSelectionPluginOptions extends WithPluginOptions {
+    isMultipleSelection: boolean;
+    isDisabledSelection: boolean;
+    isPreventClearSelection: boolean;
+}
+interface WithHandPluginOptions extends WithPluginOptions {
+    isHandMode: (board: PlaitBoard, event: PointerEvent) => boolean;
+}
+declare enum PlaitPluginKey {
+    'withSelection' = "withSelection",
+    'withHand' = "withHand"
+}
+
+interface PlaitOptionsBoard extends PlaitBoard {
+    getPluginOptions: <K = WithPluginOptions>(key: string) => K;
+    setPluginOptions: <K = WithPluginOptions>(key: string, value: Partial<K>) => void;
+}
+declare const withOptions: (board: PlaitBoard) => PlaitOptionsBoard;
+
+declare const getHitElementsBySelection: (board: PlaitBoard, selection?: Selection, match?: (element: PlaitElement) => boolean) => PlaitElement[];
+declare const getHitElementsByPoint: (board: PlaitBoard, point: Point, match?: (element: PlaitElement) => boolean, isStrict?: boolean) => PlaitElement[];
+declare const getHitElementByPoint: (board: PlaitBoard, point: Point, match?: (element: PlaitElement) => boolean, isStrict?: boolean) => undefined | PlaitElement;
+declare const getHitSelectedElements: (board: PlaitBoard, point: Point) => PlaitElement[];
+declare const cacheSelectedElements: (board: PlaitBoard, selectedElements: PlaitElement[]) => void;
+declare const getSelectedElements: (board: PlaitBoard) => PlaitElement[];
+declare const addSelectedElement: (board: PlaitBoard, element: PlaitElement | PlaitElement[]) => void;
+declare const removeSelectedElement: (board: PlaitBoard, element: PlaitElement, isRemoveChildren?: boolean) => void;
+declare const replaceSelectedElement: (board: PlaitBoard, element: PlaitElement, newElement: PlaitElement) => void;
+declare const clearSelectedElement: (board: PlaitBoard) => void;
+declare const isSelectedElement: (board: PlaitBoard, element: PlaitElement) => boolean;
+declare const temporaryDisableSelection: (board: PlaitOptionsBoard) => void;
+declare const isHitSelectedRectangle: (board: PlaitBoard, point: Point) => boolean;
+declare const isHitElement: (board: PlaitBoard, point: Point) => boolean;
+
+/**
+ * drawRoundRectangle
+ */
+declare function drawRoundRectangle(rs: RoughSVG, x1: number, y1: number, x2: number, y2: number, options: Options, outline?: boolean, borderRadius?: number): SVGGElement;
+declare const drawRectangle: (board: PlaitBoard, rectangle: RectangleClient, options: Options) => SVGGElement;
+
+declare function arrowPoints(start: Point, end: Point, degree?: number): {
+    pointLeft: Point;
+    pointRight: Point;
+};
+declare function drawArrow(rs: RoughSVG, start: Point, end: Point, options: Options, maxHypotenuseLength?: number, degree?: number): SVGGElement[];
+
+declare function drawCircle(roughSVG: RoughSVG, point: Point, diameter: number, options: Options): SVGGElement;
+
+declare function drawLine(rs: RoughSVG, start: Point, end: Point, options: Options): SVGGElement;
+declare function drawLinearPath(points: Point[], options?: Options, closePath?: boolean): SVGGElement;
+declare function drawBezierPath(points: Point[], options?: Options): SVGGElement;
+
+declare function depthFirstRecursion<T extends TreeNode = TreeNode>(node: T, callback: (node: T) => void, recursion?: (node: T) => boolean, isReverse?: boolean): void;
+declare const getIsRecursionFunc: (board: PlaitBoard) => (element: PlaitElement | PlaitBoard) => boolean;
+interface TreeNode {
+    children?: TreeNode[];
+}
+
+declare function getRectangleByElements(board: PlaitBoard, elements: PlaitElement[], recursion: boolean): RectangleClient;
+declare function getBoundingRectangleByElements(board: PlaitBoard, elements: PlaitElement[], recursion: boolean): RectangleClient;
+declare function getBoardRectangle(board: PlaitBoard): RectangleClient;
+declare function getElementById<T extends PlaitElement = PlaitElement>(board: PlaitBoard, id: string, dataSource?: PlaitElement[]): T | undefined;
+declare function getElementMap(board: PlaitBoard): Map<String, PlaitElement>;
+declare function findElements<T extends PlaitElement = PlaitElement>(board: PlaitBoard, options: {
+    match: (element: PlaitElement) => boolean;
+    recursion: (element: PlaitElement) => boolean;
+    isReverse?: boolean;
+}): T[];
+
+declare const VIEWPORT_PADDING_RATIO = 0.75;
+interface ElementHostBBox {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+declare function getViewportContainerRect(board: PlaitBoard): {
+    width: number;
+    height: number;
+};
+declare function getElementHostBBox(board: PlaitBoard, zoom: number): ElementHostBBox;
+/**
+ * Normalize the scaling ratio, or return the corrected scaling ratio if the limit is exceeded
+ */
+declare function clampZoomLevel(zoom: number, minZoom?: number, maxZoom?: number): number;
+/**
+ * Prepares element bounding box with minimum size constraints
+ */
+declare function prepareElementBBox(board: PlaitBoard, zoom: number): {
+    elementHostBBox: ElementHostBBox;
+    containerWidth: number;
+    containerHeight: number;
+    width: number;
+    height: number;
+};
+/**
+ * Calculates viewBox based on element bounding box with padding
+ */
+declare function calculateViewBox(elementHostBBox: ElementHostBBox, containerWidth: number, containerHeight: number, width: number, height: number, zoom: number, paddingRatio?: number): number[];
+declare function calcNewViewBox(board: PlaitBoard, zoom: number): number[];
+declare function getViewBoxCenterPoint(board: PlaitBoard): Point;
+declare function setSVGViewBox(board: PlaitBoard, viewBox: number[]): void;
+declare function updateViewportOffset(board: PlaitBoard): void;
+declare function updateViewportContainerScroll(board: PlaitBoard, left: number, top: number, isFromViewportChange?: boolean): void;
+declare function updateViewportByScrolling(board: PlaitBoard, scrollLeft: number, scrollTop: number): void;
+declare function initializeViewportContainer(board: PlaitBoard): void;
+declare function initializeViewBox(board: PlaitBoard): void;
+declare function updateViewBox(board: PlaitBoard): void;
+declare function initializeViewportOffset(board: PlaitBoard): void;
+declare const updateViewportOrigination: (board: PlaitBoard, origination: Point) => void;
+declare const clearViewportOrigination: (board: PlaitBoard) => void;
+declare const getViewportOrigination: (board: PlaitBoard) => Point | undefined;
+declare const isFromScrolling: (board: PlaitBoard) => boolean;
+declare const setIsFromScrolling: (board: PlaitBoard, state: boolean) => void;
+declare const isFromViewportChange: (board: PlaitBoard) => boolean;
+declare const setIsFromViewportChange: (board: PlaitBoard, state: boolean) => void;
+declare const isInVisibleViewport: (board: PlaitBoard, client: RectangleClient, isOpenKeyboard?: boolean) => boolean;
+declare function scrollToVisibleWhenKeyboardOpening(board: PlaitBoard, client: RectangleClient): void;
+
+interface MoveNodeOption {
+    element: PlaitElement;
+    newPath: Path;
+}
+declare const throttleRAF: (board: PlaitBoard, key: string, fn: () => void) => void;
+declare const debounce: <T>(func: (args?: T) => void, wait: number, options?: {
+    leading: boolean;
+}) => (args?: T) => void;
+declare const getElementsIndices: (board: PlaitBoard, elements: PlaitElement[]) => number[];
+declare const getHighestIndexOfElement: (board: PlaitBoard, elements: PlaitElement[]) => number;
+declare const moveElementsToNewPath: (board: PlaitBoard, moveOptions: MoveNodeOption[]) => void;
+
+declare const getMovingElements: (board: PlaitBoard) => PlaitElement[];
+declare const isMovingElements: (board: PlaitBoard) => boolean;
+declare const removeMovingElements: (board: PlaitBoard) => void;
+declare const cacheMovingElements: (board: PlaitBoard, elements: PlaitElement[]) => void;
+
+interface ToImageOptions {
+    elements?: PlaitElement[];
+    name?: string;
+    ratio?: number;
+    padding?: number;
+    fillStyle?: string;
+    inlineStyleClassNames?: string;
+}
+/**
+ * current board transfer pictures
+ * @param board board
+ * @param options parameter configuration
+ * @returns images in the specified format base64
+ */
+declare function toImage(board: PlaitBoard, options: ToImageOptions): Promise<string | undefined>;
+/**
+ * download the file with the specified name
+ * @param url download url
+ * @param name file name
+ */
+declare function downloadImage(url: string, name: string): void;
+
+declare enum WritableClipboardType {
+    'medias' = "medias",
+    'elements' = "elements"
+}
+declare enum WritableClipboardOperationType {
+    'copy' = "copy",
+    'cut' = "cut",
+    'duplicate' = "duplicate",
+    'paste' = "paste"
+}
+type WritableClipboardData = PlaitElement[] | any[];
+interface WritableClipboardContext {
+    text: string;
+    type: WritableClipboardType;
+    elements: WritableClipboardData;
+}
+interface ClipboardData {
+    files?: File[];
+    elements?: PlaitElement[];
+    medias?: any[];
+    text?: string;
+    operationType?: WritableClipboardOperationType;
+}
+
+declare const cacheClipboardData: (clipboardData: ClipboardData) => void;
+declare const getCachedClipboardData: () => any;
+declare const getClipboardData: (dataTransfer: DataTransfer | null) => Promise<ClipboardData | null>;
+declare const setClipboardData: (dataTransfer: DataTransfer | null, clipboardContext: WritableClipboardContext | null) => Promise<void>;
+
+declare const buildPlaitHtml: (type: WritableClipboardType, data: WritableClipboardData) => string;
+declare const getClipboardFromHtml: (html: string) => ClipboardData | null;
+declare const stripHtml: (html: string) => string;
+declare const getProbablySupportsClipboardWrite: () => boolean;
+declare const getProbablySupportsClipboardWriteText: () => boolean;
+declare const getProbablySupportsClipboardRead: () => boolean;
+declare const createClipboardContext: (type: WritableClipboardType, elements: WritableClipboardData, text: string) => WritableClipboardContext;
+declare const addClipboardContext: (clipboardContext: WritableClipboardContext, addition: WritableClipboardContext) => WritableClipboardContext;
+declare const addOrCreateClipboardContext: (clipboardContext: WritableClipboardContext | null, addition: WritableClipboardContext) => WritableClipboardContext;
+declare const replaceAngleBrackets: (str: string) => string;
+declare const reverseReplaceAngleBrackets: (str: string) => string;
+
+declare const setDataTransferClipboard: (dataTransfer: DataTransfer | null, type: WritableClipboardType, data: WritableClipboardData) => void;
+declare const setDataTransferClipboardText: (data: DataTransfer | null, text: string) => void;
+declare const getDataTransferClipboard: (data: DataTransfer | null) => ClipboardData;
+declare const getDataTransferClipboardText: (data: DataTransfer | null) => ClipboardData;
+
+declare const IS_DRAGGING: WeakMap<PlaitBoard, boolean>;
+declare const isDragging: (board: PlaitBoard) => boolean;
+declare const setDragging: (board: PlaitBoard, state: boolean) => void;
+
+declare const getViewBox: (board: PlaitBoard) => DOMRect;
+/**
+ * Get the screen point starting from the upper left corner of the svg element (based on the svg screen coordinate system)
+ * reference: https://github.com/worktile/plait/blob/develop/packages/core/src/utils/to-point.md
+ */
+declare function toHostPoint(board: PlaitBoard, x: number, y: number): Point;
+declare function toActiveRectangleFromViewBoxRectangle(board: PlaitBoard, rectangle: RectangleClient): RectangleClient;
+declare function toActivePointFromViewBoxPoint(board: PlaitBoard, point: Point): Point;
+/**
+ * Get the screen point starting from the upper left corner of the svg element (based on the svg screen coordinate system)
+ */
+declare function toActivePoint(board: PlaitBoard, x: number, y: number): Point;
+declare function toScreenPointFromActivePoint(board: PlaitBoard, activePoint: Point): Point;
+/**
+ * Get the point in the coordinate system of the svg viewBox
+ * reference: https://github.com/worktile/plait/blob/develop/packages/core/src/utils/to-point.md
+ */
+declare function toViewBoxPoint(board: PlaitBoard, hostPoint: Point): Point;
+declare function toViewBoxPoints(board: PlaitBoard, hostPoints: Point[]): Point[];
+/**
+ * `toHostPoint` reverse processing
+ * Get the screen point starting from the upper left corner of the browser window or the viewport (based on the screen coordinate system)
+ */
+declare function toScreenPointFromHostPoint(board: PlaitBoard, hostPoint: Point): Point;
+/**
+ * `toViewBoxPoint` reverse processing
+ */
+declare function toHostPointFromViewBoxPoint(board: PlaitBoard, viewBoxPoint: Point): Point;
+
+declare const getElementsInGroup: (board: PlaitBoard, group: PlaitGroup, recursion?: boolean, includeGroup?: boolean) => PlaitElement[];
+declare const getAllElementsInGroup: (board: PlaitBoard, group: PlaitGroup, recursion?: boolean, includeGroup?: boolean) => PlaitElement[];
+declare const getRectangleByGroup: (board: PlaitBoard, group: PlaitGroup, recursion?: boolean) => RectangleClient;
+declare const getGroupByElement: (board: PlaitBoard, element: PlaitElement, recursion?: boolean, originElements?: PlaitElement[]) => PlaitGroup | PlaitGroup[] | null;
+declare const getHighestGroup: (board: PlaitBoard, element: PlaitElement) => PlaitGroup | null;
+declare const getElementsInGroupByElement: (board: PlaitBoard, element: PlaitElement) => PlaitElement[];
+declare const getAllGroups: (board: PlaitBoard) => PlaitGroup[];
+declare const isSelectedElementOrGroup: (board: PlaitBoard, element: PlaitElement, elements?: PlaitElement[]) => boolean;
+declare const isSelectedAllElementsInGroup: (board: PlaitBoard, group: PlaitGroup, elements?: PlaitElement[]) => boolean;
+declare const filterSelectedGroups: (board: PlaitBoard, groups: PlaitGroup[], elements?: PlaitElement[]) => PlaitGroup[];
+declare const getSelectedGroups: (board: PlaitBoard, elements?: PlaitElement[], originElements?: PlaitElement[]) => PlaitGroup[];
+declare const getHighestSelectedGroup: (board: PlaitBoard, element: PlaitElement, elements?: PlaitElement[], originElements?: PlaitElement[]) => PlaitGroup | null;
+declare const getHighestSelectedGroups: (board: PlaitBoard, elements?: PlaitElement[], originElements?: PlaitElement[]) => PlaitGroup[];
+declare const getSelectedIsolatedElements: (board: PlaitBoard, elements?: PlaitElement[]) => PlaitElement[];
+declare const getSelectedIsolatedElementsCanAddToGroup: (board: PlaitBoard, elements?: PlaitElement[]) => PlaitElement[];
+declare const getHighestSelectedElements: (board: PlaitBoard, elements?: PlaitElement[]) => PlaitElement[];
+declare const createGroupRectangleG: (board: PlaitBoard, elements: PlaitElement[]) => SVGGElement | null;
+declare const createGroup: (groupId?: string) => PlaitGroup;
+declare const nonGroupInHighestSelectedElements: (elements: PlaitElement[]) => boolean;
+declare const hasSelectedElementsInSameGroup: (elements: PlaitElement[]) => boolean;
+declare const canAddGroup: (board: PlaitBoard, elements?: PlaitElement[]) => boolean;
+declare const canRemoveGroup: (board: PlaitBoard, elements?: PlaitElement[], originElements?: PlaitElement[]) => boolean;
+declare const getEditingGroup: (board: PlaitBoard, element: PlaitElement) => PlaitGroup | null;
+declare const moveElementsToNewPathAfterAddGroup: (board: PlaitBoard, selectedElements: PlaitElement[], newPath: Path) => void;
+
+declare function isSelectionMoving(board: PlaitBoard): boolean;
+declare function setSelectionMoving(board: PlaitBoard): void;
+declare function clearSelectionMoving(board: PlaitBoard): void;
+declare function isHandleSelection(board: PlaitBoard): boolean;
+declare function hasSetSelectionOperation(board: PlaitBoard): boolean;
+declare function getTemporaryElements(board: PlaitBoard): PlaitElement[] | undefined;
+declare function getTemporaryRef(board: PlaitBoard): {
+    elements: PlaitElement[];
+    timeoutId: any;
+} | undefined;
+declare function deleteTemporaryElements(board: PlaitBoard): void;
+declare function drawSelectionRectangleG(board: PlaitBoard): SVGGElement | null;
+declare function setSelectedElementsWithGroup(board: PlaitBoard, elements: PlaitElement[], isShift: boolean): void;
+declare function cacheSelectedElementsWithGroupOnShift(board: PlaitBoard, elements: PlaitElement[], isSelectGroupElement: boolean, elementsInHighestGroup: PlaitElement[]): void;
+declare function cacheSelectedElementsWithGroup(board: PlaitBoard, elements: PlaitElement[], isSelectGroupElement: boolean, hitElementGroups: PlaitGroup[]): void;
+declare const getSelectionOptions: (board: PlaitBoard) => WithSelectionPluginOptions;
+declare const setSelectionOptions: (board: PlaitBoard, options: Partial<WithSelectionPluginOptions>) => void;
+
+declare const rotatePoints: <T>(points: T, centerPoint: Point, angle?: number) => T;
+declare const getSelectionAngle: (elements: PlaitElement[]) => number;
+declare const hasSameAngle: (elements: PlaitElement[]) => boolean;
+declare const getRotatedBoundingRectangle: (rectanglesCornerPoints: [Point, Point, Point, Point][], angle: number) => RectangleClient;
+declare const getOffsetAfterRotate: (rectangle: RectangleClient, rotateCenterPoint: Point, angle: number) => {
+    offsetX: number;
+    offsetY: number;
+};
+declare const rotatedDataPoints: (points: Point[], rotateCenterPoint: Point, angle: number) => Point[];
+declare const hasValidAngle: (node: PlaitElement) => boolean | 0 | undefined;
+declare const isValidAngle: (angle: undefined | number) => boolean | 0 | undefined;
+declare const rotatePointsByElement: <T>(points: T, element: PlaitElement) => T | null;
+declare const rotatePointsByAngle: (points: Point[], angle: number | undefined) => Point[] | null;
+declare const rotateAntiPointsByElement: <T>(board: PlaitBoard, points: T, element: PlaitElement, isToActive?: boolean) => T | null;
+declare const getRectangleByAngle: (rectangle: RectangleClient, angle: number) => RectangleClient;
+declare const isAxisChangedByAngle: (angle: number) => boolean;
+declare function degreesToRadians(d: number): number;
+declare function radiansToDegrees(r: number): number;
+declare function rotateElements(board: PlaitBoard, elements: PlaitElement[], angle: number): void;
+declare const normalizeAngle: (angle: number) => number;
+declare const getAngleBetweenPoints: (startPoint: Point, endPoint: Point, centerPoint: Point) => number;
+declare const getAngleByElement: (element: PlaitElement) => number | undefined;
+declare const setAngleForG: (g: SVGGElement, centerPoint: Point, angle: number) => void;
+
+declare const deleteFragment: (board: PlaitBoard) => void;
+declare const setFragment: (board: PlaitBoard, operationType: WritableClipboardOperationType, clipboardData: DataTransfer | null) => void;
+declare const duplicateElements: (board: PlaitBoard, elements?: PlaitElement[], point?: Point) => void;
+
+interface SnapDelta {
+    deltaX: number;
+    deltaY: number;
+}
+interface SnapRef extends SnapDelta {
+    snapG: SVGGElement;
+}
+interface GapSnapRef {
+    before: {
+        distance: number;
+        index: number;
+    }[];
+    after: {
+        distance: number;
+        index: number;
+    }[];
+}
+type TripleSnapAxis = [number, number, number];
+declare const SNAP_TOLERANCE = 2;
+declare function getSnapRectangles(board: PlaitBoard, activeElements: PlaitElement[]): RectangleClient[];
+declare function getBarPoint(point: Point, isHorizontal: boolean): number[][];
+declare function getMinPointDelta(pointRectangles: RectangleClient[], axis: number, isHorizontal: boolean): number;
+declare const getNearestDelta: (axis: number, rectangle: RectangleClient, isHorizontal: boolean) => number;
+declare const getTripleAxis: (rectangle: RectangleClient, isHorizontal: boolean) => TripleSnapAxis;
+declare function getNearestPointRectangle(snapRectangles: RectangleClient[], activeRectangle: RectangleClient): RectangleClient;
+declare const isSnapPoint: (axis: number, rectangle: RectangleClient, isHorizontal: boolean) => boolean;
+declare function drawPointSnapLines(board: PlaitBoard, activeRectangle: RectangleClient, snapRectangles: RectangleClient[], drawHorizontal?: boolean, drawVertical?: boolean, snapMiddle?: boolean): SVGGElement;
+declare function drawDashedLines(board: PlaitBoard, lines: [Point, Point][]): SVGGElement;
+declare function drawSolidLines(board: PlaitBoard, lines: Point[][]): SVGGElement;
+
+declare const getOneMoveOptions: (board: PlaitBoard, direction: "down" | "up") => MoveNodeOption[];
+declare const getAllMoveOptions: (board: PlaitBoard, direction: "down" | "up") => MoveNodeOption[];
+declare const canSetZIndex: (board: PlaitBoard) => boolean;
+
+declare const sortElements: (board: PlaitBoard, elements: PlaitElement[], ascendingOrder?: boolean) => PlaitElement[];
+
+declare const isMobileDeviceEvent: (event: PointerEvent) => boolean;
+declare const isPencilEvent: (event: PointerEvent) => boolean;
+declare const isTouchEvent: (event: PointerEvent) => boolean;
+declare const isMouseEvent: (event: PointerEvent) => boolean;
+declare const isTouchDevice: () => number | true;
+
+declare class ListRender {
+    private board;
+    private children;
+    private instances;
+    private contexts;
+    private differ;
+    initialized: boolean;
+    constructor(board: PlaitBoard);
+    initialize(children: PlaitElement[], childrenContext: PlaitChildrenContext): void;
+    update(children: PlaitElement[], childrenContext: PlaitChildrenContext): void;
+    destroy(): void;
+}
+declare const mountElementG: (index: number, g: SVGGElement, childrenContext: PlaitChildrenContext, currentIndexForFirstElement?: number | null) => void;
+
+/**
+ * 基于 element-flavour 实现元素的绘制，取代 Angular 组件
+ */
+
+declare class ElementFlavour<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard, R extends PlaitElementRef = PlaitElementRef> {
+    private ref;
+    private _g;
+    private _containerG;
+    private _rootContainerG?;
+    initialized: boolean;
+    protected _context: PlaitPluginElementContext<T, K>;
+    get hasChildren(): boolean;
+    set context(value: PlaitPluginElementContext<T, K>);
+    get context(): PlaitPluginElementContext<T, K>;
+    get element(): T;
+    get board(): K;
+    get selected(): boolean;
+    listRender?: ListRender;
+    getContainerG(): SVGGElement;
+    getElementG(): SVGGElement;
+    constructor(ref: R);
+    initialize(): void;
+    initializeListRender(): void;
+    getRef(): R;
+    private updateListRender;
+    private initializeChildrenContext;
+    destroy(): void;
+}
+
+interface PlaitBoardOptions {
+    readonly?: boolean;
+    hideScrollbar?: boolean;
+    disabledScrollOnNonFocus?: boolean;
+    themeColors?: ThemeColor[];
+}
+interface PlaitBoardMove {
+    x: number;
+    y: number;
+}
+interface PlaitBoard {
+    viewport: Viewport;
+    children: PlaitElement[];
+    theme: PlaitTheme;
+    operations: PlaitOperation[];
+    selection: Selection | null;
+    pointer: PlaitPointerType | string;
+    history: PlaitHistory;
+    options: PlaitBoardOptions;
+    undo: () => void;
+    redo: () => void;
+    apply: (operation: PlaitOperation) => void;
+    onChange: () => void;
+    afterChange: () => void;
+    drawSelectionRectangle: () => SVGGElement | null;
+    mousedown: (event: MouseEvent) => void;
+    mousemove: (event: MouseEvent) => void;
+    mouseleave: (event: MouseEvent) => void;
+    mouseup: (event: MouseEvent) => void;
+    globalMousemove: (event: MouseEvent) => void;
+    globalMouseup: (event: MouseEvent) => void;
+    keyDown: (event: KeyboardEvent) => void;
+    globalKeyDown: (event: KeyboardEvent) => void;
+    keyUp: (event: KeyboardEvent) => void;
+    buildFragment: (clipboardContext: WritableClipboardContext | null, rectangle: RectangleClient | null, operationType: WritableClipboardOperationType, originData?: PlaitElement[]) => WritableClipboardContext | null;
+    insertFragment: (clipboardData: ClipboardData | null, targetPoint: Point, operationType?: WritableClipboardOperationType) => void;
+    deleteFragment: (data: PlaitElement[]) => void;
+    getDeletedFragment: (data: PlaitElement[]) => PlaitElement[];
+    getRelatedFragment: (data: PlaitElement[], originData?: PlaitElement[]) => PlaitElement[];
+    dblClick: (event: MouseEvent) => void;
+    normalizeElement: (context: PlaitPluginElementContext) => void;
+    drawElement: (context: PlaitPluginElementContext) => ComponentType<ElementFlavour>;
+    isRectangleHit: (element: PlaitElement, range: Selection) => boolean;
+    isHit: (element: PlaitElement, point: Point, isStrict?: boolean) => boolean;
+    isInsidePoint: (element: PlaitElement, point: Point) => boolean;
+    getOneHitElement: (hitElements: PlaitElement[]) => PlaitElement;
+    isRecursion: (element: PlaitElement) => boolean;
+    isMovable: (element: PlaitElement) => boolean;
+    getRectangle: (element: PlaitElement) => RectangleClient | null;
+    isWithinSelection: (element: PlaitElement) => boolean;
+    pathRef: (path: Path, options?: PathRefOptions) => PathRef;
+    pathRefs: () => Set<PathRef>;
+    applyTheme: (element: PlaitElement) => void;
+    isAlign: (element: PlaitElement) => boolean;
+    isImageBindingAllowed: (element: PlaitElement) => boolean;
+    canAddToGroup: (element: PlaitElement) => boolean;
+    canSetZIndex: (element: PlaitElement) => boolean;
+    isExpanded: (element: PlaitElement) => boolean;
+    pointerDown: (pointer: PointerEvent) => void;
+    pointerMove: (pointer: PointerEvent) => void;
+    pointerUp: (pointer: PointerEvent) => void;
+    pointerCancel: (pointer: PointerEvent) => void;
+    pointerOut: (pointer: PointerEvent) => void;
+    pointerLeave: (pointer: PointerEvent) => void;
+    globalPointerMove: (pointer: PointerEvent) => void;
+    globalPointerUp: (pointer: PointerEvent) => void;
+    drop: (event: DragEvent) => boolean;
+    touchStart: (event: TouchEvent) => void;
+    touchMove: (event: TouchEvent) => void;
+    touchEnd: (event: TouchEvent) => void;
+}
+declare const PlaitBoard: {
+    isBoard(value: any): value is PlaitBoard;
+    isAlive(board: PlaitBoard): boolean;
+    findPath(board: PlaitBoard, node: PlaitNode): Path;
+    getHost(board: PlaitBoard): SVGSVGElement;
+    getElementLowerHost(board: PlaitBoard): SVGSVGElement;
+    getElementHost(board: PlaitBoard): SVGSVGElement;
+    getElementUpperHost(board: PlaitBoard): SVGSVGElement;
+    getElementTopHost(board: PlaitBoard): SVGSVGElement;
+    getActiveHost(board: PlaitBoard): SVGSVGElement;
+    getRoughSVG(board: PlaitBoard): RoughSVG;
+    getBoardContainer(board: PlaitBoard): HTMLElement;
+    getBoardContext(board: PlaitBoard): PlaitBoardContext;
+    getRectangle(board: PlaitBoard): RectangleClient;
+    getViewportContainer(board: PlaitBoard): HTMLElement;
+    isFocus(board: PlaitBoard): boolean;
+    isReadonly(board: PlaitBoard): boolean | undefined;
+    hasBeenTextEditing(board: PlaitBoard): boolean;
+    getPointer<T = PlaitPointerType>(board: PlaitBoard): T;
+    isPointer<T = PlaitPointerType>(board: PlaitBoard, pointer: T): boolean;
+    isInPointer<T = PlaitPointerType>(board: PlaitBoard, pointers: T[]): boolean;
+    getMovingPointInBoard(board: PlaitBoard): Point | undefined;
+    isMovingPointInBoard(board: PlaitBoard): boolean;
+    getThemeColors<T extends ThemeColor = ThemeColor>(board: PlaitBoard): T[];
+};
+
+declare enum Direction {
+    left = "left",
+    top = "top",
+    right = "right",
+    bottom = "bottom"
+}
+declare const isHorizontalDirection: (direction: Direction) => direction is Direction.left | Direction.right;
+declare const isVerticalDirection: (direction: Direction) => direction is Direction.top | Direction.bottom;
+type Vector = [number, number];
+type DirectionFactor = -1 | 0 | 1;
+type DirectionFactors = [DirectionFactor, DirectionFactor];
+
+interface PlaitGroup extends PlaitElement {
+    type: 'group';
+}
+declare const PlaitGroupElement: {
+    isGroup: (value: any) => value is PlaitGroup;
+};
+
+interface SVGArcCommand {
+    rx: number;
+    ry: number;
+    xAxisRotation: number;
+    largeArcFlag: 0 | 1;
+    sweepFlag: 0 | 1;
+    endX: number;
+    endY: number;
+}
+
+interface BeforeContextChange<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard> {
+    beforeContextChange: (value: PlaitPluginElementContext<T>) => void;
+}
+interface OnContextChanged<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard> {
+    onContextChanged: (value: PlaitPluginElementContext<T, K>, previous: PlaitPluginElementContext<T, K>) => void;
+}
+declare function hasBeforeContextChange<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard>(value: any): value is BeforeContextChange<T, K>;
+declare function hasOnContextChanged<T extends PlaitElement = PlaitElement, K extends PlaitBoard = PlaitBoard>(value: any): value is OnContextChanged<T, K>;
+
+interface GeneralTransforms {
+    transform: (board: PlaitBoard, op: PlaitOperation) => void;
+}
+declare const GeneralTransforms: GeneralTransforms;
+
+interface GroupTransforms {
+    addGroup: (board: PlaitBoard, elements?: PlaitElement[]) => void;
+    removeGroup: (board: PlaitBoard, elements?: PlaitElement[]) => void;
+}
+declare const GroupTransforms: {
+    addGroup: (board: PlaitBoard, elements?: PlaitElement[]) => void;
+    removeGroup: (board: PlaitBoard, elements?: PlaitElement[]) => void;
+};
+
+interface NodeTransforms {
+    insertNode: (board: PlaitBoard, node: PlaitNode, path: Path) => void;
+    setNode: (board: PlaitBoard, node: Partial<PlaitNode>, path: Path) => void;
+    removeNode: (board: PlaitBoard, path: Path) => void;
+    moveNode: (board: PlaitBoard, path: Path, newPath: Path) => void;
+}
+declare const NodeTransforms: NodeTransforms;
+
+interface SelectionTransforms {
+    setSelection: (board: PlaitBoard, selection: Selection | null) => void;
+    addSelectionWithTemporaryElements: (board: PlaitBoard, elements: PlaitElement[]) => void;
+}
+declare const SelectionTransforms: SelectionTransforms;
+
+interface ViewportTransforms {
+    setViewport: (board: PlaitBoard, viewport: Viewport) => void;
+}
+declare const ViewportTransforms: ViewportTransforms;
+
+interface ZIndexTransforms {
+    moveUp: (board: PlaitBoard) => void;
+    moveDown: (board: PlaitBoard) => void;
+    moveToTop: (board: PlaitBoard) => void;
+    moveToBottom: (board: PlaitBoard) => void;
+}
+declare const ZIndexTransforms: {
+    moveUp: (board: PlaitBoard) => void;
+    moveDown: (board: PlaitBoard) => void;
+    moveToTop: (board: PlaitBoard) => void;
+    moveToBottom: (board: PlaitBoard) => void;
+};
+
+declare function updateViewport(board: PlaitBoard, origination: Point, zoom?: number): void;
+declare function updateZoom(board: PlaitBoard, newZoom: number, center?: Point): void;
+declare function fitViewport(board: PlaitBoard): void;
+declare function fitViewportWidth(board: PlaitBoard, options: FitViewportOptions): void;
+/**
+ * apply theme to every element (remove element custom properties)
+ * invoke applyThemeColor
+ */
+declare function updateThemeColor(board: PlaitBoard, mode: ThemeColorMode): void;
+declare function moveToCenter(board: PlaitBoard, centerPoint: Point): void;
+declare const BoardTransforms: {
+    updatePointerType: <T extends string = PlaitPointerType>(board: PlaitBoard, pointer: T) => void;
+    updateViewport: typeof updateViewport;
+    fitViewport: typeof fitViewport;
+    updateZoom: typeof updateZoom;
+    updateThemeColor: typeof updateThemeColor;
+    fitViewportWidth: typeof fitViewportWidth;
+    moveToCenter: typeof moveToCenter;
+};
+
+declare const CoreTransforms: {
+    removeElements: (board: PlaitBoard, elements: PlaitElement[]) => void;
+};
+
+declare const Transforms: GeneralTransforms & ViewportTransforms & SelectionTransforms & NodeTransforms & GroupTransforms & ZIndexTransforms;
+
+declare function createBoard(children: PlaitElement[], options?: PlaitBoardOptions): PlaitBoard;
+
+declare function withBoard(board: PlaitBoard): PlaitBoard;
+
+declare const IS_HAND_MODE: WeakMap<PlaitBoard, boolean>;
+declare const isHandMode: (board: PlaitBoard) => boolean;
+declare function withHandPointer<T extends PlaitBoard>(board: T): T;
+
+declare function withHistory<T extends PlaitBoard>(board: T): T;
+
+declare const withHotkey: (board: PlaitBoard) => PlaitBoard;
+
+declare function withMoving(board: PlaitBoard): PlaitBoard;
+declare function withArrowMoving(board: PlaitBoard): PlaitBoard;
+declare function getSelectedTargetElements(board: PlaitBoard): PlaitElement[];
+declare function getValidElements(board: PlaitBoard, activeElements: PlaitElement[]): PlaitElement[];
+declare function updatePoints(board: PlaitBoard, activeElements: PlaitElement[], offsetX: number, offsetY: number): PlaitElement[];
+declare function drawPendingNodesG(board: PlaitBoard, activeElements: PlaitElement[], offsetX: number, offsetY: number): null;
+
+declare function withRelatedFragment(board: PlaitBoard): PlaitBoard;
+
+declare function withSelection(board: PlaitBoard): PlaitBoard;
+
+interface PlaitI18nBoard extends PlaitBoard {
+    getI18nValue: (key: string) => string | null;
+}
+declare const withI18n: (board: PlaitBoard) => PlaitI18nBoard;
+declare const getI18nValue: (board: PlaitBoard, key: string, defaultValue?: string) => string;
+
+/**
+ * 1.create board instance
+ * 2.build fake node weak map
+ */
+declare const createTestingBoard: (plugins: PlaitPlugin[], children: PlaitElement[], options?: PlaitBoardOptions) => _plait_core.PlaitBoard;
+
+declare const fakeNodeWeakMap: (object: PlaitNode | PlaitBoard) => void;
+declare const clearNodeWeakMap: (object: PlaitNode | PlaitBoard) => void;
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/** Modifier keys that may be held while typing. */
+interface ModifierKeys {
+    control?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * Creates a browser MouseEvent with the specified options.
+ * @docs-private
+ */
+declare function createMouseEvent(type: string, clientX?: number, clientY?: number, offsetX?: number, offsetY?: number, button?: number, modifiers?: ModifierKeys): MouseEvent;
+/**
+ * Creates a browser `PointerEvent` with the specified options. Pointer events
+ * by default will appear as if they are the primary pointer of their type.
+ * https://www.w3.org/TR/pointerevents2/#dom-pointerevent-isprimary.
+ *
+ * For example, if pointer events for a multi-touch interaction are created, the non-primary
+ * pointer touches would need to be represented by non-primary pointer events.
+ *
+ * @docs-private
+ */
+declare function createPointerEvent(type: string, clientX?: number, clientY?: number, offsetX?: number, offsetY?: number, options?: PointerEventInit): PointerEvent;
+/**
+ * Creates a browser TouchEvent with the specified pointer coordinates.
+ * @docs-private
+ */
+declare function createTouchEvent(type: string, pageX?: number, pageY?: number, clientX?: number, clientY?: number): UIEvent;
+/**
+ * Creates a keyboard event with the specified key and modifiers.
+ * @docs-private
+ */
+declare function createKeyboardEvent(type: string, keyCode?: number, key?: string, modifiers?: ModifierKeys): KeyboardEvent;
+/**
+ * Creates a fake event object with any desired event type.
+ * @docs-private
+ */
+declare function createFakeEvent(type: string, bubbles?: boolean, cancelable?: boolean, composed?: boolean): Event;
+declare function createModModifierKeys(): {
+    meta: boolean;
+    control?: undefined;
+} | {
+    control: boolean;
+    meta?: undefined;
+};
+
+declare class DebugGenerator {
+    private debugKey;
+    constructor(debugKey: string);
+    isDebug(): boolean;
+    clear(): void;
+    drawPolygon(board: PlaitBoard, points: Point[], options?: Options): SVGGElement | undefined;
+    drawLine(board: PlaitBoard, points: Point[], options?: Options): SVGGElement | undefined;
+    drawRectangle(board: PlaitBoard, data: Point[] | RectangleClient, options?: Options): SVGGElement | undefined;
+    drawCircles(board: PlaitBoard, points: Point[], diameter?: number, isCumulativeDiameter?: boolean, options?: Options): SVGGElement[] | undefined;
+}
+declare const createDebugGenerator: (debugKey: string) => DebugGenerator;
+declare const isDebug: (key?: string) => boolean;
+
+export { A, ACTIVE_MOVING_CLASS_NAME, ACTIVE_STROKE_WIDTH, ALT, APOSTROPHE, ATTACHED_ELEMENT_CLASS_NAME, AT_SIGN, B, BACKSLASH, BACKSPACE, BOARD_TO_AFTER_CHANGE, BOARD_TO_CONTEXT, BOARD_TO_ELEMENT_HOST, BOARD_TO_HOST, BOARD_TO_IS_SELECTION_MOVING, BOARD_TO_MOVING_ELEMENT, BOARD_TO_MOVING_POINT, BOARD_TO_MOVING_POINT_IN_BOARD, BOARD_TO_ON_CHANGE, BOARD_TO_ROUGH_SVG, BOARD_TO_SELECTED_ELEMENT, BOARD_TO_TEMPORARY_ELEMENTS, BOARD_TO_VIEWPORT_ORIGINATION, BoardTransforms, C, CAPS_LOCK, CLOSE_SQUARE_BRACKET, COMMA, CONTEXT_MENU, CONTROL, ColorfulThemeColor, CoreTransforms, CursorClass, D, DASH, DEFAULT_COLOR, DELETE, DOWN_ARROW, DRAG_SELECTION_PRESS_AND_MOVE_BUFFER, DarkThemeColor, DebugGenerator, DefaultThemeColor, Direction, E, EIGHT, ELEMENT_TO_REF, END, ENTER, EQUALS, ESCAPE, ElementFlavour, F, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, FF_EQUALS, FF_MINUS, FF_MUTE, FF_SEMICOLON, FF_VOLUME_DOWN, FF_VOLUME_UP, FIRST_MEDIA, FIVE, FLUSHING, FOUR, G, H, HISTORY, HIT_DISTANCE_BUFFER, HOME, HOST_CLASS_NAME, I, INSERT, IS_APPLE, IS_BOARD_ALIVE, IS_BOARD_CACHE, IS_CHROME, IS_CHROME_LEGACY, IS_DRAGGING, IS_EDGE_LEGACY, IS_FIREFOX, IS_HAND_MODE, IS_IOS, IS_MAC, IS_SAFARI, IS_TEXT_EDITABLE, IS_WINDOWS, J, K, KEY_TO_ELEMENT_MAP, L, LAST_MEDIA, LEFT_ARROW, ListRender, M, MAC_ENTER, MAC_META, MAC_WK_CMD_LEFT, MAC_WK_CMD_RIGHT, MAX_RADIUS, MAX_ZOOM, MERGING, META, MIN_ZOOM, MUTE, N, NINE, NODE_TO_CONTAINER_G, NODE_TO_G, NODE_TO_INDEX, NODE_TO_PARENT, NS, NUMPAD_DIVIDE, NUMPAD_EIGHT, NUMPAD_FIVE, NUMPAD_FOUR, NUMPAD_MINUS, NUMPAD_MULTIPLY, NUMPAD_NINE, NUMPAD_ONE, NUMPAD_PERIOD, NUMPAD_PLUS, NUMPAD_SEVEN, NUMPAD_SIX, NUMPAD_THREE, NUMPAD_TWO, NUMPAD_ZERO, NUM_CENTER, NUM_LOCK, O, ONE, OPEN_SQUARE_BRACKET, P, PAGE_DOWN, PAGE_UP, PATH_REFS, PAUSE, PERIOD, PLUS_SIGN, POINTER_BUTTON, PRESS_AND_MOVE_BUFFER, PRINT_SCREEN, Path, PlaitBoard, PlaitBoardContext, PlaitElement, PlaitGroupElement, PlaitHistoryBoard, PlaitNode, PlaitOperation, PlaitPluginKey, PlaitPointerType, Point, Q, QUESTION_MARK, R, RESIZE_CURSORS, RESIZE_HANDLE_CLASS_NAME, RIGHT_ARROW, ROTATE_HANDLE_CLASS_NAME, RectangleClient, ResizeCursorClass, RetroThemeColor, S, SAVING, SCROLL_BAR_WIDTH, SCROLL_LOCK, SELECTION_BORDER_COLOR, SELECTION_FILL_COLOR, SELECTION_RECTANGLE_BOUNDING_CLASS_NAME, SELECTION_RECTANGLE_CLASS_NAME, SEMICOLON, SEVEN, SHIFT, SINGLE_QUOTE, SIX, SLASH, SNAPPING_STROKE_WIDTH, SNAP_TOLERANCE, SPACE, SPLITTING_ONCE, Selection, SoftThemeColor, StarryThemeColor, T, TAB, THREE, TILDE, TWO, ThemeColorMode, ThemeColors, Transforms, U, UP_ARROW, V, VIEWPORT_PADDING_RATIO, VOLUME_DOWN, VOLUME_UP, Viewport, W, WritableClipboardOperationType, WritableClipboardType, X, Y, Z, ZERO, ZOOM_STEP, addClipboardContext, addOrCreateClipboardContext, addSelectedElement, approximately, arrowPoints, buildPlaitHtml, cacheClipboardData, cacheMovingElements, cacheSelectedElements, cacheSelectedElementsWithGroup, cacheSelectedElementsWithGroupOnShift, calcNewViewBox, calculateViewBox, canAddGroup, canRemoveGroup, canSetZIndex, catmullRomFitting, ceilToDecimal, clampZoomLevel, clearNodeWeakMap, clearSelectedElement, clearSelectionMoving, clearViewportOrigination, createBoard, createClipboardContext, createDebugGenerator, createFakeEvent, createForeignObject, createG, createGroup, createGroupRectangleG, createKeyboardEvent, createMask, createModModifierKeys, createMouseEvent, createPath, createPointerEvent, createRect, createSVG, createTestingBoard, createText, createTouchEvent, debounce, degreesToRadians, deleteFragment, deleteTemporaryElements, depthFirstRecursion, distanceBetweenPointAndPoint, distanceBetweenPointAndRectangle, distanceBetweenPointAndSegment, distanceBetweenPointAndSegments, downloadImage, drawArrow, drawBezierPath, drawCircle, drawDashedLines, drawLine, drawLinearPath, drawPendingNodesG, drawPointSnapLines, drawRectangle, drawRoundRectangle, drawSelectionRectangleG, drawSolidLines, duplicateElements, fakeNodeWeakMap, filterSelectedGroups, findElements, findIndex, findLastIndex, getAllElementsInGroup, getAllGroups, getAllMoveOptions, getAngleBetweenPoints, getAngleByElement, getBarPoint, getBoardRectangle, getBoundingRectangleByElements, getCachedClipboardData, getClipboardData, getClipboardFromHtml, getCrossingPointsBetweenEllipseAndSegment, getDataTransferClipboard, getDataTransferClipboardText, getEditingGroup, getElementById, getElementHostBBox, getElementMap, getElementsInGroup, getElementsInGroupByElement, getElementsIndices, getEllipseArcCenter, getEllipseTangentSlope, getGroupByElement, getHighestGroup, getHighestIndexOfElement, getHighestSelectedElements, getHighestSelectedGroup, getHighestSelectedGroups, getHitElementByPoint, getHitElementsByPoint, getHitElementsBySelection, getHitSelectedElements, getI18nValue, getIsRecursionFunc, getMinPointDelta, getMovingElements, getNearestDelta, getNearestPointBetweenPointAndArc, getNearestPointBetweenPointAndDiscreteSegments, getNearestPointBetweenPointAndEllipse, getNearestPointBetweenPointAndSegment, getNearestPointBetweenPointAndSegments, getNearestPointRectangle, getOffsetAfterRotate, getOneMoveOptions, getPointBetween, getProbablySupportsClipboardRead, getProbablySupportsClipboardWrite, getProbablySupportsClipboardWriteText, getRealScrollBarWidth, getRectangleByAngle, getRectangleByElements, getRectangleByGroup, getRotatedBoundingRectangle, getSelectedElements, getSelectedGroups, getSelectedIsolatedElements, getSelectedIsolatedElementsCanAddToGroup, getSelectedTargetElements, getSelectionAngle, getSelectionOptions, getSnapRectangles, getTemporaryElements, getTemporaryRef, getTripleAxis, getValidElements, getVectorFromPointAndSlope, getViewBox, getViewBoxCenterPoint, getViewportContainerRect, getViewportOrigination, hasBeforeContextChange, hasInputOrTextareaTarget, hasOnContextChanged, hasSameAngle, hasSelectedElementsInSameGroup, hasSetSelectionOperation, hasValidAngle, hotkeys, idCreator, initializeViewBox, initializeViewportContainer, initializeViewportOffset, inverse, isAxisChangedByAngle, isContextmenu, isDOMElement, isDOMNode, isDebug, isDragging, isFromScrolling, isFromViewportChange, isHandMode, isHandleSelection, isHitElement, isHitSelectedRectangle, isHorizontalDirection, isInPlaitBoard, isInVisibleViewport, isIndicesContinuous, isLineHitLine, isLineHitRectangle, isLineHitRectangleEdge, isMainPointer, isMobileDeviceEvent, isMouseEvent, isMovingElements, isNullOrUndefined, isPencilEvent, isPointInEllipse, isPointInPolygon, isPointInRoundRectangle, isSecondaryPointer, isSelectedAllElementsInGroup, isSelectedElement, isSelectedElementOrGroup, isSelectionMoving, isSetSelectionOperation, isSetThemeOperation, isSetViewportOperation, isSingleLineHitRectangleEdge, isSnapPoint, isTouchDevice, isTouchEvent, isValidAngle, isVerticalDirection, isWheelPointer, mountElementG, moveElementsToNewPath, moveElementsToNewPathAfterAddGroup, nonGroupInHighestSelectedElements, normalizeAngle, normalizePoint, prepareElementBBox, radiansToDegrees, removeMovingElements, removeSelectedElement, replaceAngleBrackets, replaceSelectedElement, reverseReplaceAngleBrackets, rgbaToHEX, rotate, rotateAntiPointsByElement, rotateElements, rotatePoints, rotatePointsByAngle, rotatePointsByElement, rotatedDataPoints, scrollToVisibleWhenKeyboardOpening, setAngleForG, setClipboardData, setDataTransferClipboard, setDataTransferClipboardText, setDragging, setFragment, setIsFromScrolling, setIsFromViewportChange, setPathStrokeLinecap, setSVGViewBox, setSelectedElementsWithGroup, setSelectionMoving, setSelectionOptions, setStrokeLinecap, shouldClear, shouldMerge, shouldSave, sortElements, stripHtml, temporaryDisableSelection, throttleRAF, toActivePoint, toActivePointFromViewBoxPoint, toActiveRectangleFromViewBoxRectangle, toDomPrecision, toFixed, toHostPoint, toHostPointFromViewBoxPoint, toImage, toScreenPointFromActivePoint, toScreenPointFromHostPoint, toViewBoxPoint, toViewBoxPoints, uniqueById, updateForeignObject, updateForeignObjectWidth, updatePoints, updateViewBox, updateViewportByScrolling, updateViewportContainerScroll, updateViewportOffset, updateViewportOrigination, withArrowMoving, withBoard, withHandPointer, withHistory, withHotkey, withI18n, withMoving, withOptions, withRelatedFragment, withSelection };
+export type { Ancestor, BaseViewport, BeforeContextChange, ClipboardData, ComponentType, CustomTypes, DirectionFactor, DirectionFactors, ElementHostBBox, ExtendedType, FitViewportOptions, GapSnapRef, ImageEntry, InsertNodeOperation, MoveNodeOperation, MoveNodeOption, NodeParentsOptions, OnContextChanged, PathLevelsOptions, PlaitBoardMove, PlaitBoardOptions, PlaitChildrenContext, PlaitElementRef, PlaitGroup, PlaitHistory, PlaitI18nBoard, PlaitOperationInterface, PlaitOptionsBoard, PlaitPlugin, PlaitPluginElementContext, PlaitTheme, PointOfRectangle, RemoveNodeOperation, SVGArcCommand, SetNodeOperation, SetSelectionOperation, SetThemeOperation, SetViewportOperation, SnapDelta, SnapRef, ThemeColor, ToImageOptions, TreeNode, Vector, ViewBox, ViewportInterface, WithHandPluginOptions, WithPluginOptions, WithSelectionPluginOptions, WritableClipboardContext, WritableClipboardData, XYPosition };