@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/display/MovieClip.js

@@ -0,0 +1,540 @@
+import { __extends } from "tslib";
+import { MovieClip as AwayMovieClip, FrameScriptManager, Timeline } from '@awayjs/scene';
+import { Sprite } from './Sprite';
+import { Debug } from '@awayjs/core';
+import { constructClassFromSymbol } from '@awayfl/avm2';
+import { Event } from '../events/Event';
+/**
+ * The MovieClip class inherits from the following classes: Sprite, DisplayObjectContainer,
+ * InteractiveObject, DisplayObject, and EventDispatcher.
+ *
+ *   <p class="- topic/p ">Unlike the Sprite object, a MovieClip object has a timeline.</p><p class="- topic/p ">&gt;
+ * In Flash Professional, the methods for the MovieClip class provide the same functionality
+ * as actions that target movie clips. Some additional methods do not have equivalent
+ * actions in the Actions toolbox in the Actions panel in the Flash authoring tool. </p>
+ * <p class="- topic/p ">
+ * Children instances placed on the Stage in Flash Professional
+ * cannot be accessed by code from within the constructor of a parent instance
+ * since they have not been created at that ponumber in code execution.
+ * Before accessing the child, the parent must instead either create the child instance
+ * by code or delay access to a callback that listens for the child to dispatch
+ * its <codeph class="+ topic/ph pr-d/codeph ">Event.ADDED_TO_STAGE</codeph> event.
+ * </p><p class="- topic/p ">
+ * If you modify any of the following properties of a MovieClip object that contains a motion tween,
+ * the playhead is stopped in that MovieClip object:
+ * <codeph class="+ topic/ph pr-d/codeph ">alpha</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">blendMode</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">filters</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">height</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">opaqueBackground</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">rotation</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">scaleX</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">scaleY</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">scale9Grid</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">scrollRect</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">transform</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">visible</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">width</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">x</codeph>,
+ * or <codeph class="+ topic/ph pr-d/codeph ">y</codeph>.
+ * However, it does not stop the playhead in any child MovieClip objects of that
+ * MovieClip object.</p><p class="- topic/p ">
+ * <b class="+ topic/ph hi-d/b ">Note:</b>Flash Lite 4 supports the MovieClip.opaqueBackground property only if
+ * FEATURE_BITMAPCACHE is defined. The default configuration of Flash Lite 4 does not define
+ * FEATURE_BITMAPCACHE. To enable the MovieClip.opaqueBackground property for a suitable device,
+ * define FEATURE_BITMAPCACHE in your project.</p>*/
+var MovieClip = /** @class */ (function (_super) {
+    __extends(MovieClip, _super);
+    /**
+     * Creates a new MovieClip instance. After creating the MovieClip, call the
+     * addChild() or addChildAt() method of a
+     * display object container that is onstage.
+     */
+    function MovieClip() {
+        return _super.call(this) || this;
+    }
+    // 	executed directly after a MC has been constructed via Object.create,
+    //	befre the actual constructors have been run
+    MovieClip.prototype.applySymbol = function () { };
+    MovieClip.getNewMovieClip = function (adaptee) {
+        if (MovieClip._movieClips.length) {
+            var movieClip = MovieClip._movieClips.pop();
+            movieClip.adaptee = adaptee;
+            return movieClip;
+        }
+        return new MovieClip();
+    };
+    MovieClip.prototype.executeScript = function (scripts) {
+        if (!this._framescripts || !this.allowScript && this.sec.swfVersion > 9) {
+            return;
+        }
+        var script = this._framescripts[this.adaptee.currentFrameIndex];
+        if (!script) {
+            return;
+        }
+        this.allowScript = false;
+        var prev_script_scope = MovieClip.current_script_scope;
+        MovieClip.current_script_scope = this;
+        script.axCall(this);
+        MovieClip.current_script_scope = prev_script_scope;
+        if (this.queuedNavigationAction) {
+            // execute any pending FrameNavigation for this mc
+            var queuedNavigationAction = this.queuedNavigationAction;
+            this.queuedNavigationAction = null;
+            queuedNavigationAction();
+        }
+    };
+    MovieClip.prototype.initAdapter = function () { };
+    MovieClip.prototype.createAdaptee = function () {
+        var adaptee = AwayMovieClip.getNewMovieClip(new Timeline(this.sec.player.factory));
+        adaptee.reset();
+        //console.log("createAdaptee AwayMovieClip");
+        //FrameScriptManager.execute_queue();
+        return adaptee;
+    };
+    MovieClip.prototype.freeFromScript = function () {
+        //this.stopAllSounds();
+        _super.prototype.freeFromScript.call(this);
+    };
+    MovieClip.prototype.clone = function () {
+        var anyThis = this;
+        if (!anyThis._symbol) {
+            throw ('_symbol not defined when cloning movieclip');
+        }
+        var newMC = constructClassFromSymbol(anyThis._symbol, anyThis._symbol.symbolClass);
+        var adaptee = new AwayMovieClip(this.adaptee.timeline);
+        this.adaptee.copyTo(adaptee);
+        newMC.adaptee = adaptee;
+        newMC._stage = this.activeStage;
+        newMC.executeConstructor = function () {
+            //adaptee.timeline.resetScripts();
+            newMC.axInitializer();
+            newMC.constructorHasRun = true;
+        };
+        return newMC;
+    };
+    /**
+     * @inheritDoc
+     */
+    MovieClip.prototype.dispose = function () {
+        this.disposeValues();
+        //MovieClip._movieClips.push(this);
+    };
+    Object.defineProperty(MovieClip.prototype, "currentFrame", {
+        //---------------------------original as3 properties / methods:
+        /**
+         * Specifies the number of the frame in which the playhead is located in the timeline of
+         * the MovieClip instance. If the movie clip has multiple scenes, this value is the
+         * frame number in the current scene.
+         */
+        get: function () {
+            var adaptee = this._adaptee;
+            return adaptee.currentFrameIndexRelative + 1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "currentFrameLabel", {
+        /**
+         * The label at the current frame in the timeline of the MovieClip instance.
+         * If the current frame has no label, currentLabel is null.
+         */
+        get: function () {
+            return this.adaptee.timeline.getCurrentFrameLabel(this.adaptee);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "currentLabel", {
+        /**
+         * The current label in which the playhead is located in the timeline of the MovieClip instance.
+         * If the current frame has no label, currentLabel is set to the name of the previous frame
+         * that includes a label. If the current frame and previous frames do not include a label,
+         * currentLabel returns null.
+         */
+        get: function () {
+            return this.adaptee.timeline.getCurrentLabel(this.adaptee);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "currentLabels", {
+        /**
+         * Returns an array of FrameLabel objects from the current scene. If the MovieClip instance does
+         * not use scenes, the array includes all frame labels from the entire MovieClip instance.
+         */
+        get: function () {
+            //	this is called quite frequently in some games
+            //	we do not 100% support scenes, yet
+            //	as long as we do not have ull scene-support, we can cache the result
+            if (this._currentLabels)
+                return this._currentLabels;
+            var labels = this.adaptee.timeline._labels;
+            var keyframe_firstframes = this.adaptee.timeline.keyframe_firstframes;
+            this._currentLabels = [];
+            for (var key in labels) {
+                this._currentLabels.push(new this.sec.flash.display.FrameLabel(labels[key].name, keyframe_firstframes[labels[key].keyFrameIndex] + 1));
+            }
+            return this._currentLabels;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "currentScene", {
+        /**
+         * The current scene in which the playhead is located in the timeline of the MovieClip instance.
+         */
+        get: function () {
+            //todo
+            //console.log('currentScene not implemented yet in flash/MovieClip');
+            var scene = this.adaptee.currentScene;
+            var newLabels = { value: [] };
+            for (var i = 0; i < scene.labels.length; i++) {
+                newLabels.value.push(new this.sec.flash.display.FrameLabel(scene.labels[i].name, scene.labels[i].frame));
+            }
+            var as3Scene = new this.sec.flash.display.Scene(scene.name, newLabels, scene.offset, scene.numFrames);
+            return as3Scene;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "enabled", {
+        /**
+         * A boolean value that indicates whether a movie clip is enabled. The default value of enabled
+         * is true. If enabled is set to false, the movie clip's
+         * Over, Down, and Up frames are disabled. The movie clip
+         * continues to receive events (for example, mouseDown,
+         * mouseUp, keyDown, and keyUp).
+         *
+         *   The enabled property governs only the button-like properties of a movie clip. You
+         * can change the enabled property at any time; the modified movie clip is immediately
+         * enabled or disabled. If enabled is set to false, the object is not
+         * included in automatic tab ordering.
+         */
+        get: function () {
+            return this.adaptee.buttonEnabled;
+        },
+        set: function (value) {
+            this.adaptee.buttonEnabled = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "framesLoaded", {
+        /**
+         * The number of frames that are loaded from a streaming SWF file. You can use the framesLoaded
+         * property to determine whether the contents of a specific frame and all the frames before it
+         * loaded and are available locally in the browser. You can also use it to monitor the downloading
+         * of large SWF files. For example, you might want to display a message to users indicating that
+         * the SWF file is loading until a specified frame in the SWF file finishes loading.
+         *
+         *   If the movie clip contains multiple scenes, the framesLoaded property returns the number
+         * of frames loaded for all scenes in the movie clip.
+         */
+        get: function () {
+            return this.totalFrames;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "isPlaying", {
+        get: function () {
+            return this.adaptee.isPlaying;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "scenes", {
+        /**
+         * An array of Scene objects, each listing the name, the number of frames,
+         * and the frame labels for a scene in the MovieClip instance.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/MovieClip', 'get scenes', '');
+            return [];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "totalFrames", {
+        /**
+         * The total number of frames in the MovieClip instance.
+         *
+         *   If the movie clip contains multiple frames, the totalFrames property returns
+         * the total number of frames in all scenes in the movie clip.
+         */
+        get: function () {
+            return this._adaptee.numFrames;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MovieClip.prototype, "trackAsMenu", {
+        /**
+         * Indicates whether other display objects that are SimpleButton or MovieClip objects can receive
+         * mouse release events or other user input release events. The trackAsMenu property lets you create menus. You
+         * can set the trackAsMenu property on any SimpleButton or MovieClip object.
+         * The default value of the trackAsMenu property is false.
+         *
+         *   You can change the trackAsMenu property at any time; the modified movie
+         * clip immediately uses the new behavior.
+         */
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/MovieClip', 'get trackAsMenu', '');
+            return false;
+        },
+        set: function (value) {
+            // @todo
+            Debug.throwPIR('playerglobals/display/MovieClip', 'set trackAsMenu', '');
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MovieClip.prototype.addFrameScript = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        // arguments are pairs of frameIndex and script/function
+        // frameIndex is in range 0..totalFrames-1
+        var numArgs = arguments.length;
+        if (numArgs & 1) {
+            this.sec.throwError('ArgumentError TooFewArgumentsError', numArgs, numArgs + 1);
+        }
+        //addFrameScript can be called before constructor
+        if (!this._framescripts)
+            this._framescripts = [];
+        var adaptee = this.adaptee;
+        var currentFrameScriptChanged = false;
+        for (var i = 0; i < numArgs; i += 2) {
+            var frameNum = (args[i] | 0);
+            var fn = args[i + 1];
+            this._framescripts[frameNum] = fn;
+            if (frameNum == adaptee.currentFrameIndex)
+                currentFrameScriptChanged = true;
+        }
+        //Navigation may already have consumed this frame's script.
+        //Defer the new callback, reusing an exisiting queued visit.
+        if (currentFrameScriptChanged && this.constructorHasRun
+            && this.sec.swfVersion > 9
+            && MovieClip.current_script_scope != this) {
+            var script = this._framescripts[adaptee.currentFrameIndex];
+            var queue = FrameScriptManager.get_queue();
+            if (script && queue.queued_mcs.indexOf(adaptee) < 0
+                && queue.queued_mcs_pass2.indexOf(adaptee) < 0) {
+                FrameScriptManager.add_script_to_queue_pass2(adaptee, [script]);
+            }
+        }
+        this.constructorHasRun = true;
+    };
+    /**
+     * Starts playing the SWF file at the specified frame.  This happens after all
+     * remaining actions in the frame have finished executing.  To specify a scene
+     * as well as a frame, specify a value for the scene parameter.
+     * @param	frame	A number representing the frame number, or a string representing the label of the
+     *   frame, to which the playhead is sent. If you specify a number, it is relative to the
+     *   scene you specify. If you do not specify a scene,
+     *   the current scene determines the global frame number to play. If you do specify a scene, the playhead
+     *   jumps to the frame number in the specified scene.
+     * @param	scene	The name of the scene to play. This parameter is optional.
+     */
+    MovieClip.prototype.gotoAndPlay = function (frame, scene, force) {
+        if (scene === void 0) { scene = null; }
+        if (force === void 0) { force = false; }
+        this._gotoInternal(frame, scene, force, false);
+    };
+    /**
+     * Brings the playhead to the specified frame of the movie clip and stops it there.  This happens after all
+     * remaining actions in the frame have finished executing.  If you want to specify a scene in addition to a frame,
+     * specify a scene parameter.
+     * @param	frame	A number representing the frame number, or a string representing the label of the
+     *   frame, to which the playhead is sent. If you specify a number, it is relative to the
+     *   scene you specify. If you do not specify a scene, the current scene determines
+     *   the global frame number at which to go to and stop. If you do specify a scene,
+     *   the playhead goes to the frame number in the specified scene and stops.
+     * @param	scene	The name of the scene. This parameter is optional.
+     * @throws	ArgumentError If the scene or frame specified are
+     *   not found in this movie clip.
+     */
+    MovieClip.prototype.gotoAndStop = function (frame, scene, force) {
+        if (scene === void 0) { scene = null; }
+        if (force === void 0) { force = false; }
+        this._gotoInternal(frame, scene, force, true);
+    };
+    MovieClip.prototype._gotoInternal = function (frame, scene, force, stop) {
+        var _this = this;
+        if (scene === void 0) { scene = null; }
+        if (force === void 0) { force = false; }
+        if (stop === void 0) { stop = false; }
+        if (Number.isNaN(frame))
+            return;
+        if (!force && MovieClip.current_script_scope == this) {
+            this.queuedNavigationAction = function () { return _this._gotoInternal(frame, scene, true, stop); };
+            return;
+        }
+        // in FP for frame==null, we need to stop the mc
+        if (frame == null) {
+            stop && this.stop();
+            return;
+        }
+        var adaptee = this.adaptee;
+        scene = scene || adaptee.currentSceneName;
+        if (typeof frame === 'string') {
+            if (adaptee.timeline._labels[frame] == null) {
+                frame = parseInt(frame);
+                if (!isNaN(frame)) {
+                    adaptee.jumpToIndex(frame - 1, scene);
+                    if (stop) {
+                        adaptee.stop();
+                    }
+                    else {
+                        adaptee.play();
+                    }
+                }
+                if (stop) {
+                    //	for FP>10 we should throw a error and stop the timeline
+                    if (this.sec.swfVersion > 10) {
+                        adaptee.currentFrameIndex = 0;
+                    }
+                    this.stop();
+                }
+                return;
+            }
+        }
+        if (typeof frame === 'number' && frame <= 0) {
+            if (MovieClip.current_script_scope == this) {
+                return;
+            }
+            frame = 1;
+        }
+        if (stop) {
+            this.stop();
+        }
+        else {
+            this.play();
+        }
+        this._gotoFrame(frame, scene);
+    };
+    MovieClip.prototype._gotoFrame = function (frame, scene) {
+        if (scene === void 0) { scene = null; }
+        var adaptee = this._adaptee;
+        var navigated;
+        if (typeof frame === 'string') {
+            navigated = adaptee.jumpToLabel(frame);
+        }
+        else if (typeof frame === 'number' && frame <= 0) {
+            console.warn('[playerglobal/MovieClip] - gotoFrame called with invalid frame-index');
+            navigated = true;
+        }
+        else {
+            navigated = adaptee.jumpToIndex(frame - 1, scene);
+        }
+        //only execute scripts if playhead has moved or constructors have yet to run
+        if (!navigated) {
+            return;
+        }
+        //console.log("_gotoFrame", this.name);
+        FrameScriptManager.execute_as3_constructors_recursiv(this.adaptee);
+        FrameScriptManager.execute_as3_constructors_finish_scene(this.activeStage.getChildAt(0).adaptee);
+        // this is not true!
+        // only in FP10 and above we want to execute scripts immediatly here
+        // BUT ONLY ON SUB TIMELINES
+        if (this.sec.swfVersion > 9 && this !== MovieClip.current_script_scope) {
+            this.dispatchStaticBroadCastEvent(Event.FRAME_CONSTRUCTED);
+            FrameScriptManager.execute_queue();
+            this.dispatchStaticBroadCastEvent(Event.EXIT_FRAME);
+        }
+    };
+    /**
+     * Sends the playhead to the next frame and stops it.  This happens after all
+     * remaining actions in the frame have finished executing.
+     */
+    MovieClip.prototype.nextFrame = function (force) {
+        var _this = this;
+        if (force === void 0) { force = false; }
+        if (!force && MovieClip.current_script_scope == this) {
+            this.queuedNavigationAction = function () { return _this.nextFrame(true); };
+            return;
+        }
+        this._adaptee.stop();
+        ++this._adaptee.currentFrameIndex;
+        FrameScriptManager.execute_as3_constructors_recursiv(this.adaptee);
+        FrameScriptManager.execute_as3_constructors_finish_scene(this.activeStage.getChildAt(0).adaptee);
+        // only in FP10 and above we want to execute scripts immediatly here
+        if (this.sec.swfVersion > 9) {
+            this.dispatchStaticBroadCastEvent(Event.FRAME_CONSTRUCTED);
+            FrameScriptManager.execute_queue();
+            this.dispatchStaticBroadCastEvent(Event.EXIT_FRAME);
+        }
+    };
+    /**
+     * Moves the playhead to the next scene of the MovieClip instance.  This happens after all
+     * remaining actions in the frame have finished executing.
+     */
+    MovieClip.prototype.nextScene = function (force) {
+        var _this = this;
+        if (force === void 0) { force = false; }
+        if (!force && MovieClip.current_script_scope == this) {
+            this.queuedNavigationAction = function () { return _this.nextScene(true); };
+            return;
+        }
+        // @todo
+        Debug.throwPIR('playerglobals/display/MovieClip', 'nextScene', '');
+    };
+    /**
+     * Moves the playhead in the timeline of the movie clip.
+     */
+    MovieClip.prototype.play = function () {
+        return this._adaptee.play();
+    };
+    /**
+     * Sends the playhead to the previous frame and stops it.  This happens after all
+     * remaining actions in the frame have finished executing.
+     */
+    MovieClip.prototype.prevFrame = function (force) {
+        var _this = this;
+        if (force === void 0) { force = false; }
+        if (!force && MovieClip.current_script_scope == this) {
+            this.queuedNavigationAction = function () { return _this.prevFrame(true); };
+            return;
+        }
+        var adaptee = this._adaptee;
+        if (adaptee.currentFrameIndexRelative > 0) {
+            adaptee.currentFrameIndexRelative--;
+        }
+        FrameScriptManager.execute_as3_constructors_recursiv(this.adaptee);
+        FrameScriptManager.execute_as3_constructors_finish_scene(this.activeStage.getChildAt(0).adaptee);
+        // only in FP10 and above we want to execute scripts immediatly here
+        if (this.sec.swfVersion > 9) {
+            this.dispatchStaticBroadCastEvent(Event.FRAME_CONSTRUCTED);
+            FrameScriptManager.execute_queue();
+            this.dispatchStaticBroadCastEvent(Event.EXIT_FRAME);
+        }
+    };
+    /**
+     * Moves the playhead to the previous scene of the MovieClip instance.  This happens after all
+     * remaining actions in the frame have finished executing.
+     */
+    MovieClip.prototype.prevScene = function (force) {
+        var _this = this;
+        if (force === void 0) { force = false; }
+        if (!force && MovieClip.current_script_scope == this) {
+            this.queuedNavigationAction = function () { return _this.prevScene(true); };
+            return;
+        }
+        // @todo
+        Debug.throwPIR('playerglobals/display/MovieClip', 'prevScene', '');
+    };
+    /**
+     * Stops the playhead in the movie clip.
+     */
+    MovieClip.prototype.stop = function () {
+        return this._adaptee.stop();
+    };
+    MovieClip._movieClips = new Array();
+    MovieClip.current_script_scope = null;
+    return MovieClip;
+}(Sprite));
+export { MovieClip };

package/dist/lib/display/NativeMenu.d.ts

@@ -0,0 +1,8 @@
+import { EventDispatcher } from '../events/EventDispatcher';
+export declare class NativeMenu extends EventDispatcher {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor();
+}
+//# sourceMappingURL=NativeMenu.d.ts.map

package/dist/lib/display/NativeMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeMenu.d.ts","sourceRoot":"","sources":["../../../lib/display/NativeMenu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,qBAAa,UAAW,SAAQ,eAAe;IAE9C,OAAc,gBAAgB,EAAE,GAAG,CAAQ;IAC3C,OAAc,YAAY,EAAE,MAAM,EAAG,CAAQ;IAC7C,OAAc,eAAe,EAAE,MAAM,EAAG,CAAQ;;CAKhD"}

package/dist/lib/display/NativeMenu.js

@@ -0,0 +1,13 @@
+import { __extends } from "tslib";
+import { EventDispatcher } from '../events/EventDispatcher';
+var NativeMenu = /** @class */ (function (_super) {
+    __extends(NativeMenu, _super);
+    function NativeMenu() {
+        return _super.call(this) || this;
+    }
+    NativeMenu.classInitializer = null;
+    NativeMenu.classSymbols = null; // [];
+    NativeMenu.instanceSymbols = null; // [];
+    return NativeMenu;
+}(EventDispatcher));
+export { NativeMenu };

package/dist/lib/display/NativeMenuItem.d.ts

@@ -0,0 +1,11 @@
+import { EventDispatcher } from '../events/EventDispatcher';
+export declare class NativeMenuItem extends EventDispatcher {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor();
+    protected _enabled: boolean;
+    get enabled(): boolean;
+    set enabled(isSeparator: boolean);
+}
+//# sourceMappingURL=NativeMenuItem.d.ts.map

package/dist/lib/display/NativeMenuItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeMenuItem.d.ts","sourceRoot":"","sources":["../../../lib/display/NativeMenuItem.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAG5D,qBAAa,cAAe,SAAQ,eAAe;IAGlD,OAAc,gBAAgB,EAAE,GAAG,CAAQ;IAG3C,OAAc,YAAY,EAAE,MAAM,EAAG,CAAQ;IAG7C,OAAc,eAAe,EAAE,MAAM,EAAG,CAAQ;;IAOhD,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC5B,IAAW,OAAO,IAAI,OAAO,CAI5B;IAED,IAAW,OAAO,CAAC,WAAW,EAAE,OAAO,EAKtC;CACD"}

package/dist/lib/display/NativeMenuItem.js

@@ -0,0 +1,35 @@
+import { __extends } from "tslib";
+import { Debug } from '@awayjs/core';
+import { EventDispatcher } from '../events/EventDispatcher';
+// Class: NativeMenuItem
+var NativeMenuItem = /** @class */ (function (_super) {
+    __extends(NativeMenuItem, _super);
+    function NativeMenuItem() {
+        var _this = _super.call(this) || this;
+        _this._enabled = true;
+        return _this;
+    }
+    Object.defineProperty(NativeMenuItem.prototype, "enabled", {
+        get: function () {
+            // @todo
+            Debug.throwPIR('playerglobals/display/NativeMenuItem', 'get enabled', '');
+            return this._enabled;
+        },
+        set: function (isSeparator) {
+            isSeparator = !!isSeparator;
+            // @todo
+            Debug.throwPIR('playerglobals/display/NativeMenuItem', 'set enabled', '');
+            this._enabled = isSeparator;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // Called whenever the class is initialized.
+    NativeMenuItem.classInitializer = null;
+    // List of static symbols to link.
+    NativeMenuItem.classSymbols = null; // [];
+    // List of instance symbols to link.
+    NativeMenuItem.instanceSymbols = null; // [];
+    return NativeMenuItem;
+}(EventDispatcher));
+export { NativeMenuItem };

package/dist/lib/display/Scene.d.ts

@@ -0,0 +1,23 @@
+import { ASObject } from '@awayfl/avm2';
+import { FrameLabel } from './FrameLabel';
+export declare class Scene extends ASObject {
+    static classInitializer: any;
+    static classSymbols: string[];
+    static instanceSymbols: string[];
+    constructor(name: string, labels: {
+        value: FrameLabel[];
+    }, offset: number, numFrames: number);
+    private _name;
+    private offset;
+    private _numFrames;
+    private _labels;
+    get name(): string;
+    get labels(): {
+        value: FrameLabel[];
+    };
+    get numFrames(): number;
+    clone(): Scene;
+    getLabelByName(name: string, ignoreCase: boolean): FrameLabel;
+    getLabelByFrame(frame: number): FrameLabel;
+}
+//# sourceMappingURL=Scene.d.ts.map

package/dist/lib/display/Scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../lib/display/Scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAkB,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,qBAAa,KAAM,SAAQ,QAAQ;IAElC,OAAc,gBAAgB,EAAE,GAAG,CAAQ;IAC3C,OAAc,YAAY,EAAE,MAAM,EAAG,CAAQ;IAC7C,OAAc,eAAe,EAAE,MAAM,EAAG,CAAQ;gBAEnC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE;QAAC,KAAK,EAAE,UAAU,EAAE,CAAA;KAAC,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAY3F,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,OAAO,CAAwB;IAEvC,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,MAAM,IAAI;QAAC,KAAK,EAAE,UAAU,EAAE,CAAA;KAAC,CAEzC;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAEM,KAAK,IAAI,KAAK;IAMd,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG,UAAU;IAc7D,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;CAUjD"}