js-draw 0.17.4 → 0.18.1

package/dist/src/EditorImage.d.ts

@@ -1,97 +0,0 @@
-import AbstractRenderer from './rendering/renderers/AbstractRenderer';
-import Viewport from './Viewport';
-import AbstractComponent from './components/AbstractComponent';
-import Rect2 from './math/Rect2';
-import RenderingCache from './rendering/caching/RenderingCache';
-import SerializableCommand from './commands/SerializableCommand';
-import EventDispatcher from './EventDispatcher';
-export declare const sortLeavesByZIndex: (leaves: Array<ImageNode>) => void;
-export declare enum EditorImageEventType {
-    ExportViewportChanged = 0
-}
-export type EditorImageNotifier = EventDispatcher<EditorImageEventType, {
-    image: EditorImage;
-}>;
-export default class EditorImage {
-    private root;
-    private background;
-    private componentsById;
-    /** Viewport for the exported/imported image. */
-    private importExportViewport;
-    readonly notifier: EditorImageNotifier;
-    constructor();
-    getBackgroundComponents(): AbstractComponent[];
-    findParent(elem: AbstractComponent): ImageNode | null;
-    queueRerenderOf(elem: AbstractComponent): void;
-    /** @internal */
-    renderWithCache(screenRenderer: AbstractRenderer, cache: RenderingCache, viewport: Viewport): void;
-    /**
-     * Renders all nodes visible from `viewport` (or all nodes if `viewport = null`).
-     *
-     * `viewport` is used to improve rendering performance. If given, it must match
-     * the viewport used by the `renderer` (if any).
-     */
-    render(renderer: AbstractRenderer, viewport: Viewport | null): void;
-    /** Renders all nodes, even ones not within the viewport. @internal */
-    renderAll(renderer: AbstractRenderer): void;
-    /** @returns all elements in the image, sorted by z-index. This can be slow for large images. */
-    getAllElements(): AbstractComponent[];
-    /** @returns a list of `AbstractComponent`s intersecting `region`, sorted by z-index. */
-    getElementsIntersectingRegion(region: Rect2): AbstractComponent[];
-    /** @internal */
-    onDestroyElement(elem: AbstractComponent): void;
-    /**
-     * @returns the AbstractComponent with `id`, if it exists.
-     *
-     * @see {@link AbstractComponent.getId}
-     */
-    lookupElement(id: string): AbstractComponent | null;
-    private addElementDirectly;
-    private removeElementDirectly;
-    /**
-     * Returns a command that adds the given element to the `EditorImage`.
-     * If `applyByFlattening` is true, the content of the wet ink renderer is
-     * rendered onto the main rendering canvas instead of doing a full re-render.
-     *
-     * @see {@link Display.flatten}
-     */
-    static addElement(elem: AbstractComponent, applyByFlattening?: boolean): SerializableCommand;
-    /** @see EditorImage.addElement */
-    addElement(elem: AbstractComponent, applyByFlattening?: boolean): SerializableCommand;
-    private static AddElementCommand;
-    /**
-     * @returns a `Viewport` for rendering the image when importing/exporting.
-     */
-    getImportExportViewport(): Viewport;
-    setImportExportRect(imageRect: Rect2): SerializableCommand;
-    private static SetImportExportRectCommand;
-}
-type TooSmallToRenderCheck = (rect: Rect2) => boolean;
-/** Part of the Editor's image. @internal */
-export declare class ImageNode {
-    private parent;
-    private content;
-    private bbox;
-    private children;
-    private targetChildCount;
-    private id;
-    private static idCounter;
-    constructor(parent?: ImageNode | null);
-    getId(): number;
-    onContentChange(): void;
-    getContent(): AbstractComponent | null;
-    getParent(): ImageNode | null;
-    private getChildrenIntersectingRegion;
-    getChildrenOrSelfIntersectingRegion(region: Rect2): ImageNode[];
-    getLeavesIntersectingRegion(region: Rect2, isTooSmall?: TooSmallToRenderCheck): ImageNode[];
-    getChildWithContent(target: AbstractComponent): ImageNode | null;
-    getLeaves(): ImageNode[];
-    addLeaf(leaf: AbstractComponent): ImageNode;
-    getBBox(): Rect2;
-    recomputeBBox(bubbleUp: boolean): void;
-    private updateParents;
-    private rebalance;
-    remove(): void;
-    render(renderer: AbstractRenderer, visibleRect?: Rect2): void;
-}
-export {};

package/dist/src/EditorImage.js

@@ -1,477 +0,0 @@
-var _a, _b, _c;
-import Viewport from './Viewport';
-import AbstractComponent from './components/AbstractComponent';
-import Rect2 from './math/Rect2';
-import SerializableCommand from './commands/SerializableCommand';
-import EventDispatcher from './EventDispatcher';
-import { Vec2 } from './math/Vec2';
-import Mat33 from './math/Mat33';
-import { assertIsNumber, assertIsNumberArray } from './util/assertions';
-// @internal Sort by z-index, low to high
-export const sortLeavesByZIndex = (leaves) => {
-    leaves.sort((a, b) => a.getContent().getZIndex() - b.getContent().getZIndex());
-};
-export var EditorImageEventType;
-(function (EditorImageEventType) {
-    EditorImageEventType[EditorImageEventType["ExportViewportChanged"] = 0] = "ExportViewportChanged";
-})(EditorImageEventType || (EditorImageEventType = {}));
-// Handles lookup/storage of elements in the image
-export default class EditorImage {
-    // @internal
-    constructor() {
-        this.root = new ImageNode();
-        this.background = new ImageNode();
-        this.componentsById = {};
-        this.notifier = new EventDispatcher();
-        this.importExportViewport = new Viewport(() => {
-            this.notifier.dispatch(EditorImageEventType.ExportViewportChanged, {
-                image: this,
-            });
-        });
-        // Default to a 500x500 image
-        this.importExportViewport.updateScreenSize(Vec2.of(500, 500));
-    }
-    // Returns all components that make up the background of this image. These
-    // components are rendered below all other components.
-    getBackgroundComponents() {
-        const result = [];
-        const leaves = this.background.getLeaves();
-        sortLeavesByZIndex(leaves);
-        for (const leaf of leaves) {
-            const content = leaf.getContent();
-            if (content) {
-                result.push(content);
-            }
-        }
-        return result;
-    }
-    // Returns the parent of the given element, if it exists.
-    findParent(elem) {
-        var _b;
-        return (_b = this.background.getChildWithContent(elem)) !== null && _b !== void 0 ? _b : this.root.getChildWithContent(elem);
-    }
-    // Forces a re-render of `elem` when the image is next re-rendered as a whole.
-    // Does nothing if `elem` is not in this.
-    queueRerenderOf(elem) {
-        // TODO: Make more efficient (e.g. increase IDs of all parents,
-        // make cache take into account last modified time instead of IDs, etc.)
-        const parent = this.findParent(elem);
-        if (parent) {
-            parent.remove();
-            this.addElementDirectly(elem);
-        }
-    }
-    /** @internal */
-    renderWithCache(screenRenderer, cache, viewport) {
-        this.background.render(screenRenderer, viewport.visibleRect);
-        cache.render(screenRenderer, this.root, viewport);
-    }
-    /**
-     * Renders all nodes visible from `viewport` (or all nodes if `viewport = null`).
-     *
-     * `viewport` is used to improve rendering performance. If given, it must match
-     * the viewport used by the `renderer` (if any).
-     */
-    render(renderer, viewport) {
-        this.background.render(renderer, viewport === null || viewport === void 0 ? void 0 : viewport.visibleRect);
-        this.root.render(renderer, viewport === null || viewport === void 0 ? void 0 : viewport.visibleRect);
-    }
-    /** Renders all nodes, even ones not within the viewport. @internal */
-    renderAll(renderer) {
-        this.render(renderer, null);
-    }
-    /** @returns all elements in the image, sorted by z-index. This can be slow for large images. */
-    getAllElements() {
-        const leaves = this.root.getLeaves();
-        sortLeavesByZIndex(leaves);
-        return leaves.map(leaf => leaf.getContent());
-    }
-    /** @returns a list of `AbstractComponent`s intersecting `region`, sorted by z-index. */
-    getElementsIntersectingRegion(region) {
-        const leaves = this.root.getLeavesIntersectingRegion(region);
-        sortLeavesByZIndex(leaves);
-        return leaves.map(leaf => leaf.getContent());
-    }
-    /** @internal */
-    onDestroyElement(elem) {
-        delete this.componentsById[elem.getId()];
-    }
-    /**
-     * @returns the AbstractComponent with `id`, if it exists.
-     *
-     * @see {@link AbstractComponent.getId}
-     */
-    lookupElement(id) {
-        var _b;
-        return (_b = this.componentsById[id]) !== null && _b !== void 0 ? _b : null;
-    }
-    addElementDirectly(elem) {
-        elem.onAddToImage(this);
-        this.componentsById[elem.getId()] = elem;
-        // If a background component, add to the background. Else,
-        // add to the normal component tree.
-        const parentTree = elem.isBackground() ? this.background : this.root;
-        return parentTree.addLeaf(elem);
-    }
-    removeElementDirectly(element) {
-        const container = this.findParent(element);
-        container === null || container === void 0 ? void 0 : container.remove();
-        if (container) {
-            this.onDestroyElement(element);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Returns a command that adds the given element to the `EditorImage`.
-     * If `applyByFlattening` is true, the content of the wet ink renderer is
-     * rendered onto the main rendering canvas instead of doing a full re-render.
-     *
-     * @see {@link Display.flatten}
-     */
-    static addElement(elem, applyByFlattening = false) {
-        return new EditorImage.AddElementCommand(elem, applyByFlattening);
-    }
-    /** @see EditorImage.addElement */
-    addElement(elem, applyByFlattening) {
-        return EditorImage.addElement(elem, applyByFlattening);
-    }
-    /**
-     * @returns a `Viewport` for rendering the image when importing/exporting.
-     */
-    getImportExportViewport() {
-        return this.importExportViewport;
-    }
-    setImportExportRect(imageRect) {
-        const importExportViewport = this.getImportExportViewport();
-        const origSize = importExportViewport.visibleRect.size;
-        const origTransform = importExportViewport.canvasToScreenTransform;
-        return new EditorImage.SetImportExportRectCommand(origSize, origTransform, imageRect);
-    }
-}
-_a = EditorImage;
-// A Command that can access private [EditorImage] functionality
-EditorImage.AddElementCommand = (_b = class extends SerializableCommand {
-        // If [applyByFlattening], then the rendered content of this element
-        // is present on the display's wet ink canvas. As such, no re-render is necessary
-        // the first time this command is applied (the surfaces are joined instead).
-        constructor(element, applyByFlattening = false) {
-            super('add-element');
-            this.element = element;
-            this.applyByFlattening = applyByFlattening;
-            this.serializedElem = null;
-            // FIXME: The serialized version of this command may be inaccurate if this is
-            //        serialized when this command is not on the top of the undo stack.
-            //
-            // Caching the element's serialized data leads to additional memory usage *and*
-            // sometimes incorrect behavior in collaborative editing.
-            this.serializedElem = null;
-            if (isNaN(element.getBBox().area)) {
-                throw new Error('Elements in the image cannot have NaN bounding boxes');
-            }
-        }
-        apply(editor) {
-            editor.image.addElementDirectly(this.element);
-            if (!this.applyByFlattening) {
-                editor.queueRerender();
-            }
-            else {
-                this.applyByFlattening = false;
-                editor.display.flatten();
-            }
-        }
-        unapply(editor) {
-            editor.image.removeElementDirectly(this.element);
-            editor.queueRerender();
-        }
-        description(_editor, localization) {
-            return localization.addElementAction(this.element.description(localization));
-        }
-        serializeToJSON() {
-            var _b;
-            return {
-                elemData: (_b = this.serializedElem) !== null && _b !== void 0 ? _b : this.element.serialize(),
-            };
-        }
-    },
-    (() => {
-        SerializableCommand.register('add-element', (json, editor) => {
-            const id = json.elemData.id;
-            const foundElem = editor.image.lookupElement(id);
-            const elem = foundElem !== null && foundElem !== void 0 ? foundElem : AbstractComponent.deserialize(json.elemData);
-            const result = new EditorImage.AddElementCommand(elem);
-            result.serializedElem = json.elemData;
-            return result;
-        });
-    })(),
-    _b);
-// Handles resizing the background import/export region of the image.
-EditorImage.SetImportExportRectCommand = (_c = class extends SerializableCommand {
-        constructor(originalSize, originalTransform, finalRect) {
-            super(EditorImage.SetImportExportRectCommand.commandId);
-            this.originalSize = originalSize;
-            this.originalTransform = originalTransform;
-            this.finalRect = finalRect;
-        }
-        apply(editor) {
-            const viewport = editor.image.getImportExportViewport();
-            viewport.updateScreenSize(this.finalRect.size);
-            viewport.resetTransform(Mat33.translation(this.finalRect.topLeft.times(-1)));
-            editor.queueRerender();
-        }
-        unapply(editor) {
-            const viewport = editor.image.getImportExportViewport();
-            viewport.updateScreenSize(this.originalSize);
-            viewport.resetTransform(this.originalTransform);
-            editor.queueRerender();
-        }
-        description(_editor, localization) {
-            return localization.resizeOutputCommand(this.finalRect);
-        }
-        serializeToJSON() {
-            return {
-                originalSize: this.originalSize.xy,
-                originalTransform: this.originalTransform.toArray(),
-                newRegion: {
-                    x: this.finalRect.x,
-                    y: this.finalRect.y,
-                    w: this.finalRect.w,
-                    h: this.finalRect.h,
-                },
-            };
-        }
-    },
-    _c.commandId = 'set-import-export-rect',
-    (() => {
-        const commandId = _c.commandId;
-        SerializableCommand.register(commandId, (json, _editor) => {
-            assertIsNumber(json.originalSize.x);
-            assertIsNumber(json.originalSize.y);
-            assertIsNumberArray(json.originalTransform);
-            assertIsNumberArray([
-                json.newRegion.x,
-                json.newRegion.y,
-                json.newRegion.w,
-                json.newRegion.h,
-            ]);
-            const originalSize = Vec2.ofXY(json.originalSize);
-            const originalTransform = new Mat33(...json.originalTransform);
-            const finalRect = new Rect2(json.newRegion.x, json.newRegion.y, json.newRegion.w, json.newRegion.h);
-            return new EditorImage.SetImportExportRectCommand(originalSize, originalTransform, finalRect);
-        });
-    })(),
-    _c);
-/** Part of the Editor's image. @internal */
-export class ImageNode {
-    constructor(parent = null) {
-        this.parent = parent;
-        this.targetChildCount = 30;
-        this.children = [];
-        this.bbox = Rect2.empty;
-        this.content = null;
-        this.id = ImageNode.idCounter++;
-    }
-    getId() {
-        return this.id;
-    }
-    onContentChange() {
-        this.id = ImageNode.idCounter++;
-    }
-    getContent() {
-        return this.content;
-    }
-    getParent() {
-        return this.parent;
-    }
-    getChildrenIntersectingRegion(region) {
-        return this.children.filter(child => {
-            return child.getBBox().intersects(region);
-        });
-    }
-    getChildrenOrSelfIntersectingRegion(region) {
-        if (this.content) {
-            return [this];
-        }
-        return this.getChildrenIntersectingRegion(region);
-    }
-    // Returns a list of `ImageNode`s with content (and thus no children).
-    getLeavesIntersectingRegion(region, isTooSmall) {
-        const result = [];
-        let current;
-        const workList = [];
-        workList.push(this);
-        const toNext = () => {
-            current = undefined;
-            const next = workList.pop();
-            if (next && !(isTooSmall === null || isTooSmall === void 0 ? void 0 : isTooSmall(next.bbox))) {
-                current = next;
-                if (current.content !== null && current.getBBox().intersection(region)) {
-                    result.push(current);
-                }
-                workList.push(...current.getChildrenIntersectingRegion(region));
-            }
-        };
-        while (workList.length > 0) {
-            toNext();
-        }
-        return result;
-    }
-    // Returns the child of this with the target content or `null` if no
-    // such child exists.
-    getChildWithContent(target) {
-        const candidates = this.getLeavesIntersectingRegion(target.getBBox());
-        for (const candidate of candidates) {
-            if (candidate.getContent() === target) {
-                return candidate;
-            }
-        }
-        return null;
-    }
-    // Returns a list of leaves with this as an ancestor.
-    // Like getLeavesInRegion, but does not check whether ancestors are in a given rectangle
-    getLeaves() {
-        if (this.content) {
-            return [this];
-        }
-        const result = [];
-        for (const child of this.children) {
-            result.push(...child.getLeaves());
-        }
-        return result;
-    }
-    addLeaf(leaf) {
-        this.onContentChange();
-        if (this.content === null && this.children.length === 0) {
-            this.content = leaf;
-            this.recomputeBBox(true);
-            return this;
-        }
-        if (this.content !== null) {
-            console.assert(this.children.length === 0);
-            const contentNode = new ImageNode(this);
-            contentNode.content = this.content;
-            this.content = null;
-            this.children.push(contentNode);
-            contentNode.recomputeBBox(false);
-        }
-        // If this node is contained within the leaf, make this and the leaf
-        // share a parent.
-        const leafBBox = leaf.getBBox();
-        if (leafBBox.containsRect(this.getBBox())) {
-            const nodeForNewLeaf = new ImageNode(this);
-            if (this.children.length < this.targetChildCount) {
-                this.children.push(nodeForNewLeaf);
-            }
-            else {
-                const nodeForChildren = new ImageNode(this);
-                nodeForChildren.children = this.children;
-                this.children = [nodeForNewLeaf, nodeForChildren];
-                nodeForChildren.recomputeBBox(true);
-                nodeForChildren.updateParents();
-            }
-            return nodeForNewLeaf.addLeaf(leaf);
-        }
-        const containingNodes = this.children.filter(child => child.getBBox().containsRect(leafBBox));
-        // Does the leaf already fit within one of the children?
-        if (containingNodes.length > 0 && this.children.length >= this.targetChildCount) {
-            // Sort the containers in ascending order by area
-            containingNodes.sort((a, b) => a.getBBox().area - b.getBBox().area);
-            // Choose the smallest child that contains the new element.
-            const result = containingNodes[0].addLeaf(leaf);
-            result.rebalance();
-            return result;
-        }
-        const newNode = new ImageNode(this);
-        this.children.push(newNode);
-        newNode.content = leaf;
-        newNode.recomputeBBox(true);
-        return newNode;
-    }
-    getBBox() {
-        return this.bbox;
-    }
-    // Recomputes this' bounding box. If [bubbleUp], also recompute
-    // this' ancestors bounding boxes. This also re-computes this' bounding box
-    // in the z-direction (z-indicies).
-    recomputeBBox(bubbleUp) {
-        var _b;
-        const oldBBox = this.bbox;
-        if (this.content !== null) {
-            this.bbox = this.content.getBBox();
-        }
-        else {
-            this.bbox = Rect2.union(...this.children.map(child => child.getBBox()));
-        }
-        if (bubbleUp && !oldBBox.eq(this.bbox)) {
-            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.recomputeBBox(true);
-        }
-    }
-    updateParents(recursive = false) {
-        for (const child of this.children) {
-            child.parent = this;
-            if (recursive) {
-                child.updateParents(recursive);
-            }
-        }
-    }
-    rebalance() {
-        // If the current node is its parent's only child,
-        if (this.parent && this.parent.children.length === 1) {
-            console.assert(this.parent.content === null);
-            console.assert(this.parent.children[0] === this);
-            // Remove this' parent, if this' parent isn't the root.
-            const oldParent = this.parent;
-            if (oldParent.parent !== null) {
-                oldParent.children = [];
-                this.parent = oldParent.parent;
-                this.parent.children.push(this);
-                oldParent.parent = null;
-                this.parent.recomputeBBox(false);
-            }
-            else if (this.content === null) {
-                // Remove this and transfer this' children to the parent.
-                this.parent.children = this.children;
-                this.parent.updateParents();
-                this.parent = null;
-            }
-        }
-    }
-    // Remove this node and all of its children
-    remove() {
-        var _b;
-        (_b = this.content) === null || _b === void 0 ? void 0 : _b.onRemoveFromImage();
-        if (!this.parent) {
-            this.content = null;
-            this.children = [];
-            return;
-        }
-        const oldChildCount = this.parent.children.length;
-        this.parent.children = this.parent.children.filter(node => {
-            return node !== this;
-        });
-        console.assert(this.parent.children.length === oldChildCount - 1, `${oldChildCount - 1} ≠ ${this.parent.children.length} after removing all nodes equal to ${this}. Nodes should only be removed once.`);
-        this.parent.children.forEach(child => {
-            child.rebalance();
-        });
-        this.parent.recomputeBBox(true);
-        // Invalidate/disconnect this.
-        this.content = null;
-        this.parent = null;
-        this.children = [];
-    }
-    render(renderer, visibleRect) {
-        let leaves;
-        if (visibleRect) {
-            leaves = this.getLeavesIntersectingRegion(visibleRect, rect => renderer.isTooSmallToRender(rect));
-        }
-        else {
-            leaves = this.getLeaves();
-        }
-        sortLeavesByZIndex(leaves);
-        for (const leaf of leaves) {
-            // Leaves by definition have content
-            leaf.getContent().render(renderer, visibleRect);
-        }
-    }
-}
-ImageNode.idCounter = 0;

package/dist/src/EventDispatcher.d.ts

@@ -1,30 +0,0 @@
-/**
- * Handles notifying listeners of events.
- *
- * `EventKeyType` is used to distinguish events (e.g. a `ClickEvent` vs a `TouchEvent`)
- * while `EventMessageType` is the type of the data sent with an event (can be `void`).
- *
- * @example
- * ```
- * const dispatcher = new EventDispatcher<'event1'|'event2'|'event3', void>();
- * dispatcher.on('event1', () => {
- *   console.log('Event 1 triggered.');
- * });
- * dispatcher.dispatch('event1');
- * ```
- *
- * @packageDocumentation
- */
-type CallbackHandler<EventType> = (data: EventType) => void;
-export interface DispatcherEventListener {
-    remove: () => void;
-}
-export default class EventDispatcher<EventKeyType extends string | symbol | number, EventMessageType> {
-    private listeners;
-    constructor();
-    dispatch(eventName: EventKeyType, event: EventMessageType): void;
-    on(eventName: EventKeyType, callback: CallbackHandler<EventMessageType>): DispatcherEventListener;
-    /** Removes an event listener. This is equivalent to calling `.remove()` on the object returned by `.on`. */
-    off(eventName: EventKeyType, callback: CallbackHandler<EventMessageType>): void;
-}
-export {};

package/dist/src/EventDispatcher.js

@@ -1,54 +0,0 @@
-/**
- * Handles notifying listeners of events.
- *
- * `EventKeyType` is used to distinguish events (e.g. a `ClickEvent` vs a `TouchEvent`)
- * while `EventMessageType` is the type of the data sent with an event (can be `void`).
- *
- * @example
- * ```
- * const dispatcher = new EventDispatcher<'event1'|'event2'|'event3', void>();
- * dispatcher.on('event1', () => {
- *   console.log('Event 1 triggered.');
- * });
- * dispatcher.dispatch('event1');
- * ```
- *
- * @packageDocumentation
- */
-// { @inheritDoc EventDispatcher! }
-export default class EventDispatcher {
-    constructor() {
-        this.listeners = {};
-    }
-    dispatch(eventName, event) {
-        const listenerList = this.listeners[eventName];
-        if (listenerList) {
-            for (let i = 0; i < listenerList.length; i++) {
-                listenerList[i](event);
-            }
-        }
-    }
-    on(eventName, callback) {
-        if (!this.listeners[eventName])
-            this.listeners[eventName] = [];
-        this.listeners[eventName].push(callback);
-        return {
-            // Retuns false if the listener has already been removed, true otherwise.
-            remove: () => {
-                const originalListeners = this.listeners[eventName];
-                this.off(eventName, callback);
-                return originalListeners.length !== this.listeners[eventName].length;
-            },
-        };
-    }
-    /** Removes an event listener. This is equivalent to calling `.remove()` on the object returned by `.on`. */
-    off(eventName, callback) {
-        const listeners = this.listeners[eventName];
-        if (!listeners)
-            return;
-        // Replace the current list of listeners with a new, shortened list.
-        // This allows any iterators over this.listeners to continue iterating
-        // without skipping elements.
-        this.listeners[eventName] = listeners.filter(otherCallback => otherCallback !== callback);
-    }
-}

package/dist/src/Pointer.d.ts

@@ -1,24 +0,0 @@
-import { Point2 } from './math/Vec2';
-import Viewport from './Viewport';
-export declare enum PointerDevice {
-    Pen = 0,
-    Eraser = 1,
-    Touch = 2,
-    PrimaryButtonMouse = 3,
-    RightButtonMouse = 4,
-    Other = 5
-}
-export default class Pointer {
-    readonly screenPos: Point2;
-    readonly canvasPos: Point2;
-    readonly pressure: number | null;
-    readonly isPrimary: boolean;
-    readonly down: boolean;
-    readonly device: PointerDevice;
-    readonly id: number;
-    readonly timeStamp: number;
-    private constructor();
-    snappedToGrid(viewport: Viewport): Pointer;
-    static ofEvent(evt: PointerEvent, isDown: boolean, viewport: Viewport, relativeTo?: HTMLElement): Pointer;
-    static ofCanvasPoint(canvasPos: Point2, isDown: boolean, viewport: Viewport, id?: number, device?: PointerDevice, isPrimary?: boolean, pressure?: number | null): Pointer;
-}