js-draw 1.20.3 → 1.21.2

package/dist/cjs/tools/Eraser.js

@@ -1,295 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EraserMode = void 0;
-const types_1 = require("../types");
-const BaseTool_1 = __importDefault(require("./BaseTool"));
-const math_1 = require("@js-draw/math");
-const Erase_1 = __importDefault(require("../commands/Erase"));
-const Pointer_1 = require("../Pointer");
-const keybindings_1 = require("./keybindings");
-const ReactiveValue_1 = require("../util/ReactiveValue");
-const EditorImage_1 = __importDefault(require("../image/EditorImage"));
-const uniteCommands_1 = __importDefault(require("../commands/uniteCommands"));
-const RenderablePathSpec_1 = require("../rendering/RenderablePathSpec");
-var EraserMode;
-(function (EraserMode) {
-    EraserMode["PartialStroke"] = "partial-stroke";
-    EraserMode["FullStroke"] = "full-stroke";
-})(EraserMode || (exports.EraserMode = EraserMode = {}));
-/** Handles switching from other primary tools to the eraser and back */
-class EraserSwitcher extends BaseTool_1.default {
-    constructor(editor, eraser) {
-        super(editor.notifier, editor.localization.changeTool);
-        this.editor = editor;
-        this.eraser = eraser;
-    }
-    onPointerDown(event) {
-        if (event.allPointers.length === 1 && event.current.device === Pointer_1.PointerDevice.Eraser) {
-            const toolController = this.editor.toolController;
-            const enabledPrimaryTools = toolController.getPrimaryTools().filter(tool => tool.isEnabled());
-            if (enabledPrimaryTools.length) {
-                this.previousEnabledTool = enabledPrimaryTools[0];
-            }
-            else {
-                this.previousEnabledTool = null;
-            }
-            this.previousEraserEnabledState = this.eraser.isEnabled();
-            this.eraser.setEnabled(true);
-            if (this.eraser.onPointerDown(event)) {
-                return true;
-            }
-            else {
-                this.restoreOriginalTool();
-            }
-        }
-        return false;
-    }
-    onPointerMove(event) {
-        this.eraser.onPointerMove(event);
-    }
-    restoreOriginalTool() {
-        this.eraser.setEnabled(this.previousEraserEnabledState);
-        if (this.previousEnabledTool) {
-            this.previousEnabledTool.setEnabled(true);
-        }
-    }
-    onPointerUp(event) {
-        this.eraser.onPointerUp(event);
-        this.restoreOriginalTool();
-    }
-    onGestureCancel(event) {
-        this.eraser.onGestureCancel(event);
-        this.restoreOriginalTool();
-    }
-}
-class Eraser extends BaseTool_1.default {
-    constructor(editor, description, options) {
-        super(editor.notifier, description);
-        this.editor = editor;
-        this.lastPoint = null;
-        this.isFirstEraseEvt = true;
-        this.toAdd = new Set();
-        // Commands that each remove one element
-        this.eraseCommands = [];
-        this.addCommands = [];
-        this.thickness = options?.thickness ?? 10;
-        this.thicknessValue = ReactiveValue_1.ReactiveValue.fromInitialValue(this.thickness);
-        this.thicknessValue.onUpdate(value => {
-            this.thickness = value;
-            this.editor.notifier.dispatch(types_1.EditorEventType.ToolUpdated, {
-                kind: types_1.EditorEventType.ToolUpdated,
-                tool: this,
-            });
-        });
-        this.modeValue = ReactiveValue_1.ReactiveValue.fromInitialValue(options?.mode ?? EraserMode.FullStroke);
-        this.modeValue.onUpdate(_value => {
-            this.editor.notifier.dispatch(types_1.EditorEventType.ToolUpdated, {
-                kind: types_1.EditorEventType.ToolUpdated,
-                tool: this,
-            });
-        });
-    }
-    /**
-     * @returns a tool that briefly enables the eraser when a physical eraser is used.
-     * This tool should be added to the tool list after the primary tools.
-     */
-    makeEraserSwitcherTool() {
-        return new EraserSwitcher(this.editor, this);
-    }
-    clearPreview() {
-        this.editor.clearWetInk();
-    }
-    getSizeOnCanvas() {
-        return this.thickness / this.editor.viewport.getScaleFactor();
-    }
-    drawPreviewAt(point) {
-        this.clearPreview();
-        const size = this.getSizeOnCanvas();
-        const renderer = this.editor.display.getWetInkRenderer();
-        const rect = this.getEraserRect(point);
-        const rect2 = this.getEraserRect(this.lastPoint ?? point);
-        const fill = {
-            fill: math_1.Color4.transparent,
-            stroke: { width: size / 10, color: math_1.Color4.gray },
-        };
-        renderer.drawPath((0, RenderablePathSpec_1.pathToRenderable)(math_1.Path.fromConvexHullOf([...rect.corners, ...rect2.corners]), fill));
-    }
-    /**
-     * @returns the eraser rectangle in canvas coordinates.
-     *
-     * For now, all erasers are rectangles or points.
-     */
-    getEraserRect(centerPoint) {
-        const size = this.getSizeOnCanvas();
-        const halfSize = math_1.Vec2.of(size / 2, size / 2);
-        return math_1.Rect2.fromCorners(centerPoint.minus(halfSize), centerPoint.plus(halfSize));
-    }
-    /** Erases in a line from the last point to the current. */
-    eraseTo(currentPoint) {
-        if (!this.isFirstEraseEvt && currentPoint.distanceTo(this.lastPoint) === 0) {
-            return;
-        }
-        this.isFirstEraseEvt = false;
-        // 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.
-        const eraserRect = this.getEraserRect(currentPoint);
-        const line = new math_1.LineSegment2(this.lastPoint, currentPoint);
-        const region = math_1.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.
-        const eraseableElems = intersectingElems.filter(elem => elem.isSelectable());
-        if (this.modeValue.get() === EraserMode.FullStroke) {
-            // Remove any intersecting elements.
-            this.toRemove.push(...eraseableElems);
-            // Create new Erase commands for the now-to-be-erased elements and apply them.
-            const newPartialCommands = eraseableElems.map(elem => new Erase_1.default([elem]));
-            newPartialCommands.forEach(cmd => cmd.apply(this.editor));
-            this.eraseCommands.push(...newPartialCommands);
-        }
-        else {
-            const toErase = [];
-            const toAdd = [];
-            for (const targetElem of eraseableElems) {
-                toErase.push(targetElem);
-                // Completely delete items that can't be divided.
-                if (!targetElem.withRegionErased) {
-                    continue;
-                }
-                // Completely delete items that are completely or almost completely
-                // contained within the eraser.
-                const grownRect = eraserRect.grownBy(eraserRect.maxDimension / 3);
-                if (grownRect.containsRect(targetElem.getExactBBox())) {
-                    continue;
-                }
-                // Join the current and previous rectangles so that points between events are also
-                // erased.
-                const erasePath = math_1.Path.fromConvexHullOf([
-                    ...eraserRect.corners, ...this.getEraserRect(this.lastPoint ?? currentPoint).corners
-                ].map(p => this.editor.viewport.roundPoint(p)));
-                toAdd.push(...targetElem.withRegionErased(erasePath, this.editor.viewport));
-            }
-            const eraseCommand = new Erase_1.default(toErase);
-            const newAddCommands = toAdd.map(elem => EditorImage_1.default.addElement(elem));
-            eraseCommand.apply(this.editor);
-            newAddCommands.forEach(command => command.apply(this.editor));
-            const finalToErase = [];
-            for (const item of toErase) {
-                if (this.toAdd.has(item)) {
-                    this.toAdd.delete(item);
-                }
-                else {
-                    finalToErase.push(item);
-                }
-            }
-            this.toRemove.push(...finalToErase);
-            for (const item of toAdd) {
-                this.toAdd.add(item);
-            }
-            this.eraseCommands.push(new Erase_1.default(finalToErase));
-            this.addCommands.push(...newAddCommands);
-        }
-        this.drawPreviewAt(currentPoint);
-        this.lastPoint = currentPoint;
-    }
-    onPointerDown(event) {
-        if (event.allPointers.length === 1 || event.current.device === Pointer_1.PointerDevice.Eraser) {
-            this.lastPoint = event.current.canvasPos;
-            this.toRemove = [];
-            this.toAdd.clear();
-            this.isFirstEraseEvt = true;
-            this.drawPreviewAt(event.current.canvasPos);
-            return true;
-        }
-        return false;
-    }
-    onPointerMove(event) {
-        const currentPoint = event.current.canvasPos;
-        this.eraseTo(currentPoint);
-    }
-    onPointerUp(event) {
-        this.eraseTo(event.current.canvasPos);
-        const commands = [];
-        if (this.addCommands.length > 0) {
-            this.addCommands.forEach(cmd => cmd.unapply(this.editor));
-            // Remove items from toAdd that are also present in toRemove -- adding, then
-            // removing these does nothing, and can break undo/redo.
-            for (const item of this.toAdd) {
-                if (this.toRemove.includes(item)) {
-                    this.toAdd.delete(item);
-                    this.toRemove = this.toRemove.filter(other => other !== item);
-                }
-            }
-            for (const item of this.toRemove) {
-                if (this.toAdd.has(item)) {
-                    this.toAdd.delete(item);
-                    this.toRemove = this.toRemove.filter(other => other !== item);
-                }
-            }
-            commands.push(...[...this.toAdd].map(a => EditorImage_1.default.addElement(a)));
-            this.addCommands = [];
-        }
-        if (this.eraseCommands.length > 0) {
-            // Undo commands for each individual component and unite into a single command.
-            this.eraseCommands.forEach(cmd => cmd.unapply(this.editor));
-            this.eraseCommands = [];
-            const command = new Erase_1.default(this.toRemove);
-            commands.push(command);
-        }
-        if (commands.length === 1) {
-            this.editor.dispatch(commands[0]); // dispatch: Makes undo-able.
-        }
-        else {
-            this.editor.dispatch((0, uniteCommands_1.default)(commands));
-        }
-        this.clearPreview();
-    }
-    onGestureCancel(_event) {
-        this.addCommands.forEach(cmd => cmd.unapply(this.editor));
-        this.eraseCommands.forEach(cmd => cmd.unapply(this.editor));
-        this.eraseCommands = [];
-        this.addCommands = [];
-        this.clearPreview();
-    }
-    onKeyPress(event) {
-        const shortcuts = this.editor.shortcuts;
-        let newThickness;
-        if (shortcuts.matchesShortcut(keybindings_1.decreaseSizeKeyboardShortcutId, event)) {
-            newThickness = this.getThickness() * 2 / 3;
-        }
-        else if (shortcuts.matchesShortcut(keybindings_1.increaseSizeKeyboardShortcutId, event)) {
-            newThickness = this.getThickness() * 3 / 2;
-        }
-        if (newThickness !== undefined) {
-            newThickness = Math.min(Math.max(1, newThickness), 200);
-            this.setThickness(newThickness);
-            return true;
-        }
-        return false;
-    }
-    /** Returns the side-length of the tip of this eraser. */
-    getThickness() {
-        return this.thickness;
-    }
-    /** Sets the side-length of this' tip. */
-    setThickness(thickness) {
-        this.thicknessValue.set(thickness);
-    }
-    /**
-     * Returns a {@link MutableReactiveValue} that can be used to watch
-     * this tool's thickness.
-     */
-    getThicknessValue() {
-        return this.thicknessValue;
-    }
-    getModeValue() {
-        return this.modeValue;
-    }
-}
-exports.default = Eraser;

package/dist/cjs/tools/Eraser.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,21 +0,0 @@
-import Editor from '../Editor';
-import { KeyPressEvent } from '../inputEvents';
-import BaseTool from './BaseTool';
-export default class FindTool extends BaseTool {
-    private editor;
-    private overlay;
-    private searchInput;
-    private currentMatchIdx;
-    constructor(editor: Editor);
-    canReceiveInputInReadOnlyEditor(): boolean;
-    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/cjs/tools/FindTool.js

@@ -1,137 +0,0 @@
-"use strict";
-// Displays a find dialog that allows the user to search for and focus text.
-//
-// @packageDocumentation
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const TextComponent_1 = __importDefault(require("../components/TextComponent"));
-const ImageComponent_1 = __importDefault(require("../components/ImageComponent"));
-const BaseTool_1 = __importDefault(require("./BaseTool"));
-const keybindings_1 = require("./keybindings");
-const cssPrefix = 'find-tool';
-class FindTool extends BaseTool_1.default {
-    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`);
-    }
-    canReceiveInputInReadOnlyEditor() {
-        return true;
-    }
-    getMatches(searchFor) {
-        const lowerSearchFor = searchFor.toLocaleLowerCase();
-        const matchingComponents = this.editor.image.getAllElements().filter(component => {
-            let text = '';
-            if (component instanceof TextComponent_1.default) {
-                text = component.getText();
-            }
-            else if (component instanceof ImageComponent_1.default) {
-                text = component.getAltText() ?? '';
-            }
-            else {
-                return false;
-            }
-            const hasLowercaseMatch = text.toLocaleLowerCase().indexOf(lowerSearchFor) !== -1;
-            const hasSameCaseMatch = text.indexOf(searchFor) !== -1;
-            return hasLowercaseMatch || hasSameCaseMatch;
-        });
-        return matchingComponents.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) {
-            const undoable = false;
-            void this.editor.dispatch(this.editor.viewport.zoomTo(matches[matchIdx], true, true), undoable);
-            this.editor.announceForAccessibility(this.editor.localization.focusedFoundText(matchIdx + 1, matches.length));
-        }
-    }
-    toNextMatch() {
-        this.currentMatchIdx++;
-        this.focusCurrentMatch();
-    }
-    toPrevMatch() {
-        this.currentMatchIdx--;
-        this.focusCurrentMatch();
-    }
-    fillOverlay() {
-        const label = document.createElement('label');
-        this.searchInput = document.createElement('input');
-        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', `${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.closeDialog;
-        this.searchInput.onkeydown = (ev) => {
-            if (ev.key === 'Enter') {
-                if (ev.shiftKey) {
-                    this.toPrevMatch();
-                }
-                else {
-                    this.toNextMatch();
-                }
-            }
-            else if (ev.key === 'Escape') {
-                this.setVisible(false);
-            }
-            else if (this.editor.shortcuts.matchesShortcut(keybindings_1.toggleFindVisibleShortcutId, ev)) {
-                ev.preventDefault();
-                this.toggleVisible();
-            }
-        };
-        nextBtn.onclick = () => {
-            this.toNextMatch();
-        };
-        closeBtn.onclick = () => {
-            this.setVisible(false);
-        };
-        this.overlay.replaceChildren(label, this.searchInput, nextBtn, closeBtn);
-    }
-    isVisible() {
-        return this.overlay.style.display !== 'none';
-    }
-    setVisible(visible) {
-        if (visible !== this.isVisible()) {
-            this.overlay.style.display = visible ? 'block' : 'none';
-            if (visible) {
-                this.searchInput.focus();
-                this.editor.announceForAccessibility(this.editor.localization.findDialogShown);
-            }
-            else {
-                this.editor.focus();
-                this.editor.announceForAccessibility(this.editor.localization.findDialogHidden);
-            }
-        }
-    }
-    toggleVisible() {
-        this.setVisible(!this.isVisible());
-    }
-    onKeyPress(event) {
-        if (this.editor.shortcuts.matchesShortcut(keybindings_1.toggleFindVisibleShortcutId, event)) {
-            this.toggleVisible();
-            return true;
-        }
-        return false;
-    }
-    setEnabled(enabled) {
-        super.setEnabled(enabled);
-        if (this.isEnabled()) {
-            this.setVisible(false);
-        }
-    }
-}
-exports.default = FindTool;

package/dist/cjs/tools/FindTool.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,12 +0,0 @@
-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/cjs/tools/InputFilter/FunctionMapper.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const InputMapper_1 = __importDefault(require("./InputMapper"));
-/**
- * An `InputMapper` that applies a function to all events it receives.
- *
- * Useful for automated testing.
- */
-class FunctionMapper extends InputMapper_1.default {
-    constructor(fn) {
-        super();
-        this.fn = fn;
-    }
-    onEvent(event) {
-        return this.emit(this.fn(event));
-    }
-}
-exports.default = FunctionMapper;

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

@@ -1,23 +0,0 @@
-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/cjs/tools/InputFilter/InputMapper.js

@@ -1,38 +0,0 @@
-"use strict";
-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;
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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();
-exports.default = InputMapper;

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

@@ -1,15 +0,0 @@
-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/cjs/tools/InputFilter/InputPipeline.js

@@ -1,54 +0,0 @@
-"use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _InputPipeline_head, _InputPipeline_tail;
-Object.defineProperty(exports, "__esModule", { value: true });
-const InputMapper_1 = __importDefault(require("./InputMapper"));
-/**
- * The composition of multiple `InputMapper`s.
- */
-class InputPipeline extends InputMapper_1.default {
-    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();
-exports.default = InputPipeline;

package/dist/cjs/tools/InputFilter/InputPipeline.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,29 +0,0 @@
-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 {};