js-draw 0.25.1 → 1.0.1

package/dist/mjs/tools/Eraser.mjs

@@ -1,63 +1,50 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 import  { EditorEventType }  from '../types.mjs';
 import  BaseTool  from './BaseTool.mjs';
-import  { Vec2 }  from '../math/Vec2.mjs';
-import  LineSegment2  from '../math/shapes/LineSegment2.mjs';
+import { Vec2, LineSegment2, Color4, Rect2 } from '@js-draw/math';
 import  Erase  from '../commands/Erase.mjs';
 import  { PointerDevice }  from '../Pointer.mjs';
-import  Color4  from '../Color4.mjs';
-import  Rect2  from '../math/shapes/Rect2.mjs';
 import  { decreaseSizeKeyboardShortcutId, increaseSizeKeyboardShortcutId }  from './keybindings.mjs';
-var Eraser = /** @class */ (function (_super) {
-    __extends(Eraser, _super);
-    function Eraser(editor, description) {
-        var _this = _super.call(this, editor.notifier, description) || this;
-        _this.editor = editor;
-        _this.lastPoint = null;
-        _this.isFirstEraseEvt = true;
-        _this.thickness = 10;
+import  { ReactiveValue }  from '../util/ReactiveValue.mjs';
+export default class Eraser extends BaseTool {
+    constructor(editor, description) {
+        super(editor.notifier, description);
+        this.editor = editor;
+        this.lastPoint = null;
+        this.isFirstEraseEvt = true;
+        this.thickness = 10;
         // Commands that each remove one element
-        _this.partialCommands = [];
-        return _this;
+        this.partialCommands = [];
+        this.thicknessValue = ReactiveValue.fromInitialValue(this.thickness);
+        this.thicknessValue.onUpdate(value => {
+            this.thickness = value;
+            this.editor.notifier.dispatch(EditorEventType.ToolUpdated, {
+                kind: EditorEventType.ToolUpdated,
+                tool: this,
+            });
+        });
     }
-    Eraser.prototype.clearPreview = function () {
+    clearPreview() {
         this.editor.clearWetInk();
-    };
-    Eraser.prototype.getSizeOnCanvas = function () {
+    }
+    getSizeOnCanvas() {
         return this.thickness / this.editor.viewport.getScaleFactor();
-    };
-    Eraser.prototype.drawPreviewAt = function (point) {
+    }
+    drawPreviewAt(point) {
         this.clearPreview();
-        var size = this.getSizeOnCanvas();
-        var renderer = this.editor.display.getWetInkRenderer();
-        var rect = this.getEraserRect(point);
-        var fill = {
+        const size = this.getSizeOnCanvas();
+        const renderer = this.editor.display.getWetInkRenderer();
+        const rect = this.getEraserRect(point);
+        const fill = {
             fill: Color4.gray,
         };
         renderer.drawRect(rect, size / 4, fill);
-    };
-    Eraser.prototype.getEraserRect = function (centerPoint) {
-        var size = this.getSizeOnCanvas();
-        var halfSize = Vec2.of(size / 2, size / 2);
+    }
+    getEraserRect(centerPoint) {
+        const size = this.getSizeOnCanvas();
+        const halfSize = Vec2.of(size / 2, size / 2);
         return Rect2.fromCorners(centerPoint.minus(halfSize), centerPoint.plus(halfSize));
-    };
-    Eraser.prototype.eraseTo = function (currentPoint) {
-        var _a, _b;
-        var _this = this;
+    }
+    eraseTo(currentPoint) {
         if (!this.isFirstEraseEvt && currentPoint.minus(this.lastPoint).magnitude() === 0) {
             return;
         }
@@ -65,25 +52,25 @@ var Eraser = /** @class */ (function (_super) {
         // Currently only objects within eraserRect or that intersect a straight line
         // from the center of the current rect to the previous are erased. TODO: Erase
         // all objects as if there were pointerMove events between the two points.
-        var eraserRect = this.getEraserRect(currentPoint);
-        var line = new LineSegment2(this.lastPoint, currentPoint);
-        var region = Rect2.union(line.bbox, eraserRect);
-        var intersectingElems = this.editor.image.getElementsIntersectingRegion(region).filter(function (component) {
+        const eraserRect = this.getEraserRect(currentPoint);
+        const line = new LineSegment2(this.lastPoint, currentPoint);
+        const region = Rect2.union(line.bbox, eraserRect);
+        const intersectingElems = this.editor.image.getElementsIntersectingRegion(region).filter(component => {
             return component.intersects(line) || component.intersectsRect(eraserRect);
         });
         // Only erase components that could be selected (and thus interacted with)
         // by the user.
-        var toErase = intersectingElems.filter(function (elem) { return elem.isSelectable(); });
+        const toErase = intersectingElems.filter(elem => elem.isSelectable());
         // Remove any intersecting elements.
-        (_a = this.toRemove).push.apply(_a, toErase);
+        this.toRemove.push(...toErase);
         // Create new Erase commands for the now-to-be-erased elements and apply them.
-        var newPartialCommands = toErase.map(function (elem) { return new Erase([elem]); });
-        newPartialCommands.forEach(function (cmd) { return cmd.apply(_this.editor); });
-        (_b = this.partialCommands).push.apply(_b, newPartialCommands);
+        const newPartialCommands = toErase.map(elem => new Erase([elem]));
+        newPartialCommands.forEach(cmd => cmd.apply(this.editor));
+        this.partialCommands.push(...newPartialCommands);
         this.drawPreviewAt(currentPoint);
         this.lastPoint = currentPoint;
-    };
-    Eraser.prototype.onPointerDown = function (event) {
+    }
+    onPointerDown(event) {
         if (event.allPointers.length === 1 || event.current.device === PointerDevice.Eraser) {
             this.lastPoint = event.current.canvasPos;
             this.toRemove = [];
@@ -92,32 +79,30 @@ var Eraser = /** @class */ (function (_super) {
             return true;
         }
         return false;
-    };
-    Eraser.prototype.onPointerMove = function (event) {
-        var currentPoint = event.current.canvasPos;
+    }
+    onPointerMove(event) {
+        const currentPoint = event.current.canvasPos;
         this.eraseTo(currentPoint);
-    };
-    Eraser.prototype.onPointerUp = function (event) {
-        var _this = this;
+    }
+    onPointerUp(event) {
         this.eraseTo(event.current.canvasPos);
         if (this.toRemove.length > 0) {
             // Undo commands for each individual component and unite into a single command.
-            this.partialCommands.forEach(function (cmd) { return cmd.unapply(_this.editor); });
+            this.partialCommands.forEach(cmd => cmd.unapply(this.editor));
             this.partialCommands = [];
-            var command = new Erase(this.toRemove);
+            const command = new Erase(this.toRemove);
             this.editor.dispatch(command); // dispatch: Makes undo-able.
         }
         this.clearPreview();
-    };
-    Eraser.prototype.onGestureCancel = function () {
-        var _this = this;
-        this.partialCommands.forEach(function (cmd) { return cmd.unapply(_this.editor); });
+    }
+    onGestureCancel() {
+        this.partialCommands.forEach(cmd => cmd.unapply(this.editor));
         this.partialCommands = [];
         this.clearPreview();
-    };
-    Eraser.prototype.onKeyPress = function (event) {
-        var shortcuts = this.editor.shortcuts;
-        var newThickness;
+    }
+    onKeyPress(event) {
+        const shortcuts = this.editor.shortcuts;
+        let newThickness;
         if (shortcuts.matchesShortcut(decreaseSizeKeyboardShortcutId, event)) {
             newThickness = this.getThickness() * 2 / 3;
         }
@@ -130,17 +115,18 @@ var Eraser = /** @class */ (function (_super) {
             return true;
         }
         return false;
-    };
-    Eraser.prototype.getThickness = function () {
+    }
+    getThickness() {
         return this.thickness;
-    };
-    Eraser.prototype.setThickness = function (thickness) {
-        this.thickness = thickness;
-        this.editor.notifier.dispatch(EditorEventType.ToolUpdated, {
-            kind: EditorEventType.ToolUpdated,
-            tool: this,
-        });
-    };
-    return Eraser;
-}(BaseTool));
-export default Eraser;
+    }
+    /**
+     * Returns a {@link MutableReactiveValue} that can be used to watch
+     * this tool's thickness.
+     */
+    getThicknessValue() {
+        return this.thicknessValue;
+    }
+    setThickness(thickness) {
+        this.thicknessValue.set(thickness);
+    }
+}

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

@@ -1,5 +1,5 @@
 import Editor from '../Editor';
-import { KeyPressEvent } from '../types';
+import { KeyPressEvent } from '../inputEvents';
 import BaseTool from './BaseTool';
 export default class FindTool extends BaseTool {
     private editor;

package/dist/mjs/tools/FindTool.mjs

@@ -1,107 +1,89 @@
 // Displays a find dialog that allows the user to search for and focus text.
 //
 // @packageDocumentation
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 import  TextComponent  from '../components/TextComponent.mjs';
 import  BaseTool  from './BaseTool.mjs';
 import  { toggleFindVisibleShortcutId }  from './keybindings.mjs';
-var cssPrefix = 'find-tool';
-var FindTool = /** @class */ (function (_super) {
-    __extends(FindTool, _super);
-    function FindTool(editor) {
-        var _this = _super.call(this, editor.notifier, editor.localization.findLabel) || this;
-        _this.editor = editor;
-        _this.currentMatchIdx = 0;
-        _this.overlay = document.createElement('div');
-        _this.fillOverlay();
-        editor.createHTMLOverlay(_this.overlay);
-        _this.overlay.style.display = 'none';
-        _this.overlay.classList.add("".concat(cssPrefix, "-overlay"));
-        return _this;
+const cssPrefix = 'find-tool';
+export default class FindTool extends BaseTool {
+    constructor(editor) {
+        super(editor.notifier, editor.localization.findLabel);
+        this.editor = editor;
+        this.currentMatchIdx = 0;
+        this.overlay = document.createElement('div');
+        this.fillOverlay();
+        editor.createHTMLOverlay(this.overlay);
+        this.overlay.style.display = 'none';
+        this.overlay.classList.add(`${cssPrefix}-overlay`);
     }
-    FindTool.prototype.getMatches = function (searchFor) {
+    getMatches(searchFor) {
         searchFor = searchFor.toLocaleLowerCase();
-        var allTextComponents = this.editor.image.getAllElements()
-            .filter(function (elem) { return elem instanceof TextComponent; });
-        var matches = allTextComponents.filter(function (text) { return text.getText().toLocaleLowerCase().indexOf(searchFor) !== -1; });
-        return matches.map(function (match) { return match.getBBox(); });
-    };
-    FindTool.prototype.focusCurrentMatch = function () {
-        var matches = this.getMatches(this.searchInput.value);
-        var matchIdx = this.currentMatchIdx % matches.length;
+        const allTextComponents = this.editor.image.getAllElements()
+            .filter(elem => elem instanceof TextComponent);
+        const matches = allTextComponents.filter(text => text.getText().toLocaleLowerCase().indexOf(searchFor) !== -1);
+        return matches.map(match => match.getBBox());
+    }
+    focusCurrentMatch() {
+        const matches = this.getMatches(this.searchInput.value);
+        let matchIdx = this.currentMatchIdx % matches.length;
         if (matchIdx < 0) {
             matchIdx = matches.length + matchIdx;
         }
         if (matchIdx < matches.length) {
-            var undoable = false;
+            const undoable = false;
             this.editor.dispatch(this.editor.viewport.zoomTo(matches[matchIdx], true, true), undoable);
             this.editor.announceForAccessibility(this.editor.localization.focusedFoundText(matchIdx + 1, matches.length));
         }
-    };
-    FindTool.prototype.toNextMatch = function () {
+    }
+    toNextMatch() {
         this.currentMatchIdx++;
         this.focusCurrentMatch();
-    };
-    FindTool.prototype.toPrevMatch = function () {
+    }
+    toPrevMatch() {
         this.currentMatchIdx--;
         this.focusCurrentMatch();
-    };
-    FindTool.prototype.fillOverlay = function () {
-        var _this = this;
-        var label = document.createElement('label');
+    }
+    fillOverlay() {
+        const label = document.createElement('label');
         this.searchInput = document.createElement('input');
-        var nextBtn = document.createElement('button');
-        var closeBtn = document.createElement('button');
+        const nextBtn = document.createElement('button');
+        const closeBtn = document.createElement('button');
         // Math.random() ensures that the ID is unique (to allow us to refer to it
         // with an htmlFor).
-        this.searchInput.setAttribute('id', "".concat(cssPrefix, "-searchInput-").concat(Math.random()));
+        this.searchInput.setAttribute('id', `${cssPrefix}-searchInput-${Math.random()}`);
         label.htmlFor = this.searchInput.getAttribute('id');
         label.innerText = this.editor.localization.findLabel;
         nextBtn.innerText = this.editor.localization.toNextMatch;
-        closeBtn.innerText = this.editor.localization.closeFindDialog;
-        this.searchInput.onkeydown = function (ev) {
+        closeBtn.innerText = this.editor.localization.closeDialog;
+        this.searchInput.onkeydown = (ev) => {
             if (ev.key === 'Enter') {
                 if (ev.shiftKey) {
-                    _this.toPrevMatch();
+                    this.toPrevMatch();
                 }
                 else {
-                    _this.toNextMatch();
+                    this.toNextMatch();
                 }
             }
             else if (ev.key === 'Escape') {
-                _this.setVisible(false);
+                this.setVisible(false);
             }
-            else if (_this.editor.shortcuts.matchesShortcut(toggleFindVisibleShortcutId, ev)) {
+            else if (this.editor.shortcuts.matchesShortcut(toggleFindVisibleShortcutId, ev)) {
                 ev.preventDefault();
-                _this.toggleVisible();
+                this.toggleVisible();
             }
         };
-        nextBtn.onclick = function () {
-            _this.toNextMatch();
+        nextBtn.onclick = () => {
+            this.toNextMatch();
         };
-        closeBtn.onclick = function () {
-            _this.setVisible(false);
+        closeBtn.onclick = () => {
+            this.setVisible(false);
         };
         this.overlay.replaceChildren(label, this.searchInput, nextBtn, closeBtn);
-    };
-    FindTool.prototype.isVisible = function () {
+    }
+    isVisible() {
         return this.overlay.style.display !== 'none';
-    };
-    FindTool.prototype.setVisible = function (visible) {
+    }
+    setVisible(visible) {
         if (visible !== this.isVisible()) {
             this.overlay.style.display = visible ? 'block' : 'none';
             if (visible) {
@@ -113,23 +95,21 @@ var FindTool = /** @class */ (function (_super) {
                 this.editor.announceForAccessibility(this.editor.localization.findDialogHidden);
             }
         }
-    };
-    FindTool.prototype.toggleVisible = function () {
+    }
+    toggleVisible() {
         this.setVisible(!this.isVisible());
-    };
-    FindTool.prototype.onKeyPress = function (event) {
+    }
+    onKeyPress(event) {
         if (this.editor.shortcuts.matchesShortcut(toggleFindVisibleShortcutId, event)) {
             this.toggleVisible();
             return true;
         }
         return false;
-    };
-    FindTool.prototype.setEnabled = function (enabled) {
-        _super.prototype.setEnabled.call(this, enabled);
+    }
+    setEnabled(enabled) {
+        super.setEnabled(enabled);
         if (enabled) {
             this.setVisible(false);
         }
-    };
-    return FindTool;
-}(BaseTool));
-export default FindTool;
+    }
+}

package/dist/mjs/tools/InputFilter/FunctionMapper.d.ts

@@ -0,0 +1,12 @@
+import { InputEvt } from '../../inputEvents';
+import InputMapper from './InputMapper';
+/**
+ * An `InputMapper` that applies a function to all events it receives.
+ *
+ * Useful for automated testing.
+ */
+export default class FunctionMapper extends InputMapper {
+    private fn;
+    constructor(fn: (event: InputEvt) => InputEvt);
+    onEvent(event: InputEvt): boolean;
+}

package/dist/mjs/tools/InputFilter/FunctionMapper.mjs

@@ -0,0 +1,15 @@
+import  InputMapper  from './InputMapper.mjs';
+/**
+ * An `InputMapper` that applies a function to all events it receives.
+ *
+ * Useful for automated testing.
+ */
+export default class FunctionMapper extends InputMapper {
+    constructor(fn) {
+        super();
+        this.fn = fn;
+    }
+    onEvent(event) {
+        return this.emit(this.fn(event));
+    }
+}

package/dist/mjs/tools/InputFilter/InputMapper.d.ts

@@ -0,0 +1,23 @@
+import { InputEvt } from '../../inputEvents';
+type OnEventCallback = (event: InputEvt) => boolean;
+export interface InputEventListener {
+    onEvent: OnEventCallback;
+}
+/**
+ * Accepts input events and emits input events.
+ */
+export default abstract class InputMapper implements InputEventListener {
+    #private;
+    constructor();
+    setEmitListener(listener: InputEventListener | OnEventCallback | null): void;
+    protected emit(event: InputEvt): boolean;
+    /**
+     * @returns true if the given `event` should be considered "handled" by the app and thus not
+     * forwarded to other targets. For example, returning "true" for a touchpad pinch event prevents
+     * the pinch event from zooming the webpage.
+     *
+     * Generally, this should return the result of calling `this.emit` with some event.
+     */
+    abstract onEvent(event: InputEvt): boolean;
+}
+export {};

package/dist/mjs/tools/InputFilter/InputMapper.mjs

@@ -0,0 +1,36 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _InputMapper_listener;
+/**
+ * Accepts input events and emits input events.
+ */
+class InputMapper {
+    constructor() {
+        _InputMapper_listener.set(this, null);
+    }
+    // @internal
+    setEmitListener(listener) {
+        if (listener && typeof (listener) === 'object') {
+            __classPrivateFieldSet(this, _InputMapper_listener, (event) => {
+                return listener.onEvent(event) ?? false;
+            }, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _InputMapper_listener, listener, "f");
+        }
+    }
+    emit(event) {
+        return __classPrivateFieldGet(this, _InputMapper_listener, "f")?.call(this, event) ?? false;
+    }
+}
+_InputMapper_listener = new WeakMap();
+export default InputMapper;

package/dist/mjs/tools/InputFilter/InputPipeline.d.ts

@@ -0,0 +1,15 @@
+import { InputEvt } from '../../inputEvents';
+import InputMapper from './InputMapper';
+/**
+ * The composition of multiple `InputMapper`s.
+ */
+export default class InputPipeline extends InputMapper {
+    #private;
+    onEvent(event: InputEvt): boolean;
+    /**
+     * Adds a new `InputMapper` to the *tail* of this pipeline.
+     * Note that an instance of an `InputMapper` can only be used in a single
+     * pipeline.
+     */
+    addToTail(mapper: InputMapper): void;
+}

package/dist/mjs/tools/InputFilter/InputPipeline.mjs

@@ -0,0 +1,49 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _InputPipeline_head, _InputPipeline_tail;
+import  InputMapper  from './InputMapper.mjs';
+/**
+ * The composition of multiple `InputMapper`s.
+ */
+class InputPipeline extends InputMapper {
+    constructor() {
+        super(...arguments);
+        _InputPipeline_head.set(this, null);
+        _InputPipeline_tail.set(this, null);
+    }
+    onEvent(event) {
+        if (__classPrivateFieldGet(this, _InputPipeline_head, "f") === null) {
+            return this.emit(event);
+        }
+        else {
+            return __classPrivateFieldGet(this, _InputPipeline_head, "f").onEvent(event);
+        }
+    }
+    /**
+     * Adds a new `InputMapper` to the *tail* of this pipeline.
+     * Note that an instance of an `InputMapper` can only be used in a single
+     * pipeline.
+     */
+    addToTail(mapper) {
+        if (!__classPrivateFieldGet(this, _InputPipeline_tail, "f")) {
+            __classPrivateFieldSet(this, _InputPipeline_head, mapper, "f");
+            __classPrivateFieldSet(this, _InputPipeline_tail, __classPrivateFieldGet(this, _InputPipeline_head, "f"), "f");
+        }
+        else {
+            __classPrivateFieldGet(this, _InputPipeline_tail, "f").setEmitListener(mapper);
+            __classPrivateFieldSet(this, _InputPipeline_tail, mapper, "f");
+        }
+        __classPrivateFieldGet(this, _InputPipeline_tail, "f").setEmitListener(event => this.emit(event));
+    }
+}
+_InputPipeline_head = new WeakMap(), _InputPipeline_tail = new WeakMap();
+export default InputPipeline;

package/dist/mjs/tools/InputFilter/InputStabilizer.d.ts

@@ -0,0 +1,29 @@
+import { InputEvt } from '../../inputEvents';
+import InputMapper from './InputMapper';
+import Viewport from '../../Viewport';
+import Editor from '../../Editor';
+declare enum StabilizerType {
+    IntertialStabilizer = 0
+}
+interface InputStabilizerOptions {
+    kind: StabilizerType.IntertialStabilizer;
+    mass: number;
+    springConstant: number;
+    frictionCoefficient: number;
+    maxPointDist: number;
+    minSimilarityToFinalize: number;
+    inertiaFraction: number;
+    velocityDecayFactor: number;
+}
+export default class InputStabilizer extends InputMapper {
+    private viewport;
+    private readonly options;
+    private stabilizer;
+    private lastPointerEvent;
+    constructor(viewport: Viewport, options?: InputStabilizerOptions);
+    private mapPointerEvent;
+    private emitPointerMove;
+    onEvent(event: InputEvt): boolean;
+    static fromEditor(editor: Editor): InputStabilizer;
+}
+export {};