excalibur 0.25.1 → 0.25.2

package/build/dist/Input/Pointers.d.ts

@@ -1,78 +0,0 @@
-import { Class } from '../Class';
-import { Engine } from '../Engine';
-import { Pointer } from './Pointer';
-import { PointerEvent, WheelEvent, NativePointerButton } from './PointerEvents';
-import { GameEvent } from '../Events';
-import * as Events from '../Events';
-import { GlobalCoordinates } from '../Math/global-coordinates';
-import { Vector } from '../Math/vector';
-import { Actor } from '../Actor';
-export declare type DOMPointerEvent = globalThis.PointerEvent;
-export declare type DOMWheelEvent = globalThis.WheelEvent;
-/**
- * Handles pointer events (mouse, touch, stylus, etc.) and normalizes to
- * [W3C Pointer Events](http://www.w3.org/TR/pointerevents/).
- */
-export declare class Pointers extends Class {
-    private _engine;
-    private _pointerDown;
-    private _pointerUp;
-    private _pointerMove;
-    private _pointerCancel;
-    private _wheel;
-    private _pointers;
-    private _activePointers;
-    constructor(engine: Engine);
-    on(eventName: Events.up, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.down, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.move, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.enter, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.leave, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.cancel, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.wheel, handler: (event: WheelEvent) => void): void;
-    on(eventName: string, handler: (event: GameEvent<any>) => void): void;
-    /**
-     * Primary pointer (mouse, 1 finger, stylus, etc.)
-     */
-    primary: Pointer;
-    /**
-     * Initializes pointer event listeners
-     */
-    init(target?: GlobalEventHandlers): void;
-    /**
-     * Synthesize a pointer event that looks like a real browser event to excalibur
-     * @param eventName
-     * @param pos
-     */
-    triggerEvent(eventName: 'up' | 'down' | 'move' | 'cancel' | 'wheel', pos: Vector | GlobalCoordinates, button?: NativePointerButton, pointerType?: 'mouse' | 'touch' | 'pen', pointerId?: number): void;
-    /**
-     * Update all pointer events and pointers, meant to be called at the end of frame
-     */
-    update(): void;
-    /**
-     * Safely gets a Pointer at a specific index and initializes one if it doesn't yet exist
-     * @param index  The pointer index to retrieve
-     */
-    at(index: number): Pointer;
-    /**
-     * Get number of pointers being watched
-     */
-    count(): number;
-    checkAndUpdateActorUnderPointer(actor: Actor): void;
-    private _dispatchWithBubble;
-    private _dispatchPointerLeaveEvents;
-    private _dispatchPointerEnterEvents;
-    dispatchPointerEvents(): void;
-    private _propagateWheelPointerEvent;
-    private _handleMouseEvent;
-    private _handleTouchEvent;
-    private _handlePointerEvent;
-    private _handleWheelEvent;
-    /**
-     * Gets the index of the pointer specified for the given pointer ID or finds the next empty pointer slot available.
-     * This is required because IE10/11 uses incrementing pointer IDs so we need to store a mapping of ID => idx
-     */
-    private _getPointerIndex;
-    private _nativeButtonToPointerButton;
-    private _stringToPointerType;
-}

package/build/dist/PostProcessing/ColorBlindCorrector.d.ts

@@ -1,28 +0,0 @@
-import { PostProcessor } from './PostProcessor';
-import { Engine } from '../Engine';
-export declare enum ColorBlindness {
-    Protanope = 0,
-    Deuteranope = 1,
-    Tritanope = 2
-}
-/**
- * This post processor can correct colors and simulate color blindness.
- * It is possible to use this on every game, but the game's performance
- * will suffer measurably. It's better to use it as a helpful tool while developing your game.
- * Remember, the best practice is to design with color blindness in mind.
- */
-export declare class ColorBlindCorrector implements PostProcessor {
-    engine: Engine;
-    simulate: boolean;
-    colorMode: ColorBlindness;
-    private _vertexShader;
-    private _fragmentShader;
-    private _internalCanvas;
-    private _gl;
-    private _program;
-    constructor(engine: Engine, simulate?: boolean, colorMode?: ColorBlindness);
-    private _getFragmentShaderByMode;
-    private _setRectangle;
-    private _getShader;
-    process(image: ImageData, out: CanvasRenderingContext2D): void;
-}

package/build/dist/PostProcessing/Index.d.ts

@@ -1,2 +0,0 @@
-export * from './ColorBlindCorrector';
-export * from './PostProcessor';

package/build/dist/PostProcessing/PostProcessor.d.ts

@@ -1,6 +0,0 @@
-/**
- * Adds post processing support for the engine, can process raw pixel data and manipulate canvas directly.
- */
-export interface PostProcessor {
-    process(image: ImageData, out: CanvasRenderingContext2D): void;
-}

package/build/dist/Traits/CapturePointer.d.ts

@@ -1,10 +0,0 @@
-import { Trait } from '../Interfaces/Trait';
-import { Actor } from '../Actor';
-import { Engine } from '../Engine';
-/**
- * Revises pointer events path accordingly to the actor
- * @deprecated Will be removed in 0.26.0
- */
-export declare class CapturePointer implements Trait {
-    update(actor: Actor, engine: Engine): void;
-}

package/build/esm/Graphics/Context/batch.d.ts

@@ -1,11 +0,0 @@
-import { Pool, Poolable } from '../../Util/Pool';
-export declare class BatchCommand<T> implements Poolable {
-    max: number;
-    _pool: Pool<this>;
-    commands: T[];
-    constructor(max: number);
-    isFull(): boolean;
-    canAdd(): boolean;
-    add(cmd: T): void;
-    dispose(): this;
-}

package/build/esm/Graphics/Context/draw-image-command.d.ts

@@ -1,47 +0,0 @@
-import { Matrix } from '../../Math/matrix';
-import { BoundingBox } from '../../Collision/Index';
-import { Color } from '../../Color';
-import { Pool, Poolable } from '../../Util/Pool';
-import { HTMLImageSource } from './ExcaliburGraphicsContext';
-import { Vector } from '../../Math/vector';
-export declare enum DrawCommandType {
-    Image = "image",
-    Line = "line",
-    Rectangle = "rectangle",
-    Circle = "circle"
-}
-export declare class DrawImageCommand implements Poolable {
-    _pool: Pool<this>;
-    snapToPixel: boolean;
-    image: HTMLImageSource;
-    color: Color;
-    type: DrawCommandType;
-    opacity: number;
-    width: number;
-    height: number;
-    dest: [number, number];
-    view: [number, number, number, number];
-    private _geom;
-    constructor();
-    constructor(image: HTMLImageSource, x: number, y: number);
-    constructor(image: HTMLImageSource, x: number, y: number, width?: number, height?: number);
-    constructor(image: HTMLImageSource, sx: number, sy: number, swidth?: number, sheight?: number, dx?: number, dy?: number, dwidth?: number, dheight?: number);
-    init(image?: HTMLImageSource, sx?: number, sy?: number, swidth?: number, sheight?: number, dx?: number, dy?: number, dwidth?: number, dheight?: number): this;
-    initRect(color: Color, start: Vector, width: number, height: number): this;
-    initLine(color: Color, start: Vector, end: Vector, thickness: number): this;
-    initCircle(pos: Vector, radius: number, color: Color): this;
-    dispose(): this;
-    applyTransform(transform: Matrix, opacity: number): void;
-    get geometry(): [number, number][];
-}
-export declare class DrawRectCommand {
-    dest: [number, number];
-    width: number;
-    height: number;
-    constructor(x: number, y: number, width: number, height: number);
-}
-export declare class DrawDebugRectCommand {
-    bounds: BoundingBox;
-    color: Color;
-    constructor(bounds: BoundingBox, color: Color);
-}

package/build/esm/Graphics/Context/image-renderer.d.ts

@@ -1,39 +0,0 @@
-import { Shader } from './shader';
-import { BatchCommand } from './batch';
-import { DrawImageCommand } from './draw-image-command';
-import { BatchRenderer } from './renderer';
-import { WebGLGraphicsContextInfo } from './ExcaliburGraphicsContextWebGL';
-import { HTMLImageSource } from './ExcaliburGraphicsContext';
-import { Color } from '../../Color';
-import { Vector } from '../..';
-export declare class BatchImage extends BatchCommand<DrawImageCommand> {
-    maxDraws: number;
-    maxTextures: number;
-    textures: WebGLTexture[];
-    commands: DrawImageCommand[];
-    private _graphicMap;
-    constructor(maxDraws: number, maxTextures: number);
-    isFull(): boolean;
-    canAdd(): boolean;
-    private _isCommandFull;
-    private _isTextureFull;
-    private _wouldAddTexture;
-    maybeAdd(command: DrawImageCommand): boolean;
-    add(command: DrawImageCommand): void;
-    bindTextures(gl: WebGLRenderingContext): void;
-    getBatchTextureId(command: DrawImageCommand): number;
-    dispose(): this;
-    clear(): void;
-}
-export declare class ImageRenderer extends BatchRenderer<DrawImageCommand> {
-    private _contextInfo;
-    constructor(gl: WebGLRenderingContext, _contextInfo: WebGLGraphicsContextInfo);
-    buildShader(gl: WebGLRenderingContext): Shader;
-    private _transformFragmentSource;
-    addCircle(pos: Vector, radius: number, color: Color): void;
-    addRectangle(color: Color, pos: Vector, width: number, height: number): void;
-    addLine(color: Color, start: Vector, end: Vector, thickness?: number): void;
-    addImage(graphic: HTMLImageSource, sx: number, sy: number, swidth?: number, sheight?: number, dx?: number, dy?: number, dwidth?: number, dheight?: number): void;
-    renderBatch(gl: WebGLRenderingContext, batch: BatchImage, vertexCount: number): void;
-    buildBatchVertices(vertexBuffer: Float32Array, batch: BatchImage): number;
-}

package/build/esm/Graphics/Context/line-renderer.d.ts

@@ -1,22 +0,0 @@
-import { Vector } from '../../Math/vector';
-import { Color } from '../../Color';
-import { Shader } from './shader';
-import { BatchRenderer } from './renderer';
-import { BatchCommand } from './batch';
-import { WebGLGraphicsContextInfo } from './ExcaliburGraphicsContextWebGL';
-import { Pool, Poolable } from '../../Util/Pool';
-export declare class DrawLine implements Poolable {
-    _pool?: Pool<this>;
-    color: Color;
-    start: Vector;
-    end: Vector;
-    dispose(): this;
-}
-export declare class LineRenderer extends BatchRenderer<DrawLine> {
-    private _contextInfo;
-    constructor(gl: WebGLRenderingContext, _contextInfo: WebGLGraphicsContextInfo);
-    buildShader(gl: WebGLRenderingContext): Shader;
-    addLine(start: Vector, end: Vector, color: Color): void;
-    buildBatchVertices(vertexBuffer: Float32Array, batch: BatchCommand<DrawLine>): number;
-    renderBatch(gl: WebGLRenderingContext, _batch: BatchCommand<DrawLine>, vertexCount: number): void;
-}

package/build/esm/Graphics/Context/point-renderer.d.ts

@@ -1,22 +0,0 @@
-import { Shader } from './shader';
-import { Vector } from '../../Math/vector';
-import { Color } from '../../Color';
-import { BatchRenderer } from './renderer';
-import { BatchCommand } from './batch';
-import { WebGLGraphicsContextInfo } from './ExcaliburGraphicsContextWebGL';
-import { Pool, Poolable } from '../../Util/Pool';
-export declare class DrawPoint implements Poolable {
-    _pool?: Pool<this>;
-    point: Vector;
-    color: Color;
-    size: number;
-    dispose(): this;
-}
-export declare class PointRenderer extends BatchRenderer<DrawPoint> {
-    private _contextInfo;
-    constructor(gl: WebGLRenderingContext, _contextInfo: WebGLGraphicsContextInfo);
-    buildShader(gl: WebGLRenderingContext): Shader;
-    addPoint(point: Vector, color: Color, size: number): void;
-    buildBatchVertices(vertexBuffer: Float32Array, batch: BatchCommand<DrawPoint>): number;
-    renderBatch(gl: WebGLRenderingContext, _batch: BatchCommand<DrawPoint>, vertexCount: number): void;
-}

package/build/esm/Input/Pointer.d.ts

@@ -1,134 +0,0 @@
-import { Actor } from '../Actor';
-import { Vector } from '../Math/vector';
-import { Class } from '../Class';
-import { PointerMoveEvent, PointerDownEvent, PointerUpEvent, WheelEvent } from './PointerEvents';
-export interface ActorsUnderPointer {
-    [ActorId: number]: Actor;
-    length: number;
-}
-/**
- * The type of pointer for a [[PointerEvent]].
- */
-export declare enum PointerType {
-    Touch = "Touch",
-    Mouse = "Mouse",
-    Pen = "Pen",
-    Unknown = "Unknown"
-}
-/**
- * Determines the scope of handling mouse/touch events. See [[Pointers]] for more information.
- */
-export declare enum PointerScope {
-    /**
-     * Handle events on the `canvas` element only. Events originating outside the
-     * `canvas` will not be handled.
-     */
-    Canvas = "Canvas",
-    /**
-     * Handles events on the entire document. All events will be handled by Excalibur.
-     */
-    Document = "Document"
-}
-/**
- * Captures and dispatches PointerEvents
- */
-export declare class Pointer extends Class {
-    private static _MAX_ID;
-    readonly id: number;
-    private _isDown;
-    private _wasDown;
-    private _actorsUnderPointer;
-    private _actors;
-    private _actorsLastFrame;
-    private _actorsNoLongerUnderPointer;
-    private _actorSortingFcn;
-    /**
-     * Whether the Pointer is currently dragging.
-     */
-    get isDragging(): boolean;
-    /**
-     * Whether the Pointer just started dragging.
-     */
-    get isDragStart(): boolean;
-    /**
-     * Whether the Pointer just ended dragging.
-     */
-    get isDragEnd(): boolean;
-    /**
-     * Returns true if pointer has any actors under
-     */
-    get hasActorsUnderPointer(): boolean;
-    /**
-     * The last position on the document this pointer was at. Can be `null` if pointer was never active.
-     */
-    lastPagePos: Vector;
-    /**
-     * The last position on the screen this pointer was at. Can be `null` if pointer was never active.
-     */
-    lastScreenPos: Vector;
-    /**
-     * The last position in the game world coordinates this pointer was at. Can be `null` if pointer was never active.
-     */
-    lastWorldPos: Vector;
-    /**
-     * Returns the currently dragging target or null if it isn't exist
-     */
-    dragTarget: Actor;
-    constructor();
-    on(event: 'move', handler: (event: PointerMoveEvent) => void): void;
-    on(event: 'down', handler: (event: PointerDownEvent) => void): void;
-    on(event: 'up', handler: (event: PointerUpEvent) => void): void;
-    on(event: 'wheel', handler: (event: WheelEvent) => void): void;
-    once(event: 'move', handler: (event: PointerMoveEvent) => void): void;
-    once(event: 'down', handler: (event: PointerDownEvent) => void): void;
-    once(event: 'up', handler: (event: PointerUpEvent) => void): void;
-    once(event: 'wheel', handler: (event: WheelEvent) => void): void;
-    off(event: 'move', handler?: (event: PointerMoveEvent) => void): void;
-    off(event: 'down', handler?: (event: PointerDownEvent) => void): void;
-    off(event: 'up', handler?: (event: PointerUpEvent) => void): void;
-    off(event: 'wheel', handler?: (event: WheelEvent) => void): void;
-    /**
-     * Update the state of current pointer, meant to be called a the end of frame
-     */
-    update(): void;
-    /**
-     * Adds an Actor to actorsUnderPointer object.
-     * @param actor An Actor to be added;
-     */
-    addActorUnderPointer(actor: Actor): void;
-    /**
-     * Removes an Actor from actorsUnderPointer object.
-     * @param actor An Actor to be removed;
-     */
-    removeActorUnderPointer(actor: Actor): void;
-    /**
-     * Returns all actors under this pointer this frame
-     */
-    getActorsUnderPointer(): Actor[];
-    /**
-     * Returns all actors that are no longer under the pointer this frame
-     */
-    getActorsUnderPointerLastFrame(): Actor[];
-    /**
-     * Returns all actors relevant for events to pointer this frame
-     */
-    getActorsForEvents(): Actor[];
-    /**
-     * Checks if Pointer location has a specific Actor bounds contained underneath.
-     * @param actor An Actor for check;
-     */
-    checkActorUnderPointer(actor: Actor): boolean;
-    /**
-     * Checks if an actor was under the pointer last frame
-     * @param actor
-     */
-    wasActorUnderPointer(actor: Actor): boolean;
-    /**
-     * Checks if Pointer has a specific Actor in ActorsUnderPointer list.
-     * @param actor An Actor for check;
-     */
-    isActorAliveUnderPointer(actor: Actor): boolean;
-    private _onPointerMove;
-    private _onPointerDown;
-    private _onPointerUp;
-}

package/build/esm/Input/PointerEvents.d.ts

@@ -1,170 +0,0 @@
-import { Actor } from '../Actor';
-import { GlobalCoordinates } from '../Math/global-coordinates';
-import { Vector } from '../Math/vector';
-import { Pointer, PointerType } from './Pointer';
-import { GameEvent } from '../Events';
-/**
- * Native browser button enumeration
- */
-export declare enum NativePointerButton {
-    NoButton = -1,
-    Left = 0,
-    Middle = 1,
-    Right = 2,
-    Unknown = 3
-}
-/**
- * The mouse button being pressed.
- */
-export declare enum PointerButton {
-    Left = "Left",
-    Middle = "Middle",
-    Right = "Right",
-    Unknown = "Unknown",
-    NoButton = "NoButton"
-}
-export declare enum WheelDeltaMode {
-    Pixel = "Pixel",
-    Line = "Line",
-    Page = "Page"
-}
-/**
- * Type that indicates Excalibur's valid synthetic pointer events
- */
-export declare type PointerEventName = 'pointerdragstart' | 'pointerdragend' | 'pointerdragmove' | 'pointerdragenter' | 'pointerdragleave' | 'pointermove' | 'pointerenter' | 'pointerleave' | 'pointerup' | 'pointerdown';
-/**
- * Pointer events
- *
- * Represents a mouse, touch, or stylus event. See [[Pointers]] for more information on
- * handling pointer input.
- *
- * For mouse-based events, you can inspect [[PointerEvent.button]] to see what button was pressed.
- */
-export declare class PointerEvent extends GameEvent<Actor> {
-    protected coordinates: GlobalCoordinates;
-    pointer: Pointer;
-    index: number;
-    pointerType: PointerType;
-    button: PointerButton;
-    ev: any;
-    protected _name: string;
-    get name(): string;
-    /** The world coordinates of the event. */
-    get worldPos(): Vector;
-    /** The page coordinates of the event. */
-    get pagePos(): Vector;
-    /** The screen coordinates of the event. */
-    get screenPos(): Vector;
-    /**
-     * @param coordinates         The [[GlobalCoordinates]] of the event
-     * @param pointer             The [[Pointer]] of the event
-     * @param index               The index of the pointer (zero-based)
-     * @param pointerType         The type of pointer
-     * @param button              The button pressed (if [[PointerType.Mouse]])
-     * @param ev                  The raw DOM event being handled
-     */
-    constructor(coordinates: GlobalCoordinates, pointer: Pointer, index: number, pointerType: PointerType, button: PointerButton, ev: any);
-    get pos(): Vector;
-    _canceled: boolean;
-    /**
-     * Cancels pointer event propogation, event will not be transmitted to any other actors
-     */
-    cancel(): void;
-    /**
-     *
-     * @returns If the event is canceled it will no longer be transmitted to any other actors
-     */
-    isCanceled(): boolean;
-    propagate(actor: Actor): void;
-    /**
-     * Action, that calls when event happens
-     */
-    doAction(actor: Actor): void;
-    protected _onActionStart(_actor?: Actor): void;
-    protected _onActionEnd(_actor?: Actor): void;
-}
-export declare class PointerEventFactory<T extends PointerEvent> {
-    protected _pointerEventType: new (coordinates: GlobalCoordinates, pointer: Pointer, index: number, pointerType: PointerType, button: PointerButton, ev: any) => T;
-    constructor(_pointerEventType: new (coordinates: GlobalCoordinates, pointer: Pointer, index: number, pointerType: PointerType, button: PointerButton, ev: any) => T);
-    /**
-     * Create specific PointerEvent
-     */
-    create(coordinates: GlobalCoordinates, pointer: Pointer, index: number, pointerType: PointerType, button: PointerButton, ev: any): T;
-}
-export declare class PointerDragEvent extends PointerEvent {
-}
-export declare class PointerUpEvent extends PointerEvent {
-    protected _name: string;
-    protected _onActionEnd(actor: Actor): void;
-}
-export declare class PointerDownEvent extends PointerEvent {
-    protected _name: string;
-    protected _onActionEnd(actor: Actor): void;
-}
-export declare class PointerMoveEvent extends PointerEvent {
-    protected _name: string;
-    propagate(actor: Actor): void;
-    protected _onActionStart(actor: Actor): void;
-}
-export declare class PointerEnterEvent extends PointerEvent {
-    protected _name: string;
-    protected _onActionStart(actor: Actor): void;
-    protected _onActionEnd(actor: Actor): void;
-}
-export declare class PointerLeaveEvent extends PointerEvent {
-    protected _name: string;
-    protected _onActionStart(actor: Actor): void;
-    protected _onActionEnd(actor: Actor): void;
-}
-export declare class PointerCancelEvent extends PointerEvent {
-    protected _name: string;
-}
-/**
- * Wheel Events
- *
- * Represents a mouse wheel event. See [[Pointers]] for more information on
- * handling point input.
- */
-export declare class WheelEvent extends GameEvent<Actor> {
-    x: number;
-    y: number;
-    pageX: number;
-    pageY: number;
-    screenX: number;
-    screenY: number;
-    index: number;
-    deltaX: number;
-    deltaY: number;
-    deltaZ: number;
-    deltaMode: WheelDeltaMode;
-    ev: any;
-    /**
-     * @param x            The `x` coordinate of the event (in world coordinates)
-     * @param y            The `y` coordinate of the event (in world coordinates)
-     * @param pageX        The `x` coordinate of the event (in document coordinates)
-     * @param pageY        The `y` coordinate of the event (in document coordinates)
-     * @param screenX      The `x` coordinate of the event (in screen coordinates)
-     * @param screenY      The `y` coordinate of the event (in screen coordinates)
-     * @param index        The index of the pointer (zero-based)
-     * @param deltaX       The type of pointer
-     * @param deltaY       The type of pointer
-     * @param deltaZ       The type of pointer
-     * @param deltaMode    The type of movement [[WheelDeltaMode]]
-     * @param ev           The raw DOM event being handled
-     */
-    constructor(x: number, y: number, pageX: number, pageY: number, screenX: number, screenY: number, index: number, deltaX: number, deltaY: number, deltaZ: number, deltaMode: WheelDeltaMode, ev: any);
-    private _isCanceled;
-    /**
-     * Cancels pointer event propogation, event will not be transmitted to any other actors
-     */
-    cancel(): void;
-    /**
-     *
-     * @returns If the event is canceled it will no longer be transmitted to any other actors
-     */
-    isCanceled(): boolean;
-}
-/**
- *
- */
-export declare function createPointerEventByName(eventName: string, coordinates: GlobalCoordinates, pointer: Pointer, index: number, pointerType: PointerType, button: PointerButton, ev: any): PointerEvent;

package/build/esm/Input/Pointers.d.ts

@@ -1,78 +0,0 @@
-import { Class } from '../Class';
-import { Engine } from '../Engine';
-import { Pointer } from './Pointer';
-import { PointerEvent, WheelEvent, NativePointerButton } from './PointerEvents';
-import { GameEvent } from '../Events';
-import * as Events from '../Events';
-import { GlobalCoordinates } from '../Math/global-coordinates';
-import { Vector } from '../Math/vector';
-import { Actor } from '../Actor';
-export declare type DOMPointerEvent = globalThis.PointerEvent;
-export declare type DOMWheelEvent = globalThis.WheelEvent;
-/**
- * Handles pointer events (mouse, touch, stylus, etc.) and normalizes to
- * [W3C Pointer Events](http://www.w3.org/TR/pointerevents/).
- */
-export declare class Pointers extends Class {
-    private _engine;
-    private _pointerDown;
-    private _pointerUp;
-    private _pointerMove;
-    private _pointerCancel;
-    private _wheel;
-    private _pointers;
-    private _activePointers;
-    constructor(engine: Engine);
-    on(eventName: Events.up, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.down, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.move, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.enter, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.leave, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.cancel, handler: (event: PointerEvent) => void): void;
-    on(eventName: Events.wheel, handler: (event: WheelEvent) => void): void;
-    on(eventName: string, handler: (event: GameEvent<any>) => void): void;
-    /**
-     * Primary pointer (mouse, 1 finger, stylus, etc.)
-     */
-    primary: Pointer;
-    /**
-     * Initializes pointer event listeners
-     */
-    init(target?: GlobalEventHandlers): void;
-    /**
-     * Synthesize a pointer event that looks like a real browser event to excalibur
-     * @param eventName
-     * @param pos
-     */
-    triggerEvent(eventName: 'up' | 'down' | 'move' | 'cancel' | 'wheel', pos: Vector | GlobalCoordinates, button?: NativePointerButton, pointerType?: 'mouse' | 'touch' | 'pen', pointerId?: number): void;
-    /**
-     * Update all pointer events and pointers, meant to be called at the end of frame
-     */
-    update(): void;
-    /**
-     * Safely gets a Pointer at a specific index and initializes one if it doesn't yet exist
-     * @param index  The pointer index to retrieve
-     */
-    at(index: number): Pointer;
-    /**
-     * Get number of pointers being watched
-     */
-    count(): number;
-    checkAndUpdateActorUnderPointer(actor: Actor): void;
-    private _dispatchWithBubble;
-    private _dispatchPointerLeaveEvents;
-    private _dispatchPointerEnterEvents;
-    dispatchPointerEvents(): void;
-    private _propagateWheelPointerEvent;
-    private _handleMouseEvent;
-    private _handleTouchEvent;
-    private _handlePointerEvent;
-    private _handleWheelEvent;
-    /**
-     * Gets the index of the pointer specified for the given pointer ID or finds the next empty pointer slot available.
-     * This is required because IE10/11 uses incrementing pointer IDs so we need to store a mapping of ID => idx
-     */
-    private _getPointerIndex;
-    private _nativeButtonToPointerButton;
-    private _stringToPointerType;
-}