@kritzel/engine 0.4.31

package/dist/types/classes/structures/quadtree.structure.d.ts

@@ -0,0 +1,128 @@
+import { KritzelBoundingBox } from '../../interfaces/bounding-box.interface';
+import { KritzelBaseObject } from '../objects/base-object.class';
+/**
+ * A quadtree data structure for efficient spatial indexing of objects.
+ * Quadtrees recursively subdivide 2D space into four quadrants to enable
+ * fast spatial queries like finding all objects within a given region.
+ *
+ * @template T - The type of objects stored in the quadtree, must extend KritzelBaseObject
+ */
+export declare class KritzelQuadtree<T extends KritzelBaseObject<any>> {
+    private bounds;
+    private capacity;
+    private objects;
+    private children;
+    private _size;
+    /**
+     * Total number of objects in the quadtree (O(1) access).
+     * @returns The count of all objects stored in this quadtree and its children
+     */
+    get size(): number;
+    /**
+     * Creates a new quadtree with the specified bounds and capacity.
+     *
+     * @param bounds - The bounding box defining the spatial region covered by this quadtree
+     * @param capacity - Maximum number of objects a node can hold before subdividing (default: 16)
+     */
+    constructor(bounds: KritzelBoundingBox, capacity?: number);
+    /**
+     * Resets the quadtree to its initial empty state.
+     * Clears all stored objects and removes all child nodes.
+     */
+    reset(): void;
+    /**
+     * Inserts an object into the quadtree.
+     * If the current node exceeds capacity, it will subdivide and delegate
+     * the insertion to the appropriate child quadrant.
+     *
+     * @param object - The object to insert, must have a rotatedBoundingBox property
+     * @returns `true` if the object was successfully inserted, `false` if it doesn't intersect the quadtree bounds
+     */
+    insert(object: T): boolean;
+    /**
+     * Updates an existing object in the quadtree by matching its ID.
+     * Searches through the tree to find the object and replaces it with the new reference.
+     * Note: This does not reposition the object if its bounding box has changed.
+     *
+     * @param object - The updated object with the same ID as the one to replace
+     * @returns `true` if the object was found and updated, `false` otherwise
+     */
+    update(object: T): boolean;
+    /**
+     * Reindexes an existing object by removing it from its current node and
+     * reinserting it based on its latest bounding box.
+     *
+     * @param object - The updated object to reindex
+     * @returns `true` if the object was found and reinserted, `false` otherwise
+     */
+    reindex(object: T): boolean;
+    /**
+     * Removes objects from the quadtree that match the given predicate.
+     * Recursively searches through all nodes and removes matching objects.
+     *
+     * @param predicate - A function that returns `true` for objects that should be removed
+     * @returns The total number of objects removed from the quadtree
+     */
+    remove(predicate: (object: T) => boolean): number;
+    /**
+     * Finds all objects whose bounding boxes intersect with the given range.
+     * This is the primary spatial query method for efficient object retrieval.
+     *
+     * @param range - The bounding box to query against
+     * @returns An array of all objects that intersect with the given range
+     */
+    query(range: KritzelBoundingBox): T[];
+    /**
+     * Internal method that collects query results into a pre-allocated array.
+     * Avoids creating intermediate arrays from spread operators.
+     *
+     * @param range - The bounding box to query against
+     * @param results - The array to collect matching objects into
+     */
+    private _queryInto;
+    /**
+     * Filters all objects in the quadtree using a custom predicate function.
+     * Unlike `query`, this method checks all objects regardless of spatial location.
+     *
+     * @param predicate - A function that returns `true` for objects to include in results
+     * @returns An array of all objects that satisfy the predicate
+     */
+    filter(predicate: (object: T) => boolean): T[];
+    /**
+     * Internal method that collects filter results into a pre-allocated array.
+     * Avoids creating intermediate arrays from spread operators.
+     *
+     * @param predicate - A function that returns `true` for objects to include
+     * @param results - The array to collect matching objects into
+     */
+    private _filterInto;
+    /**
+     * Retrieves all objects stored in the quadtree.
+     * Traverses the entire tree structure to collect every object.
+     *
+     * @returns An array containing all objects in the quadtree
+     */
+    allObjects(): T[];
+    /**
+     * Internal method that collects all objects into a pre-allocated array.
+     * Avoids creating intermediate arrays from spread operators.
+     *
+     * @param results - The array to collect all objects into
+     */
+    private _collectAllInto;
+    /**
+     * Subdivides this quadtree node into four child quadrants.
+     * Called automatically when the node's capacity is exceeded.
+     * Creates children for: Northwest (NW), Northeast (NE), Southwest (SW), Southeast (SE).
+     */
+    private subdivide;
+    /**
+     * Checks whether two bounding boxes intersect (overlap) each other.
+     * Uses axis-aligned bounding box (AABB) collision detection.
+     *
+     * @param a - The first bounding box
+     * @param b - The second bounding box
+     * @returns `true` if the bounding boxes overlap, `false` otherwise
+     */
+    private intersects;
+}

package/dist/types/classes/tools/base-tool.class.d.ts

@@ -0,0 +1,72 @@
+import { KritzelSerializable } from '../../interfaces/serializable.interface';
+import { KritzelToolType } from '../../interfaces/tool-type.interface';
+import { KritzelTool } from '../../interfaces/tool.interface';
+import { KritzelCore } from '../core/core.class';
+/**
+ * Abstract base class for all drawing tools in Kritzel.
+ * Provides common functionality and defines the interface that all tools must implement.
+ * Tools handle user interactions (pointer events, wheel events) and can be serialized/deserialized.
+ */
+export declare class KritzelBaseTool implements KritzelTool, KritzelSerializable {
+    /** Class name identifier used for serialization/deserialization */
+    __class__: string;
+    /** Identifies the tool type for config resolution (survives minification and dual-package bundling) */
+    toolType: KritzelToolType;
+    /** Human-readable name of the tool */
+    name: string;
+    /** Reference to the Kritzel core instance for accessing store, viewport, and other core functionality */
+    protected readonly _core: KritzelCore;
+    /**
+     * Creates a new instance of KritzelBaseTool.
+     * @param core - The KritzelCore instance that provides access to application state and functionality
+     */
+    constructor(core: KritzelCore);
+    /**
+     * Called when the tool becomes the active tool.
+     * Override in subclasses to perform initialization when the tool is selected.
+     */
+    onActivate(): void;
+    /**
+     * Called when the tool is deactivated (another tool becomes active).
+     * Override in subclasses to perform cleanup when the tool is deselected.
+     */
+    onDeactivate(): void;
+    /**
+     * Handles pointer down events (mouse click, touch start, pen down).
+     * Override in subclasses to implement tool-specific behavior when the user starts an interaction.
+     * @param _event - The PointerEvent containing information about the pointer (position, type, buttons, etc.)
+     */
+    handlePointerDown(_event: PointerEvent): void;
+    /**
+     * Handles pointer move events (mouse move, touch move, pen move).
+     * Override in subclasses to implement tool-specific behavior during dragging or hovering.
+     * @param _event - The PointerEvent containing information about the pointer (position, type, buttons, etc.)
+     */
+    handlePointerMove(_event: PointerEvent): void;
+    /**
+     * Handles pointer up events (mouse release, touch end, pen up).
+     * Override in subclasses to implement tool-specific behavior when the user ends an interaction.
+     * @param _event - The PointerEvent containing information about the pointer (position, type, buttons, etc.)
+     */
+    handlePointerUp(_event: PointerEvent): void;
+    /**
+     * Handles mouse wheel events for zooming or scrolling.
+     * Override in subclasses to implement tool-specific wheel behavior.
+     * @param _event - The WheelEvent containing scroll delta and modifier key information
+     */
+    handleWheel(_event: WheelEvent): void;
+    /**
+     * Serializes the tool to a plain object for persistence or transfer.
+     * @returns An object containing the tool's class name and name property
+     */
+    serialize(): {
+        __class__: string;
+        name: string;
+    };
+    /**
+     * Deserializes a plain object into this tool instance.
+     * @param object - The serialized tool data to restore
+     * @returns This tool instance with restored properties
+     */
+    deserialize(object: any): KritzelSerializable;
+}

package/dist/types/classes/tools/brush-tool.class.d.ts

@@ -0,0 +1,68 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+/**
+ * Brush tool for free-hand drawing on the canvas.
+ * Creates smooth paths by tracking pointer movement and rendering stroke paths.
+ * Supports mouse, touch, and pen input with configurable color, size, and opacity.
+ */
+export declare class KritzelBrushTool extends KritzelBaseTool {
+    toolType: "brush";
+    /** The color of the brush stroke (supports theme-aware light/dark colors) */
+    color: ThemeAwareColor;
+    /** The width of the brush stroke in pixels */
+    size: number;
+    /** The opacity of the brush stroke (0-1) */
+    opacity: number;
+    /** Available color palette for the brush tool */
+    palette: ThemeAwareColor[];
+    /** Available stroke size presets for the brush tool */
+    sizes: number[];
+    /**
+     * Minimum distance in screen pixels between two consecutive stored points.
+     * Pointer-move samples closer than this to the previously stored point are
+     * dropped. This shrinks the path's `points` array (which is fully
+     * re-serialized on every Yjs update during a stroke), reducing per-stroke
+     * websocket traffic without visible quality loss — `perfect-freehand`
+     * already smooths the rendered stroke.
+     */
+    static readonly MIN_POINT_DISTANCE_PX = 3;
+    /** Tracks the ID of the path currently being drawn */
+    private _currentPathId;
+    /**
+     * Returns true if (x, y) is far enough from the last stored point on
+     * `currentPath` to be appended. Distance is measured in the same coordinate
+     * system the points themselves are stored in (world units when
+     * lockDrawingScale is true, screen units otherwise), with the threshold
+     * scaled by `divider` so the filter is always ~1 screen pixel.
+     *
+     * Uses squared distance to avoid a per-move `Math.sqrt`.
+     */
+    private shouldAppendPoint;
+    /**
+     * Creates a new instance of KritzelBrushTool.
+     * @param core - The KritzelCore instance that provides access to application state and functionality
+     */
+    constructor(core: KritzelCore);
+    /**
+     * Handles pointer down events to start drawing a new path.
+     * Creates a new KritzelPath object at the pointer position and adds it to the canvas.
+     * Supports both mouse (left-click) and touch/pen input.
+     * @param event - The PointerEvent containing pointer position and input type information
+     */
+    handlePointerDown(event: PointerEvent): void;
+    /**
+     * Handles pointer move events to extend the current path while drawing.
+     * Adds new points to the current path as the pointer moves across the canvas.
+     * Only processes events when actively drawing (isDrawing state is true).
+     * @param event - The PointerEvent containing the current pointer position
+     */
+    handlePointerMove(event: PointerEvent): void;
+    /**
+     * Handles pointer up events to complete the current path.
+     * Marks the path as completed, updates the store, and emits an objects change event.
+     * Resets the drawing state and clears the current path reference.
+     * @param event - The PointerEvent indicating the end of the drawing gesture
+     */
+    handlePointerUp(event: PointerEvent): void;
+}

package/dist/types/classes/tools/eraser-tool.class.d.ts

@@ -0,0 +1,38 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+/**
+ * Eraser tool for removing objects from the canvas.
+ * Objects touched by the eraser during a drag gesture are marked for removal
+ * and deleted when the gesture completes. Supports mouse, touch, and pen input.
+ */
+export declare class KritzelEraserTool extends KritzelBaseTool {
+    toolType: "eraser";
+    /** Timeout handle for delayed touch start activation to prevent accidental erasing */
+    touchStartTimeout: any;
+    /**
+     * Creates a new instance of KritzelEraserTool.
+     * @param core - The KritzelCore instance that provides access to application state and functionality
+     */
+    constructor(core: KritzelCore);
+    /**
+     * Handles pointer down events to start the erasing gesture.
+     * For mouse input, immediately activates erasing on left-click.
+     * For touch/pen input, uses a delayed activation to prevent accidental erasing.
+     * @param event - The PointerEvent containing pointer position and input type information
+     */
+    handlePointerDown(event: PointerEvent): void;
+    /**
+     * Handles pointer move events to mark objects for removal during erasing.
+     * Performs hit testing on objects under the pointer and marks them for removal.
+     * Objects are visually indicated as being erased but not yet removed from the canvas.
+     * @param event - The PointerEvent containing the current pointer position
+     */
+    handlePointerMove(event: PointerEvent): void;
+    /**
+     * Handles pointer up events to complete the erasing gesture.
+     * Removes all objects that were marked for removal during the gesture.
+     * Clears the erasing state and emits an objects change event if any objects were removed.
+     * @param event - The PointerEvent indicating the end of the erasing gesture
+     */
+    handlePointerUp(event: PointerEvent): void;
+}

package/dist/types/classes/tools/image-tool.class.d.ts

@@ -0,0 +1,74 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+/**
+ * Image tool for importing and placing images on the canvas.
+ *
+ * Flow:
+ *   1. User picks a file.
+ *   2. Static images are compressed via `browser-image-compression` (bandwidth win).
+ *      GIF files retain their original bytes so animation is preserved.
+ *   3. Intrinsic dimensions are measured from a temporary object URL.
+ *   4. Bytes are uploaded through the asset resolver (write-through:
+ *      local IndexedDB immediately, remote providers in the background).
+ *   5. A `KritzelImage` is created carrying only the resulting asset id
+ *      and MIME type, then added to the canvas. The renderer resolves
+ *      the id to a URL via the asset resolver.
+ */
+export declare class KritzelImageTool extends KritzelBaseTool {
+    toolType: "image";
+    /** Hidden file input element for image selection */
+    fileInput: HTMLInputElement | null;
+    /** Maximum dimension (width or height) for image compression in pixels */
+    maxCompressionSize: number;
+    /** Diagonal offset (in world units) applied between images when multiple are imported at once */
+    multiImportOffset: number;
+    /**
+     * Creates a new instance of KritzelImageTool.
+     * Sets up the hidden file input element for image selection.
+     * @param core - The KritzelCore instance that provides access to application state and functionality
+     */
+    constructor(core: KritzelCore);
+    /**
+     * Called when the image tool becomes active.
+     * Automatically opens the file picker dialog.
+     */
+    onActivate(): void;
+    /**
+     * Opens the native file picker dialog for image selection.
+     * Does nothing if the canvas is in disabled state.
+     */
+    private openFilePicker;
+    /**
+     * Creates and configures the hidden file input element.
+     * Sets up event listeners for file selection and cancellation.
+     */
+    private setupFileInput;
+    /**
+     * Handles the file selection event from the file input.
+     * Compresses each selected image if necessaryand places them as a batch on the canvas.
+     * Resets the file input value after processing.
+     * @param event - The change event from the file input element
+     */
+    private handleFileSelect;
+    /**
+     * Prepares an image file for insertion by compressing it if necessary.
+     * @param file
+     * @returns
+     */
+    private prepareImageFile;
+    /**
+     * Adds a batch of prepared images to the canvas store and switches
+     * to the selection tool. The first image is centered in the viewport;
+     * each subsequent image is offset diagonally so multiple imports do
+     * not fully overlap. All images are selected together and a single
+     * batch change/added event is emitted.
+     *
+     * @param images - The prepared `KritzelImage` objects to add
+     */
+    private addImagesToStore;
+    /**
+     * Handles cancellation of the file picker or errors during image processing.
+     * Switches back to the selection tool without adding any image.
+     */
+    private handleCancel;
+}

package/dist/types/classes/tools/line-tool.class.d.ts

@@ -0,0 +1,63 @@
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelCore } from '../core/core.class';
+import { LineArrowConfig } from '../../interfaces/arrow-head.interface';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+/**
+ * Line tool for drawing straight lines on the canvas.
+ * Creates lines by tracking the start and end points of a drag gesture.
+ * Supports configurable stroke color, width, opacity, and arrow heads.
+ * Automatically switches to selection tool after line completion.
+ */
+export declare class KritzelLineTool extends KritzelBaseTool {
+    toolType: "line";
+    /** The stroke color of the line (supports theme-aware light/dark colors) */
+    color: ThemeAwareColor;
+    /** The stroke width of the line in pixels */
+    size: number;
+    /** The opacity of the line (0-1) */
+    opacity: number;
+    /** Available color palette for the line tool */
+    palette: ThemeAwareColor[];
+    /** Available stroke size presets for the line tool */
+    sizes: number[];
+    /** Arrow head configuration for lines created with this tool */
+    arrows?: LineArrowConfig;
+    /** X coordinate of the line's starting point */
+    private _startX;
+    /** Y coordinate of the line's starting point */
+    private _startY;
+    /** Tracks the ID of the line currently being drawn */
+    private _currentLineId;
+    /**
+     * Creates a new instance of KritzelLineTool.
+     * @param core - The KritzelCore instance that provides access to application state and functionality
+     */
+    constructor(core: KritzelCore);
+    /**
+     * Handles pointer down events to start drawing a new line.
+     * Creates a new KritzelLine object at the pointer position with start and end points at the same location.
+     * Supports both mouse (left-click) and touch/pen input.
+     * @param event - The PointerEvent containing pointer position and input type information
+     */
+    handlePointerDown(event: PointerEvent): void;
+    /**
+     * Handles pointer move events to update the line's end point while drawing.
+     * Updates the current line's end coordinates to follow the pointer position.
+     * Only processes events when actively drawing (isDrawing state is true).
+     * @param event - The PointerEvent containing the current pointer position
+     */
+    handlePointerMove(event: PointerEvent): void;
+    /**
+     * Handles pointer up events to complete the current line.
+     * Marks the line as completed, updates the store, emits an objects change event,
+     * and switches to selection tool with the drawn line selected.
+     * @param event - The PointerEvent indicating the end of the drawing gesture
+     */
+    handlePointerUp(event: PointerEvent): void;
+    /**
+     * Creates a selection group with the drawn line, selects it, and switches to the selection tool.
+     * This provides immediate editing capability for the newly drawn line.
+     * @param line - The KritzelLine object to select
+     */
+    private selectLineAndSwitchTool;
+}

package/dist/types/classes/tools/selection-tool.class.d.ts

@@ -0,0 +1,188 @@
+import { KritzelMoveHandler } from '../handlers/move.handler';
+import { KritzelResizeHandler } from '../handlers/resize.handler';
+import { KritzelRotationHandler } from '../handlers/rotation.handler';
+import { KritzelSelectionHandler } from '../handlers/selection.handler';
+import { KritzelBaseTool } from './base-tool.class';
+import { KritzelHoverHandler } from '../handlers/hover.handler';
+import { KritzelCore } from '../core/core.class';
+import { KritzelLineHandleHandler } from '../handlers/line-handle.handler';
+import { ToolConfigDefinition } from '../../interfaces/tool-config.interface';
+import { ThemeAwareColor } from '../../constants/color-palette.constants';
+import { LineArrowConfig } from '../../interfaces/arrow-head.interface';
+/**
+ * Selection tool for selecting, moving, resizing, and rotating objects on the canvas.
+ * Provides comprehensive object manipulation capabilities including multi-select,
+ * property editing, and various transformation handles. Delegates specific interactions
+ * to specialized handlers (selection, move, resize, rotation, hover, line handle).
+ */
+export declare class KritzelSelectionTool extends KritzelBaseTool {
+    toolType: "selection";
+    /** Handler for selection box and object selection logic */
+    selectionHandler: KritzelSelectionHandler;
+    /** Handler for moving selected objects */
+    moveHandler: KritzelMoveHandler;
+    /** Handler for hover effects on objects */
+    hoverHandler: KritzelHoverHandler;
+    /** Handler for resizing selected objects */
+    resizeHandler: KritzelResizeHandler;
+    /** Handler for rotating selected objects */
+    rotationHandler: KritzelRotationHandler;
+    /** Handler for manipulating line start/end handles */
+    lineHandleHandler: KritzelLineHandleHandler;
+    /** Available color palette for selected objects */
+    palette: ThemeAwareColor[];
+    /**
+     * Stores a selection group that was cleared on the first finger-down of a
+     * potential pinch-zoom gesture, so it can be restored when the second finger
+     * arrives. Cleared when the touch interaction ends.
+     */
+    private _savedSelectionGroupForPinch;
+    /**
+     * Checks if there are any objects currently selected.
+     * @returns True if there are objects in the selection group, false otherwise
+     */
+    hasSelection(): boolean;
+    /**
+     * Gets the currently selected objects.
+     * @returns Array of selected objects, or empty array if no selection
+     */
+    getSelectedObjects(): any[];
+    /**
+     * Recursively flattens a collection of objects, expanding any groups into their children.
+     * @param objects - Array of objects that may include groups
+     * @returns Flattened array with all nested group children expanded
+     */
+    private flattenObjects;
+    /**
+     * Gets the primary color of the selected objects.
+     * Returns the fill color for paths, stroke for lines, font color for text, or stroke color for shapes.
+     */
+    get color(): ThemeAwareColor;
+    /**
+     * Sets the primary color of all selected objects.
+     * Updates the appropriate color property based on object type (fill, stroke, fontColor, strokeColor).
+     */
+    set color(value: ThemeAwareColor);
+    /**
+     * Gets the opacity of the first selected object.
+     * @returns The opacity value (0-1) or 1 if no selection
+     */
+    get opacity(): number;
+    /**
+     * Sets the opacity of all selected objects.
+     * @param value - The opacity value (0-1)
+     */
+    set opacity(value: number);
+    /**
+     * Gets the size (stroke width or font size) of the selected objects.
+     * Returns strokeWidth for paths/lines/shapes, fontSize for text objects.
+     */
+    get size(): number;
+    /**
+     * Sets the size (stroke width or font size) of all selected objects.
+     * Updates strokeWidth for paths/lines/shapes and fontSize for text objects.
+     * Refreshes selection group dimensions after updating.
+     */
+    set size(value: number);
+    /**
+     * Gets the fill color of the first selected shape.
+     * @returns The fill color or transparent if no shapes are selected
+     */
+    get fillColor(): ThemeAwareColor;
+    /**
+     * Sets the fill color of all selected shapes.
+     * Also updates the font color based on fill color contrast and syncs stroke color when fill is not transparent.
+     */
+    set fillColor(value: ThemeAwareColor);
+    /**
+     * Gets the font family of the first selected text or shape object.
+     * @returns The font family name or 'Arial' as default
+     */
+    get fontFamily(): string;
+    /**
+     * Sets the font family of all selected text and shape objects.
+     * Refreshes selection group dimensions after updating.
+     */
+    set fontFamily(value: string);
+    /**
+     * Gets the arrow configuration of the first selected line.
+     * @returns The arrow config or default disabled arrows if no lines are selected
+     */
+    get arrows(): LineArrowConfig;
+    /**
+     * Sets the arrow configuration of all selected lines.
+     * Refreshes selection group dimensions after updating.
+     */
+    set arrows(value: LineArrowConfig);
+    /**
+     * Generates a tool configuration definition based on the types of selected objects.
+     * Determines which controls should be shown in the UI based on whether the selection
+     * contains shapes, text, lines, images, or stroke-based objects.
+     * @returns Tool configuration for the UI, or null if nothing is selected
+     */
+    getToolConfig(): ToolConfigDefinition | null;
+    /**
+     * Refreshes the selection group's dimensions after object properties that affect size have changed.
+     * Uses requestAnimationFrame to ensure the DOM has been updated before measuring.
+     */
+    private refreshSelectionGroupDimensions;
+    constructor(core: KritzelCore);
+    /**
+     * Handles pointer down events for selection and manipulation.
+     * Determines the type of interaction (resize handle, rotation handle, line handle, or object)
+     * and delegates to the appropriate handler. Manages selection state and supports
+     * additive selection with Shift/Ctrl modifiers.
+     * @param event - The PointerEvent containing pointer position and input type information
+     */
+    handlePointerDown(event: PointerEvent): void;
+    /**
+     * Handles pointer move events during selection and manipulation.
+     * Delegates movement to the appropriate handler based on the current interaction state
+     * (line handle, move, hover, selection box, resize, or rotation).
+     * @param event - The PointerEvent containing the current pointer position
+     */
+    handlePointerMove(event: PointerEvent): void;
+    /**
+     * Handles pointer up events to complete selection and manipulation operations.
+     * Delegates to all handlers to finalize their respective operations.
+     * @param event - The PointerEvent indicating the end of the interaction
+     */
+    handlePointerUp(event: PointerEvent): void;
+    /**
+     * Gets the object at the pointer event location and wraps it in a selection group.
+     * Performs hit testing to ensure the pointer is actually over the object.
+     * @param event - The PointerEvent to get the object from
+     * @returns A KritzelSelectionGroup containing the object, or null if no object at that location
+     */
+    private getSelectedObject;
+    /**
+     * Determines the type of resize handle at the pointer location.
+     * @param event - The PointerEvent to check for handle type
+     * @returns The KritzelHandleType if a resize handle is at the location, undefined otherwise
+     */
+    private getHandleType;
+    /**
+     * Checks if a resize handle is at the pointer location.
+     * @param event - The PointerEvent to check
+     * @returns True if a resize handle overlay element is at the pointer location
+     */
+    private isHandleSelected;
+    /**
+     * Checks if a rotation handle is at the pointer location.
+     * @param event - The PointerEvent to check
+     * @returns True if a rotation handle overlay element is at the pointer location
+     */
+    private isRotationHandleSelected;
+    /**
+     * Checks if a line handle (start or end point) is at the pointer location.
+     * @param event - The PointerEvent to check
+     * @returns True if a line handle overlay element is at the pointer location
+     */
+    private isLineHandleSelected;
+    /**
+     * Determines the type of line handle (start or end) at the pointer location.
+     * @param event - The PointerEvent to check for line handle type
+     * @returns The LineHandleType if a line handle is at the location, undefined otherwise
+     */
+    private getLineHandleType;
+}