js-draw 0.17.3 → 0.18.0

package/dist/mjs/src/toolbar/widgets/PenToolWidget.d.ts

@@ -0,0 +1,27 @@
+import { ComponentBuilderFactory } from '../../components/builders/types';
+import Editor from '../../Editor';
+import Pen from '../../tools/Pen';
+import { KeyPressEvent } from '../../types';
+import { ToolbarLocalization } from '../localization';
+import BaseToolWidget from './BaseToolWidget';
+import { SavedToolbuttonState } from './BaseWidget';
+export interface PenTypeRecord {
+    name: string;
+    id: string;
+    factory: ComponentBuilderFactory;
+}
+export default class PenToolWidget extends BaseToolWidget {
+    private tool;
+    private updateInputs;
+    protected penTypes: PenTypeRecord[];
+    constructor(editor: Editor, tool: Pen, localization?: ToolbarLocalization);
+    protected getTitle(): string;
+    private getCurrentPenTypeIdx;
+    private getCurrentPenType;
+    protected createIcon(): Element;
+    private static idCounter;
+    protected fillDropdown(dropdown: HTMLElement): boolean;
+    protected onKeyPress(event: KeyPressEvent): boolean;
+    serializeState(): SavedToolbuttonState;
+    deserializeFrom(state: SavedToolbuttonState): void;
+}

package/dist/{src/toolbar/widgets/PenToolWidget.js → mjs/src/toolbar/widgets/PenToolWidget.mjs}

@@ -1,13 +1,13 @@
-import { makeArrowBuilder } from '../../components/builders/ArrowBuilder';
-import { makeFreehandLineBuilder } from '../../components/builders/FreehandLineBuilder';
-import { makePressureSensitiveFreehandLineBuilder } from '../../components/builders/PressureSensitiveFreehandLineBuilder';
-import { makeLineBuilder } from '../../components/builders/LineBuilder';
-import { makeFilledRectangleBuilder, makeOutlinedRectangleBuilder } from '../../components/builders/RectangleBuilder';
-import { EditorEventType } from '../../types';
-import { toolbarCSSPrefix } from '../HTMLToolbar';
-import makeColorInput from '../makeColorInput';
-import BaseToolWidget from './BaseToolWidget';
-import Color4 from '../../Color4';
+import  { makeArrowBuilder }  from '../../components/builders/ArrowBuilder.mjs';
+import  { makeFreehandLineBuilder }  from '../../components/builders/FreehandLineBuilder.mjs';
+import  { makePressureSensitiveFreehandLineBuilder }  from '../../components/builders/PressureSensitiveFreehandLineBuilder.mjs';
+import  { makeLineBuilder }  from '../../components/builders/LineBuilder.mjs';
+import  { makeFilledRectangleBuilder, makeOutlinedRectangleBuilder }  from '../../components/builders/RectangleBuilder.mjs';
+import  { EditorEventType }  from '../../types.mjs';
+import  { toolbarCSSPrefix }  from '../HTMLToolbar.mjs';
+import  makeColorInput  from '../makeColorInput.mjs';
+import  BaseToolWidget  from './BaseToolWidget.mjs';
+import  Color4  from '../../Color4.mjs';
 export default class PenToolWidget extends BaseToolWidget {
     constructor(editor, tool, localization) {
         super(editor, tool, 'pen', localization);
@@ -97,6 +97,7 @@ export default class PenToolWidget extends BaseToolWidget {
     }
     fillDropdown(dropdown) {
         const container = document.createElement('div');
+        container.classList.add(`${toolbarCSSPrefix}spacedList`);
         const thicknessRow = document.createElement('div');
         const objectTypeRow = document.createElement('div');
         // Thickness: Value of the input is squared to allow for finer control/larger values.

package/dist/mjs/src/toolbar/widgets/SelectionToolWidget.d.ts

@@ -0,0 +1,13 @@
+import Editor from '../../Editor';
+import SelectionTool from '../../tools/SelectionTool/SelectionTool';
+import { KeyPressEvent } from '../../types';
+import { ToolbarLocalization } from '../localization';
+import BaseToolWidget from './BaseToolWidget';
+export default class SelectionToolWidget extends BaseToolWidget {
+    private tool;
+    constructor(editor: Editor, tool: SelectionTool, localization?: ToolbarLocalization);
+    private resizeImageToSelection;
+    protected onKeyPress(event: KeyPressEvent): boolean;
+    protected getTitle(): string;
+    protected createIcon(): Element;
+}

package/dist/{src/toolbar/widgets/SelectionToolWidget.js → mjs/src/toolbar/widgets/SelectionToolWidget.mjs}

@@ -7,14 +7,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import Color4 from '../../Color4';
-import { isRestylableComponent } from '../../components/RestylableComponent';
-import uniteCommands from '../../commands/uniteCommands';
-import { EditorEventType } from '../../types';
-import makeColorInput from '../makeColorInput';
-import ActionButtonWidget from './ActionButtonWidget';
-import BaseToolWidget from './BaseToolWidget';
-import BaseWidget from './BaseWidget';
+import  Color4  from '../../Color4.mjs';
+import  { isRestylableComponent }  from '../../components/RestylableComponent.mjs';
+import  uniteCommands  from '../../commands/uniteCommands.mjs';
+import  { EditorEventType }  from '../../types.mjs';
+import  makeColorInput  from '../makeColorInput.mjs';
+import  ActionButtonWidget  from './ActionButtonWidget.mjs';
+import  BaseToolWidget  from './BaseToolWidget.mjs';
+import  BaseWidget  from './BaseWidget.mjs';
 class RestyleSelectionWidget extends BaseWidget {
     constructor(editor, selectionTool, localizationTable) {
         super(editor, 'restyle-selection', localizationTable);

package/dist/mjs/src/toolbar/widgets/TextToolWidget.d.ts

@@ -0,0 +1,16 @@
+import Editor from '../../Editor';
+import TextTool from '../../tools/TextTool';
+import { ToolbarLocalization } from '../localization';
+import BaseToolWidget from './BaseToolWidget';
+import { SavedToolbuttonState } from './BaseWidget';
+export default class TextToolWidget extends BaseToolWidget {
+    private tool;
+    private updateDropdownInputs;
+    constructor(editor: Editor, tool: TextTool, localization?: ToolbarLocalization);
+    protected getTitle(): string;
+    protected createIcon(): Element;
+    private static idCounter;
+    protected fillDropdown(dropdown: HTMLElement): boolean;
+    serializeState(): SavedToolbuttonState;
+    deserializeFrom(state: SavedToolbuttonState): void;
+}

package/dist/{src/toolbar/widgets/TextToolWidget.js → mjs/src/toolbar/widgets/TextToolWidget.mjs}

@@ -1,8 +1,8 @@
-import Color4 from '../../Color4';
-import { EditorEventType } from '../../types';
-import { toolbarCSSPrefix } from '../HTMLToolbar';
-import makeColorInput from '../makeColorInput';
-import BaseToolWidget from './BaseToolWidget';
+import  Color4  from '../../Color4.mjs';
+import  { EditorEventType }  from '../../types.mjs';
+import  { toolbarCSSPrefix }  from '../HTMLToolbar.mjs';
+import  makeColorInput  from '../makeColorInput.mjs';
+import  BaseToolWidget  from './BaseToolWidget.mjs';
 export default class TextToolWidget extends BaseToolWidget {
     constructor(editor, tool, localization) {
         super(editor, tool, 'text-tool-widget', localization);
@@ -24,6 +24,8 @@ export default class TextToolWidget extends BaseToolWidget {
         return this.editor.icons.makeTextIcon(textStyle);
     }
     fillDropdown(dropdown) {
+        const container = document.createElement('div');
+        container.classList.add(`${toolbarCSSPrefix}spacedList`);
         const fontRow = document.createElement('div');
         const colorRow = document.createElement('div');
         const sizeRow = document.createElement('div');
@@ -83,7 +85,8 @@ export default class TextToolWidget extends BaseToolWidget {
             sizeInput.value = `${style.size}`;
         };
         this.updateDropdownInputs();
-        dropdown.replaceChildren(colorRow, sizeRow, fontRow);
+        container.replaceChildren(colorRow, sizeRow, fontRow);
+        dropdown.appendChild(container);
         return true;
     }
     serializeState() {

package/dist/mjs/src/toolbar/widgets/lib.mjs

@@ -0,0 +1,10 @@
+export  { default as ActionButtonWidget }  from './ActionButtonWidget.mjs';
+export  { default as BaseToolWidget }  from './BaseToolWidget.mjs';
+export  { default as BaseWidget }  from './BaseWidget.mjs';
+export  { default as PenToolWidget }  from './PenToolWidget.mjs';
+export  { default as TextToolWidget }  from './TextToolWidget.mjs';
+export  { default as HandToolWidget }  from './HandToolWidget.mjs';
+export  { default as SelectionToolWidget }  from './SelectionToolWidget.mjs';
+export  { default as EraserToolWidget }  from './EraserToolWidget.mjs';
+export  { default as InsertImageWidget }  from './InsertImageWidget.mjs';
+export  { default as DocumentPropertiesWidget }  from './DocumentPropertiesWidget.mjs';

package/dist/mjs/src/tools/BaseTool.d.ts

@@ -0,0 +1,22 @@
+import { PointerEvtListener, WheelEvt, PointerEvt, EditorNotifier, KeyPressEvent, KeyUpEvent, PasteEvent, CopyEvent } from '../types';
+import ToolEnabledGroup from './ToolEnabledGroup';
+export default abstract class BaseTool implements PointerEvtListener {
+    private notifier;
+    readonly description: string;
+    private enabled;
+    private group;
+    onPointerDown(_event: PointerEvt): boolean;
+    onPointerMove(_event: PointerEvt): void;
+    onPointerUp(_event: PointerEvt): void;
+    onGestureCancel(): void;
+    protected constructor(notifier: EditorNotifier, description: string);
+    onWheel(_event: WheelEvt): boolean;
+    onCopy(_event: CopyEvent): boolean;
+    onPaste(_event: PasteEvent): boolean;
+    onKeyPress(_event: KeyPressEvent): boolean;
+    onKeyUp(_event: KeyUpEvent): boolean;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    setToolGroup(group: ToolEnabledGroup): void;
+    getToolGroup(): ToolEnabledGroup | null;
+}

package/dist/{src/tools/BaseTool.js → mjs/src/tools/BaseTool.mjs}

@@ -1,4 +1,4 @@
-import { EditorEventType } from '../types';
+import  { EditorEventType }  from '../types.mjs';
 export default class BaseTool {
     onPointerDown(_event) { return false; }
     onPointerMove(_event) { }

package/dist/mjs/src/tools/Eraser.d.ts

@@ -0,0 +1,23 @@
+import { PointerEvt } from '../types';
+import BaseTool from './BaseTool';
+import Editor from '../Editor';
+export default class Eraser extends BaseTool {
+    private editor;
+    private lastPoint;
+    private isFirstEraseEvt;
+    private toRemove;
+    private thickness;
+    private partialCommands;
+    constructor(editor: Editor, description: string);
+    private clearPreview;
+    private getSizeOnCanvas;
+    private drawPreviewAt;
+    private getEraserRect;
+    private eraseTo;
+    onPointerDown(event: PointerEvt): boolean;
+    onPointerMove(event: PointerEvt): void;
+    onPointerUp(event: PointerEvt): void;
+    onGestureCancel(): void;
+    getThickness(): number;
+    setThickness(thickness: number): void;
+}

package/dist/{src/tools/Eraser.js → mjs/src/tools/Eraser.mjs}

@@ -1,11 +1,11 @@
-import { EditorEventType } from '../types';
-import BaseTool from './BaseTool';
-import { Vec2 } from '../math/Vec2';
-import LineSegment2 from '../math/LineSegment2';
-import Erase from '../commands/Erase';
-import { PointerDevice } from '../Pointer';
-import Color4 from '../Color4';
-import Rect2 from '../math/Rect2';
+import  { EditorEventType }  from '../types.mjs';
+import  BaseTool  from './BaseTool.mjs';
+import  { Vec2 }  from '../math/Vec2.mjs';
+import  LineSegment2  from '../math/LineSegment2.mjs';
+import  Erase  from '../commands/Erase.mjs';
+import  { PointerDevice }  from '../Pointer.mjs';
+import  Color4  from '../Color4.mjs';
+import  Rect2  from '../math/Rect2.mjs';
 export default class Eraser extends BaseTool {
     constructor(editor, description) {
         super(editor.notifier, description);

package/dist/mjs/src/tools/FindTool.d.ts

@@ -0,0 +1,21 @@
+import Editor from '../Editor';
+import { KeyPressEvent } from '../types';
+import BaseTool from './BaseTool';
+export declare const cssPrefix = "find-tool";
+export default class FindTool extends BaseTool {
+    private editor;
+    private overlay;
+    private searchInput;
+    private currentMatchIdx;
+    constructor(editor: Editor);
+    private getMatches;
+    private focusCurrentMatch;
+    private toNextMatch;
+    private toPrevMatch;
+    private fillOverlay;
+    private isVisible;
+    private setVisible;
+    private toggleVisible;
+    onKeyPress(event: KeyPressEvent): boolean;
+    setEnabled(enabled: boolean): void;
+}

package/dist/{src/tools/FindTool.js → mjs/src/tools/FindTool.mjs}

@@ -1,8 +1,8 @@
 // Displays a find dialog that allows the user to search for and focus text. 
 //
 // @packageDocumentation
-import TextComponent from '../components/TextComponent';
-import BaseTool from './BaseTool';
+import  TextComponent  from '../components/TextComponent.mjs';
+import  BaseTool  from './BaseTool.mjs';
 export const cssPrefix = 'find-tool';
 export default class FindTool extends BaseTool {
     constructor(editor) {

package/dist/mjs/src/tools/PanZoom.d.ts

@@ -0,0 +1,52 @@
+import { Editor } from '../Editor';
+import { Point2 } from '../math/Vec2';
+import Pointer from '../Pointer';
+import { KeyPressEvent, PointerEvt, WheelEvt } from '../types';
+import BaseTool from './BaseTool';
+interface PinchData {
+    canvasCenter: Point2;
+    screenCenter: Point2;
+    angle: number;
+    dist: number;
+}
+export declare enum PanZoomMode {
+    OneFingerTouchGestures = 1,
+    TwoFingerTouchGestures = 2,
+    RightClickDrags = 4,
+    SinglePointerGestures = 8,
+    Keyboard = 16,
+    RotationLocked = 32
+}
+export default class PanZoom extends BaseTool {
+    private editor;
+    private mode;
+    private transform;
+    private lastDist;
+    private lastScreenCenter;
+    private lastTimestamp;
+    private lastPointerDownTimestamp;
+    private initialTouchAngle;
+    private initialViewportRotation;
+    private inertialScroller;
+    private velocity;
+    constructor(editor: Editor, mode: PanZoomMode, description: string);
+    computePinchData(p1: Pointer, p2: Pointer): PinchData;
+    private allPointersAreOfType;
+    onPointerDown({ allPointers: pointers, current: currentPointer }: PointerEvt): boolean;
+    private updateVelocity;
+    private getCenterDelta;
+    private toSnappedRotationDelta;
+    private handleTwoFingerMove;
+    private handleOneFingerMove;
+    onPointerMove({ allPointers }: PointerEvt): void;
+    onPointerUp(event: PointerEvt): void;
+    onGestureCancel(): void;
+    private updateTransform;
+    onWheel({ delta, screenPos }: WheelEvt): boolean;
+    onKeyPress({ key, ctrlKey, altKey }: KeyPressEvent): boolean;
+    private isRotationLocked;
+    setModeEnabled(mode: PanZoomMode, enabled: boolean): void;
+    setMode(mode: PanZoomMode): void;
+    getMode(): PanZoomMode;
+}
+export {};

package/dist/{src/tools/PanZoom.js → mjs/src/tools/PanZoom.mjs}

@@ -7,14 +7,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import Mat33 from '../math/Mat33';
-import { Vec2 } from '../math/Vec2';
-import Vec3 from '../math/Vec3';
-import { PointerDevice } from '../Pointer';
-import { EditorEventType } from '../types';
-import untilNextAnimationFrame from '../util/untilNextAnimationFrame';
-import { Viewport } from '../Viewport';
-import BaseTool from './BaseTool';
+import  Mat33  from '../math/Mat33.mjs';
+import  { Vec2 }  from '../math/Vec2.mjs';
+import  Vec3  from '../math/Vec3.mjs';
+import  { PointerDevice }  from '../Pointer.mjs';
+import  { EditorEventType }  from '../types.mjs';
+import  untilNextAnimationFrame  from '../util/untilNextAnimationFrame.mjs';
+import  { Viewport }  from '../Viewport.mjs';
+import  BaseTool  from './BaseTool.mjs';
 export var PanZoomMode;
 (function (PanZoomMode) {
     PanZoomMode[PanZoomMode["OneFingerTouchGestures"] = 1] = "OneFingerTouchGestures";

package/dist/mjs/src/tools/PasteHandler.d.ts

@@ -0,0 +1,23 @@
+import Editor from '../Editor';
+import { PasteEvent } from '../types';
+import BaseTool from './BaseTool';
+/**
+ * A tool that handles paste events (e.g. as triggered by ctrl+V).
+ *
+ * @example
+ * While `ToolController` has a `PasteHandler` in its default list of tools,
+ * if a non-default set is being used, `PasteHandler` can be added as follows:
+ * ```ts
+ * const toolController = editor.toolController;
+ * toolController.addTool(new PasteHandler(editor));
+ * ```
+ */
+export default class PasteHandler extends BaseTool {
+    private editor;
+    constructor(editor: Editor);
+    onPaste(event: PasteEvent): boolean;
+    private addComponentsFromPaste;
+    private doSVGPaste;
+    private doTextPaste;
+    private doImagePaste;
+}

package/dist/{src/tools/PasteHandler.js → mjs/src/tools/PasteHandler.mjs}

@@ -7,13 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import TextComponent from '../components/TextComponent';
-import SVGLoader from '../SVGLoader';
-import Mat33 from '../math/Mat33';
-import BaseTool from './BaseTool';
-import TextTool from './TextTool';
-import Color4 from '../Color4';
-import ImageComponent from '../components/ImageComponent';
+import  TextComponent  from '../components/TextComponent.mjs';
+import  SVGLoader  from '../SVGLoader.mjs';
+import  Mat33  from '../math/Mat33.mjs';
+import  BaseTool  from './BaseTool.mjs';
+import  TextTool  from './TextTool.mjs';
+import  Color4  from '../Color4.mjs';
+import  ImageComponent  from '../components/ImageComponent.mjs';
 /**
  * A tool that handles paste events (e.g. as triggered by ctrl+V).
  *

package/dist/mjs/src/tools/Pen.d.ts

@@ -0,0 +1,39 @@
+import Color4 from '../Color4';
+import Editor from '../Editor';
+import Pointer from '../Pointer';
+import { KeyPressEvent, KeyUpEvent, PointerEvt, StrokeDataPoint } from '../types';
+import BaseTool from './BaseTool';
+import { ComponentBuilder, ComponentBuilderFactory } from '../components/builders/types';
+export interface PenStyle {
+    color: Color4;
+    thickness: number;
+}
+export default class Pen extends BaseTool {
+    private editor;
+    private style;
+    private builderFactory;
+    protected builder: ComponentBuilder | null;
+    private lastPoint;
+    private ctrlKeyPressed;
+    constructor(editor: Editor, description: string, style: PenStyle, builderFactory?: ComponentBuilderFactory);
+    private getPressureMultiplier;
+    protected toStrokePoint(pointer: Pointer): StrokeDataPoint;
+    protected previewStroke(): void;
+    protected addPointToStroke(point: StrokeDataPoint): void;
+    onPointerDown({ current, allPointers }: PointerEvt): boolean;
+    onPointerMove({ current }: PointerEvt): void;
+    onPointerUp({ current }: PointerEvt): void;
+    onGestureCancel(): void;
+    private finalizeStroke;
+    private noteUpdated;
+    setColor(color: Color4): void;
+    setThickness(thickness: number): void;
+    setStrokeFactory(factory: ComponentBuilderFactory): void;
+    getThickness(): number;
+    getColor(): Color4;
+    getStrokeFactory(): ComponentBuilderFactory;
+    setEnabled(enabled: boolean): void;
+    private isSnappingToGrid;
+    onKeyPress({ key, ctrlKey }: KeyPressEvent): boolean;
+    onKeyUp({ key }: KeyUpEvent): boolean;
+}

package/dist/{src/tools/Pen.js → mjs/src/tools/Pen.mjs}

@@ -1,8 +1,8 @@
-import EditorImage from '../EditorImage';
-import { PointerDevice } from '../Pointer';
-import { makeFreehandLineBuilder } from '../components/builders/FreehandLineBuilder';
-import { EditorEventType } from '../types';
-import BaseTool from './BaseTool';
+import  EditorImage  from '../EditorImage.mjs';
+import  { PointerDevice }  from '../Pointer.mjs';
+import  { makeFreehandLineBuilder }  from '../components/builders/FreehandLineBuilder.mjs';
+import  { EditorEventType }  from '../types.mjs';
+import  BaseTool  from './BaseTool.mjs';
 export default class Pen extends BaseTool {
     constructor(editor, description, style, builderFactory = makeFreehandLineBuilder) {
         super(editor.notifier, description);

package/dist/mjs/src/tools/PipetteTool.d.ts

@@ -0,0 +1,18 @@
+import Color4 from '../Color4';
+import Editor from '../Editor';
+import { PointerEvt } from '../types';
+import BaseTool from './BaseTool';
+type ColorListener = (color: Color4 | null) => void;
+export default class PipetteTool extends BaseTool {
+    private editor;
+    private colorPreviewListener;
+    private colorSelectListener;
+    constructor(editor: Editor, description: string);
+    setColorListener(colorPreviewListener: ColorListener, colorSelectListener: ColorListener): void;
+    clearColorListener(): void;
+    onPointerDown({ current, allPointers }: PointerEvt): boolean;
+    onPointerMove({ current }: PointerEvt): void;
+    onPointerUp({ current }: PointerEvt): void;
+    onGestureCancel(): void;
+}
+export {};

package/dist/{src/tools/PipetteTool.js → mjs/src/tools/PipetteTool.mjs}

@@ -1,5 +1,5 @@
 // @internal @packageDocumentation
-import BaseTool from './BaseTool';
+import  BaseTool  from './BaseTool.mjs';
 export default class PipetteTool extends BaseTool {
     constructor(editor, description) {
         super(editor.notifier, description);

package/dist/mjs/src/tools/SelectionTool/SelectAllShortcutHandler.d.ts

@@ -0,0 +1,8 @@
+import Editor from '../../Editor';
+import { KeyPressEvent } from '../../types';
+import BaseTool from '../BaseTool';
+export default class SelectAllShortcutHandler extends BaseTool {
+    private editor;
+    constructor(editor: Editor);
+    onKeyPress({ key, ctrlKey }: KeyPressEvent): boolean;
+}

package/dist/{src/tools/SelectionTool/SelectAllShortcutHandler.js → mjs/src/tools/SelectionTool/SelectAllShortcutHandler.mjs}

@@ -1,5 +1,5 @@
-import BaseTool from '../BaseTool';
-import SelectionTool from './SelectionTool';
+import  BaseTool  from '../BaseTool.mjs';
+import  SelectionTool  from './SelectionTool.mjs';
 // Handles ctrl+a: Select all
 export default class SelectAllShortcutHandler extends BaseTool {
     constructor(editor) {

package/dist/mjs/src/tools/SelectionTool/Selection.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @internal
+ * @packageDocumentation
+ */
+import Editor from '../../Editor';
+import Mat33 from '../../math/Mat33';
+import Rect2 from '../../math/Rect2';
+import { Point2 } from '../../math/Vec2';
+import Pointer from '../../Pointer';
+import AbstractComponent from '../../components/AbstractComponent';
+import Command from '../../commands/Command';
+export default class Selection {
+    private editor;
+    private handles;
+    private originalRegion;
+    private transformers;
+    private transform;
+    private selectedElems;
+    private container;
+    private backgroundElem;
+    private hasParent;
+    constructor(startPoint: Point2, editor: Editor);
+    getBackgroundElem(): HTMLElement;
+    getTransform(): Mat33;
+    get preTransformRegion(): Rect2;
+    get region(): Rect2;
+    /**
+     * Computes and returns the bounding box of the selection without
+     * any additional padding. Computes directly from the elements that are selected.
+     * @internal
+     */
+    computeTightBoundingBox(): Rect2;
+    get regionRotation(): number;
+    get preTransformedScreenRegion(): Rect2;
+    get preTransformedScreenRegionRotation(): number;
+    get screenRegion(): Rect2;
+    get screenRegionRotation(): number;
+    setTransform(transform: Mat33, preview?: boolean): void;
+    finalizeTransform(): void;
+    private static ApplyTransformationCommand;
+    private previewTransformCmds;
+    resolveToObjects(): boolean;
+    recomputeRegion(): boolean;
+    getMinCanvasSize(): number;
+    getSelectedItemCount(): number;
+    updateUI(): void;
+    private removedFromImage;
+    private addRemoveSelectionFromImage;
+    private removeDeletedElemsFromSelection;
+    private targetHandle;
+    private backgroundDragging;
+    onDragStart(pointer: Pointer, target: EventTarget): boolean;
+    onDragUpdate(pointer: Pointer): void;
+    onDragEnd(): void;
+    onDragCancel(): void;
+    scrollTo(): Promise<void>;
+    deleteSelectedObjects(): Command;
+    duplicateSelectedObjects(): Promise<Command>;
+    addTo(elem: HTMLElement): void;
+    setToPoint(point: Point2): void;
+    cancelSelection(): void;
+    setSelectedObjects(objects: AbstractComponent[], bbox: Rect2): void;
+    getSelectedObjects(): AbstractComponent[];
+}

package/dist/{src/tools/SelectionTool/Selection.js → mjs/src/tools/SelectionTool/Selection.mjs}

@@ -12,18 +12,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var _a;
-import SerializableCommand from '../../commands/SerializableCommand';
-import Mat33 from '../../math/Mat33';
-import Rect2 from '../../math/Rect2';
-import { Vec2 } from '../../math/Vec2';
-import SelectionHandle, { HandleShape, handleSize } from './SelectionHandle';
-import { cssPrefix } from './SelectionTool';
-import Viewport from '../../Viewport';
-import Erase from '../../commands/Erase';
-import Duplicate from '../../commands/Duplicate';
-import { DragTransformer, ResizeTransformer, RotateTransformer } from './TransformMode';
-import { ResizeMode } from './types';
-import EditorImage from '../../EditorImage';
+import  SerializableCommand  from '../../commands/SerializableCommand.mjs';
+import  Mat33  from '../../math/Mat33.mjs';
+import  Rect2  from '../../math/Rect2.mjs';
+import  { Vec2 }  from '../../math/Vec2.mjs';
+import  SelectionHandle, { HandleShape, handleSize }  from './SelectionHandle.mjs';
+import  { cssPrefix }  from './SelectionTool.mjs';
+import  Viewport  from '../../Viewport.mjs';
+import  Erase  from '../../commands/Erase.mjs';
+import  Duplicate  from '../../commands/Duplicate.mjs';
+import  { DragTransformer, ResizeTransformer, RotateTransformer }  from './TransformMode.mjs';
+import  { ResizeMode }  from './types.mjs';
+import  EditorImage  from '../../EditorImage.mjs';
 const updateChunkSize = 100;
 const maxPreviewElemCount = 500;
 // @internal

package/dist/mjs/src/tools/SelectionTool/SelectionHandle.d.ts

@@ -0,0 +1,38 @@
+import { Point2, Vec2 } from '../../math/Vec2';
+import Selection from './Selection';
+import Pointer from '../../Pointer';
+export declare enum HandleShape {
+    Circle = 0,
+    Square = 1
+}
+export declare const handleSize = 30;
+export type DragStartCallback = (startPoint: Point2) => void;
+export type DragUpdateCallback = (canvasPoint: Point2) => void;
+export type DragEndCallback = () => void;
+export default class SelectionHandle {
+    readonly shape: HandleShape;
+    private readonly parentSide;
+    private readonly parent;
+    private readonly onDragStart;
+    private readonly onDragUpdate;
+    private readonly onDragEnd;
+    private element;
+    private snapToGrid;
+    constructor(shape: HandleShape, parentSide: Vec2, parent: Selection, onDragStart: DragStartCallback, onDragUpdate: DragUpdateCallback, onDragEnd: DragEndCallback);
+    /**
+     * Adds this to `container`, where `conatiner` should be the background/selection
+     * element visible on the screen.
+     */
+    addTo(container: HTMLElement): void;
+    updatePosition(): void;
+    /**
+     * @returns `true` if the given `EventTarget` matches this.
+     */
+    isTarget(target: EventTarget): boolean;
+    private dragLastPos;
+    handleDragStart(pointer: Pointer): void;
+    handleDragUpdate(pointer: Pointer): void;
+    handleDragEnd(): void;
+    setSnapToGrid(snap: boolean): void;
+    isSnappingToGrid(): boolean;
+}