@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/events/TouchEvent.js

@@ -0,0 +1,550 @@
+import { __extends } from "tslib";
+import { Event } from './Event';
+import { AVMStage } from '@awayfl/swf-loader';
+import { Point } from '@awayjs/core';
+/**
+/// @eventType	flash.events.TouchEvent.TOUCH_BEGIN
+[Event(name="touchBegin", type="flash.events.TouchEvent")]
+
+/// @eventType	flash.events.TouchEvent.TOUCH_END
+[Event(name="touchEnd", type="flash.events.TouchEvent")]
+
+/// @eventType	flash.events.TouchEvent.TOUCH_MOVE
+[Event(name="touchMove", type="flash.events.TouchEvent")]
+
+/// @eventType	flash.events.TouchEvent.TOUCH_OUT
+[Event(name="touchOut", type="flash.events.TouchEvent")]
+
+/// @eventType	flash.events.TouchEvent.TOUCH_OVER
+[Event(name="touchOver", type="flash.events.TouchEvent")]
+
+/// @eventType	flash.events.TouchEvent.TOUCH_ROLL_OUT
+[Event(name="touchRollOut", type="flash.events.TouchEvent")]
+
+/// @eventType	flash.events.TouchEvent.TOUCH_ROLL_OVER
+[Event(name="touchRollOver", type="flash.events.TouchEvent")]
+
+/// @eventType	flash.events.TouchEvent.TOUCH_TAP
+[Event(name="touchTap", type="flash.events.TouchEvent")]
+
+ * The TouchEvent class lets you handle events on devices that detect user contact with
+ * the device (such as a finger on a touch screen).
+ * When a user interacts with a device such as a mobile phone or tablet with a touch screen, the user typically
+ * touches the screen with his or her fingers or a pointing device. You can develop applications that respond to
+ * basic touch events (such as a single finger tap) with the TouchEvent class.
+ * Create event listeners using the event types defined in this class.
+ * For user interaction with multiple points of contact
+ * (such as several fingers moving across a touch screen at the same time) use
+ * the related GestureEvent, PressAndTapGestureEvent, and TransformGestureEvent classes.
+ * And, use the properties and methods of these classes
+ * to construct event handlers that respond to the user touching the device.
+ * <p class="- topic/p ">Use the Multitouch class to determine the current environment's support for touch interaction,
+ * and to
+ * manage the support of touch interaction if the current environment supports it.</p>
+ * <p class="- topic/p "><b class="+ topic/ph hi-d/b ">Note:</b>
+ * When objects are nested on the display list, touch events target the deepest possible
+ * nested object that is visible in the display list. This object is called the target node. To have a target node's
+ * ancestor (an object containing the target node in the display list) receive notification of a touch event, use
+ * <codeph class="+ topic/ph pr-d/codeph ">EventDispatcher.addEventListener()</codeph>
+ * on the ancestor node with the type parameter set to the specific
+ * touch event you want to detect.</p>
+ */
+var TouchEvent = /** @class */ (function (_super) {
+    __extends(TouchEvent, _super);
+    /**
+     * Creates an Event object that contains information about touch events.
+     * Event objects are passed as parameters to event listeners.
+     * @param	type	The type of the event. Possible values are: TouchEvent.TOUCH_BEGIN,
+     *   TouchEvent.TOUCH_END, TouchEvent.TOUCH_MOVE,
+     *   TouchEvent.TOUCH_OUT, TouchEvent.TOUCH_OVER,
+     *   TouchEvent.TOUCH_ROLL_OUT, TouchEvent.TOUCH_ROLL_OVER,
+     *   and TouchEvent.TOUCH_TAP.
+     * @param	bubbles	Determines whether the Event object participates in the bubbling phase of the event flow.
+     * @param	cancelable	Determines whether the Event object can be canceled.
+     * @param	touchPointID	A unique identification number (as an int) assigned to the touch point.
+     * @param	isPrimaryTouchPoint	Indicates whether the first point of contact is mapped to mouse events.
+     * @param	localX	The horizontal coordinate at which the event occurred relative to the containing sprite.
+     * @param	localY	The vertical coordinate at which the event occurred relative to the containing sprite.
+     * @param	sizeX	Width of the contact area.
+     * @param	sizeY	Height of the contact area.
+     * @param	pressure	A value between 0.0 and 1.0 indicating force of the contact with the device.
+     *   If the device does not support detecting the pressure, the value is 1.0.
+     * @param	relatedObject	The complementary InteractiveObject instance that is affected by the event.
+     * For example, when a touchOut event occurs,
+     *   relatedObject represents the display list object to which the pointing device now points.
+     * @param	ctrlKey	On Windows or Linux, indicates whether the Ctrl key is activated.
+     * On Mac, indicates whether either the Ctrl key or the Command key is activated.
+     * @param	altKey	Indicates whether the Alt key is activated (Windows or Linux only).
+     * @param	shiftKey	Indicates whether the Shift key is activated.
+     * @param	commandKey	(AIR only) Indicates whether the Command key is activated (Mac only).
+     * This parameter is for Adobe AIR only; do not set it for Flash Player content.
+     * @param	controlKey	(AIR only) Indicates whether the Control or Ctrl key is activated.
+     * This parameter is for Adobe AIR only; do not set it for Flash Player content.
+
+     */
+    function TouchEvent(type, bubbles, cancelable, touchPointID, isPrimaryTouchPoint, localX, localY, sizeX, sizeY, pressure, relatedObject, ctrlKey, altKey, shiftKey) {
+        if (bubbles === void 0) { bubbles = true; }
+        if (cancelable === void 0) { cancelable = false; }
+        if (touchPointID === void 0) { touchPointID = 0; }
+        if (isPrimaryTouchPoint === void 0) { isPrimaryTouchPoint = false; }
+        if (localX === void 0) { localX = NaN; }
+        if (localY === void 0) { localY = NaN; }
+        if (sizeX === void 0) { sizeX = NaN; }
+        if (sizeY === void 0) { sizeY = NaN; }
+        if (pressure === void 0) { pressure = NaN; }
+        if (relatedObject === void 0) { relatedObject = null; }
+        if (ctrlKey === void 0) { ctrlKey = false; }
+        if (altKey === void 0) { altKey = false; }
+        if (shiftKey === void 0) { shiftKey = false; }
+        var _this = _super.call(this, type, bubbles, cancelable) || this;
+        _this._localX = localX;
+        _this._localY = localY;
+        _this._ctrlKey = ctrlKey;
+        _this._altKey = altKey;
+        _this._shiftKey = shiftKey;
+        return _this;
+    }
+    Object.defineProperty(TouchEvent.prototype, "altKey", {
+        /**
+         * Indicates whether the Alt key is active (true) or inactive (false).
+         * Supported for Windows and Linux operating systems only.
+         * @internal	Reserved in case Desktop Player wants to capture this key in a future implementation.
+         *   The Option key modifier on Macintosh system must be represented using this key modifier. So far, it seems
+         *   only the Windows version is hooked up.
+         */
+        get: function () {
+            return this._altKey;
+        },
+        set: function (value) {
+            this._altKey = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "ctrlKey", {
+        /**
+         * On Windows or Linux, indicates whether the Ctrl key is active (true) or inactive (false).
+         * On Macintosh, indicates whether either the Control key or the Command key is activated.
+         */
+        get: function () {
+            return this._ctrlKey;
+        },
+        set: function (value) {
+            this._ctrlKey = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "isPrimaryTouchPoint", {
+        /**
+         * Indicates whether the first point of contact is mapped to mouse events.
+         */
+        get: function () { return false; },
+        set: function (value) { },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "isRelatedObjectInaccessible", {
+        /**
+         * If true, the relatedObject property is set to null for
+         * reasons related to security sandboxes.  If the nominal value of relatedObject is a reference to a
+         * DisplayObject in another sandbox, relatedObject is set to
+         * null unless there is permission in both directions across this sandbox boundary. Permission is
+         * established by calling Security.allowDomain() from a SWF file, or by providing
+         * a policy file from the server of an image file, and setting the LoaderContext.checkPolicyFile
+         * property when loading the image.
+         */
+        get: function () { return false; },
+        set: function (value) { },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "localX", {
+        /**
+         * The horizontal coordinate at which the event occurred relative to the containing sprite.
+         */
+        get: function () {
+            return (this._localX / 20) | 0;
+        },
+        set: function (value) {
+            this._localX = (value * 20) | 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "localY", {
+        /**
+         * The vertical coordinate at which the event occurred relative to the containing sprite.
+         */
+        get: function () {
+            return (this._localY / 20) | 0;
+        },
+        set: function (value) {
+            this._localY = (value * 20) | 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "pressure", {
+        /**
+         * A value between 0.0 and 1.0 indicating force of the contact with the device.
+         * If the device does not support detecting the pressure, the value is 1.0.
+         */
+        get: function () { return 0; },
+        set: function (value) { },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "relatedObject", {
+        /**
+         * A reference to a display list object that is related to the event. For example, when a touchOut event occurs,
+         * relatedObject represents the display list object to which the pointing device now points.
+         * This property applies to the touchOut, touchOver, touchRollOut, and touchRollOver events.
+         * The value of this property can be null in two circumstances: if there is no related object,
+         * or there is a related object, but it is in a security sandbox to which you don't have access.
+         * Use the isRelatedObjectInaccessible() property to determine which of these reasons applies.
+         */
+        get: function () {
+            return null;
+        },
+        set: function (value) {
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "shiftKey", {
+        /**
+         * Indicates whether the Shift key is active (true) or inactive
+         * (false).
+         */
+        get: function () {
+            return this._shiftKey;
+        },
+        set: function (value) {
+            this._shiftKey = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "sizeX", {
+        /**
+         * Width of the contact area.
+         * @langversion	3.0
+         */
+        get: function () { return 0; },
+        set: function (value) { },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "sizeY", {
+        /**
+         * Height of the contact area.
+         */
+        get: function () { return 0; },
+        set: function (value) { },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "stageX", {
+        /**
+         * The horizontal coordinate at which the event occurred in global Stage coordinates.
+         * This property is calculated when the localX property is set.
+         */
+        get: function () {
+            return this._stageX;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "stageY", {
+        /**
+         * The vertical coordinate at which the event occurred in global Stage coordinates.
+         * This property is calculated when the localY property is set.
+         */
+        get: function () { return 0; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TouchEvent.prototype, "touchPointID", {
+        /**
+         * A unique identification number (as an int) assigned to the touch point.
+         */
+        get: function () { return 0; },
+        set: function (value) { },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Creates a copy of the TouchEvent object and sets the value of each property to match that of the original.
+     * @return	A new TouchEvent object with property values that match those of the original.
+     */
+    TouchEvent.prototype.clone = function () {
+        return null;
+    };
+    /**
+     * Returns a string that contains all the properties of the TouchEvent object.
+     * The string is in the following format:
+     * [TouchEvent type=value bubbles=value cancelable=value ... ]
+     * @return	A string that contains all the properties of the TouchEvent object.
+     */
+    TouchEvent.prototype.toString = function () { return ''; };
+    /**
+     * Instructs Flash Player or Adobe AIR to render after processing of this event completes,
+     * if the display list has been modified.
+     */
+    TouchEvent.prototype.updateAfterEvent = function () {
+    };
+    /* added to clone events from away to as3web. */
+    TouchEvent.prototype.fillFromAway = function (awayEvent) {
+        //console.log("cloneFromAway not implemented yet in flash/MouseEvent");
+        this.adaptee = awayEvent;
+        // todo: set targets correctly
+        this.target = awayEvent.target.adapter || this.sec.flash.display.DisplayObject.axClass._activeStage;
+        this.currentTarget = awayEvent.currentTarget.adapter || this.sec.flash.display.DisplayObject.axClass._activeStage;
+        this.ctrlKey = awayEvent.ctrlKey;
+        this.shiftKey = awayEvent.shiftKey;
+        var stagePoint = AVMStage.instance().unprojectPoint(new Point(awayEvent.screenX, awayEvent.screenY), this.target.stage.adaptee);
+        this._stageX = stagePoint.x;
+        this._stageY = stagePoint.y;
+        //todo: translate more stuff from awayjs to as3
+        //result.screenX = this.screenX;
+        //result.screenY = this.screenY;
+        /*
+        result.view = awayEvent.view;
+        result.entity = awayEvent.entity;
+        result.renderable = awayEvent.renderable;
+        result.material = awayEvent.material;
+        result.uv = awayEvent.uv;
+        result.position = awayEvent.position;
+        result.normal = awayEvent.normal;
+        result.elementIndex = awayEvent.elementIndex;
+*/
+        //result._iParentEvent = awayEvent;
+        //result._iAllowedToPropagate = awayEvent._iAllowedToPropagate;
+    };
+    /**
+     * Defines the value of the type property of a TOUCH_BEGIN touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:PropertyValuealtKeytrue
+     * if the Alt key is active (Windows or Linux).bubblestruecancelablefalse;
+     * there is no default behavior to cancel.commandKeytrue on the Mac if the Command key is active;
+     * false if it is inactive. Always false on Windows.controlKeytrue if the Ctrl or Control key is active;
+     * false if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise,
+     * #false.currentTargetThe object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event
+     * flow.isRelatedObjectInaccessibletrue if the relatedObject property
+     * is set to null because of security sandbox rules.localX
+     * The horizontal coordinate at which the event occurred relative to the containing sprite.
+     * localYThe vertical coordinate at which the event occurred relative to the containing sprite.pressure
+     * A value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure, the value is 1.0.related
+     * ObjectA reference to a display list object related to the event.shiftKey
+     * true if the Shift key is active; false if it is inactive.sizeX
+     * Width of the contact area.sizeYHeight of the contact area.stageX
+     * The horizontal coordinate at which the event occurred in global stage coordinates.stageY
+     * The vertical coordinate at which the event occurred in global stage coordinates.target
+     * The InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.touchPoint
+     * IDA unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_BEGIN = 'touchBegin';
+    /**
+     * Defines the value of the type property of a TOUCH_END touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:PropertyValuealtKey
+     * true if the Alt key is active (Windows or Linux).bubblestruecancelablefalse;
+     * there is no default behavior to cancel.commandKeytrue on the Mac if the Command key is active;
+     * false if it is inactive. Always false on Windows.controlKeytrue if the Ctrl or Control key is active;
+     * false if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise, false.currentTarget
+     * The object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event flow.isRelatedObjectInaccessible
+     * true if the relatedObject property is set to null because of security sandbox rules.localX
+     * The horizontal coordinate at which the event occurred relative to the containing sprite.localY
+     * The vertical coordinate at which the event occurred relative to the containing sprite.
+     * pressureA value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure, the value is 1.0.related
+     * ObjectA reference to a display list object related to the event.shiftKey
+     * true if the Shift key is active; false if it is inactive.sizeX
+     * Width of the contact area.sizeYHeight of the contact area.stageX
+     * The horizontal coordinate at which the event occurred in global stage coordinates.stageY
+     * The vertical coordinate at which the event occurred in global stage coordinates.
+     * targetThe InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.
+     * touchPointIDA unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_END = 'touchEnd';
+    /**
+     * Defines the value of the type property of a TOUCH_MOVE touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:PropertyValue
+     * altKeytrue if the Alt key is active (Windows or Linux).bubblestruecancelablefalse;
+     * there is no default behavior to cancel.commandKeytrue on the Mac if the Command key is active;
+     * false if it is inactive. Always false on Windows.controlKeytrue if the Ctrl or Control key is active;
+     * false if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise, false.currentTarget
+     * The object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event flow.isRelatedObjectInaccessible
+     * true if the relatedObject property is set to null because of security sandbox rules.localX
+     * The horizontal coordinate at which the event occurred relative to the containing sprite.localY
+     * The vertical coordinate at which the event occurred relative to the containing sprite.pressure
+     * A value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure, the value is 1.0.related
+     * ObjectA reference to a display list object related to the event.shiftKeytrue
+     * if the Shift key is active; false if it is inactive.sizeXWidth of the contact area.sizeY
+     * Height of the contact area.stageXThe horizontal coordinate
+     * at which the event occurred in global stage coordinates.
+     * stageYThe vertical coordinate at which the event occurred in global stage coordinates.
+     * targetThe InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.
+     * touchPointIDA unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_MOVE = 'touchMove';
+    /**
+     * Defines the value of the type property of a TOUCH_OUT touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:
+     * PropertyValuealtKeytrue if the Alt key is active (Windows or Linux).bubblestruecancelablefalse;
+     * there is no default behavior to cancel.commandKeytrue on the Mac if the Command key is active;
+     * false if it is inactive. Always false on Windows.controlKeytrue if the Ctrl or Control key is active;
+     * false if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise, false.currentTarget
+     * The object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event flow.isRelatedObjectInaccessibletrue
+     * if the relatedObject property is set to null because of security sandbox rules.localX
+     * The horizontal coordinate at which the event occurred relative to the containing sprite.localY
+     * The vertical coordinate at which the event occurred relative to the containing sprite.pressure
+     * A value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure, the value is 1.0.relatedObject
+     * A reference to a display list object related to the event.shiftKeytrue if the Shift key is active;
+     * false if it is inactive.sizeXWidth of the contact area.sizeYHeight of the contact area.stageX
+     * The horizontal coordinate at which the event occurred in global stage coordinates.stageY
+     * The vertical coordinate at which the event occurred in global stage coordinates.target
+     * The InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.touchPoint
+     * IDA unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_OUT = 'touchOut';
+    /**
+     * Defines the value of the type property of a TOUCH_OVER touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:PropertyValuealtKey
+     * true if the Alt key is active (Windows or Linux).bubblestruecancelablefalse;
+     * there is no default behavior to cancel.commandKeytrue on the Mac if the Command key is active;
+     * false if it is inactive. Always false on Windows.controlKeytrue if the Ctrl or Control key is active; false
+     * if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise,
+     * false.currentTargetThe object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event
+     * flow.isRelatedObjectInaccessibletrue if the relatedObject property
+     * is set to null because of security sandbox rules.
+     * localXThe horizontal coordinate at which the event occurred relative to the containing sprite.localY
+     * The vertical coordinate at which the event occurred relative to the containing sprite.pressure
+     * A value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure, the value is 1.0.relatedObject
+     * A reference to a display list object related to the event.shiftKeytrue
+     * if the Shift key is active; false if it is inactive.sizeXWidth of the contact area.sizeY
+     * Height of the contact area.stageXThe horizontal coordinate at which
+     * the event occurred in global stage coordinates.stageYThe vertical coordinate
+     * at which the event occurred in global stage coordinates.target
+     * The InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.
+     * touchPointIDA unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_OVER = 'touchOver';
+    /**
+     * Defines the value of the type property of a TOUCH_ROLL_OUT touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:PropertyValuealtKeytrue
+     * if the Alt key is active (Windows or Linux).bubblestruecancelablefalse; there is no default behavior to cancel.
+     * commandKeytrue on the Mac if the Command key is active; false if it is inactive.
+     * Always false on Windows.controlKeytrue if the Ctrl or Control key is active;
+     * false if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise, false.currentTarget
+     * The object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event flow.isRelatedObjectInaccessibletrue
+     * if the relatedObject property is set to null because of security sandbox rules.localX
+     * The horizontal coordinate at which the event occurred relative to the containing sprite.localY
+     * The vertical coordinate at which the event occurred relative to the containing sprite.pressure
+     * A value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure, the value is 1.0.relatedObject
+     * A reference to a display list object related to the event.shiftKeytrue if the Shift key is active;
+     * false if it is inactive.sizeXWidth of the contact area.sizeYHeight of the contact area.stageX
+     * The horizontal coordinate at which the event occurred in global stage coordinates.stageY
+     * The vertical coordinate at which the event occurred in global stage coordinates.target
+     * The InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.touchPointID
+     * A unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_ROLL_OUT = 'touchRollOut';
+    /**
+     * Defines the value of the type property of a TOUCH_ROLL_OVER touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:PropertyValuealtKey
+     * true if the Alt key is active (Windows or Linux).bubblestruecancelablefalse;
+     * #there is no default behavior to cancel.commandKeytrue on the Mac if the Command key is active;
+     * false if it is inactive. Always false on Windows.controlKeytrue if the Ctrl or Control key is active;
+     * false if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise, false.currentTarget
+     * The object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event flow.isRelatedObjectInaccessibletrue
+     * if the relatedObject property is set to null because of security sandbox rules.localX
+     * The horizontal coordinate at which the event occurred relative to the containing sprite.localY
+     * The vertical coordinate at which the event occurred relative to the containing sprite.pressure
+     * A value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure, the value is 1.0.relatedObject
+     * A reference to a display list object related to the event.shiftKeytrue if the Shift key is active;
+     * false if it is inactive.sizeXWidth of the contact area.sizeYHeight of the contact area.stageX
+     * The horizontal coordinate at which the event occurred in global stage coordinates.stageY
+     * The vertical coordinate at which the event occurred in global stage coordinates.target
+     * The InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.touchPointID
+     * A unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_ROLL_OVER = 'touchRollOver';
+    /**
+     * Defines the value of the type property of a TOUCH_TAP touch event object.
+     *
+     *   The dispatched TouchEvent object has the following properties:PropertyValuealtKeytrue
+     * if the Alt key is active (Windows or Linux).bubblestruecancelablefalse;
+     * there is no default behavior to cancel.commandKeytrue on the Mac if the Command key is active;
+     * false if it is inactive. Always false on Windows.controlKeytrue if the Ctrl or Control key is active;
+     * false if it is inactive.ctrlKeytrue on Windows or Linux if the Ctrl key is active.
+     * true on Mac if either the Ctrl key or the Command key is active. Otherwise, false.currentTarget
+     * The object that is actively processing the Event
+     * object with an event listener.eventPhaseThe current phase in the event flow.isRelatedObjectInaccessibletrue
+     * if the relatedObject property is set to null because of security sandbox rules.localX
+     * The horizontal coordinate at which the event occurred relative to the containing sprite.localY
+     * The vertical coordinate at which the event occurred relative to the containing sprite.
+     * pressureA value between 0.0 and 1.0 indicating force of the contact with the device.
+     * If the device does not support detecting the pressure,
+     * the value is 1.0.relatedObjectA reference to a display list object related to the event.shiftKey
+     * true if the Shift key is active; false if it is inactive.sizeXWidth of the contact area.sizeY
+     * Height of the contact area.stageX
+     * The horizontal coordinate at which the event occurred in global stage coordinates.
+     * stageYThe vertical coordinate at which the event occurred in global stage coordinates.target
+     * The InteractiveObject instance under the touching device.
+     * The target is not always the object in the display list
+     * that registered the event listener. Use the currentTarget
+     * property to access the object in the display list that is currently processing the event.touchPointID
+     * A unique identification number (as an int) assigned to the touch point.
+     */
+    TouchEvent.TOUCH_TAP = 'touchTap';
+    return TouchEvent;
+}(Event));
+export { TouchEvent };

package/dist/lib/events/TransformGestureEvent.d.ts

@@ -0,0 +1,12 @@
+import { GestureEvent } from './GestureEvent';
+export declare class TransformGestureEvent extends GestureEvent {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean, phase?: string, localX?: number, localY?: number, scaleX?: number, scaleY?: number, rotation?: number, offsetX?: number, offsetY?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean);
+    static GESTURE_ZOOM: string;
+    static GESTURE_PAN: string;
+    static GESTURE_ROTATE: string;
+    static GESTURE_SWIPE: string;
+}
+//# sourceMappingURL=TransformGestureEvent.d.ts.map

package/dist/lib/events/TransformGestureEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformGestureEvent.d.ts","sourceRoot":"","sources":["../../../lib/events/TransformGestureEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,qBAAa,qBAAsB,SAAQ,YAAY;IAEtD,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IACtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;gBAE7B,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAc,EAAE,UAAU,GAAE,OAAe,EAC7E,KAAK,GAAE,MAAa,EAAE,MAAM,GAAE,MAAU,EAAE,MAAM,GAAE,MAAU,EAAE,MAAM,GAAE,MAAU,EAChF,MAAM,GAAE,MAAU,EAAE,QAAQ,GAAE,MAAU,EAAE,OAAO,GAAE,MAAU,EAAE,OAAO,GAAE,MAAU,EAClF,OAAO,GAAE,OAAe,EAAE,MAAM,GAAE,OAAe,EAAE,QAAQ,GAAE,OAAe;IAK7E,MAAM,CAAC,YAAY,EAAE,MAAM,CAAiB;IAC5C,MAAM,CAAC,WAAW,EAAE,MAAM,CAAgB;IAC1C,MAAM,CAAC,cAAc,EAAE,MAAM,CAAmB;IAChD,MAAM,CAAC,aAAa,EAAE,MAAM,CAAkB;CAC9C"}

package/dist/lib/events/TransformGestureEvent.js

@@ -0,0 +1,31 @@
+import { __extends } from "tslib";
+import { GestureEvent } from './GestureEvent';
+var TransformGestureEvent = /** @class */ (function (_super) {
+    __extends(TransformGestureEvent, _super);
+    function TransformGestureEvent(type, bubbles, cancelable, phase, localX, localY, scaleX, scaleY, rotation, offsetX, offsetY, ctrlKey, altKey, shiftKey) {
+        if (bubbles === void 0) { bubbles = true; }
+        if (cancelable === void 0) { cancelable = false; }
+        if (phase === void 0) { phase = null; }
+        if (localX === void 0) { localX = 0; }
+        if (localY === void 0) { localY = 0; }
+        if (scaleX === void 0) { scaleX = 1; }
+        if (scaleY === void 0) { scaleY = 1; }
+        if (rotation === void 0) { rotation = 0; }
+        if (offsetX === void 0) { offsetX = 0; }
+        if (offsetY === void 0) { offsetY = 0; }
+        if (ctrlKey === void 0) { ctrlKey = false; }
+        if (altKey === void 0) { altKey = false; }
+        if (shiftKey === void 0) { shiftKey = false; }
+        return _super.call(this, type, bubbles, cancelable, phase, localX, localY, ctrlKey, altKey, shiftKey) || this;
+    }
+    TransformGestureEvent.classInitializer = null;
+    TransformGestureEvent.classSymbols = null;
+    TransformGestureEvent.instanceSymbols = null;
+    // JS -> AS Bindings
+    TransformGestureEvent.GESTURE_ZOOM = 'gestureZoom';
+    TransformGestureEvent.GESTURE_PAN = 'gesturePan';
+    TransformGestureEvent.GESTURE_ROTATE = 'gestureRotate';
+    TransformGestureEvent.GESTURE_SWIPE = 'gestureSwipe';
+    return TransformGestureEvent;
+}(GestureEvent));
+export { TransformGestureEvent };

package/dist/lib/events/UncaughtErrorEvent.d.ts

@@ -0,0 +1,9 @@
+import { ErrorEvent } from './ErrorEvent';
+export declare class UncaughtErrorEvent extends ErrorEvent {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor(type?: string, bubbles?: boolean, cancelable?: boolean, error_in?: any);
+    static UNCAUGHT_ERROR: string;
+}
+//# sourceMappingURL=UncaughtErrorEvent.d.ts.map

package/dist/lib/events/UncaughtErrorEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UncaughtErrorEvent.d.ts","sourceRoot":"","sources":["../../../lib/events/UncaughtErrorEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,qBAAa,kBAAmB,SAAQ,UAAU;IAEjD,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IACtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;gBAE7B,IAAI,GAAE,MAAwB,EAAE,OAAO,GAAE,OAAc,EAAE,UAAU,GAAE,OAAc,EAC9F,QAAQ,GAAE,GAAU;IAKrB,MAAM,CAAC,cAAc,EAAE,MAAM,CAAmB;CAChD"}

package/dist/lib/events/UncaughtErrorEvent.js

@@ -0,0 +1,19 @@
+import { __extends } from "tslib";
+import { ErrorEvent } from './ErrorEvent';
+var UncaughtErrorEvent = /** @class */ (function (_super) {
+    __extends(UncaughtErrorEvent, _super);
+    function UncaughtErrorEvent(type, bubbles, cancelable, error_in) {
+        if (type === void 0) { type = 'uncaughtError'; }
+        if (bubbles === void 0) { bubbles = true; }
+        if (cancelable === void 0) { cancelable = true; }
+        if (error_in === void 0) { error_in = null; }
+        return _super.call(this, type, bubbles, cancelable, error_in) || this;
+    }
+    UncaughtErrorEvent.classInitializer = null;
+    UncaughtErrorEvent.classSymbols = null;
+    UncaughtErrorEvent.instanceSymbols = null;
+    // JS -> AS Bindings
+    UncaughtErrorEvent.UNCAUGHT_ERROR = 'uncaughtError';
+    return UncaughtErrorEvent;
+}(ErrorEvent));
+export { UncaughtErrorEvent };

package/dist/lib/events/UncaughtErrorEvents.d.ts

@@ -0,0 +1,23 @@
+import { EventDispatcher } from './EventDispatcher';
+/**
+ * Copyright 2014 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare class UncaughtErrorEvents extends EventDispatcher {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor();
+}
+//# sourceMappingURL=UncaughtErrorEvents.d.ts.map

package/dist/lib/events/UncaughtErrorEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UncaughtErrorEvents.d.ts","sourceRoot":"","sources":["../../../lib/events/UncaughtErrorEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AAEH,qBAAa,mBAAoB,SAAQ,eAAe;IAEvD,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IACtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;;CAKzC"}