@yuzhouu/canvas-standard 0.1.0

package/_vendor/plugin-eraser/_vendor/canvas-core/shapes/shapeUtil.d.ts

@@ -0,0 +1,245 @@
+import { Box } from "../geometry/box";
+import { Mat } from "../geometry/mat";
+import { Vec } from "../geometry/vec";
+import type { Editor } from "../editor/editor";
+import type { CreateShapeInput, ShapeUpdate } from "../editor/commands/commands";
+import { type SelectionMirrorAxis } from "../editor/selection/selection";
+import type { SelectionBindingMiddleHandleAnchor, SelectionBindingSegment, SelectionBindingTerminalHandleAnchor, SelectionCustomHandleAnchor, SelectionHandle, SelectionResizeHandleId, SelectionResizeMode } from "../editor/selection/selection";
+import type { ShapeId, ShapeParentId, ShapeRecordBase } from "../schema/records";
+import { type ShapeTerminalBindingPort } from "../bindings/terminalPorts";
+import type { ChildTransformPolicy } from "./childTransformPolicy";
+export interface ShapeEditEndResult {
+    deleteShapeIds?: ShapeId[];
+}
+export interface ShapeEditEndInput {
+    editor: Editor;
+}
+export interface ShapeBindingPointInput {
+    editor: Editor;
+    rawPagePoint: Vec;
+    oppositePagePoint: Vec;
+}
+export interface ShapeSelectionResizeInput {
+    handleId: SelectionResizeHandleId;
+    isOnlyResizeTarget: boolean;
+    pageCenter: Vec;
+    selectionLocalBounds: Box;
+    scaleX: number;
+    scaleY: number;
+    isResizingFromCenter: boolean;
+    selectionRotation: number;
+    selectionRotationCenter: Vec;
+}
+export interface ShapeSelectionResizeCapabilityInput {
+    editor: Editor;
+    isOnlyResizeTarget: boolean;
+}
+export interface ShapeSelectionTransformCapabilityInput {
+    editor: Editor;
+    /** Set by aggregate capability checks; omitted by frame-only queries. */
+    isOnlyAffectedShape?: boolean;
+}
+export interface ShapeSelectionResizeModesInput extends ShapeSelectionResizeCapabilityInput {
+    handleId: SelectionResizeHandleId;
+}
+export type ShapeSelectionFlipAxis = SelectionMirrorAxis;
+export interface ShapeSelectionFlipInput {
+    axis: ShapeSelectionFlipAxis;
+    selectionBounds: Box;
+    selectionLocalBounds: Box;
+    selectionRotation: number;
+    selectionRotationCenter: Vec;
+}
+export type ShapeSelectionPagePoints = readonly [Vec, Vec];
+export interface ShapeSelectionPagePointsInput {
+    pagePoints: ShapeSelectionPagePoints;
+    pageMiddlePoint?: Vec;
+}
+export interface ShapeBrushWrapInput {
+    editor: Editor;
+    brushBounds: Box;
+    pageOutlineVertices: readonly Vec[];
+    pageBounds: Box | null;
+}
+export interface ShapeBrushSelectInput extends ShapeBrushWrapInput {
+    isWrapping: boolean;
+}
+export interface ShapeGroupingInput {
+    parentId: ShapeParentId;
+    parentLocalBounds: Box;
+}
+export interface ShapeLineSegmentHitTestInput {
+    editor?: Editor;
+    pageStart: Vec;
+    pageEnd: Vec;
+    pageMargin: number;
+    positionedStart: Vec;
+    positionedEnd: Vec;
+    positionedMargin: number;
+}
+export interface ShapeGeometryInput {
+    editor: Editor;
+}
+export interface ShapeClipboardCopyInput {
+    editor: Editor;
+    copiedShapeIds: ReadonlySet<ShapeId>;
+}
+export interface ShapeChildVisibilityInput {
+    editor: Editor;
+}
+export interface ShapeChildPlacementInput {
+    editor: Editor;
+    reason: "create" | "reparent";
+}
+export interface ShapePointHitTestInput extends ShapeGeometryInput {
+    pagePoint: Vec;
+    positionedPoint: Vec;
+}
+export interface ShapeTerminalBindingOutline {
+    points: readonly Vec[];
+    closed: boolean;
+}
+export type ShapeSnapPointKind = "corner" | "edge_midpoint" | "center" | "custom";
+export interface ShapeSnapPoint {
+    point: Vec;
+    kind?: ShapeSnapPointKind;
+    weight?: number;
+}
+export interface ShapeBoundsSnapGeometry {
+    points?: readonly ShapeSnapPoint[];
+}
+export interface ShapeHandleSnapContext {
+    shapeId: ShapeId;
+    handle: SelectionHandle;
+    currentPagePoint: Vec;
+}
+export interface ShapeHandleSnapGeometry {
+    points?: readonly ShapeSnapPoint[];
+    outline?: readonly Vec[] | null;
+    getSelfSnapPoints?(context: ShapeHandleSnapContext): readonly ShapeSnapPoint[];
+    getSelfSnapOutline?(context: ShapeHandleSnapContext): readonly Vec[] | null;
+}
+export interface ShapeSelectionHandleAnchorInput {
+    isOnlySelected: boolean;
+    editor: Editor;
+}
+export type ShapeSelectionFrameInput = ShapeSelectionTransformCapabilityInput;
+export interface ShapeHoverTargetInput {
+    editor: Editor;
+}
+export interface ShapeSelectionTranslateInput {
+    editor: Editor;
+}
+export interface ShapeSelectionOverlayInfoInput {
+    editor: Editor;
+}
+export interface ShapeLabelPathNearestPositionOptions {
+    hintPosition?: number;
+}
+/**
+ * A page-space path that can host a bound label. Positions are normalized by
+ * the owner-defined path measure so labels preserve their relative placement
+ * when the owner geometry changes.
+ */
+export interface ShapeLabelPathGeometry {
+    length: number;
+    defaultPosition: number;
+    getPointAt(position: number): Vec;
+    getNearestPosition(point: Vec, options?: ShapeLabelPathNearestPositionOptions): number;
+}
+export interface ShapeSelectionHandleAnchors {
+    terminalHandleAnchors: readonly SelectionBindingTerminalHandleAnchor[];
+    middleHandleAnchors: readonly SelectionBindingMiddleHandleAnchor[];
+    customHandleAnchors?: readonly SelectionCustomHandleAnchor[];
+}
+export interface ShapeSelectionPathStyle {
+    localPath: string;
+    localDecorationPaths: readonly string[];
+    localBounds: Box;
+    localToPage: Mat;
+    strokeWidth: number;
+    strokeDasharray?: string;
+}
+export interface ShapeSelectionOverlayInfo {
+    usesSelectionPathOverlay: boolean;
+    startPagePoint: Vec | null;
+    endPagePoint: Vec | null;
+    middlePagePoint: Vec | null;
+    path: string | null;
+    pathStyle: ShapeSelectionPathStyle | null;
+    pageClipPath?: string | null;
+    bindingSegments?: readonly SelectionBindingSegment[];
+}
+export declare abstract class ShapeUtil<S extends ShapeRecordBase = ShapeRecordBase> {
+    abstract readonly type: S["type"];
+    abstract getDefaultProps(): S["props"];
+    abstract validateProps(props: unknown): S["props"];
+    abstract getLocalBounds(shape: S): Box;
+    getPositionedBounds(shape: S): Box;
+    getRenderBounds(shape: S): Box;
+    getPointHitTestBounds(shape: S, _input?: ShapeGeometryInput): Box;
+    getExportBounds(shape: S): Box;
+    getChildClipLocalBounds(_shape: S): Box | null;
+    getChildClipLocalPolygons(shape: S): readonly (readonly Vec[])[] | null;
+    getChildExportClipLocalBounds(shape: S): Box | null;
+    getChildExportClipLocalPolygons(shape: S): readonly (readonly Vec[])[] | null;
+    getSelectionResizeLocalBounds(shape: S): Box;
+    resizeSelectionBounds(shape: S, input: ShapeSelectionResizeInput): ShapeUpdate;
+    getAllowedSelectionResizeModes(_shape: S, _input: ShapeSelectionResizeModesInput): readonly SelectionResizeMode[];
+    getSelectionResizeHandleIds(_shape: S, _input: ShapeSelectionResizeCapabilityInput): readonly SelectionResizeHandleId[];
+    flipSelectionBounds(shape: S, input: ShapeSelectionFlipInput): ShapeUpdate;
+    updateSelectionPagePoints(shape: S, _input: ShapeSelectionPagePointsInput): ShapeUpdate;
+    getSelectionPagePoints(_shape: S): ShapeSelectionPagePoints | null;
+    getSelectionPageMiddlePoint(_shape: S): Vec | null;
+    contributesToSelectionFrame(_shape: S, _input: ShapeSelectionFrameInput): boolean;
+    canParticipateInSelectionResize(_shape: S, _input: ShapeSelectionTransformCapabilityInput): boolean;
+    canParticipateInSelectionFlip(shape: S, input: ShapeSelectionTransformCapabilityInput): boolean;
+    canParticipateInSelectionRotation(_shape: S, _input: ShapeSelectionTransformCapabilityInput): boolean;
+    canUseSelectionResizeHandles(shape: S, input: ShapeSelectionFrameInput): boolean;
+    canUseSelectionRotateHandle(shape: S, input: ShapeSelectionFrameInput): boolean;
+    canParticipateInSelectionTranslation(_shape: S, _input: ShapeSelectionTranslateInput): boolean;
+    getSelectionTargetId(shape: S, _input: ShapeSelectionFrameInput): ShapeId;
+    getHoverTargetId(shape: S, _input: ShapeHoverTargetInput): ShapeId;
+    getHoverDecorationTargetId(shape: S, _input: ShapeHoverTargetInput): ShapeId;
+    getTranslateTargetId(shape: S, _input: ShapeSelectionTranslateInput): ShapeId;
+    isSelectionTransformContainer(_shape: S): boolean;
+    shouldRotateDescendants(shape: S): boolean;
+    shouldResizeDescendants(_shape: S): boolean;
+    getResizeToFitDescendantsProps(_shape: S, _descendantBounds: Box): S["props"] | null;
+    getMinimumChildCount(_shape: S): number;
+    contributesToExportBounds(_shape: S): boolean;
+    canUngroupChildren(_shape: S): boolean;
+    getGroupingShapeCreateInput(_input: ShapeGroupingInput): CreateShapeInput | null;
+    canStartTranslateFromSelectionBounds(_shape: S, _input: ShapeSelectionFrameInput): boolean;
+    canSnap(_shape: S, _input?: ShapeGeometryInput): boolean;
+    canSnapChildrenToSelf(_shape: S): boolean;
+    getBoundsSnapGeometry(_shape: S): ShapeBoundsSnapGeometry;
+    getHandleSnapGeometry(shape: S): ShapeHandleSnapGeometry;
+    getPositionedOutlineVertices(shape: S): Vec[];
+    getSelectionFramePositionedOutlineVertices(_shape: S, _input: ShapeSelectionFrameInput): Vec[] | null;
+    getSelectionHandleAnchors(_shape: S, _input: ShapeSelectionHandleAnchorInput): ShapeSelectionHandleAnchors;
+    getSelectionOverlayInfo(_shape: S, _input: ShapeSelectionOverlayInfoInput): ShapeSelectionOverlayInfo;
+    getLabelPathGeometry(_shape: S, _input: ShapeSelectionOverlayInfoInput): ShapeLabelPathGeometry | null;
+    isWrappedByBrush(_shape: S, input: ShapeBrushWrapInput): boolean;
+    canSelectByBrush(shape: S, input: ShapeBrushSelectInput): boolean;
+    /** Builds the local transform encoded by this record's transform fields. */
+    getLocalTransform(shape: S): Mat;
+    getPositionedTransform(shape: S): Mat;
+    canEdit(_shape: S): boolean;
+    canReceiveChildren(_shape: S): boolean;
+    getChildTransformPolicy(_shape: S): ChildTransformPolicy;
+    canReceiveChild(shape: S, _child: ShapeRecordBase): boolean;
+    isChildVisible(_shape: S, _child: ShapeRecordBase, _input: ShapeChildVisibilityInput): boolean;
+    getChildPlacementMeta(_shape: S, child: ShapeRecordBase, _input: ShapeChildPlacementInput): Record<string, unknown>;
+    canAutomaticallyReceiveChildren(shape: S): boolean;
+    canBeDirectlyBrushSelected(_shape: S): boolean;
+    canReceiveTerminalBinding(_shape: S, _input?: ShapeGeometryInput): boolean;
+    getTerminalBindingPorts(shape: S, input: ShapeGeometryInput): readonly ShapeTerminalBindingPort[];
+    getTerminalBindingOutlines(shape: S, input: ShapeGeometryInput): readonly ShapeTerminalBindingOutline[];
+    canCopyToClipboard(_shape: S, _input: ShapeClipboardCopyInput): boolean;
+    onEditEnd(_shape: S, _input: ShapeEditEndInput): ShapeEditEndResult | void;
+    hitTest(shape: S, positionedPoint: Vec, _input?: ShapePointHitTestInput): boolean;
+    hitTestBindingTarget(shape: S, positionedPoint: Vec, input?: ShapePointHitTestInput): boolean;
+    hitTestLineSegment(shape: S, input: ShapeLineSegmentHitTestInput): boolean;
+    resolveBindingPoint(shape: S, input: ShapeBindingPointInput): Vec;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/shapes/shapeUtilGeometry.d.ts

@@ -0,0 +1,6 @@
+import type { Box } from "../geometry/box";
+import { Vec } from "../geometry/vec";
+export declare function getBoxCorners(bounds: Box): Vec[];
+export declare function doesLineSegmentIntersectBox(start: Vec, end: Vec, bounds: Box): boolean;
+export declare function getOutlineBoundaryPoint(raw: Vec, opposite: Vec, outlineVertices: readonly Vec[]): Vec | null;
+export declare function getValidatedDimension(props: object, key: "w" | "h", fallback: number): number;

package/_vendor/plugin-eraser/_vendor/canvas-core/shapes/shapeUtilRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { ShapeRecordBase } from "../schema/records";
+import { ShapeUtil } from "./shapeUtil";
+export declare class ShapeUtilRegistry {
+    private readonly registry;
+    register<S extends ShapeRecordBase>(util: ShapeUtil<S>): void;
+    has(type: ShapeRecordBase["type"]): boolean;
+    values(): IterableIterator<ShapeUtil>;
+    get<S extends ShapeRecordBase>(type: S["type"]): ShapeUtil<S>;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/shapes/types.d.ts

@@ -0,0 +1,2 @@
+export type { BindingId, BindingRecord, DocumentId, DocumentMetadataRecord, PageRecord, PageId, EditorRecord, ShapeRecord, ShapeId, SessionRecord, } from "../schema/records";
+export { DEFAULT_DOCUMENT_ID, DEFAULT_PAGE_ID, DEFAULT_SESSION_ID, createDefaultDocument, createDefaultPage, createDefaultSession, isBindingRecord, isDocumentMetadataRecord, isPageRecord, isShapeRecord, isSessionRecord, } from "../schema/records";

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/hand/handTool.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from "../../editor/editor";
+import { StateNode } from "../stateNode";
+export declare class HandTool extends StateNode {
+    constructor(editor: Editor);
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/selectContainment.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from "../../editor/editor";
+import type { Vec } from "../../geometry/vec";
+import type { ShapeId, ShapeParentId } from "../../schema/records";
+/**
+ * Containment / reparenting helpers used by the translating gesture. These are
+ * pure with respect to the state node: they read and mutate editor state only,
+ * driven by the set of shape ids being dragged.
+ */
+export declare function getSharedCurrentParentId(editor: Editor, shapeIds: readonly ShapeId[]): ShapeParentId | null;
+export declare function resolveContainmentParentId(editor: Editor, shapeIds: readonly ShapeId[], pagePoint?: Vec): ShapeParentId | null;
+export declare function updateDropTarget(editor: Editor, shapeIds: readonly ShapeId[], pagePoint?: Vec): void;
+export declare function applyContainmentParent(editor: Editor, shapeIds: readonly ShapeId[], pagePoint?: Vec): void;

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/selectTool.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from "../../editor/editor";
+import { StateNode } from "../stateNode";
+export declare class SelectTool extends StateNode {
+    constructor(editor: Editor);
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/selectToolHelpers.d.ts

@@ -0,0 +1,170 @@
+import { Box } from "../../geometry/box";
+import { Mat } from "../../geometry/mat";
+import { Vec } from "../../geometry/vec";
+import type { ShapeUpdate } from "../../editor/commands/commands";
+import type { Editor } from "../../editor/editor";
+import type { PointerEditorEvent, TickEditorEvent } from "../../editor/events/events";
+import type { SelectionResizeHandleId, SelectionResizeMode, SelectionResizePointShapeSnapshot, SelectionResizeShapeSnapshot, SelectionRotationTransform, SelectionRotatePointShapeSnapshot, SelectionRotateShapeSnapshot } from "../../editor/selection/selection";
+import type { HandleSnapMode, HandleSnapSnapshot, ResizeSnapSnapshot, TranslateSnapSnapshot } from "../../editor/snapping/snapTypes";
+import type { PointerDragInteractionSession, SelectionHandleInteractionSession } from "../../editor/events/interactions";
+import type { ShapeId, ShapeRecord } from "../../schema/records";
+export declare const DRAG_START_DISTANCE_SCREEN = 3;
+export declare const DRAG_START_DISTANCE_SCREEN_SQUARED: number;
+export declare const ROTATION_SNAP_STEP: number;
+export declare const ROTATION_SOFT_SNAP_STEP: number;
+export declare const ROTATION_SOFT_SNAP_THRESHOLD: number;
+export declare const ROTATION_SOFT_SNAP_MAX_SCREEN_VELOCITY = 0.5;
+export declare const GROUP_CHILD_QUICK_SELECT_DURATION_MS = 250;
+export declare const TRANSLATE_SNAP_DISTANCE_SCREEN = 8;
+export declare const TRANSLATE_SNAP_MAX_SCREEN_VELOCITY = 0.5;
+export declare const RESIZE_SNAP_DISTANCE_SCREEN = 8;
+export declare const HANDLE_SNAP_DISTANCE_SCREEN = 8;
+export declare const TRANSLATE_OPERATION_KIND = "select.translate";
+export declare const RESIZE_OPERATION_KIND = "select.resize";
+export declare const ROTATE_OPERATION_KIND = "select.rotate";
+export type TranslateAxis = "x" | "y";
+export interface PointingCanvasInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+}
+export interface PointingShapeInfo {
+    shapeId: ShapeId;
+    translateTargetId: ShapeId;
+    originPagePoint: Vec;
+    originTimestamp: number;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+    wasSelected: boolean;
+    fromSelectionBounds: boolean;
+    quickClickSelectionTargetId: ShapeId | null;
+    dragSession: PointerDragInteractionSession | null;
+}
+export interface TranslatingShapeSnapshot {
+    id: ShapeId;
+    x: number;
+    y: number;
+    startLocalToPage: Mat;
+}
+export interface TranslatingInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    movingShapeIds: ShapeId[];
+    startBounds: Box | null;
+    snapSnapshot: TranslateSnapSnapshot;
+    snapRotation: number;
+    selectedShapes: TranslatingShapeSnapshot[];
+    updates: ShapeUpdate[];
+    lockedAxis: TranslateAxis | null;
+    lastDeltaX: number;
+    lastDeltaY: number;
+}
+export interface BrushInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    additiveSelection: boolean;
+}
+export interface PointingResizeHandleInfo {
+    handleId: SelectionResizeHandleId;
+    originPagePoint: Vec;
+    cursorHandleOffset: Vec;
+    previousSelection: ShapeId[];
+}
+export interface ResizingInfo extends PointingResizeHandleInfo {
+    startBounds: Box;
+    rotation: number;
+    rotationCenter: Vec;
+    aspectRatio: number;
+    snapSnapshot: ResizeSnapSnapshot;
+    shapes: SelectionResizeShapeSnapshot[];
+    pointShapes: SelectionResizePointShapeSnapshot[];
+    updates: ShapeUpdate[];
+    allowedResizeModes: readonly SelectionResizeMode[];
+    lastPagePointX: number;
+    lastPagePointY: number;
+    lastShiftKey: boolean;
+    lastAltKey: boolean;
+    lastAccelKey: boolean;
+}
+export interface PointingRotateHandleInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+}
+export interface RotatingInfo extends PointingRotateHandleInfo {
+    center: Vec;
+    startAngle: number;
+    initialSelectionRotation: number;
+    shapes: SelectionRotateShapeSnapshot[];
+    pointShapes: SelectionRotatePointShapeSnapshot[];
+    updates: ShapeUpdate[];
+    lastPointerX: number;
+    lastPointerY: number;
+    lastShiftKey: boolean;
+    lastAccelKey: boolean;
+}
+export interface PointingSelectionHandleInteractionInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    session: SelectionHandleInteractionSession;
+    snapSnapshot: HandleSnapSnapshot | null;
+}
+export interface DraggingPluginInteractionInfo {
+    originPagePoint: Vec;
+    previousSelection: ShapeId[];
+    session: PointerDragInteractionSession;
+    snapMode: HandleSnapMode;
+    snapSnapshot: HandleSnapSnapshot | null;
+    lastPagePointX: number;
+    lastPagePointY: number;
+    lastShiftKey: boolean;
+    lastAltKey: boolean;
+    lastAccelKey: boolean;
+}
+export interface SelectionDragInput {
+    pagePoint: Vec;
+    shiftKey: boolean;
+    altKey: boolean;
+    accelKey: boolean;
+    ctrlKey: boolean;
+}
+export type EdgeScrollTickMode = "always_apply" | "apply_after_scroll_or_without_screen_point" | "apply_after_scroll";
+export declare function getSelectionDragInputFromCurrentInputs(editor: Editor): SelectionDragInput | null;
+export declare function getSelectionDragInputForTick(editor: Editor, event: TickEditorEvent, mode: EdgeScrollTickMode): SelectionDragInput | null;
+export declare function applySelectionDragFromCurrentInputs(editor: Editor, apply: (input: SelectionDragInput) => void): void;
+export declare function createBrushBounds(origin: Vec, current: Vec): Box;
+export declare function hasExceededScreenDragThreshold(originScreenPoint: Vec, screenPoint: Vec): boolean;
+export declare function arePagePointsApproximatelyEqual(left: Vec, right: Vec): boolean;
+export declare function toggleIds(base: ShapeId[], toggled: ShapeId[]): ShapeId[];
+export declare function getOutermostSelectableShapeIds(editor: Editor, shapeIds: Iterable<ShapeId>): ShapeId[];
+export declare function getSelectableShapeIdForHit(editor: Editor, shapeId: ShapeId, selectedShapeIds: readonly ShapeId[]): ShapeId;
+export declare function getSelectedTransformAncestorIdForHit(editor: Editor, shapeId: ShapeId, selectedShapeIds: readonly ShapeId[]): ShapeId | null;
+export interface TransformDescendantAncestorPathEntry {
+    ancestorId: ShapeId;
+    childId: ShapeId;
+}
+export declare function getNearestTransformDescendantAncestorId(editor: Editor, shapeId: ShapeId): ShapeId | null;
+export declare function getTransformDescendantAncestorPath(editor: Editor, shapeId: ShapeId): TransformDescendantAncestorPathEntry[];
+export declare function isAdditiveSelectionActive({ shiftKey, accelKey, }: {
+    shiftKey: boolean;
+    accelKey: boolean;
+}): boolean;
+export declare function isBrushWrappingSelection({ ctrlKey }: {
+    ctrlKey: boolean;
+}): boolean;
+export declare function isQuickClick(info: PointingShapeInfo, event: PointerEditorEvent): boolean;
+export declare function normalizeAngle(angle: number): number;
+export declare function snapAngle(angle: number, step: number): number;
+export declare function getBoxCorners(bounds: Box): Vec[];
+export declare function getShapeSelectionResizePageOutlineVertices(editor: Editor, shape: ShapeRecord): Vec[];
+export declare function getResizedShapeUpdate(editor: Editor, shape: SelectionResizeShapeSnapshot, startBounds: Box, nextBounds: Box, scaleX: number, scaleY: number, handleId: SelectionResizeHandleId, isOnlyResizeTarget: boolean, isResizingFromCenter: boolean, rotationCenter: Vec, selectionRotation: number, update: ShapeUpdate): void;
+export declare function getSelectionTransform(rotationCenter: Vec, selectionRotation: number): SelectionRotationTransform;
+export declare function getResizedPagePointsUpdate(editor: Editor, shape: SelectionResizePointShapeSnapshot, startBounds: Box, nextBounds: Box, scaleX: number, scaleY: number, handleId: SelectionResizeHandleId, isResizingFromCenter: boolean, rotationCenter: Vec, selectionRotation: number, update: ShapeUpdate): void;
+export declare function getRotatedShapeUpdate(editor: Editor, shape: SelectionRotateShapeSnapshot, center: Vec, delta: number, update: ShapeUpdate): void;
+export declare function getRotatedPagePointsUpdate(editor: Editor, shape: SelectionRotatePointShapeSnapshot, center: Vec, delta: number, update: ShapeUpdate): void;
+export declare function createTranslatingUpdates(shapes: TranslatingShapeSnapshot[]): ShapeUpdate[];
+export declare function getTranslateShapeSnapshots(editor: Editor, selectedShapeIds: ShapeId[]): TranslatingShapeSnapshot[];
+export declare function isShapeWrappedByBrush(editor: Editor, brushBounds: Box, shapeId: ShapeId): boolean;
+export declare function shouldSelectShapeWithBrush(editor: Editor, brushBounds: Box, shapeId: ShapeId, isWrapping: boolean): boolean;
+export declare function isBrushSelectableShapeId(editor: Editor, shapeId: ShapeId): boolean;
+export declare function createResizingUpdates(shapes: SelectionResizeShapeSnapshot[], pointShapes: SelectionResizePointShapeSnapshot[]): ShapeUpdate[];
+export declare function createRotatingUpdates(shapes: SelectionRotateShapeSnapshot[], pointShapes: SelectionRotatePointShapeSnapshot[]): ShapeUpdate[];

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/brushingState.d.ts

@@ -0,0 +1,19 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../stateNode";
+import type { PointerEditorEvent, TickEditorEvent } from "../../../editor/events/events";
+import { type BrushInfo } from "../selectToolHelpers";
+import { InfoStateNode } from "./selectStateNode";
+export declare class BrushingState extends InfoStateNode<BrushInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onInfoEnter(): void;
+    protected onPointerMove(event: PointerEditorEvent): void;
+    protected onTick(event: TickEditorEvent): void;
+    protected onKeyDown(): void;
+    protected onKeyUp(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    private updateBrush;
+    private updateBrushFromInputs;
+    private complete;
+    private cancel;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/draggingPluginInteractionState.d.ts

@@ -0,0 +1,15 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../stateNode";
+import type { CancelEditorEvent, PointerEditorEvent } from "../../../editor/events/events";
+import { type DraggingPluginInteractionInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class DraggingPluginInteractionState extends DraggingStateNode<DraggingPluginInteractionInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected getOperationKind(info: DraggingPluginInteractionInfo): string;
+    protected onDragStart(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(event: CancelEditorEvent): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, shiftKey, altKey, accelKey, }: DragApplyInput): void;
+    private complete;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/idleState.d.ts

@@ -0,0 +1,8 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../stateNode";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+export declare class IdleState extends StateNode {
+    constructor(editor: Editor, parent: StateNode);
+    protected onEnter(): void;
+    protected onPointerDown(event: PointerEditorEvent): void;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/index.d.ts

@@ -0,0 +1,11 @@
+export { BrushingState } from "./brushingState";
+export { DraggingPluginInteractionState } from "./draggingPluginInteractionState";
+export { IdleState } from "./idleState";
+export { PointingCanvasState } from "./pointingCanvasState";
+export { PointingResizeHandleState } from "./pointingResizeHandleState";
+export { PointingRotateHandleState } from "./pointingRotateHandleState";
+export { PointingSelectionHandleInteractionState } from "./pointingSelectionHandleInteractionState";
+export { PointingShapeState } from "./pointingShapeState";
+export { ResizingState } from "./resizingState";
+export { RotatingState } from "./rotatingState";
+export { TranslatingState } from "./translatingState";

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/pointingCanvasState.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../stateNode";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+import { type PointingCanvasInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingCanvasState extends PointingStateNode<PointingCanvasInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(event: PointerEditorEvent): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/pointingResizeHandleState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../stateNode";
+import { type PointingResizeHandleInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingResizeHandleState extends PointingStateNode<PointingResizeHandleInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/pointingRotateHandleState.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../stateNode";
+import { type PointingRotateHandleInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingRotateHandleState extends PointingStateNode<PointingRotateHandleInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(): void;
+    protected onCancel(): void;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/pointingSelectionHandleInteractionState.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "../../../editor/editor";
+import type { CancelEditorEvent, EditorEventContext, PointerEditorEvent } from "../../../editor/events/events";
+import { StateNode } from "../../stateNode";
+import { type PointingSelectionHandleInteractionInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingSelectionHandleInteractionState extends PointingStateNode<PointingSelectionHandleInteractionInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onDragThresholdExceeded(): void;
+    protected onPointerUp(_event: PointerEditorEvent, context: EditorEventContext): void;
+    protected onCancel(event: CancelEditorEvent): void;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/pointingShapeState.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from "../../../editor/editor";
+import { StateNode } from "../../stateNode";
+import type { EditorEventContext, EditorEventRoutingEffect, PointerEditorEvent } from "../../../editor/events/events";
+import { type PointingShapeInfo } from "../selectToolHelpers";
+import { PointingStateNode } from "./selectStateNode";
+export declare class PointingShapeState extends PointingStateNode<PointingShapeInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected onInfoEnter(): void;
+    protected onDragThresholdExceeded(event: PointerEditorEvent): void;
+    protected onPointerUp(event: PointerEditorEvent, context: EditorEventContext): EditorEventRoutingEffect | void;
+    protected onCancel(): void;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/resizingState.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from "../../../editor/editor";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+import { StateNode } from "../../stateNode";
+import { type ResizingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class ResizingState extends DraggingStateNode<ResizingInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected getOperationKind(): string;
+    protected onDragStart(): void;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    protected onInfoExit(): void;
+    protected apply({ pagePoint, shiftKey, altKey, accelKey, }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}

package/_vendor/plugin-eraser/_vendor/canvas-core/tools/select/states/rotatingState.d.ts

@@ -0,0 +1,14 @@
+import type { Editor } from "../../../editor/editor";
+import type { PointerEditorEvent } from "../../../editor/events/events";
+import { StateNode } from "../../stateNode";
+import { type RotatingInfo } from "../selectToolHelpers";
+import { DraggingStateNode, type DragApplyInput } from "./selectStateNode";
+export declare class RotatingState extends DraggingStateNode<RotatingInfo> {
+    constructor(editor: Editor, parent: StateNode);
+    protected getOperationKind(): string;
+    protected onPointerUp(event: PointerEditorEvent): void;
+    protected onCancel(): void;
+    protected apply({ pagePoint, shiftKey, accelKey }: DragApplyInput): void;
+    private complete;
+    private cancel;
+}