@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/events/EventDispatcherBase.js

@@ -0,0 +1,258 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+/**
+ * Base export class for dispatching events
+*
+* @export class away.events.EventDispatcher
+*
+*/
+var EventDispatcherBase = /** @class */ (function (_super) {
+    __extends(EventDispatcherBase, _super);
+    function EventDispatcherBase(target) {
+        if (target === void 0) { target = null; }
+        var _this = _super.call(this) || this;
+        _this._t = target || _this;
+        _this._listenerObjects || (_this._listenerObjects = []);
+        return _this;
+    }
+    EventDispatcherBase.prototype.toString = function () {
+        return '';
+    };
+    /**
+     * Add an event listener
+     * @method addEventListener
+     * @param {String} Name of event to add a listener for
+     * @param {Function} Callback function
+     */
+    EventDispatcherBase.prototype.addEventListener = function (type, listener, useCapture, priority, useWeakReference) {
+        if (useCapture === void 0) { useCapture = false; }
+        if (priority === void 0) { priority = 0; }
+        if (useWeakReference === void 0) { useWeakReference = false; }
+        this._listenerObjects || (this._listenerObjects = []);
+        var l = this._listenerObjects[type];
+        if (l === undefined)
+            l = this._listenerObjects[type] = new ListenerObject();
+        l.addEventListener(listener, priority);
+    };
+    /**
+     * Remove an event listener
+     * @method removeEventListener
+     * @param {String} Name of event to remove a listener for
+     * @param {Function} Callback function
+     */
+    EventDispatcherBase.prototype.removeEventListener = function (type, listener) {
+        this._listenerObjects || (this._listenerObjects = []);
+        var l = this._listenerObjects[type];
+        if (l) {
+            l.removeEventListener(listener);
+            if (l.numListeners == 0)
+                delete this._listenerObjects[type];
+        }
+    };
+    /**
+     * Dispatch an event
+     * @method dispatchEvent
+     * @param {Event} Event to dispatch
+     */
+    EventDispatcherBase.prototype.dispatchEvent = function (event) {
+        this._listenerObjects || (this._listenerObjects = []);
+        var l = this._listenerObjects[event.type];
+        if (l) {
+            // Flash reports the aggregation target (EventDispatcher(target) constructor arg)
+            // as currentTarget during dispatch — e.g. GreenSock dispatches tween events via an
+            // internal aggregated dispatcher and handlers cast event.currentTarget to the tween.
+            if (this._t)
+                event.currentTarget = this._t;
+            if (!event.target)
+                event.target = this._t;
+            //console.log("dispatchEvent", event.type, (<any>this).adaptee?.id);
+            l.dispatchEvent(event);
+        }
+        return true;
+    };
+    /**
+     * check if an object has an event listener assigned to it
+     * @method hasListener
+     * @param {String} Name of event to remove a listener for
+     * @param {Function} Callback function
+     */
+    EventDispatcherBase.prototype.hasEventListener = function (type, listener) {
+        if (this._listenerObjects[type] === undefined)
+            return false;
+        if (listener != null)
+            return this._listenerObjects[type].getEventListenerIndex(listener) !== -1;
+        return this._listenerObjects[type].numListeners > 0;
+    };
+    return EventDispatcherBase;
+}(ASObject));
+export { EventDispatcherBase };
+function sortListenersByPriority(a, b) {
+    return a.priority < b.priority ? -1 : 1;
+}
+var ListenerObject = /** @class */ (function () {
+    function ListenerObject() {
+        this._index = 0;
+        this._singlePriority = 0;
+        this._listeners = new Array();
+        this.numListeners = 0;
+    }
+    ListenerObject.prototype.addEventListener = function (listener, priority) {
+        // if event already exists, it will not be added again, and old priority will remain
+        if (priority === void 0) { priority = 0; }
+        if (!this._listenersByPriority) {
+            // single priority mode:
+            if (this._listeners.indexOf(listener) !== -1) {
+                // the listener is already present - do nothing just return
+                return;
+            }
+            else {
+                // its a new listener
+                if (this._listeners.length == 0 || priority == this._singlePriority) {
+                    // same priority as existing listeners. just add it and return
+                    this._listeners.push(listener);
+                    this.numListeners++;
+                    return;
+                }
+                else {
+                    // different priority - switch to multi-priority mode
+                    if (this._singlePriority < priority) {
+                        this._listenersByPriority = [
+                            {
+                                priority: this._singlePriority,
+                                listeners: this._listeners.concat()
+                            },
+                            {
+                                priority: priority,
+                                listeners: [listener]
+                            }
+                        ];
+                    }
+                    else {
+                        this._listenersByPriority = [
+                            {
+                                priority: priority,
+                                listeners: [listener]
+                            },
+                            {
+                                priority: this._singlePriority,
+                                listeners: this._listeners.concat()
+                            }
+                        ];
+                    }
+                    this.numListeners++;
+                }
+                return;
+            }
+        }
+        // multi-priority mode:
+        //check if a listener already exists
+        for (var i = 0; i < this._listenersByPriority.length; i++) {
+            if (this._listenersByPriority[i].listeners.indexOf(listener) !== -1) {
+                return;
+            }
+        }
+        // find priority item
+        var priorityItem = null;
+        for (var i = 0; i < this._listenersByPriority.length; i++) {
+            if (this._listenersByPriority[i].priority == priority) {
+                priorityItem = this._listenersByPriority[i];
+                break;
+            }
+        }
+        if (!priorityItem) {
+            priorityItem = {
+                priority: priority,
+                listeners: []
+            };
+            this._listenersByPriority.push(priorityItem);
+            if (this._listenersByPriority.length > 1) {
+                this._listenersByPriority.sort(sortListenersByPriority);
+            }
+        }
+        priorityItem.listeners.push(listener);
+        this.numListeners++;
+    };
+    ListenerObject.prototype.removeEventListener = function (listener) {
+        var index = -1;
+        if (!this._listenersByPriority) {
+            index = this._listeners.indexOf(listener);
+            if (index === -1)
+                return;
+            this._listeners.splice(index, 1);
+            this.numListeners--;
+            return;
+        }
+        //check if listener exists
+        for (var i = 0; i < this._listenersByPriority.length; i++) {
+            index = this._listenersByPriority[i].listeners.indexOf(listener);
+            if (index !== -1) {
+                this.numListeners--;
+                this._listenersByPriority[i].listeners.splice(index, 1);
+                return;
+            }
+        }
+    };
+    ListenerObject.prototype.dispatchEvent = function (event) {
+        // when listeners do attach/remove new listeners the new listeners will be ignored during this dispatch,
+        // and listeners that got removed will still dispatch during this dispatch
+        // this means we need to concat the listener-array before we iterate it
+        if (!this._listenersByPriority) {
+            // single-priority mode:
+            var listeners = this._listeners.length > 1 ? this._listeners.concat() : this._listeners;
+            var numListeners = listeners.length;
+            var i = 0;
+            for (i = 0; i < numListeners; i++) {
+                if (listeners[i])
+                    listeners[i].call(listeners[i], event);
+            }
+            return;
+        }
+        // multi-priority mode:
+        var p = this._listenersByPriority.length;
+        //console.log("multi-priority mode", p);
+        while (p > 0) {
+            p--;
+            //console.log("multi-priority mode next", p);
+            var listeners = this._listenersByPriority[p].listeners.length > 1 ?
+                this._listenersByPriority[p].listeners.concat() : this._listenersByPriority[p].listeners;
+            var numListeners = listeners.length;
+            var i = 0;
+            //let len=events.length;
+            //console.log("events", len);
+            for (i = 0; i < numListeners; i++) {
+                if (listeners[i])
+                    listeners[i].call(listeners[i], event);
+            }
+        }
+        if (this._listenersByPriority.length == 1) {
+            // if only 1 priority exists, we can go back to single-priority-mode
+            this._listeners = this._listenersByPriority[0].listeners.concat();
+            this._singlePriority = this._listenersByPriority[0].priority;
+            this._listenersByPriority = null;
+        }
+    };
+    /**
+     * get Event Listener Index in array. Returns -1 if no listener is added
+     * @method getEventListenerIndex
+     * @param {String} Name of event to remove a listener for
+     * @param {Function} Callback function
+     */
+    ListenerObject.prototype.getEventListenerIndex = function (listener) {
+        if (!this._listenersByPriority) {
+            // single-priority mode:
+            return this._listeners.indexOf(listener);
+        }
+        // multi-priority mode:
+        for (var i = 0; i < this._listenersByPriority.length; i++) {
+            for (var e = 0; e < this._listenersByPriority[i].listeners.length; e++) {
+                if (this._listenersByPriority[i].listeners[e] == listener) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    };
+    return ListenerObject;
+}());
+export { ListenerObject };
+export default EventDispatcherBase;

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

@@ -0,0 +1,26 @@
+import { ASObject } from '@awayfl/avm2';
+/**
+ * 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 EventPhase extends ASObject {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor();
+    static CAPTURING_PHASE: number;
+    static AT_TARGET: number;
+    static BUBBLING_PHASE: number;
+}
+//# sourceMappingURL=EventPhase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EventPhase.d.ts","sourceRoot":"","sources":["../../../lib/events/EventPhase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC;;;;;;;;;;;;;;GAcG;AAEH,qBAAa,UAAW,SAAQ,QAAQ;IAEvC,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IACtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;;IAOzC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAc;IAC5C,MAAM,CAAC,SAAS,EAAE,MAAM,CAAc;IACtC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAc;CAC3C"}

package/dist/lib/events/EventPhase.js

@@ -0,0 +1,33 @@
+import { __extends } from "tslib";
+import { ASObject } from '@awayfl/avm2';
+/**
+ * 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.
+ */
+// Class: EventPhase
+var EventPhase = /** @class */ (function (_super) {
+    __extends(EventPhase, _super);
+    function EventPhase() {
+        return _super.call(this) || this;
+    }
+    EventPhase.classInitializer = null;
+    EventPhase.classSymbols = null;
+    EventPhase.instanceSymbols = null;
+    // JS -> AS Bindings
+    EventPhase.CAPTURING_PHASE = 1;
+    EventPhase.AT_TARGET = 2;
+    EventPhase.BUBBLING_PHASE = 3;
+    return EventPhase;
+}(ASObject));
+export { EventPhase };

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

@@ -0,0 +1,50 @@
+import { FocusEvent as FocusEventAway } from '@awayjs/scene';
+import { Event } from './Event';
+import { InteractiveObject } from '../display/InteractiveObject';
+export declare class FocusEvent extends Event {
+    static FOCUS_IN: string;
+    static FOCUS_OUT: string;
+    static KEY_FOCUS_CHANGE: string;
+    static MOUSE_FOCUS_CHANGE: string;
+    private adaptee;
+    /**
+     * 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.
+     * @langversion	3.0
+     * @playerversion	Flash 10
+     * @playerversion	Lite 4
+     */
+    get isRelatedObjectInaccessible(): boolean;
+    set isRelatedObjectInaccessible(value: boolean);
+    /**
+     * The key code value of the key pressed to trigger a keyFocusChange event.
+     */
+    get keyCode(): number;
+    set keyCode(value: number);
+    /**
+     * A reference to the complementary InteractiveObject instance that is affected by the
+     * change in focus. For example, when a focusOut event occurs, the
+     * relatedObject represents the InteractiveObject instance that has gained focus.
+     * The value of this property can be null in two circumstances: if there 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 relatedObject(): InteractiveObject;
+    set relatedObject(value: InteractiveObject);
+    /**
+     * Indicates whether the Shift key modifier is activated, in which case the value is
+     * true. Otherwise, the value is false. This property is
+     * used only if the FocusEvent is of type keyFocusChange.
+     */
+    get shiftKey(): boolean;
+    set shiftKey(value: boolean);
+    clone(): Event;
+    toString(): string;
+    fillFromAway(awayEvent: FocusEventAway): void;
+}
+//# sourceMappingURL=FocusEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FocusEvent.d.ts","sourceRoot":"","sources":["../../../lib/events/FocusEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,qBAAa,UAAW,SAAQ,KAAK;IAEpC,OAAc,QAAQ,SAAW;IACjC,OAAc,SAAS,SAAY;IACnC,OAAc,gBAAgB,SAAkB;IAChD,OAAc,kBAAkB,SAAoB;IAEpD,OAAO,CAAC,OAAO,CAAiB;IAEhC;;;;;;;;;;;OAWG;IACH,IAAW,2BAA2B,IAAK,OAAO,CAGjD;IAED,IAAW,2BAA2B,CAAE,KAAK,EAAE,OAAO,EAErD;IAED;;OAEG;IACH,IAAW,OAAO,IAAK,MAAM,CAG5B;IAED,IAAW,OAAO,CAAE,KAAK,EAAE,MAAM,EAEhC;IAED;;;;;;;OAOG;IACH,IAAW,aAAa,IAAK,iBAAiB,CAG7C;IAED,IAAW,aAAa,CAAE,KAAK,EAAE,iBAAiB,EAEjD;IAED;;;;OAIG;IACH,IAAW,QAAQ,IAAK,OAAO,CAG9B;IAED,IAAW,QAAQ,CAAE,KAAK,EAAE,OAAO,EAElC;IAEM,KAAK,IAAI,KAAK;IAKd,QAAQ,IAAI,MAAM;IAMlB,YAAY,CAAE,SAAS,EAAE,cAAc;CAQ9C"}

package/dist/lib/events/FocusEvent.js

@@ -0,0 +1,102 @@
+import { __extends } from "tslib";
+import { Event } from './Event';
+var FocusEvent = /** @class */ (function (_super) {
+    __extends(FocusEvent, _super);
+    function FocusEvent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(FocusEvent.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.
+         * @langversion	3.0
+         * @playerversion	Flash 10
+         * @playerversion	Lite 4
+         */
+        get: function () {
+            console.log('isRelatedObjectInaccessible not implemented yet in flash/FocusEvent');
+            return false;
+        },
+        set: function (value) {
+            console.log('isRelatedObjectInaccessible not implemented yet in flash/FocusEvent');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FocusEvent.prototype, "keyCode", {
+        /**
+         * The key code value of the key pressed to trigger a keyFocusChange event.
+         */
+        get: function () {
+            console.log('keyCode not implemented yet in flash/FocusEvent');
+            return 0;
+        },
+        set: function (value) {
+            console.log('keyCode not implemented yet in flash/FocusEvent');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FocusEvent.prototype, "relatedObject", {
+        /**
+         * A reference to the complementary InteractiveObject instance that is affected by the
+         * change in focus. For example, when a focusOut event occurs, the
+         * relatedObject represents the InteractiveObject instance that has gained focus.
+         * The value of this property can be null in two circumstances: if there 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 () {
+            console.log('relatedObject not implemented yet in flash/FocusEvent');
+            return null;
+        },
+        set: function (value) {
+            console.log('relatedObject not implemented yet in flash/FocusEvent');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(FocusEvent.prototype, "shiftKey", {
+        /**
+         * Indicates whether the Shift key modifier is activated, in which case the value is
+         * true. Otherwise, the value is false. This property is
+         * used only if the FocusEvent is of type keyFocusChange.
+         */
+        get: function () {
+            console.log('shiftKey not implemented yet in flash/FocusEvent');
+            return false;
+        },
+        set: function (value) {
+            console.log('shiftKey not implemented yet in flash/FocusEvent');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    FocusEvent.prototype.clone = function () {
+        console.log('clone not implemented yet in flash/IOErrorEvent');
+        return null;
+    };
+    FocusEvent.prototype.toString = function () {
+        console.log('toString not implemented yet in flash/FocusEvent');
+        return '';
+    };
+    /* added to clone events from away to as3web. */
+    FocusEvent.prototype.fillFromAway = function (awayEvent) {
+        //console.log("cloneFromAway not implemented yet in flash/MouseEvent");
+        this.adaptee = awayEvent;
+        // todo: set targets correctly
+        this.target = awayEvent.target;
+        //this.currentTarget = awayEvent.currentTarget;
+    };
+    FocusEvent.FOCUS_IN = 'focusIn';
+    FocusEvent.FOCUS_OUT = 'focusOut';
+    FocusEvent.KEY_FOCUS_CHANGE = 'keyFocusChange';
+    FocusEvent.MOUSE_FOCUS_CHANGE = 'mouseFocusChange';
+    return FocusEvent;
+}(Event));
+export { FocusEvent };

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

@@ -0,0 +1,12 @@
+import { ActivityEvent } from './ActivityEvent';
+export declare class FullScreenEvent extends ActivityEvent {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    fullScreen: boolean;
+    interactive: boolean;
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean, fullScreen?: boolean, interactive?: boolean);
+    static FULL_SCREEN: string;
+    static FULL_SCREEN_INTERACTIVE_ACCEPTED: string;
+}
+//# sourceMappingURL=FullScreenEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FullScreenEvent.d.ts","sourceRoot":"","sources":["../../../lib/events/FullScreenEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,qBAAa,eAAgB,SAAQ,aAAa;IAEjD,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IACtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;IAEzC,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;gBAET,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe,EAAE,UAAU,GAAE,OAAe,EAC9E,UAAU,GAAE,OAAe,EAAE,WAAW,GAAE,OAAe;IAO1D,MAAM,CAAC,WAAW,EAAE,MAAM,CAAgB;IAC1C,MAAM,CAAC,gCAAgC,EAAE,MAAM,CAAmC;CAClF"}

package/dist/lib/events/FullScreenEvent.js

@@ -0,0 +1,23 @@
+import { __extends } from "tslib";
+import { ActivityEvent } from './ActivityEvent';
+var FullScreenEvent = /** @class */ (function (_super) {
+    __extends(FullScreenEvent, _super);
+    function FullScreenEvent(type, bubbles, cancelable, fullScreen, interactive) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        if (fullScreen === void 0) { fullScreen = false; }
+        if (interactive === void 0) { interactive = false; }
+        var _this = _super.call(this, type, bubbles, cancelable) || this;
+        _this.fullScreen = !!fullScreen;
+        _this.interactive = !!interactive;
+        return _this;
+    }
+    FullScreenEvent.classInitializer = null;
+    FullScreenEvent.classSymbols = null;
+    FullScreenEvent.instanceSymbols = null;
+    // JS -> AS Bindings
+    FullScreenEvent.FULL_SCREEN = 'fullScreen';
+    FullScreenEvent.FULL_SCREEN_INTERACTIVE_ACCEPTED = 'fullScreenInteractiveAccepted';
+    return FullScreenEvent;
+}(ActivityEvent));
+export { FullScreenEvent };

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

@@ -0,0 +1,27 @@
+import { Event } from './Event';
+import { GameInputDevice } from '../ui/GameInputDevice';
+/**
+ * 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 GameInputEvent extends Event {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    device: GameInputDevice;
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean, device?: GameInputDevice);
+    static DEVICE_ADDED: string;
+    static DEVICE_REMOVED: string;
+}
+//# sourceMappingURL=GameInputEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GameInputEvent.d.ts","sourceRoot":"","sources":["../../../lib/events/GameInputEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AAEH,qBAAa,cAAe,SAAQ,KAAK;IAExC,MAAM,CAAC,gBAAgB,EAAE,GAAG,CAAQ;IAEpC,MAAM,CAAC,YAAY,EAAE,MAAM,EAAG,CAAQ;IACtC,MAAM,CAAC,eAAe,EAAE,MAAM,EAAG,CAAQ;IACzC,MAAM,EAAE,eAAe,CAAC;gBAEZ,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAe,EAAE,UAAU,GAAE,OAAe,EAC9E,MAAM,GAAE,eAAsB;IAO/B,MAAM,CAAC,YAAY,EAAE,MAAM,CAAiB;IAC5C,MAAM,CAAC,cAAc,EAAE,MAAM,CAAmB;CAChD"}

package/dist/lib/events/GameInputEvent.js

@@ -0,0 +1,38 @@
+import { __extends } from "tslib";
+import { Event } from './Event';
+/**
+ * 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.
+ */
+// Class: GameInputEvent
+var GameInputEvent = /** @class */ (function (_super) {
+    __extends(GameInputEvent, _super);
+    function GameInputEvent(type, bubbles, cancelable, device) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        if (device === void 0) { device = null; }
+        var _this = _super.call(this, type, bubbles, cancelable) || this;
+        // TODO: coerce
+        _this.device = device;
+        return _this;
+    }
+    GameInputEvent.classInitializer = null;
+    GameInputEvent.classSymbols = null;
+    GameInputEvent.instanceSymbols = null;
+    // JS -> AS Bindings
+    GameInputEvent.DEVICE_ADDED = 'deviceAdded';
+    GameInputEvent.DEVICE_REMOVED = 'deviceRemoved';
+    return GameInputEvent;
+}(Event));
+export { GameInputEvent };

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

@@ -0,0 +1,9 @@
+import { Event } from './Event';
+export declare class GeolocationEvent extends Event {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean, latitude?: number, longitude?: number, altitude?: number, hAccuracy?: number, vAccuracy?: number, speed?: number, heading?: number, timestamp?: number);
+    static UPDATE: string;
+}
+//# sourceMappingURL=GeolocationEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GeolocationEvent.d.ts","sourceRoot":"","sources":["../../../lib/events/GeolocationEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,qBAAa,gBAAiB,SAAQ,KAAK;IAE1C,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,OAAe,EAAE,UAAU,GAAE,OAAe,EAC9E,QAAQ,GAAE,MAAU,EAAE,SAAS,GAAE,MAAU,EAAE,QAAQ,GAAE,MAAU,EACjE,SAAS,GAAE,MAAU,EAAE,SAAS,GAAE,MAAU,EAAE,KAAK,GAAE,MAAU,EAC/D,OAAO,GAAE,MAAU,EAAE,SAAS,GAAE,MAAU;IAK3C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAY;CACjC"}

package/dist/lib/events/GeolocationEvent.js

@@ -0,0 +1,25 @@
+import { __extends } from "tslib";
+import { Event } from './Event';
+var GeolocationEvent = /** @class */ (function (_super) {
+    __extends(GeolocationEvent, _super);
+    function GeolocationEvent(type, bubbles, cancelable, latitude, longitude, altitude, hAccuracy, vAccuracy, speed, heading, timestamp) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        if (latitude === void 0) { latitude = 0; }
+        if (longitude === void 0) { longitude = 0; }
+        if (altitude === void 0) { altitude = 0; }
+        if (hAccuracy === void 0) { hAccuracy = 0; }
+        if (vAccuracy === void 0) { vAccuracy = 0; }
+        if (speed === void 0) { speed = 0; }
+        if (heading === void 0) { heading = 0; }
+        if (timestamp === void 0) { timestamp = 0; }
+        return _super.call(this, type, bubbles, cancelable) || this;
+    }
+    GeolocationEvent.classInitializer = null;
+    GeolocationEvent.classSymbols = null;
+    GeolocationEvent.instanceSymbols = null;
+    // JS -> AS Bindings
+    GeolocationEvent.UPDATE = 'update';
+    return GeolocationEvent;
+}(Event));
+export { GeolocationEvent };

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

@@ -0,0 +1,33 @@
+import { Event } from './Event';
+export declare class GestureEvent extends Event {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor(type: string, bubbles?: boolean, cancelable?: boolean, phase?: string, localX?: number, localY?: number, ctrlKey?: boolean, altKey?: boolean, shiftKey?: boolean);
+    static GESTURE_TWO_FINGER_TAP: string;
+    private _phase;
+    private _localX;
+    private _localY;
+    private _ctrlKey;
+    private _altKey;
+    private _shiftKey;
+    get localX(): number;
+    set localX(value: number);
+    get localY(): number;
+    set localY(value: number);
+    get stageX(): number;
+    get stageY(): number;
+    get ctrlKey(): boolean;
+    set ctrlKey(value: boolean);
+    get altKey(): boolean;
+    set altKey(value: boolean);
+    get shiftKey(): boolean;
+    set shiftKey(value: boolean);
+    get phase(): string;
+    set phase(value: string);
+    updateAfterEvent(): void;
+    NativeCtor(phase: string, localX: number, localY: number, ctrlKey: boolean, altKey: boolean, shiftKey: boolean): void;
+    clone(): Event;
+    toString(): string;
+}
+//# sourceMappingURL=GestureEvent.d.ts.map