diff --git a/.gitignore b/.gitignore
index 11c72867..f4f3cc6b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,6 @@
 /.idea
 /.vscode
 /demo_wxgame
+/demo/.wing
+/demo/.idea
+/demo/.vscode
diff --git a/demo/.vscode/tasks.json b/demo/.vscode/tasks.json
deleted file mode 100644
index 77b8de35..00000000
--- a/demo/.vscode/tasks.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-   "version": "0.1.0",
-   "command": "egret",
-   "isShellCommand": true,
-   "showOutput": "silent",
-   "args": [
-      "build"
-   ],
-   "problemMatcher": "$tsc"
-}
\ No newline at end of file
diff --git a/demo/.wing/launch.json b/demo/.wing/launch.json
deleted file mode 100644
index 9a3f27f1..00000000
--- a/demo/.wing/launch.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-	"version": "0.2.0",
-	"configurations": [
-		{
-			"name": "Launch Wing Player",
-			"type": "chrome",
-			"request": "launch",
-			"file": "index.html",
-			"runtimeExecutable": "${execPath}",
-			"useBuildInServer": true,
-			"sourceMaps": true,
-			"webRoot": "${workspaceRoot}",
-			"preLaunchTask":"build",
-			"port":5479
-		},
-		{
-			"name": "Launch Chrome",
-			"type": "chrome",
-			"request": "launch",
-			"file": "index.html",
-			"useBuildInServer": true,
-			"sourceMaps": true,
-			"webRoot": "${workspaceRoot}",
-			"preLaunchTask":"build",
-			"userDataDir":"${tmpdir}",
-			"port":5479
-		}
-	]
-}
\ No newline at end of file
diff --git a/demo/.wing/settings.json b/demo/.wing/settings.json
deleted file mode 100644
index 372e43ca..00000000
--- a/demo/.wing/settings.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-	"search.exclude": {
-		"**/bin-debug": true,
-		"**/bin-release": true
-	}
-}
\ No newline at end of file
diff --git a/demo/.wing/tasks.json b/demo/.wing/tasks.json
deleted file mode 100644
index 521f0c80..00000000
--- a/demo/.wing/tasks.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-    "version": "0.1.0",
-    "command": "egret",
-    "isShellCommand": true,
-    "suppressTaskName": true,
-    "tasks": [
-        {
-            "taskName": "build",
-            "showOutput": "always",
-            "args": [
-                "build",
-                "-sourcemap"
-            ],
-            "problemMatcher": "$tsc"
-        },
-        {
-            "taskName": "clean",
-            "showOutput": "always",
-            "args": [
-                "build",
-                "-e"
-            ],
-            "problemMatcher": "$tsc"
-        },
-        {
-            "taskName": "publish",
-            "showOutput": "always",
-            "args": [
-                "publish"
-            ],
-            "problemMatcher": "$tsc"
-        }
-    ]
-}
\ No newline at end of file
diff --git a/demo/egretProperties.json b/demo/egretProperties.json
index 1f7a10ee..2b676f9c 100644
--- a/demo/egretProperties.json
+++ b/demo/egretProperties.json
@@ -24,6 +24,9 @@
     {
       "name": "promise"
     },
+    {
+      "name": "dragonBones"
+    },
     {
       "name": "framework",
       "path": "./libs/framework"
@@ -31,6 +34,10 @@
     {
       "name": "long",
       "path": "./libs/long"
+    },
+    {
+      "name": "fairygui",
+      "path": "./libs/fairygui"
     }
   ]
 }
\ No newline at end of file
diff --git a/demo/index.html b/demo/index.html
index 5ed3328a..3f4f4d67 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -31,7 +31,7 @@
          data-content-width="640"
          data-content-height="1136"
          data-multi-fingered="2"
-         data-show-fps="true" data-show-log="false"
+         data-show-fps="false" data-show-log="false"
          data-show-fps-style="x:0,y:0,size:12,textColor:0xffffff,bgAlpha:0.9">
     </div>
 <script>
@@ -77,7 +77,7 @@
              * "calculateCanvasScaleFactor": //a function return canvas scale factor
              * }
              **/
-            egret.runEgret({ renderMode: "canvas", audioType: 0, calculateCanvasScaleFactor:function(context) {
+            egret.runEgret({ renderMode: "webgl", audioType: 0, calculateCanvasScaleFactor:function(context) {
                 var backingStore = context.backingStorePixelRatio ||
                     context.webkitBackingStorePixelRatio ||
                     context.mozBackingStorePixelRatio ||
diff --git a/demo/libs/fairygui/fairygui.d.ts b/demo/libs/fairygui/fairygui.d.ts
new file mode 100644
index 00000000..a92150a9
--- /dev/null
+++ b/demo/libs/fairygui/fairygui.d.ts
@@ -0,0 +1,2444 @@
+declare module fgui {
+    class AsyncOperation {
+        callback: (obj: GObject) => void;
+        callbackObj: any;
+        private _itemList;
+        private _objectPool;
+        private _index;
+        constructor();
+        createObject(pkgName: string, resName: string): void;
+        createObjectFromURL(url: string): void;
+        cancel(): void;
+        private internalCreateObject;
+        private collectComponentChildren;
+        private collectListChildren;
+        private run;
+    }
+}
+declare module fgui {
+    class Controller extends egret.EventDispatcher {
+        private _selectedIndex;
+        private _previousIndex;
+        private _pageIds;
+        private _pageNames;
+        private _actions?;
+        name: string;
+        parent: GComponent;
+        autoRadioGroupDepth?: boolean;
+        changing: boolean;
+        constructor();
+        dispose(): void;
+        selectedIndex: number;
+        setSelectedIndex(value: number): void;
+        readonly previsousIndex: number;
+        selectedPage: string;
+        setSelectedPage(value: string): void;
+        readonly previousPage: string;
+        readonly pageCount: number;
+        getPageName(index: number): string;
+        addPage(name?: string): void;
+        addPageAt(name: string, index: number): void;
+        removePage(name: string): void;
+        removePageAt(index?: number): void;
+        clearPages(): void;
+        hasPage(aName: string): boolean;
+        getPageIndexById(aId: string): number;
+        getPageIdByName(aName: string): string;
+        getPageNameById(aId: string): string;
+        getPageId(index?: number): string;
+        selectedPageId: string;
+        oppositePageId: string;
+        readonly previousPageId: string;
+        runActions(): void;
+        setup(buffer: ByteBuffer): void;
+    }
+}
+declare module fgui {
+    class DragDropManager {
+        private _agent;
+        private _sourceData;
+        private static _inst;
+        static readonly inst: DragDropManager;
+        constructor();
+        readonly dragAgent: GObject;
+        readonly dragging: boolean;
+        startDrag(source: GObject, icon: string, sourceData?: any, touchPointID?: number): void;
+        cancel(): void;
+        private __dragEnd;
+    }
+}
+declare module fgui {
+    enum ButtonMode {
+        Common = 0,
+        Check = 1,
+        Radio = 2
+    }
+    enum AutoSizeType {
+        None = 0,
+        Both = 1,
+        Height = 2
+    }
+    enum AlignType {
+        Left = 0,
+        Center = 1,
+        Right = 2
+    }
+    enum VertAlignType {
+        Top = 0,
+        Middle = 1,
+        Bottom = 2
+    }
+    enum LoaderFillType {
+        None = 0,
+        Scale = 1,
+        ScaleMatchHeight = 2,
+        ScaleMatchWidth = 3,
+        ScaleFree = 4,
+        ScaleNoBorder = 5
+    }
+    enum ListLayoutType {
+        SingleColumn = 0,
+        SingleRow = 1,
+        FlowHorizontal = 2,
+        FlowVertical = 3,
+        Pagination = 4
+    }
+    enum ListSelectionMode {
+        Single = 0,
+        Multiple = 1,
+        Multiple_SingleClick = 2,
+        None = 3
+    }
+    enum OverflowType {
+        Visible = 0,
+        Hidden = 1,
+        Scroll = 2
+    }
+    enum PackageItemType {
+        Image = 0,
+        MovieClip = 1,
+        Sound = 2,
+        Component = 3,
+        Atlas = 4,
+        Font = 5,
+        Swf = 6,
+        Misc = 7,
+        Unknown = 8,
+        Spine = 9,
+        DragonBones = 10
+    }
+    enum ObjectType {
+        Image = 0,
+        MovieClip = 1,
+        Swf = 2,
+        Graph = 3,
+        Loader = 4,
+        Group = 5,
+        Text = 6,
+        RichText = 7,
+        InputText = 8,
+        Component = 9,
+        List = 10,
+        Label = 11,
+        Button = 12,
+        ComboBox = 13,
+        ProgressBar = 14,
+        Slider = 15,
+        ScrollBar = 16,
+        Tree = 17,
+        Loader3D = 18
+    }
+    enum ProgressTitleType {
+        Percent = 0,
+        ValueAndMax = 1,
+        Value = 2,
+        Max = 3
+    }
+    enum ScrollBarDisplayType {
+        Default = 0,
+        Visible = 1,
+        Auto = 2,
+        Hidden = 3
+    }
+    enum ScrollType {
+        Horizontal = 0,
+        Vertical = 1,
+        Both = 2
+    }
+    enum FlipType {
+        None = 0,
+        Horizontal = 1,
+        Vertical = 2,
+        Both = 3
+    }
+    enum ChildrenRenderOrder {
+        Ascent = 0,
+        Descent = 1,
+        Arch = 2
+    }
+    enum GroupLayoutType {
+        None = 0,
+        Horizontal = 1,
+        Vertical = 2
+    }
+    enum PopupDirection {
+        Auto = 0,
+        Up = 1,
+        Down = 2
+    }
+    enum RelationType {
+        Left_Left = 0,
+        Left_Center = 1,
+        Left_Right = 2,
+        Center_Center = 3,
+        Right_Left = 4,
+        Right_Center = 5,
+        Right_Right = 6,
+        Top_Top = 7,
+        Top_Middle = 8,
+        Top_Bottom = 9,
+        Middle_Middle = 10,
+        Bottom_Top = 11,
+        Bottom_Middle = 12,
+        Bottom_Bottom = 13,
+        Width = 14,
+        Height = 15,
+        LeftExt_Left = 16,
+        LeftExt_Right = 17,
+        RightExt_Left = 18,
+        RightExt_Right = 19,
+        TopExt_Top = 20,
+        TopExt_Bottom = 21,
+        BottomExt_Top = 22,
+        BottomExt_Bottom = 23,
+        Size = 24
+    }
+    enum FillMethod {
+        None = 0,
+        Horizontal = 1,
+        Vertical = 2,
+        Radial90 = 3,
+        Radial180 = 4,
+        Radial360 = 5
+    }
+    enum FillOrigin {
+        Top = 0,
+        Bottom = 1,
+        Left = 2,
+        Right = 3,
+        TopLeft = 0,
+        TopRight = 1,
+        BottomLeft = 2,
+        BottomRight = 3
+    }
+    enum FillOrigin90 {
+        TopLeft = 0,
+        TopRight = 1,
+        BottomLeft = 2,
+        BottomRight = 3
+    }
+    enum ObjectPropID {
+        Text = 0,
+        Icon = 1,
+        Color = 2,
+        OutlineColor = 3,
+        Playing = 4,
+        Frame = 5,
+        DeltaTime = 6,
+        TimeScale = 7,
+        FontSize = 8,
+        Selected = 9
+    }
+}
+declare module fgui {
+    class GObject extends egret.EventDispatcher {
+        data: any;
+        packageItem: PackageItem;
+        static draggingObject: GObject;
+        private _x;
+        private _y;
+        private _alpha;
+        private _rotation;
+        private _visible;
+        private _touchable;
+        private _grayed;
+        private _draggable;
+        private _scaleX;
+        private _scaleY;
+        private _skewX;
+        private _skewY;
+        private _pivotX;
+        private _pivotY;
+        private _pivotAsAnchor;
+        private _pivotOffsetX;
+        private _pivotOffsetY;
+        private _sortingOrder;
+        private _internalVisible;
+        private _handlingController?;
+        private _tooltips?;
+        private _pixelSnapping?;
+        private _disposed?;
+        private _dragTesting?;
+        private _dragStartPos?;
+        private _relations;
+        private _group?;
+        private _gears;
+        private _displayObject;
+        private _dragBounds?;
+        sourceWidth: number;
+        sourceHeight: number;
+        initWidth: number;
+        initHeight: number;
+        minWidth: number;
+        minHeight: number;
+        maxWidth: number;
+        maxHeight: number;
+        _parent: GComponent;
+        _width: number;
+        _height: number;
+        _rawWidth: number;
+        _rawHeight: number;
+        _id: string;
+        _name: string;
+        _underConstruct: boolean;
+        _gearLocked?: boolean;
+        _sizePercentInGroup: number;
+        _treeNode?: GTreeNode;
+        static XY_CHANGED: string;
+        static SIZE_CHANGED: string;
+        static SIZE_DELAY_CHANGE: string;
+        static GEAR_STOP: string;
+        constructor();
+        readonly id: string;
+        name: string;
+        x: number;
+        y: number;
+        setXY(xv: number, yv: number): void;
+        xMin: number;
+        yMin: number;
+        pixelSnapping: boolean;
+        center(restraint?: boolean): void;
+        width: number;
+        height: number;
+        setSize(wv: number, hv: number, ignorePivot?: boolean): void;
+        makeFullScreen(): void;
+        ensureSizeCorrect(): void;
+        readonly actualWidth: number;
+        readonly actualHeight: number;
+        scaleX: number;
+        scaleY: number;
+        setScale(sx: number, sy: number): void;
+        skewX: number;
+        skewY: number;
+        setSkew(xv: number, yv: number): void;
+        pivotX: number;
+        pivotY: number;
+        setPivot(xv: number, yv: number, asAnchor?: boolean): void;
+        readonly pivotAsAnchor: boolean;
+        protected internalSetPivot(xv: number, yv: number, asAnchor: boolean): void;
+        private updatePivotOffset;
+        private applyPivot;
+        touchable: boolean;
+        grayed: boolean;
+        enabled: boolean;
+        rotation: number;
+        readonly normalizeRotation: number;
+        alpha: number;
+        visible: boolean;
+        readonly internalVisible: boolean;
+        readonly internalVisible2: boolean;
+        readonly internalVisible3: boolean;
+        sortingOrder: number;
+        readonly focused: boolean;
+        requestFocus(): void;
+        tooltips: string;
+        blendMode: string;
+        filters: egret.Filter[];
+        readonly inContainer: boolean;
+        readonly onStage: boolean;
+        readonly resourceURL: string;
+        group: GGroup;
+        getGear(index: number): GearBase;
+        protected updateGear(index: number): void;
+        checkGearController(index: number, c: Controller): boolean;
+        updateGearFromRelations(index: number, dx: number, dy: number): void;
+        addDisplayLock(): number;
+        releaseDisplayLock(token: number): void;
+        private checkGearDisplay;
+        readonly gearXY: GearXY;
+        readonly gearSize: GearSize;
+        readonly gearLook: GearLook;
+        readonly relations: Relations;
+        addRelation(target: GObject, relationType: number, usePercent?: boolean): void;
+        removeRelation(target: GObject, relationType?: number): void;
+        readonly displayObject: egret.DisplayObject;
+        protected setDisplayObject(value: egret.DisplayObject): void;
+        parent: GComponent;
+        removeFromParent(): void;
+        readonly root: GRoot;
+        readonly asCom: GComponent;
+        readonly asButton: GButton;
+        readonly asLabel: GLabel;
+        readonly asProgress: GProgressBar;
+        readonly asTextField: GTextField;
+        readonly asRichTextField: GRichTextField;
+        readonly asTextInput: GTextInput;
+        readonly asLoader: GLoader;
+        readonly asList: GList;
+        readonly asTree: GTree;
+        readonly asGraph: GGraph;
+        readonly asGroup: GGroup;
+        readonly asSlider: GSlider;
+        readonly asComboBox: GComboBox;
+        readonly asImage: GImage;
+        readonly asMovieClip: GMovieClip;
+        static cast(obj: egret.DisplayObject): GObject;
+        text: string;
+        icon: string;
+        readonly isDisposed: boolean;
+        readonly treeNode: GTreeNode;
+        dispose(): void;
+        addClickListener(listener: Function, thisObj?: any): void;
+        removeClickListener(listener: Function, thisObj?: any): void;
+        hasClickListener(): boolean;
+        addEventListener(type: string, listener: Function, thisObject?: any): void;
+        removeEventListener(type: string, listener: Function, thisObject?: any): void;
+        private _reDispatch;
+        draggable: boolean;
+        dragBounds: egret.Rectangle;
+        startDrag(touchPointID?: number, stageX?: number, stageY?: number): void;
+        stopDrag(): void;
+        readonly dragging: boolean;
+        localToGlobal(ax?: number, ay?: number, result?: egret.Point): egret.Point;
+        globalToLocal(ax?: number, ay?: number, result?: egret.Point): egret.Point;
+        localToRoot(ax?: number, ay?: number, result?: egret.Point): egret.Point;
+        rootToLocal(ax?: number, ay?: number, resultPoint?: egret.Point): egret.Point;
+        localToGlobalRect(ax?: number, ay?: number, aw?: number, ah?: number, result?: egret.Rectangle): egret.Rectangle;
+        globalToLocalRect(ax?: number, ay?: number, aw?: number, ah?: number, result?: egret.Rectangle): egret.Rectangle;
+        handleControllerChanged(c: Controller): void;
+        protected createDisplayObject(): void;
+        protected switchDisplayObject(newObj: egret.DisplayObject): void;
+        protected handleXYChanged(): void;
+        protected handleSizeChanged(): void;
+        protected handleScaleChanged(): void;
+        protected handleGrayedChanged(): void;
+        protected handleAlphaChanged(): void;
+        handleVisibleChanged(): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        constructFromResource(): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+        private initDrag;
+        private dragBegin;
+        private dragEnd;
+        private reset;
+        private __begin;
+        private __moving;
+        private __end;
+    }
+}
+declare module fgui {
+    class GComponent extends GObject {
+        private _sortingChildCount;
+        private _applyingController?;
+        protected _margin: Margin;
+        protected _trackBounds: boolean;
+        protected _boundsChanged: boolean;
+        protected _childrenRenderOrder: ChildrenRenderOrder;
+        protected _apexIndex: number;
+        _buildingDisplayList: boolean;
+        _children: Array<GObject>;
+        _controllers: Array<Controller>;
+        _transitions: Array<Transition>;
+        _rootContainer: UIContainer;
+        _container: egret.DisplayObjectContainer;
+        _scrollPane?: ScrollPane;
+        _alignOffset: egret.Point;
+        constructor();
+        protected createDisplayObject(): void;
+        dispose(): void;
+        readonly displayListContainer: egret.DisplayObjectContainer;
+        addChild(child: GObject): GObject;
+        addChildAt(child: GObject, index?: number): GObject;
+        private getInsertPosForSortingChild;
+        removeChild(child: GObject, dispose?: boolean): GObject;
+        removeChildAt(index: number, dispose?: boolean): GObject;
+        removeChildren(beginIndex?: number, endIndex?: number, dispose?: boolean): void;
+        getChildAt(index: number): GObject;
+        getChild(name: string): GObject;
+        getChildByPath(path: String): GObject;
+        getVisibleChild(name: string): GObject;
+        getChildInGroup(name: string, group: GGroup): GObject;
+        getChildById(id: string): GObject;
+        getChildIndex(child: GObject): number;
+        setChildIndex(child: GObject, index: number): void;
+        setChildIndexBefore(child: GObject, index: number): number;
+        private _setChildIndex;
+        swapChildren(child1: GObject, child2: GObject): void;
+        swapChildrenAt(index1: number, index2: number): void;
+        readonly numChildren: number;
+        isAncestorOf(child: GObject): boolean;
+        addController(controller: Controller): void;
+        getControllerAt(index: number): Controller;
+        getController(name: string): Controller;
+        removeController(c: Controller): void;
+        readonly controllers: Array<Controller>;
+        childStateChanged(child: GObject): void;
+        private buildNativeDisplayList;
+        applyController(c: Controller): void;
+        applyAllControllers(): void;
+        adjustRadioGroupDepth(obj: GObject, c: Controller): void;
+        getTransitionAt(index: number): Transition;
+        getTransition(transName: string): Transition;
+        isChildInView(child: GObject): boolean;
+        getFirstChildInView(): number;
+        readonly scrollPane: ScrollPane;
+        opaque: boolean;
+        margin: Margin;
+        childrenRenderOrder: ChildrenRenderOrder;
+        apexIndex: number;
+        mask: egret.DisplayObject | egret.Rectangle;
+        readonly baseUserData: string;
+        protected updateScrollRect(): void;
+        protected setupScroll(buffer: ByteBuffer): void;
+        protected setupOverflow(overflow: OverflowType): void;
+        protected handleSizeChanged(): void;
+        protected handleGrayedChanged(): void;
+        handleControllerChanged(c: Controller): void;
+        setBoundsChangedFlag(): void;
+        private __render;
+        ensureBoundsCorrect(): void;
+        protected updateBounds(): void;
+        setBounds(ax: number, ay: number, aw: number, ah?: number): void;
+        viewWidth: number;
+        viewHeight: number;
+        getSnappingPosition(xValue: number, yValue: number, resultPoint?: egret.Point): egret.Point;
+        childSortingOrderChanged(child: GObject, oldValue: number, newValue?: number): void;
+        constructFromResource(): void;
+        constructFromResource2(objectPool: Array<GObject>, poolIndex: number): void;
+        protected onConstruct(): void;
+        protected constructExtension(buffer: ByteBuffer): void;
+        protected constructFromXML(xml: any): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+        private ___added;
+        private ___removed;
+    }
+}
+declare module fgui {
+    class GButton extends GComponent {
+        protected _titleObject: GObject;
+        protected _iconObject: GObject;
+        private _mode;
+        private _selected;
+        private _title;
+        private _selectedTitle;
+        private _icon;
+        private _selectedIcon;
+        private _sound;
+        private _soundVolumeScale;
+        private _buttonController;
+        private _relatedController?;
+        private _relatedPageId;
+        private _changeStateOnClick;
+        private _linkedPopup?;
+        private _downEffect;
+        private _downEffectValue;
+        private _downScaled?;
+        private _down;
+        private _over;
+        static UP: string;
+        static DOWN: string;
+        static OVER: string;
+        static SELECTED_OVER: string;
+        static DISABLED: string;
+        static SELECTED_DISABLED: string;
+        constructor();
+        icon: string;
+        selectedIcon: string;
+        title: string;
+        text: string;
+        selectedTitle: string;
+        titleColor: number;
+        titleFontSize: number;
+        sound: string;
+        soundVolumeScale: number;
+        selected: boolean;
+        mode: ButtonMode;
+        relatedController: Controller;
+        relatedPageId: string;
+        changeStateOnClick: boolean;
+        linkedPopup: GObject;
+        getTextField(): GTextField;
+        addStateListener(listener: Function, thisObj: any): void;
+        removeStateListener(listener: Function, thisObj: any): void;
+        fireClick(downEffect?: boolean): void;
+        protected setState(val: string): void;
+        handleControllerChanged(c: Controller): void;
+        protected handleGrayedChanged(): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        protected constructExtension(buffer: ByteBuffer): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+        private __mousedown;
+        private __mouseup;
+        private __click;
+    }
+}
+declare module fgui {
+    class GComboBox extends GComponent {
+        dropdown: GComponent;
+        protected _titleObject: GObject;
+        protected _iconObject: GObject;
+        protected _list: GList;
+        private _items;
+        private _values;
+        private _icons?;
+        private _visibleItemCount;
+        private _itemsUpdated;
+        private _selectedIndex;
+        private _buttonController;
+        private _popupDirection;
+        private _selectionController?;
+        private _over;
+        private _down;
+        constructor();
+        text: string;
+        icon: string;
+        titleColor: number;
+        titleFontSize: number;
+        visibleItemCount: number;
+        popupDirection: PopupDirection;
+        items: Array<string>;
+        icons: Array<string>;
+        values: Array<string>;
+        selectedIndex: number;
+        value: string;
+        selectionController: Controller;
+        getTextField(): GTextField;
+        protected setState(val: string): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        protected constructExtension(buffer: ByteBuffer): void;
+        handleControllerChanged(c: Controller): void;
+        private updateSelectionController;
+        dispose(): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+        protected showDropdown(): void;
+        private __popupWinClosed;
+        private __clickItem;
+        private __clickItem2;
+        private __mousedown;
+        private __mouseup;
+    }
+}
+declare module fgui {
+    class GGraph extends GObject {
+        private _graphics;
+        private _type;
+        private _lineSize;
+        private _lineColor;
+        private _lineAlpha;
+        private _fillColor;
+        private _fillAlpha;
+        private _cornerRadius?;
+        private _sides?;
+        private _startAngle?;
+        private _polygonPoints?;
+        private _distances?;
+        constructor();
+        readonly graphics: egret.Graphics;
+        drawRect(lineSize: number, lineColor: number, lineAlpha: number, fillColor: number, fillAlpha: number, corner?: Array<number>): void;
+        drawEllipse(lineSize: number, lineColor: number, lineAlpha: number, fillColor: number, fillAlpha: number): void;
+        drawRegularPolygon(lineSize: number, lineColor: number, lineAlpha: number, fillColor: number, fillAlpha: number, sides: number, startAngle?: number, distances?: number[]): void;
+        drawPolygon(lineSize: number, lineColor: number, lineAlpha: number, fillColor: number, fillAlpha: number, points: number[]): void;
+        distances: number[];
+        clearGraphics(): void;
+        color: number;
+        private updateGraph;
+        replaceMe(target: GObject): void;
+        addBeforeMe(target: GObject): void;
+        addAfterMe(target: GObject): void;
+        setNativeObject(obj: egret.DisplayObject): void;
+        protected createDisplayObject(): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        protected handleSizeChanged(): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare namespace fgui {
+    class GGroup extends GObject {
+        private _layout;
+        private _lineGap;
+        private _columnGap;
+        private _excludeInvisibles?;
+        private _autoSizeDisabled?;
+        private _mainGridIndex;
+        private _mainGridMinSize;
+        private _boundsChanged;
+        private _percentReady;
+        private _mainChildIndex;
+        private _totalSize;
+        private _numChildren;
+        _updating: number;
+        constructor();
+        dispose(): void;
+        layout: number;
+        lineGap: number;
+        columnGap: number;
+        excludeInvisibles: boolean;
+        autoSizeDisabled: boolean;
+        mainGridMinSize: number;
+        mainGridIndex: number;
+        setBoundsChangedFlag(positionChangedOnly?: boolean): void;
+        ensureSizeCorrect(): void;
+        ensureBoundsCorrect(): void;
+        private updateBounds;
+        private handleLayout;
+        moveChildren(dx: number, dy: number): void;
+        resizeChildren(dw: number, dh: number): void;
+        handleAlphaChanged(): void;
+        handleVisibleChanged(): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare module fgui {
+    class GImage extends GObject {
+        private _content;
+        private _flip;
+        constructor();
+        color: number;
+        flip: FlipType;
+        fillMethod: number;
+        fillOrigin: number;
+        fillClockwise: boolean;
+        fillAmount: number;
+        texture: egret.Texture;
+        protected createDisplayObject(): void;
+        constructFromResource(): void;
+        protected handleXYChanged(): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare module fgui {
+    class GLabel extends GComponent {
+        protected _titleObject: GObject;
+        protected _iconObject: GObject;
+        constructor();
+        icon: string;
+        title: string;
+        text: string;
+        titleColor: number;
+        titleFontSize: number;
+        editable: boolean;
+        getTextField(): GTextField;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        protected constructExtension(buffer: ByteBuffer): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare module fgui {
+    class GList extends GComponent {
+        itemRenderer: (index: number, item: GObject) => void;
+        itemProvider: (index: number) => string;
+        callbackThisObj: any;
+        scrollItemToViewOnClick: boolean;
+        foldInvisibleItems: boolean;
+        private _layout;
+        private _lineCount;
+        private _columnCount;
+        private _lineGap;
+        private _columnGap;
+        private _defaultItem;
+        private _autoResizeItem;
+        private _selectionMode;
+        private _align;
+        private _verticalAlign;
+        private _selectionController?;
+        private _lastSelectedIndex;
+        private _pool;
+        private _virtual?;
+        private _loop?;
+        private _numItems;
+        private _realNumItems;
+        private _firstIndex;
+        private _curLineItemCount;
+        private _curLineItemCount2;
+        private _itemSize?;
+        private _virtualListChanged;
+        private _virtualItems?;
+        private _eventLocked?;
+        private itemInfoVer;
+        constructor();
+        dispose(): void;
+        layout: ListLayoutType;
+        lineCount: number;
+        columnCount: number;
+        lineGap: number;
+        columnGap: number;
+        align: AlignType;
+        verticalAlign: VertAlignType;
+        virtualItemSize: egret.Point;
+        defaultItem: string;
+        autoResizeItem: boolean;
+        selectionMode: ListSelectionMode;
+        selectionController: Controller;
+        readonly itemPool: GObjectPool;
+        getFromPool(url?: string): GObject;
+        returnToPool(obj: GObject): void;
+        addChildAt(child: GObject, index: number): GObject;
+        addItem(url?: string): GObject;
+        addItemFromPool(url?: string): GObject;
+        removeChildAt(index: number, dispose?: boolean): GObject;
+        removeChildToPoolAt(index: number): void;
+        removeChildToPool(child: GObject): void;
+        removeChildrenToPool(beginIndex?: number, endIndex?: number): void;
+        selectedIndex: number;
+        getSelection(result?: number[]): number[];
+        addSelection(index: number, scrollItToView?: boolean): void;
+        removeSelection(index: number): void;
+        clearSelection(): void;
+        private clearSelectionExcept;
+        selectAll(): void;
+        selectNone(): void;
+        selectReverse(): void;
+        handleArrowKey(dir: number): void;
+        private __clickItem;
+        protected dispatchItemEvent(evt: ItemEvent): void;
+        private setSelectionOnEvent;
+        resizeToFit(itemCount?: number, minSize?: number): void;
+        getMaxItemWidth(): number;
+        protected handleSizeChanged(): void;
+        handleControllerChanged(c: Controller): void;
+        private updateSelectionController;
+        getSnappingPosition(xValue: number, yValue: number, result?: egret.Point): egret.Point;
+        scrollToView(index: number, ani?: boolean, setFirst?: boolean): void;
+        getFirstChildInView(): number;
+        childIndexToItemIndex(index: number): number;
+        itemIndexToChildIndex(index: number): number;
+        setVirtual(): void;
+        setVirtualAndLoop(): void;
+        private _setVirtual;
+        numItems: number;
+        refreshVirtualList(): void;
+        private checkVirtualList;
+        private setVirtualListChangedFlag;
+        private _refreshVirtualList;
+        private __scrolled;
+        private getIndexOnPos1;
+        private getIndexOnPos2;
+        private getIndexOnPos3;
+        private handleScroll;
+        private handleScroll1;
+        private handleScroll2;
+        private handleScroll3;
+        private handleArchOrder1;
+        private handleArchOrder2;
+        private handleAlign;
+        protected updateBounds(): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+        protected readItems(buffer: ByteBuffer): void;
+        protected setupItem(buffer: ByteBuffer, obj: GObject): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare module fgui {
+    class GObjectPool {
+        private _pool;
+        private _count;
+        constructor();
+        clear(): void;
+        readonly count: number;
+        getObject(url: string): GObject;
+        returnObject(obj: GObject): void;
+    }
+}
+declare module fgui {
+    class GLoader extends GObject {
+        private _url;
+        private _align;
+        private _verticalAlign;
+        private _autoSize;
+        private _fill;
+        private _shrinkOnly;
+        private _showErrorSign;
+        private _contentItem;
+        private _container;
+        private _content;
+        private _errorSign?;
+        private _content2?;
+        private _updatingLayout;
+        private static _errorSignPool;
+        constructor();
+        protected createDisplayObject(): void;
+        dispose(): void;
+        url: string;
+        icon: string;
+        align: AlignType;
+        verticalAlign: VertAlignType;
+        fill: LoaderFillType;
+        shrinkOnly: boolean;
+        autoSize: boolean;
+        playing: boolean;
+        frame: number;
+        color: number;
+        showErrorSign: boolean;
+        readonly content: MovieClip;
+        readonly component: GComponent;
+        texture: egret.Texture;
+        fillMethod: number;
+        fillOrigin: number;
+        fillClockwise: boolean;
+        fillAmount: number;
+        protected loadContent(): void;
+        protected loadFromPackage(itemURL: string): void;
+        protected loadExternal(): void;
+        protected freeExternal(texture: egret.Texture): void;
+        protected onExternalLoadSuccess(texture: egret.Texture): void;
+        protected onExternalLoadFailed(): void;
+        private __getResCompleted;
+        private setErrorState;
+        private clearErrorState;
+        private updateLayout;
+        private clearContent;
+        protected handleSizeChanged(): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare namespace fgui {
+    class GLoader3D extends GObject {
+        private _url;
+        private _align;
+        private _verticalAlign;
+        private _autoSize;
+        private _fill;
+        private _shrinkOnly;
+        private _playing;
+        private _frame;
+        private _loop;
+        private _animationName;
+        private _skinName;
+        private _color;
+        private _contentItem;
+        private _container;
+        private _content;
+        private _updatingLayout;
+        constructor();
+        protected createDisplayObject(): void;
+        dispose(): void;
+        url: string;
+        icon: string;
+        align: AlignType;
+        verticalAlign: VertAlignType;
+        fill: LoaderFillType;
+        shrinkOnly: boolean;
+        autoSize: boolean;
+        playing: boolean;
+        frame: number;
+        animationName: string;
+        skinName: string;
+        loop: boolean;
+        color: number;
+        readonly content: dragonBones.EgretArmatureDisplay;
+        protected loadContent(): void;
+        protected loadFromPackage(itemURL: string): void;
+        private onLoaded;
+        setDragonBones(armatureName: string, dragonBonesName?: string, skinName?: string, textureAtlasName?: string, anchor?: egret.Point): void;
+        private onChange;
+        private onChangeDragonBones;
+        protected loadExternal(): void;
+        private updateLayout;
+        private clearContent;
+        protected handleSizeChanged(): void;
+        protected handleGrayedChanged(): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare module fgui {
+    class GMovieClip extends GObject {
+        private _content;
+        constructor();
+        color: number;
+        protected createDisplayObject(): void;
+        playing: boolean;
+        frame: number;
+        timeScale: number;
+        rewind(): void;
+        syncStatus(anotherMc: GMovieClip): void;
+        advance(timeInMiniseconds: number): void;
+        setPlaySettings(start?: number, end?: number, times?: number, endAt?: number, endCallback?: Function, callbackObj?: any): void;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        constructFromResource(): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare module fgui {
+    class GProgressBar extends GComponent {
+        private _min;
+        private _max;
+        private _value;
+        private _titleType;
+        private _reverse;
+        private _titleObject;
+        private _aniObject;
+        private _barObjectH;
+        private _barObjectV;
+        private _barMaxWidth;
+        private _barMaxHeight;
+        private _barMaxWidthDelta;
+        private _barMaxHeightDelta;
+        private _barStartX;
+        private _barStartY;
+        constructor();
+        titleType: ProgressTitleType;
+        min: number;
+        max: number;
+        value: number;
+        tweenValue(value: number, duration: number): GTweener;
+        update(newValue: number): void;
+        private setFillAmount;
+        protected constructExtension(buffer: ByteBuffer): void;
+        protected handleSizeChanged(): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+}
+declare module fgui {
+    class GTextField extends GObject {
+        protected _textField: egret.TextField;
+        protected _bitmapContainer?: egret.DisplayObjectContainer;
+        protected _font: string;
+        protected _fontSize: number;
+        protected _align: AlignType;
+        protected _verticalAlign: VertAlignType;
+        protected _color: number;
+        protected _leading: number;
+        protected _letterSpacing: number;
+        protected _underline: boolean;
+        protected _text: string;
+        protected _ubbEnabled: boolean;
+        protected _templateVars?: {
+            [index: string]: string;
+        };
+        protected _autoSize: AutoSizeType;
+        protected _widthAutoSize: boolean;
+        protected _heightAutoSize: boolean;
+        protected _updatingSize: boolean;
+        protected _sizeDirty: boolean;
+        protected _textWidth: number;
+        protected _textHeight: number;
+        protected _requireRender: boolean;
+        protected _bitmapFont?: BitmapFont;
+        protected _lines?: Array<LineInfo>;
+        protected _bitmapPool?: Array<egret.Bitmap>;
+        protected static _htmlParser: egret.HtmlTextParser;
+        constructor();
+        protected createDisplayObject(): void;
+        private switchBitmapMode;
+        dispose(): void;
+        text: string;
+        protected updateTextFieldText(): void;
+        font: string;
+        fontSize: number;
+        color: number;
+        align: AlignType;
+        verticalAlign: VertAlignType;
+        private getAlignTypeString;
+        private getVertAlignTypeString;
+        leading: number;
+        letterSpacing: number;
+        underline: boolean;
+        bold: boolean;
+        italic: boolean;
+        singleLine: boolean;
+        stroke: number;
+        strokeColor: number;
+        ubbEnabled: boolean;
+        autoSize: AutoSizeType;
+        readonly textWidth: number;
+        ensureSizeCorrect(): void;
+        protected updateTextFormat(): void;
+        protected render(): void;
+        private __render;
+        protected renderNow(updateBounds?: boolean): void;
+        private renderWithBitmapFont;
+        protected handleSizeChanged(): void;
+        protected parseTemplate(template: string): string;
+        templateVars: {
+            [index: string]: string;
+        };
+        setVar(name: string, value: string): GTextField;
+        flushVars(): void;
+        protected handleGrayedChanged(): void;
+        private doAlign;
+        getProp(index: number): any;
+        setProp(index: number, value: any): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+    }
+    interface LineInfo {
+        width: number;
+        height: number;
+        textHeight: number;
+        text: string;
+        y: number;
+    }
+}
+declare module fgui {
+    class GRichTextField extends GTextField {
+        constructor();
+        protected updateTextFieldText(): void;
+    }
+}
+declare module fgui {
+    class GRoot extends GComponent {
+        static contentScaleLevel: number;
+        private _nativeStage;
+        private _modalLayer;
+        private _popupStack;
+        private _justClosedPopups;
+        private _modalWaitPane;
+        private _tooltipWin;
+        private _defaultTooltipWin;
+        private _volumeScale;
+        private static _inst;
+        static touchScreen: boolean;
+        static contentScaleFactor: number;
+        static touchDown: boolean;
+        static ctrlKeyDown: boolean;
+        static shiftKeyDown: boolean;
+        static mouseX: number;
+        static mouseY: number;
+        static readonly inst: GRoot;
+        constructor();
+        readonly nativeStage: egret.Stage;
+        showWindow(win: Window): void;
+        hideWindow(win: Window): void;
+        hideWindowImmediately(win: Window): void;
+        bringToFront(win: Window): void;
+        showModalWait(msg?: string): void;
+        closeModalWait(): void;
+        closeAllExceptModals(): void;
+        closeAllWindows(): void;
+        getTopWindow(): Window;
+        readonly modalLayer: GGraph;
+        readonly hasModalWindow: boolean;
+        readonly modalWaiting: boolean;
+        showPopup(popup: GObject, target?: GObject, dir?: PopupDirection | boolean): void;
+        togglePopup(popup: GObject, target?: GObject, dir?: PopupDirection | boolean): void;
+        hidePopup(popup?: GObject): void;
+        readonly hasAnyPopup: boolean;
+        private closePopup;
+        showTooltips(msg: string): void;
+        showTooltipsWin(tooltipWin: GObject, position?: egret.Point): void;
+        hideTooltips(): void;
+        getObjectUnderPoint(globalX: number, globalY: number): GObject;
+        focus: GObject;
+        private setFocus;
+        volumeScale: number;
+        playOneShotSound(sound: egret.Sound, volumeScale?: number): void;
+        private adjustModalLayer;
+        private __addedToStage;
+        private __stageMouseDownCapture;
+        private __stageMouseMoveCapture;
+        private __stageMouseUpCapture;
+        private __winResize;
+        private updateContentScaleLevel;
+    }
+}
+declare module fgui {
+    class GScrollBar extends GComponent {
+        private _grip;
+        private _arrowButton1;
+        private _arrowButton2;
+        private _bar;
+        private _target;
+        private _vertical;
+        private _scrollPerc;
+        private _fixedGripSize;
+        private _dragOffset;
+        private _gripDragging;
+        constructor();
+        setScrollPane(target: ScrollPane, vertical: boolean): void;
+        setDisplayPerc(value: number): void;
+        setScrollPerc(val: number): void;
+        readonly minSize: number;
+        readonly gripDragging: boolean;
+        protected constructExtension(buffer: ByteBuffer): void;
+        private __gripMouseDown;
+        private __gripMouseMove;
+        private __gripMouseUp;
+        private __arrowButton1Click;
+        private __arrowButton2Click;
+        private __barMouseDown;
+    }
+}
+declare module fgui {
+    class GSlider extends GComponent {
+        private _min;
+        private _max;
+        private _value;
+        private _titleType;
+        private _reverse;
+        private _wholeNumbers;
+        private _titleObject;
+        private _barObjectH;
+        private _barObjectV;
+        private _barMaxWidth;
+        private _barMaxHeight;
+        private _barMaxWidthDelta;
+        private _barMaxHeightDelta;
+        private _gripObject;
+        private _clickPos;
+        private _clickPercent;
+        private _barStartX;
+        private _barStartY;
+        changeOnClick: boolean;
+        canDrag: boolean;
+        constructor();
+        titleType: ProgressTitleType;
+        wholeNumbers: boolean;
+        min: number;
+        max: number;
+        value: number;
+        update(): void;
+        private updateWithPercent;
+        protected constructExtension(buffer: ByteBuffer): void;
+        protected handleSizeChanged(): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+        private __gripMouseDown;
+        private __gripMouseMove;
+        private __gripMouseUp;
+        private __barMouseDown;
+    }
+}
+declare module fgui {
+    class GTextInput extends GTextField {
+        private _promptText;
+        private _password;
+        constructor();
+        dispose(): void;
+        editable: boolean;
+        maxLength: number;
+        promptText: string;
+        restrict: string;
+        password: boolean;
+        verticalAlign: VertAlignType;
+        private updateVertAlign;
+        protected updateTextFieldText(): void;
+        protected handleSizeChanged(): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+        setup_afterAdd(buffer: ByteBuffer, beginPos: number): void;
+        private __textChanged;
+        private __focusIn;
+        private __focusOut;
+    }
+}
+declare namespace fgui {
+    class GTree extends GList {
+        treeNodeRender: (node: GTreeNode, obj: GComponent) => void;
+        treeNodeWillExpand: (node: GTreeNode, expanded: boolean) => void;
+        private _indent;
+        private _clickToExpand;
+        private _rootNode;
+        private _expandedStatusInEvt;
+        constructor();
+        readonly rootNode: GTreeNode;
+        indent: number;
+        clickToExpand: number;
+        getSelectedNode(): GTreeNode;
+        getSelectedNodes(result?: Array<GTreeNode>): Array<GTreeNode>;
+        selectNode(node: GTreeNode, scrollItToView?: boolean): void;
+        unselectNode(node: GTreeNode): void;
+        expandAll(folderNode?: GTreeNode): void;
+        collapseAll(folderNode?: GTreeNode): void;
+        private createCell;
+        _afterInserted(node: GTreeNode): void;
+        private getInsertIndexForNode;
+        _afterRemoved(node: GTreeNode): void;
+        _afterExpanded(node: GTreeNode): void;
+        _afterCollapsed(node: GTreeNode): void;
+        _afterMoved(node: GTreeNode): void;
+        private getFolderEndIndex;
+        private checkChildren;
+        private hideFolderNode;
+        private removeNode;
+        private __cellMouseDown;
+        private __expandedStateChanged;
+        protected dispatchItemEvent(evt: ItemEvent): void;
+        setup_beforeAdd(buffer: ByteBuffer, beginPos: number): void;
+        protected readItems(buffer: ByteBuffer): void;
+    }
+}
+declare namespace fgui {
+    class GTreeNode {
+        data: any;
+        private _parent;
+        private _children;
+        private _expanded;
+        private _level;
+        private _tree;
+        _cell: GComponent;
+        _resURL?: string;
+        constructor(hasChild: boolean, resURL?: string);
+        expanded: boolean;
+        readonly isFolder: boolean;
+        readonly parent: GTreeNode;
+        text: string;
+        icon: string;
+        readonly cell: GComponent;
+        readonly level: number;
+        _setLevel(value: number): void;
+        addChild(child: GTreeNode): GTreeNode;
+        addChildAt(child: GTreeNode, index: number): GTreeNode;
+        removeChild(child: GTreeNode): GTreeNode;
+        removeChildAt(index: number): GTreeNode;
+        removeChildren(beginIndex?: number, endIndex?: number): void;
+        getChildAt(index: number): GTreeNode;
+        getChildIndex(child: GTreeNode): number;
+        getPrevSibling(): GTreeNode;
+        getNextSibling(): GTreeNode;
+        setChildIndex(child: GTreeNode, index: number): void;
+        swapChildren(child1: GTreeNode, child2: GTreeNode): void;
+        swapChildrenAt(index1: number, index2: number): void;
+        readonly numChildren: number;
+        expandToRoot(): void;
+        readonly tree: GTree;
+        _setTree(value: GTree): void;
+    }
+}
+declare module fgui {
+    interface IUISource {
+        fileName: string;
+        loaded: boolean;
+        load(callback: Function, thisObj: any): void;
+    }
+}
+declare module fgui {
+    class Margin {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        constructor();
+        copy(source: Margin): void;
+    }
+}
+declare namespace fgui {
+    class PixelHitTest {
+        private _data;
+        offsetX: number;
+        offsetY: number;
+        scaleX: number;
+        scaleY: number;
+        constructor(data: PixelHitTestData, offsetX: number, offsetY: number);
+        contains(x: number, y: number): boolean;
+    }
+    class PixelHitTestData {
+        pixelWidth: number;
+        scale: number;
+        pixels: number[];
+        constructor();
+        load(ba: ByteBuffer): void;
+    }
+}
+declare module fgui {
+    class PackageItem {
+        owner: UIPackage;
+        type: PackageItemType;
+        objectType?: ObjectType;
+        id: string;
+        name: string;
+        width: number;
+        height: number;
+        file: string;
+        decoded?: boolean;
+        loading?: Array<Function>;
+        rawData?: ByteBuffer;
+        asset?: egret.Texture | egret.Sound | dragonBones.DragonBonesData;
+        highResolution?: Array<string>;
+        branches?: Array<string>;
+        scale9Grid?: egret.Rectangle;
+        scaleByTile?: boolean;
+        tileGridIndice?: number;
+        smoothing?: boolean;
+        pixelHitTestData?: PixelHitTestData;
+        interval?: number;
+        repeatDelay?: number;
+        swing?: boolean;
+        frames?: Array<Frame>;
+        extensionType?: any;
+        bitmapFont?: BitmapFont;
+        skeletonAnchor?: egret.Point;
+        armatureName?: string;
+        atlasAsset?: dragonBones.TextureAtlasData;
+        constructor();
+        load(): Object;
+        getBranch(): PackageItem;
+        getHighResolution(): PackageItem;
+        toString(): string;
+    }
+}
+declare module fgui {
+    class PopupMenu {
+        protected _contentPane: GComponent;
+        protected _list: GList;
+        constructor(resourceURL?: string);
+        dispose(): void;
+        addItem(caption: string, callback?: (item?: ItemEvent) => void): GButton;
+        addItemAt(caption: string, index: number, callback?: (item?: ItemEvent) => void): GButton;
+        addSeperator(): void;
+        getItemName(index: number): string;
+        setItemText(name: string, caption: string): void;
+        setItemVisible(name: string, visible: boolean): void;
+        setItemGrayed(name: string, grayed: boolean): void;
+        setItemCheckable(name: string, checkable: boolean): void;
+        setItemChecked(name: string, checked: boolean): void;
+        isItemChecked(name: string): boolean;
+        removeItem(name: string): boolean;
+        clearItems(): void;
+        readonly itemCount: number;
+        readonly contentPane: GComponent;
+        readonly list: GList;
+        show(target?: GObject, dir?: PopupDirection | boolean): void;
+        private __clickItem;
+        private __clickItem2;
+        private __addedToStage;
+    }
+}
+declare module fgui {
+    class RelationItem {
+        private _owner;
+        private _target;
+        private _defs;
+        private _targetX;
+        private _targetY;
+        private _targetWidth;
+        private _targetHeight;
+        constructor(owner: GObject);
+        readonly owner: GObject;
+        target: GObject;
+        add(relationType: number, usePercent: boolean): void;
+        internalAdd(relationType: number, usePercent: boolean): void;
+        remove(relationType?: number): void;
+        copyFrom(source: RelationItem): void;
+        dispose(): void;
+        readonly isEmpty: boolean;
+        applyOnSelfResized(dWidth: number, dHeight: number, applyPivot: boolean): void;
+        private applyOnXYChanged;
+        private applyOnSizeChanged;
+        private addRefTarget;
+        private releaseRefTarget;
+        private __targetXYChanged;
+        private __targetSizeChanged;
+        private __targetSizeWillChange;
+    }
+    class RelationDef {
+        percent: boolean;
+        type: number;
+        axis: number;
+        constructor();
+        copyFrom(source: RelationDef): void;
+    }
+}
+declare module fgui {
+    class Relations {
+        private _owner;
+        private _items;
+        handling: GObject;
+        sizeDirty: boolean;
+        constructor(owner: GObject);
+        add(target: GObject, relationType: number, usePercent?: boolean): void;
+        remove(target: GObject, relationType?: number): void;
+        contains(target: GObject): boolean;
+        clearFor(target: GObject): void;
+        clearAll(): void;
+        copyFrom(source: Relations): void;
+        dispose(): void;
+        onOwnerSizeChanged(dWidth: number, dHeight: number, applyPivot: boolean): void;
+        ensureRelationsSizeCorrect(): void;
+        readonly empty: boolean;
+        setup(buffer: ByteBuffer, parentToChild: boolean): void;
+    }
+}
+declare module fgui {
+    class ScrollPane extends egret.EventDispatcher {
+        private _owner;
+        private _container;
+        private _maskContainer;
+        private _alignContainer?;
+        private _scrollType;
+        private _scrollStep;
+        private _decelerationRate;
+        private _scrollBarMargin;
+        private _bouncebackEffect;
+        private _touchEffect;
+        private _scrollBarDisplayAuto?;
+        private _vScrollNone;
+        private _hScrollNone;
+        private _needRefresh;
+        private _refreshBarAxis;
+        private _displayOnLeft?;
+        private _snapToItem?;
+        _displayInDemand?: boolean;
+        private _pageMode?;
+        private _inertiaDisabled?;
+        private _floating?;
+        private _dontClipMargin?;
+        private _xPos;
+        private _yPos;
+        private _viewSize;
+        private _contentSize;
+        private _overlapSize;
+        private _pageSize;
+        private _containerPos;
+        private _beginTouchPos;
+        private _lastTouchPos;
+        private _lastTouchGlobalPos;
+        private _velocity;
+        private _velocityScale;
+        private _lastMoveTime;
+        private _isHoldAreaDone;
+        private _aniFlag;
+        _loop: number;
+        private _headerLockedSize;
+        private _footerLockedSize;
+        private _refreshEventDispatching;
+        private _dragged;
+        private _tweening;
+        private _tweenTime;
+        private _tweenDuration;
+        private _tweenStart;
+        private _tweenChange;
+        private _pageController?;
+        private _hzScrollBar?;
+        private _vtScrollBar?;
+        private _header?;
+        private _footer?;
+        static draggingPane: ScrollPane;
+        static SCROLL: string;
+        static SCROLL_END: string;
+        static PULL_DOWN_RELEASE: string;
+        static PULL_UP_RELEASE: string;
+        constructor(owner: GComponent);
+        setup(buffer: ByteBuffer): void;
+        dispose(): void;
+        readonly owner: GComponent;
+        readonly hzScrollBar: GScrollBar;
+        readonly vtScrollBar: GScrollBar;
+        readonly header: GComponent;
+        readonly footer: GComponent;
+        bouncebackEffect: boolean;
+        touchEffect: boolean;
+        scrollStep: number;
+        decelerationRate: number;
+        snapToItem: boolean;
+        readonly isDragged: boolean;
+        percX: number;
+        setPercX(value: number, ani?: boolean): void;
+        percY: number;
+        setPercY(value: number, ani?: boolean): void;
+        posX: number;
+        setPosX(value: number, ani?: boolean): void;
+        posY: number;
+        setPosY(value: number, ani?: boolean): void;
+        readonly contentWidth: number;
+        readonly contentHeight: number;
+        viewWidth: number;
+        viewHeight: number;
+        currentPageX: number;
+        currentPageY: number;
+        setCurrentPageX(value: number, ani?: boolean): void;
+        setCurrentPageY(value: number, ani?: boolean): void;
+        readonly isBottomMost: boolean;
+        readonly isRightMost: boolean;
+        pageController: Controller;
+        readonly scrollingPosX: number;
+        readonly scrollingPosY: number;
+        scrollTop(ani?: boolean): void;
+        scrollBottom(ani?: boolean): void;
+        scrollUp(ratio?: number, ani?: boolean): void;
+        scrollDown(ratio?: number, ani?: boolean): void;
+        scrollLeft(ratio?: number, ani?: boolean): void;
+        scrollRight(ratio?: number, ani?: boolean): void;
+        scrollToView(target: egret.Rectangle | GObject, ani?: boolean, setFirst?: boolean): void;
+        isChildInView(obj: GObject): boolean;
+        cancelDragging(): void;
+        lockHeader(size: number): void;
+        lockFooter(size: number): void;
+        onOwnerSizeChanged(): void;
+        handleControllerChanged(c: Controller): void;
+        private updatePageController;
+        adjustMaskContainer(): void;
+        setSize(aWidth: number, aHeight: number): void;
+        setContentSize(aWidth: number, aHeight: number): void;
+        changeContentSizeOnScrolling(deltaWidth: number, deltaHeight: number, deltaPosX: number, deltaPosY: number): void;
+        private handleSizeChanged;
+        private posChanged;
+        private refresh;
+        private refresh2;
+        private __touchBegin;
+        private __touchMove;
+        private __touchEnd;
+        private __touchTap;
+        private updateScrollBarPos;
+        updateScrollBarVisible(): void;
+        private updateScrollBarVisible2;
+        private __barTweenComplete;
+        private getLoopPartSize;
+        private loopCheckingCurrent;
+        private loopCheckingTarget;
+        private loopCheckingTarget2;
+        private loopCheckingNewPos;
+        private alignPosition;
+        private alignByPage;
+        private updateTargetAndDuration;
+        private updateTargetAndDuration2;
+        private fixDuration;
+        private startTween;
+        private killTween;
+        private checkRefreshBar;
+        private tweenUpdate;
+        private runTween;
+    }
+}
+declare module fgui {
+    class Transition {
+        name: string;
+        private _owner;
+        private _ownerBaseX;
+        private _ownerBaseY;
+        private _items;
+        private _totalTimes;
+        private _totalTasks;
+        private _playing;
+        private _paused;
+        private _onComplete;
+        private _onCompleteCaller;
+        private _onCompleteParam;
+        private _options;
+        private _reversed;
+        private _totalDuration;
+        private _autoPlay;
+        private _autoPlayTimes;
+        private _autoPlayDelay;
+        private _timeScale;
+        private _startTime;
+        private _endTime;
+        constructor(owner: GComponent);
+        play(onComplete?: () => void, onCompleteObj?: any, onCompleteParam?: any, times?: number, delay?: number, startTime?: number, endTime?: number): void;
+        playReverse(onComplete?: () => void, onCompleteObj?: any, onCompleteParam?: any, times?: number, delay?: number): void;
+        changePlayTimes(value: number): void;
+        setAutoPlay(value: boolean, times?: number, delay?: number): void;
+        private _play;
+        stop(setToComplete?: boolean, processCallback?: boolean): void;
+        private stopItem;
+        setPaused(paused: boolean): void;
+        dispose(): void;
+        readonly playing: boolean;
+        setValue(label: string, ...args: any[]): void;
+        setHook(label: string, callback: Function, caller?: any): void;
+        clearHooks(): void;
+        setTarget(label: string, newTarget: GObject): void;
+        setDuration(label: string, value: number): void;
+        getLabelTime(label: string): number;
+        timeScale: number;
+        updateFromRelations(targetId: string, dx: number, dy: number): void;
+        onOwnerAddedToStage(): void;
+        onOwnerRemovedFromStage(): void;
+        private onDelayedPlay;
+        private internalPlay;
+        private playItem;
+        private skipAnimations;
+        private onDelayedPlayItem;
+        private onTweenStart;
+        private onTweenUpdate;
+        private onTweenComplete;
+        private onPlayTransCompleted;
+        private callHook;
+        private checkAllComplete;
+        private applyValue;
+        setup(buffer: ByteBuffer): void;
+        private decodeValue;
+    }
+}
+declare module fgui {
+    class TranslationHelper {
+        static strings: {
+            [index: string]: {
+                [index: string]: string;
+            };
+        };
+        static loadFromXML(source: string): void;
+        static translateComponent(item: PackageItem): void;
+    }
+}
+declare module fgui {
+    class UIConfig {
+        constructor();
+        static defaultFont: string;
+        static windowModalWaiting: string;
+        static globalModalWaiting: string;
+        static modalLayerColor: number;
+        static modalLayerAlpha: number;
+        static buttonSound: string;
+        static buttonSoundVolumeScale: number;
+        static horizontalScrollBar: string;
+        static verticalScrollBar: string;
+        static defaultScrollStep: number;
+        static defaultScrollDecelerationRate: number;
+        static defaultScrollBarDisplay: number;
+        static defaultScrollTouchEffect: boolean;
+        static defaultScrollBounceEffect: boolean;
+        static popupMenu: string;
+        static popupMenu_seperator: string;
+        static loaderErrorSign: string;
+        static tooltipsWin: string;
+        static defaultComboBoxVisibleItemCount: number;
+        static touchScrollSensitivity: number;
+        static touchDragSensitivity: number;
+        static clickDragSensitivity: number;
+        static bringWindowToFrontOnClick: boolean;
+        static frameTimeForAsyncUIConstruction: number;
+    }
+}
+declare module fgui {
+    class UIObjectFactory {
+        static extensions: {
+            [index: string]: new () => GComponent;
+        };
+        static loaderType: new () => GLoader;
+        constructor();
+        static setExtension(url: string, type: new () => GComponent): void;
+        static setPackageItemExtension(url: string, type: new () => GComponent): void;
+        static setLoaderExtension(type: new () => GLoader): void;
+        static resolvePackageItemExtension(pi: PackageItem): void;
+        static newObject(type: number | PackageItem, userClass?: new () => GObject): GObject;
+    }
+}
+declare module fgui {
+    class UIPackage {
+        private _id;
+        private _name;
+        private _items;
+        private _itemsById;
+        private _itemsByName;
+        private _resKey;
+        private _customId;
+        private _sprites;
+        private _dependencies;
+        private _branches;
+        _branchIndex: number;
+        static _constructing: number;
+        private static _instById;
+        private static _instByName;
+        private static _branch;
+        private static _vars;
+        constructor();
+        static branch: string;
+        static getVar(key: string): string;
+        static setVar(key: string, value: string): void;
+        static getById(id: string): UIPackage;
+        static getByName(name: string): UIPackage;
+        static loadPackage(resKey: string): Promise<UIPackage>;
+        static addPackage(resKey: string, descData?: ArrayBuffer): UIPackage;
+        static removePackage(packageIdOrName: string): void;
+        static createObject(pkgName: string, resName: string, userClass?: new () => GObject): GObject;
+        static createObjectFromURL(url: string, userClass?: new () => GObject): GObject;
+        static getItemURL(pkgName: string, resName: string): string;
+        static getItemByURL(url: string): PackageItem;
+        static normalizeURL(url: string): string;
+        static setStringsSource(source: string): void;
+        private loadPackage;
+        dispose(): void;
+        readonly id: string;
+        readonly name: string;
+        customId: string;
+        createObject(resName: string, userClass?: new () => GObject): GObject;
+        internalCreateObject(item: PackageItem, userClass?: new () => GObject): GObject;
+        getItemById(itemId: string): PackageItem;
+        getItemByName(resName: string): PackageItem;
+        getItemAssetByName(resName: string): Object;
+        getItemAsset(item: PackageItem): Object;
+        getItemAssetAsync(item: PackageItem, onComplete?: (err: any, item: PackageItem) => void): void;
+        private loadMovieClip;
+        private loadFont;
+        private loadDragonBones;
+    }
+}
+declare module fgui {
+    class Window extends GComponent {
+        private _contentPane;
+        private _modalWaitPane;
+        private _closeButton;
+        private _dragArea;
+        private _contentArea;
+        private _frame;
+        private _modal;
+        private _uiSources?;
+        private _inited?;
+        private _loading?;
+        protected _requestingCmd: number;
+        bringToFontOnClick: boolean;
+        constructor();
+        addUISource(source: IUISource): void;
+        contentPane: GComponent;
+        readonly frame: GComponent;
+        closeButton: GObject;
+        dragArea: GObject;
+        contentArea: GObject;
+        show(): void;
+        showOn(root: GRoot): void;
+        hide(): void;
+        hideImmediately(): void;
+        centerOn(r: GRoot, restraint?: boolean): void;
+        toggleStatus(): void;
+        readonly isShowing: boolean;
+        readonly isTop: boolean;
+        modal: boolean;
+        bringToFront(): void;
+        showModalWait(requestingCmd?: number): void;
+        protected layoutModalWaitPane(): void;
+        closeModalWait(requestingCmd?: number): boolean;
+        readonly modalWaiting: boolean;
+        init(): void;
+        protected onInit(): void;
+        protected onShown(): void;
+        protected onHide(): void;
+        protected doShowAnimation(): void;
+        protected doHideAnimation(): void;
+        private __uiLoadComplete;
+        private _init;
+        dispose(): void;
+        protected closeEventHandler(evt: egret.Event): void;
+        private __onShown;
+        private __onHidden;
+        private __mouseDown;
+        private __dragStart;
+    }
+}
+declare module fgui {
+    class ControllerAction {
+        fromPage: string[];
+        toPage: string[];
+        static createAction(type: number): ControllerAction;
+        constructor();
+        run(controller: Controller, prevPage: string, curPage: string): void;
+        protected enter(controller: Controller): void;
+        protected leave(controller: Controller): void;
+        setup(buffer: ByteBuffer): void;
+    }
+}
+declare module fgui {
+    class ChangePageAction extends ControllerAction {
+        objectId: string;
+        controllerName: string;
+        targetPage: string;
+        constructor();
+        protected enter(controller: Controller): void;
+        setup(buffer: ByteBuffer): void;
+    }
+}
+declare module fgui {
+    class PlayTransitionAction extends ControllerAction {
+        transitionName: string;
+        playTimes: number;
+        delay: number;
+        stopOnExit: boolean;
+        private _currentTransition;
+        constructor();
+        protected enter(controller: Controller): void;
+        protected leave(controller: Controller): void;
+        setup(buffer: ByteBuffer): void;
+    }
+}
+declare module fgui {
+    class BitmapFont {
+        id: string;
+        size: number;
+        ttf: boolean;
+        glyphs: {
+            [index: string]: BMGlyph;
+        };
+        resizable: boolean;
+        tint: boolean;
+        constructor();
+    }
+    interface BMGlyph {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        advance?: number;
+        lineHeight?: number;
+        channel?: number;
+        texture?: egret.Texture;
+    }
+}
+declare namespace fgui {
+    function fillImage(w: number, h: number, method: number, origin: number, clockwise: boolean, amount: number): Array<number>;
+}
+declare module fgui {
+    class Image extends egret.Bitmap {
+        private _fillMethod;
+        private _fillOrigin;
+        private _fillAmount;
+        private _fillClockwise?;
+        private _mask?;
+        private _maskDirtyFlag?;
+        private _color;
+        constructor();
+        color: number;
+        $setX(value: number): boolean;
+        $setY(value: number): boolean;
+        fillMethod: FillMethod;
+        fillOrigin: number;
+        fillClockwise: boolean;
+        fillAmount: number;
+        private markChanged;
+        private doFill;
+    }
+}
+declare module fgui {
+    interface Frame {
+        addDelay?: number;
+        texture?: egret.Texture;
+    }
+    class MovieClip extends Image {
+        interval: number;
+        swing: boolean;
+        repeatDelay: number;
+        timeScale: number;
+        private _playing;
+        private _frameCount;
+        private _frames;
+        private _frame;
+        private _start;
+        private _end;
+        private _times;
+        private _endAt;
+        private _status;
+        private _callback;
+        private _callbackObj;
+        private _smoothing;
+        private _frameElapsed;
+        private _reversed;
+        private _repeatedCount;
+        constructor();
+        frames: Array<Frame>;
+        readonly frameCount: number;
+        frame: number;
+        playing: boolean;
+        smoothing: boolean;
+        rewind(): void;
+        syncStatus(anotherMc: MovieClip): void;
+        advance(timeInMiniseconds: number): void;
+        setPlaySettings(start?: number, end?: number, times?: number, endAt?: number, endCallback?: Function, callbackObj?: any): void;
+        private update;
+        private drawFrame;
+        private checkTimer;
+        $onAddToStage(stage: egret.Stage, nestLevel: number): void;
+        $onRemoveFromStage(): void;
+    }
+}
+declare module fgui {
+    class UIContainer extends egret.DisplayObjectContainer {
+        private _hitArea?;
+        private _cachedMatrix?;
+        private _cachedHitArea?;
+        private _opaque?;
+        constructor();
+        cacheHitArea(value: boolean): void;
+        hitArea: PixelHitTest | egret.DisplayObject;
+        opaque: boolean;
+        $hitTest(stageX: number, stageY: number): egret.DisplayObject;
+    }
+}
+declare module fgui {
+    class DragEvent extends egret.Event {
+        stageX: number;
+        stageY: number;
+        touchPointID: number;
+        private _prevented;
+        static DRAG_START: string;
+        static DRAG_END: string;
+        static DRAG_MOVING: string;
+        constructor(type: string, stageX?: number, stageY?: number, touchPointID?: number);
+        preventDefault(): void;
+        isDefaultPrevented(): boolean;
+    }
+}
+declare module fgui {
+    class DropEvent extends egret.Event {
+        source: any;
+        static DROP: string;
+        constructor(type: string, source?: any);
+    }
+}
+declare module fgui {
+    class ItemEvent extends egret.Event {
+        itemObject: GObject;
+        stageX: number;
+        stageY: number;
+        static CLICK: string;
+        constructor(type: string, itemObject?: GObject, stageX?: number, stageY?: number);
+    }
+}
+declare module fgui {
+    class StateChangeEvent extends egret.Event {
+        static CHANGED: string;
+        constructor(type: string);
+    }
+}
+declare namespace fgui {
+    class GearBase {
+        static disableAllTweenEffect: boolean;
+        protected _owner: GObject;
+        protected _controller: Controller;
+        protected _tweenConfig?: GearTweenConfig;
+        static create(owner: GObject, index: number): GearBase;
+        constructor(owner: GObject);
+        dispose(): void;
+        controller: Controller;
+        readonly tweenConfig: GearTweenConfig;
+        setup(buffer: ByteBuffer): void;
+        updateFromRelations(dx: number, dy: number): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        protected init(): void;
+        apply(): void;
+        updateState(): void;
+    }
+    class GearTweenConfig {
+        tween: boolean;
+        easeType: number;
+        duration: number;
+        delay: number;
+        _displayLockToken: number;
+        _tweener: GTweener;
+        constructor();
+    }
+}
+declare namespace fgui {
+    class GearAnimation extends GearBase {
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        updateState(): void;
+    }
+}
+declare namespace fgui {
+    class GearColor extends GearBase {
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        updateState(): void;
+    }
+}
+declare namespace fgui {
+    class GearDisplay extends GearBase {
+        pages: string[];
+        private _visible;
+        private _displayLockToken;
+        constructor(owner: GObject);
+        protected init(): void;
+        apply(): void;
+        addLock(): number;
+        releaseLock(token: number): void;
+        readonly connected: boolean;
+    }
+}
+declare namespace fgui {
+    class GearDisplay2 extends GearBase {
+        pages: string[];
+        condition: number;
+        private _visible;
+        constructor(owner: GObject);
+        protected init(): void;
+        apply(): void;
+        evaluate(connected: boolean): boolean;
+    }
+}
+declare namespace fgui {
+    class GearFontSize extends GearBase {
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        updateState(): void;
+    }
+}
+declare namespace fgui {
+    class GearIcon extends GearBase {
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        updateState(): void;
+    }
+}
+declare namespace fgui {
+    class GearLook extends GearBase {
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        private __tweenUpdate;
+        private __tweenComplete;
+        updateState(): void;
+    }
+}
+declare namespace fgui {
+    class GearSize extends GearBase {
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        private __tweenUpdate;
+        private __tweenComplete;
+        updateState(): void;
+        updateFromRelations(dx: number, dy: number): void;
+    }
+}
+declare namespace fgui {
+    class GearText extends GearBase {
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        updateState(): void;
+    }
+}
+declare namespace fgui {
+    class GearXY extends GearBase {
+        positionsInPercent: boolean;
+        private _storage;
+        private _default;
+        constructor(owner: GObject);
+        protected init(): void;
+        protected addStatus(pageId: string, buffer: ByteBuffer): void;
+        addExtStatus(pageId: string, buffer: ByteBuffer): void;
+        apply(): void;
+        private __tweenUpdate;
+        private __tweenComplete;
+        updateState(): void;
+        updateFromRelations(dx: number, dy: number): void;
+    }
+}
+declare namespace fgui {
+    function evaluateEase(easeType: number, time: number, duration: number, overshootOrAmplitude: number, period: number): number;
+}
+declare namespace fgui {
+    class EaseType {
+        static Linear: number;
+        static SineIn: number;
+        static SineOut: number;
+        static SineInOut: number;
+        static QuadIn: number;
+        static QuadOut: number;
+        static QuadInOut: number;
+        static CubicIn: number;
+        static CubicOut: number;
+        static CubicInOut: number;
+        static QuartIn: number;
+        static QuartOut: number;
+        static QuartInOut: number;
+        static QuintIn: number;
+        static QuintOut: number;
+        static QuintInOut: number;
+        static ExpoIn: number;
+        static ExpoOut: number;
+        static ExpoInOut: number;
+        static CircIn: number;
+        static CircOut: number;
+        static CircInOut: number;
+        static ElasticIn: number;
+        static ElasticOut: number;
+        static ElasticInOut: number;
+        static BackIn: number;
+        static BackOut: number;
+        static BackInOut: number;
+        static BounceIn: number;
+        static BounceOut: number;
+        static BounceInOut: number;
+        static Custom: number;
+    }
+}
+declare namespace fgui {
+    class GPath {
+        private _segments;
+        private _points;
+        private _fullLength;
+        constructor();
+        readonly length: number;
+        create(pt1: Array<GPathPoint> | GPathPoint, pt2?: GPathPoint, pt3?: GPathPoint, pt4?: GPathPoint): void;
+        private createSplineSegment;
+        clear(): void;
+        getPointAt(t: number, result?: egret.Point): egret.Point;
+        readonly segmentCount: number;
+        getAnchorsInSegment(segmentIndex: number, points?: Array<egret.Point>): Array<egret.Point>;
+        getPointsInSegment(segmentIndex: number, t0: number, t1: number, points?: Array<egret.Point>, ts?: Array<number>, pointDensity?: number): Array<egret.Point>;
+        getAllPoints(points?: Array<egret.Point>, ts?: Array<number>, pointDensity?: number): Array<egret.Point>;
+        private onCRSplineCurve;
+        private onBezierCurve;
+    }
+}
+declare namespace fgui {
+    enum CurveType {
+        CRSpline = 0,
+        Bezier = 1,
+        CubicBezier = 2,
+        Straight = 3
+    }
+    class GPathPoint {
+        x: number;
+        y: number;
+        control1_x: number;
+        control1_y: number;
+        control2_x: number;
+        control2_y: number;
+        curveType: number;
+        constructor();
+        static newPoint(x?: number, y?: number, curveType?: number): GPathPoint;
+        static newBezierPoint(x?: number, y?: number, control1_x?: number, control1_y?: number): GPathPoint;
+        static newCubicBezierPoint(x?: number, y?: number, control1_x?: number, control1_y?: number, control2_x?: number, control2_y?: number): GPathPoint;
+        clone(): GPathPoint;
+    }
+}
+declare namespace fgui {
+    class GTween {
+        static catchCallbackExceptions: boolean;
+        static to(start: number, end: number, duration: number): GTweener;
+        static to2(start: number, start2: number, end: number, end2: number, duration: number): GTweener;
+        static to3(start: number, start2: number, start3: number, end: number, end2: number, end3: number, duration: number): GTweener;
+        static to4(start: number, start2: number, start3: number, start4: number, end: number, end2: number, end3: number, end4: number, duration: number): GTweener;
+        static toColor(start: number, end: number, duration: number): GTweener;
+        static delayedCall(delay: number): GTweener;
+        static shake(startX: number, startY: number, amplitude: number, duration: number): GTweener;
+        static isTweening(target: any, propType?: any): Boolean;
+        static kill(target: any, complete?: boolean, propType?: any): void;
+        static getTween(target: any, propType?: any): GTweener;
+    }
+}
+declare module fgui {
+    class GTweener {
+        _target: any;
+        _propType: any;
+        _killed: boolean;
+        _paused: boolean;
+        private _delay;
+        private _duration;
+        private _breakpoint;
+        private _easeType;
+        private _easeOvershootOrAmplitude;
+        private _easePeriod;
+        private _repeat;
+        private _yoyo;
+        private _timeScale;
+        private _snapping;
+        private _userData;
+        private _path;
+        private _onUpdate;
+        private _onStart;
+        private _onComplete;
+        private _onUpdateCaller;
+        private _onStartCaller;
+        private _onCompleteCaller;
+        private _startValue;
+        private _endValue;
+        private _value;
+        private _deltaValue;
+        private _valueSize;
+        private _started;
+        private _ended;
+        private _elapsedTime;
+        private _normalizedTime;
+        constructor();
+        setDelay(value: number): GTweener;
+        readonly delay: number;
+        setDuration(value: number): GTweener;
+        readonly duration: number;
+        setBreakpoint(value: number): GTweener;
+        setEase(value: number): GTweener;
+        setEasePeriod(value: number): GTweener;
+        setEaseOvershootOrAmplitude(value: number): GTweener;
+        setRepeat(repeat: number, yoyo?: boolean): GTweener;
+        readonly repeat: number;
+        setTimeScale(value: number): GTweener;
+        setSnapping(value: boolean): GTweener;
+        setTarget(value: any, propType?: any): GTweener;
+        readonly target: any;
+        setUserData(value: any): GTweener;
+        readonly userData: any;
+        setPath(value: GPath): GTweener;
+        onUpdate(callback: Function, caller?: any): GTweener;
+        onStart(callback: Function, caller?: any): GTweener;
+        onComplete(callback: Function, caller?: any): GTweener;
+        readonly startValue: TweenValue;
+        readonly endValue: TweenValue;
+        readonly value: TweenValue;
+        readonly deltaValue: TweenValue;
+        readonly normalizedTime: number;
+        readonly completed: boolean;
+        readonly allCompleted: boolean;
+        setPaused(paused: boolean): GTweener;
+        seek(time: number): void;
+        kill(complete?: boolean): void;
+        _to(start: number, end: number, duration: number): GTweener;
+        _to2(start: number, start2: number, end: number, end2: number, duration: number): GTweener;
+        _to3(start: number, start2: number, start3: number, end: number, end2: number, end3: number, duration: number): GTweener;
+        _to4(start: number, start2: number, start3: number, start4: number, end: number, end2: number, end3: number, end4: number, duration: number): GTweener;
+        _toColor(start: number, end: number, duration: number): GTweener;
+        _shake(startX: number, startY: number, amplitude: number, duration: number): GTweener;
+        _init(): void;
+        _reset(): void;
+        _update(dt: number): void;
+        private update;
+        private callStartCallback;
+        private callUpdateCallback;
+        private callCompleteCallback;
+    }
+}
+declare module fgui {
+    class TweenManager {
+        static createTween(): GTweener;
+        static isTweening(target: any, propType?: any): boolean;
+        static killTweens(target: any, completed?: boolean, propType?: any): boolean;
+        static getTween(target: any, propType?: any): GTweener;
+        private static update;
+    }
+}
+declare namespace fgui {
+    class TweenValue {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+        constructor();
+        color: number;
+        getField(index: number): number;
+        setField(index: number, value: number): void;
+        setZero(): void;
+    }
+}
+declare module fgui {
+    class ByteBuffer extends egret.ByteArray {
+        stringTable?: Array<string>;
+        version: number;
+        constructor(buffer?: ArrayBuffer | Uint8Array, bufferExtSize?: number);
+        skip(count: number): void;
+        readBool(): boolean;
+        readS(): string;
+        readSArray(cnt: number): Array<string>;
+        writeS(value: string): void;
+        readColor(hasAlpha?: boolean): number;
+        readChar(): string;
+        readBuffer(): ByteBuffer;
+        seek(indexTablePos: number, blockIndex: number): boolean;
+    }
+}
+declare namespace fgui {
+    class ColorMatrix {
+        readonly matrix: Array<number>;
+        constructor(p_brightness?: number, p_contrast?: number, p_saturation?: number, p_hue?: number);
+        reset(): void;
+        invert(): void;
+        adjustColor(p_brightness: number, p_contrast: number, p_saturation: number, p_hue: number): void;
+        adjustBrightness(p_val: number): void;
+        adjustContrast(p_val: number): void;
+        adjustSaturation(p_val: number): void;
+        adjustHue(p_val: number): void;
+        concat(p_matrix: Array<number>): void;
+        clone(): ColorMatrix;
+        protected copyMatrix(p_matrix: Array<number>): void;
+        protected multiplyMatrix(p_matrix: Array<number>): void;
+        protected cleanValue(p_val: number, p_limit: number): number;
+    }
+}
+declare module fgui {
+    class GTimers {
+        private _items;
+        private _itemPool;
+        private _enumI;
+        private _enumCount;
+        private _lastTime;
+        static deltaTime: number;
+        static time: number;
+        static readonly inst: GTimers;
+        constructor();
+        private getItem;
+        private findItem;
+        add(delayInMiniseconds: number, repeat: number, callback: Function, thisObj?: any, callbackParam?: any): void;
+        callLater(callback: Function, thisObj?: any, callbackParam?: any): void;
+        callDelay(delay: number, callback: Function, thisObj?: any, callbackParam?: any): void;
+        exists(callback: Function, thisObj?: any): boolean;
+        remove(callback: Function, thisObj?: any): void;
+        private __timer;
+    }
+}
+declare module fgui {
+    class UBBParser {
+        private _text;
+        private _readPos;
+        protected _handlers: {
+            [index: string]: (tagName: string, end: boolean, attr: string) => string;
+        };
+        smallFontSize: number;
+        normalFontSize: number;
+        largeFontSize: number;
+        defaultImgWidth: number;
+        defaultImgHeight: number;
+        static inst: UBBParser;
+        constructor();
+        protected onTag_URL(tagName: string, end: boolean, attr: string): string;
+        protected onTag_IMG(tagName: string, end: boolean, attr: string): string;
+        protected onTag_Simple(tagName: string, end: boolean, attr: string): string;
+        protected onTag_COLOR(tagName: string, end: boolean, attr: string): string;
+        protected onTag_FONT(tagName: string, end: boolean, attr: string): string;
+        protected onTag_SIZE(tagName: string, end: boolean, attr: string): string;
+        protected getTagText(remove?: boolean): string;
+        parse(text: string, remove?: boolean): string;
+    }
+}
+declare module fgui {
+    class ToolSet {
+        static startsWith(source: string, str: string, ignoreCase?: boolean): boolean;
+        static trimRight(targetString: string): string;
+        static convertToHtmlColor(argb: number, hasAlpha?: boolean): string;
+        static convertFromHtmlColor(str: string, hasAlpha?: boolean): number;
+        static displayObjectToGObject(obj: egret.DisplayObject): GObject;
+        static encodeHTML(str: string): string;
+        static clamp(value: number, min: number, max: number): number;
+        static clamp01(value: number): number;
+        static lerp(start: number, end: number, percent: number): number;
+        static repeat(t: number, length: number): number;
+        static distance(x1: number, y1: number, x2: number, y2: number): number;
+        static fillPath(ctx: egret.Graphics, points: number[], px: number, py: number): void;
+        static setColorFilter(obj: egret.DisplayObject, color?: number | number[] | boolean): void;
+    }
+}
+import fairygui = fgui;
\ No newline at end of file
diff --git a/demo/libs/fairygui/fairygui.js b/demo/libs/fairygui/fairygui.js
new file mode 100644
index 00000000..49b99782
--- /dev/null
+++ b/demo/libs/fairygui/fairygui.js
@@ -0,0 +1,19026 @@
+window.fgui = {};
+window.fairygui = window.fgui;
+window.__extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+
+(function (fgui) {
+    var AsyncOperation = (function () {
+        function AsyncOperation() {
+            this._itemList = new Array();
+            this._objectPool = new Array();
+        }
+        AsyncOperation.prototype.createObject = function (pkgName, resName) {
+            var pkg = fgui.UIPackage.getByName(pkgName);
+            if (pkg) {
+                var pi = pkg.getItemByName(resName);
+                if (!pi)
+                    throw new Error("resource not found: " + resName);
+                this.internalCreateObject(pi);
+            }
+            else
+                throw new Error("package not found: " + pkgName);
+        };
+        AsyncOperation.prototype.createObjectFromURL = function (url) {
+            var pi = fgui.UIPackage.getItemByURL(url);
+            if (pi)
+                this.internalCreateObject(pi);
+            else
+                throw new Error("resource not found: " + url);
+        };
+        AsyncOperation.prototype.cancel = function () {
+            fgui.GTimers.inst.remove(this.run, this);
+            this._itemList.length = 0;
+            var cnt = this._objectPool.length;
+            if (cnt > 0) {
+                for (var i = 0; i < cnt; i++)
+                    this._objectPool[i].dispose();
+                this._objectPool.length = 0;
+            }
+        };
+        AsyncOperation.prototype.internalCreateObject = function (item) {
+            this._itemList.length = 0;
+            this._objectPool.length = 0;
+            var di = { pi: item, type: item.objectType };
+            di.childCount = this.collectComponentChildren(item);
+            this._itemList.push(di);
+            this._index = 0;
+            fgui.GTimers.inst.add(1, 0, this.run, this);
+        };
+        AsyncOperation.prototype.collectComponentChildren = function (item) {
+            var buffer = item.rawData;
+            buffer.seek(0, 2);
+            var di;
+            var pi;
+            var i;
+            var dataLen;
+            var curPos;
+            var pkg;
+            var dcnt = buffer.readShort();
+            for (i = 0; i < dcnt; i++) {
+                dataLen = buffer.readShort();
+                curPos = buffer.position;
+                buffer.seek(curPos, 0);
+                var type = buffer.readByte();
+                var src = buffer.readS();
+                var pkgId = buffer.readS();
+                buffer.position = curPos;
+                if (src != null) {
+                    if (pkgId != null)
+                        pkg = fgui.UIPackage.getById(pkgId);
+                    else
+                        pkg = item.owner;
+                    pi = pkg != null ? pkg.getItemById(src) : null;
+                    di = { pi: pi, type: type };
+                    if (pi != null && pi.type == fgui.PackageItemType.Component)
+                        di.childCount = this.collectComponentChildren(pi);
+                }
+                else {
+                    di = { type: type };
+                    if (type == fgui.ObjectType.List)
+                        di.listItemCount = this.collectListChildren(buffer);
+                }
+                this._itemList.push(di);
+                buffer.position = curPos + dataLen;
+            }
+            return dcnt;
+        };
+        AsyncOperation.prototype.collectListChildren = function (buffer) {
+            buffer.seek(buffer.position, 8);
+            var listItemCount = 0;
+            var i;
+            var nextPos;
+            var url;
+            var pi;
+            var di;
+            var defaultItem = buffer.readS();
+            var itemCount = buffer.readShort();
+            for (i = 0; i < itemCount; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                url = buffer.readS();
+                if (url == null)
+                    url = defaultItem;
+                if (url) {
+                    pi = fgui.UIPackage.getItemByURL(url);
+                    if (pi) {
+                        di = { pi: pi, type: pi.objectType };
+                        if (pi.type == fgui.PackageItemType.Component)
+                            di.childCount = this.collectComponentChildren(pi);
+                        this._itemList.push(di);
+                        listItemCount++;
+                    }
+                }
+                buffer.position = nextPos;
+            }
+            return listItemCount;
+        };
+        AsyncOperation.prototype.run = function () {
+            var obj;
+            var di;
+            var poolStart;
+            var k;
+            var t = egret.getTimer();
+            var frameTime = fgui.UIConfig.frameTimeForAsyncUIConstruction;
+            var totalItems = this._itemList.length;
+            while (this._index < totalItems) {
+                di = this._itemList[this._index];
+                if (di.pi) {
+                    obj = fgui.UIObjectFactory.newObject(di.pi);
+                    this._objectPool.push(obj);
+                    fgui.UIPackage._constructing++;
+                    if (di.pi.type == fgui.PackageItemType.Component) {
+                        poolStart = this._objectPool.length - di.childCount - 1;
+                        obj.constructFromResource2(this._objectPool, poolStart);
+                        this._objectPool.splice(poolStart, di.childCount);
+                    }
+                    else {
+                        obj.constructFromResource();
+                    }
+                    fgui.UIPackage._constructing--;
+                }
+                else {
+                    obj = fgui.UIObjectFactory.newObject(di.type);
+                    this._objectPool.push(obj);
+                    if (di.type == fgui.ObjectType.List && di.listItemCount > 0) {
+                        poolStart = this._objectPool.length - di.listItemCount - 1;
+                        for (k = 0; k < di.listItemCount; k++)
+                            obj.itemPool.returnObject(this._objectPool[k + poolStart]);
+                        this._objectPool.splice(poolStart, di.listItemCount);
+                    }
+                }
+                this._index++;
+                if ((this._index % 5 == 0) && egret.getTimer() - t >= frameTime)
+                    return;
+            }
+            fgui.GTimers.inst.remove(this.run, this);
+            var result = this._objectPool[0];
+            this._itemList.length = 0;
+            this._objectPool.length = 0;
+            if (this.callback != null)
+                this.callback.call(this.callbackObj, result);
+        };
+        return AsyncOperation;
+    }());
+    fgui.AsyncOperation = AsyncOperation;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var _nextPageId = 0;
+    var Controller = (function (_super_1) {
+        __extends(Controller, _super_1);
+        function Controller() {
+            var _this = _super_1.call(this) || this;
+            _this._pageIds = [];
+            _this._pageNames = [];
+            _this._selectedIndex = -1;
+            _this._previousIndex = -1;
+            return _this;
+        }
+        Controller.prototype.dispose = function () {
+        };
+        Object.defineProperty(Controller.prototype, "selectedIndex", {
+            get: function () {
+                return this._selectedIndex;
+            },
+            set: function (value) {
+                if (this._selectedIndex != value) {
+                    if (value > this._pageIds.length - 1)
+                        throw "index out of bounds: " + value;
+                    this.changing = true;
+                    this._previousIndex = this._selectedIndex;
+                    this._selectedIndex = value;
+                    this.parent.applyController(this);
+                    this.dispatchEvent(new fgui.StateChangeEvent(fgui.StateChangeEvent.CHANGED));
+                    this.changing = false;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Controller.prototype.setSelectedIndex = function (value) {
+            if (this._selectedIndex != value) {
+                if (value > this._pageIds.length - 1)
+                    throw "index out of bounds: " + value;
+                this.changing = true;
+                this._previousIndex = this._selectedIndex;
+                this._selectedIndex = value;
+                this.parent.applyController(this);
+                this.changing = false;
+            }
+        };
+        Object.defineProperty(Controller.prototype, "previsousIndex", {
+            get: function () {
+                return this._previousIndex;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Controller.prototype, "selectedPage", {
+            get: function () {
+                if (this._selectedIndex == -1)
+                    return null;
+                else
+                    return this._pageNames[this._selectedIndex];
+            },
+            set: function (val) {
+                var i = this._pageNames.indexOf(val);
+                if (i == -1)
+                    i = 0;
+                this.selectedIndex = i;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Controller.prototype.setSelectedPage = function (value) {
+            var i = this._pageNames.indexOf(value);
+            if (i == -1)
+                i = 0;
+            this.setSelectedIndex(i);
+        };
+        Object.defineProperty(Controller.prototype, "previousPage", {
+            get: function () {
+                if (this._previousIndex == -1)
+                    return null;
+                else
+                    return this._pageNames[this._previousIndex];
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Controller.prototype, "pageCount", {
+            get: function () {
+                return this._pageIds.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Controller.prototype.getPageName = function (index) {
+            return this._pageNames[index];
+        };
+        Controller.prototype.addPage = function (name) {
+            this.addPageAt(name || "", this._pageIds.length);
+        };
+        Controller.prototype.addPageAt = function (name, index) {
+            var nid = "" + (_nextPageId++);
+            if (index == this._pageIds.length) {
+                this._pageIds.push(nid);
+                this._pageNames.push(name);
+            }
+            else {
+                this._pageIds.splice(index, 0, nid);
+                this._pageNames.splice(index, 0, name);
+            }
+        };
+        Controller.prototype.removePage = function (name) {
+            var i = this._pageNames.indexOf(name);
+            if (i != -1) {
+                this._pageIds.splice(i, 1);
+                this._pageNames.splice(i, 1);
+                if (this._selectedIndex >= this._pageIds.length)
+                    this.selectedIndex = this._selectedIndex - 1;
+                else
+                    this.parent.applyController(this);
+            }
+        };
+        Controller.prototype.removePageAt = function (index) {
+            if (index === void 0) { index = 0; }
+            this._pageIds.splice(index, 1);
+            this._pageNames.splice(index, 1);
+            if (this._selectedIndex >= this._pageIds.length)
+                this.selectedIndex = this._selectedIndex - 1;
+            else
+                this.parent.applyController(this);
+        };
+        Controller.prototype.clearPages = function () {
+            this._pageIds.length = 0;
+            this._pageNames.length = 0;
+            if (this._selectedIndex != -1)
+                this.selectedIndex = -1;
+            else
+                this.parent.applyController(this);
+        };
+        Controller.prototype.hasPage = function (aName) {
+            return this._pageNames.indexOf(aName) != -1;
+        };
+        Controller.prototype.getPageIndexById = function (aId) {
+            return this._pageIds.indexOf(aId);
+        };
+        Controller.prototype.getPageIdByName = function (aName) {
+            var i = this._pageNames.indexOf(aName);
+            if (i != -1)
+                return this._pageIds[i];
+            else
+                return null;
+        };
+        Controller.prototype.getPageNameById = function (aId) {
+            var i = this._pageIds.indexOf(aId);
+            if (i != -1)
+                return this._pageNames[i];
+            else
+                return null;
+        };
+        Controller.prototype.getPageId = function (index) {
+            if (index === void 0) { index = 0; }
+            return this._pageIds[index];
+        };
+        Object.defineProperty(Controller.prototype, "selectedPageId", {
+            get: function () {
+                if (this._selectedIndex == -1)
+                    return null;
+                else
+                    return this._pageIds[this._selectedIndex];
+            },
+            set: function (val) {
+                var i = this._pageIds.indexOf(val);
+                this.selectedIndex = i;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Controller.prototype, "oppositePageId", {
+            set: function (val) {
+                var i = this._pageIds.indexOf(val);
+                if (i > 0)
+                    this.selectedIndex = 0;
+                else if (this._pageIds.length > 1)
+                    this.selectedIndex = 1;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Controller.prototype, "previousPageId", {
+            get: function () {
+                if (this._previousIndex == -1)
+                    return null;
+                else
+                    return this._pageIds[this._previousIndex];
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Controller.prototype.runActions = function () {
+            if (this._actions) {
+                var cnt = this._actions.length;
+                for (var i = 0; i < cnt; i++)
+                    this._actions[i].run(this, this.previousPageId, this.selectedPageId);
+            }
+        };
+        Controller.prototype.setup = function (buffer) {
+            var beginPos = buffer.position;
+            buffer.seek(beginPos, 0);
+            this.name = buffer.readS();
+            if (buffer.readBool())
+                this.autoRadioGroupDepth = true;
+            buffer.seek(beginPos, 1);
+            var i;
+            var nextPos;
+            var cnt = buffer.readShort();
+            for (i = 0; i < cnt; i++) {
+                this._pageIds.push(buffer.readS());
+                this._pageNames.push(buffer.readS());
+            }
+            var homePageIndex = 0;
+            if (buffer.version >= 2) {
+                var homePageType = buffer.readByte();
+                switch (homePageType) {
+                    case 1:
+                        homePageIndex = buffer.readShort();
+                        break;
+                    case 2:
+                        homePageIndex = this._pageNames.indexOf(fgui.UIPackage.branch);
+                        if (homePageIndex == -1)
+                            homePageIndex = 0;
+                        break;
+                    case 3:
+                        homePageIndex = this._pageNames.indexOf(fgui.UIPackage.getVar(buffer.readS()));
+                        if (homePageIndex == -1)
+                            homePageIndex = 0;
+                        break;
+                }
+            }
+            buffer.seek(beginPos, 2);
+            cnt = buffer.readShort();
+            if (cnt > 0) {
+                if (!this._actions)
+                    this._actions = new Array();
+                for (i = 0; i < cnt; i++) {
+                    nextPos = buffer.readShort();
+                    nextPos += buffer.position;
+                    var action = fgui.ControllerAction.createAction(buffer.readByte());
+                    action.setup(buffer);
+                    this._actions.push(action);
+                    buffer.position = nextPos;
+                }
+            }
+            if (this.parent && this._pageIds.length > 0)
+                this._selectedIndex = homePageIndex;
+            else
+                this._selectedIndex = -1;
+        };
+        return Controller;
+    }(egret.EventDispatcher));
+    fgui.Controller = Controller;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var DragDropManager = (function () {
+        function DragDropManager() {
+            this._agent = new fgui.GLoader();
+            this._agent.draggable = true;
+            this._agent.touchable = false;
+            this._agent.setSize(100, 100);
+            this._agent.setPivot(0.5, 0.5, true);
+            this._agent.align = fgui.AlignType.Center;
+            this._agent.verticalAlign = fgui.VertAlignType.Middle;
+            this._agent.sortingOrder = 1000000;
+            this._agent.addEventListener(fgui.DragEvent.DRAG_END, this.__dragEnd, this);
+        }
+        Object.defineProperty(DragDropManager, "inst", {
+            get: function () {
+                if (DragDropManager._inst == null)
+                    DragDropManager._inst = new DragDropManager();
+                return DragDropManager._inst;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(DragDropManager.prototype, "dragAgent", {
+            get: function () {
+                return this._agent;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(DragDropManager.prototype, "dragging", {
+            get: function () {
+                return this._agent.parent != null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        DragDropManager.prototype.startDrag = function (source, icon, sourceData, touchPointID) {
+            if (this._agent.parent)
+                return;
+            this._sourceData = sourceData;
+            this._agent.url = icon;
+            fgui.GRoot.inst.addChild(this._agent);
+            var pt = fgui.GRoot.inst.globalToLocal(fgui.GRoot.mouseX, fgui.GRoot.mouseY);
+            this._agent.setXY(pt.x, pt.y);
+            this._agent.startDrag(touchPointID);
+        };
+        DragDropManager.prototype.cancel = function () {
+            if (this._agent.parent) {
+                this._agent.stopDrag();
+                fgui.GRoot.inst.removeChild(this._agent);
+                this._sourceData = null;
+            }
+        };
+        DragDropManager.prototype.__dragEnd = function (evt) {
+            if (this._agent.parent == null)
+                return;
+            fgui.GRoot.inst.removeChild(this._agent);
+            var sourceData = this._sourceData;
+            this._sourceData = null;
+            var obj = fgui.GRoot.inst.getObjectUnderPoint(evt.stageX, evt.stageY);
+            while (obj) {
+                if (obj.hasEventListener(fgui.DropEvent.DROP)) {
+                    var dropEvt = new fgui.DropEvent(fgui.DropEvent.DROP, sourceData);
+                    obj.requestFocus();
+                    obj.dispatchEvent(dropEvt);
+                    return;
+                }
+                obj = obj.parent;
+            }
+        };
+        return DragDropManager;
+    }());
+    fgui.DragDropManager = DragDropManager;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ButtonMode;
+    (function (ButtonMode) {
+        ButtonMode[ButtonMode["Common"] = 0] = "Common";
+        ButtonMode[ButtonMode["Check"] = 1] = "Check";
+        ButtonMode[ButtonMode["Radio"] = 2] = "Radio";
+    })(ButtonMode = fgui.ButtonMode || (fgui.ButtonMode = {}));
+    var AutoSizeType;
+    (function (AutoSizeType) {
+        AutoSizeType[AutoSizeType["None"] = 0] = "None";
+        AutoSizeType[AutoSizeType["Both"] = 1] = "Both";
+        AutoSizeType[AutoSizeType["Height"] = 2] = "Height";
+    })(AutoSizeType = fgui.AutoSizeType || (fgui.AutoSizeType = {}));
+    var AlignType;
+    (function (AlignType) {
+        AlignType[AlignType["Left"] = 0] = "Left";
+        AlignType[AlignType["Center"] = 1] = "Center";
+        AlignType[AlignType["Right"] = 2] = "Right";
+    })(AlignType = fgui.AlignType || (fgui.AlignType = {}));
+    var VertAlignType;
+    (function (VertAlignType) {
+        VertAlignType[VertAlignType["Top"] = 0] = "Top";
+        VertAlignType[VertAlignType["Middle"] = 1] = "Middle";
+        VertAlignType[VertAlignType["Bottom"] = 2] = "Bottom";
+    })(VertAlignType = fgui.VertAlignType || (fgui.VertAlignType = {}));
+    var LoaderFillType;
+    (function (LoaderFillType) {
+        LoaderFillType[LoaderFillType["None"] = 0] = "None";
+        LoaderFillType[LoaderFillType["Scale"] = 1] = "Scale";
+        LoaderFillType[LoaderFillType["ScaleMatchHeight"] = 2] = "ScaleMatchHeight";
+        LoaderFillType[LoaderFillType["ScaleMatchWidth"] = 3] = "ScaleMatchWidth";
+        LoaderFillType[LoaderFillType["ScaleFree"] = 4] = "ScaleFree";
+        LoaderFillType[LoaderFillType["ScaleNoBorder"] = 5] = "ScaleNoBorder";
+    })(LoaderFillType = fgui.LoaderFillType || (fgui.LoaderFillType = {}));
+    var ListLayoutType;
+    (function (ListLayoutType) {
+        ListLayoutType[ListLayoutType["SingleColumn"] = 0] = "SingleColumn";
+        ListLayoutType[ListLayoutType["SingleRow"] = 1] = "SingleRow";
+        ListLayoutType[ListLayoutType["FlowHorizontal"] = 2] = "FlowHorizontal";
+        ListLayoutType[ListLayoutType["FlowVertical"] = 3] = "FlowVertical";
+        ListLayoutType[ListLayoutType["Pagination"] = 4] = "Pagination";
+    })(ListLayoutType = fgui.ListLayoutType || (fgui.ListLayoutType = {}));
+    var ListSelectionMode;
+    (function (ListSelectionMode) {
+        ListSelectionMode[ListSelectionMode["Single"] = 0] = "Single";
+        ListSelectionMode[ListSelectionMode["Multiple"] = 1] = "Multiple";
+        ListSelectionMode[ListSelectionMode["Multiple_SingleClick"] = 2] = "Multiple_SingleClick";
+        ListSelectionMode[ListSelectionMode["None"] = 3] = "None";
+    })(ListSelectionMode = fgui.ListSelectionMode || (fgui.ListSelectionMode = {}));
+    var OverflowType;
+    (function (OverflowType) {
+        OverflowType[OverflowType["Visible"] = 0] = "Visible";
+        OverflowType[OverflowType["Hidden"] = 1] = "Hidden";
+        OverflowType[OverflowType["Scroll"] = 2] = "Scroll";
+    })(OverflowType = fgui.OverflowType || (fgui.OverflowType = {}));
+    var PackageItemType;
+    (function (PackageItemType) {
+        PackageItemType[PackageItemType["Image"] = 0] = "Image";
+        PackageItemType[PackageItemType["MovieClip"] = 1] = "MovieClip";
+        PackageItemType[PackageItemType["Sound"] = 2] = "Sound";
+        PackageItemType[PackageItemType["Component"] = 3] = "Component";
+        PackageItemType[PackageItemType["Atlas"] = 4] = "Atlas";
+        PackageItemType[PackageItemType["Font"] = 5] = "Font";
+        PackageItemType[PackageItemType["Swf"] = 6] = "Swf";
+        PackageItemType[PackageItemType["Misc"] = 7] = "Misc";
+        PackageItemType[PackageItemType["Unknown"] = 8] = "Unknown";
+        PackageItemType[PackageItemType["Spine"] = 9] = "Spine";
+        PackageItemType[PackageItemType["DragonBones"] = 10] = "DragonBones";
+    })(PackageItemType = fgui.PackageItemType || (fgui.PackageItemType = {}));
+    ;
+    var ObjectType;
+    (function (ObjectType) {
+        ObjectType[ObjectType["Image"] = 0] = "Image";
+        ObjectType[ObjectType["MovieClip"] = 1] = "MovieClip";
+        ObjectType[ObjectType["Swf"] = 2] = "Swf";
+        ObjectType[ObjectType["Graph"] = 3] = "Graph";
+        ObjectType[ObjectType["Loader"] = 4] = "Loader";
+        ObjectType[ObjectType["Group"] = 5] = "Group";
+        ObjectType[ObjectType["Text"] = 6] = "Text";
+        ObjectType[ObjectType["RichText"] = 7] = "RichText";
+        ObjectType[ObjectType["InputText"] = 8] = "InputText";
+        ObjectType[ObjectType["Component"] = 9] = "Component";
+        ObjectType[ObjectType["List"] = 10] = "List";
+        ObjectType[ObjectType["Label"] = 11] = "Label";
+        ObjectType[ObjectType["Button"] = 12] = "Button";
+        ObjectType[ObjectType["ComboBox"] = 13] = "ComboBox";
+        ObjectType[ObjectType["ProgressBar"] = 14] = "ProgressBar";
+        ObjectType[ObjectType["Slider"] = 15] = "Slider";
+        ObjectType[ObjectType["ScrollBar"] = 16] = "ScrollBar";
+        ObjectType[ObjectType["Tree"] = 17] = "Tree";
+        ObjectType[ObjectType["Loader3D"] = 18] = "Loader3D";
+    })(ObjectType = fgui.ObjectType || (fgui.ObjectType = {}));
+    var ProgressTitleType;
+    (function (ProgressTitleType) {
+        ProgressTitleType[ProgressTitleType["Percent"] = 0] = "Percent";
+        ProgressTitleType[ProgressTitleType["ValueAndMax"] = 1] = "ValueAndMax";
+        ProgressTitleType[ProgressTitleType["Value"] = 2] = "Value";
+        ProgressTitleType[ProgressTitleType["Max"] = 3] = "Max";
+    })(ProgressTitleType = fgui.ProgressTitleType || (fgui.ProgressTitleType = {}));
+    var ScrollBarDisplayType;
+    (function (ScrollBarDisplayType) {
+        ScrollBarDisplayType[ScrollBarDisplayType["Default"] = 0] = "Default";
+        ScrollBarDisplayType[ScrollBarDisplayType["Visible"] = 1] = "Visible";
+        ScrollBarDisplayType[ScrollBarDisplayType["Auto"] = 2] = "Auto";
+        ScrollBarDisplayType[ScrollBarDisplayType["Hidden"] = 3] = "Hidden";
+    })(ScrollBarDisplayType = fgui.ScrollBarDisplayType || (fgui.ScrollBarDisplayType = {}));
+    ;
+    var ScrollType;
+    (function (ScrollType) {
+        ScrollType[ScrollType["Horizontal"] = 0] = "Horizontal";
+        ScrollType[ScrollType["Vertical"] = 1] = "Vertical";
+        ScrollType[ScrollType["Both"] = 2] = "Both";
+    })(ScrollType = fgui.ScrollType || (fgui.ScrollType = {}));
+    ;
+    var FlipType;
+    (function (FlipType) {
+        FlipType[FlipType["None"] = 0] = "None";
+        FlipType[FlipType["Horizontal"] = 1] = "Horizontal";
+        FlipType[FlipType["Vertical"] = 2] = "Vertical";
+        FlipType[FlipType["Both"] = 3] = "Both";
+    })(FlipType = fgui.FlipType || (fgui.FlipType = {}));
+    var ChildrenRenderOrder;
+    (function (ChildrenRenderOrder) {
+        ChildrenRenderOrder[ChildrenRenderOrder["Ascent"] = 0] = "Ascent";
+        ChildrenRenderOrder[ChildrenRenderOrder["Descent"] = 1] = "Descent";
+        ChildrenRenderOrder[ChildrenRenderOrder["Arch"] = 2] = "Arch";
+    })(ChildrenRenderOrder = fgui.ChildrenRenderOrder || (fgui.ChildrenRenderOrder = {}));
+    var GroupLayoutType;
+    (function (GroupLayoutType) {
+        GroupLayoutType[GroupLayoutType["None"] = 0] = "None";
+        GroupLayoutType[GroupLayoutType["Horizontal"] = 1] = "Horizontal";
+        GroupLayoutType[GroupLayoutType["Vertical"] = 2] = "Vertical";
+    })(GroupLayoutType = fgui.GroupLayoutType || (fgui.GroupLayoutType = {}));
+    var PopupDirection;
+    (function (PopupDirection) {
+        PopupDirection[PopupDirection["Auto"] = 0] = "Auto";
+        PopupDirection[PopupDirection["Up"] = 1] = "Up";
+        PopupDirection[PopupDirection["Down"] = 2] = "Down";
+    })(PopupDirection = fgui.PopupDirection || (fgui.PopupDirection = {}));
+    var RelationType;
+    (function (RelationType) {
+        RelationType[RelationType["Left_Left"] = 0] = "Left_Left";
+        RelationType[RelationType["Left_Center"] = 1] = "Left_Center";
+        RelationType[RelationType["Left_Right"] = 2] = "Left_Right";
+        RelationType[RelationType["Center_Center"] = 3] = "Center_Center";
+        RelationType[RelationType["Right_Left"] = 4] = "Right_Left";
+        RelationType[RelationType["Right_Center"] = 5] = "Right_Center";
+        RelationType[RelationType["Right_Right"] = 6] = "Right_Right";
+        RelationType[RelationType["Top_Top"] = 7] = "Top_Top";
+        RelationType[RelationType["Top_Middle"] = 8] = "Top_Middle";
+        RelationType[RelationType["Top_Bottom"] = 9] = "Top_Bottom";
+        RelationType[RelationType["Middle_Middle"] = 10] = "Middle_Middle";
+        RelationType[RelationType["Bottom_Top"] = 11] = "Bottom_Top";
+        RelationType[RelationType["Bottom_Middle"] = 12] = "Bottom_Middle";
+        RelationType[RelationType["Bottom_Bottom"] = 13] = "Bottom_Bottom";
+        RelationType[RelationType["Width"] = 14] = "Width";
+        RelationType[RelationType["Height"] = 15] = "Height";
+        RelationType[RelationType["LeftExt_Left"] = 16] = "LeftExt_Left";
+        RelationType[RelationType["LeftExt_Right"] = 17] = "LeftExt_Right";
+        RelationType[RelationType["RightExt_Left"] = 18] = "RightExt_Left";
+        RelationType[RelationType["RightExt_Right"] = 19] = "RightExt_Right";
+        RelationType[RelationType["TopExt_Top"] = 20] = "TopExt_Top";
+        RelationType[RelationType["TopExt_Bottom"] = 21] = "TopExt_Bottom";
+        RelationType[RelationType["BottomExt_Top"] = 22] = "BottomExt_Top";
+        RelationType[RelationType["BottomExt_Bottom"] = 23] = "BottomExt_Bottom";
+        RelationType[RelationType["Size"] = 24] = "Size";
+    })(RelationType = fgui.RelationType || (fgui.RelationType = {}));
+    var FillMethod;
+    (function (FillMethod) {
+        FillMethod[FillMethod["None"] = 0] = "None";
+        FillMethod[FillMethod["Horizontal"] = 1] = "Horizontal";
+        FillMethod[FillMethod["Vertical"] = 2] = "Vertical";
+        FillMethod[FillMethod["Radial90"] = 3] = "Radial90";
+        FillMethod[FillMethod["Radial180"] = 4] = "Radial180";
+        FillMethod[FillMethod["Radial360"] = 5] = "Radial360";
+    })(FillMethod = fgui.FillMethod || (fgui.FillMethod = {}));
+    var FillOrigin;
+    (function (FillOrigin) {
+        FillOrigin[FillOrigin["Top"] = 0] = "Top";
+        FillOrigin[FillOrigin["Bottom"] = 1] = "Bottom";
+        FillOrigin[FillOrigin["Left"] = 2] = "Left";
+        FillOrigin[FillOrigin["Right"] = 3] = "Right";
+        FillOrigin[FillOrigin["TopLeft"] = 0] = "TopLeft";
+        FillOrigin[FillOrigin["TopRight"] = 1] = "TopRight";
+        FillOrigin[FillOrigin["BottomLeft"] = 2] = "BottomLeft";
+        FillOrigin[FillOrigin["BottomRight"] = 3] = "BottomRight";
+    })(FillOrigin = fgui.FillOrigin || (fgui.FillOrigin = {}));
+    var FillOrigin90;
+    (function (FillOrigin90) {
+        FillOrigin90[FillOrigin90["TopLeft"] = 0] = "TopLeft";
+        FillOrigin90[FillOrigin90["TopRight"] = 1] = "TopRight";
+        FillOrigin90[FillOrigin90["BottomLeft"] = 2] = "BottomLeft";
+        FillOrigin90[FillOrigin90["BottomRight"] = 3] = "BottomRight";
+    })(FillOrigin90 = fgui.FillOrigin90 || (fgui.FillOrigin90 = {}));
+    var ObjectPropID;
+    (function (ObjectPropID) {
+        ObjectPropID[ObjectPropID["Text"] = 0] = "Text";
+        ObjectPropID[ObjectPropID["Icon"] = 1] = "Icon";
+        ObjectPropID[ObjectPropID["Color"] = 2] = "Color";
+        ObjectPropID[ObjectPropID["OutlineColor"] = 3] = "OutlineColor";
+        ObjectPropID[ObjectPropID["Playing"] = 4] = "Playing";
+        ObjectPropID[ObjectPropID["Frame"] = 5] = "Frame";
+        ObjectPropID[ObjectPropID["DeltaTime"] = 6] = "DeltaTime";
+        ObjectPropID[ObjectPropID["TimeScale"] = 7] = "TimeScale";
+        ObjectPropID[ObjectPropID["FontSize"] = 8] = "FontSize";
+        ObjectPropID[ObjectPropID["Selected"] = 9] = "Selected";
+    })(ObjectPropID = fgui.ObjectPropID || (fgui.ObjectPropID = {}));
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GObject = (function (_super_1) {
+        __extends(GObject, _super_1);
+        function GObject() {
+            var _this = _super_1.call(this) || this;
+            _this._x = 0;
+            _this._y = 0;
+            _this._alpha = 1;
+            _this._rotation = 0;
+            _this._visible = true;
+            _this._touchable = true;
+            _this._scaleX = 1;
+            _this._scaleY = 1;
+            _this._skewX = 0;
+            _this._skewY = 0;
+            _this._pivotX = 0;
+            _this._pivotY = 0;
+            _this._pivotOffsetX = 0;
+            _this._pivotOffsetY = 0;
+            _this._sortingOrder = 0;
+            _this._internalVisible = true;
+            _this._disposed = false;
+            _this.sourceWidth = 0;
+            _this.sourceHeight = 0;
+            _this.initWidth = 0;
+            _this.initHeight = 0;
+            _this.minWidth = 0;
+            _this.minHeight = 0;
+            _this.maxWidth = 0;
+            _this.maxHeight = 0;
+            _this._width = 0;
+            _this._height = 0;
+            _this._rawWidth = 0;
+            _this._rawHeight = 0;
+            _this._sizePercentInGroup = 0;
+            _this._id = "" + _gInstanceCounter++;
+            _this._name = "";
+            _this.createDisplayObject();
+            _this._relations = new fgui.Relations(_this);
+            _this._gears = new Array(10);
+            return _this;
+        }
+        Object.defineProperty(GObject.prototype, "id", {
+            get: function () {
+                return this._id;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "name", {
+            get: function () {
+                return this._name;
+            },
+            set: function (value) {
+                this._name = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "x", {
+            get: function () {
+                return this._x;
+            },
+            set: function (value) {
+                this.setXY(value, this._y);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "y", {
+            get: function () {
+                return this._y;
+            },
+            set: function (value) {
+                this.setXY(this._x, value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.setXY = function (xv, yv) {
+            if (this._x != xv || this._y != yv) {
+                var dx = xv - this._x;
+                var dy = yv - this._y;
+                this._x = xv;
+                this._y = yv;
+                this.handleXYChanged();
+                if (this instanceof fgui.GGroup)
+                    this.moveChildren(dx, dy);
+                this.updateGear(1);
+                if (this._parent && !(this._parent instanceof fgui.GList)) {
+                    this._parent.setBoundsChangedFlag();
+                    if (this._group)
+                        this._group.setBoundsChangedFlag(true);
+                    this.dispatchEventWith(GObject.XY_CHANGED);
+                }
+                if (GObject.draggingObject == this && !sUpdateInDragging)
+                    this.localToGlobalRect(0, 0, this._width, this._height, sGlobalRect);
+            }
+        };
+        Object.defineProperty(GObject.prototype, "xMin", {
+            get: function () {
+                return this._pivotAsAnchor ? (this._x - this._width * this._pivotX) : this._x;
+            },
+            set: function (value) {
+                if (this._pivotAsAnchor)
+                    this.setXY(value + this._width * this._pivotX, this._y);
+                else
+                    this.setXY(value, this._y);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "yMin", {
+            get: function () {
+                return this._pivotAsAnchor ? (this._y - this._height * this._pivotY) : this._y;
+            },
+            set: function (value) {
+                if (this._pivotAsAnchor)
+                    this.setXY(this._x, value + this._height * this._pivotY);
+                else
+                    this.setXY(this._x, value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "pixelSnapping", {
+            get: function () {
+                return this._pixelSnapping;
+            },
+            set: function (value) {
+                if (this._pixelSnapping != value) {
+                    this._pixelSnapping = value;
+                    this.handleXYChanged();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.center = function (restraint) {
+            var r;
+            if (this._parent)
+                r = this.parent;
+            else
+                r = this.root;
+            this.setXY((r.width - this._width) / 2, (r.height - this._height) / 2);
+            if (restraint) {
+                this.addRelation(r, fgui.RelationType.Center_Center);
+                this.addRelation(r, fgui.RelationType.Middle_Middle);
+            }
+        };
+        Object.defineProperty(GObject.prototype, "width", {
+            get: function () {
+                this.ensureSizeCorrect();
+                if (this._relations.sizeDirty)
+                    this._relations.ensureRelationsSizeCorrect();
+                return this._width;
+            },
+            set: function (value) {
+                this.setSize(value, this._rawHeight);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "height", {
+            get: function () {
+                this.ensureSizeCorrect();
+                if (this._relations.sizeDirty)
+                    this._relations.ensureRelationsSizeCorrect();
+                return this._height;
+            },
+            set: function (value) {
+                this.setSize(this._rawWidth, value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.setSize = function (wv, hv, ignorePivot) {
+            if (this._rawWidth != wv || this._rawHeight != hv) {
+                this._rawWidth = wv;
+                this._rawHeight = hv;
+                if (wv < this.minWidth)
+                    wv = this.minWidth;
+                if (hv < this.minHeight)
+                    hv = this.minHeight;
+                if (this.maxWidth > 0 && wv > this.maxWidth)
+                    wv = this.maxWidth;
+                if (this.maxHeight > 0 && hv > this.maxHeight)
+                    hv = this.maxHeight;
+                var dWidth = wv - this._width;
+                var dHeight = hv - this._height;
+                this._width = wv;
+                this._height = hv;
+                this.handleSizeChanged();
+                if (this._pivotX != 0 || this._pivotY != 0) {
+                    if (!this._pivotAsAnchor) {
+                        if (!ignorePivot)
+                            this.setXY(this.x - this._pivotX * dWidth, this.y - this._pivotY * dHeight);
+                        this.updatePivotOffset();
+                    }
+                    else {
+                        this.applyPivot();
+                    }
+                }
+                if (this instanceof fgui.GGroup)
+                    this.resizeChildren(dWidth, dHeight);
+                this.updateGear(2);
+                if (this._parent) {
+                    this._relations.onOwnerSizeChanged(dWidth, dHeight, this._pivotAsAnchor || !ignorePivot);
+                    this._parent.setBoundsChangedFlag();
+                    if (this._group)
+                        this._group.setBoundsChangedFlag();
+                }
+                this.dispatchEventWith(GObject.SIZE_CHANGED);
+            }
+        };
+        GObject.prototype.makeFullScreen = function () {
+            this.setSize(fgui.GRoot.inst.width, fgui.GRoot.inst.height);
+        };
+        GObject.prototype.ensureSizeCorrect = function () {
+        };
+        Object.defineProperty(GObject.prototype, "actualWidth", {
+            get: function () {
+                return this.width * Math.abs(this._scaleX);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "actualHeight", {
+            get: function () {
+                return this.height * Math.abs(this._scaleY);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "scaleX", {
+            get: function () {
+                return this._scaleX;
+            },
+            set: function (value) {
+                this.setScale(value, this._scaleY);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "scaleY", {
+            get: function () {
+                return this._scaleY;
+            },
+            set: function (value) {
+                this.setScale(this._scaleX, value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.setScale = function (sx, sy) {
+            if (this._scaleX != sx || this._scaleY != sy) {
+                this._scaleX = sx;
+                this._scaleY = sy;
+                this.handleScaleChanged();
+                this.applyPivot();
+                this.updateGear(2);
+            }
+        };
+        Object.defineProperty(GObject.prototype, "skewX", {
+            get: function () {
+                return this._skewX;
+            },
+            set: function (value) {
+                this.setSkew(value, this._skewY);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "skewY", {
+            get: function () {
+                return this._skewY;
+            },
+            set: function (value) {
+                this.setSkew(this._skewX, value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.setSkew = function (xv, yv) {
+            if (this._skewX != xv || this._skewY != yv) {
+                this._skewX = xv;
+                this._skewY = yv;
+                if (this._displayObject) {
+                    this._displayObject.skewX = xv;
+                    this._displayObject.skewY = yv;
+                }
+                this.applyPivot();
+            }
+        };
+        Object.defineProperty(GObject.prototype, "pivotX", {
+            get: function () {
+                return this._pivotX;
+            },
+            set: function (value) {
+                this.setPivot(value, this._pivotY);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "pivotY", {
+            get: function () {
+                return this._pivotY;
+            },
+            set: function (value) {
+                this.setPivot(this._pivotX, value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.setPivot = function (xv, yv, asAnchor) {
+            if (this._pivotX != xv || this._pivotY != yv || this._pivotAsAnchor != asAnchor) {
+                this._pivotX = xv;
+                this._pivotY = yv;
+                this._pivotAsAnchor = asAnchor;
+                this.updatePivotOffset();
+                this.handleXYChanged();
+            }
+        };
+        Object.defineProperty(GObject.prototype, "pivotAsAnchor", {
+            get: function () {
+                return this._pivotAsAnchor;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.internalSetPivot = function (xv, yv, asAnchor) {
+            this._pivotX = xv;
+            this._pivotY = yv;
+            this._pivotAsAnchor = asAnchor;
+            if (asAnchor)
+                this.handleXYChanged();
+        };
+        GObject.prototype.updatePivotOffset = function () {
+            if (this._displayObject) {
+                if (this._pivotX != 0 || this._pivotY != 0) {
+                    var px = this._pivotX * this._width;
+                    var py = this._pivotY * this._height;
+                    var pt = this._displayObject.matrix.transformPoint(px, py, sHelperPoint);
+                    this._pivotOffsetX = this._pivotX * this._width - (pt.x - this._displayObject.x);
+                    this._pivotOffsetY = this._pivotY * this._height - (pt.y - this._displayObject.y);
+                }
+                else {
+                    this._pivotOffsetX = 0;
+                    this._pivotOffsetY = 0;
+                }
+            }
+        };
+        GObject.prototype.applyPivot = function () {
+            if (this._pivotX != 0 || this._pivotY != 0) {
+                this.updatePivotOffset();
+                this.handleXYChanged();
+            }
+        };
+        Object.defineProperty(GObject.prototype, "touchable", {
+            get: function () {
+                return this._touchable;
+            },
+            set: function (value) {
+                if (this._touchable != value) {
+                    this._touchable = value;
+                    this.updateGear(3);
+                    if ((this instanceof fgui.GImage) || (this instanceof fgui.GMovieClip)
+                        || (this instanceof fgui.GTextField) && !(this instanceof fgui.GTextInput) && !(this instanceof fgui.GRichTextField))
+                        return;
+                    if (this._displayObject) {
+                        this._displayObject.touchEnabled = this._touchable;
+                        if (this._displayObject instanceof egret.DisplayObjectContainer)
+                            this._displayObject.touchChildren = this._touchable;
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "grayed", {
+            get: function () {
+                return this._grayed;
+            },
+            set: function (value) {
+                if (this._grayed != value) {
+                    this._grayed = value;
+                    this.handleGrayedChanged();
+                    this.updateGear(3);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "enabled", {
+            get: function () {
+                return !this._grayed && this._touchable;
+            },
+            set: function (value) {
+                this.grayed = !value;
+                this.touchable = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "rotation", {
+            get: function () {
+                return this._rotation;
+            },
+            set: function (value) {
+                if (this._rotation != value) {
+                    this._rotation = value;
+                    if (this._displayObject)
+                        this._displayObject.rotation = this.normalizeRotation;
+                    this.applyPivot();
+                    this.updateGear(3);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "normalizeRotation", {
+            get: function () {
+                var rot = this._rotation % 360;
+                if (rot > 180)
+                    rot -= 360;
+                else if (rot < -180)
+                    rot += 360;
+                return rot;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "alpha", {
+            get: function () {
+                return this._alpha;
+            },
+            set: function (value) {
+                if (this._alpha != value) {
+                    this._alpha = value;
+                    this.handleAlphaChanged();
+                    this.updateGear(3);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "visible", {
+            get: function () {
+                return this._visible;
+            },
+            set: function (value) {
+                if (this._visible != value) {
+                    this._visible = value;
+                    this.handleVisibleChanged();
+                    if (this._parent)
+                        this._parent.setBoundsChangedFlag();
+                    if (this._group && this._group.excludeInvisibles)
+                        this._group.setBoundsChangedFlag();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "internalVisible", {
+            get: function () {
+                return this._internalVisible && (!this._group || this._group.internalVisible);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "internalVisible2", {
+            get: function () {
+                return this._visible && (!this._group || this._group.internalVisible2);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "internalVisible3", {
+            get: function () {
+                return this._visible && this._internalVisible;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "sortingOrder", {
+            get: function () {
+                return this._sortingOrder;
+            },
+            set: function (value) {
+                if (value < 0)
+                    value = 0;
+                if (this._sortingOrder != value) {
+                    var old = this._sortingOrder;
+                    this._sortingOrder = value;
+                    if (this._parent)
+                        this._parent.childSortingOrderChanged(this, old, this._sortingOrder);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "focused", {
+            get: function () {
+                return this.root.focus == this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.requestFocus = function () {
+            this.root.focus = this;
+        };
+        Object.defineProperty(GObject.prototype, "tooltips", {
+            get: function () {
+                return this._tooltips;
+            },
+            set: function (value) {
+                this._tooltips = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "blendMode", {
+            get: function () {
+                return this._displayObject.blendMode;
+            },
+            set: function (value) {
+                this._displayObject.blendMode = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "filters", {
+            get: function () {
+                return this._displayObject.filters;
+            },
+            set: function (value) {
+                this._displayObject.filters = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "inContainer", {
+            get: function () {
+                return this._displayObject != null && this._displayObject.parent != null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "onStage", {
+            get: function () {
+                return this._displayObject != null && this._displayObject.stage != null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "resourceURL", {
+            get: function () {
+                if (this.packageItem)
+                    return "ui://" + this.packageItem.owner.id + this.packageItem.id;
+                else
+                    return null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "group", {
+            get: function () {
+                return this._group;
+            },
+            set: function (value) {
+                if (this._group != value) {
+                    if (this._group)
+                        this._group.setBoundsChangedFlag();
+                    this._group = value;
+                    if (this._group)
+                        this._group.setBoundsChangedFlag();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.getGear = function (index) {
+            var gear = this._gears[index];
+            if (gear == null)
+                this._gears[index] = gear = fgui.GearBase.create(this, index);
+            return gear;
+        };
+        GObject.prototype.updateGear = function (index) {
+            if (this._underConstruct || this._gearLocked)
+                return;
+            var gear = this._gears[index];
+            if (gear && gear.controller)
+                gear.updateState();
+        };
+        GObject.prototype.checkGearController = function (index, c) {
+            return this._gears[index] != null && this._gears[index].controller == c;
+        };
+        GObject.prototype.updateGearFromRelations = function (index, dx, dy) {
+            if (this._gears[index])
+                this._gears[index].updateFromRelations(dx, dy);
+        };
+        GObject.prototype.addDisplayLock = function () {
+            var gearDisplay = this._gears[0];
+            if (gearDisplay && gearDisplay.controller) {
+                var ret = gearDisplay.addLock();
+                this.checkGearDisplay();
+                return ret;
+            }
+            else
+                return 0;
+        };
+        GObject.prototype.releaseDisplayLock = function (token) {
+            var gearDisplay = this._gears[0];
+            if (gearDisplay && gearDisplay.controller) {
+                gearDisplay.releaseLock(token);
+                this.checkGearDisplay();
+            }
+        };
+        GObject.prototype.checkGearDisplay = function () {
+            if (this._handlingController)
+                return;
+            var connected = this._gears[0] == null || this._gears[0].connected;
+            if (this._gears[8])
+                connected = this._gears[8].evaluate(connected);
+            if (connected != this._internalVisible) {
+                this._internalVisible = connected;
+                if (this._parent)
+                    this._parent.childStateChanged(this);
+                if (this._group && this._group.excludeInvisibles)
+                    this._group.setBoundsChangedFlag();
+            }
+        };
+        Object.defineProperty(GObject.prototype, "gearXY", {
+            get: function () {
+                return this.getGear(1);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "gearSize", {
+            get: function () {
+                return this.getGear(2);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "gearLook", {
+            get: function () {
+                return this.getGear(3);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "relations", {
+            get: function () {
+                return this._relations;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.addRelation = function (target, relationType, usePercent) {
+            this._relations.add(target, relationType, usePercent);
+        };
+        GObject.prototype.removeRelation = function (target, relationType) {
+            this._relations.remove(target, relationType || 0);
+        };
+        Object.defineProperty(GObject.prototype, "displayObject", {
+            get: function () {
+                return this._displayObject;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.setDisplayObject = function (value) {
+            if (this._displayObject != value) {
+                if (this._displayObject)
+                    delete this._displayObject["$owner"];
+                this._displayObject = value;
+                this._displayObject["$owner"] = this;
+            }
+        };
+        Object.defineProperty(GObject.prototype, "parent", {
+            get: function () {
+                return this._parent;
+            },
+            set: function (val) {
+                this._parent = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.removeFromParent = function () {
+            if (this._parent)
+                this._parent.removeChild(this);
+        };
+        Object.defineProperty(GObject.prototype, "root", {
+            get: function () {
+                if (this instanceof fgui.GRoot)
+                    return this;
+                var p = this._parent;
+                while (p) {
+                    if (p instanceof fgui.GRoot)
+                        return p;
+                    p = p.parent;
+                }
+                return fgui.GRoot.inst;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asCom", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asButton", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asLabel", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asProgress", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asTextField", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asRichTextField", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asTextInput", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asLoader", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asList", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asTree", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asGraph", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asGroup", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asSlider", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asComboBox", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asImage", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "asMovieClip", {
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.cast = function (obj) {
+            return obj["$owner"];
+        };
+        Object.defineProperty(GObject.prototype, "text", {
+            get: function () {
+                return null;
+            },
+            set: function (value) {
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "icon", {
+            get: function () {
+                return null;
+            },
+            set: function (value) {
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "isDisposed", {
+            get: function () {
+                return this._disposed;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "treeNode", {
+            get: function () {
+                return this._treeNode;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.dispose = function () {
+            if (this._disposed)
+                return;
+            this._disposed = true;
+            this.removeFromParent();
+            this._relations.dispose();
+            this._displayObject = null;
+            for (var i = 0; i < 10; i++) {
+                var gear = this._gears[i];
+                if (gear)
+                    gear.dispose();
+            }
+        };
+        GObject.prototype.addClickListener = function (listener, thisObj) {
+            this.addEventListener(egret.TouchEvent.TOUCH_TAP, listener, thisObj);
+        };
+        GObject.prototype.removeClickListener = function (listener, thisObj) {
+            this.removeEventListener(egret.TouchEvent.TOUCH_TAP, listener, thisObj);
+        };
+        GObject.prototype.hasClickListener = function () {
+            return this.hasEventListener(egret.TouchEvent.TOUCH_TAP);
+        };
+        GObject.prototype.addEventListener = function (type, listener, thisObject) {
+            _super_1.prototype.addEventListener.call(this, type, listener, thisObject);
+            if (this._displayObject) {
+                this._displayObject.addEventListener(type, this._reDispatch, this);
+            }
+        };
+        GObject.prototype.removeEventListener = function (type, listener, thisObject) {
+            _super_1.prototype.removeEventListener.call(this, type, listener, thisObject);
+            if (this._displayObject && !this.hasEventListener(type)) {
+                this._displayObject.removeEventListener(type, this._reDispatch, this);
+            }
+        };
+        GObject.prototype._reDispatch = function (evt) {
+            this.dispatchEvent(evt);
+        };
+        Object.defineProperty(GObject.prototype, "draggable", {
+            get: function () {
+                return this._draggable;
+            },
+            set: function (value) {
+                if (this._draggable != value) {
+                    this._draggable = value;
+                    this.initDrag();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GObject.prototype, "dragBounds", {
+            get: function () {
+                return this._dragBounds;
+            },
+            set: function (value) {
+                this._dragBounds = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.startDrag = function (touchPointID, stageX, stageY) {
+            if (this._displayObject.stage == null)
+                return;
+            this.dragBegin(touchPointID, stageX, stageY);
+        };
+        GObject.prototype.stopDrag = function () {
+            this.dragEnd();
+        };
+        Object.defineProperty(GObject.prototype, "dragging", {
+            get: function () {
+                return GObject.draggingObject == this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObject.prototype.localToGlobal = function (ax, ay, result) {
+            ax = ax || 0;
+            ay = ay || 0;
+            if (this._pivotAsAnchor) {
+                ax += this._pivotX * this._width;
+                ay += this._pivotY * this._height;
+            }
+            return this._displayObject.localToGlobal(ax, ay, result);
+        };
+        GObject.prototype.globalToLocal = function (ax, ay, result) {
+            ax = ax || 0;
+            ay = ay || 0;
+            var pt = this._displayObject.globalToLocal(ax, ay, result);
+            if (this._pivotAsAnchor) {
+                pt.x -= this._pivotX * this._width;
+                pt.y -= this._pivotY * this._height;
+            }
+            return pt;
+        };
+        GObject.prototype.localToRoot = function (ax, ay, result) {
+            ax = ax || 0;
+            ay = ay || 0;
+            var pt = this._displayObject.localToGlobal(ax, ay, result);
+            pt.x /= fgui.GRoot.contentScaleFactor;
+            pt.y /= fgui.GRoot.contentScaleFactor;
+            return pt;
+        };
+        GObject.prototype.rootToLocal = function (ax, ay, resultPoint) {
+            ax = ax || 0;
+            ay = ay || 0;
+            ax *= fgui.GRoot.contentScaleFactor;
+            ay *= fgui.GRoot.contentScaleFactor;
+            return this._displayObject.globalToLocal(ax, ay, resultPoint);
+        };
+        GObject.prototype.localToGlobalRect = function (ax, ay, aw, ah, result) {
+            ax = ax || 0;
+            ay = ay || 0;
+            aw = aw || 0;
+            ah = ah || 0;
+            result = result || new egret.Rectangle();
+            var pt = this.localToGlobal(ax, ay);
+            result.x = pt.x;
+            result.y = pt.y;
+            pt = this.localToGlobal(ax + aw, ay + ah);
+            result.right = pt.x;
+            result.bottom = pt.y;
+            return result;
+        };
+        GObject.prototype.globalToLocalRect = function (ax, ay, aw, ah, result) {
+            ax = ax || 0;
+            ay = ay || 0;
+            aw = aw || 0;
+            ah = ah || 0;
+            result = result || new egret.Rectangle();
+            var pt = this.globalToLocal(ax, ay);
+            result.x = pt.x;
+            result.y = pt.y;
+            pt = this.globalToLocal(ax + aw, ay + ah);
+            result.right = pt.x;
+            result.bottom = pt.y;
+            return result;
+        };
+        GObject.prototype.handleControllerChanged = function (c) {
+            this._handlingController = true;
+            for (var i = 0; i < 10; i++) {
+                var gear = this._gears[i];
+                if (gear && gear.controller == c)
+                    gear.apply();
+            }
+            this._handlingController = false;
+            this.checkGearDisplay();
+        };
+        GObject.prototype.createDisplayObject = function () {
+        };
+        GObject.prototype.switchDisplayObject = function (newObj) {
+            if (newObj == this._displayObject)
+                return;
+            var old = this._displayObject;
+            if (this._displayObject && this._displayObject.parent) {
+                var i = this._displayObject.parent.getChildIndex(this._displayObject);
+                this._displayObject.parent.addChildAt(newObj, i);
+                this._displayObject.parent.removeChild(this._displayObject);
+            }
+            this._displayObject = newObj;
+            this._displayObject.x = old.x;
+            this._displayObject.y = old.y;
+            this._displayObject.rotation = old.rotation;
+            this._displayObject.alpha = old.alpha;
+            this._displayObject.visible = old.visible;
+            this._displayObject.touchEnabled = old.touchEnabled;
+            this._displayObject.scaleX = old.scaleX;
+            this._displayObject.scaleY = old.scaleY;
+            fgui.ToolSet.setColorFilter(this._displayObject, this._grayed);
+            if (this._displayObject instanceof egret.DisplayObjectContainer)
+                this._displayObject.touchChildren = this._touchable;
+        };
+        GObject.prototype.handleXYChanged = function () {
+            if (this._displayObject) {
+                var xv = this._x;
+                var yv = this._y;
+                if (this._pivotAsAnchor) {
+                    xv -= this._pivotX * this._width;
+                    yv -= this._pivotY * this._height;
+                }
+                if (this._pixelSnapping) {
+                    xv = Math.round(xv);
+                    yv = Math.round(yv);
+                }
+                this._displayObject.x = xv + this._pivotOffsetX;
+                this._displayObject.y = yv + this._pivotOffsetY;
+            }
+        };
+        GObject.prototype.handleSizeChanged = function () {
+            if (this._displayObject) {
+                this._displayObject.width = this._width;
+                this._displayObject.height = this._height;
+            }
+        };
+        GObject.prototype.handleScaleChanged = function () {
+            if (this._displayObject) {
+                this._displayObject.scaleX = this._scaleX;
+                this._displayObject.scaleY = this._scaleY;
+            }
+        };
+        GObject.prototype.handleGrayedChanged = function () {
+            if (this._displayObject) {
+                fgui.ToolSet.setColorFilter(this._displayObject, this._grayed);
+            }
+        };
+        GObject.prototype.handleAlphaChanged = function () {
+            if (this._displayObject)
+                this._displayObject.alpha = this._alpha;
+        };
+        GObject.prototype.handleVisibleChanged = function () {
+            if (this._displayObject)
+                this._displayObject.visible = this.internalVisible2;
+            if (this instanceof fgui.GGroup)
+                this.handleVisibleChanged();
+        };
+        GObject.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Text:
+                    return this.text;
+                case fgui.ObjectPropID.Icon:
+                    return this.icon;
+                case fgui.ObjectPropID.Color:
+                    return NaN;
+                case fgui.ObjectPropID.OutlineColor:
+                    return NaN;
+                case fgui.ObjectPropID.Playing:
+                    return false;
+                case fgui.ObjectPropID.Frame:
+                    return 0;
+                case fgui.ObjectPropID.DeltaTime:
+                    return 0;
+                case fgui.ObjectPropID.TimeScale:
+                    return 1;
+                case fgui.ObjectPropID.FontSize:
+                    return 0;
+                case fgui.ObjectPropID.Selected:
+                    return false;
+                default:
+                    return undefined;
+            }
+        };
+        GObject.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Text:
+                    this.text = value;
+                    break;
+                case fgui.ObjectPropID.Icon:
+                    this.icon = value;
+                    break;
+            }
+        };
+        GObject.prototype.constructFromResource = function () {
+        };
+        GObject.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            buffer.seek(beginPos, 0);
+            buffer.skip(5);
+            var f1;
+            var f2;
+            this._id = buffer.readS();
+            this._name = buffer.readS();
+            f1 = buffer.readInt();
+            f2 = buffer.readInt();
+            this.setXY(f1, f2);
+            if (buffer.readBool()) {
+                this.initWidth = buffer.readInt();
+                this.initHeight = buffer.readInt();
+                this.setSize(this.initWidth, this.initHeight, true);
+            }
+            if (buffer.readBool()) {
+                this.minWidth = buffer.readInt();
+                this.maxWidth = buffer.readInt();
+                this.minHeight = buffer.readInt();
+                this.maxHeight = buffer.readInt();
+            }
+            if (buffer.readBool()) {
+                f1 = buffer.readFloat();
+                f2 = buffer.readFloat();
+                this.setScale(f1, f2);
+            }
+            if (buffer.readBool()) {
+                f1 = buffer.readFloat();
+                f2 = buffer.readFloat();
+                this.setSkew(f1, f2);
+            }
+            if (buffer.readBool()) {
+                f1 = buffer.readFloat();
+                f2 = buffer.readFloat();
+                this.setPivot(f1, f2, buffer.readBool());
+            }
+            f1 = buffer.readFloat();
+            if (f1 != 1)
+                this.alpha = f1;
+            f1 = buffer.readFloat();
+            if (f1 != 0)
+                this.rotation = f1;
+            if (!buffer.readBool())
+                this.visible = false;
+            if (!buffer.readBool())
+                this.touchable = false;
+            if (buffer.readBool())
+                this.grayed = true;
+            var bm = buffer.readByte();
+            if (bm == 2)
+                this.blendMode = egret.BlendMode.ADD;
+            else if (bm == 5)
+                this.blendMode = egret.BlendMode.ERASE;
+            var filter = buffer.readByte();
+            if (filter == 1 && this._displayObject)
+                fgui.ToolSet.setColorFilter(this._displayObject, [buffer.readFloat(), buffer.readFloat(), buffer.readFloat(), buffer.readFloat()]);
+            var str = buffer.readS();
+            if (str != null)
+                this.data = str;
+        };
+        GObject.prototype.setup_afterAdd = function (buffer, beginPos) {
+            buffer.seek(beginPos, 1);
+            var str = buffer.readS();
+            if (str != null)
+                this.tooltips = str;
+            var groupId = buffer.readShort();
+            if (groupId >= 0)
+                this.group = this.parent.getChildAt(groupId);
+            buffer.seek(beginPos, 2);
+            var cnt = buffer.readShort();
+            for (var i = 0; i < cnt; i++) {
+                var nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                var gear = this.getGear(buffer.readByte());
+                gear.setup(buffer);
+                buffer.position = nextPos;
+            }
+        };
+        GObject.prototype.initDrag = function () {
+            if (this._draggable)
+                this.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__begin, this);
+            else
+                this.removeEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__begin, this);
+        };
+        GObject.prototype.dragBegin = function (touchPointID, stageX, stageY) {
+            if (GObject.draggingObject) {
+                var tmp = GObject.draggingObject;
+                tmp.stopDrag();
+                GObject.draggingObject = null;
+                var dragEvent = new fgui.DragEvent(fgui.DragEvent.DRAG_END);
+                dragEvent.stageX = stageX || fgui.GRoot.mouseX;
+                dragEvent.stageY = stageY || fgui.GRoot.mouseY;
+                dragEvent.touchPointID = touchPointID || 0;
+                tmp.dispatchEvent(dragEvent);
+            }
+            sGlobalDragStart.x = stageX || fgui.GRoot.mouseX;
+            sGlobalDragStart.y = stageY || fgui.GRoot.mouseY;
+            this.localToGlobalRect(0, 0, this._width, this._height, sGlobalRect);
+            this._dragTesting = true;
+            GObject.draggingObject = this;
+            fgui.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.__moving, this);
+            fgui.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END, this.__end, this);
+        };
+        GObject.prototype.dragEnd = function () {
+            if (GObject.draggingObject == this) {
+                this.reset();
+                this._dragTesting = false;
+                GObject.draggingObject = null;
+            }
+        };
+        GObject.prototype.reset = function () {
+            fgui.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_MOVE, this.__moving, this);
+            fgui.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_END, this.__end, this);
+        };
+        GObject.prototype.__begin = function (evt) {
+            if (this._dragStartPos == null)
+                this._dragStartPos = new egret.Point();
+            this._dragStartPos.x = evt.stageX;
+            this._dragStartPos.y = evt.stageY;
+            this._dragTesting = true;
+            fgui.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.__moving, this);
+            fgui.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END, this.__end, this);
+        };
+        GObject.prototype.__moving = function (evt) {
+            if (GObject.draggingObject != this && this._draggable && this._dragTesting) {
+                var sensitivity = fgui.UIConfig.touchDragSensitivity;
+                if (this._dragStartPos
+                    && Math.abs(this._dragStartPos.x - evt.stageX) < sensitivity
+                    && Math.abs(this._dragStartPos.y - evt.stageY) < sensitivity)
+                    return;
+                this._dragTesting = false;
+                var dragEvent = new fgui.DragEvent(fgui.DragEvent.DRAG_START);
+                dragEvent.stageX = evt.stageX;
+                dragEvent.stageY = evt.stageY;
+                dragEvent.touchPointID = evt.touchPointID;
+                this.dispatchEvent(dragEvent);
+                if (!dragEvent.isDefaultPrevented())
+                    this.dragBegin(evt.touchPointID, evt.stageX, evt.stageY);
+            }
+            if (GObject.draggingObject == this) {
+                var xx = evt.stageX - sGlobalDragStart.x + sGlobalRect.x;
+                var yy = evt.stageY - sGlobalDragStart.y + sGlobalRect.y;
+                if (this._dragBounds) {
+                    var rect = fgui.GRoot.inst.localToGlobalRect(this._dragBounds.x, this._dragBounds.y, this._dragBounds.width, this._dragBounds.height, sDragHelperRect);
+                    if (xx < rect.x)
+                        xx = rect.x;
+                    else if (xx + sGlobalRect.width > rect.right) {
+                        xx = rect.right - sGlobalRect.width;
+                        if (xx < rect.x)
+                            xx = rect.x;
+                    }
+                    if (yy < rect.y)
+                        yy = rect.y;
+                    else if (yy + sGlobalRect.height > rect.bottom) {
+                        yy = rect.bottom - sGlobalRect.height;
+                        if (yy < rect.y)
+                            yy = rect.y;
+                    }
+                }
+                sUpdateInDragging = true;
+                var pt = this.parent.globalToLocal(xx, yy, sHelperPoint);
+                this.setXY(Math.round(pt.x), Math.round(pt.y));
+                sUpdateInDragging = false;
+                var dragEvent = new fgui.DragEvent(fgui.DragEvent.DRAG_MOVING);
+                dragEvent.stageX = evt.stageX;
+                dragEvent.stageY = evt.stageY;
+                dragEvent.touchPointID = evt.touchPointID;
+                this.dispatchEvent(dragEvent);
+            }
+        };
+        GObject.prototype.__end = function (evt) {
+            if (GObject.draggingObject == this) {
+                GObject.draggingObject = null;
+                this.reset();
+                var dragEvent = new fgui.DragEvent(fgui.DragEvent.DRAG_END);
+                dragEvent.stageX = evt.stageX;
+                dragEvent.stageY = evt.stageY;
+                dragEvent.touchPointID = evt.touchPointID;
+                this.dispatchEvent(dragEvent);
+            }
+            else if (this._dragTesting) {
+                this._dragTesting = false;
+                this.reset();
+            }
+        };
+        GObject.XY_CHANGED = "__xyChanged";
+        GObject.SIZE_CHANGED = "__sizeChanged";
+        GObject.SIZE_DELAY_CHANGE = "__sizeDelayChange";
+        GObject.GEAR_STOP = "gearStop";
+        return GObject;
+    }(egret.EventDispatcher));
+    fgui.GObject = GObject;
+    var _gInstanceCounter = 0;
+    var sGlobalDragStart = new egret.Point();
+    var sGlobalRect = new egret.Rectangle();
+    var sHelperPoint = new egret.Point();
+    var sDragHelperRect = new egret.Rectangle();
+    var sUpdateInDragging;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GComponent = (function (_super_1) {
+        __extends(GComponent, _super_1);
+        function GComponent() {
+            var _this = _super_1.call(this) || this;
+            _this._sortingChildCount = 0;
+            _this._childrenRenderOrder = fgui.ChildrenRenderOrder.Ascent;
+            _this._apexIndex = 0;
+            _this._children = new Array();
+            _this._controllers = new Array();
+            _this._transitions = new Array();
+            _this._margin = new fgui.Margin();
+            _this._alignOffset = new egret.Point();
+            return _this;
+        }
+        GComponent.prototype.createDisplayObject = function () {
+            this._rootContainer = new fgui.UIContainer();
+            this.setDisplayObject(this._rootContainer);
+            this._container = this._rootContainer;
+        };
+        GComponent.prototype.dispose = function () {
+            var i;
+            var cnt;
+            cnt = this._transitions.length;
+            for (i = 0; i < cnt; ++i) {
+                var trans = this._transitions[i];
+                trans.dispose();
+            }
+            cnt = this._controllers.length;
+            for (i = 0; i < cnt; ++i) {
+                var cc = this._controllers[i];
+                cc.dispose();
+            }
+            if (this._scrollPane)
+                this._scrollPane.dispose();
+            cnt = this._children.length;
+            for (i = cnt - 1; i >= 0; --i) {
+                var obj = this._children[i];
+                obj.parent = null;
+                obj.dispose();
+            }
+            this._boundsChanged = false;
+            _super_1.prototype.dispose.call(this);
+        };
+        Object.defineProperty(GComponent.prototype, "displayListContainer", {
+            get: function () {
+                return this._container;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GComponent.prototype.addChild = function (child) {
+            this.addChildAt(child, this._children.length);
+            return child;
+        };
+        GComponent.prototype.addChildAt = function (child, index) {
+            if (index === void 0) { index = 0; }
+            if (!child)
+                throw "child is null";
+            var numChildren = this._children.length;
+            if (index >= 0 && index <= numChildren) {
+                if (child.parent == this) {
+                    this.setChildIndex(child, index);
+                }
+                else {
+                    child.removeFromParent();
+                    child.parent = this;
+                    var cnt = this._children.length;
+                    if (child.sortingOrder != 0) {
+                        this._sortingChildCount++;
+                        index = this.getInsertPosForSortingChild(child);
+                    }
+                    else if (this._sortingChildCount > 0) {
+                        if (index > (cnt - this._sortingChildCount))
+                            index = cnt - this._sortingChildCount;
+                    }
+                    if (index == cnt)
+                        this._children.push(child);
+                    else
+                        this._children.splice(index, 0, child);
+                    this.childStateChanged(child);
+                    this.setBoundsChangedFlag();
+                }
+                return child;
+            }
+            else {
+                throw "Invalid child index";
+            }
+        };
+        GComponent.prototype.getInsertPosForSortingChild = function (target) {
+            var cnt = this._children.length;
+            var i = 0;
+            for (i = 0; i < cnt; i++) {
+                var child = this._children[i];
+                if (child == target)
+                    continue;
+                if (target.sortingOrder < child.sortingOrder)
+                    break;
+            }
+            return i;
+        };
+        GComponent.prototype.removeChild = function (child, dispose) {
+            var childIndex = this._children.indexOf(child);
+            if (childIndex != -1) {
+                this.removeChildAt(childIndex, dispose);
+            }
+            return child;
+        };
+        GComponent.prototype.removeChildAt = function (index, dispose) {
+            if (index >= 0 && index < this.numChildren) {
+                var child = this._children[index];
+                child.parent = null;
+                if (child.sortingOrder != 0)
+                    this._sortingChildCount--;
+                this._children.splice(index, 1);
+                child.group = null;
+                if (child.inContainer) {
+                    this._container.removeChild(child.displayObject);
+                    if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Arch)
+                        fgui.GTimers.inst.callLater(this.buildNativeDisplayList, this);
+                }
+                if (dispose)
+                    child.dispose();
+                this.setBoundsChangedFlag();
+                return child;
+            }
+            else {
+                throw "Invalid child index";
+            }
+        };
+        GComponent.prototype.removeChildren = function (beginIndex, endIndex, dispose) {
+            if (beginIndex == undefined)
+                beginIndex = 0;
+            if (endIndex == undefined)
+                endIndex = -1;
+            if (endIndex < 0 || endIndex >= this.numChildren)
+                endIndex = this.numChildren - 1;
+            for (var i = beginIndex; i <= endIndex; ++i)
+                this.removeChildAt(beginIndex, dispose);
+        };
+        GComponent.prototype.getChildAt = function (index) {
+            if (index >= 0 && index < this.numChildren)
+                return this._children[index];
+            else
+                throw "Invalid child index";
+        };
+        GComponent.prototype.getChild = function (name) {
+            var cnt = this._children.length;
+            for (var i = 0; i < cnt; ++i) {
+                if (this._children[i].name == name)
+                    return this._children[i];
+            }
+            return null;
+        };
+        GComponent.prototype.getChildByPath = function (path) {
+            var arr = path.split(".");
+            var cnt = arr.length;
+            var gcom = this;
+            var obj;
+            for (var i = 0; i < cnt; ++i) {
+                obj = gcom.getChild(arr[i]);
+                if (!obj)
+                    break;
+                if (i != cnt - 1) {
+                    if (!(obj instanceof GComponent)) {
+                        obj = null;
+                        break;
+                    }
+                    else
+                        gcom = obj;
+                }
+            }
+            return obj;
+        };
+        GComponent.prototype.getVisibleChild = function (name) {
+            var cnt = this._children.length;
+            for (var i = 0; i < cnt; ++i) {
+                var child = this._children[i];
+                if (child.internalVisible && child.internalVisible && child.name == name)
+                    return child;
+            }
+            return null;
+        };
+        GComponent.prototype.getChildInGroup = function (name, group) {
+            var cnt = this._children.length;
+            for (var i = 0; i < cnt; ++i) {
+                var child = this._children[i];
+                if (child.group == group && child.name == name)
+                    return child;
+            }
+            return null;
+        };
+        GComponent.prototype.getChildById = function (id) {
+            var cnt = this._children.length;
+            for (var i = 0; i < cnt; ++i) {
+                if (this._children[i]._id == id)
+                    return this._children[i];
+            }
+            return null;
+        };
+        GComponent.prototype.getChildIndex = function (child) {
+            return this._children.indexOf(child);
+        };
+        GComponent.prototype.setChildIndex = function (child, index) {
+            var oldIndex = this._children.indexOf(child);
+            if (oldIndex == -1)
+                throw "Not a child of this container";
+            if (child.sortingOrder != 0)
+                return;
+            var cnt = this._children.length;
+            if (this._sortingChildCount > 0) {
+                if (index > (cnt - this._sortingChildCount - 1))
+                    index = cnt - this._sortingChildCount - 1;
+            }
+            this._setChildIndex(child, oldIndex, index);
+        };
+        GComponent.prototype.setChildIndexBefore = function (child, index) {
+            var oldIndex = this._children.indexOf(child);
+            if (oldIndex == -1)
+                throw "Not a child of this container";
+            if (child.sortingOrder != 0)
+                return oldIndex;
+            var cnt = this._children.length;
+            if (this._sortingChildCount > 0) {
+                if (index > (cnt - this._sortingChildCount - 1))
+                    index = cnt - this._sortingChildCount - 1;
+            }
+            if (oldIndex < index)
+                return this._setChildIndex(child, oldIndex, index - 1);
+            else
+                return this._setChildIndex(child, oldIndex, index);
+        };
+        GComponent.prototype._setChildIndex = function (child, oldIndex, index) {
+            var cnt = this._children.length;
+            if (index > cnt)
+                index = cnt;
+            if (oldIndex == index)
+                return oldIndex;
+            this._children.splice(oldIndex, 1);
+            this._children.splice(index, 0, child);
+            if (child.inContainer) {
+                var displayIndex = 0;
+                var g;
+                var i;
+                if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Ascent) {
+                    for (i = 0; i < index; i++) {
+                        g = this._children[i];
+                        if (g.inContainer)
+                            displayIndex++;
+                    }
+                    if (displayIndex == this._container.numChildren)
+                        displayIndex--;
+                    this._container.setChildIndex(child.displayObject, displayIndex);
+                }
+                else if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Descent) {
+                    for (i = cnt - 1; i > index; i--) {
+                        g = this._children[i];
+                        if (g.inContainer)
+                            displayIndex++;
+                    }
+                    if (displayIndex == this._container.numChildren)
+                        displayIndex--;
+                    this._container.setChildIndex(child.displayObject, displayIndex);
+                }
+                else {
+                    fgui.GTimers.inst.callLater(this.buildNativeDisplayList, this);
+                }
+                this.setBoundsChangedFlag();
+            }
+            return index;
+        };
+        GComponent.prototype.swapChildren = function (child1, child2) {
+            var index1 = this._children.indexOf(child1);
+            var index2 = this._children.indexOf(child2);
+            if (index1 == -1 || index2 == -1)
+                throw "Not a child of this container";
+            this.swapChildrenAt(index1, index2);
+        };
+        GComponent.prototype.swapChildrenAt = function (index1, index2) {
+            var child1 = this._children[index1];
+            var child2 = this._children[index2];
+            this.setChildIndex(child1, index2);
+            this.setChildIndex(child2, index1);
+        };
+        Object.defineProperty(GComponent.prototype, "numChildren", {
+            get: function () {
+                return this._children.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GComponent.prototype.isAncestorOf = function (child) {
+            if (!child)
+                return false;
+            var p = child.parent;
+            while (p) {
+                if (p == this)
+                    return true;
+                p = p.parent;
+            }
+            return false;
+        };
+        GComponent.prototype.addController = function (controller) {
+            this._controllers.push(controller);
+            controller.parent = this;
+            this.applyController(controller);
+        };
+        GComponent.prototype.getControllerAt = function (index) {
+            return this._controllers[index];
+        };
+        GComponent.prototype.getController = function (name) {
+            var cnt = this._controllers.length;
+            for (var i = 0; i < cnt; ++i) {
+                var c = this._controllers[i];
+                if (c.name == name)
+                    return c;
+            }
+            return null;
+        };
+        GComponent.prototype.removeController = function (c) {
+            var index = this._controllers.indexOf(c);
+            if (index == -1)
+                throw "controller not exists";
+            c.parent = null;
+            this._controllers.splice(index, 1);
+            var length = this._children.length;
+            for (var i = 0; i < length; i++) {
+                var child = this._children[i];
+                child.handleControllerChanged(c);
+            }
+        };
+        Object.defineProperty(GComponent.prototype, "controllers", {
+            get: function () {
+                return this._controllers;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GComponent.prototype.childStateChanged = function (child) {
+            if (this._buildingDisplayList)
+                return;
+            var cnt = this._children.length;
+            var g;
+            var i;
+            if (child instanceof fgui.GGroup) {
+                for (i = 0; i < cnt; i++) {
+                    g = this._children[i];
+                    if (g.group == child)
+                        this.childStateChanged(g);
+                }
+                return;
+            }
+            if (!child.displayObject)
+                return;
+            if (child.internalVisible) {
+                if (!child.displayObject.parent) {
+                    var index = 0;
+                    if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Ascent) {
+                        for (i = 0; i < cnt; i++) {
+                            g = this._children[i];
+                            if (g == child)
+                                break;
+                            if (g.displayObject && g.displayObject.parent)
+                                index++;
+                        }
+                        this._container.addChildAt(child.displayObject, index);
+                    }
+                    else if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Descent) {
+                        for (i = cnt - 1; i >= 0; i--) {
+                            g = this._children[i];
+                            if (g == child)
+                                break;
+                            if (g.displayObject && g.displayObject.parent)
+                                index++;
+                        }
+                        this._container.addChildAt(child.displayObject, index);
+                    }
+                    else {
+                        this._container.addChild(child.displayObject);
+                        fgui.GTimers.inst.callLater(this.buildNativeDisplayList, this);
+                    }
+                }
+            }
+            else {
+                if (child.displayObject.parent)
+                    this._container.removeChild(child.displayObject);
+            }
+        };
+        GComponent.prototype.buildNativeDisplayList = function () {
+            var cnt = this._children.length;
+            if (cnt == 0)
+                return;
+            var i;
+            var child;
+            switch (this._childrenRenderOrder) {
+                case fgui.ChildrenRenderOrder.Ascent:
+                    {
+                        for (i = 0; i < cnt; i++) {
+                            child = this._children[i];
+                            if (child.displayObject && child.internalVisible)
+                                this._container.addChild(child.displayObject);
+                        }
+                    }
+                    break;
+                case fgui.ChildrenRenderOrder.Descent:
+                    {
+                        for (i = cnt - 1; i >= 0; i--) {
+                            child = this._children[i];
+                            if (child.displayObject && child.internalVisible)
+                                this._container.addChild(child.displayObject);
+                        }
+                    }
+                    break;
+                case fgui.ChildrenRenderOrder.Arch:
+                    {
+                        var apex = fgui.ToolSet.clamp(this._apexIndex, 0, cnt);
+                        for (i = 0; i < apex; i++) {
+                            child = this._children[i];
+                            if (child.displayObject && child.internalVisible)
+                                this._container.addChild(child.displayObject);
+                        }
+                        for (i = cnt - 1; i >= apex; i--) {
+                            child = this._children[i];
+                            if (child.displayObject && child.internalVisible)
+                                this._container.addChild(child.displayObject);
+                        }
+                    }
+                    break;
+            }
+        };
+        GComponent.prototype.applyController = function (c) {
+            this._applyingController = c;
+            var child;
+            var length = this._children.length;
+            for (var i = 0; i < length; i++) {
+                child = this._children[i];
+                child.handleControllerChanged(c);
+            }
+            this._applyingController = null;
+            c.runActions();
+        };
+        GComponent.prototype.applyAllControllers = function () {
+            var cnt = this._controllers.length;
+            for (var i = 0; i < cnt; ++i) {
+                this.applyController(this._controllers[i]);
+            }
+        };
+        GComponent.prototype.adjustRadioGroupDepth = function (obj, c) {
+            var cnt = this._children.length;
+            var i;
+            var child;
+            var myIndex = -1, maxIndex = -1;
+            for (i = 0; i < cnt; i++) {
+                child = this._children[i];
+                if (child == obj) {
+                    myIndex = i;
+                }
+                else if ((child instanceof fgui.GButton) && child.relatedController == c) {
+                    if (i > maxIndex)
+                        maxIndex = i;
+                }
+            }
+            if (myIndex < maxIndex) {
+                if (this._applyingController)
+                    this._children[maxIndex].handleControllerChanged(this._applyingController);
+                this.swapChildrenAt(myIndex, maxIndex);
+            }
+        };
+        GComponent.prototype.getTransitionAt = function (index) {
+            return this._transitions[index];
+        };
+        GComponent.prototype.getTransition = function (transName) {
+            var cnt = this._transitions.length;
+            for (var i = 0; i < cnt; ++i) {
+                var trans = this._transitions[i];
+                if (trans.name == transName)
+                    return trans;
+            }
+            return null;
+        };
+        GComponent.prototype.isChildInView = function (child) {
+            if (this._rootContainer.scrollRect) {
+                return child.x + child.width >= 0 && child.x <= this.width
+                    && child.y + child.height >= 0 && child.y <= this.height;
+            }
+            else if (this._scrollPane) {
+                return this._scrollPane.isChildInView(child);
+            }
+            else
+                return true;
+        };
+        GComponent.prototype.getFirstChildInView = function () {
+            var cnt = this._children.length;
+            for (var i = 0; i < cnt; ++i) {
+                var child = this._children[i];
+                if (this.isChildInView(child))
+                    return i;
+            }
+            return -1;
+        };
+        Object.defineProperty(GComponent.prototype, "scrollPane", {
+            get: function () {
+                return this._scrollPane;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComponent.prototype, "opaque", {
+            get: function () {
+                return this._rootContainer.opaque;
+            },
+            set: function (value) {
+                this._rootContainer.opaque = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComponent.prototype, "margin", {
+            get: function () {
+                return this._margin;
+            },
+            set: function (value) {
+                this._margin.copy(value);
+                if (this._rootContainer.scrollRect) {
+                    this._container.x = this._margin.left + this._alignOffset.x;
+                    this._container.y = this._margin.top + this._alignOffset.y;
+                }
+                this.handleSizeChanged();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComponent.prototype, "childrenRenderOrder", {
+            get: function () {
+                return this._childrenRenderOrder;
+            },
+            set: function (value) {
+                if (this._childrenRenderOrder != value) {
+                    this._childrenRenderOrder = value;
+                    this.buildNativeDisplayList();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComponent.prototype, "apexIndex", {
+            get: function () {
+                return this._apexIndex;
+            },
+            set: function (value) {
+                if (this._apexIndex != value) {
+                    this._apexIndex = value;
+                    if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Arch)
+                        this.buildNativeDisplayList();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComponent.prototype, "mask", {
+            get: function () {
+                return this._rootContainer.mask;
+            },
+            set: function (value) {
+                this._rootContainer.mask = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComponent.prototype, "baseUserData", {
+            get: function () {
+                var buffer = this.packageItem.rawData;
+                buffer.seek(0, 4);
+                return buffer.readS();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GComponent.prototype.updateScrollRect = function () {
+            var rect = this._rootContainer.scrollRect;
+            if (rect == null)
+                rect = new egret.Rectangle();
+            var w = this.width - this._margin.right;
+            var h = this.height - this._margin.bottom;
+            rect.setTo(0, 0, w, h);
+            this._rootContainer.scrollRect = rect;
+        };
+        GComponent.prototype.setupScroll = function (buffer) {
+            if (this._rootContainer == this._container) {
+                this._container = new egret.DisplayObjectContainer();
+                this._rootContainer.addChild(this._container);
+            }
+            this._scrollPane = new fgui.ScrollPane(this);
+            this._scrollPane.setup(buffer);
+            this.setBoundsChangedFlag();
+        };
+        GComponent.prototype.setupOverflow = function (overflow) {
+            if (overflow == fgui.OverflowType.Hidden) {
+                if (this._rootContainer == this._container) {
+                    this._container = new egret.DisplayObjectContainer();
+                    this._rootContainer.addChild(this._container);
+                }
+                this.updateScrollRect();
+                this._container.x = this._margin.left;
+                this._container.y = this._margin.top;
+            }
+            else if (this._margin.left != 0 || this._margin.top != 0) {
+                if (this._rootContainer == this._container) {
+                    this._container = new egret.DisplayObjectContainer();
+                    this._rootContainer.addChild(this._container);
+                }
+                this._container.x = this._margin.left;
+                this._container.y = this._margin.top;
+            }
+            this.setBoundsChangedFlag();
+        };
+        GComponent.prototype.handleSizeChanged = function () {
+            _super_1.prototype.handleSizeChanged.call(this);
+            if (this._scrollPane)
+                this._scrollPane.onOwnerSizeChanged();
+            else if (this._rootContainer.scrollRect)
+                this.updateScrollRect();
+            if (this._rootContainer.hitArea instanceof fgui.PixelHitTest) {
+                var hitTest = (this._rootContainer.hitArea);
+                if (this.sourceWidth != 0)
+                    hitTest.scaleX = this._width / this.sourceWidth;
+                if (this.sourceHeight != 0)
+                    hitTest.scaleY = this._height / this.sourceHeight;
+            }
+        };
+        GComponent.prototype.handleGrayedChanged = function () {
+            var c = this.getController("grayed");
+            if (c) {
+                c.selectedIndex = this.grayed ? 1 : 0;
+                return;
+            }
+            var v = this.grayed;
+            var cnt = this._children.length;
+            for (var i = 0; i < cnt; ++i) {
+                this._children[i].grayed = v;
+            }
+        };
+        GComponent.prototype.handleControllerChanged = function (c) {
+            _super_1.prototype.handleControllerChanged.call(this, c);
+            if (this._scrollPane)
+                this._scrollPane.handleControllerChanged(c);
+        };
+        GComponent.prototype.setBoundsChangedFlag = function () {
+            if (!this._scrollPane && !this._trackBounds)
+                return;
+            if (!this._boundsChanged) {
+                this._boundsChanged = true;
+                egret.callLater(this.__render, this);
+            }
+        };
+        GComponent.prototype.__render = function () {
+            if (this._boundsChanged) {
+                var len = this._children.length;
+                if (len > 0) {
+                    for (var i = 0; i < len; i++) {
+                        var child = this._children[i];
+                        child.ensureSizeCorrect();
+                    }
+                }
+                this.updateBounds();
+            }
+        };
+        GComponent.prototype.ensureBoundsCorrect = function () {
+            var len = this._children.length;
+            if (len > 0) {
+                for (var i = 0; i < len; i++) {
+                    var child = this._children[i];
+                    child.ensureSizeCorrect();
+                }
+            }
+            if (this._boundsChanged)
+                this.updateBounds();
+        };
+        GComponent.prototype.updateBounds = function () {
+            var ax = 0, ay = 0, aw = 0, ah = 0;
+            var len = this._children.length;
+            if (len > 0) {
+                ax = Number.POSITIVE_INFINITY, ay = Number.POSITIVE_INFINITY;
+                var ar = Number.NEGATIVE_INFINITY, ab = Number.NEGATIVE_INFINITY;
+                var tmp = 0;
+                var i = 0;
+                for (var i = 0; i < len; i++) {
+                    var child = this._children[i];
+                    tmp = child.x;
+                    if (tmp < ax)
+                        ax = tmp;
+                    tmp = child.y;
+                    if (tmp < ay)
+                        ay = tmp;
+                    tmp = child.x + child.actualWidth;
+                    if (tmp > ar)
+                        ar = tmp;
+                    tmp = child.y + child.actualHeight;
+                    if (tmp > ab)
+                        ab = tmp;
+                }
+                aw = ar - ax;
+                ah = ab - ay;
+            }
+            this.setBounds(ax, ay, aw, ah);
+        };
+        GComponent.prototype.setBounds = function (ax, ay, aw, ah) {
+            if (ah === void 0) { ah = 0; }
+            this._boundsChanged = false;
+            if (this._scrollPane)
+                this._scrollPane.setContentSize(Math.round(ax + aw), Math.round(ay + ah));
+        };
+        Object.defineProperty(GComponent.prototype, "viewWidth", {
+            get: function () {
+                if (this._scrollPane)
+                    return this._scrollPane.viewWidth;
+                else
+                    return this.width - this._margin.left - this._margin.right;
+            },
+            set: function (value) {
+                if (this._scrollPane)
+                    this._scrollPane.viewWidth = value;
+                else
+                    this.width = value + this._margin.left + this._margin.right;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComponent.prototype, "viewHeight", {
+            get: function () {
+                if (this._scrollPane)
+                    return this._scrollPane.viewHeight;
+                else
+                    return this.height - this._margin.top - this._margin.bottom;
+            },
+            set: function (value) {
+                if (this._scrollPane)
+                    this._scrollPane.viewHeight = value;
+                else
+                    this.height = value + this._margin.top + this._margin.bottom;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GComponent.prototype.getSnappingPosition = function (xValue, yValue, resultPoint) {
+            if (!resultPoint)
+                resultPoint = new egret.Point();
+            var cnt = this._children.length;
+            if (cnt == 0) {
+                resultPoint.x = 0;
+                resultPoint.y = 0;
+                return resultPoint;
+            }
+            this.ensureBoundsCorrect();
+            var obj = null;
+            var prev = null;
+            var i = 0;
+            if (yValue != 0) {
+                for (; i < cnt; i++) {
+                    obj = this._children[i];
+                    if (yValue < obj.y) {
+                        if (i == 0) {
+                            yValue = 0;
+                            break;
+                        }
+                        else {
+                            prev = this._children[i - 1];
+                            if (yValue < prev.y + prev.actualHeight / 2)
+                                yValue = prev.y;
+                            else
+                                yValue = obj.y;
+                            break;
+                        }
+                    }
+                }
+                if (i == cnt)
+                    yValue = obj.y;
+            }
+            if (xValue != 0) {
+                if (i > 0)
+                    i--;
+                for (; i < cnt; i++) {
+                    obj = this._children[i];
+                    if (xValue < obj.x) {
+                        if (i == 0) {
+                            xValue = 0;
+                            break;
+                        }
+                        else {
+                            prev = this._children[i - 1];
+                            if (xValue < prev.x + prev.actualWidth / 2)
+                                xValue = prev.x;
+                            else
+                                xValue = obj.x;
+                            break;
+                        }
+                    }
+                }
+                if (i == cnt)
+                    xValue = obj.x;
+            }
+            resultPoint.x = xValue;
+            resultPoint.y = yValue;
+            return resultPoint;
+        };
+        GComponent.prototype.childSortingOrderChanged = function (child, oldValue, newValue) {
+            if (newValue === void 0) { newValue = 0; }
+            if (newValue == 0) {
+                this._sortingChildCount--;
+                this.setChildIndex(child, this._children.length);
+            }
+            else {
+                if (oldValue == 0)
+                    this._sortingChildCount++;
+                var oldIndex = this._children.indexOf(child);
+                var index = this.getInsertPosForSortingChild(child);
+                if (oldIndex < index)
+                    this._setChildIndex(child, oldIndex, index - 1);
+                else
+                    this._setChildIndex(child, oldIndex, index);
+            }
+        };
+        GComponent.prototype.constructFromResource = function () {
+            this.constructFromResource2(null, 0);
+        };
+        GComponent.prototype.constructFromResource2 = function (objectPool, poolIndex) {
+            var contentItem = this.packageItem.getBranch();
+            if (!contentItem.decoded) {
+                contentItem.decoded = true;
+                fgui.TranslationHelper.translateComponent(contentItem);
+            }
+            var i;
+            var dataLen;
+            var curPos;
+            var nextPos;
+            var f1;
+            var f2;
+            var i1;
+            var i2;
+            var buffer = contentItem.rawData;
+            buffer.seek(0, 0);
+            this._underConstruct = true;
+            this.sourceWidth = buffer.readInt();
+            this.sourceHeight = buffer.readInt();
+            this.initWidth = this.sourceWidth;
+            this.initHeight = this.sourceHeight;
+            this.setSize(this.sourceWidth, this.sourceHeight);
+            if (buffer.readBool()) {
+                this.minWidth = buffer.readInt();
+                this.maxWidth = buffer.readInt();
+                this.minHeight = buffer.readInt();
+                this.maxHeight = buffer.readInt();
+            }
+            if (buffer.readBool()) {
+                f1 = buffer.readFloat();
+                f2 = buffer.readFloat();
+                this.internalSetPivot(f1, f2, buffer.readBool());
+            }
+            if (buffer.readBool()) {
+                this._margin.top = buffer.readInt();
+                this._margin.bottom = buffer.readInt();
+                this._margin.left = buffer.readInt();
+                this._margin.right = buffer.readInt();
+            }
+            var overflow = buffer.readByte();
+            if (overflow == fgui.OverflowType.Scroll) {
+                var savedPos = buffer.position;
+                buffer.seek(0, 7);
+                this.setupScroll(buffer);
+                buffer.position = savedPos;
+            }
+            else
+                this.setupOverflow(overflow);
+            if (buffer.readBool())
+                buffer.skip(8);
+            this._buildingDisplayList = true;
+            buffer.seek(0, 1);
+            var controllerCount = buffer.readShort();
+            for (i = 0; i < controllerCount; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                var controller = new fgui.Controller();
+                this._controllers.push(controller);
+                controller.parent = this;
+                controller.setup(buffer);
+                buffer.position = nextPos;
+            }
+            buffer.seek(0, 2);
+            var child;
+            var childCount = buffer.readShort();
+            for (i = 0; i < childCount; i++) {
+                dataLen = buffer.readShort();
+                curPos = buffer.position;
+                if (objectPool)
+                    child = objectPool[poolIndex + i];
+                else {
+                    buffer.seek(curPos, 0);
+                    var type = buffer.readByte();
+                    var src = buffer.readS();
+                    var pkgId = buffer.readS();
+                    var pi = null;
+                    if (src != null) {
+                        var pkg;
+                        if (pkgId != null)
+                            pkg = fgui.UIPackage.getById(pkgId);
+                        else
+                            pkg = contentItem.owner;
+                        pi = pkg ? pkg.getItemById(src) : null;
+                    }
+                    if (pi) {
+                        child = fgui.UIObjectFactory.newObject(pi);
+                        child.constructFromResource();
+                    }
+                    else
+                        child = fgui.UIObjectFactory.newObject(type);
+                }
+                child._underConstruct = true;
+                child.setup_beforeAdd(buffer, curPos);
+                child.parent = this;
+                this._children.push(child);
+                buffer.position = curPos + dataLen;
+            }
+            buffer.seek(0, 3);
+            this.relations.setup(buffer, true);
+            buffer.seek(0, 2);
+            buffer.skip(2);
+            for (i = 0; i < childCount; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                buffer.seek(buffer.position, 3);
+                this._children[i].relations.setup(buffer, false);
+                buffer.position = nextPos;
+            }
+            buffer.seek(0, 2);
+            buffer.skip(2);
+            for (i = 0; i < childCount; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                child = this._children[i];
+                child.setup_afterAdd(buffer, buffer.position);
+                child._underConstruct = false;
+                buffer.position = nextPos;
+            }
+            buffer.seek(0, 4);
+            buffer.skip(2);
+            this.opaque = buffer.readBool();
+            var maskId = buffer.readShort();
+            if (maskId != -1) {
+                this.mask = this.getChildAt(maskId).displayObject;
+                buffer.readBool();
+            }
+            var hitTestId = buffer.readS();
+            i1 = buffer.readInt();
+            i2 = buffer.readInt();
+            if (hitTestId != null) {
+                pi = contentItem.owner.getItemById(hitTestId);
+                if (pi && pi.pixelHitTestData)
+                    this._rootContainer.hitArea = new fgui.PixelHitTest(pi.pixelHitTestData, i1, i2);
+            }
+            else if (i1 != 0 && i2 != -1) {
+                this._rootContainer.hitArea = this.getChildAt(i2).displayObject;
+            }
+            buffer.seek(0, 5);
+            var transitionCount = buffer.readShort();
+            for (i = 0; i < transitionCount; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                var trans = new fgui.Transition(this);
+                trans.setup(buffer);
+                this._transitions.push(trans);
+                buffer.position = nextPos;
+            }
+            if (this._transitions.length > 0) {
+                this.displayObject.addEventListener(egret.Event.ADDED_TO_STAGE, this.___added, this);
+                this.displayObject.addEventListener(egret.Event.REMOVED_FROM_STAGE, this.___removed, this);
+            }
+            this.applyAllControllers();
+            this._buildingDisplayList = false;
+            this._underConstruct = false;
+            this.buildNativeDisplayList();
+            this.setBoundsChangedFlag();
+            if (contentItem.objectType != fgui.ObjectType.Component)
+                this.constructExtension(buffer);
+            this.onConstruct();
+        };
+        GComponent.prototype.onConstruct = function () {
+            this.constructFromXML(null);
+        };
+        GComponent.prototype.constructExtension = function (buffer) {
+        };
+        GComponent.prototype.constructFromXML = function (xml) {
+        };
+        GComponent.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 4);
+            var pageController = buffer.readShort();
+            if (pageController != -1 && this._scrollPane)
+                this._scrollPane.pageController = this._parent.getControllerAt(pageController);
+            var cnt = buffer.readShort();
+            for (var i = 0; i < cnt; i++) {
+                var cc = this.getController(buffer.readS());
+                var pageId = buffer.readS();
+                if (cc)
+                    cc.selectedPageId = pageId;
+            }
+            if (buffer.version >= 2) {
+                cnt = buffer.readShort();
+                for (i = 0; i < cnt; i++) {
+                    var target = buffer.readS();
+                    var propertyId = buffer.readShort();
+                    var value = buffer.readS();
+                    var obj = this.getChildByPath(target);
+                    if (obj)
+                        obj.setProp(propertyId, value);
+                }
+            }
+        };
+        GComponent.prototype.___added = function (evt) {
+            var cnt = this._transitions.length;
+            for (var i = 0; i < cnt; ++i) {
+                this._transitions[i].onOwnerAddedToStage();
+            }
+        };
+        GComponent.prototype.___removed = function (evt) {
+            var cnt = this._transitions.length;
+            for (var i = 0; i < cnt; ++i) {
+                this._transitions[i].onOwnerRemovedFromStage();
+            }
+        };
+        return GComponent;
+    }(fgui.GObject));
+    fgui.GComponent = GComponent;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GButton = (function (_super_1) {
+        __extends(GButton, _super_1);
+        function GButton() {
+            var _this = _super_1.call(this) || this;
+            _this._mode = fgui.ButtonMode.Common;
+            _this._title = "";
+            _this._icon = "";
+            _this._sound = fgui.UIConfig.buttonSound;
+            _this._soundVolumeScale = fgui.UIConfig.buttonSoundVolumeScale;
+            _this._changeStateOnClick = true;
+            _this._downEffect = 0;
+            _this._downEffectValue = 0.8;
+            return _this;
+        }
+        Object.defineProperty(GButton.prototype, "icon", {
+            get: function () {
+                return this._icon;
+            },
+            set: function (value) {
+                this._icon = value;
+                value = (this._selected && this._selectedIcon) ? this._selectedIcon : this._icon;
+                if (this._iconObject)
+                    this._iconObject.icon = value;
+                this.updateGear(7);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "selectedIcon", {
+            get: function () {
+                return this._selectedIcon;
+            },
+            set: function (value) {
+                this._selectedIcon = value;
+                value = (this._selected && this._selectedIcon) ? this._selectedIcon : this._icon;
+                if (this._iconObject)
+                    this._iconObject.icon = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "title", {
+            get: function () {
+                return this._title;
+            },
+            set: function (value) {
+                this._title = value;
+                if (this._titleObject)
+                    this._titleObject.text = (this._selected && this._selectedTitle) ? this._selectedTitle : this._title;
+                this.updateGear(6);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "text", {
+            get: function () {
+                return this.title;
+            },
+            set: function (value) {
+                this.title = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "selectedTitle", {
+            get: function () {
+                return this._selectedTitle;
+            },
+            set: function (value) {
+                this._selectedTitle = value;
+                if (this._titleObject)
+                    this._titleObject.text = (this._selected && this._selectedTitle) ? this._selectedTitle : this._title;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "titleColor", {
+            get: function () {
+                var tf = this.getTextField();
+                if (tf)
+                    return tf.color;
+                else
+                    return 0;
+            },
+            set: function (value) {
+                var tf = this.getTextField();
+                if (tf)
+                    tf.color = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "titleFontSize", {
+            get: function () {
+                var tf = this.getTextField();
+                if (tf)
+                    return tf.fontSize;
+                else
+                    return 0;
+            },
+            set: function (value) {
+                var tf = this.getTextField();
+                if (tf)
+                    tf.fontSize = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "sound", {
+            get: function () {
+                return this._sound;
+            },
+            set: function (val) {
+                this._sound = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "soundVolumeScale", {
+            get: function () {
+                return this._soundVolumeScale;
+            },
+            set: function (value) {
+                this._soundVolumeScale = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "selected", {
+            get: function () {
+                return this._selected;
+            },
+            set: function (val) {
+                if (this._mode == fgui.ButtonMode.Common)
+                    return;
+                if (this._selected != val) {
+                    this._selected = val;
+                    if (this.grayed && this._buttonController && this._buttonController.hasPage(GButton.DISABLED)) {
+                        if (this._selected)
+                            this.setState(GButton.SELECTED_DISABLED);
+                        else
+                            this.setState(GButton.DISABLED);
+                    }
+                    else {
+                        if (this._selected)
+                            this.setState(this._over ? GButton.SELECTED_OVER : GButton.DOWN);
+                        else
+                            this.setState(this._over ? GButton.OVER : GButton.UP);
+                    }
+                    if (this._selectedTitle && this._titleObject)
+                        this._titleObject.text = this._selected ? this._selectedTitle : this._title;
+                    if (this._selectedIcon) {
+                        var str = this._selected ? this._selectedIcon : this._icon;
+                        if (this._iconObject)
+                            this._iconObject.icon = str;
+                    }
+                    if (this._relatedController
+                        && this._parent
+                        && !this._parent._buildingDisplayList) {
+                        if (this._selected) {
+                            this._relatedController.selectedPageId = this._relatedPageId;
+                            if (this._relatedController.autoRadioGroupDepth)
+                                this._parent.adjustRadioGroupDepth(this, this._relatedController);
+                        }
+                        else if (this._mode == fgui.ButtonMode.Check && this._relatedController.selectedPageId == this._relatedPageId)
+                            this._relatedController.oppositePageId = this._relatedPageId;
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "mode", {
+            get: function () {
+                return this._mode;
+            },
+            set: function (value) {
+                if (this._mode != value) {
+                    if (value == fgui.ButtonMode.Common)
+                        this.selected = false;
+                    this._mode = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "relatedController", {
+            get: function () {
+                return this._relatedController;
+            },
+            set: function (val) {
+                this._relatedController = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "relatedPageId", {
+            get: function () {
+                return this._relatedPageId;
+            },
+            set: function (val) {
+                this._relatedPageId = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "changeStateOnClick", {
+            get: function () {
+                return this._changeStateOnClick;
+            },
+            set: function (value) {
+                this._changeStateOnClick = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GButton.prototype, "linkedPopup", {
+            get: function () {
+                return this._linkedPopup;
+            },
+            set: function (value) {
+                this._linkedPopup = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GButton.prototype.getTextField = function () {
+            if (this._titleObject instanceof fgui.GTextField)
+                return this._titleObject;
+            else if ((this._titleObject instanceof fgui.GLabel) || (this._titleObject instanceof GButton))
+                return this._titleObject.getTextField();
+            else
+                return null;
+        };
+        GButton.prototype.addStateListener = function (listener, thisObj) {
+            this.addEventListener(fgui.StateChangeEvent.CHANGED, listener, thisObj);
+        };
+        GButton.prototype.removeStateListener = function (listener, thisObj) {
+            this.removeEventListener(fgui.StateChangeEvent.CHANGED, listener, thisObj);
+        };
+        GButton.prototype.fireClick = function (downEffect) {
+            if (downEffect && this._mode == fgui.ButtonMode.Common) {
+                this.setState(GButton.OVER);
+                fgui.GTimers.inst.add(100, 1, function () { this.setState(GButton.DOWN); }, this);
+                fgui.GTimers.inst.add(200, 1, function () { this.setState(GButton.UP); }, this);
+            }
+            this.__click(null);
+        };
+        GButton.prototype.setState = function (val) {
+            if (this._buttonController)
+                this._buttonController.selectedPage = val;
+            if (this._downEffect == 1) {
+                var cnt = this.numChildren;
+                if (val == GButton.DOWN || val == GButton.SELECTED_OVER || val == GButton.SELECTED_DISABLED) {
+                    var r = this._downEffectValue * 255;
+                    var color = (r << 16) + (r << 8) + r;
+                    for (var i = 0; i < cnt; i++) {
+                        var obj = this.getChildAt(i);
+                        if (obj["color"] != undefined && !(obj instanceof fgui.GTextField))
+                            obj.color = color;
+                    }
+                }
+                else {
+                    for (var i = 0; i < cnt; i++) {
+                        var obj = this.getChildAt(i);
+                        if (obj["color"] != undefined && !(obj instanceof fgui.GTextField))
+                            obj.color = 0xFFFFFF;
+                    }
+                }
+            }
+            else if (this._downEffect == 2) {
+                if (val == GButton.DOWN || val == GButton.SELECTED_OVER || val == GButton.SELECTED_DISABLED) {
+                    if (!this._downScaled) {
+                        this._downScaled = true;
+                        this._rootContainer.cacheHitArea(true);
+                        this.setScale(this.scaleX * this._downEffectValue, this.scaleY * this._downEffectValue);
+                    }
+                }
+                else {
+                    if (this._downScaled) {
+                        this._downScaled = false;
+                        this._rootContainer.cacheHitArea(false);
+                        this.setScale(this.scaleX / this._downEffectValue, this.scaleY / this._downEffectValue);
+                    }
+                }
+            }
+        };
+        GButton.prototype.handleControllerChanged = function (c) {
+            _super_1.prototype.handleControllerChanged.call(this, c);
+            if (this._relatedController == c)
+                this.selected = this._relatedPageId == c.selectedPageId;
+        };
+        GButton.prototype.handleGrayedChanged = function () {
+            if (this._buttonController && this._buttonController.hasPage(GButton.DISABLED)) {
+                if (this.grayed) {
+                    if (this._selected && this._buttonController.hasPage(GButton.SELECTED_DISABLED))
+                        this.setState(GButton.SELECTED_DISABLED);
+                    else
+                        this.setState(GButton.DISABLED);
+                }
+                else if (this._selected)
+                    this.setState(GButton.DOWN);
+                else
+                    this.setState(GButton.UP);
+            }
+            else
+                _super_1.prototype.handleGrayedChanged.call(this);
+        };
+        GButton.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    return this.titleColor;
+                case fgui.ObjectPropID.OutlineColor:
+                    {
+                        var tf = this.getTextField();
+                        if (tf)
+                            return tf.strokeColor;
+                        else
+                            return 0;
+                    }
+                case fgui.ObjectPropID.FontSize:
+                    return this.titleFontSize;
+                case fgui.ObjectPropID.Selected:
+                    return this.selected;
+                default:
+                    return _super_1.prototype.getProp.call(this, index);
+            }
+        };
+        GButton.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    this.titleColor = value;
+                    break;
+                case fgui.ObjectPropID.OutlineColor:
+                    {
+                        var tf = this.getTextField();
+                        if (tf)
+                            tf.strokeColor = value;
+                    }
+                    break;
+                case fgui.ObjectPropID.FontSize:
+                    this.titleFontSize = value;
+                    break;
+                case fgui.ObjectPropID.Selected:
+                    this.selected = value;
+                    break;
+                default:
+                    _super_1.prototype.setProp.call(this, index, value);
+                    break;
+            }
+        };
+        GButton.prototype.constructExtension = function (buffer) {
+            buffer.seek(0, 6);
+            this._mode = buffer.readByte();
+            var str = buffer.readS();
+            if (str)
+                this._sound = str;
+            this._soundVolumeScale = buffer.readFloat();
+            this._downEffect = buffer.readByte();
+            this._downEffectValue = buffer.readFloat();
+            if (this._downEffect == 2)
+                this.setPivot(0.5, 0.5, this.pivotAsAnchor);
+            this._buttonController = this.getController("button");
+            this._titleObject = this.getChild("title");
+            this._iconObject = this.getChild("icon");
+            if (this._titleObject)
+                this._title = this._titleObject.text;
+            if (this._iconObject)
+                this._icon = this._iconObject.icon;
+            if (this._mode == fgui.ButtonMode.Common)
+                this.setState(GButton.UP);
+            this.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__mousedown, this);
+            this.addEventListener(egret.TouchEvent.TOUCH_TAP, this.__click, this);
+        };
+        GButton.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            if (!buffer.seek(beginPos, 6))
+                return;
+            if (buffer.readByte() != this.packageItem.objectType)
+                return;
+            var str;
+            var iv;
+            str = buffer.readS();
+            if (str != null)
+                this.title = str;
+            str = buffer.readS();
+            if (str != null)
+                this.selectedTitle = str;
+            str = buffer.readS();
+            if (str != null)
+                this.icon = str;
+            str = buffer.readS();
+            if (str != null)
+                this.selectedIcon = str;
+            if (buffer.readBool())
+                this.titleColor = buffer.readColor();
+            iv = buffer.readInt();
+            if (iv != 0)
+                this.titleFontSize = iv;
+            iv = buffer.readShort();
+            if (iv >= 0)
+                this._relatedController = this.parent.getControllerAt(iv);
+            this._relatedPageId = buffer.readS();
+            str = buffer.readS();
+            if (str != null)
+                this._sound = str;
+            if (buffer.readBool())
+                this._soundVolumeScale = buffer.readFloat();
+            this.selected = buffer.readBool();
+        };
+        GButton.prototype.__mousedown = function (evt) {
+            this._down = true;
+            fgui.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END, this.__mouseup, this);
+            if (this._mode == fgui.ButtonMode.Common) {
+                if (this.grayed && this._buttonController && this._buttonController.hasPage(GButton.DISABLED))
+                    this.setState(GButton.SELECTED_DISABLED);
+                else
+                    this.setState(GButton.DOWN);
+            }
+            if (this._linkedPopup) {
+                if (this._linkedPopup instanceof fgui.Window)
+                    this._linkedPopup.toggleStatus();
+                else
+                    this.root.togglePopup(this._linkedPopup, this);
+            }
+        };
+        GButton.prototype.__mouseup = function (evt) {
+            if (this._down) {
+                fgui.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_END, this.__mouseup, this);
+                this._down = false;
+                if (!this.displayObject)
+                    return;
+                if (this._mode == fgui.ButtonMode.Common) {
+                    if (this.grayed && this._buttonController && this._buttonController.hasPage(GButton.DISABLED))
+                        this.setState(GButton.DISABLED);
+                    else if (this._over)
+                        this.setState(GButton.OVER);
+                    else
+                        this.setState(GButton.UP);
+                }
+            }
+        };
+        GButton.prototype.__click = function (evt) {
+            if (this._sound) {
+                var pi = fgui.UIPackage.getItemByURL(this._sound);
+                if (pi) {
+                    var sound = pi.owner.getItemAsset(pi);
+                    if (sound)
+                        fgui.GRoot.inst.playOneShotSound(sound, this._soundVolumeScale);
+                }
+            }
+            if (this._mode == fgui.ButtonMode.Check) {
+                if (this._changeStateOnClick) {
+                    this.selected = !this._selected;
+                    this.dispatchEvent(new fgui.StateChangeEvent(fgui.StateChangeEvent.CHANGED));
+                }
+            }
+            else if (this._mode == fgui.ButtonMode.Radio) {
+                if (this._changeStateOnClick && !this._selected) {
+                    this.selected = true;
+                    this.dispatchEvent(new fgui.StateChangeEvent(fgui.StateChangeEvent.CHANGED));
+                }
+            }
+            else {
+                if (this._relatedController)
+                    this._relatedController.selectedPageId = this._relatedPageId;
+            }
+        };
+        GButton.UP = "up";
+        GButton.DOWN = "down";
+        GButton.OVER = "over";
+        GButton.SELECTED_OVER = "selectedOver";
+        GButton.DISABLED = "disabled";
+        GButton.SELECTED_DISABLED = "selectedDisabled";
+        return GButton;
+    }(fgui.GComponent));
+    fgui.GButton = GButton;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GComboBox = (function (_super_1) {
+        __extends(GComboBox, _super_1);
+        function GComboBox() {
+            var _this = _super_1.call(this) || this;
+            _this._visibleItemCount = 0;
+            _this._selectedIndex = 0;
+            _this._popupDirection = fgui.PopupDirection.Auto;
+            _this._visibleItemCount = fgui.UIConfig.defaultComboBoxVisibleItemCount;
+            _this._itemsUpdated = true;
+            _this._selectedIndex = -1;
+            _this._items = [];
+            _this._values = [];
+            return _this;
+        }
+        Object.defineProperty(GComboBox.prototype, "text", {
+            get: function () {
+                if (this._titleObject)
+                    return this._titleObject.text;
+                else
+                    return null;
+            },
+            set: function (value) {
+                if (this._titleObject)
+                    this._titleObject.text = value;
+                this.updateGear(6);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "icon", {
+            get: function () {
+                if (this._iconObject)
+                    return this._iconObject.icon;
+                else
+                    return null;
+            },
+            set: function (value) {
+                if (this._iconObject)
+                    this._iconObject.icon = value;
+                this.updateGear(7);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "titleColor", {
+            get: function () {
+                var tf = this.getTextField();
+                if (tf)
+                    return tf.color;
+                else
+                    return 0;
+            },
+            set: function (value) {
+                var tf = this.getTextField();
+                if (tf)
+                    tf.color = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "titleFontSize", {
+            get: function () {
+                var tf = this.getTextField();
+                if (tf)
+                    return tf.fontSize;
+                else
+                    return 0;
+            },
+            set: function (value) {
+                var tf = this.getTextField();
+                if (tf)
+                    tf.fontSize = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "visibleItemCount", {
+            get: function () {
+                return this._visibleItemCount;
+            },
+            set: function (value) {
+                this._visibleItemCount = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "popupDirection", {
+            get: function () {
+                return this._popupDirection;
+            },
+            set: function (value) {
+                this._popupDirection = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "items", {
+            get: function () {
+                return this._items;
+            },
+            set: function (value) {
+                if (!value)
+                    this._items.length = 0;
+                else
+                    this._items = value.concat();
+                if (this._items.length > 0) {
+                    if (this._selectedIndex >= this._items.length)
+                        this._selectedIndex = this._items.length - 1;
+                    else if (this._selectedIndex == -1)
+                        this._selectedIndex = 0;
+                    this.text = this._items[this._selectedIndex];
+                    if (this._icons && this._selectedIndex < this._icons.length)
+                        this.icon = this._icons[this._selectedIndex];
+                }
+                else {
+                    this.text = "";
+                    if (this._icons)
+                        this.icon = null;
+                    this._selectedIndex = -1;
+                }
+                this._itemsUpdated = true;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "icons", {
+            get: function () {
+                return this._icons;
+            },
+            set: function (value) {
+                this._icons = value;
+                if (this._icons && this._selectedIndex != -1 && this._selectedIndex < this._icons.length)
+                    this.icon = this._icons[this._selectedIndex];
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "values", {
+            get: function () {
+                return this._values;
+            },
+            set: function (value) {
+                if (!value)
+                    this._values.length = 0;
+                else
+                    this._values = value.concat();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "selectedIndex", {
+            get: function () {
+                return this._selectedIndex;
+            },
+            set: function (val) {
+                if (this._selectedIndex == val)
+                    return;
+                this._selectedIndex = val;
+                if (this._selectedIndex >= 0 && this._selectedIndex < this._items.length) {
+                    this.text = this._items[this._selectedIndex];
+                    if (this._icons && this._selectedIndex < this._icons.length)
+                        this.icon = this._icons[this._selectedIndex];
+                }
+                else {
+                    this.text = "";
+                    if (this._icons)
+                        this.icon = null;
+                }
+                this.updateSelectionController();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "value", {
+            get: function () {
+                return this._values[this._selectedIndex];
+            },
+            set: function (val) {
+                var index = this._values.indexOf(val);
+                if (index == -1 && val == null)
+                    index = this._values.indexOf("");
+                this.selectedIndex = index;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GComboBox.prototype, "selectionController", {
+            get: function () {
+                return this._selectionController;
+            },
+            set: function (value) {
+                this._selectionController = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GComboBox.prototype.getTextField = function () {
+            if (this._titleObject instanceof fgui.GTextField)
+                return this._titleObject;
+            else if ((this._titleObject instanceof fgui.GLabel) || (this._titleObject instanceof fgui.GButton))
+                return this._titleObject.getTextField();
+            else
+                return null;
+        };
+        GComboBox.prototype.setState = function (val) {
+            if (this._buttonController)
+                this._buttonController.selectedPage = val;
+        };
+        GComboBox.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    return this.titleColor;
+                case fgui.ObjectPropID.OutlineColor:
+                    {
+                        var tf = this.getTextField();
+                        if (tf)
+                            return tf.strokeColor;
+                        else
+                            return 0;
+                    }
+                case fgui.ObjectPropID.FontSize:
+                    {
+                        tf = this.getTextField();
+                        if (tf)
+                            return tf.fontSize;
+                        else
+                            return 0;
+                    }
+                default:
+                    return _super_1.prototype.getProp.call(this, index);
+            }
+        };
+        GComboBox.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    this.titleColor = value;
+                    break;
+                case fgui.ObjectPropID.OutlineColor:
+                    {
+                        var tf = this.getTextField();
+                        if (tf)
+                            tf.strokeColor = value;
+                    }
+                    break;
+                case fgui.ObjectPropID.FontSize:
+                    {
+                        tf = this.getTextField();
+                        if (tf)
+                            tf.fontSize = value;
+                    }
+                    break;
+                default:
+                    _super_1.prototype.setProp.call(this, index, value);
+                    break;
+            }
+        };
+        GComboBox.prototype.constructExtension = function (buffer) {
+            var str;
+            this._buttonController = this.getController("button");
+            this._titleObject = this.getChild("title");
+            this._iconObject = this.getChild("icon");
+            str = buffer.readS();
+            if (str) {
+                this.dropdown = (fgui.UIPackage.createObjectFromURL(str));
+                if (!this.dropdown) {
+                    console.error("下拉框必须为元件");
+                    return;
+                }
+                this.dropdown.name = "this.dropdown";
+                this._list = this.dropdown.getChild("list").asList;
+                if (this._list == null) {
+                    console.error(this.resourceURL + ": 下拉框的弹出元件里必须包含名为list的列表");
+                    return;
+                }
+                this._list.addEventListener(fgui.ItemEvent.CLICK, this.__clickItem, this);
+                this._list.addRelation(this.dropdown, fgui.RelationType.Width);
+                this._list.removeRelation(this.dropdown, fgui.RelationType.Height);
+                this.dropdown.addRelation(this._list, fgui.RelationType.Height);
+                this.dropdown.removeRelation(this._list, fgui.RelationType.Width);
+                this.dropdown.displayObject.addEventListener(egret.Event.REMOVED_FROM_STAGE, this.__popupWinClosed, this);
+            }
+            this.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__mousedown, this);
+        };
+        GComboBox.prototype.handleControllerChanged = function (c) {
+            _super_1.prototype.handleControllerChanged.call(this, c);
+            if (this._selectionController == c)
+                this.selectedIndex = c.selectedIndex;
+        };
+        GComboBox.prototype.updateSelectionController = function () {
+            if (this._selectionController && !this._selectionController.changing
+                && this._selectedIndex < this._selectionController.pageCount) {
+                var c = this._selectionController;
+                this._selectionController = null;
+                c.selectedIndex = this._selectedIndex;
+                this._selectionController = c;
+            }
+        };
+        GComboBox.prototype.dispose = function () {
+            if (this.dropdown) {
+                this.dropdown.dispose();
+                this.dropdown = null;
+            }
+            _super_1.prototype.dispose.call(this);
+        };
+        GComboBox.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            if (!buffer.seek(beginPos, 6))
+                return;
+            if (buffer.readByte() != this.packageItem.objectType)
+                return;
+            var i;
+            var iv;
+            var nextPos;
+            var str;
+            var itemCount = buffer.readShort();
+            for (i = 0; i < itemCount; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                this._items[i] = buffer.readS();
+                this._values[i] = buffer.readS();
+                str = buffer.readS();
+                if (str != null) {
+                    if (this._icons == null)
+                        this._icons = new Array();
+                    this._icons[i] = str;
+                }
+                buffer.position = nextPos;
+            }
+            str = buffer.readS();
+            if (str != null) {
+                this.text = str;
+                this._selectedIndex = this._items.indexOf(str);
+            }
+            else if (this._items.length > 0) {
+                this._selectedIndex = 0;
+                this.text = this._items[0];
+            }
+            else
+                this._selectedIndex = -1;
+            str = buffer.readS();
+            if (str != null)
+                this.icon = str;
+            if (buffer.readBool())
+                this.titleColor = buffer.readColor();
+            iv = buffer.readInt();
+            if (iv > 0)
+                this._visibleItemCount = iv;
+            this._popupDirection = buffer.readByte();
+            iv = buffer.readShort();
+            if (iv >= 0)
+                this._selectionController = this.parent.getControllerAt(iv);
+        };
+        GComboBox.prototype.showDropdown = function () {
+            if (this._itemsUpdated) {
+                this._itemsUpdated = false;
+                this._list.removeChildrenToPool();
+                var cnt = this._items.length;
+                for (var i = 0; i < cnt; i++) {
+                    var item = this._list.addItemFromPool();
+                    item.name = i < this._values.length ? this._values[i] : "";
+                    item.text = this._items[i];
+                    item.icon = (this._icons && i < this._icons.length) ? this._icons[i] : null;
+                }
+                this._list.resizeToFit(this._visibleItemCount);
+            }
+            this._list.selectedIndex = -1;
+            this.dropdown.width = this.width;
+            this._list.ensureBoundsCorrect();
+            this.root.togglePopup(this.dropdown, this, this._popupDirection);
+            if (this.dropdown.parent)
+                this.setState(fgui.GButton.DOWN);
+        };
+        GComboBox.prototype.__popupWinClosed = function (evt) {
+            if (this._over)
+                this.setState(fgui.GButton.OVER);
+            else
+                this.setState(fgui.GButton.UP);
+        };
+        GComboBox.prototype.__clickItem = function (evt) {
+            fgui.GTimers.inst.add(100, 1, this.__clickItem2, this, this._list.getChildIndex(evt.itemObject));
+        };
+        GComboBox.prototype.__clickItem2 = function (index) {
+            if (this.dropdown.parent instanceof fgui.GRoot)
+                this.dropdown.parent.hidePopup();
+            this._selectedIndex = -1;
+            this.selectedIndex = index;
+            this.dispatchEvent(new fgui.StateChangeEvent(fgui.StateChangeEvent.CHANGED));
+        };
+        GComboBox.prototype.__mousedown = function (evt) {
+            if ((evt.target instanceof egret.TextField) && evt.target.type == egret.TextFieldType.INPUT)
+                return;
+            this._down = true;
+            fgui.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END, this.__mouseup, this);
+            if (this.dropdown)
+                this.showDropdown();
+        };
+        GComboBox.prototype.__mouseup = function (evt) {
+            if (this._down) {
+                this._down = false;
+                fgui.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_END, this.__mouseup, this);
+                if (this.dropdown && !this.dropdown.parent) {
+                    if (this._over)
+                        this.setState(fgui.GButton.OVER);
+                    else
+                        this.setState(fgui.GButton.UP);
+                }
+            }
+        };
+        return GComboBox;
+    }(fgui.GComponent));
+    fgui.GComboBox = GComboBox;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GGraph = (function (_super_1) {
+        __extends(GGraph, _super_1);
+        function GGraph() {
+            var _this = _super_1.call(this) || this;
+            _this._type = 0;
+            _this._lineSize = 0;
+            _this._lineColor = 0;
+            _this._fillColor = 0;
+            _this._lineSize = 1;
+            _this._lineAlpha = 1;
+            _this._fillAlpha = 1;
+            _this._fillColor = 0xFFFFFF;
+            return _this;
+        }
+        Object.defineProperty(GGraph.prototype, "graphics", {
+            get: function () {
+                return this._graphics;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GGraph.prototype.drawRect = function (lineSize, lineColor, lineAlpha, fillColor, fillAlpha, corner) {
+            this._type = 1;
+            this._lineSize = lineSize;
+            this._lineColor = lineColor;
+            this._lineAlpha = lineAlpha;
+            this._fillColor = fillColor;
+            this._fillAlpha = fillAlpha;
+            this._cornerRadius = corner;
+            this.updateGraph();
+        };
+        GGraph.prototype.drawEllipse = function (lineSize, lineColor, lineAlpha, fillColor, fillAlpha) {
+            this._type = 2;
+            this._lineSize = lineSize;
+            this._lineColor = lineColor;
+            this._lineAlpha = lineAlpha;
+            this._fillColor = fillColor;
+            this._fillAlpha = fillAlpha;
+            this._cornerRadius = null;
+            this.updateGraph();
+        };
+        GGraph.prototype.drawRegularPolygon = function (lineSize, lineColor, lineAlpha, fillColor, fillAlpha, sides, startAngle, distances) {
+            this._type = 4;
+            this._lineSize = lineSize;
+            this._lineColor = lineColor;
+            this._lineAlpha = lineAlpha;
+            this._fillColor = fillColor;
+            this._fillAlpha = fillAlpha;
+            this._sides = sides;
+            this._startAngle = startAngle || 0;
+            this._distances = distances;
+            this.updateGraph();
+        };
+        GGraph.prototype.drawPolygon = function (lineSize, lineColor, lineAlpha, fillColor, fillAlpha, points) {
+            this._type = 3;
+            this._lineSize = lineSize;
+            this._lineColor = lineColor;
+            this._lineAlpha = lineAlpha;
+            this._fillColor = fillColor;
+            this._fillAlpha = fillAlpha;
+            this._polygonPoints = points;
+            this.updateGraph();
+        };
+        Object.defineProperty(GGraph.prototype, "distances", {
+            get: function () {
+                return this._distances;
+            },
+            set: function (value) {
+                this._distances = value;
+                if (this._type == 3)
+                    this.updateGraph();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GGraph.prototype.clearGraphics = function () {
+            if (this._graphics) {
+                this._type = 0;
+                this._graphics.clear();
+            }
+        };
+        Object.defineProperty(GGraph.prototype, "color", {
+            get: function () {
+                return this._fillColor;
+            },
+            set: function (value) {
+                this._fillColor = value;
+                if (this._type != 0)
+                    this.updateGraph();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GGraph.prototype.updateGraph = function () {
+            var ctx = this.graphics;
+            ctx.clear();
+            var w = this.width;
+            var h = this.height;
+            if (w == 0 || h == 0)
+                return;
+            if (this._lineSize == 0)
+                ctx.lineStyle(0, 0, 0);
+            else
+                ctx.lineStyle(this._lineSize, this._lineColor, this._lineAlpha);
+            ctx.beginFill(this._fillColor, this._fillAlpha);
+            if (this._type == 1) {
+                if (this._cornerRadius) {
+                    if (this._cornerRadius.length == 1)
+                        ctx.drawRoundRect(0, 0, w, h, this._cornerRadius[0] * 2, this._cornerRadius[0] * 2);
+                    else
+                        ctx.drawRoundRect(0, 0, w, h, this._cornerRadius[0] * 2, this._cornerRadius[1] * 2);
+                }
+                else
+                    ctx.drawRect(0, 0, w, h);
+            }
+            else if (this._type == 2)
+                ctx.drawEllipse(0, 0, w, h);
+            else if (this._type == 3) {
+                fgui.ToolSet.fillPath(ctx, this._polygonPoints, 0, 0);
+            }
+            else if (this._type == 4) {
+                if (!this._polygonPoints)
+                    this._polygonPoints = [];
+                var radius = Math.min(this._width, this._height) / 2;
+                this._polygonPoints.length = 0;
+                var angle = this._startAngle * Math.PI / 180;
+                var deltaAngle = 2 * Math.PI / this._sides;
+                var dist;
+                for (var i = 0; i < this._sides; i++) {
+                    if (this._distances) {
+                        dist = this._distances[i];
+                        if (isNaN(dist))
+                            dist = 1;
+                    }
+                    else
+                        dist = 1;
+                    var xv = radius + radius * dist * Math.cos(angle);
+                    var yv = radius + radius * dist * Math.sin(angle);
+                    this._polygonPoints.push(xv, yv);
+                    angle += deltaAngle;
+                }
+                fgui.ToolSet.fillPath(ctx, this._polygonPoints, 0, 0);
+            }
+            ctx.endFill();
+        };
+        GGraph.prototype.replaceMe = function (target) {
+            if (!this._parent)
+                throw "parent not set";
+            target.name = this.name;
+            target.alpha = this.alpha;
+            target.rotation = this.rotation;
+            target.visible = this.visible;
+            target.touchable = this.touchable;
+            target.grayed = this.grayed;
+            target.setXY(this.x, this.y);
+            target.setSize(this.width, this.height);
+            var index = this._parent.getChildIndex(this);
+            this._parent.addChildAt(target, index);
+            target.relations.copyFrom(this.relations);
+            this._parent.removeChild(this, true);
+        };
+        GGraph.prototype.addBeforeMe = function (target) {
+            if (this._parent == null)
+                throw "parent not set";
+            var index = this._parent.getChildIndex(this);
+            this._parent.addChildAt(target, index);
+        };
+        GGraph.prototype.addAfterMe = function (target) {
+            if (this._parent == null)
+                throw "parent not set";
+            var index = this._parent.getChildIndex(this);
+            index++;
+            this._parent.addChildAt(target, index);
+        };
+        GGraph.prototype.setNativeObject = function (obj) {
+            var sprite = new egret.Sprite();
+            this.setDisplayObject(sprite);
+            if (this._parent)
+                this._parent.childStateChanged(this);
+            this.handleXYChanged();
+            sprite.alpha = this.alpha;
+            sprite.rotation = this.rotation;
+            sprite.visible = this.visible;
+            sprite.touchEnabled = this.touchable;
+            sprite.touchChildren = this.touchable;
+            sprite.addChild(obj);
+        };
+        GGraph.prototype.createDisplayObject = function () {
+            var sprite = new egret.Sprite();
+            sprite.touchEnabled = true;
+            this._graphics = sprite.graphics;
+            this.setDisplayObject(sprite);
+        };
+        GGraph.prototype.getProp = function (index) {
+            if (index == fgui.ObjectPropID.Color)
+                return this.color;
+            else
+                return _super_1.prototype.getProp.call(this, index);
+        };
+        GGraph.prototype.setProp = function (index, value) {
+            if (index == fgui.ObjectPropID.Color)
+                this.color = value;
+            else
+                _super_1.prototype.setProp.call(this, index, value);
+        };
+        GGraph.prototype.handleSizeChanged = function () {
+            _super_1.prototype.handleSizeChanged.call(this);
+            if (this._type != 0)
+                this.updateGraph();
+        };
+        GGraph.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            this._type = buffer.readByte();
+            if (this._type != 0) {
+                var i;
+                var cnt;
+                this._lineSize = buffer.readInt();
+                var c = buffer.readColor(true);
+                this._lineColor = c & 0xFFFFFF;
+                this._lineAlpha = ((c >> 24) & 0xFF) / 0xFF;
+                c = buffer.readColor(true);
+                this._fillColor = c & 0xFFFFFF;
+                this._fillAlpha = ((c >> 24) & 0xFF) / 0xFF;
+                if (buffer.readBool()) {
+                    this._cornerRadius = new Array(4);
+                    for (i = 0; i < 4; i++)
+                        this._cornerRadius[i] = buffer.readFloat();
+                }
+                if (this._type == 3) {
+                    cnt = buffer.readShort();
+                    this._polygonPoints = [];
+                    this._polygonPoints.length = cnt;
+                    for (i = 0; i < cnt; i++)
+                        this._polygonPoints[i] = buffer.readFloat();
+                }
+                else if (this._type == 4) {
+                    this._sides = buffer.readShort();
+                    this._startAngle = buffer.readFloat();
+                    cnt = buffer.readShort();
+                    if (cnt > 0) {
+                        this._distances = [];
+                        for (i = 0; i < cnt; i++)
+                            this._distances[i] = buffer.readFloat();
+                    }
+                }
+                this.updateGraph();
+            }
+        };
+        return GGraph;
+    }(fgui.GObject));
+    fgui.GGraph = GGraph;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GGroup = (function (_super_1) {
+        __extends(GGroup, _super_1);
+        function GGroup() {
+            var _this = _super_1.call(this) || this;
+            _this._layout = 0;
+            _this._lineGap = 0;
+            _this._columnGap = 0;
+            _this._mainGridIndex = -1;
+            _this._mainGridMinSize = 50;
+            _this._mainChildIndex = -1;
+            _this._totalSize = 0;
+            _this._numChildren = 0;
+            _this._updating = 0;
+            return _this;
+        }
+        GGroup.prototype.dispose = function () {
+            this._boundsChanged = false;
+            _super_1.prototype.dispose.call(this);
+        };
+        Object.defineProperty(GGroup.prototype, "layout", {
+            get: function () {
+                return this._layout;
+            },
+            set: function (value) {
+                if (this._layout != value) {
+                    this._layout = value;
+                    this.setBoundsChangedFlag();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GGroup.prototype, "lineGap", {
+            get: function () {
+                return this._lineGap;
+            },
+            set: function (value) {
+                if (this._lineGap != value) {
+                    this._lineGap = value;
+                    this.setBoundsChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GGroup.prototype, "columnGap", {
+            get: function () {
+                return this._columnGap;
+            },
+            set: function (value) {
+                if (this._columnGap != value) {
+                    this._columnGap = value;
+                    this.setBoundsChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GGroup.prototype, "excludeInvisibles", {
+            get: function () {
+                return this._excludeInvisibles;
+            },
+            set: function (value) {
+                if (this._excludeInvisibles != value) {
+                    this._excludeInvisibles = value;
+                    this.setBoundsChangedFlag();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GGroup.prototype, "autoSizeDisabled", {
+            get: function () {
+                return this._autoSizeDisabled;
+            },
+            set: function (value) {
+                this._autoSizeDisabled = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GGroup.prototype, "mainGridMinSize", {
+            get: function () {
+                return this._mainGridMinSize;
+            },
+            set: function (value) {
+                if (this._mainGridMinSize != value) {
+                    this._mainGridMinSize = value;
+                    this.setBoundsChangedFlag();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GGroup.prototype, "mainGridIndex", {
+            get: function () {
+                return this._mainGridIndex;
+            },
+            set: function (value) {
+                if (this._mainGridIndex != value) {
+                    this._mainGridIndex = value;
+                    this.setBoundsChangedFlag();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GGroup.prototype.setBoundsChangedFlag = function (positionChangedOnly) {
+            if (this._updating == 0 && this._parent) {
+                if (!positionChangedOnly)
+                    this._percentReady = false;
+                if (!this._boundsChanged) {
+                    this._boundsChanged = true;
+                    if (this._layout != fgui.GroupLayoutType.None)
+                        fgui.GTimers.inst.callLater(this.ensureBoundsCorrect, this);
+                }
+            }
+        };
+        GGroup.prototype.ensureSizeCorrect = function () {
+            if (this._parent == null || !this._boundsChanged || this._layout == 0)
+                return;
+            this._boundsChanged = false;
+            if (this._autoSizeDisabled)
+                this.resizeChildren(0, 0);
+            else {
+                this.handleLayout();
+                this.updateBounds();
+            }
+        };
+        GGroup.prototype.ensureBoundsCorrect = function () {
+            if (this._parent == null || !this._boundsChanged)
+                return;
+            this._boundsChanged = false;
+            if (this._layout == 0)
+                this.updateBounds();
+            else {
+                if (this._autoSizeDisabled)
+                    this.resizeChildren(0, 0);
+                else {
+                    this.handleLayout();
+                    this.updateBounds();
+                }
+            }
+        };
+        GGroup.prototype.updateBounds = function () {
+            fgui.GTimers.inst.remove(this.ensureBoundsCorrect, this);
+            var cnt = this._parent.numChildren;
+            var i;
+            var child;
+            var ax = Number.POSITIVE_INFINITY, ay = Number.POSITIVE_INFINITY;
+            var ar = Number.NEGATIVE_INFINITY, ab = Number.NEGATIVE_INFINITY;
+            var tmp;
+            var empty = true;
+            for (i = 0; i < cnt; i++) {
+                child = this._parent.getChildAt(i);
+                if (child.group != this || this._excludeInvisibles && !child.internalVisible3)
+                    continue;
+                tmp = child.xMin;
+                if (tmp < ax)
+                    ax = tmp;
+                tmp = child.yMin;
+                if (tmp < ay)
+                    ay = tmp;
+                tmp = child.xMin + child.width;
+                if (tmp > ar)
+                    ar = tmp;
+                tmp = child.yMin + child.height;
+                if (tmp > ab)
+                    ab = tmp;
+                empty = false;
+            }
+            var w = 0, h = 0;
+            if (!empty) {
+                this._updating |= 1;
+                this.setXY(ax, ay);
+                this._updating &= 2;
+                w = ar - ax;
+                h = ab - ay;
+            }
+            if ((this._updating & 2) == 0) {
+                this._updating |= 2;
+                this.setSize(w, h);
+                this._updating &= 1;
+            }
+            else {
+                this._updating &= 1;
+                this.resizeChildren(this._width - w, this._height - h);
+            }
+        };
+        GGroup.prototype.handleLayout = function () {
+            this._updating |= 1;
+            var child;
+            var i;
+            var cnt;
+            if (this._layout == fgui.GroupLayoutType.Horizontal) {
+                var curX = this.x;
+                cnt = this._parent.numChildren;
+                for (i = 0; i < cnt; i++) {
+                    child = this._parent.getChildAt(i);
+                    if (child.group != this)
+                        continue;
+                    if (this._excludeInvisibles && !child.internalVisible3)
+                        continue;
+                    child.xMin = curX;
+                    if (child.width != 0)
+                        curX += child.width + this._columnGap;
+                }
+            }
+            else if (this._layout == fgui.GroupLayoutType.Vertical) {
+                var curY = this.y;
+                cnt = this._parent.numChildren;
+                for (i = 0; i < cnt; i++) {
+                    child = this._parent.getChildAt(i);
+                    if (child.group != this)
+                        continue;
+                    if (this._excludeInvisibles && !child.internalVisible3)
+                        continue;
+                    child.yMin = curY;
+                    if (child.height != 0)
+                        curY += child.height + this._lineGap;
+                }
+            }
+            this._updating &= 2;
+        };
+        GGroup.prototype.moveChildren = function (dx, dy) {
+            if ((this._updating & 1) != 0 || this._parent == null)
+                return;
+            this._updating |= 1;
+            var cnt = this._parent.numChildren;
+            var i;
+            var child;
+            for (i = 0; i < cnt; i++) {
+                child = this._parent.getChildAt(i);
+                if (child.group == this) {
+                    child.setXY(child.x + dx, child.y + dy);
+                }
+            }
+            this._updating &= 2;
+        };
+        GGroup.prototype.resizeChildren = function (dw, dh) {
+            if (this._layout == fgui.GroupLayoutType.None || (this._updating & 2) != 0 || this._parent == null)
+                return;
+            this._updating |= 2;
+            if (this._boundsChanged) {
+                this._boundsChanged = false;
+                if (!this._autoSizeDisabled) {
+                    this.updateBounds();
+                    return;
+                }
+            }
+            var cnt = this._parent.numChildren;
+            var i;
+            var child;
+            if (!this._percentReady) {
+                this._percentReady = true;
+                this._numChildren = 0;
+                this._totalSize = 0;
+                this._mainChildIndex = -1;
+                var j = 0;
+                for (i = 0; i < cnt; i++) {
+                    child = this._parent.getChildAt(i);
+                    if (child.group != this)
+                        continue;
+                    if (!this._excludeInvisibles || child.internalVisible3) {
+                        if (j == this._mainGridIndex)
+                            this._mainChildIndex = i;
+                        this._numChildren++;
+                        if (this._layout == 1)
+                            this._totalSize += child.width;
+                        else
+                            this._totalSize += child.height;
+                    }
+                    j++;
+                }
+                if (this._mainChildIndex != -1) {
+                    if (this._layout == 1) {
+                        child = this._parent.getChildAt(this._mainChildIndex);
+                        this._totalSize += this._mainGridMinSize - child.width;
+                        child._sizePercentInGroup = this._mainGridMinSize / this._totalSize;
+                    }
+                    else {
+                        child = this._parent.getChildAt(this._mainChildIndex);
+                        this._totalSize += this._mainGridMinSize - child.height;
+                        child._sizePercentInGroup = this._mainGridMinSize / this._totalSize;
+                    }
+                }
+                for (i = 0; i < cnt; i++) {
+                    child = this._parent.getChildAt(i);
+                    if (child.group != this)
+                        continue;
+                    if (i == this._mainChildIndex)
+                        continue;
+                    if (this._totalSize > 0)
+                        child._sizePercentInGroup = (this._layout == 1 ? child.width : child.height) / this._totalSize;
+                    else
+                        child._sizePercentInGroup = 0;
+                }
+            }
+            var remainSize = 0;
+            var remainPercent = 1;
+            var priorHandled = false;
+            if (this._layout == 1) {
+                remainSize = this.width - (this._numChildren - 1) * this._columnGap;
+                if (this._mainChildIndex != -1 && remainSize >= this._totalSize) {
+                    child = this._parent.getChildAt(this._mainChildIndex);
+                    child.setSize(remainSize - (this._totalSize - this._mainGridMinSize), child._rawHeight + dh, true);
+                    remainSize -= child.width;
+                    remainPercent -= child._sizePercentInGroup;
+                    priorHandled = true;
+                }
+                var curX = this.x;
+                for (i = 0; i < cnt; i++) {
+                    child = this._parent.getChildAt(i);
+                    if (child.group != this)
+                        continue;
+                    if (this._excludeInvisibles && !child.internalVisible3) {
+                        child.setSize(child._rawWidth, child._rawHeight + dh, true);
+                        continue;
+                    }
+                    if (!priorHandled || i != this._mainChildIndex) {
+                        child.setSize(Math.round(child._sizePercentInGroup / remainPercent * remainSize), child._rawHeight + dh, true);
+                        remainPercent -= child._sizePercentInGroup;
+                        remainSize -= child.width;
+                    }
+                    child.xMin = curX;
+                    if (child.width != 0)
+                        curX += child.width + this._columnGap;
+                }
+            }
+            else {
+                remainSize = this.height - (this._numChildren - 1) * this._lineGap;
+                if (this._mainChildIndex != -1 && remainSize >= this._totalSize) {
+                    child = this._parent.getChildAt(this._mainChildIndex);
+                    child.setSize(child._rawWidth + dw, remainSize - (this._totalSize - this._mainGridMinSize), true);
+                    remainSize -= child.height;
+                    remainPercent -= child._sizePercentInGroup;
+                    priorHandled = true;
+                }
+                var curY = this.y;
+                for (i = 0; i < cnt; i++) {
+                    child = this._parent.getChildAt(i);
+                    if (child.group != this)
+                        continue;
+                    if (this._excludeInvisibles && !child.internalVisible3) {
+                        child.setSize(child._rawWidth + dw, child._rawHeight, true);
+                        continue;
+                    }
+                    if (!priorHandled || i != this._mainChildIndex) {
+                        child.setSize(child._rawWidth + dw, Math.round(child._sizePercentInGroup / remainPercent * remainSize), true);
+                        remainPercent -= child._sizePercentInGroup;
+                        remainSize -= child.height;
+                    }
+                    child.yMin = curY;
+                    if (child.height != 0)
+                        curY += child.height + this._lineGap;
+                }
+            }
+            this._updating &= 1;
+        };
+        GGroup.prototype.handleAlphaChanged = function () {
+            if (this._underConstruct)
+                return;
+            var cnt = this._parent.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                var child = this._parent.getChildAt(i);
+                if (child.group == this)
+                    child.alpha = this.alpha;
+            }
+        };
+        GGroup.prototype.handleVisibleChanged = function () {
+            if (!this._parent)
+                return;
+            var cnt = this._parent.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                var child = this._parent.getChildAt(i);
+                if (child.group == this)
+                    child.handleVisibleChanged();
+            }
+        };
+        GGroup.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            this._layout = buffer.readByte();
+            this._lineGap = buffer.readInt();
+            this._columnGap = buffer.readInt();
+            if (buffer.version >= 2) {
+                this._excludeInvisibles = buffer.readBool();
+                this._autoSizeDisabled = buffer.readBool();
+                this._mainChildIndex = buffer.readInt();
+            }
+        };
+        GGroup.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            if (!this.visible)
+                this.handleVisibleChanged();
+        };
+        return GGroup;
+    }(fgui.GObject));
+    fgui.GGroup = GGroup;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GImage = (function (_super_1) {
+        __extends(GImage, _super_1);
+        function GImage() {
+            var _this = _super_1.call(this) || this;
+            _this._flip = fgui.FlipType.None;
+            return _this;
+        }
+        Object.defineProperty(GImage.prototype, "color", {
+            get: function () {
+                return this._content.color;
+            },
+            set: function (value) {
+                if (this._content.color != value) {
+                    this._content.color = value;
+                    this.updateGear(4);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GImage.prototype, "flip", {
+            get: function () {
+                return this._flip;
+            },
+            set: function (value) {
+                if (this._flip != value) {
+                    this._flip = value;
+                    var sx = 1, sy = 1;
+                    if (this._flip == fgui.FlipType.Horizontal || this._flip == fgui.FlipType.Both)
+                        sx = -1;
+                    if (this._flip == fgui.FlipType.Vertical || this._flip == fgui.FlipType.Both)
+                        sy = -1;
+                    this._content.scaleX = sx;
+                    this._content.scaleY = sy;
+                    this.handleXYChanged();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GImage.prototype, "fillMethod", {
+            get: function () {
+                return this._content.fillMethod;
+            },
+            set: function (value) {
+                this._content.fillMethod = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GImage.prototype, "fillOrigin", {
+            get: function () {
+                return this._content.fillOrigin;
+            },
+            set: function (value) {
+                this._content.fillOrigin = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GImage.prototype, "fillClockwise", {
+            get: function () {
+                return this._content.fillClockwise;
+            },
+            set: function (value) {
+                this._content.fillClockwise = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GImage.prototype, "fillAmount", {
+            get: function () {
+                return this._content.fillAmount;
+            },
+            set: function (value) {
+                this._content.fillAmount = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GImage.prototype, "texture", {
+            get: function () {
+                return this._content.texture;
+            },
+            set: function (value) {
+                if (value) {
+                    this.sourceWidth = value.textureWidth;
+                    this.sourceHeight = value.textureHeight;
+                }
+                else {
+                    this.sourceWidth = 0;
+                    this.sourceHeight = 0;
+                }
+                this.initWidth = this.sourceWidth;
+                this.initHeight = this.sourceHeight;
+                this._content.scale9Grid = null;
+                this._content.fillMode = egret.BitmapFillMode.SCALE;
+                this._content.texture = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GImage.prototype.createDisplayObject = function () {
+            this._content = new fgui.Image();
+            this._content.touchEnabled = false;
+            this.setDisplayObject(this._content);
+        };
+        GImage.prototype.constructFromResource = function () {
+            var contentItem = this.packageItem.getBranch();
+            this.sourceWidth = contentItem.width;
+            this.sourceHeight = contentItem.height;
+            this.initWidth = this.sourceWidth;
+            this.initHeight = this.sourceHeight;
+            this.setSize(this.sourceWidth, this.sourceHeight);
+            contentItem = contentItem.getHighResolution();
+            contentItem.load();
+            this._content.scale9Grid = contentItem.scale9Grid;
+            this._content.smoothing = contentItem.smoothing;
+            if (contentItem.scaleByTile)
+                this._content.fillMode = egret.BitmapFillMode.REPEAT;
+            this.setSize(this.sourceWidth, this.sourceHeight);
+            this._content.texture = contentItem.asset;
+        };
+        GImage.prototype.handleXYChanged = function () {
+            _super_1.prototype.handleXYChanged.call(this);
+            if (this._flip != fgui.FlipType.None) {
+                if (this._content.scaleX == -1)
+                    this._content.x += this.width;
+                if (this._content.scaleY == -1)
+                    this._content.y += this.height;
+            }
+        };
+        GImage.prototype.getProp = function (index) {
+            if (index == fgui.ObjectPropID.Color)
+                return this.color;
+            else
+                return _super_1.prototype.getProp.call(this, index);
+        };
+        GImage.prototype.setProp = function (index, value) {
+            if (index == fgui.ObjectPropID.Color)
+                this.color = value;
+            else
+                _super_1.prototype.setProp.call(this, index, value);
+        };
+        GImage.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            if (buffer.readBool())
+                this.color = buffer.readColor();
+            this.flip = buffer.readByte();
+            this._content.fillMethod = buffer.readByte();
+            if (this._content.fillMethod != 0) {
+                this._content.fillOrigin = buffer.readByte();
+                this._content.fillClockwise = buffer.readBool();
+                this._content.fillAmount = buffer.readFloat();
+            }
+        };
+        return GImage;
+    }(fgui.GObject));
+    fgui.GImage = GImage;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GLabel = (function (_super_1) {
+        __extends(GLabel, _super_1);
+        function GLabel() {
+            return _super_1.call(this) || this;
+        }
+        Object.defineProperty(GLabel.prototype, "icon", {
+            get: function () {
+                if (this._iconObject)
+                    return this._iconObject.icon;
+            },
+            set: function (value) {
+                if (this._iconObject)
+                    this._iconObject.icon = value;
+                this.updateGear(7);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLabel.prototype, "title", {
+            get: function () {
+                if (this._titleObject)
+                    return this._titleObject.text;
+                else
+                    return null;
+            },
+            set: function (value) {
+                if (this._titleObject)
+                    this._titleObject.text = value;
+                this.updateGear(6);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLabel.prototype, "text", {
+            get: function () {
+                return this.title;
+            },
+            set: function (value) {
+                this.title = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLabel.prototype, "titleColor", {
+            get: function () {
+                var tf = this.getTextField();
+                if (tf)
+                    return tf.color;
+                else
+                    return 0;
+            },
+            set: function (value) {
+                var tf = this.getTextField();
+                if (tf)
+                    tf.color = value;
+                this.updateGear(4);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLabel.prototype, "titleFontSize", {
+            get: function () {
+                var tf = this.getTextField();
+                if (tf)
+                    return tf.fontSize;
+                else
+                    return 0;
+            },
+            set: function (value) {
+                var tf = this.getTextField();
+                if (tf)
+                    tf.fontSize = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLabel.prototype, "editable", {
+            get: function () {
+                if (this._titleObject && (this._titleObject instanceof fgui.GTextInput))
+                    return this._titleObject.asTextInput.editable;
+                else
+                    return false;
+            },
+            set: function (val) {
+                if (this._titleObject)
+                    this._titleObject.asTextInput.editable = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GLabel.prototype.getTextField = function () {
+            if (this._titleObject instanceof fgui.GTextField)
+                return this._titleObject;
+            else if ((this._titleObject instanceof GLabel) || (this._titleObject instanceof fgui.GButton))
+                return this._titleObject.getTextField();
+            else
+                return null;
+        };
+        GLabel.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    return this.titleColor;
+                case fgui.ObjectPropID.OutlineColor:
+                    {
+                        var tf = this.getTextField();
+                        if (tf)
+                            return tf.strokeColor;
+                        else
+                            return 0;
+                    }
+                case fgui.ObjectPropID.FontSize:
+                    return this.titleFontSize;
+                default:
+                    return _super_1.prototype.getProp.call(this, index);
+            }
+        };
+        GLabel.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    this.titleColor = value;
+                    break;
+                case fgui.ObjectPropID.OutlineColor:
+                    {
+                        var tf = this.getTextField();
+                        if (tf)
+                            tf.strokeColor = value;
+                    }
+                    break;
+                case fgui.ObjectPropID.FontSize:
+                    this.titleFontSize = value;
+                    break;
+                default:
+                    _super_1.prototype.setProp.call(this, index, value);
+                    break;
+            }
+        };
+        GLabel.prototype.constructExtension = function (buffer) {
+            this._titleObject = this.getChild("title");
+            this._iconObject = this.getChild("icon");
+        };
+        GLabel.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            if (!buffer.seek(beginPos, 6))
+                return;
+            if (buffer.readByte() != this.packageItem.objectType)
+                return;
+            var str;
+            str = buffer.readS();
+            if (str != null)
+                this.title = str;
+            str = buffer.readS();
+            if (str != null)
+                this.icon = str;
+            if (buffer.readBool())
+                this.titleColor = buffer.readColor();
+            var iv = buffer.readInt();
+            if (iv != 0)
+                this.titleFontSize = iv;
+            if (buffer.readBool()) {
+                var input = this.getTextField();
+                if (input instanceof fgui.GTextInput) {
+                    str = buffer.readS();
+                    if (str != null)
+                        input.promptText = str;
+                    str = buffer.readS();
+                    if (str != null)
+                        input.restrict = str;
+                    iv = buffer.readInt();
+                    if (iv != 0)
+                        input.maxLength = iv;
+                    iv = buffer.readInt();
+                    if (iv != 0) {
+                    }
+                    if (buffer.readBool())
+                        input.password = true;
+                }
+                else
+                    buffer.skip(13);
+            }
+        };
+        return GLabel;
+    }(fgui.GComponent));
+    fgui.GLabel = GLabel;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GList = (function (_super_1) {
+        __extends(GList, _super_1);
+        function GList() {
+            var _this = _super_1.call(this) || this;
+            _this.scrollItemToViewOnClick = true;
+            _this.foldInvisibleItems = false;
+            _this._lineCount = 0;
+            _this._columnCount = 0;
+            _this._lineGap = 0;
+            _this._columnGap = 0;
+            _this._lastSelectedIndex = 0;
+            _this._numItems = 0;
+            _this._realNumItems = 0;
+            _this._firstIndex = 0;
+            _this._curLineItemCount = 0;
+            _this._curLineItemCount2 = 0;
+            _this._virtualListChanged = 0;
+            _this.itemInfoVer = 0;
+            _this._trackBounds = true;
+            _this._pool = new fgui.GObjectPool();
+            _this._layout = fgui.ListLayoutType.SingleColumn;
+            _this._autoResizeItem = true;
+            _this._lastSelectedIndex = -1;
+            _this._selectionMode = fgui.ListSelectionMode.Single;
+            _this.opaque = true;
+            _this._align = fgui.AlignType.Left;
+            _this._verticalAlign = fgui.VertAlignType.Top;
+            _this._container = new egret.DisplayObjectContainer();
+            _this._rootContainer.addChild(_this._container);
+            return _this;
+        }
+        GList.prototype.dispose = function () {
+            this._pool.clear();
+            _super_1.prototype.dispose.call(this);
+        };
+        Object.defineProperty(GList.prototype, "layout", {
+            get: function () {
+                return this._layout;
+            },
+            set: function (value) {
+                if (this._layout != value) {
+                    this._layout = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "lineCount", {
+            get: function () {
+                return this._lineCount;
+            },
+            set: function (value) {
+                if (this._lineCount != value) {
+                    this._lineCount = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "columnCount", {
+            get: function () {
+                return this._columnCount;
+            },
+            set: function (value) {
+                if (this._columnCount != value) {
+                    this._columnCount = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "lineGap", {
+            get: function () {
+                return this._lineGap;
+            },
+            set: function (value) {
+                if (this._lineGap != value) {
+                    this._lineGap = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "columnGap", {
+            get: function () {
+                return this._columnGap;
+            },
+            set: function (value) {
+                if (this._columnGap != value) {
+                    this._columnGap = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "align", {
+            get: function () {
+                return this._align;
+            },
+            set: function (value) {
+                if (this._align != value) {
+                    this._align = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "verticalAlign", {
+            get: function () {
+                return this._verticalAlign;
+            },
+            set: function (value) {
+                if (this._verticalAlign != value) {
+                    this._verticalAlign = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "virtualItemSize", {
+            get: function () {
+                return this._itemSize;
+            },
+            set: function (value) {
+                if (this._virtual) {
+                    if (!this._itemSize)
+                        this._itemSize = new egret.Point();
+                    this._itemSize.copyFrom(value);
+                    this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "defaultItem", {
+            get: function () {
+                return this._defaultItem;
+            },
+            set: function (val) {
+                this._defaultItem = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "autoResizeItem", {
+            get: function () {
+                return this._autoResizeItem;
+            },
+            set: function (value) {
+                if (this._autoResizeItem != value) {
+                    this._autoResizeItem = value;
+                    this.setBoundsChangedFlag();
+                    if (this._virtual)
+                        this.setVirtualListChangedFlag(true);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "selectionMode", {
+            get: function () {
+                return this._selectionMode;
+            },
+            set: function (value) {
+                this._selectionMode = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "selectionController", {
+            get: function () {
+                return this._selectionController;
+            },
+            set: function (value) {
+                this._selectionController = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GList.prototype, "itemPool", {
+            get: function () {
+                return this._pool;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GList.prototype.getFromPool = function (url) {
+            if (!url)
+                url = this._defaultItem;
+            var obj = this._pool.getObject(url);
+            if (obj)
+                obj.visible = true;
+            return obj;
+        };
+        GList.prototype.returnToPool = function (obj) {
+            obj.displayObject.cacheAsBitmap = false;
+            this._pool.returnObject(obj);
+        };
+        GList.prototype.addChildAt = function (child, index) {
+            _super_1.prototype.addChildAt.call(this, child, index);
+            if (child instanceof fgui.GButton) {
+                child.selected = false;
+                child.changeStateOnClick = false;
+            }
+            child.addEventListener(egret.TouchEvent.TOUCH_TAP, this.__clickItem, this);
+            return child;
+        };
+        GList.prototype.addItem = function (url) {
+            if (!url)
+                url = this._defaultItem;
+            return this.addChild(fgui.UIPackage.createObjectFromURL(url));
+        };
+        GList.prototype.addItemFromPool = function (url) {
+            return this.addChild(this.getFromPool(url));
+        };
+        GList.prototype.removeChildAt = function (index, dispose) {
+            var child = _super_1.prototype.removeChildAt.call(this, index, dispose);
+            child.removeEventListener(egret.TouchEvent.TOUCH_TAP, this.__clickItem, this);
+            return child;
+        };
+        GList.prototype.removeChildToPoolAt = function (index) {
+            var child = _super_1.prototype.removeChildAt.call(this, index);
+            this.returnToPool(child);
+        };
+        GList.prototype.removeChildToPool = function (child) {
+            _super_1.prototype.removeChild.call(this, child);
+            this.returnToPool(child);
+        };
+        GList.prototype.removeChildrenToPool = function (beginIndex, endIndex) {
+            if (beginIndex == undefined)
+                beginIndex = 0;
+            if (endIndex == undefined)
+                endIndex = -1;
+            if (endIndex < 0 || endIndex >= this._children.length)
+                endIndex = this._children.length - 1;
+            for (var i = beginIndex; i <= endIndex; ++i)
+                this.removeChildToPoolAt(beginIndex);
+        };
+        Object.defineProperty(GList.prototype, "selectedIndex", {
+            get: function () {
+                var i;
+                if (this._virtual) {
+                    for (i = 0; i < this._realNumItems; i++) {
+                        var ii = this._virtualItems[i];
+                        if ((ii.obj instanceof fgui.GButton) && ii.obj.selected
+                            || ii.obj == null && ii.selected) {
+                            if (this._loop)
+                                return i % this._numItems;
+                            else
+                                return i;
+                        }
+                    }
+                }
+                else {
+                    var cnt = this._children.length;
+                    for (i = 0; i < cnt; i++) {
+                        var obj = this._children[i];
+                        if ((obj instanceof fgui.GButton) && obj.selected)
+                            return i;
+                    }
+                }
+                return -1;
+            },
+            set: function (value) {
+                if (value >= 0 && value < this.numItems) {
+                    if (this._selectionMode != fgui.ListSelectionMode.Single)
+                        this.clearSelection();
+                    this.addSelection(value);
+                }
+                else
+                    this.clearSelection();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GList.prototype.getSelection = function (result) {
+            if (!result)
+                result = new Array();
+            var i;
+            if (this._virtual) {
+                for (i = 0; i < this._realNumItems; i++) {
+                    var ii = this._virtualItems[i];
+                    if ((ii.obj instanceof fgui.GButton) && ii.obj.selected
+                        || ii.obj == null && ii.selected) {
+                        var j = i;
+                        if (this._loop) {
+                            j = i % this._numItems;
+                            if (result.indexOf(j) != -1)
+                                continue;
+                        }
+                        result.push(j);
+                    }
+                }
+            }
+            else {
+                var cnt = this._children.length;
+                for (i = 0; i < cnt; i++) {
+                    var obj = this._children[i];
+                    if ((obj instanceof fgui.GButton) && obj.selected)
+                        result.push(i);
+                }
+            }
+            return result;
+        };
+        GList.prototype.addSelection = function (index, scrollItToView) {
+            if (this._selectionMode == fgui.ListSelectionMode.None)
+                return;
+            this.checkVirtualList();
+            if (this._selectionMode == fgui.ListSelectionMode.Single)
+                this.clearSelection();
+            if (scrollItToView)
+                this.scrollToView(index);
+            this._lastSelectedIndex = index;
+            var obj;
+            if (this._virtual) {
+                var ii = this._virtualItems[index];
+                if (ii.obj)
+                    obj = ii.obj;
+                ii.selected = true;
+            }
+            else
+                obj = this.getChildAt(index);
+            if ((obj instanceof fgui.GButton) && !obj.selected) {
+                obj.selected = true;
+                this.updateSelectionController(index);
+            }
+        };
+        GList.prototype.removeSelection = function (index) {
+            if (this._selectionMode == fgui.ListSelectionMode.None)
+                return;
+            var obj;
+            if (this._virtual) {
+                var ii = this._virtualItems[index];
+                if (ii.obj)
+                    obj = ii.obj;
+                ii.selected = false;
+            }
+            else
+                obj = this.getChildAt(index);
+            if (obj instanceof fgui.GButton)
+                obj.selected = false;
+        };
+        GList.prototype.clearSelection = function () {
+            var i;
+            if (this._virtual) {
+                for (i = 0; i < this._realNumItems; i++) {
+                    var ii = this._virtualItems[i];
+                    if (ii.obj instanceof fgui.GButton)
+                        ii.obj.selected = false;
+                    ii.selected = false;
+                }
+            }
+            else {
+                var cnt = this._children.length;
+                for (i = 0; i < cnt; i++) {
+                    var obj = this._children[i];
+                    if (obj instanceof fgui.GButton)
+                        obj.selected = false;
+                }
+            }
+        };
+        GList.prototype.clearSelectionExcept = function (g) {
+            var i;
+            if (this._virtual) {
+                for (i = 0; i < this._realNumItems; i++) {
+                    var ii = this._virtualItems[i];
+                    if (ii.obj != g) {
+                        if ((ii.obj instanceof fgui.GButton))
+                            ii.obj.selected = false;
+                        ii.selected = false;
+                    }
+                }
+            }
+            else {
+                var cnt = this._children.length;
+                for (i = 0; i < cnt; i++) {
+                    var obj = this._children[i];
+                    if ((obj instanceof fgui.GButton) && obj != g)
+                        obj.selected = false;
+                }
+            }
+        };
+        GList.prototype.selectAll = function () {
+            this.checkVirtualList();
+            var last = -1;
+            var i;
+            if (this._virtual) {
+                for (i = 0; i < this._realNumItems; i++) {
+                    var ii = this._virtualItems[i];
+                    if ((ii.obj instanceof fgui.GButton) && !ii.obj.selected) {
+                        ii.obj.selected = true;
+                        last = i;
+                    }
+                    ii.selected = true;
+                }
+            }
+            else {
+                var cnt = this._children.length;
+                for (i = 0; i < cnt; i++) {
+                    var obj = this._children[i];
+                    if ((obj instanceof fgui.GButton) && !obj.selected) {
+                        obj.selected = true;
+                        last = i;
+                    }
+                }
+            }
+            if (last != -1)
+                this.updateSelectionController(last);
+        };
+        GList.prototype.selectNone = function () {
+            this.clearSelection();
+        };
+        GList.prototype.selectReverse = function () {
+            this.checkVirtualList();
+            var last = -1;
+            var i;
+            if (this._virtual) {
+                for (i = 0; i < this._realNumItems; i++) {
+                    var ii = this._virtualItems[i];
+                    if (ii.obj instanceof fgui.GButton) {
+                        ii.obj.selected = !ii.obj.selected;
+                        if (ii.obj.selected)
+                            last = i;
+                    }
+                    ii.selected = !ii.selected;
+                }
+            }
+            else {
+                var cnt = this._children.length;
+                for (i = 0; i < cnt; i++) {
+                    var obj = this._children[i];
+                    if (obj instanceof fgui.GButton) {
+                        obj.selected = !obj.selected;
+                        if (obj.selected)
+                            last = i;
+                    }
+                }
+            }
+            if (last != -1)
+                this.updateSelectionController(last);
+        };
+        GList.prototype.handleArrowKey = function (dir) {
+            var index = this.selectedIndex;
+            if (index == -1)
+                return;
+            switch (dir) {
+                case 1:
+                    if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowVertical) {
+                        index--;
+                        if (index >= 0) {
+                            this.clearSelection();
+                            this.addSelection(index, true);
+                        }
+                    }
+                    else if (this._layout == fgui.ListLayoutType.FlowHorizontal || this._layout == fgui.ListLayoutType.Pagination) {
+                        var current = this._children[index];
+                        var k = 0;
+                        for (var i = index - 1; i >= 0; i--) {
+                            var obj = this._children[i];
+                            if (obj.y != current.y) {
+                                current = obj;
+                                break;
+                            }
+                            k++;
+                        }
+                        for (; i >= 0; i--) {
+                            obj = this._children[i];
+                            if (obj.y != current.y) {
+                                this.clearSelection();
+                                this.addSelection(i + k + 1, true);
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                case 3:
+                    if (this._layout == fgui.ListLayoutType.SingleRow || this._layout == fgui.ListLayoutType.FlowHorizontal || this._layout == fgui.ListLayoutType.Pagination) {
+                        index++;
+                        if (index < this._children.length) {
+                            this.clearSelection();
+                            this.addSelection(index, true);
+                        }
+                    }
+                    else if (this._layout == fgui.ListLayoutType.FlowVertical) {
+                        current = this._children[index];
+                        k = 0;
+                        var cnt = this._children.length;
+                        for (i = index + 1; i < cnt; i++) {
+                            obj = this._children[i];
+                            if (obj.x != current.x) {
+                                current = obj;
+                                break;
+                            }
+                            k++;
+                        }
+                        for (; i < cnt; i++) {
+                            obj = this._children[i];
+                            if (obj.x != current.x) {
+                                this.clearSelection();
+                                this.addSelection(i - k - 1, true);
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                case 5:
+                    if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowVertical) {
+                        index++;
+                        if (index < this._children.length) {
+                            this.clearSelection();
+                            this.addSelection(index, true);
+                        }
+                    }
+                    else if (this._layout == fgui.ListLayoutType.FlowHorizontal || this._layout == fgui.ListLayoutType.Pagination) {
+                        current = this._children[index];
+                        k = 0;
+                        cnt = this._children.length;
+                        for (i = index + 1; i < cnt; i++) {
+                            obj = this._children[i];
+                            if (obj.y != current.y) {
+                                current = obj;
+                                break;
+                            }
+                            k++;
+                        }
+                        for (; i < cnt; i++) {
+                            obj = this._children[i];
+                            if (obj.y != current.y) {
+                                this.clearSelection();
+                                this.addSelection(i - k - 1, true);
+                                break;
+                            }
+                        }
+                    }
+                    break;
+                case 7:
+                    if (this._layout == fgui.ListLayoutType.SingleRow || this._layout == fgui.ListLayoutType.FlowHorizontal || this._layout == fgui.ListLayoutType.Pagination) {
+                        index--;
+                        if (index >= 0) {
+                            this.clearSelection();
+                            this.addSelection(index, true);
+                        }
+                    }
+                    else if (this._layout == fgui.ListLayoutType.FlowVertical) {
+                        current = this._children[index];
+                        k = 0;
+                        for (i = index - 1; i >= 0; i--) {
+                            obj = this._children[i];
+                            if (obj.x != current.x) {
+                                current = obj;
+                                break;
+                            }
+                            k++;
+                        }
+                        for (; i >= 0; i--) {
+                            obj = this._children[i];
+                            if (obj.x != current.x) {
+                                this.clearSelection();
+                                this.addSelection(i + k + 1, true);
+                                break;
+                            }
+                        }
+                    }
+                    break;
+            }
+        };
+        GList.prototype.__clickItem = function (evt) {
+            if (this._scrollPane && this._scrollPane.isDragged)
+                return;
+            var item = (evt.currentTarget);
+            this.setSelectionOnEvent(item);
+            if (this._scrollPane && this.scrollItemToViewOnClick)
+                this._scrollPane.scrollToView(item, true);
+            var ie = new fgui.ItemEvent(fgui.ItemEvent.CLICK, item);
+            ie.stageX = evt.stageX;
+            ie.stageY = evt.stageY;
+            this.dispatchItemEvent(ie);
+        };
+        GList.prototype.dispatchItemEvent = function (evt) {
+            this.dispatchEvent(evt);
+        };
+        GList.prototype.setSelectionOnEvent = function (item) {
+            if (!(item instanceof fgui.GButton) || this._selectionMode == fgui.ListSelectionMode.None)
+                return;
+            var dontChangeLastIndex = false;
+            var index = this.childIndexToItemIndex(this.getChildIndex(item));
+            if (this._selectionMode == fgui.ListSelectionMode.Single) {
+                if (!item.selected) {
+                    this.clearSelectionExcept(item);
+                    item.selected = true;
+                }
+            }
+            else {
+                if (fgui.GRoot.shiftKeyDown) {
+                    if (!item.selected) {
+                        if (this._lastSelectedIndex != -1) {
+                            var min = Math.min(this._lastSelectedIndex, index);
+                            var max = Math.max(this._lastSelectedIndex, index);
+                            max = Math.min(max, this.numItems - 1);
+                            var i;
+                            if (this._virtual) {
+                                for (i = min; i <= max; i++) {
+                                    var ii = this._virtualItems[i];
+                                    if (ii.obj instanceof fgui.GButton)
+                                        ii.obj.selected = true;
+                                    ii.selected = true;
+                                }
+                            }
+                            else {
+                                for (i = min; i <= max; i++) {
+                                    var obj = this.getChildAt(i);
+                                    if (obj instanceof fgui.GButton)
+                                        obj.selected = true;
+                                }
+                            }
+                            dontChangeLastIndex = true;
+                        }
+                        else {
+                            item.selected = true;
+                        }
+                    }
+                }
+                else if (fgui.GRoot.ctrlKeyDown || this._selectionMode == fgui.ListSelectionMode.Multiple_SingleClick) {
+                    item.selected = !item.selected;
+                }
+                else {
+                    if (!item.selected) {
+                        this.clearSelectionExcept(item);
+                        item.selected = true;
+                    }
+                    else
+                        this.clearSelectionExcept(item);
+                }
+            }
+            if (!dontChangeLastIndex)
+                this._lastSelectedIndex = index;
+            if (item.selected)
+                this.updateSelectionController(index);
+        };
+        GList.prototype.resizeToFit = function (itemCount, minSize) {
+            if (itemCount === void 0) { itemCount = Number.POSITIVE_INFINITY; }
+            if (minSize === void 0) { minSize = 0; }
+            this.ensureBoundsCorrect();
+            var curCount = this.numItems;
+            if (itemCount > curCount)
+                itemCount = curCount;
+            if (this._virtual) {
+                var lineCount = Math.ceil(itemCount / this._curLineItemCount);
+                if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal)
+                    this.viewHeight = lineCount * this._itemSize.y + Math.max(0, lineCount - 1) * this._lineGap;
+                else
+                    this.viewWidth = lineCount * this._itemSize.x + Math.max(0, lineCount - 1) * this._columnGap;
+            }
+            else if (itemCount == 0) {
+                if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal)
+                    this.viewHeight = minSize;
+                else
+                    this.viewWidth = minSize;
+            }
+            else {
+                var i = itemCount - 1;
+                var obj;
+                while (i >= 0) {
+                    obj = this.getChildAt(i);
+                    if (!this.foldInvisibleItems || obj.visible)
+                        break;
+                    i--;
+                }
+                if (i < 0) {
+                    if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal)
+                        this.viewHeight = minSize;
+                    else
+                        this.viewWidth = minSize;
+                }
+                else {
+                    var size = 0;
+                    if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                        size = obj.y + obj.height;
+                        if (size < minSize)
+                            size = minSize;
+                        this.viewHeight = size;
+                    }
+                    else {
+                        size = obj.x + obj.width;
+                        if (size < minSize)
+                            size = minSize;
+                        this.viewWidth = size;
+                    }
+                }
+            }
+        };
+        GList.prototype.getMaxItemWidth = function () {
+            var cnt = this._children.length;
+            var max = 0;
+            for (var i = 0; i < cnt; i++) {
+                var child = this.getChildAt(i);
+                if (child.width > max)
+                    max = child.width;
+            }
+            return max;
+        };
+        GList.prototype.handleSizeChanged = function () {
+            _super_1.prototype.handleSizeChanged.call(this);
+            this.setBoundsChangedFlag();
+            if (this._virtual)
+                this.setVirtualListChangedFlag(true);
+        };
+        GList.prototype.handleControllerChanged = function (c) {
+            _super_1.prototype.handleControllerChanged.call(this, c);
+            if (this._selectionController == c)
+                this.selectedIndex = c.selectedIndex;
+        };
+        GList.prototype.updateSelectionController = function (index) {
+            if (this._selectionController && !this._selectionController.changing
+                && index < this._selectionController.pageCount) {
+                var c = this._selectionController;
+                this._selectionController = null;
+                c.selectedIndex = index;
+                this._selectionController = c;
+            }
+        };
+        GList.prototype.getSnappingPosition = function (xValue, yValue, result) {
+            if (this._virtual) {
+                if (!result)
+                    result = new egret.Point();
+                var saved;
+                var index;
+                if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                    saved = yValue;
+                    s_n = yValue;
+                    index = this.getIndexOnPos1(false);
+                    yValue = s_n;
+                    if (index < this._virtualItems.length && saved - yValue > this._virtualItems[index].height / 2 && index < this._realNumItems)
+                        yValue += this._virtualItems[index].height + this._lineGap;
+                }
+                else if (this._layout == fgui.ListLayoutType.SingleRow || this._layout == fgui.ListLayoutType.FlowVertical) {
+                    saved = xValue;
+                    s_n = xValue;
+                    index = this.getIndexOnPos2(false);
+                    xValue = s_n;
+                    if (index < this._virtualItems.length && saved - xValue > this._virtualItems[index].width / 2 && index < this._realNumItems)
+                        xValue += this._virtualItems[index].width + this._columnGap;
+                }
+                else {
+                    saved = xValue;
+                    s_n = xValue;
+                    index = this.getIndexOnPos3(false);
+                    xValue = s_n;
+                    if (index < this._virtualItems.length && saved - xValue > this._virtualItems[index].width / 2 && index < this._realNumItems)
+                        xValue += this._virtualItems[index].width + this._columnGap;
+                }
+                result.x = xValue;
+                result.y = yValue;
+                return result;
+            }
+            else {
+                return _super_1.prototype.getSnappingPosition.call(this, xValue, yValue, result);
+            }
+        };
+        GList.prototype.scrollToView = function (index, ani, setFirst) {
+            if (this._virtual) {
+                if (this._numItems == 0)
+                    return;
+                this.checkVirtualList();
+                if (index >= this._virtualItems.length)
+                    throw "Invalid child index: " + index + ">" + this._virtualItems.length;
+                if (this._loop)
+                    index = Math.floor(this._firstIndex / this._numItems) * this._numItems + index;
+                var rect;
+                var ii = this._virtualItems[index];
+                var pos = 0;
+                var i;
+                if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                    for (i = this._curLineItemCount - 1; i < index; i += this._curLineItemCount)
+                        pos += this._virtualItems[i].height + this._lineGap;
+                    rect = new egret.Rectangle(0, pos, this._itemSize.x, ii.height);
+                }
+                else if (this._layout == fgui.ListLayoutType.SingleRow || this._layout == fgui.ListLayoutType.FlowVertical) {
+                    for (i = this._curLineItemCount - 1; i < index; i += this._curLineItemCount)
+                        pos += this._virtualItems[i].width + this._columnGap;
+                    rect = new egret.Rectangle(pos, 0, ii.width, this._itemSize.y);
+                }
+                else {
+                    var page = index / (this._curLineItemCount * this._curLineItemCount2);
+                    rect = new egret.Rectangle(page * this.viewWidth + (index % this._curLineItemCount) * (ii.width + this._columnGap), (index / this._curLineItemCount) % this._curLineItemCount2 * (ii.height + this._lineGap), ii.width, ii.height);
+                }
+                if (this._scrollPane)
+                    this._scrollPane.scrollToView(rect, ani, setFirst);
+            }
+            else {
+                var obj = this.getChildAt(index);
+                if (obj) {
+                    if (this._scrollPane)
+                        this._scrollPane.scrollToView(obj, ani, setFirst);
+                    else if (this.parent && this.parent.scrollPane)
+                        this.parent.scrollPane.scrollToView(obj, ani, setFirst);
+                }
+            }
+        };
+        GList.prototype.getFirstChildInView = function () {
+            return this.childIndexToItemIndex(_super_1.prototype.getFirstChildInView.call(this));
+        };
+        GList.prototype.childIndexToItemIndex = function (index) {
+            if (!this._virtual)
+                return index;
+            if (this._layout == fgui.ListLayoutType.Pagination) {
+                for (var i = this._firstIndex; i < this._realNumItems; i++) {
+                    if (this._virtualItems[i].obj) {
+                        index--;
+                        if (index < 0)
+                            return i;
+                    }
+                }
+                return index;
+            }
+            else {
+                index += this._firstIndex;
+                if (this._loop && this._numItems > 0)
+                    index = index % this._numItems;
+                return index;
+            }
+        };
+        GList.prototype.itemIndexToChildIndex = function (index) {
+            if (!this._virtual)
+                return index;
+            if (this._layout == fgui.ListLayoutType.Pagination) {
+                return this.getChildIndex(this._virtualItems[index].obj);
+            }
+            else {
+                if (this._loop && this._numItems > 0) {
+                    var j = this._firstIndex % this._numItems;
+                    if (index >= j)
+                        index = index - j;
+                    else
+                        index = this._numItems - j + index;
+                }
+                else
+                    index -= this._firstIndex;
+                return index;
+            }
+        };
+        GList.prototype.setVirtual = function () {
+            this._setVirtual(false);
+        };
+        GList.prototype.setVirtualAndLoop = function () {
+            this._setVirtual(true);
+        };
+        GList.prototype._setVirtual = function (loop) {
+            if (!this._virtual) {
+                if (this._scrollPane == null)
+                    throw "Virtual list must be scrollable!";
+                if (loop) {
+                    if (this._layout == fgui.ListLayoutType.FlowHorizontal || this._layout == fgui.ListLayoutType.FlowVertical)
+                        throw "Loop list is not supported for FlowHorizontal or FlowVertical layout!";
+                    this._scrollPane.bouncebackEffect = false;
+                }
+                this._virtual = true;
+                this._loop = loop;
+                this._virtualItems = new Array();
+                this.removeChildrenToPool();
+                if (this._itemSize == null) {
+                    this._itemSize = new egret.Point();
+                    var obj = this.getFromPool(null);
+                    if (obj == null) {
+                        throw "Virtual List must have a default list item resource.";
+                    }
+                    else {
+                        this._itemSize.x = obj.width;
+                        this._itemSize.y = obj.height;
+                    }
+                    this.returnToPool(obj);
+                }
+                if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                    this._scrollPane.scrollStep = this._itemSize.y;
+                    if (this._loop)
+                        this._scrollPane._loop = 2;
+                }
+                else {
+                    this._scrollPane.scrollStep = this._itemSize.x;
+                    if (this._loop)
+                        this._scrollPane._loop = 1;
+                }
+                this._scrollPane.addEventListener(fgui.ScrollPane.SCROLL, this.__scrolled, this);
+                this.setVirtualListChangedFlag(true);
+            }
+        };
+        Object.defineProperty(GList.prototype, "numItems", {
+            get: function () {
+                if (this._virtual)
+                    return this._numItems;
+                else
+                    return this._children.length;
+            },
+            set: function (value) {
+                if (this._virtual) {
+                    if (this.itemRenderer == null)
+                        throw "Set itemRenderer first!";
+                    this._numItems = value;
+                    if (this._loop)
+                        this._realNumItems = this._numItems * 6;
+                    else
+                        this._realNumItems = this._numItems;
+                    var oldCount = this._virtualItems.length;
+                    if (this._realNumItems > oldCount) {
+                        for (i = oldCount; i < this._realNumItems; i++) {
+                            var ii = {
+                                width: this._itemSize.x,
+                                height: this._itemSize.y,
+                                updateFlag: 0
+                            };
+                            this._virtualItems.push(ii);
+                        }
+                    }
+                    else {
+                        for (i = this._realNumItems; i < oldCount; i++)
+                            this._virtualItems[i].selected = false;
+                    }
+                    if (this._virtualListChanged != 0)
+                        fgui.GTimers.inst.remove(this._refreshVirtualList, this);
+                    this._refreshVirtualList();
+                }
+                else {
+                    var cnt = this._children.length;
+                    if (value > cnt) {
+                        for (var i = cnt; i < value; i++) {
+                            if (this.itemProvider == null)
+                                this.addItemFromPool();
+                            else
+                                this.addItemFromPool(this.itemProvider.call(this.callbackThisObj, i));
+                        }
+                    }
+                    else {
+                        this.removeChildrenToPool(value, cnt);
+                    }
+                    if (this.itemRenderer != null) {
+                        for (i = 0; i < value; i++)
+                            this.itemRenderer.call(this.callbackThisObj, i, this.getChildAt(i));
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GList.prototype.refreshVirtualList = function () {
+            this.setVirtualListChangedFlag(false);
+        };
+        GList.prototype.checkVirtualList = function () {
+            if (this._virtualListChanged != 0) {
+                this._refreshVirtualList();
+                fgui.GTimers.inst.remove(this._refreshVirtualList, this);
+            }
+        };
+        GList.prototype.setVirtualListChangedFlag = function (layoutChanged) {
+            if (layoutChanged)
+                this._virtualListChanged = 2;
+            else if (this._virtualListChanged == 0)
+                this._virtualListChanged = 1;
+            fgui.GTimers.inst.callLater(this._refreshVirtualList, this);
+        };
+        GList.prototype._refreshVirtualList = function () {
+            var layoutChanged = this._virtualListChanged == 2;
+            this._virtualListChanged = 0;
+            this._eventLocked = true;
+            if (layoutChanged) {
+                if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.SingleRow)
+                    this._curLineItemCount = 1;
+                else if (this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                    if (this._columnCount > 0)
+                        this._curLineItemCount = this._columnCount;
+                    else {
+                        this._curLineItemCount = Math.floor((this._scrollPane.viewWidth + this._columnGap) / (this._itemSize.x + this._columnGap));
+                        if (this._curLineItemCount <= 0)
+                            this._curLineItemCount = 1;
+                    }
+                }
+                else if (this._layout == fgui.ListLayoutType.FlowVertical) {
+                    if (this._lineCount > 0)
+                        this._curLineItemCount = this._lineCount;
+                    else {
+                        this._curLineItemCount = Math.floor((this._scrollPane.viewHeight + this._lineGap) / (this._itemSize.y + this._lineGap));
+                        if (this._curLineItemCount <= 0)
+                            this._curLineItemCount = 1;
+                    }
+                }
+                else {
+                    if (this._columnCount > 0)
+                        this._curLineItemCount = this._columnCount;
+                    else {
+                        this._curLineItemCount = Math.floor((this._scrollPane.viewWidth + this._columnGap) / (this._itemSize.x + this._columnGap));
+                        if (this._curLineItemCount <= 0)
+                            this._curLineItemCount = 1;
+                    }
+                    if (this._lineCount > 0)
+                        this._curLineItemCount2 = this._lineCount;
+                    else {
+                        this._curLineItemCount2 = Math.floor((this._scrollPane.viewHeight + this._lineGap) / (this._itemSize.y + this._lineGap));
+                        if (this._curLineItemCount2 <= 0)
+                            this._curLineItemCount2 = 1;
+                    }
+                }
+            }
+            var ch = 0, cw = 0;
+            if (this._realNumItems > 0) {
+                var i;
+                var len = Math.ceil(this._realNumItems / this._curLineItemCount) * this._curLineItemCount;
+                var len2 = Math.min(this._curLineItemCount, this._realNumItems);
+                if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                    for (i = 0; i < len; i += this._curLineItemCount)
+                        ch += this._virtualItems[i].height + this._lineGap;
+                    if (ch > 0)
+                        ch -= this._lineGap;
+                    if (this._autoResizeItem)
+                        cw = this._scrollPane.viewWidth;
+                    else {
+                        for (i = 0; i < len2; i++)
+                            cw += this._virtualItems[i].width + this._columnGap;
+                        if (cw > 0)
+                            cw -= this._columnGap;
+                    }
+                }
+                else if (this._layout == fgui.ListLayoutType.SingleRow || this._layout == fgui.ListLayoutType.FlowVertical) {
+                    for (i = 0; i < len; i += this._curLineItemCount)
+                        cw += this._virtualItems[i].width + this._columnGap;
+                    if (cw > 0)
+                        cw -= this._columnGap;
+                    if (this._autoResizeItem)
+                        ch = this._scrollPane.viewHeight;
+                    else {
+                        for (i = 0; i < len2; i++)
+                            ch += this._virtualItems[i].height + this._lineGap;
+                        if (ch > 0)
+                            ch -= this._lineGap;
+                    }
+                }
+                else {
+                    var pageCount = Math.ceil(len / (this._curLineItemCount * this._curLineItemCount2));
+                    cw = pageCount * this.viewWidth;
+                    ch = this.viewHeight;
+                }
+            }
+            this.handleAlign(cw, ch);
+            this._scrollPane.setContentSize(cw, ch);
+            this._eventLocked = false;
+            this.handleScroll(true);
+        };
+        GList.prototype.__scrolled = function (evt) {
+            this.handleScroll(false);
+        };
+        GList.prototype.getIndexOnPos1 = function (forceUpdate) {
+            if (this._realNumItems < this._curLineItemCount) {
+                s_n = 0;
+                return 0;
+            }
+            var i;
+            var pos2;
+            var pos3;
+            if (this.numChildren > 0 && !forceUpdate) {
+                pos2 = this.getChildAt(0).y;
+                if (pos2 > s_n) {
+                    for (i = this._firstIndex - this._curLineItemCount; i >= 0; i -= this._curLineItemCount) {
+                        pos2 -= (this._virtualItems[i].height + this._lineGap);
+                        if (pos2 <= s_n) {
+                            s_n = pos2;
+                            return i;
+                        }
+                    }
+                    s_n = 0;
+                    return 0;
+                }
+                else {
+                    for (i = this._firstIndex; i < this._realNumItems; i += this._curLineItemCount) {
+                        pos3 = pos2 + this._virtualItems[i].height + this._lineGap;
+                        if (pos3 > s_n) {
+                            s_n = pos2;
+                            return i;
+                        }
+                        pos2 = pos3;
+                    }
+                    s_n = pos2;
+                    return this._realNumItems - this._curLineItemCount;
+                }
+            }
+            else {
+                pos2 = 0;
+                for (i = 0; i < this._realNumItems; i += this._curLineItemCount) {
+                    pos3 = pos2 + this._virtualItems[i].height + this._lineGap;
+                    if (pos3 > s_n) {
+                        s_n = pos2;
+                        return i;
+                    }
+                    pos2 = pos3;
+                }
+                s_n = pos2;
+                return this._realNumItems - this._curLineItemCount;
+            }
+        };
+        GList.prototype.getIndexOnPos2 = function (forceUpdate) {
+            if (this._realNumItems < this._curLineItemCount) {
+                s_n = 0;
+                return 0;
+            }
+            var i;
+            var pos2;
+            var pos3;
+            if (this.numChildren > 0 && !forceUpdate) {
+                pos2 = this.getChildAt(0).x;
+                if (pos2 > s_n) {
+                    for (i = this._firstIndex - this._curLineItemCount; i >= 0; i -= this._curLineItemCount) {
+                        pos2 -= (this._virtualItems[i].width + this._columnGap);
+                        if (pos2 <= s_n) {
+                            s_n = pos2;
+                            return i;
+                        }
+                    }
+                    s_n = 0;
+                    return 0;
+                }
+                else {
+                    for (i = this._firstIndex; i < this._realNumItems; i += this._curLineItemCount) {
+                        pos3 = pos2 + this._virtualItems[i].width + this._columnGap;
+                        if (pos3 > s_n) {
+                            s_n = pos2;
+                            return i;
+                        }
+                        pos2 = pos3;
+                    }
+                    s_n = pos2;
+                    return this._realNumItems - this._curLineItemCount;
+                }
+            }
+            else {
+                pos2 = 0;
+                for (i = 0; i < this._realNumItems; i += this._curLineItemCount) {
+                    pos3 = pos2 + this._virtualItems[i].width + this._columnGap;
+                    if (pos3 > s_n) {
+                        s_n = pos2;
+                        return i;
+                    }
+                    pos2 = pos3;
+                }
+                s_n = pos2;
+                return this._realNumItems - this._curLineItemCount;
+            }
+        };
+        GList.prototype.getIndexOnPos3 = function (forceUpdate) {
+            if (this._realNumItems < this._curLineItemCount) {
+                s_n = 0;
+                return 0;
+            }
+            var viewWidth = this.viewWidth;
+            var page = Math.floor(s_n / viewWidth);
+            var startIndex = page * (this._curLineItemCount * this._curLineItemCount2);
+            var pos2 = page * viewWidth;
+            var i;
+            var pos3;
+            for (i = 0; i < this._curLineItemCount; i++) {
+                pos3 = pos2 + this._virtualItems[startIndex + i].width + this._columnGap;
+                if (pos3 > s_n) {
+                    s_n = pos2;
+                    return startIndex + i;
+                }
+                pos2 = pos3;
+            }
+            s_n = pos2;
+            return startIndex + this._curLineItemCount - 1;
+        };
+        GList.prototype.handleScroll = function (forceUpdate) {
+            if (this._eventLocked)
+                return;
+            if (this._layout == fgui.ListLayoutType.SingleColumn || this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                var enterCounter = 0;
+                while (this.handleScroll1(forceUpdate)) {
+                    enterCounter++;
+                    forceUpdate = false;
+                    if (enterCounter > 20) {
+                        console.log("FairyGUI: list will never be filled as the item renderer function always returns a different size.");
+                        break;
+                    }
+                }
+                this.handleArchOrder1();
+            }
+            else if (this._layout == fgui.ListLayoutType.SingleRow || this._layout == fgui.ListLayoutType.FlowVertical) {
+                enterCounter = 0;
+                while (this.handleScroll2(forceUpdate)) {
+                    enterCounter++;
+                    forceUpdate = false;
+                    if (enterCounter > 20) {
+                        console.log("FairyGUI: list will never be filled as the item renderer function always returns a different size.");
+                        break;
+                    }
+                }
+                this.handleArchOrder2();
+            }
+            else {
+                this.handleScroll3(forceUpdate);
+            }
+            this._boundsChanged = false;
+        };
+        GList.prototype.handleScroll1 = function (forceUpdate) {
+            var pos = this._scrollPane.scrollingPosY;
+            var max = pos + this._scrollPane.viewHeight;
+            var end = max == this._scrollPane.contentHeight;
+            s_n = pos;
+            var newFirstIndex = this.getIndexOnPos1(forceUpdate);
+            pos = s_n;
+            if (newFirstIndex == this._firstIndex && !forceUpdate) {
+                return false;
+            }
+            var oldFirstIndex = this._firstIndex;
+            this._firstIndex = newFirstIndex;
+            var curIndex = newFirstIndex;
+            var forward = oldFirstIndex > newFirstIndex;
+            var childCount = this.numChildren;
+            var lastIndex = oldFirstIndex + childCount - 1;
+            var reuseIndex = forward ? lastIndex : oldFirstIndex;
+            var curX = 0, curY = pos;
+            var needRender;
+            var deltaSize = 0;
+            var firstItemDeltaSize = 0;
+            var url = this.defaultItem;
+            var ii, ii2;
+            var i, j;
+            var partSize = (this._scrollPane.viewWidth - this._columnGap * (this._curLineItemCount - 1)) / this._curLineItemCount;
+            this.itemInfoVer++;
+            while (curIndex < this._realNumItems && (end || curY < max)) {
+                ii = this._virtualItems[curIndex];
+                if (ii.obj == null || forceUpdate) {
+                    if (this.itemProvider != null) {
+                        url = this.itemProvider.call(this.callbackThisObj, curIndex % this._numItems);
+                        if (url == null)
+                            url = this._defaultItem;
+                        url = fgui.UIPackage.normalizeURL(url);
+                    }
+                    if (ii.obj && ii.obj.resourceURL != url) {
+                        if (ii.obj instanceof fgui.GButton)
+                            ii.selected = ii.obj.selected;
+                        this.removeChildToPool(ii.obj);
+                        ii.obj = null;
+                    }
+                }
+                if (ii.obj == null) {
+                    if (forward) {
+                        for (j = reuseIndex; j >= oldFirstIndex; j--) {
+                            ii2 = this._virtualItems[j];
+                            if (ii2.obj && ii2.updateFlag != this.itemInfoVer && ii2.obj.resourceURL == url) {
+                                if (ii2.obj instanceof fgui.GButton)
+                                    ii2.selected = ii2.obj.selected;
+                                ii.obj = ii2.obj;
+                                ii2.obj = null;
+                                if (j == reuseIndex)
+                                    reuseIndex--;
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        for (j = reuseIndex; j <= lastIndex; j++) {
+                            ii2 = this._virtualItems[j];
+                            if (ii2.obj && ii2.updateFlag != this.itemInfoVer && ii2.obj.resourceURL == url) {
+                                if (ii2.obj instanceof fgui.GButton)
+                                    ii2.selected = ii2.obj.selected;
+                                ii.obj = ii2.obj;
+                                ii2.obj = null;
+                                if (j == reuseIndex)
+                                    reuseIndex++;
+                                break;
+                            }
+                        }
+                    }
+                    if (ii.obj) {
+                        this.setChildIndex(ii.obj, forward ? curIndex - newFirstIndex : this.numChildren);
+                    }
+                    else {
+                        ii.obj = this._pool.getObject(url);
+                        if (forward)
+                            this.addChildAt(ii.obj, curIndex - newFirstIndex);
+                        else
+                            this.addChild(ii.obj);
+                    }
+                    if (ii.obj instanceof fgui.GButton)
+                        ii.obj.selected = ii.selected;
+                    needRender = true;
+                }
+                else
+                    needRender = forceUpdate;
+                if (needRender) {
+                    if (this._autoResizeItem && (this._layout == fgui.ListLayoutType.SingleColumn || this._columnCount > 0))
+                        ii.obj.setSize(partSize, ii.obj.height, true);
+                    this.itemRenderer.call(this.callbackThisObj, curIndex % this._numItems, ii.obj);
+                    if (curIndex % this._curLineItemCount == 0) {
+                        deltaSize += Math.ceil(ii.obj.height) - ii.height;
+                        if (curIndex == newFirstIndex && oldFirstIndex > newFirstIndex) {
+                            firstItemDeltaSize = Math.ceil(ii.obj.height) - ii.height;
+                        }
+                    }
+                    ii.width = Math.ceil(ii.obj.width);
+                    ii.height = Math.ceil(ii.obj.height);
+                }
+                ii.updateFlag = this.itemInfoVer;
+                ii.obj.setXY(curX, curY);
+                if (curIndex == newFirstIndex)
+                    max += ii.height;
+                curX += ii.width + this._columnGap;
+                if (curIndex % this._curLineItemCount == this._curLineItemCount - 1) {
+                    curX = 0;
+                    curY += ii.height + this._lineGap;
+                }
+                curIndex++;
+            }
+            for (i = 0; i < childCount; i++) {
+                ii = this._virtualItems[oldFirstIndex + i];
+                if (ii.updateFlag != this.itemInfoVer && ii.obj) {
+                    if (ii.obj instanceof fgui.GButton)
+                        ii.selected = ii.obj.selected;
+                    this.removeChildToPool(ii.obj);
+                    ii.obj = null;
+                }
+            }
+            childCount = this._children.length;
+            for (i = 0; i < childCount; i++) {
+                var obj = this._virtualItems[newFirstIndex + i].obj;
+                if (this._children[i] != obj)
+                    this.setChildIndex(obj, i);
+            }
+            if (deltaSize != 0 || firstItemDeltaSize != 0)
+                this._scrollPane.changeContentSizeOnScrolling(0, deltaSize, 0, firstItemDeltaSize);
+            if (curIndex > 0 && this.numChildren > 0 && this._container.y <= 0 && this.getChildAt(0).y > -this._container.y)
+                return true;
+            else
+                return false;
+        };
+        GList.prototype.handleScroll2 = function (forceUpdate) {
+            var pos = this._scrollPane.scrollingPosX;
+            var max = pos + this._scrollPane.viewWidth;
+            var end = pos == this._scrollPane.contentWidth;
+            s_n = pos;
+            var newFirstIndex = this.getIndexOnPos2(forceUpdate);
+            pos = s_n;
+            if (newFirstIndex == this._firstIndex && !forceUpdate) {
+                return false;
+            }
+            var oldFirstIndex = this._firstIndex;
+            this._firstIndex = newFirstIndex;
+            var curIndex = newFirstIndex;
+            var forward = oldFirstIndex > newFirstIndex;
+            var childCount = this.numChildren;
+            var lastIndex = oldFirstIndex + childCount - 1;
+            var reuseIndex = forward ? lastIndex : oldFirstIndex;
+            var curX = pos, curY = 0;
+            var needRender;
+            var deltaSize = 0;
+            var firstItemDeltaSize = 0;
+            var url = this.defaultItem;
+            var ii, ii2;
+            var i, j;
+            var partSize = (this._scrollPane.viewHeight - this._lineGap * (this._curLineItemCount - 1)) / this._curLineItemCount;
+            this.itemInfoVer++;
+            while (curIndex < this._realNumItems && (end || curX < max)) {
+                ii = this._virtualItems[curIndex];
+                if (ii.obj == null || forceUpdate) {
+                    if (this.itemProvider != null) {
+                        url = this.itemProvider.call(this.callbackThisObj, curIndex % this._numItems);
+                        if (url == null)
+                            url = this._defaultItem;
+                        url = fgui.UIPackage.normalizeURL(url);
+                    }
+                    if (ii.obj && ii.obj.resourceURL != url) {
+                        if (ii.obj instanceof fgui.GButton)
+                            ii.selected = ii.obj.selected;
+                        this.removeChildToPool(ii.obj);
+                        ii.obj = null;
+                    }
+                }
+                if (ii.obj == null) {
+                    if (forward) {
+                        for (j = reuseIndex; j >= oldFirstIndex; j--) {
+                            ii2 = this._virtualItems[j];
+                            if (ii2.obj && ii2.updateFlag != this.itemInfoVer && ii2.obj.resourceURL == url) {
+                                if (ii2.obj instanceof fgui.GButton)
+                                    ii2.selected = ii2.obj.selected;
+                                ii.obj = ii2.obj;
+                                ii2.obj = null;
+                                if (j == reuseIndex)
+                                    reuseIndex--;
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        for (j = reuseIndex; j <= lastIndex; j++) {
+                            ii2 = this._virtualItems[j];
+                            if (ii2.obj && ii2.updateFlag != this.itemInfoVer && ii2.obj.resourceURL == url) {
+                                if (ii2.obj instanceof fgui.GButton)
+                                    ii2.selected = ii2.obj.selected;
+                                ii.obj = ii2.obj;
+                                ii2.obj = null;
+                                if (j == reuseIndex)
+                                    reuseIndex++;
+                                break;
+                            }
+                        }
+                    }
+                    if (ii.obj) {
+                        this.setChildIndex(ii.obj, forward ? curIndex - newFirstIndex : this.numChildren);
+                    }
+                    else {
+                        ii.obj = this._pool.getObject(url);
+                        if (forward)
+                            this.addChildAt(ii.obj, curIndex - newFirstIndex);
+                        else
+                            this.addChild(ii.obj);
+                    }
+                    if (ii.obj instanceof fgui.GButton)
+                        ii.obj.selected = ii.selected;
+                    needRender = true;
+                }
+                else
+                    needRender = forceUpdate;
+                if (needRender) {
+                    if (this._autoResizeItem && (this._layout == fgui.ListLayoutType.SingleRow || this._lineCount > 0))
+                        ii.obj.setSize(ii.obj.width, partSize, true);
+                    this.itemRenderer.call(this.callbackThisObj, curIndex % this._numItems, ii.obj);
+                    if (curIndex % this._curLineItemCount == 0) {
+                        deltaSize += Math.ceil(ii.obj.width) - ii.width;
+                        if (curIndex == newFirstIndex && oldFirstIndex > newFirstIndex) {
+                            firstItemDeltaSize = Math.ceil(ii.obj.width) - ii.width;
+                        }
+                    }
+                    ii.width = Math.ceil(ii.obj.width);
+                    ii.height = Math.ceil(ii.obj.height);
+                }
+                ii.updateFlag = this.itemInfoVer;
+                ii.obj.setXY(curX, curY);
+                if (curIndex == newFirstIndex)
+                    max += ii.width;
+                curY += ii.height + this._lineGap;
+                if (curIndex % this._curLineItemCount == this._curLineItemCount - 1) {
+                    curY = 0;
+                    curX += ii.width + this._columnGap;
+                }
+                curIndex++;
+            }
+            for (i = 0; i < childCount; i++) {
+                ii = this._virtualItems[oldFirstIndex + i];
+                if (ii.updateFlag != this.itemInfoVer && ii.obj) {
+                    if (ii.obj instanceof fgui.GButton)
+                        ii.selected = ii.obj.selected;
+                    this.removeChildToPool(ii.obj);
+                    ii.obj = null;
+                }
+            }
+            childCount = this._children.length;
+            for (i = 0; i < childCount; i++) {
+                var obj = this._virtualItems[newFirstIndex + i].obj;
+                if (this._children[i] != obj)
+                    this.setChildIndex(obj, i);
+            }
+            if (deltaSize != 0 || firstItemDeltaSize != 0)
+                this._scrollPane.changeContentSizeOnScrolling(deltaSize, 0, firstItemDeltaSize, 0);
+            if (curIndex > 0 && this.numChildren > 0 && this._container.x <= 0 && this.getChildAt(0).x > -this._container.x)
+                return true;
+            else
+                return false;
+        };
+        GList.prototype.handleScroll3 = function (forceUpdate) {
+            var pos = this._scrollPane.scrollingPosX;
+            s_n = pos;
+            var newFirstIndex = this.getIndexOnPos3(forceUpdate);
+            pos = s_n;
+            if (newFirstIndex == this._firstIndex && !forceUpdate)
+                return;
+            var oldFirstIndex = this._firstIndex;
+            this._firstIndex = newFirstIndex;
+            var reuseIndex = oldFirstIndex;
+            var virtualItemCount = this._virtualItems.length;
+            var pageSize = this._curLineItemCount * this._curLineItemCount2;
+            var startCol = newFirstIndex % this._curLineItemCount;
+            var viewWidth = this.viewWidth;
+            var page = Math.floor(newFirstIndex / pageSize);
+            var startIndex = page * pageSize;
+            var lastIndex = startIndex + pageSize * 2;
+            var needRender;
+            var i;
+            var ii, ii2;
+            var col;
+            var url = this._defaultItem;
+            var partWidth = (this._scrollPane.viewWidth - this._columnGap * (this._curLineItemCount - 1)) / this._curLineItemCount;
+            var partHeight = (this._scrollPane.viewHeight - this._lineGap * (this._curLineItemCount2 - 1)) / this._curLineItemCount2;
+            this.itemInfoVer++;
+            for (i = startIndex; i < lastIndex; i++) {
+                if (i >= this._realNumItems)
+                    continue;
+                col = i % this._curLineItemCount;
+                if (i - startIndex < pageSize) {
+                    if (col < startCol)
+                        continue;
+                }
+                else {
+                    if (col > startCol)
+                        continue;
+                }
+                ii = this._virtualItems[i];
+                ii.updateFlag = this.itemInfoVer;
+            }
+            var lastObj;
+            var insertIndex = 0;
+            for (i = startIndex; i < lastIndex; i++) {
+                if (i >= this._realNumItems)
+                    continue;
+                ii = this._virtualItems[i];
+                if (ii.updateFlag != this.itemInfoVer)
+                    continue;
+                if (ii.obj == null) {
+                    while (reuseIndex < virtualItemCount) {
+                        ii2 = this._virtualItems[reuseIndex];
+                        if (ii2.obj && ii2.updateFlag != this.itemInfoVer) {
+                            if (ii2.obj instanceof fgui.GButton)
+                                ii2.selected = ii2.obj.selected;
+                            ii.obj = ii2.obj;
+                            ii2.obj = null;
+                            break;
+                        }
+                        reuseIndex++;
+                    }
+                    if (insertIndex == -1)
+                        insertIndex = this.getChildIndex(lastObj) + 1;
+                    if (ii.obj == null) {
+                        if (this.itemProvider != null) {
+                            url = this.itemProvider.call(this.callbackThisObj, i % this._numItems);
+                            if (url == null)
+                                url = this._defaultItem;
+                            url = fgui.UIPackage.normalizeURL(url);
+                        }
+                        ii.obj = this._pool.getObject(url);
+                        this.addChildAt(ii.obj, insertIndex);
+                    }
+                    else {
+                        insertIndex = this.setChildIndexBefore(ii.obj, insertIndex);
+                    }
+                    insertIndex++;
+                    if (ii.obj instanceof fgui.GButton)
+                        ii.obj.selected = ii.selected;
+                    needRender = true;
+                }
+                else {
+                    needRender = forceUpdate;
+                    insertIndex = -1;
+                    lastObj = ii.obj;
+                }
+                if (needRender) {
+                    if (this._autoResizeItem) {
+                        if (this._curLineItemCount == this._columnCount && this._curLineItemCount2 == this._lineCount)
+                            ii.obj.setSize(partWidth, partHeight, true);
+                        else if (this._curLineItemCount == this._columnCount)
+                            ii.obj.setSize(partWidth, ii.obj.height, true);
+                        else if (this._curLineItemCount2 == this._lineCount)
+                            ii.obj.setSize(ii.obj.width, partHeight, true);
+                    }
+                    this.itemRenderer.call(this.callbackThisObj, i % this._numItems, ii.obj);
+                    ii.width = Math.ceil(ii.obj.width);
+                    ii.height = Math.ceil(ii.obj.height);
+                }
+            }
+            var borderX = (startIndex / pageSize) * viewWidth;
+            var xx = borderX;
+            var yy = 0;
+            var lineHeight = 0;
+            for (i = startIndex; i < lastIndex; i++) {
+                if (i >= this._realNumItems)
+                    continue;
+                ii = this._virtualItems[i];
+                if (ii.updateFlag == this.itemInfoVer)
+                    ii.obj.setXY(xx, yy);
+                if (ii.height > lineHeight)
+                    lineHeight = ii.height;
+                if (i % this._curLineItemCount == this._curLineItemCount - 1) {
+                    xx = borderX;
+                    yy += lineHeight + this._lineGap;
+                    lineHeight = 0;
+                    if (i == startIndex + pageSize - 1) {
+                        borderX += viewWidth;
+                        xx = borderX;
+                        yy = 0;
+                    }
+                }
+                else
+                    xx += ii.width + this._columnGap;
+            }
+            for (i = reuseIndex; i < virtualItemCount; i++) {
+                ii = this._virtualItems[i];
+                if (ii.updateFlag != this.itemInfoVer && ii.obj) {
+                    if (ii.obj instanceof fgui.GButton)
+                        ii.selected = ii.obj.selected;
+                    this.removeChildToPool(ii.obj);
+                    ii.obj = null;
+                }
+            }
+        };
+        GList.prototype.handleArchOrder1 = function () {
+            if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Arch) {
+                var mid = this._scrollPane.posY + this.viewHeight / 2;
+                var minDist = Number.POSITIVE_INFINITY;
+                var dist = 0;
+                var apexIndex = 0;
+                var cnt = this.numChildren;
+                for (var i = 0; i < cnt; i++) {
+                    var obj = this.getChildAt(i);
+                    if (!this.foldInvisibleItems || obj.visible) {
+                        dist = Math.abs(mid - obj.y - obj.height / 2);
+                        if (dist < minDist) {
+                            minDist = dist;
+                            apexIndex = i;
+                        }
+                    }
+                }
+                this.apexIndex = apexIndex;
+            }
+        };
+        GList.prototype.handleArchOrder2 = function () {
+            if (this._childrenRenderOrder == fgui.ChildrenRenderOrder.Arch) {
+                var mid = this._scrollPane.posX + this.viewWidth / 2;
+                var minDist = Number.POSITIVE_INFINITY;
+                var dist = 0;
+                var apexIndex = 0;
+                var cnt = this.numChildren;
+                for (var i = 0; i < cnt; i++) {
+                    var obj = this.getChildAt(i);
+                    if (!this.foldInvisibleItems || obj.visible) {
+                        dist = Math.abs(mid - obj.x - obj.width / 2);
+                        if (dist < minDist) {
+                            minDist = dist;
+                            apexIndex = i;
+                        }
+                    }
+                }
+                this.apexIndex = apexIndex;
+            }
+        };
+        GList.prototype.handleAlign = function (contentWidth, contentHeight) {
+            var newOffsetX = 0;
+            var newOffsetY = 0;
+            if (contentHeight < this.viewHeight) {
+                if (this._verticalAlign == fgui.VertAlignType.Middle)
+                    newOffsetY = Math.floor((this.viewHeight - contentHeight) / 2);
+                else if (this._verticalAlign == fgui.VertAlignType.Bottom)
+                    newOffsetY = this.viewHeight - contentHeight;
+            }
+            if (contentWidth < this.viewWidth) {
+                if (this._align == fgui.AlignType.Center)
+                    newOffsetX = Math.floor((this.viewWidth - contentWidth) / 2);
+                else if (this._align == fgui.AlignType.Right)
+                    newOffsetX = this.viewWidth - contentWidth;
+            }
+            if (newOffsetX != this._alignOffset.x || newOffsetY != this._alignOffset.y) {
+                this._alignOffset.setTo(newOffsetX, newOffsetY);
+                if (this._scrollPane)
+                    this._scrollPane.adjustMaskContainer();
+                else {
+                    this._container.x = this._margin.left + this._alignOffset.x;
+                    this._container.y = this._margin.top + this._alignOffset.y;
+                }
+            }
+        };
+        GList.prototype.updateBounds = function () {
+            if (this._virtual)
+                return;
+            var i;
+            var child;
+            var curX = 0;
+            var curY = 0;
+            var maxWidth = 0;
+            var maxHeight = 0;
+            var cw = 0, ch = 0;
+            var j = 0;
+            var page = 0;
+            var k = 0;
+            var cnt = this._children.length;
+            var viewWidth = this.viewWidth;
+            var viewHeight = this.viewHeight;
+            var lineSize = 0;
+            var lineStart = 0;
+            var ratio = 0;
+            if (this._layout == fgui.ListLayoutType.SingleColumn) {
+                for (i = 0; i < cnt; i++) {
+                    child = this.getChildAt(i);
+                    if (this.foldInvisibleItems && !child.visible)
+                        continue;
+                    if (curY != 0)
+                        curY += this._lineGap;
+                    child.y = curY;
+                    if (this._autoResizeItem)
+                        child.setSize(viewWidth, child.height, true);
+                    curY += Math.ceil(child.height);
+                    if (child.width > maxWidth)
+                        maxWidth = child.width;
+                }
+                ch = curY;
+                if (ch <= viewHeight && this._autoResizeItem && this._scrollPane && this._scrollPane._displayInDemand && this._scrollPane.vtScrollBar) {
+                    viewWidth += this._scrollPane.vtScrollBar.width;
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        child.setSize(viewWidth, child.height, true);
+                        if (child.width > maxWidth)
+                            maxWidth = child.width;
+                    }
+                }
+                cw = Math.ceil(maxWidth);
+            }
+            else if (this._layout == fgui.ListLayoutType.SingleRow) {
+                for (i = 0; i < cnt; i++) {
+                    child = this.getChildAt(i);
+                    if (this.foldInvisibleItems && !child.visible)
+                        continue;
+                    if (curX != 0)
+                        curX += this._columnGap;
+                    child.x = curX;
+                    if (this._autoResizeItem)
+                        child.setSize(child.width, viewHeight, true);
+                    curX += Math.ceil(child.width);
+                    if (child.height > maxHeight)
+                        maxHeight = child.height;
+                }
+                cw = curX;
+                if (cw <= viewWidth && this._autoResizeItem && this._scrollPane && this._scrollPane._displayInDemand && this._scrollPane.hzScrollBar) {
+                    viewHeight += this._scrollPane.hzScrollBar.height;
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        child.setSize(child.width, viewHeight, true);
+                        if (child.height > maxHeight)
+                            maxHeight = child.height;
+                    }
+                }
+                ch = Math.ceil(maxHeight);
+            }
+            else if (this._layout == fgui.ListLayoutType.FlowHorizontal) {
+                if (this._autoResizeItem && this._columnCount > 0) {
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        lineSize += child.sourceWidth;
+                        j++;
+                        if (j == this._columnCount || i == cnt - 1) {
+                            ratio = (viewWidth - lineSize - (j - 1) * this._columnGap) / lineSize;
+                            curX = 0;
+                            for (j = lineStart; j <= i; j++) {
+                                child = this.getChildAt(j);
+                                if (this.foldInvisibleItems && !child.visible)
+                                    continue;
+                                child.setXY(curX, curY);
+                                if (j < i) {
+                                    child.setSize(child.sourceWidth + Math.round(child.sourceWidth * ratio), child.height, true);
+                                    curX += Math.ceil(child.width) + this._columnGap;
+                                }
+                                else {
+                                    child.setSize(viewWidth - curX, child.height, true);
+                                }
+                                if (child.height > maxHeight)
+                                    maxHeight = child.height;
+                            }
+                            curY += Math.ceil(maxHeight) + this._lineGap;
+                            maxHeight = 0;
+                            j = 0;
+                            lineStart = i + 1;
+                            lineSize = 0;
+                        }
+                    }
+                    ch = curY + Math.ceil(maxHeight);
+                    cw = viewWidth;
+                }
+                else {
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        if (curX != 0)
+                            curX += this._columnGap;
+                        if (this._columnCount != 0 && j >= this._columnCount
+                            || this._columnCount == 0 && curX + child.width > viewWidth && maxHeight != 0) {
+                            curX = 0;
+                            curY += Math.ceil(maxHeight) + this._lineGap;
+                            maxHeight = 0;
+                            j = 0;
+                        }
+                        child.setXY(curX, curY);
+                        curX += Math.ceil(child.width);
+                        if (curX > maxWidth)
+                            maxWidth = curX;
+                        if (child.height > maxHeight)
+                            maxHeight = child.height;
+                        j++;
+                    }
+                    ch = curY + Math.ceil(maxHeight);
+                    cw = Math.ceil(maxWidth);
+                }
+            }
+            else if (this._layout == fgui.ListLayoutType.FlowVertical) {
+                if (this._autoResizeItem && this._lineCount > 0) {
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        lineSize += child.sourceHeight;
+                        j++;
+                        if (j == this._lineCount || i == cnt - 1) {
+                            ratio = (viewHeight - lineSize - (j - 1) * this._lineGap) / lineSize;
+                            curY = 0;
+                            for (j = lineStart; j <= i; j++) {
+                                child = this.getChildAt(j);
+                                if (this.foldInvisibleItems && !child.visible)
+                                    continue;
+                                child.setXY(curX, curY);
+                                if (j < i) {
+                                    child.setSize(child.width, child.sourceHeight + Math.round(child.sourceHeight * ratio), true);
+                                    curY += Math.ceil(child.height) + this._lineGap;
+                                }
+                                else {
+                                    child.setSize(child.width, viewHeight - curY, true);
+                                }
+                                if (child.width > maxWidth)
+                                    maxWidth = child.width;
+                            }
+                            curX += Math.ceil(maxWidth) + this._columnGap;
+                            maxWidth = 0;
+                            j = 0;
+                            lineStart = i + 1;
+                            lineSize = 0;
+                        }
+                    }
+                    cw = curX + Math.ceil(maxWidth);
+                    ch = viewHeight;
+                }
+                else {
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        if (curY != 0)
+                            curY += this._lineGap;
+                        if (this._lineCount != 0 && j >= this._lineCount
+                            || this._lineCount == 0 && curY + child.height > viewHeight && maxWidth != 0) {
+                            curY = 0;
+                            curX += Math.ceil(maxWidth) + this._columnGap;
+                            maxWidth = 0;
+                            j = 0;
+                        }
+                        child.setXY(curX, curY);
+                        curY += Math.ceil(child.height);
+                        if (curY > maxHeight)
+                            maxHeight = curY;
+                        if (child.width > maxWidth)
+                            maxWidth = child.width;
+                        j++;
+                    }
+                    cw = curX + Math.ceil(maxWidth);
+                    ch = Math.ceil(maxHeight);
+                }
+            }
+            else {
+                var eachHeight;
+                if (this._autoResizeItem && this._lineCount > 0)
+                    eachHeight = Math.floor((viewHeight - (this._lineCount - 1) * this._lineGap) / this._lineCount);
+                if (this._autoResizeItem && this._columnCount > 0) {
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        if (j == 0 && (this._lineCount != 0 && k >= this._lineCount
+                            || this._lineCount == 0 && curY + (this._lineCount > 0 ? eachHeight : child.height) > viewHeight)) {
+                            page++;
+                            curY = 0;
+                            k = 0;
+                        }
+                        lineSize += child.sourceWidth;
+                        j++;
+                        if (j == this._columnCount || i == cnt - 1) {
+                            ratio = (viewWidth - lineSize - (j - 1) * this._columnGap) / lineSize;
+                            curX = 0;
+                            for (j = lineStart; j <= i; j++) {
+                                child = this.getChildAt(j);
+                                if (this.foldInvisibleItems && !child.visible)
+                                    continue;
+                                child.setXY(page * viewWidth + curX, curY);
+                                if (j < i) {
+                                    child.setSize(child.sourceWidth + Math.round(child.sourceWidth * ratio), this._lineCount > 0 ? eachHeight : child.height, true);
+                                    curX += Math.ceil(child.width) + this._columnGap;
+                                }
+                                else {
+                                    child.setSize(viewWidth - curX, this._lineCount > 0 ? eachHeight : child.height, true);
+                                }
+                                if (child.height > maxHeight)
+                                    maxHeight = child.height;
+                            }
+                            curY += Math.ceil(maxHeight) + this._lineGap;
+                            maxHeight = 0;
+                            j = 0;
+                            lineStart = i + 1;
+                            lineSize = 0;
+                            k++;
+                        }
+                    }
+                }
+                else {
+                    for (i = 0; i < cnt; i++) {
+                        child = this.getChildAt(i);
+                        if (this.foldInvisibleItems && !child.visible)
+                            continue;
+                        if (curX != 0)
+                            curX += this._columnGap;
+                        if (this._autoResizeItem && this._lineCount > 0)
+                            child.setSize(child.width, eachHeight, true);
+                        if (this._columnCount != 0 && j >= this._columnCount
+                            || this._columnCount == 0 && curX + child.width > viewWidth && maxHeight != 0) {
+                            curX = 0;
+                            curY += Math.ceil(maxHeight) + this._lineGap;
+                            maxHeight = 0;
+                            j = 0;
+                            k++;
+                            if (this._lineCount != 0 && k >= this._lineCount
+                                || this._lineCount == 0 && curY + child.height > viewHeight && maxWidth != 0) {
+                                page++;
+                                curY = 0;
+                                k = 0;
+                            }
+                        }
+                        child.setXY(page * viewWidth + curX, curY);
+                        curX += Math.ceil(child.width);
+                        if (curX > maxWidth)
+                            maxWidth = curX;
+                        if (child.height > maxHeight)
+                            maxHeight = child.height;
+                        j++;
+                    }
+                }
+                ch = page > 0 ? viewHeight : curY + Math.ceil(maxHeight);
+                cw = (page + 1) * viewWidth;
+            }
+            this.handleAlign(cw, ch);
+            this.setBounds(0, 0, cw, ch);
+        };
+        GList.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            this._layout = buffer.readByte();
+            this._selectionMode = buffer.readByte();
+            this._align = buffer.readByte();
+            this._verticalAlign = buffer.readByte();
+            this._lineGap = buffer.readShort();
+            this._columnGap = buffer.readShort();
+            this._lineCount = buffer.readShort();
+            this._columnCount = buffer.readShort();
+            this._autoResizeItem = buffer.readBool();
+            this._childrenRenderOrder = buffer.readByte();
+            this._apexIndex = buffer.readShort();
+            if (buffer.readBool()) {
+                this._margin.top = buffer.readInt();
+                this._margin.bottom = buffer.readInt();
+                this._margin.left = buffer.readInt();
+                this._margin.right = buffer.readInt();
+            }
+            var overflow = buffer.readByte();
+            if (overflow == fgui.OverflowType.Scroll) {
+                var savedPos = buffer.position;
+                buffer.seek(beginPos, 7);
+                this.setupScroll(buffer);
+                buffer.position = savedPos;
+            }
+            else
+                this.setupOverflow(overflow);
+            if (buffer.readBool())
+                buffer.skip(8);
+            if (buffer.version >= 2) {
+                this.scrollItemToViewOnClick = buffer.readBool();
+                this.foldInvisibleItems = buffer.readBool();
+            }
+            buffer.seek(beginPos, 8);
+            this._defaultItem = buffer.readS();
+            this.readItems(buffer);
+        };
+        GList.prototype.readItems = function (buffer) {
+            var cnt;
+            var i;
+            var nextPos;
+            var str;
+            cnt = buffer.readShort();
+            for (i = 0; i < cnt; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                str = buffer.readS();
+                if (str == null) {
+                    str = this.defaultItem;
+                    if (!str) {
+                        buffer.position = nextPos;
+                        continue;
+                    }
+                }
+                var obj = this.getFromPool(str);
+                if (obj != null) {
+                    this.addChild(obj);
+                    this.setupItem(buffer, obj);
+                }
+                buffer.position = nextPos;
+            }
+        };
+        GList.prototype.setupItem = function (buffer, obj) {
+            var str;
+            str = buffer.readS();
+            if (str != null)
+                obj.text = str;
+            str = buffer.readS();
+            if (str != null && (obj instanceof fgui.GButton))
+                obj.selectedTitle = str;
+            str = buffer.readS();
+            if (str != null)
+                obj.icon = str;
+            str = buffer.readS();
+            if (str != null && (obj instanceof fgui.GButton))
+                obj.selectedIcon = str;
+            str = buffer.readS();
+            if (str != null)
+                obj.name = str;
+            var cnt;
+            var i;
+            if (obj instanceof fgui.GComponent) {
+                cnt = buffer.readShort();
+                for (i = 0; i < cnt; i++) {
+                    var cc = obj.getController(buffer.readS());
+                    str = buffer.readS();
+                    if (cc)
+                        cc.selectedPageId = str;
+                }
+                if (buffer.version >= 2) {
+                    cnt = buffer.readShort();
+                    for (i = 0; i < cnt; i++) {
+                        var target = buffer.readS();
+                        var propertyId = buffer.readShort();
+                        var value = buffer.readS();
+                        var obj2 = obj.getChildByPath(target);
+                        if (obj2)
+                            obj2.setProp(propertyId, value);
+                    }
+                }
+            }
+        };
+        GList.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 6);
+            var i = buffer.readShort();
+            if (i != -1)
+                this._selectionController = this.parent.getControllerAt(i);
+        };
+        return GList;
+    }(fgui.GComponent));
+    fgui.GList = GList;
+    var s_n = 0;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GObjectPool = (function () {
+        function GObjectPool() {
+            this._count = 0;
+            this._pool = {};
+        }
+        GObjectPool.prototype.clear = function () {
+            for (var i1 in this._pool) {
+                var arr = this._pool[i1];
+                var cnt = arr.length;
+                for (var i = 0; i < cnt; i++)
+                    arr[i].dispose();
+            }
+            this._pool = {};
+            this._count = 0;
+        };
+        Object.defineProperty(GObjectPool.prototype, "count", {
+            get: function () {
+                return this._count;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GObjectPool.prototype.getObject = function (url) {
+            url = fgui.UIPackage.normalizeURL(url);
+            if (url == null)
+                return null;
+            var arr = this._pool[url];
+            if (arr && arr.length) {
+                this._count--;
+                return arr.shift();
+            }
+            var child = fgui.UIPackage.createObjectFromURL(url);
+            return child;
+        };
+        GObjectPool.prototype.returnObject = function (obj) {
+            var url = obj.resourceURL;
+            if (!url)
+                return;
+            var arr = this._pool[url];
+            if (arr == null) {
+                arr = new Array();
+                this._pool[url] = arr;
+            }
+            this._count++;
+            arr.push(obj);
+        };
+        return GObjectPool;
+    }());
+    fgui.GObjectPool = GObjectPool;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GLoader = (function (_super_1) {
+        __extends(GLoader, _super_1);
+        function GLoader() {
+            var _this = _super_1.call(this) || this;
+            _this._url = "";
+            _this._fill = fgui.LoaderFillType.None;
+            _this._align = fgui.AlignType.Left;
+            _this._verticalAlign = fgui.VertAlignType.Top;
+            _this._showErrorSign = true;
+            return _this;
+        }
+        GLoader.prototype.createDisplayObject = function () {
+            this._container = new fgui.UIContainer();
+            this._container.opaque = true;
+            this.setDisplayObject(this._container);
+            this._content = new fgui.MovieClip();
+            this._container.addChild(this._content);
+        };
+        GLoader.prototype.dispose = function () {
+            if (!this._contentItem) {
+                var texture = this._content.texture;
+                if (texture)
+                    this.freeExternal(texture);
+            }
+            if (this._content2)
+                this._content2.dispose();
+            _super_1.prototype.dispose.call(this);
+        };
+        Object.defineProperty(GLoader.prototype, "url", {
+            get: function () {
+                return this._url;
+            },
+            set: function (value) {
+                if (this._url == value)
+                    return;
+                this.clearContent();
+                this._url = value;
+                this.loadContent();
+                this.updateGear(7);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "icon", {
+            get: function () {
+                return this._url;
+            },
+            set: function (value) {
+                this.url = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "align", {
+            get: function () {
+                return this._align;
+            },
+            set: function (value) {
+                if (this._align != value) {
+                    this._align = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "verticalAlign", {
+            get: function () {
+                return this._verticalAlign;
+            },
+            set: function (value) {
+                if (this._verticalAlign != value) {
+                    this._verticalAlign = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "fill", {
+            get: function () {
+                return this._fill;
+            },
+            set: function (value) {
+                if (this._fill != value) {
+                    this._fill = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "shrinkOnly", {
+            get: function () {
+                return this._shrinkOnly;
+            },
+            set: function (value) {
+                if (this._shrinkOnly != value) {
+                    this._shrinkOnly = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "autoSize", {
+            get: function () {
+                return this._autoSize;
+            },
+            set: function (value) {
+                if (this._autoSize != value) {
+                    this._autoSize = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "playing", {
+            get: function () {
+                return this._content.playing;
+            },
+            set: function (value) {
+                if (this._content.playing != value) {
+                    this._content.playing = value;
+                    this.updateGear(5);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "frame", {
+            get: function () {
+                return this._content.frame;
+            },
+            set: function (value) {
+                if (this._content.frame != value) {
+                    this._content.frame = value;
+                    this.updateGear(5);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "color", {
+            get: function () {
+                return this._content.color;
+            },
+            set: function (value) {
+                if (this._content.color != value) {
+                    this._content.color = value;
+                    this.updateGear(4);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "showErrorSign", {
+            get: function () {
+                return this._showErrorSign;
+            },
+            set: function (value) {
+                this._showErrorSign = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "content", {
+            get: function () {
+                return this._content;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "component", {
+            get: function () {
+                return this._content2;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "texture", {
+            get: function () {
+                return this._content.texture;
+            },
+            set: function (value) {
+                this.url = null;
+                this._content.frames = null;
+                this._content.texture = value;
+                if (value) {
+                    this.sourceWidth = value.textureWidth;
+                    this.sourceHeight = value.textureHeight;
+                }
+                else {
+                    this.sourceWidth = this.sourceHeight = 0;
+                }
+                this.updateLayout();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "fillMethod", {
+            get: function () {
+                return this._content.fillMethod;
+            },
+            set: function (value) {
+                this._content.fillMethod = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "fillOrigin", {
+            get: function () {
+                return this._content.fillOrigin;
+            },
+            set: function (value) {
+                this._content.fillOrigin = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "fillClockwise", {
+            get: function () {
+                return this._content.fillClockwise;
+            },
+            set: function (value) {
+                this._content.fillClockwise = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader.prototype, "fillAmount", {
+            get: function () {
+                return this._content.fillAmount;
+            },
+            set: function (value) {
+                this._content.fillAmount = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GLoader.prototype.loadContent = function () {
+            if (!this._url)
+                return;
+            if (fgui.ToolSet.startsWith(this._url, "ui://"))
+                this.loadFromPackage(this._url);
+            else
+                this.loadExternal();
+        };
+        GLoader.prototype.loadFromPackage = function (itemURL) {
+            this._contentItem = fgui.UIPackage.getItemByURL(itemURL);
+            if (this._contentItem) {
+                this._contentItem = this._contentItem.getBranch();
+                this.sourceWidth = this._contentItem.width;
+                this.sourceHeight = this._contentItem.height;
+                this._contentItem = this._contentItem.getHighResolution();
+                this._contentItem.load();
+                if (this._autoSize)
+                    this.setSize(this.sourceWidth, this.sourceHeight);
+                if (this._contentItem.type == fgui.PackageItemType.Image) {
+                    if (this._contentItem.asset == null) {
+                        this.setErrorState();
+                    }
+                    else {
+                        this._content.texture = this._contentItem.asset;
+                        this._content.scale9Grid = this._contentItem.scale9Grid;
+                        if (this._contentItem.scaleByTile)
+                            this._content.fillMode = egret.BitmapFillMode.REPEAT;
+                        else
+                            this._content.fillMode = egret.BitmapFillMode.SCALE;
+                        this.updateLayout();
+                    }
+                }
+                else if (this._contentItem.type == fgui.PackageItemType.MovieClip) {
+                    this._content.interval = this._contentItem.interval;
+                    this._content.swing = this._contentItem.swing;
+                    this._content.repeatDelay = this._contentItem.repeatDelay;
+                    this._content.frames = this._contentItem.frames;
+                    this.updateLayout();
+                }
+                else if (this._contentItem.type == fgui.PackageItemType.Component) {
+                    var obj = fgui.UIPackage.createObjectFromURL(itemURL);
+                    if (!obj)
+                        this.setErrorState();
+                    else if (!(obj instanceof fgui.GComponent)) {
+                        obj.dispose();
+                        this.setErrorState();
+                    }
+                    else {
+                        this._content2 = obj.asCom;
+                        this._container.addChild(this._content2.displayObject);
+                        this.updateLayout();
+                    }
+                }
+                else
+                    this.setErrorState();
+            }
+            else
+                this.setErrorState();
+        };
+        GLoader.prototype.loadExternal = function () {
+            RES.getResByUrl(this._url, this.__getResCompleted, this);
+        };
+        GLoader.prototype.freeExternal = function (texture) {
+        };
+        GLoader.prototype.onExternalLoadSuccess = function (texture) {
+            this._content.texture = texture;
+            this._content.scale9Grid = null;
+            this._content.fillMode = egret.BitmapFillMode.SCALE;
+            this.sourceWidth = texture.textureWidth;
+            this.sourceHeight = texture.textureHeight;
+            this.updateLayout();
+        };
+        GLoader.prototype.onExternalLoadFailed = function () {
+            this.setErrorState();
+        };
+        GLoader.prototype.__getResCompleted = function (res, key) {
+            if (res instanceof egret.Texture)
+                this.onExternalLoadSuccess(res);
+            else
+                this.onExternalLoadFailed();
+        };
+        GLoader.prototype.setErrorState = function () {
+            if (!this._showErrorSign)
+                return;
+            if (this._errorSign == null) {
+                if (fgui.UIConfig.loaderErrorSign != null) {
+                    this._errorSign = GLoader._errorSignPool.getObject(fgui.UIConfig.loaderErrorSign);
+                }
+            }
+            if (this._errorSign) {
+                this._errorSign.setSize(this.width, this.height);
+                this._container.addChild(this._errorSign.displayObject);
+            }
+        };
+        GLoader.prototype.clearErrorState = function () {
+            if (this._errorSign) {
+                this._container.removeChild(this._errorSign.displayObject);
+                GLoader._errorSignPool.returnObject(this._errorSign);
+                this._errorSign = null;
+            }
+        };
+        GLoader.prototype.updateLayout = function () {
+            if (!this._content2 && !this._content) {
+                if (this._autoSize) {
+                    this._updatingLayout = true;
+                    this.setSize(50, 30);
+                    this._updatingLayout = false;
+                }
+                return;
+            }
+            var cw = this.sourceWidth;
+            var ch = this.sourceHeight;
+            if (this._autoSize) {
+                this._updatingLayout = true;
+                if (cw == 0)
+                    cw = 50;
+                if (ch == 0)
+                    ch = 30;
+                this.setSize(cw, ch);
+                this._updatingLayout = false;
+                if (cw == this._width && ch == this._height) {
+                    if (this._content2) {
+                        this._content2.setXY(0, 0);
+                        this._content2.setScale(1, 1);
+                    }
+                    else {
+                        this._content.x = 0;
+                        this._content.y = 0;
+                        this._content.width = cw;
+                        this._content.height = ch;
+                    }
+                    return;
+                }
+            }
+            var sx = 1, sy = 1;
+            if (this._fill != fgui.LoaderFillType.None) {
+                sx = this.width / this.sourceWidth;
+                sy = this.height / this.sourceHeight;
+                if (sx != 1 || sy != 1) {
+                    if (this._fill == fgui.LoaderFillType.ScaleMatchHeight)
+                        sx = sy;
+                    else if (this._fill == fgui.LoaderFillType.ScaleMatchWidth)
+                        sy = sx;
+                    else if (this._fill == fgui.LoaderFillType.Scale) {
+                        if (sx > sy)
+                            sx = sy;
+                        else
+                            sy = sx;
+                    }
+                    else if (this._fill == fgui.LoaderFillType.ScaleNoBorder) {
+                        if (sx > sy)
+                            sy = sx;
+                        else
+                            sx = sy;
+                    }
+                    if (this._shrinkOnly) {
+                        if (sx > 1)
+                            sx = 1;
+                        if (sy > 1)
+                            sy = 1;
+                    }
+                    cw = this.sourceWidth * sx;
+                    ch = this.sourceHeight * sy;
+                }
+            }
+            if (this._content2) {
+                this._content2.setScale(sx, sy);
+            }
+            else {
+                this._content.width = cw;
+                this._content.height = ch;
+            }
+            var nx, ny;
+            if (this._align == fgui.AlignType.Center)
+                nx = Math.floor((this.width - cw) / 2);
+            else if (this._align == fgui.AlignType.Right)
+                nx = this.width - cw;
+            else
+                nx = 0;
+            if (this._verticalAlign == fgui.VertAlignType.Middle)
+                ny = Math.floor((this.height - ch) / 2);
+            else if (this._verticalAlign == fgui.VertAlignType.Bottom)
+                ny = this.height - ch;
+            else
+                ny = 0;
+            if (this._content2)
+                this._content2.setXY(nx, ny);
+            else {
+                this._content.x = nx;
+                this._content.y = ny;
+            }
+        };
+        GLoader.prototype.clearContent = function () {
+            this.clearErrorState();
+            if (!this._contentItem && this._content.texture) {
+                this.freeExternal(this._content.texture);
+            }
+            this._content.texture = null;
+            this._content.frames = null;
+            if (this._content2) {
+                this._container.removeChild(this._content2.displayObject);
+                this._content2.dispose();
+                this._content2 = null;
+            }
+            this._contentItem = null;
+        };
+        GLoader.prototype.handleSizeChanged = function () {
+            _super_1.prototype.handleSizeChanged.call(this);
+            if (!this._updatingLayout)
+                this.updateLayout();
+        };
+        GLoader.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    return this.color;
+                case fgui.ObjectPropID.Playing:
+                    return this.playing;
+                case fgui.ObjectPropID.Frame:
+                    return this.frame;
+                case fgui.ObjectPropID.TimeScale:
+                    return this._content.timeScale;
+                default:
+                    return _super_1.prototype.getProp.call(this, index);
+            }
+        };
+        GLoader.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    this.color = value;
+                    break;
+                case fgui.ObjectPropID.Playing:
+                    this.playing = value;
+                    break;
+                case fgui.ObjectPropID.Frame:
+                    this.frame = value;
+                    break;
+                case fgui.ObjectPropID.TimeScale:
+                    this._content.timeScale = value;
+                    break;
+                case fgui.ObjectPropID.DeltaTime:
+                    this._content.advance(value);
+                    break;
+                default:
+                    _super_1.prototype.setProp.call(this, index, value);
+                    break;
+            }
+        };
+        GLoader.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            this._url = buffer.readS();
+            this._align = buffer.readByte();
+            this._verticalAlign = buffer.readByte();
+            this._fill = buffer.readByte();
+            this._shrinkOnly = buffer.readBool();
+            this._autoSize = buffer.readBool();
+            this._showErrorSign = buffer.readBool();
+            this._content.playing = buffer.readBool();
+            this._content.frame = buffer.readInt();
+            if (buffer.readBool())
+                this.color = buffer.readColor();
+            this._content.fillMethod = buffer.readByte();
+            if (this._content.fillMethod != 0) {
+                this._content.fillOrigin = buffer.readByte();
+                this._content.fillClockwise = buffer.readBool();
+                this._content.fillAmount = buffer.readFloat();
+            }
+            if (this._url)
+                this.loadContent();
+        };
+        GLoader._errorSignPool = new fgui.GObjectPool();
+        return GLoader;
+    }(fgui.GObject));
+    fgui.GLoader = GLoader;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GLoader3D = (function (_super_1) {
+        __extends(GLoader3D, _super_1);
+        function GLoader3D() {
+            var _this = _super_1.call(this) || this;
+            _this._frame = 0;
+            _this._playing = true;
+            _this._url = "";
+            _this._fill = fgui.LoaderFillType.None;
+            _this._align = fgui.AlignType.Left;
+            _this._verticalAlign = fgui.VertAlignType.Top;
+            _this._color = 0xFFFFFF;
+            return _this;
+        }
+        GLoader3D.prototype.createDisplayObject = function () {
+            var d = new fgui.UIContainer();
+            d.opaque = true;
+            this.setDisplayObject(d);
+            this._container = new egret.DisplayObjectContainer();
+            d.addChild(this._container);
+        };
+        GLoader3D.prototype.dispose = function () {
+            _super_1.prototype.dispose.call(this);
+        };
+        Object.defineProperty(GLoader3D.prototype, "url", {
+            get: function () {
+                return this._url;
+            },
+            set: function (value) {
+                if (this._url == value)
+                    return;
+                this._url = value;
+                this.loadContent();
+                this.updateGear(7);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "icon", {
+            get: function () {
+                return this._url;
+            },
+            set: function (value) {
+                this.url = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "align", {
+            get: function () {
+                return this._align;
+            },
+            set: function (value) {
+                if (this._align != value) {
+                    this._align = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "verticalAlign", {
+            get: function () {
+                return this._verticalAlign;
+            },
+            set: function (value) {
+                if (this._verticalAlign != value) {
+                    this._verticalAlign = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "fill", {
+            get: function () {
+                return this._fill;
+            },
+            set: function (value) {
+                if (this._fill != value) {
+                    this._fill = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "shrinkOnly", {
+            get: function () {
+                return this._shrinkOnly;
+            },
+            set: function (value) {
+                if (this._shrinkOnly != value) {
+                    this._shrinkOnly = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "autoSize", {
+            get: function () {
+                return this._autoSize;
+            },
+            set: function (value) {
+                if (this._autoSize != value) {
+                    this._autoSize = value;
+                    this.updateLayout();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "playing", {
+            get: function () {
+                return this._playing;
+            },
+            set: function (value) {
+                if (this._playing != value) {
+                    this._playing = value;
+                    this.updateGear(5);
+                    this.onChange();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "frame", {
+            get: function () {
+                return this._frame;
+            },
+            set: function (value) {
+                if (this._frame != value) {
+                    this._frame = value;
+                    this.updateGear(5);
+                    this.onChange();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "animationName", {
+            get: function () {
+                return this._animationName;
+            },
+            set: function (value) {
+                if (this._animationName != value) {
+                    this._animationName = value;
+                    this.onChange();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "skinName", {
+            get: function () {
+                return this._skinName;
+            },
+            set: function (value) {
+                if (this._skinName != value) {
+                    this._skinName = value;
+                    this.onChange();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "loop", {
+            get: function () {
+                return this._loop;
+            },
+            set: function (value) {
+                if (this._loop != value) {
+                    this._loop = value;
+                    this.onChange();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "color", {
+            get: function () {
+                return this._color;
+            },
+            set: function (value) {
+                if (this._color != value) {
+                    this._color = value;
+                    this.updateGear(4);
+                    if (this._content)
+                        this._content.tint = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GLoader3D.prototype, "content", {
+            get: function () {
+                return;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GLoader3D.prototype.loadContent = function () {
+            this.clearContent();
+            if (!this._url)
+                return;
+            if (fgui.ToolSet.startsWith(this._url, "ui://"))
+                this.loadFromPackage(this._url);
+            else
+                this.loadExternal();
+        };
+        GLoader3D.prototype.loadFromPackage = function (itemURL) {
+            this._contentItem = fgui.UIPackage.getItemByURL(itemURL);
+            if (this._contentItem) {
+                this._contentItem = this._contentItem.getBranch();
+                this.sourceWidth = this._contentItem.width;
+                this.sourceHeight = this._contentItem.height;
+                this._contentItem = this._contentItem.getHighResolution();
+                if (this._autoSize)
+                    this.setSize(this.sourceWidth, this.sourceHeight);
+                if (this._contentItem.type == fgui.PackageItemType.Spine || this._contentItem.type == fgui.PackageItemType.DragonBones)
+                    this._contentItem.owner.getItemAssetAsync(this._contentItem, this.onLoaded.bind(this));
+            }
+        };
+        GLoader3D.prototype.onLoaded = function (err, item) {
+            if (this._contentItem != item)
+                return;
+            if (err)
+                console.warn(err);
+            if (!this._contentItem.asset)
+                return;
+            if (this._contentItem.type == fgui.PackageItemType.DragonBones)
+                this.setDragonBones(this._contentItem.armatureName, this._contentItem.asset.name, this._contentItem.atlasAsset.name, this._skinName, this._contentItem.skeletonAnchor);
+        };
+        GLoader3D.prototype.setDragonBones = function (armatureName, dragonBonesName, skinName, textureAtlasName, anchor) {
+            this.url = null;
+            var egretFactory = dragonBones.EgretFactory.factory;
+            this._content = egretFactory.buildArmatureDisplay(armatureName, dragonBonesName, skinName, textureAtlasName);
+            this._container.addChild(this._content);
+            this._content.x = anchor.x;
+            this._content.y = anchor.y;
+            this._content.tint = this._color;
+            this.onChangeDragonBones();
+            this.updateLayout();
+        };
+        GLoader3D.prototype.onChange = function () {
+            this.onChangeDragonBones();
+        };
+        GLoader3D.prototype.onChangeDragonBones = function () {
+            if (!(this._content instanceof dragonBones.EgretArmatureDisplay))
+                return;
+            if (this._animationName) {
+                if (this._playing)
+                    this._content.animation.play(this._animationName, this._loop ? 0 : 1);
+                else
+                    this._content.animation.gotoAndStopByFrame(this._animationName, this._frame);
+            }
+            else
+                this._content.animation.reset();
+        };
+        GLoader3D.prototype.loadExternal = function () {
+        };
+        GLoader3D.prototype.updateLayout = function () {
+            var cw = this.sourceWidth;
+            var ch = this.sourceHeight;
+            if (this._autoSize) {
+                this._updatingLayout = true;
+                if (cw == 0)
+                    cw = 50;
+                if (ch == 0)
+                    ch = 30;
+                this.setSize(cw, ch);
+                this._updatingLayout = false;
+                if (cw == this._width && ch == this._height) {
+                    this._container.scaleX = this._container.scaleY = 1;
+                    this._container.x = this._container.y = 0;
+                    return;
+                }
+            }
+            var sx = 1, sy = 1;
+            if (this._fill != fgui.LoaderFillType.None) {
+                sx = this.width / this.sourceWidth;
+                sy = this.height / this.sourceHeight;
+                if (sx != 1 || sy != 1) {
+                    if (this._fill == fgui.LoaderFillType.ScaleMatchHeight)
+                        sx = sy;
+                    else if (this._fill == fgui.LoaderFillType.ScaleMatchWidth)
+                        sy = sx;
+                    else if (this._fill == fgui.LoaderFillType.Scale) {
+                        if (sx > sy)
+                            sx = sy;
+                        else
+                            sy = sx;
+                    }
+                    else if (this._fill == fgui.LoaderFillType.ScaleNoBorder) {
+                        if (sx > sy)
+                            sy = sx;
+                        else
+                            sx = sy;
+                    }
+                    if (this._shrinkOnly) {
+                        if (sx > 1)
+                            sx = 1;
+                        if (sy > 1)
+                            sy = 1;
+                    }
+                    cw = this.sourceWidth * sx;
+                    ch = this.sourceHeight * sy;
+                }
+            }
+            this._container.scaleX = sx;
+            this._container.scaleY = sy;
+            var nx, ny;
+            if (this._align == fgui.AlignType.Center)
+                nx = Math.floor((this.width - cw) / 2);
+            else if (this._align == fgui.AlignType.Right)
+                nx = this.width - cw;
+            else
+                nx = 0;
+            if (this._verticalAlign == fgui.VertAlignType.Middle)
+                ny = Math.floor((this.height - ch) / 2);
+            else if (this._verticalAlign == fgui.VertAlignType.Bottom)
+                ny = this.height - ch;
+            else
+                ny = 0;
+            this._container.x = nx;
+            this._container.y = ny;
+        };
+        GLoader3D.prototype.clearContent = function () {
+            this._contentItem = null;
+            if (this._content) {
+                this._container.removeChild(this._content);
+                if ('dispose' in this._content)
+                    this._content.dispose();
+                this._content = null;
+            }
+        };
+        GLoader3D.prototype.handleSizeChanged = function () {
+            _super_1.prototype.handleSizeChanged.call(this);
+            if (!this._updatingLayout)
+                this.updateLayout();
+        };
+        GLoader3D.prototype.handleGrayedChanged = function () {
+        };
+        GLoader3D.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    return this.color;
+                case fgui.ObjectPropID.Playing:
+                    return this.playing;
+                case fgui.ObjectPropID.Frame:
+                    return this.frame;
+                case fgui.ObjectPropID.TimeScale:
+                    return 1;
+                default:
+                    return _super_1.prototype.getProp.call(this, index);
+            }
+        };
+        GLoader3D.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    this.color = value;
+                    break;
+                case fgui.ObjectPropID.Playing:
+                    this.playing = value;
+                    break;
+                case fgui.ObjectPropID.Frame:
+                    this.frame = value;
+                    break;
+                case fgui.ObjectPropID.TimeScale:
+                    break;
+                case fgui.ObjectPropID.DeltaTime:
+                    break;
+                default:
+                    _super_1.prototype.setProp.call(this, index, value);
+                    break;
+            }
+        };
+        GLoader3D.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            this._url = buffer.readS();
+            this._align = buffer.readByte();
+            this._verticalAlign = buffer.readByte();
+            this._fill = buffer.readByte();
+            this._shrinkOnly = buffer.readBool();
+            this._autoSize = buffer.readBool();
+            this._animationName = buffer.readS();
+            this._skinName = buffer.readS();
+            this._playing = buffer.readBool();
+            this._frame = buffer.readInt();
+            this._loop = buffer.readBool();
+            if (buffer.readBool())
+                this.color = buffer.readColor();
+            if (this._url)
+                this.loadContent();
+        };
+        return GLoader3D;
+    }(fgui.GObject));
+    fgui.GLoader3D = GLoader3D;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GMovieClip = (function (_super_1) {
+        __extends(GMovieClip, _super_1);
+        function GMovieClip() {
+            return _super_1.call(this) || this;
+        }
+        Object.defineProperty(GMovieClip.prototype, "color", {
+            get: function () {
+                return this._content.color;
+            },
+            set: function (value) {
+                if (this._content.color != value) {
+                    this._content.color = value;
+                    this.updateGear(4);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GMovieClip.prototype.createDisplayObject = function () {
+            this._content = new fgui.MovieClip();
+            this._content.touchEnabled = false;
+            this.setDisplayObject(this._content);
+        };
+        Object.defineProperty(GMovieClip.prototype, "playing", {
+            get: function () {
+                return this._content.playing;
+            },
+            set: function (value) {
+                if (this._content.playing != value) {
+                    this._content.playing = value;
+                    this.updateGear(5);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GMovieClip.prototype, "frame", {
+            get: function () {
+                return this._content.frame;
+            },
+            set: function (value) {
+                if (this._content.frame != value) {
+                    this._content.frame = value;
+                    this.updateGear(5);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GMovieClip.prototype, "timeScale", {
+            get: function () {
+                return this._content.timeScale;
+            },
+            set: function (value) {
+                this._content.timeScale = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GMovieClip.prototype.rewind = function () {
+            this._content.rewind();
+        };
+        GMovieClip.prototype.syncStatus = function (anotherMc) {
+            this._content.syncStatus(anotherMc._content);
+        };
+        GMovieClip.prototype.advance = function (timeInMiniseconds) {
+            this._content.advance(timeInMiniseconds);
+        };
+        GMovieClip.prototype.setPlaySettings = function (start, end, times, endAt, endCallback, callbackObj) {
+            this._content.setPlaySettings(start, end, times, endAt, endCallback, callbackObj);
+        };
+        GMovieClip.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    return this.color;
+                case fgui.ObjectPropID.Playing:
+                    return this.playing;
+                case fgui.ObjectPropID.Frame:
+                    return this.frame;
+                case fgui.ObjectPropID.TimeScale:
+                    return this.timeScale;
+                default:
+                    return _super_1.prototype.getProp.call(this, index);
+            }
+        };
+        GMovieClip.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    this.color = value;
+                    break;
+                case fgui.ObjectPropID.Playing:
+                    this.playing = value;
+                    break;
+                case fgui.ObjectPropID.Frame:
+                    this.frame = value;
+                    break;
+                case fgui.ObjectPropID.TimeScale:
+                    this.timeScale = value;
+                    break;
+                case fgui.ObjectPropID.DeltaTime:
+                    this.advance(value);
+                    break;
+                default:
+                    _super_1.prototype.setProp.call(this, index, value);
+                    break;
+            }
+        };
+        GMovieClip.prototype.constructFromResource = function () {
+            var contentItem = this.packageItem.getBranch();
+            this.sourceWidth = contentItem.width;
+            this.sourceHeight = contentItem.height;
+            this.initWidth = this.sourceWidth;
+            this.initHeight = this.sourceHeight;
+            this.setSize(this.sourceWidth, this.sourceHeight);
+            contentItem = contentItem.getHighResolution();
+            contentItem.load();
+            this._content.interval = contentItem.interval;
+            this._content.swing = contentItem.swing;
+            this._content.repeatDelay = contentItem.repeatDelay;
+            this._content.frames = contentItem.frames;
+            this._content.smoothing = contentItem.smoothing;
+        };
+        GMovieClip.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            if (buffer.readBool())
+                this.color = buffer.readColor();
+            buffer.readByte();
+            this._content.frame = buffer.readInt();
+            this._content.playing = buffer.readBool();
+        };
+        return GMovieClip;
+    }(fgui.GObject));
+    fgui.GMovieClip = GMovieClip;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GProgressBar = (function (_super_1) {
+        __extends(GProgressBar, _super_1);
+        function GProgressBar() {
+            var _this = _super_1.call(this) || this;
+            _this._min = 0;
+            _this._max = 0;
+            _this._value = 0;
+            _this._barMaxWidth = 0;
+            _this._barMaxHeight = 0;
+            _this._barMaxWidthDelta = 0;
+            _this._barMaxHeightDelta = 0;
+            _this._barStartX = 0;
+            _this._barStartY = 0;
+            _this._titleType = fgui.ProgressTitleType.Percent;
+            _this._value = 50;
+            _this._max = 100;
+            return _this;
+        }
+        Object.defineProperty(GProgressBar.prototype, "titleType", {
+            get: function () {
+                return this._titleType;
+            },
+            set: function (value) {
+                if (this._titleType != value) {
+                    this._titleType = value;
+                    this.update(this._value);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GProgressBar.prototype, "min", {
+            get: function () {
+                return this._min;
+            },
+            set: function (value) {
+                if (this._min != value) {
+                    this._min = value;
+                    this.update(this._value);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GProgressBar.prototype, "max", {
+            get: function () {
+                return this._max;
+            },
+            set: function (value) {
+                if (this._max != value) {
+                    this._max = value;
+                    this.update(this._value);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GProgressBar.prototype, "value", {
+            get: function () {
+                return this._value;
+            },
+            set: function (value) {
+                if (this._value != value) {
+                    fgui.GTween.kill(this, false, this.update);
+                    this._value = value;
+                    this.update(value);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GProgressBar.prototype.tweenValue = function (value, duration) {
+            var oldValule;
+            var tweener = fgui.GTween.getTween(this, this.update);
+            if (tweener) {
+                oldValule = tweener.value.x;
+                tweener.kill();
+            }
+            else
+                oldValule = this._value;
+            this._value = value;
+            return fgui.GTween.to(oldValule, this._value, duration).setTarget(this, this.update).setEase(fgui.EaseType.Linear);
+        };
+        GProgressBar.prototype.update = function (newValue) {
+            var percent = fgui.ToolSet.clamp01((newValue - this._min) / (this._max - this._min));
+            if (this._titleObject) {
+                switch (this._titleType) {
+                    case fgui.ProgressTitleType.Percent:
+                        this._titleObject.text = Math.floor(percent * 100) + "%";
+                        break;
+                    case fgui.ProgressTitleType.ValueAndMax:
+                        this._titleObject.text = Math.floor(newValue) + "/" + Math.floor(this._max);
+                        break;
+                    case fgui.ProgressTitleType.Value:
+                        this._titleObject.text = "" + Math.floor(newValue);
+                        break;
+                    case fgui.ProgressTitleType.Max:
+                        this._titleObject.text = "" + Math.floor(this._max);
+                        break;
+                }
+            }
+            var fullWidth = this.width - this._barMaxWidthDelta;
+            var fullHeight = this.height - this._barMaxHeightDelta;
+            if (!this._reverse) {
+                if (this._barObjectH) {
+                    if (!this.setFillAmount(this._barObjectH, percent))
+                        this._barObjectH.width = Math.round(fullWidth * percent);
+                }
+                if (this._barObjectV) {
+                    if (!this.setFillAmount(this._barObjectV, percent))
+                        this._barObjectV.height = Math.round(fullHeight * percent);
+                }
+            }
+            else {
+                if (this._barObjectH) {
+                    if (!this.setFillAmount(this._barObjectH, 1 - percent)) {
+                        this._barObjectH.width = Math.round(fullWidth * percent);
+                        this._barObjectH.x = this._barStartX + (fullWidth - this._barObjectH.width);
+                    }
+                }
+                if (this._barObjectV) {
+                    if (!this.setFillAmount(this._barObjectV, 1 - percent)) {
+                        this._barObjectV.height = Math.round(fullHeight * percent);
+                        this._barObjectV.y = this._barStartY + (fullHeight - this._barObjectV.height);
+                    }
+                }
+            }
+            if (this._aniObject)
+                this._aniObject.setProp(fgui.ObjectPropID.Frame, Math.floor(percent * 100));
+        };
+        GProgressBar.prototype.setFillAmount = function (bar, percent) {
+            if (((bar instanceof fgui.GImage) || (bar instanceof fgui.GLoader)) && bar.fillMethod != fgui.FillMethod.None) {
+                bar.fillAmount = percent;
+                return true;
+            }
+            else
+                return false;
+        };
+        GProgressBar.prototype.constructExtension = function (buffer) {
+            buffer.seek(0, 6);
+            this._titleType = buffer.readByte();
+            this._reverse = buffer.readBool();
+            this._titleObject = this.getChild("title");
+            this._barObjectH = this.getChild("bar");
+            this._barObjectV = this.getChild("bar_v");
+            this._aniObject = this.getChild("ani");
+            if (this._barObjectH) {
+                this._barMaxWidth = this._barObjectH.width;
+                this._barMaxWidthDelta = this.width - this._barMaxWidth;
+                this._barStartX = this._barObjectH.x;
+            }
+            if (this._barObjectV) {
+                this._barMaxHeight = this._barObjectV.height;
+                this._barMaxHeightDelta = this.height - this._barMaxHeight;
+                this._barStartY = this._barObjectV.y;
+            }
+        };
+        GProgressBar.prototype.handleSizeChanged = function () {
+            _super_1.prototype.handleSizeChanged.call(this);
+            if (this._barObjectH)
+                this._barMaxWidth = this.width - this._barMaxWidthDelta;
+            if (this._barObjectV)
+                this._barMaxHeight = this.height - this._barMaxHeightDelta;
+            if (!this._underConstruct)
+                this.update(this._value);
+        };
+        GProgressBar.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            if (!buffer.seek(beginPos, 6)) {
+                this.update(this._value);
+                return;
+            }
+            if (buffer.readByte() != this.packageItem.objectType) {
+                this.update(this._value);
+                return;
+            }
+            this._value = buffer.readInt();
+            this._max = buffer.readInt();
+            if (buffer.version >= 2)
+                this._min = buffer.readInt();
+            this.update(this._value);
+        };
+        return GProgressBar;
+    }(fgui.GComponent));
+    fgui.GProgressBar = GProgressBar;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GTextField = (function (_super_1) {
+        __extends(GTextField, _super_1);
+        function GTextField() {
+            var _this = _super_1.call(this) || this;
+            _this._fontSize = 0;
+            _this._leading = 0;
+            _this._letterSpacing = 0;
+            _this._textWidth = 0;
+            _this._textHeight = 0;
+            _this._fontSize = 12;
+            _this._align = fgui.AlignType.Left;
+            _this._verticalAlign = fgui.VertAlignType.Top;
+            _this._text = "";
+            _this._leading = 3;
+            _this._color = 0;
+            _this._autoSize = fgui.AutoSizeType.Both;
+            _this._widthAutoSize = true;
+            _this._heightAutoSize = true;
+            return _this;
+        }
+        GTextField.prototype.createDisplayObject = function () {
+            this._textField = new egret.TextField();
+            this._textField.touchEnabled = false;
+            this.setDisplayObject(this._textField);
+        };
+        GTextField.prototype.switchBitmapMode = function (val) {
+            if (val && this.displayObject == this._textField) {
+                if (this._bitmapContainer == null)
+                    this._bitmapContainer = new egret.Sprite();
+                this.switchDisplayObject(this._bitmapContainer);
+            }
+            else if (!val && this.displayObject == this._bitmapContainer)
+                this.switchDisplayObject(this._textField);
+        };
+        GTextField.prototype.dispose = function () {
+            _super_1.prototype.dispose.call(this);
+            this._bitmapFont = null;
+            this._requireRender = false;
+        };
+        Object.defineProperty(GTextField.prototype, "text", {
+            get: function () {
+                return this._text;
+            },
+            set: function (value) {
+                this._text = value;
+                if (this._text == null)
+                    this._text = "";
+                this.updateGear(6);
+                if (this.parent && this.parent._underConstruct)
+                    this.renderNow();
+                else
+                    this.render();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTextField.prototype.updateTextFieldText = function () {
+            var text2 = this._text;
+            if (this._templateVars)
+                text2 = this.parseTemplate(text2);
+            if (this._ubbEnabled) {
+                var arr = GTextField._htmlParser.parser(fgui.UBBParser.inst.parse(fgui.ToolSet.encodeHTML(text2)));
+                if (this._underline) {
+                    for (var i = 0; i < arr.length; i++) {
+                        var element = arr[i];
+                        if (element.style)
+                            element.style.underline = true;
+                        else
+                            element.style = { underline: true };
+                    }
+                }
+                this._textField.textFlow = arr;
+            }
+            else if (this._underline) {
+                var arr = new Array(1);
+                arr[0] = { text: text2, style: { underline: true } };
+                this._textField.textFlow = arr;
+            }
+            else
+                this._textField.text = text2;
+        };
+        Object.defineProperty(GTextField.prototype, "font", {
+            get: function () {
+                return this._font;
+            },
+            set: function (value) {
+                if (this._font != value) {
+                    this._font = value;
+                    this.updateTextFormat();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "fontSize", {
+            get: function () {
+                return this._fontSize;
+            },
+            set: function (value) {
+                if (value < 0)
+                    return;
+                if (this._fontSize != value) {
+                    this._fontSize = value;
+                    this.updateTextFormat();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "color", {
+            get: function () {
+                return this._color;
+            },
+            set: function (value) {
+                if (this._color != value) {
+                    this._color = value;
+                    this.updateGear(4);
+                    this.updateTextFormat();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "align", {
+            get: function () {
+                return this._align;
+            },
+            set: function (value) {
+                if (this._align != value) {
+                    this._align = value;
+                    this._textField.textAlign = this.getAlignTypeString(this._align);
+                    if (this._bitmapFont && !this._underConstruct)
+                        this.render();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "verticalAlign", {
+            get: function () {
+                return this._verticalAlign;
+            },
+            set: function (value) {
+                if (this._verticalAlign != value) {
+                    this._verticalAlign = value;
+                    this._textField.verticalAlign = this.getVertAlignTypeString(this._verticalAlign);
+                    if (this._bitmapFont && !this._underConstruct)
+                        this.render();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTextField.prototype.getAlignTypeString = function (type) {
+            return type == fgui.AlignType.Left ? egret.HorizontalAlign.LEFT :
+                (type == fgui.AlignType.Center ? egret.HorizontalAlign.CENTER : egret.HorizontalAlign.RIGHT);
+        };
+        GTextField.prototype.getVertAlignTypeString = function (type) {
+            return type == fgui.VertAlignType.Top ? egret.VerticalAlign.TOP :
+                (type == fgui.VertAlignType.Middle ? egret.VerticalAlign.MIDDLE : egret.VerticalAlign.BOTTOM);
+        };
+        Object.defineProperty(GTextField.prototype, "leading", {
+            get: function () {
+                return this._leading;
+            },
+            set: function (value) {
+                if (this._leading != value) {
+                    this._leading = value;
+                    this.updateTextFormat();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "letterSpacing", {
+            get: function () {
+                return this._letterSpacing;
+            },
+            set: function (value) {
+                if (this._letterSpacing != value) {
+                    this._letterSpacing = value;
+                    this.updateTextFormat();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "underline", {
+            get: function () {
+                return this._underline;
+            },
+            set: function (value) {
+                this._underline = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "bold", {
+            get: function () {
+                return this._textField.bold;
+            },
+            set: function (value) {
+                this._textField.bold = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "italic", {
+            get: function () {
+                return this._textField.italic;
+            },
+            set: function (value) {
+                this._textField.italic = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "singleLine", {
+            get: function () {
+                return !this._textField.multiline;
+            },
+            set: function (value) {
+                value = !value;
+                if (this._textField.multiline != value) {
+                    this._textField.multiline = value;
+                    this.render();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "stroke", {
+            get: function () {
+                return this._textField.stroke;
+            },
+            set: function (value) {
+                this._textField.stroke = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "strokeColor", {
+            get: function () {
+                return this._textField.strokeColor;
+            },
+            set: function (value) {
+                this._textField.strokeColor = value;
+                this.updateGear(4);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "ubbEnabled", {
+            get: function () {
+                return this._ubbEnabled;
+            },
+            set: function (value) {
+                if (this._ubbEnabled != value) {
+                    this._ubbEnabled = value;
+                    this.render();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "autoSize", {
+            get: function () {
+                return this._autoSize;
+            },
+            set: function (value) {
+                if (this._autoSize != value) {
+                    this._autoSize = value;
+                    this._widthAutoSize = value == fgui.AutoSizeType.Both;
+                    this._heightAutoSize = value == fgui.AutoSizeType.Both || value == fgui.AutoSizeType.Height;
+                    this.render();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextField.prototype, "textWidth", {
+            get: function () {
+                if (this._requireRender)
+                    this.renderNow();
+                return this._textWidth;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTextField.prototype.ensureSizeCorrect = function () {
+            if (this._sizeDirty && this._requireRender)
+                this.renderNow();
+        };
+        GTextField.prototype.updateTextFormat = function () {
+            this._textField.size = this._fontSize;
+            this._bitmapFont = null;
+            if (fgui.ToolSet.startsWith(this._font, "ui://")) {
+                var pi = fgui.UIPackage.getItemByURL(this._font);
+                if (pi)
+                    this._bitmapFont = pi.owner.getItemAsset(pi);
+            }
+            if (this._bitmapFont == null) {
+                if (this._font)
+                    this._textField.fontFamily = this._font;
+                else
+                    this._textField.fontFamily = fgui.UIConfig.defaultFont;
+            }
+            if (this.grayed)
+                this._textField.textColor = 0xAAAAAA;
+            else
+                this._textField.textColor = this._color;
+            this._textField.lineSpacing = this._leading;
+            if (!this._underConstruct)
+                this.render();
+        };
+        GTextField.prototype.render = function () {
+            if (!this._requireRender) {
+                this._requireRender = true;
+                egret.callLater(this.__render, this);
+            }
+            if (!this._sizeDirty && (this._widthAutoSize || this._heightAutoSize)) {
+                this._sizeDirty = true;
+                this.dispatchEventWith(fgui.GObject.SIZE_DELAY_CHANGE);
+            }
+        };
+        GTextField.prototype.__render = function () {
+            if (this._requireRender)
+                this.renderNow();
+        };
+        GTextField.prototype.renderNow = function (updateBounds) {
+            if (updateBounds === void 0) { updateBounds = true; }
+            this._requireRender = false;
+            this._sizeDirty = false;
+            if (this._bitmapFont) {
+                this.renderWithBitmapFont(updateBounds);
+                return;
+            }
+            this.switchBitmapMode(false);
+            this._textField.width = this._widthAutoSize ? (this.maxWidth <= 0 ? 10000 : this.maxWidth) : Math.ceil(this.width);
+            this.updateTextFieldText();
+            this._textWidth = Math.ceil(this._textField.textWidth);
+            if (this._textWidth > 0)
+                this._textWidth += 4;
+            this._textHeight = Math.ceil(this._textField.textHeight);
+            if (this._textHeight > 0)
+                this._textHeight += 4;
+            var w, h = 0;
+            if (this._widthAutoSize) {
+                w = this._textWidth;
+                this._textField.width = w;
+            }
+            else
+                w = this.width;
+            if (this._heightAutoSize) {
+                h = this._textHeight;
+                if (this._textField.height != this._textHeight)
+                    this._textField.height = this._textHeight;
+            }
+            else {
+                h = this.height;
+                if (this._textHeight > h)
+                    this._textHeight = h;
+            }
+            if (updateBounds) {
+                this._updatingSize = true;
+                this.setSize(w, h);
+                this._updatingSize = false;
+            }
+        };
+        GTextField.prototype.renderWithBitmapFont = function (updateBounds) {
+            this.switchBitmapMode(true);
+            if (!this._bitmapPool)
+                this._bitmapPool = [];
+            var cnt = this._bitmapContainer.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                var obj = this._bitmapContainer.getChildAt(i);
+                this._bitmapPool.push(obj);
+            }
+            this._bitmapContainer.removeChildren();
+            if (!this._lines)
+                this._lines = new Array();
+            else
+                returnList(this._lines);
+            var letterSpacing = this._letterSpacing;
+            var lineSpacing = this._leading - 1;
+            var rectWidth = this.width - GUTTER_X * 2;
+            var lineWidth = 0, lineHeight = 0, lineTextHeight = 0;
+            var glyphWidth = 0, glyphHeight = 0;
+            var wordChars = 0, wordStart = 0, wordEnd = 0;
+            var lastLineHeight = 0;
+            var lineBuffer = "";
+            var lineY = GUTTER_Y;
+            var line;
+            var wordWrap = !this._widthAutoSize && this._textField.multiline;
+            var fontScale = this._bitmapFont.resizable ? this._fontSize / this._bitmapFont.size : 1;
+            var tint = this._bitmapFont.tint;
+            this._textWidth = 0;
+            this._textHeight = 0;
+            var text2 = this._text;
+            if (this._templateVars)
+                text2 = this.parseTemplate(text2);
+            var textLength = text2.length;
+            for (var offset = 0; offset < textLength; ++offset) {
+                var ch = text2.charAt(offset);
+                var cc = ch.charCodeAt(0);
+                if (cc == 10) {
+                    lineBuffer += ch;
+                    line = borrow();
+                    line.width = lineWidth;
+                    if (lineTextHeight == 0) {
+                        if (lastLineHeight == 0)
+                            lastLineHeight = this._fontSize;
+                        if (lineHeight == 0)
+                            lineHeight = lastLineHeight;
+                        lineTextHeight = lineHeight;
+                    }
+                    line.height = lineHeight;
+                    lastLineHeight = lineHeight;
+                    line.textHeight = lineTextHeight;
+                    line.text = lineBuffer;
+                    line.y = lineY;
+                    lineY += (line.height + lineSpacing);
+                    if (line.width > this._textWidth)
+                        this._textWidth = line.width;
+                    this._lines.push(line);
+                    lineBuffer = "";
+                    lineWidth = 0;
+                    lineHeight = 0;
+                    lineTextHeight = 0;
+                    wordChars = 0;
+                    wordStart = 0;
+                    wordEnd = 0;
+                    continue;
+                }
+                if (cc >= 65 && cc <= 90 || cc >= 97 && cc <= 122) {
+                    if (wordChars == 0)
+                        wordStart = lineWidth;
+                    wordChars++;
+                }
+                else {
+                    if (wordChars > 0)
+                        wordEnd = lineWidth;
+                    wordChars = 0;
+                }
+                if (cc == 32) {
+                    glyphWidth = Math.ceil(this._fontSize / 2);
+                    glyphHeight = this._fontSize;
+                }
+                else {
+                    var glyph = this._bitmapFont.glyphs[ch];
+                    if (glyph) {
+                        glyphWidth = Math.ceil(glyph.advance * fontScale);
+                        glyphHeight = Math.ceil(glyph.lineHeight * fontScale);
+                    }
+                    else {
+                        glyphWidth = 0;
+                        glyphHeight = 0;
+                    }
+                }
+                if (glyphHeight > lineTextHeight)
+                    lineTextHeight = glyphHeight;
+                if (glyphHeight > lineHeight)
+                    lineHeight = glyphHeight;
+                if (lineWidth != 0)
+                    lineWidth += letterSpacing;
+                lineWidth += glyphWidth;
+                if (!wordWrap || lineWidth <= rectWidth) {
+                    lineBuffer += ch;
+                }
+                else {
+                    line = borrow();
+                    line.height = lineHeight;
+                    line.textHeight = lineTextHeight;
+                    if (lineBuffer.length == 0) {
+                        line.text = ch;
+                    }
+                    else if (wordChars > 0 && wordEnd > 0) {
+                        lineBuffer += ch;
+                        var len = lineBuffer.length - wordChars;
+                        line.text = fgui.ToolSet.trimRight(lineBuffer.substr(0, len));
+                        line.width = wordEnd;
+                        lineBuffer = lineBuffer.substr(len);
+                        lineWidth -= wordStart;
+                    }
+                    else {
+                        line.text = lineBuffer;
+                        line.width = lineWidth - (glyphWidth + letterSpacing);
+                        lineBuffer = ch;
+                        lineWidth = glyphWidth;
+                        lineHeight = glyphHeight;
+                        lineTextHeight = glyphHeight;
+                    }
+                    line.y = lineY;
+                    lineY += (line.height + lineSpacing);
+                    if (line.width > this._textWidth)
+                        this._textWidth = line.width;
+                    wordChars = 0;
+                    wordStart = 0;
+                    wordEnd = 0;
+                    this._lines.push(line);
+                }
+            }
+            if (lineBuffer.length > 0) {
+                line = borrow();
+                line.width = lineWidth;
+                if (lineHeight == 0)
+                    lineHeight = lastLineHeight;
+                if (lineTextHeight == 0)
+                    lineTextHeight = lineHeight;
+                line.height = lineHeight;
+                line.textHeight = lineTextHeight;
+                line.text = lineBuffer;
+                line.y = lineY;
+                if (line.width > this._textWidth)
+                    this._textWidth = line.width;
+                this._lines.push(line);
+            }
+            if (this._textWidth > 0)
+                this._textWidth += GUTTER_X * 2;
+            var count = this._lines.length;
+            if (count == 0) {
+                this._textHeight = 0;
+            }
+            else {
+                line = this._lines[this._lines.length - 1];
+                this._textHeight = line.y + line.height + GUTTER_Y;
+            }
+            var w, h = 0;
+            if (this._widthAutoSize) {
+                if (this._textWidth == 0)
+                    w = 0;
+                else
+                    w = this._textWidth;
+            }
+            else
+                w = this.width;
+            if (this._heightAutoSize) {
+                if (this._textHeight == 0)
+                    h = 0;
+                else
+                    h = this._textHeight;
+            }
+            else
+                h = this.height;
+            if (updateBounds) {
+                this._updatingSize = true;
+                this.setSize(w, h);
+                this._updatingSize = false;
+            }
+            if (w == 0 || h == 0)
+                return;
+            var charX = GUTTER_X;
+            var lineIndent = 0;
+            var charIndent = 0;
+            rectWidth = this.width - GUTTER_X * 2;
+            var lineCount = this._lines.length;
+            for (var i = 0; i < lineCount; i++) {
+                line = this._lines[i];
+                charX = GUTTER_X;
+                if (this._align == fgui.AlignType.Center)
+                    lineIndent = (rectWidth - line.width) / 2;
+                else if (this._align == fgui.AlignType.Right)
+                    lineIndent = rectWidth - line.width;
+                else
+                    lineIndent = 0;
+                textLength = line.text.length;
+                for (var j = 0; j < textLength; j++) {
+                    ch = line.text.charAt(j);
+                    cc = ch.charCodeAt(0);
+                    if (cc == 10)
+                        continue;
+                    if (cc == 32) {
+                        charX += letterSpacing + Math.ceil(this._fontSize / 2);
+                        continue;
+                    }
+                    glyph = this._bitmapFont.glyphs[ch];
+                    if (glyph) {
+                        charIndent = (line.height + line.textHeight) / 2 - Math.ceil(glyph.lineHeight * fontScale);
+                        var bm;
+                        if (this._bitmapPool.length)
+                            bm = this._bitmapPool.pop();
+                        else {
+                            bm = new egret.Bitmap();
+                            bm.smoothing = true;
+                        }
+                        bm.x = charX + lineIndent + Math.ceil(glyph.x * fontScale);
+                        bm.y = line.y + charIndent + Math.ceil(glyph.y * fontScale);
+                        bm["$backupY"] = bm.y;
+                        bm.texture = glyph.texture;
+                        bm.scaleX = fontScale;
+                        bm.scaleY = fontScale;
+                        if (tint)
+                            bm.tint = this._color;
+                        else
+                            bm.tint = 0xFFFFFF;
+                        this._bitmapContainer.addChild(bm);
+                        charX += letterSpacing + Math.ceil(glyph.advance * fontScale);
+                    }
+                    else {
+                        charX += letterSpacing;
+                    }
+                }
+            }
+            this.doAlign();
+        };
+        GTextField.prototype.handleSizeChanged = function () {
+            if (this._updatingSize)
+                return;
+            if (this._bitmapFont) {
+                if (!this._widthAutoSize)
+                    this.render();
+                else
+                    this.doAlign();
+            }
+            else {
+                if (this._underConstruct) {
+                    this._textField.width = this.width;
+                    this._textField.height = this.height;
+                }
+                else {
+                    if (!this._widthAutoSize) {
+                        if (!this._heightAutoSize) {
+                            this._textField.width = this.width;
+                            this._textField.height = this.height;
+                        }
+                        else
+                            this._textField.width = this.width;
+                    }
+                }
+            }
+        };
+        GTextField.prototype.parseTemplate = function (template) {
+            var pos1 = 0, pos2, pos3;
+            var tag;
+            var value;
+            var result = "";
+            while ((pos2 = template.indexOf("{", pos1)) != -1) {
+                if (pos2 > 0 && template.charCodeAt(pos2 - 1) == 92) {
+                    result += template.substring(pos1, pos2 - 1);
+                    result += "{";
+                    pos1 = pos2 + 1;
+                    continue;
+                }
+                result += template.substring(pos1, pos2);
+                pos1 = pos2;
+                pos2 = template.indexOf("}", pos1);
+                if (pos2 == -1)
+                    break;
+                if (pos2 == pos1 + 1) {
+                    result += template.substr(pos1, 2);
+                    pos1 = pos2 + 1;
+                    continue;
+                }
+                tag = template.substring(pos1 + 1, pos2);
+                pos3 = tag.indexOf("=");
+                if (pos3 != -1) {
+                    value = this._templateVars[tag.substring(0, pos3)];
+                    if (value == null)
+                        result += tag.substring(pos3 + 1);
+                    else
+                        result += value;
+                }
+                else {
+                    value = this._templateVars[tag];
+                    if (value != null)
+                        result += value;
+                }
+                pos1 = pos2 + 1;
+            }
+            if (pos1 < template.length)
+                result += template.substr(pos1);
+            return result;
+        };
+        Object.defineProperty(GTextField.prototype, "templateVars", {
+            get: function () {
+                return this._templateVars;
+            },
+            set: function (value) {
+                if (!this._templateVars && !value)
+                    return;
+                this._templateVars = value;
+                this.flushVars();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTextField.prototype.setVar = function (name, value) {
+            if (!this._templateVars)
+                this._templateVars = {};
+            this._templateVars[name] = value;
+            return this;
+        };
+        GTextField.prototype.flushVars = function () {
+            this.render();
+        };
+        GTextField.prototype.handleGrayedChanged = function () {
+            _super_1.prototype.handleGrayedChanged.call(this);
+            this.updateTextFormat();
+        };
+        GTextField.prototype.doAlign = function () {
+            var yOffset;
+            if (this._verticalAlign == fgui.VertAlignType.Top || this._textHeight == 0)
+                yOffset = GUTTER_Y;
+            else {
+                var dh = this.height - this._textHeight;
+                if (dh < 0)
+                    dh = 0;
+                if (this._verticalAlign == fgui.VertAlignType.Middle)
+                    yOffset = Math.floor(dh / 2);
+                else
+                    yOffset = Math.floor(dh);
+            }
+            var cnt = this._bitmapContainer.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                var obj = this._bitmapContainer.getChildAt(i);
+                obj.y = obj["$backupY"] + yOffset;
+            }
+        };
+        GTextField.prototype.getProp = function (index) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    return this.color;
+                case fgui.ObjectPropID.OutlineColor:
+                    return this.strokeColor;
+                case fgui.ObjectPropID.FontSize:
+                    return this.fontSize;
+                default:
+                    return _super_1.prototype.getProp.call(this, index);
+            }
+        };
+        GTextField.prototype.setProp = function (index, value) {
+            switch (index) {
+                case fgui.ObjectPropID.Color:
+                    this.color = value;
+                    break;
+                case fgui.ObjectPropID.OutlineColor:
+                    this.strokeColor = value;
+                    break;
+                case fgui.ObjectPropID.FontSize:
+                    this.fontSize = value;
+                    break;
+                default:
+                    _super_1.prototype.setProp.call(this, index, value);
+                    break;
+            }
+        };
+        GTextField.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 5);
+            this._font = buffer.readS();
+            this._fontSize = buffer.readShort();
+            this._color = buffer.readColor();
+            this.align = buffer.readByte();
+            this.verticalAlign = buffer.readByte();
+            this._leading = buffer.readShort();
+            this._letterSpacing = buffer.readShort();
+            this._ubbEnabled = buffer.readBool();
+            this._autoSize = buffer.readByte();
+            this._widthAutoSize = this._autoSize == fgui.AutoSizeType.Both;
+            this._heightAutoSize = this._autoSize == fgui.AutoSizeType.Both || this._autoSize == fgui.AutoSizeType.Height;
+            this._underline = buffer.readBool();
+            this._textField.italic = buffer.readBool();
+            this._textField.bold = buffer.readBool();
+            this._textField.multiline = !buffer.readBool();
+            if (buffer.readBool()) {
+                this._textField.strokeColor = buffer.readColor();
+                this.stroke = buffer.readFloat() + 1;
+            }
+            if (buffer.readBool())
+                buffer.skip(12);
+            if (buffer.readBool())
+                this._templateVars = {};
+        };
+        GTextField.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            this.updateTextFormat();
+            buffer.seek(beginPos, 6);
+            var str = buffer.readS();
+            if (str != null)
+                this.text = str;
+            this._sizeDirty = false;
+        };
+        GTextField._htmlParser = new egret.HtmlTextParser();
+        return GTextField;
+    }(fgui.GObject));
+    fgui.GTextField = GTextField;
+    var pool = [];
+    function borrow() {
+        if (pool.length) {
+            var ret = pool.pop();
+            ret.width = 0;
+            ret.height = 0;
+            ret.textHeight = 0;
+            ret.text = null;
+            ret.y = 0;
+            return ret;
+        }
+        else
+            return {
+                width: 0,
+                height: 0,
+                textHeight: 0,
+                text: null,
+                y: 0
+            };
+    }
+    function returnList(value) {
+        var length = value.length;
+        for (var i = 0; i < length; i++) {
+            var li = value[i];
+            pool.push(li);
+        }
+        value.length = 0;
+    }
+    var GUTTER_X = 2;
+    var GUTTER_Y = 2;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GRichTextField = (function (_super_1) {
+        __extends(GRichTextField, _super_1);
+        function GRichTextField() {
+            var _this = _super_1.call(this) || this;
+            _this._textField.touchEnabled = true;
+            return _this;
+        }
+        GRichTextField.prototype.updateTextFieldText = function () {
+            var text2 = this._text;
+            if (this._templateVars)
+                text2 = this.parseTemplate(text2);
+            var arr;
+            if (this._ubbEnabled)
+                arr = fgui.GTextField._htmlParser.parser(fgui.UBBParser.inst.parse(text2));
+            else
+                arr = fgui.GTextField._htmlParser.parser(text2);
+            if (this._underline) {
+                for (var i = 0; i < arr.length; i++) {
+                    var element = arr[i];
+                    if (element.style)
+                        element.style.underline = true;
+                    else
+                        element.style = { underline: true };
+                }
+            }
+            this._textField.textFlow = arr;
+        };
+        return GRichTextField;
+    }(fgui.GTextField));
+    fgui.GRichTextField = GRichTextField;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GRoot = (function (_super_1) {
+        __extends(GRoot, _super_1);
+        function GRoot() {
+            var _this = _super_1.call(this) || this;
+            if (GRoot._inst == null)
+                GRoot._inst = _this;
+            _this.opaque = false;
+            _this._volumeScale = 1;
+            _this._popupStack = new Array();
+            _this._justClosedPopups = new Array();
+            _this.displayObject.addEventListener(egret.Event.ADDED_TO_STAGE, _this.__addedToStage, _this);
+            return _this;
+        }
+        Object.defineProperty(GRoot, "inst", {
+            get: function () {
+                if (GRoot._inst == null)
+                    new GRoot();
+                return GRoot._inst;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GRoot.prototype, "nativeStage", {
+            get: function () {
+                return this._nativeStage;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GRoot.prototype.showWindow = function (win) {
+            this.addChild(win);
+            win.requestFocus();
+            if (win.x > this.width)
+                win.x = this.width - win.width;
+            else if (win.x + win.width < 0)
+                win.x = 0;
+            if (win.y > this.height)
+                win.y = this.height - win.height;
+            else if (win.y + win.height < 0)
+                win.y = 0;
+            this.adjustModalLayer();
+        };
+        GRoot.prototype.hideWindow = function (win) {
+            win.hide();
+        };
+        GRoot.prototype.hideWindowImmediately = function (win) {
+            if (win.parent == this)
+                this.removeChild(win);
+            this.adjustModalLayer();
+        };
+        GRoot.prototype.bringToFront = function (win) {
+            var cnt = this.numChildren;
+            var i;
+            if (this._modalLayer.parent != null && !win.modal)
+                i = this.getChildIndex(this._modalLayer) - 1;
+            else
+                i = cnt - 1;
+            for (; i >= 0; i--) {
+                var g = this.getChildAt(i);
+                if (g == win)
+                    return;
+                if (g instanceof fgui.Window)
+                    break;
+            }
+            if (i >= 0)
+                this.setChildIndex(win, i);
+        };
+        GRoot.prototype.showModalWait = function (msg) {
+            if (fgui.UIConfig.globalModalWaiting != null) {
+                if (this._modalWaitPane == null)
+                    this._modalWaitPane = fgui.UIPackage.createObjectFromURL(fgui.UIConfig.globalModalWaiting);
+                this._modalWaitPane.setSize(this.width, this.height);
+                this._modalWaitPane.addRelation(this, fgui.RelationType.Size);
+                this.addChild(this._modalWaitPane);
+                this._modalWaitPane.text = msg;
+            }
+        };
+        GRoot.prototype.closeModalWait = function () {
+            if (this._modalWaitPane != null && this._modalWaitPane.parent != null)
+                this.removeChild(this._modalWaitPane);
+        };
+        GRoot.prototype.closeAllExceptModals = function () {
+            var arr = this._children.slice();
+            var cnt = arr.length;
+            for (var i = 0; i < cnt; i++) {
+                var g = arr[i];
+                if ((g instanceof fgui.Window) && !g.modal)
+                    g.hide();
+            }
+        };
+        GRoot.prototype.closeAllWindows = function () {
+            var arr = this._children.slice();
+            var cnt = arr.length;
+            for (var i = 0; i < cnt; i++) {
+                var g = arr[i];
+                if (g instanceof fgui.Window)
+                    g.hide();
+            }
+        };
+        GRoot.prototype.getTopWindow = function () {
+            var cnt = this.numChildren;
+            for (var i = cnt - 1; i >= 0; i--) {
+                var g = this.getChildAt(i);
+                if (g instanceof fgui.Window) {
+                    return g;
+                }
+            }
+            return null;
+        };
+        Object.defineProperty(GRoot.prototype, "modalLayer", {
+            get: function () {
+                return this._modalLayer;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GRoot.prototype, "hasModalWindow", {
+            get: function () {
+                return this._modalLayer.parent != null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GRoot.prototype, "modalWaiting", {
+            get: function () {
+                return this._modalWaitPane && this._modalWaitPane.inContainer;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GRoot.prototype.showPopup = function (popup, target, dir) {
+            if (this._popupStack.length > 0) {
+                var k = this._popupStack.indexOf(popup);
+                if (k != -1) {
+                    for (var i = this._popupStack.length - 1; i >= k; i--)
+                        this.removeChild(this._popupStack.pop());
+                }
+            }
+            this._popupStack.push(popup);
+            if (target) {
+                var p = target;
+                while (p) {
+                    if (p.parent == this) {
+                        if (popup.sortingOrder < p.sortingOrder) {
+                            popup.sortingOrder = p.sortingOrder;
+                        }
+                        break;
+                    }
+                    p = p.parent;
+                }
+            }
+            this.addChild(popup);
+            this.adjustModalLayer();
+            var pos;
+            var sizeW = 0, sizeH = 0;
+            if (target) {
+                pos = target.localToRoot();
+                sizeW = target.width;
+                sizeH = target.height;
+            }
+            else {
+                pos = this.globalToLocal(GRoot.mouseX, GRoot.mouseY);
+            }
+            var xx, yy;
+            xx = pos.x;
+            if (xx + popup.width > this.width)
+                xx = xx + sizeW - popup.width;
+            yy = pos.y + sizeH;
+            if (((dir === undefined || dir === fgui.PopupDirection.Auto) && pos.y + popup.height > this.height)
+                || dir === false || dir === fgui.PopupDirection.Up) {
+                yy = pos.y - popup.height - 1;
+                if (yy < 0) {
+                    yy = 0;
+                    xx += sizeW / 2;
+                }
+            }
+            popup.x = xx;
+            popup.y = yy;
+        };
+        GRoot.prototype.togglePopup = function (popup, target, dir) {
+            if (this._justClosedPopups.indexOf(popup) != -1)
+                return;
+            this.showPopup(popup, target, dir);
+        };
+        GRoot.prototype.hidePopup = function (popup) {
+            if (popup) {
+                var k = this._popupStack.indexOf(popup);
+                if (k != -1) {
+                    for (var i = this._popupStack.length - 1; i >= k; i--)
+                        this.closePopup(this._popupStack.pop());
+                }
+            }
+            else {
+                var cnt = this._popupStack.length;
+                for (i = cnt - 1; i >= 0; i--)
+                    this.closePopup(this._popupStack[i]);
+                this._popupStack.length = 0;
+            }
+        };
+        Object.defineProperty(GRoot.prototype, "hasAnyPopup", {
+            get: function () {
+                return this._popupStack.length != 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GRoot.prototype.closePopup = function (target) {
+            if (target.parent) {
+                if (target instanceof fgui.Window)
+                    target.hide();
+                else
+                    this.removeChild(target);
+            }
+        };
+        GRoot.prototype.showTooltips = function (msg) {
+            if (this._defaultTooltipWin == null) {
+                var resourceURL = fgui.UIConfig.tooltipsWin;
+                if (!resourceURL) {
+                    console.error("UIConfig.tooltipsWin not defined");
+                    return;
+                }
+                this._defaultTooltipWin = fgui.UIPackage.createObjectFromURL(resourceURL);
+            }
+            this._defaultTooltipWin.text = msg;
+            this.showTooltipsWin(this._defaultTooltipWin);
+        };
+        GRoot.prototype.showTooltipsWin = function (tooltipWin, position) {
+            this.hideTooltips();
+            this._tooltipWin = tooltipWin;
+            var xx = 0;
+            var yy = 0;
+            if (!position) {
+                xx = GRoot.mouseX + 10;
+                yy = GRoot.mouseY + 20;
+            }
+            else {
+                xx = position.x;
+                yy = position.y;
+            }
+            var pt = this.globalToLocal(xx, yy);
+            xx = pt.x;
+            yy = pt.y;
+            if (xx + this._tooltipWin.width > this.width) {
+                xx = xx - this._tooltipWin.width - 1;
+                if (xx < 0)
+                    xx = 10;
+            }
+            if (yy + this._tooltipWin.height > this.height) {
+                yy = yy - this._tooltipWin.height - 1;
+                if (xx - this._tooltipWin.width - 1 > 0)
+                    xx = xx - this._tooltipWin.width - 1;
+                if (yy < 0)
+                    yy = 10;
+            }
+            this._tooltipWin.x = xx;
+            this._tooltipWin.y = yy;
+            this.addChild(this._tooltipWin);
+        };
+        GRoot.prototype.hideTooltips = function () {
+            if (this._tooltipWin) {
+                if (this._tooltipWin.parent)
+                    this.removeChild(this._tooltipWin);
+                this._tooltipWin = null;
+            }
+        };
+        GRoot.prototype.getObjectUnderPoint = function (globalX, globalY) {
+            var ret = this._nativeStage.$hitTest(globalX, globalY);
+            if (ret)
+                return fgui.ToolSet.displayObjectToGObject(ret);
+            else
+                return null;
+        };
+        Object.defineProperty(GRoot.prototype, "focus", {
+            get: function () {
+                return null;
+            },
+            set: function (value) {
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GRoot.prototype.setFocus = function (value) {
+        };
+        Object.defineProperty(GRoot.prototype, "volumeScale", {
+            get: function () {
+                return this._volumeScale;
+            },
+            set: function (value) {
+                this._volumeScale = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GRoot.prototype.playOneShotSound = function (sound, volumeScale) {
+            volumeScale = volumeScale || 1;
+            var vs = this._volumeScale * volumeScale;
+            var channel = sound.play(0, 1);
+            channel.volume = vs;
+        };
+        GRoot.prototype.adjustModalLayer = function () {
+            var cnt = this.numChildren;
+            if (this._modalWaitPane && this._modalWaitPane.parent)
+                this.setChildIndex(this._modalWaitPane, cnt - 1);
+            for (var i = cnt - 1; i >= 0; i--) {
+                var g = this.getChildAt(i);
+                if ((g instanceof fgui.Window) && g.modal) {
+                    if (this._modalLayer.parent == null)
+                        this.addChildAt(this._modalLayer, i);
+                    else
+                        this.setChildIndexBefore(this._modalLayer, i);
+                    return;
+                }
+            }
+            if (this._modalLayer.parent)
+                this.removeChild(this._modalLayer);
+        };
+        GRoot.prototype.__addedToStage = function (evt) {
+            this.displayObject.removeEventListener(egret.Event.ADDED_TO_STAGE, this.__addedToStage, this);
+            this._nativeStage = this.displayObject.stage;
+            this._nativeStage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__stageMouseDownCapture, this, true);
+            this._nativeStage.addEventListener(egret.TouchEvent.TOUCH_END, this.__stageMouseUpCapture, this, true);
+            this._nativeStage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.__stageMouseMoveCapture, this, true);
+            this._modalLayer = new fgui.GGraph();
+            this._modalLayer.setSize(this.width, this.height);
+            this._modalLayer.drawRect(0, 0, 0, fgui.UIConfig.modalLayerColor, fgui.UIConfig.modalLayerAlpha);
+            this._modalLayer.addRelation(this, fgui.RelationType.Size);
+            this.displayObject.stage.addEventListener(egret.Event.RESIZE, this.__winResize, this);
+            this.__winResize(null);
+        };
+        GRoot.prototype.__stageMouseDownCapture = function (evt) {
+            GRoot.mouseX = evt.stageX;
+            GRoot.mouseY = evt.stageY;
+            GRoot.touchDown = true;
+            if (this._tooltipWin)
+                this.hideTooltips();
+            this._justClosedPopups.length = 0;
+            if (this._popupStack.length > 0) {
+                var mc = (evt.target);
+                while (mc != this.displayObject.stage && mc) {
+                    if (mc["$owner"]) {
+                        var pindex = this._popupStack.indexOf(mc["$owner"]);
+                        if (pindex != -1) {
+                            for (var i = this._popupStack.length - 1; i > pindex; i--) {
+                                var popup = this._popupStack.pop();
+                                this.closePopup(popup);
+                                this._justClosedPopups.push(popup);
+                            }
+                            return;
+                        }
+                    }
+                    mc = mc.parent;
+                }
+                var cnt = this._popupStack.length;
+                for (i = cnt - 1; i >= 0; i--) {
+                    popup = this._popupStack[i];
+                    this.closePopup(popup);
+                    this._justClosedPopups.push(popup);
+                }
+                this._popupStack.length = 0;
+            }
+        };
+        GRoot.prototype.__stageMouseMoveCapture = function (evt) {
+            GRoot.mouseX = evt.stageX;
+            GRoot.mouseY = evt.stageY;
+        };
+        GRoot.prototype.__stageMouseUpCapture = function (evt) {
+            GRoot.touchDown = false;
+        };
+        GRoot.prototype.__winResize = function (evt) {
+            this.setSize(this._nativeStage.stageWidth, this._nativeStage.stageHeight);
+        };
+        GRoot.prototype.updateContentScaleLevel = function () {
+            var ss = 1;
+            if (ss >= 3.5)
+                GRoot.contentScaleLevel = 3;
+            else if (ss >= 2.5)
+                GRoot.contentScaleLevel = 2;
+            else if (ss >= 1.5)
+                GRoot.contentScaleLevel = 1;
+            else
+                GRoot.contentScaleLevel = 0;
+        };
+        GRoot.contentScaleLevel = 0;
+        GRoot.contentScaleFactor = 1;
+        return GRoot;
+    }(fgui.GComponent));
+    fgui.GRoot = GRoot;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GScrollBar = (function (_super_1) {
+        __extends(GScrollBar, _super_1);
+        function GScrollBar() {
+            var _this = _super_1.call(this) || this;
+            _this._dragOffset = new egret.Point();
+            _this._scrollPerc = 0;
+            return _this;
+        }
+        GScrollBar.prototype.setScrollPane = function (target, vertical) {
+            this._target = target;
+            this._vertical = vertical;
+        };
+        GScrollBar.prototype.setDisplayPerc = function (value) {
+            if (this._vertical) {
+                if (!this._fixedGripSize)
+                    this._grip.height = Math.floor(value * this._bar.height);
+                this._grip.y = this._bar.y + (this._bar.height - this._grip.height) * this._scrollPerc;
+            }
+            else {
+                if (!this._fixedGripSize)
+                    this._grip.width = Math.floor(value * this._bar.width);
+                this._grip.x = this._bar.x + (this._bar.width - this._grip.width) * this._scrollPerc;
+            }
+            this._grip.visible = value != 0 && value != 1;
+        };
+        GScrollBar.prototype.setScrollPerc = function (val) {
+            this._scrollPerc = val;
+            if (this._vertical)
+                this._grip.y = this._bar.y + (this._bar.height - this._grip.height) * this._scrollPerc;
+            else
+                this._grip.x = this._bar.x + (this._bar.width - this._grip.width) * this._scrollPerc;
+        };
+        Object.defineProperty(GScrollBar.prototype, "minSize", {
+            get: function () {
+                if (this._vertical)
+                    return (this._arrowButton1 ? this._arrowButton1.height : 0) + (this._arrowButton2 ? this._arrowButton2.height : 0);
+                else
+                    return (this._arrowButton1 ? this._arrowButton1.width : 0) + (this._arrowButton2 ? this._arrowButton2.width : 0);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GScrollBar.prototype, "gripDragging", {
+            get: function () {
+                return this._gripDragging;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GScrollBar.prototype.constructExtension = function (buffer) {
+            buffer.seek(0, 6);
+            this._fixedGripSize = buffer.readBool();
+            this._grip = this.getChild("grip");
+            if (!this._grip) {
+                console.error("需要定义grip");
+                return;
+            }
+            this._bar = this.getChild("bar");
+            if (!this._bar) {
+                console.error("需要定义bar");
+                return;
+            }
+            this._arrowButton1 = this.getChild("arrow1");
+            this._arrowButton2 = this.getChild("arrow2");
+            this._grip.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__gripMouseDown, this);
+            if (this._arrowButton1)
+                this._arrowButton1.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__arrowButton1Click, this);
+            if (this._arrowButton2)
+                this._arrowButton2.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__arrowButton2Click, this);
+            this.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__barMouseDown, this);
+        };
+        GScrollBar.prototype.__gripMouseDown = function (evt) {
+            this._gripDragging = true;
+            this._target.updateScrollBarVisible();
+            evt.stopPropagation();
+            this.globalToLocal(evt.stageX, evt.stageY, this._dragOffset);
+            this._dragOffset.x -= this._grip.x;
+            this._dragOffset.y -= this._grip.y;
+            this._grip.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.__gripMouseMove, this);
+            this._grip.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_END, this.__gripMouseUp, this);
+        };
+        GScrollBar.prototype.__gripMouseMove = function (evt) {
+            if (!this.onStage)
+                return;
+            var pt = this.globalToLocal(evt.stageX, evt.stageY, s_vec2);
+            if (this._vertical) {
+                var curY = pt.y - this._dragOffset.y;
+                this._target.setPercY((curY - this._bar.y) / (this._bar.height - this._grip.height), false);
+            }
+            else {
+                var curX = pt.x - this._dragOffset.x;
+                this._target.setPercX((curX - this._bar.x) / (this._bar.width - this._grip.width), false);
+            }
+        };
+        GScrollBar.prototype.__gripMouseUp = function (evt) {
+            var st = evt.currentTarget;
+            st.removeEventListener(egret.TouchEvent.TOUCH_MOVE, this.__gripMouseMove, this);
+            st.removeEventListener(egret.TouchEvent.TOUCH_END, this.__gripMouseUp, this);
+            if (this.onStage)
+                return;
+            this._gripDragging = false;
+            this._target.updateScrollBarVisible();
+        };
+        GScrollBar.prototype.__arrowButton1Click = function (evt) {
+            evt.stopPropagation();
+            if (this._vertical)
+                this._target.scrollUp();
+            else
+                this._target.scrollLeft();
+        };
+        GScrollBar.prototype.__arrowButton2Click = function (evt) {
+            evt.stopPropagation();
+            if (this._vertical)
+                this._target.scrollDown();
+            else
+                this._target.scrollRight();
+        };
+        GScrollBar.prototype.__barMouseDown = function (evt) {
+            var pt = this._grip.globalToLocal(evt.stageX, evt.stageY, s_vec2);
+            if (this._vertical) {
+                if (pt.y < 0)
+                    this._target.scrollUp(4);
+                else
+                    this._target.scrollDown(4);
+            }
+            else {
+                if (pt.x < 0)
+                    this._target.scrollLeft(4);
+                else
+                    this._target.scrollRight(4);
+            }
+        };
+        return GScrollBar;
+    }(fgui.GComponent));
+    fgui.GScrollBar = GScrollBar;
+    var s_vec2 = new egret.Point();
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GSlider = (function (_super_1) {
+        __extends(GSlider, _super_1);
+        function GSlider() {
+            var _this = _super_1.call(this) || this;
+            _this._min = 0;
+            _this._max = 0;
+            _this._value = 0;
+            _this._barMaxWidth = 0;
+            _this._barMaxHeight = 0;
+            _this._barMaxWidthDelta = 0;
+            _this._barMaxHeightDelta = 0;
+            _this._clickPercent = 0;
+            _this._barStartX = 0;
+            _this._barStartY = 0;
+            _this.changeOnClick = true;
+            _this.canDrag = true;
+            _this._titleType = fgui.ProgressTitleType.Percent;
+            _this._value = 50;
+            _this._max = 100;
+            _this._clickPos = new egret.Point();
+            return _this;
+        }
+        Object.defineProperty(GSlider.prototype, "titleType", {
+            get: function () {
+                return this._titleType;
+            },
+            set: function (value) {
+                this._titleType = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GSlider.prototype, "wholeNumbers", {
+            get: function () {
+                return this._wholeNumbers;
+            },
+            set: function (value) {
+                if (this._wholeNumbers != value) {
+                    this._wholeNumbers = value;
+                    this.update();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GSlider.prototype, "min", {
+            get: function () {
+                return this._min;
+            },
+            set: function (value) {
+                if (this._min != value) {
+                    this._min = value;
+                    this.update();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GSlider.prototype, "max", {
+            get: function () {
+                return this._max;
+            },
+            set: function (value) {
+                if (this._max != value) {
+                    this._max = value;
+                    this.update();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GSlider.prototype, "value", {
+            get: function () {
+                return this._value;
+            },
+            set: function (value) {
+                if (this._value != value) {
+                    this._value = value;
+                    this.update();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GSlider.prototype.update = function () {
+            this.updateWithPercent((this._value - this._min) / (this._max - this._min));
+        };
+        GSlider.prototype.updateWithPercent = function (percent, manual) {
+            percent = fgui.ToolSet.clamp01(percent);
+            if (manual) {
+                var newValue = fgui.ToolSet.clamp(this._min + (this._max - this._min) * percent, this._min, this._max);
+                if (this._wholeNumbers) {
+                    newValue = Math.round(newValue);
+                    percent = fgui.ToolSet.clamp01((newValue - this._min) / (this._max - this._min));
+                }
+                if (newValue != this._value) {
+                    this._value = newValue;
+                    this.dispatchEvent(new fgui.StateChangeEvent(fgui.StateChangeEvent.CHANGED));
+                }
+            }
+            if (this._titleObject) {
+                switch (this._titleType) {
+                    case fgui.ProgressTitleType.Percent:
+                        this._titleObject.text = Math.floor(percent * 100) + "%";
+                        break;
+                    case fgui.ProgressTitleType.ValueAndMax:
+                        this._titleObject.text = this._value + "/" + this._max;
+                        break;
+                    case fgui.ProgressTitleType.Value:
+                        this._titleObject.text = "" + this._value;
+                        break;
+                    case fgui.ProgressTitleType.Max:
+                        this._titleObject.text = "" + this._max;
+                        break;
+                }
+            }
+            var fullWidth = this.width - this._barMaxWidthDelta;
+            var fullHeight = this.height - this._barMaxHeightDelta;
+            if (!this._reverse) {
+                if (this._barObjectH)
+                    this._barObjectH.width = Math.round(fullWidth * percent);
+                if (this._barObjectV)
+                    this._barObjectV.height = Math.round(fullHeight * percent);
+            }
+            else {
+                if (this._barObjectH) {
+                    this._barObjectH.width = Math.round(fullWidth * percent);
+                    this._barObjectH.x = this._barStartX + (fullWidth - this._barObjectH.width);
+                }
+                if (this._barObjectV) {
+                    this._barObjectV.height = Math.round(fullHeight * percent);
+                    this._barObjectV.y = this._barStartY + (fullHeight - this._barObjectV.height);
+                }
+            }
+        };
+        GSlider.prototype.constructExtension = function (buffer) {
+            buffer.seek(0, 6);
+            this._titleType = buffer.readByte();
+            this._reverse = buffer.readBool();
+            if (buffer.version >= 2) {
+                this._wholeNumbers = buffer.readBool();
+                this.changeOnClick = buffer.readBool();
+            }
+            this._titleObject = (this.getChild("title"));
+            this._barObjectH = this.getChild("bar");
+            this._barObjectV = this.getChild("bar_v");
+            this._gripObject = this.getChild("grip");
+            if (this._barObjectH) {
+                this._barMaxWidth = this._barObjectH.width;
+                this._barMaxWidthDelta = this.width - this._barMaxWidth;
+                this._barStartX = this._barObjectH.x;
+            }
+            if (this._barObjectV) {
+                this._barMaxHeight = this._barObjectV.height;
+                this._barMaxHeightDelta = this.height - this._barMaxHeight;
+                this._barStartY = this._barObjectV.y;
+            }
+            if (this._gripObject) {
+                this._gripObject.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__gripMouseDown, this);
+            }
+            this.displayObject.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__barMouseDown, this);
+        };
+        GSlider.prototype.handleSizeChanged = function () {
+            _super_1.prototype.handleSizeChanged.call(this);
+            if (this._barObjectH)
+                this._barMaxWidth = this.width - this._barMaxWidthDelta;
+            if (this._barObjectV)
+                this._barMaxHeight = this.height - this._barMaxHeightDelta;
+            if (!this._underConstruct)
+                this.update();
+        };
+        GSlider.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            if (!buffer.seek(beginPos, 6)) {
+                this.update();
+                return;
+            }
+            if (buffer.readByte() != this.packageItem.objectType) {
+                this.update();
+                return;
+            }
+            this._value = buffer.readInt();
+            this._max = buffer.readInt();
+            if (buffer.version >= 2)
+                this._min = buffer.readInt();
+            this.update();
+        };
+        GSlider.prototype.__gripMouseDown = function (evt) {
+            this.canDrag = true;
+            evt.stopPropagation();
+            this._clickPos = this.globalToLocal(evt.stageX, evt.stageY);
+            this._clickPercent = fgui.ToolSet.clamp01((this._value - this._min) / (this._max - this._min));
+            this._gripObject.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.__gripMouseMove, this);
+            this._gripObject.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_END, this.__gripMouseUp, this);
+        };
+        GSlider.prototype.__gripMouseMove = function (evt) {
+            if (!this.canDrag) {
+                return;
+            }
+            var pt = this.globalToLocal(evt.stageX, evt.stageY, s_vec2);
+            var deltaX = pt.x - this._clickPos.x;
+            var deltaY = pt.y - this._clickPos.y;
+            if (this._reverse) {
+                deltaX = -deltaX;
+                deltaY = -deltaY;
+            }
+            var percent;
+            if (this._barObjectH)
+                percent = this._clickPercent + deltaX / this._barMaxWidth;
+            else
+                percent = this._clickPercent + deltaY / this._barMaxHeight;
+            this.updateWithPercent(percent, true);
+        };
+        GSlider.prototype.__gripMouseUp = function (evt) {
+            evt.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_MOVE, this.__gripMouseMove, this);
+            evt.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_END, this.__gripMouseUp, this);
+        };
+        GSlider.prototype.__barMouseDown = function (evt) {
+            if (!this.changeOnClick)
+                return;
+            var pt = this._gripObject.globalToLocal(evt.stageX, evt.stageY, s_vec2);
+            var percent = fgui.ToolSet.clamp01((this._value - this._min) / (this._max - this._min));
+            var delta;
+            if (this._barObjectH)
+                delta = pt.x / this._barMaxWidth;
+            if (this._barObjectV)
+                delta = pt.y / this._barMaxHeight;
+            if (this._reverse)
+                percent -= delta;
+            else
+                percent += delta;
+            this.updateWithPercent(percent, true);
+        };
+        return GSlider;
+    }(fgui.GComponent));
+    fgui.GSlider = GSlider;
+    var s_vec2 = new egret.Point();
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GTextInput = (function (_super_1) {
+        __extends(GTextInput, _super_1);
+        function GTextInput() {
+            var _this = _super_1.call(this) || this;
+            _this._widthAutoSize = false;
+            _this._heightAutoSize = false;
+            _this.displayObject.touchChildren = true;
+            _this._textField.type = egret.TextFieldType.INPUT;
+            _this._textField.addEventListener(egret.Event.CHANGE, _this.__textChanged, _this);
+            _this._textField.addEventListener(egret.FocusEvent.FOCUS_IN, _this.__focusIn, _this);
+            _this._textField.addEventListener(egret.FocusEvent.FOCUS_OUT, _this.__focusOut, _this);
+            return _this;
+        }
+        GTextInput.prototype.dispose = function () {
+            _super_1.prototype.dispose.call(this);
+        };
+        Object.defineProperty(GTextInput.prototype, "editable", {
+            get: function () {
+                return this._textField.type == egret.TextFieldType.INPUT;
+            },
+            set: function (val) {
+                if (val)
+                    this._textField.type = egret.TextFieldType.INPUT;
+                else
+                    this._textField.type = egret.TextFieldType.DYNAMIC;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextInput.prototype, "maxLength", {
+            get: function () {
+                return this._textField.maxChars;
+            },
+            set: function (val) {
+                this._textField.maxChars = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextInput.prototype, "promptText", {
+            get: function () {
+                return this._promptText;
+            },
+            set: function (val) {
+                this._promptText = val;
+                this.updateTextFieldText();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextInput.prototype, "restrict", {
+            get: function () {
+                return this._textField.restrict;
+            },
+            set: function (value) {
+                this._textField.restrict = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextInput.prototype, "password", {
+            get: function () {
+                return this._password;
+            },
+            set: function (val) {
+                if (this._password != val) {
+                    this._password = val;
+                    this._textField.displayAsPassword = this._password;
+                    if (val)
+                        this._textField.inputType = egret.TextFieldInputType.PASSWORD;
+                    else
+                        this._textField.inputType = egret.TextFieldInputType.TEXT;
+                    this.render();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTextInput.prototype, "verticalAlign", {
+            get: function () {
+                return this._verticalAlign;
+            },
+            set: function (value) {
+                if (this._verticalAlign != value) {
+                    this._verticalAlign = value;
+                    this.updateVertAlign();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTextInput.prototype.updateVertAlign = function () {
+            switch (this._verticalAlign) {
+                case fgui.VertAlignType.Top:
+                    this._textField.verticalAlign = egret.VerticalAlign.TOP;
+                    break;
+                case fgui.VertAlignType.Middle:
+                    this._textField.verticalAlign = egret.VerticalAlign.MIDDLE;
+                    break;
+                case fgui.VertAlignType.Bottom:
+                    this._textField.verticalAlign = egret.VerticalAlign.BOTTOM;
+                    break;
+            }
+        };
+        GTextInput.prototype.updateTextFieldText = function () {
+            if (!this._text && this._promptText) {
+                this._textField.displayAsPassword = false;
+                this._textField.textFlow = (new egret.HtmlTextParser).parser(fgui.UBBParser.inst.parse(this._promptText));
+            }
+            else {
+                this._textField.displayAsPassword = this._password;
+                if (this._ubbEnabled)
+                    this._textField.textFlow = (new egret.HtmlTextParser).parser(fgui.UBBParser.inst.parse(fgui.ToolSet.encodeHTML(this._text)));
+                else
+                    this._textField.text = this._text;
+            }
+        };
+        GTextInput.prototype.handleSizeChanged = function () {
+            if (!this._updatingSize) {
+                this._textField.width = Math.ceil(this.width);
+                this._textField.height = Math.ceil(this.height);
+            }
+        };
+        GTextInput.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 4);
+            var str = buffer.readS();
+            if (str != null)
+                this._promptText = str;
+            str = buffer.readS();
+            if (str != null)
+                this._textField.restrict = str;
+            var iv = buffer.readInt();
+            if (iv != 0)
+                this._textField.maxChars = iv;
+            iv = buffer.readInt();
+            if (iv != 0) {
+            }
+            if (buffer.readBool())
+                this.password = true;
+            this.updateVertAlign();
+        };
+        GTextInput.prototype.setup_afterAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_afterAdd.call(this, buffer, beginPos);
+            if (!this._text && this._promptText) {
+                this._textField.displayAsPassword = false;
+                this._textField.textFlow = (new egret.HtmlTextParser).parser(fgui.UBBParser.inst.parse(fgui.ToolSet.encodeHTML(this._promptText)));
+            }
+        };
+        GTextInput.prototype.__textChanged = function (evt) {
+            this._text = this._textField.text;
+        };
+        GTextInput.prototype.__focusIn = function (evt) {
+            if (!this._text && this._promptText) {
+                this._textField.displayAsPassword = this._password;
+                this._textField.text = "";
+            }
+        };
+        GTextInput.prototype.__focusOut = function (evt) {
+            this._text = this._textField.text;
+            if (!this._text && this._promptText) {
+                this._textField.displayAsPassword = false;
+                this._textField.textFlow = (new egret.HtmlTextParser).parser(fgui.UBBParser.inst.parse(fgui.ToolSet.encodeHTML(this._promptText)));
+            }
+        };
+        return GTextInput;
+    }(fgui.GTextField));
+    fgui.GTextInput = GTextInput;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GTree = (function (_super_1) {
+        __extends(GTree, _super_1);
+        function GTree() {
+            var _this = _super_1.call(this) || this;
+            _this._indent = 15;
+            _this._rootNode = new fgui.GTreeNode(true);
+            _this._rootNode._setTree(_this);
+            _this._rootNode.expanded = true;
+            return _this;
+        }
+        Object.defineProperty(GTree.prototype, "rootNode", {
+            get: function () {
+                return this._rootNode;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTree.prototype, "indent", {
+            get: function () {
+                return this._indent;
+            },
+            set: function (value) {
+                this._indent = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTree.prototype, "clickToExpand", {
+            get: function () {
+                return this._clickToExpand;
+            },
+            set: function (value) {
+                this._clickToExpand = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTree.prototype.getSelectedNode = function () {
+            if (this.selectedIndex != -1)
+                return this.getChildAt(this.selectedIndex)._treeNode;
+            else
+                return null;
+        };
+        GTree.prototype.getSelectedNodes = function (result) {
+            if (!result)
+                result = new Array();
+            s_list.length = 0;
+            _super_1.prototype.getSelection.call(this, s_list);
+            var cnt = s_list.length;
+            var ret = new Array();
+            for (var i = 0; i < cnt; i++) {
+                var node = this.getChildAt(s_list[i])._treeNode;
+                ret.push(node);
+            }
+            return ret;
+        };
+        GTree.prototype.selectNode = function (node, scrollItToView) {
+            var parentNode = node.parent;
+            while (parentNode && parentNode != this._rootNode) {
+                parentNode.expanded = true;
+                parentNode = parentNode.parent;
+            }
+            if (!node._cell)
+                return;
+            this.addSelection(this.getChildIndex(node._cell), scrollItToView);
+        };
+        GTree.prototype.unselectNode = function (node) {
+            if (!node._cell)
+                return;
+            this.removeSelection(this.getChildIndex(node._cell));
+        };
+        GTree.prototype.expandAll = function (folderNode) {
+            if (!folderNode)
+                folderNode = this._rootNode;
+            folderNode.expanded = true;
+            var cnt = folderNode.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                var node = folderNode.getChildAt(i);
+                if (node.isFolder)
+                    this.expandAll(node);
+            }
+        };
+        GTree.prototype.collapseAll = function (folderNode) {
+            if (!folderNode)
+                folderNode = this._rootNode;
+            if (folderNode != this._rootNode)
+                folderNode.expanded = false;
+            var cnt = folderNode.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                var node = folderNode.getChildAt(i);
+                if (node.isFolder)
+                    this.collapseAll(node);
+            }
+        };
+        GTree.prototype.createCell = function (node) {
+            var child = this.getFromPool(node._resURL ? node._resURL : this.defaultItem);
+            if (!(child instanceof fgui.GComponent))
+                throw new Error("cannot create tree node object.");
+            child._treeNode = node;
+            node._cell = child;
+            var indentObj = child.getChild("indent");
+            if (indentObj != null)
+                indentObj.width = (node.level - 1) * this._indent;
+            var cc;
+            cc = child.getController("expanded");
+            if (cc) {
+                cc.addEventListener(fgui.StateChangeEvent.CHANGED, this.__expandedStateChanged, this);
+                cc.selectedIndex = node.expanded ? 1 : 0;
+            }
+            cc = child.getController("leaf");
+            if (cc)
+                cc.selectedIndex = node.isFolder ? 0 : 1;
+            if (node.isFolder)
+                child.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.__cellMouseDown, this);
+            if (this.treeNodeRender)
+                this.treeNodeRender.call(this.callbackThisObj, node, child);
+        };
+        GTree.prototype._afterInserted = function (node) {
+            if (!node._cell)
+                this.createCell(node);
+            var index = this.getInsertIndexForNode(node);
+            this.addChildAt(node._cell, index);
+            if (this.treeNodeRender)
+                this.treeNodeRender.call(this.callbackThisObj, node, node._cell);
+            if (node.isFolder && node.expanded)
+                this.checkChildren(node, index);
+        };
+        GTree.prototype.getInsertIndexForNode = function (node) {
+            var prevNode = node.getPrevSibling();
+            if (prevNode == null)
+                prevNode = node.parent;
+            var insertIndex = this.getChildIndex(prevNode._cell) + 1;
+            var myLevel = node.level;
+            var cnt = this.numChildren;
+            for (var i = insertIndex; i < cnt; i++) {
+                var testNode = this.getChildAt(i)._treeNode;
+                if (testNode.level <= myLevel)
+                    break;
+                insertIndex++;
+            }
+            return insertIndex;
+        };
+        GTree.prototype._afterRemoved = function (node) {
+            this.removeNode(node);
+        };
+        GTree.prototype._afterExpanded = function (node) {
+            if (node == this._rootNode) {
+                this.checkChildren(this._rootNode, 0);
+                return;
+            }
+            if (this.treeNodeWillExpand != null)
+                this.treeNodeWillExpand.call(this.callbackThisObj, node, true);
+            if (node._cell == null)
+                return;
+            if (this.treeNodeRender)
+                this.treeNodeRender.call(this.callbackThisObj, node, node._cell);
+            var cc = node._cell.getController("expanded");
+            if (cc)
+                cc.selectedIndex = 1;
+            if (node._cell.parent)
+                this.checkChildren(node, this.getChildIndex(node._cell));
+        };
+        GTree.prototype._afterCollapsed = function (node) {
+            if (node == this._rootNode) {
+                this.checkChildren(this._rootNode, 0);
+                return;
+            }
+            if (this.treeNodeWillExpand)
+                this.treeNodeWillExpand.call(this.callbackThisObj, node, false);
+            if (node._cell == null)
+                return;
+            if (this.treeNodeRender)
+                this.treeNodeRender.call(this.callbackThisObj, node, node._cell);
+            var cc = node._cell.getController("expanded");
+            if (cc)
+                cc.selectedIndex = 0;
+            if (node._cell.parent)
+                this.hideFolderNode(node);
+        };
+        GTree.prototype._afterMoved = function (node) {
+            var startIndex = this.getChildIndex(node._cell);
+            var endIndex;
+            if (node.isFolder)
+                endIndex = this.getFolderEndIndex(startIndex, node.level);
+            else
+                endIndex = startIndex + 1;
+            var insertIndex = this.getInsertIndexForNode(node);
+            var i;
+            var cnt = endIndex - startIndex;
+            var obj;
+            if (insertIndex < startIndex) {
+                for (i = 0; i < cnt; i++) {
+                    obj = this.getChildAt(startIndex + i);
+                    this.setChildIndex(obj, insertIndex + i);
+                }
+            }
+            else {
+                for (i = 0; i < cnt; i++) {
+                    obj = this.getChildAt(startIndex);
+                    this.setChildIndex(obj, insertIndex);
+                }
+            }
+        };
+        GTree.prototype.getFolderEndIndex = function (startIndex, level) {
+            var cnt = this.numChildren;
+            for (var i = startIndex + 1; i < cnt; i++) {
+                var node = this.getChildAt(i)._treeNode;
+                if (node.level <= level)
+                    return i;
+            }
+            return cnt;
+        };
+        GTree.prototype.checkChildren = function (folderNode, index) {
+            var cnt = folderNode.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                index++;
+                var node = folderNode.getChildAt(i);
+                if (node._cell == null)
+                    this.createCell(node);
+                if (!node._cell.parent)
+                    this.addChildAt(node._cell, index);
+                if (node.isFolder && node.expanded)
+                    index = this.checkChildren(node, index);
+            }
+            return index;
+        };
+        GTree.prototype.hideFolderNode = function (folderNode) {
+            var cnt = folderNode.numChildren;
+            for (var i = 0; i < cnt; i++) {
+                var node = folderNode.getChildAt(i);
+                if (node._cell)
+                    this.removeChild(node._cell);
+                if (node.isFolder && node.expanded)
+                    this.hideFolderNode(node);
+            }
+        };
+        GTree.prototype.removeNode = function (node) {
+            if (node._cell) {
+                if (node._cell.parent)
+                    this.removeChild(node._cell);
+                this.returnToPool(node._cell);
+                node._cell._treeNode = null;
+                node._cell = null;
+            }
+            if (node.isFolder) {
+                var cnt = node.numChildren;
+                for (var i = 0; i < cnt; i++) {
+                    var node2 = node.getChildAt(i);
+                    this.removeNode(node2);
+                }
+            }
+        };
+        GTree.prototype.__cellMouseDown = function (evt) {
+            var node = evt.currentTarget._treeNode;
+            this._expandedStatusInEvt = node.expanded;
+        };
+        GTree.prototype.__expandedStateChanged = function (evt) {
+            var cc = evt.currentTarget;
+            var node = cc.parent._treeNode;
+            node.expanded = cc.selectedIndex == 1;
+        };
+        GTree.prototype.dispatchItemEvent = function (evt) {
+            if (this._clickToExpand != 0) {
+                var node = evt.itemObject._treeNode;
+                if (node && node.isFolder && this._expandedStatusInEvt == node.expanded) {
+                    if (this._clickToExpand == 2) {
+                    }
+                    else
+                        node.expanded = !node.expanded;
+                }
+            }
+            _super_1.prototype.dispatchItemEvent.call(this, evt);
+        };
+        GTree.prototype.setup_beforeAdd = function (buffer, beginPos) {
+            _super_1.prototype.setup_beforeAdd.call(this, buffer, beginPos);
+            buffer.seek(beginPos, 9);
+            this._indent = buffer.readInt();
+            this._clickToExpand = buffer.readByte();
+        };
+        GTree.prototype.readItems = function (buffer) {
+            var cnt;
+            var i;
+            var nextPos;
+            var str;
+            var isFolder;
+            var lastNode;
+            var level;
+            var prevLevel = 0;
+            cnt = buffer.readShort();
+            for (i = 0; i < cnt; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                str = buffer.readS();
+                if (str == null) {
+                    str = this.defaultItem;
+                    if (!str) {
+                        buffer.position = nextPos;
+                        continue;
+                    }
+                }
+                isFolder = buffer.readBool();
+                level = buffer.readByte();
+                var node = new fgui.GTreeNode(isFolder, str);
+                node.expanded = true;
+                if (i == 0)
+                    this._rootNode.addChild(node);
+                else {
+                    if (level > prevLevel)
+                        lastNode.addChild(node);
+                    else if (level < prevLevel) {
+                        for (var j = level; j <= prevLevel; j++)
+                            lastNode = lastNode.parent;
+                        lastNode.addChild(node);
+                    }
+                    else
+                        lastNode.parent.addChild(node);
+                }
+                lastNode = node;
+                prevLevel = level;
+                this.setupItem(buffer, node.cell);
+                buffer.position = nextPos;
+            }
+        };
+        return GTree;
+    }(fgui.GList));
+    fgui.GTree = GTree;
+    var s_list = new Array();
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GTreeNode = (function () {
+        function GTreeNode(hasChild, resURL) {
+            this._level = 0;
+            this._resURL = resURL;
+            if (hasChild)
+                this._children = new Array();
+        }
+        Object.defineProperty(GTreeNode.prototype, "expanded", {
+            get: function () {
+                return this._expanded;
+            },
+            set: function (value) {
+                if (!this._children)
+                    return;
+                if (this._expanded != value) {
+                    this._expanded = value;
+                    if (this._tree) {
+                        if (this._expanded)
+                            this._tree._afterExpanded(this);
+                        else
+                            this._tree._afterCollapsed(this);
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTreeNode.prototype, "isFolder", {
+            get: function () {
+                return this._children != null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTreeNode.prototype, "parent", {
+            get: function () {
+                return this._parent;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTreeNode.prototype, "text", {
+            get: function () {
+                if (this._cell)
+                    return this._cell.text;
+                else
+                    return null;
+            },
+            set: function (value) {
+                if (this._cell)
+                    this._cell.text = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTreeNode.prototype, "icon", {
+            get: function () {
+                if (this._cell)
+                    return this._cell.icon;
+                else
+                    return null;
+            },
+            set: function (value) {
+                if (this._cell)
+                    this._cell.icon = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTreeNode.prototype, "cell", {
+            get: function () {
+                return this._cell;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTreeNode.prototype, "level", {
+            get: function () {
+                return this._level;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTreeNode.prototype._setLevel = function (value) {
+            this._level = value;
+        };
+        GTreeNode.prototype.addChild = function (child) {
+            this.addChildAt(child, this._children.length);
+            return child;
+        };
+        GTreeNode.prototype.addChildAt = function (child, index) {
+            if (!child)
+                throw new Error("child is null");
+            var numChildren = this._children.length;
+            if (index >= 0 && index <= numChildren) {
+                if (child._parent == this) {
+                    this.setChildIndex(child, index);
+                }
+                else {
+                    if (child._parent)
+                        child._parent.removeChild(child);
+                    var cnt = this._children.length;
+                    if (index == cnt)
+                        this._children.push(child);
+                    else
+                        this._children.splice(index, 0, child);
+                    child._parent = this;
+                    child._level = this._level + 1;
+                    child._setTree(this._tree);
+                    if (this._tree && this == this._tree.rootNode || this._cell && this._cell.parent && this._expanded)
+                        this._tree._afterInserted(child);
+                }
+                return child;
+            }
+            else {
+                throw new RangeError("Invalid child index");
+            }
+        };
+        GTreeNode.prototype.removeChild = function (child) {
+            var childIndex = this._children.indexOf(child);
+            if (childIndex != -1) {
+                this.removeChildAt(childIndex);
+            }
+            return child;
+        };
+        GTreeNode.prototype.removeChildAt = function (index) {
+            if (index >= 0 && index < this.numChildren) {
+                var child = this._children[index];
+                this._children.splice(index, 1);
+                child._parent = null;
+                if (this._tree) {
+                    child._setTree(null);
+                    this._tree._afterRemoved(child);
+                }
+                return child;
+            }
+            else {
+                throw "Invalid child index";
+            }
+        };
+        GTreeNode.prototype.removeChildren = function (beginIndex, endIndex) {
+            beginIndex = beginIndex || 0;
+            if (endIndex == null)
+                endIndex = -1;
+            if (endIndex < 0 || endIndex >= this.numChildren)
+                endIndex = this.numChildren - 1;
+            for (var i = beginIndex; i <= endIndex; ++i)
+                this.removeChildAt(beginIndex);
+        };
+        GTreeNode.prototype.getChildAt = function (index) {
+            if (index >= 0 && index < this.numChildren)
+                return this._children[index];
+            else
+                throw "Invalid child index";
+        };
+        GTreeNode.prototype.getChildIndex = function (child) {
+            return this._children.indexOf(child);
+        };
+        GTreeNode.prototype.getPrevSibling = function () {
+            if (this._parent == null)
+                return null;
+            var i = this._parent._children.indexOf(this);
+            if (i <= 0)
+                return null;
+            return this._parent._children[i - 1];
+        };
+        GTreeNode.prototype.getNextSibling = function () {
+            if (this._parent == null)
+                return null;
+            var i = this._parent._children.indexOf(this);
+            if (i < 0 || i >= this._parent._children.length - 1)
+                return null;
+            return this._parent._children[i + 1];
+        };
+        GTreeNode.prototype.setChildIndex = function (child, index) {
+            var oldIndex = this._children.indexOf(child);
+            if (oldIndex == -1)
+                throw "Not a child of this container";
+            var cnt = this._children.length;
+            if (index < 0)
+                index = 0;
+            else if (index > cnt)
+                index = cnt;
+            if (oldIndex == index)
+                return;
+            this._children.splice(oldIndex, 1);
+            this._children.splice(index, 0, child);
+            if (this._tree && this == this._tree.rootNode || this._cell && this._cell.parent && this._expanded)
+                this._tree._afterMoved(child);
+        };
+        GTreeNode.prototype.swapChildren = function (child1, child2) {
+            var index1 = this._children.indexOf(child1);
+            var index2 = this._children.indexOf(child2);
+            if (index1 == -1 || index2 == -1)
+                throw "Not a child of this container";
+            this.swapChildrenAt(index1, index2);
+        };
+        GTreeNode.prototype.swapChildrenAt = function (index1, index2) {
+            var child1 = this._children[index1];
+            var child2 = this._children[index2];
+            this.setChildIndex(child1, index2);
+            this.setChildIndex(child2, index1);
+        };
+        Object.defineProperty(GTreeNode.prototype, "numChildren", {
+            get: function () {
+                return this._children.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTreeNode.prototype.expandToRoot = function () {
+            var p = this;
+            while (p) {
+                p.expanded = true;
+                p = p.parent;
+            }
+        };
+        Object.defineProperty(GTreeNode.prototype, "tree", {
+            get: function () {
+                return this._tree;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTreeNode.prototype._setTree = function (value) {
+            this._tree = value;
+            if (this._tree && this._tree.treeNodeWillExpand && this._expanded)
+                this._tree.treeNodeWillExpand(this, true);
+            if (this._children) {
+                var cnt = this._children.length;
+                for (var i = 0; i < cnt; i++) {
+                    var node = this._children[i];
+                    node._level = this._level + 1;
+                    node._setTree(value);
+                }
+            }
+        };
+        return GTreeNode;
+    }());
+    fgui.GTreeNode = GTreeNode;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var Margin = (function () {
+        function Margin() {
+            this.left = 0;
+            this.right = 0;
+            this.top = 0;
+            this.bottom = 0;
+        }
+        Margin.prototype.copy = function (source) {
+            this.top = source.top;
+            this.bottom = source.bottom;
+            this.left = source.left;
+            this.right = source.right;
+        };
+        return Margin;
+    }());
+    fgui.Margin = Margin;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var PixelHitTest = (function () {
+        function PixelHitTest(data, offsetX, offsetY) {
+            this._data = data;
+            this.offsetX = offsetX;
+            this.offsetY = offsetY;
+            this.scaleX = 1;
+            this.scaleY = 1;
+        }
+        PixelHitTest.prototype.contains = function (x, y) {
+            x = Math.floor((x / this.scaleX - this.offsetX) * this._data.scale);
+            y = Math.floor((y / this.scaleY - this.offsetY) * this._data.scale);
+            if (x < 0 || y < 0 || x >= this._data.pixelWidth)
+                return false;
+            var pos = y * this._data.pixelWidth + x;
+            var pos2 = Math.floor(pos / 8);
+            var pos3 = pos % 8;
+            if (pos2 >= 0 && pos2 < this._data.pixels.length)
+                return ((this._data.pixels[pos2] >> pos3) & 0x1) == 1;
+            else
+                return false;
+        };
+        return PixelHitTest;
+    }());
+    fgui.PixelHitTest = PixelHitTest;
+    var PixelHitTestData = (function () {
+        function PixelHitTestData() {
+        }
+        PixelHitTestData.prototype.load = function (ba) {
+            ba.readInt();
+            this.pixelWidth = ba.readInt();
+            this.scale = 1 / ba.readByte();
+            var len = ba.readInt();
+            this.pixels = [];
+            for (var i = 0; i < len; i++) {
+                var j = ba.readByte();
+                if (j < 0)
+                    j += 256;
+                this.pixels[i] = j;
+            }
+        };
+        return PixelHitTestData;
+    }());
+    fgui.PixelHitTestData = PixelHitTestData;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var PackageItem = (function () {
+        function PackageItem() {
+            this.width = 0;
+            this.height = 0;
+        }
+        PackageItem.prototype.load = function () {
+            return this.owner.getItemAsset(this);
+        };
+        PackageItem.prototype.getBranch = function () {
+            if (this.branches && this.owner._branchIndex != -1) {
+                var itemId = this.branches[this.owner._branchIndex];
+                if (itemId)
+                    return this.owner.getItemById(itemId);
+            }
+            return this;
+        };
+        PackageItem.prototype.getHighResolution = function () {
+            if (this.highResolution && fgui.GRoot.contentScaleLevel > 0) {
+                var itemId = this.highResolution[fgui.GRoot.contentScaleLevel - 1];
+                if (itemId)
+                    return this.owner.getItemById(itemId);
+            }
+            return this;
+        };
+        PackageItem.prototype.toString = function () {
+            return this.name;
+        };
+        return PackageItem;
+    }());
+    fgui.PackageItem = PackageItem;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var PopupMenu = (function () {
+        function PopupMenu(resourceURL) {
+            if (!resourceURL) {
+                resourceURL = fgui.UIConfig.popupMenu;
+                if (!resourceURL)
+                    throw "UIConfig.popupMenu not defined";
+            }
+            this._contentPane = fgui.UIPackage.createObjectFromURL(resourceURL).asCom;
+            this._contentPane.addEventListener(egret.Event.ADDED_TO_STAGE, this.__addedToStage, this);
+            this._list = (this._contentPane.getChild("list"));
+            this._list.removeChildrenToPool();
+            this._list.addRelation(this._contentPane, fgui.RelationType.Width);
+            this._list.removeRelation(this._contentPane, fgui.RelationType.Height);
+            this._contentPane.addRelation(this._list, fgui.RelationType.Height);
+            this._list.addEventListener(fgui.ItemEvent.CLICK, this.__clickItem, this);
+        }
+        PopupMenu.prototype.dispose = function () {
+            this._contentPane.dispose();
+        };
+        PopupMenu.prototype.addItem = function (caption, callback) {
+            var item = this._list.addItemFromPool().asButton;
+            item.title = caption;
+            item.data = callback;
+            item.grayed = false;
+            var c = item.getController("checked");
+            if (c)
+                c.selectedIndex = 0;
+            return item;
+        };
+        PopupMenu.prototype.addItemAt = function (caption, index, callback) {
+            var item = this._list.getFromPool().asButton;
+            this._list.addChildAt(item, index);
+            item.title = caption;
+            item.data = callback;
+            item.grayed = false;
+            var c = item.getController("checked");
+            if (c)
+                c.selectedIndex = 0;
+            return item;
+        };
+        PopupMenu.prototype.addSeperator = function () {
+            if (fgui.UIConfig.popupMenu_seperator == null)
+                throw "UIConfig.popupMenu_seperator not defined";
+            this.list.addItemFromPool(fgui.UIConfig.popupMenu_seperator);
+        };
+        PopupMenu.prototype.getItemName = function (index) {
+            var item = this._list.getChildAt(index);
+            return item.name;
+        };
+        PopupMenu.prototype.setItemText = function (name, caption) {
+            var item = this._list.getChild(name).asButton;
+            item.title = caption;
+        };
+        PopupMenu.prototype.setItemVisible = function (name, visible) {
+            var item = this._list.getChild(name).asButton;
+            if (item.visible != visible) {
+                item.visible = visible;
+                this._list.setBoundsChangedFlag();
+            }
+        };
+        PopupMenu.prototype.setItemGrayed = function (name, grayed) {
+            var item = this._list.getChild(name).asButton;
+            item.grayed = grayed;
+        };
+        PopupMenu.prototype.setItemCheckable = function (name, checkable) {
+            var item = this._list.getChild(name).asButton;
+            var c = item.getController("checked");
+            if (c) {
+                if (checkable) {
+                    if (c.selectedIndex == 0)
+                        c.selectedIndex = 1;
+                }
+                else
+                    c.selectedIndex = 0;
+            }
+        };
+        PopupMenu.prototype.setItemChecked = function (name, checked) {
+            var item = this._list.getChild(name).asButton;
+            var c = item.getController("checked");
+            if (c)
+                c.selectedIndex = checked ? 2 : 1;
+        };
+        PopupMenu.prototype.isItemChecked = function (name) {
+            var item = this._list.getChild(name).asButton;
+            var c = item.getController("checked");
+            if (c)
+                return c.selectedIndex == 2;
+            else
+                return false;
+        };
+        PopupMenu.prototype.removeItem = function (name) {
+            var item = this._list.getChild(name);
+            if (item) {
+                var index = this._list.getChildIndex(item);
+                this._list.removeChildToPoolAt(index);
+                return true;
+            }
+            else
+                return false;
+        };
+        PopupMenu.prototype.clearItems = function () {
+            this._list.removeChildrenToPool();
+        };
+        Object.defineProperty(PopupMenu.prototype, "itemCount", {
+            get: function () {
+                return this._list.numChildren;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(PopupMenu.prototype, "contentPane", {
+            get: function () {
+                return this._contentPane;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(PopupMenu.prototype, "list", {
+            get: function () {
+                return this._list;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        PopupMenu.prototype.show = function (target, dir) {
+            var r = target ? target.root : fgui.GRoot.inst;
+            r.showPopup(this.contentPane, (target instanceof fgui.GRoot) ? null : target, dir);
+        };
+        PopupMenu.prototype.__clickItem = function (evt) {
+            fgui.GTimers.inst.add(100, 1, this.__clickItem2, this, evt);
+        };
+        PopupMenu.prototype.__clickItem2 = function (evt) {
+            var item = evt.itemObject.asButton;
+            if (item == null)
+                return;
+            if (item.grayed) {
+                this._list.selectedIndex = -1;
+                return;
+            }
+            var c = item.getController("checked");
+            if (c && c.selectedIndex != 0) {
+                if (c.selectedIndex == 1)
+                    c.selectedIndex = 2;
+                else
+                    c.selectedIndex = 1;
+            }
+            var r = (this._contentPane.parent);
+            r.hidePopup(this.contentPane);
+            if (item.data != null) {
+                if (item.data.length == 1)
+                    item.data(evt);
+                else
+                    item.data();
+            }
+        };
+        PopupMenu.prototype.__addedToStage = function (evt) {
+            this._list.selectedIndex = -1;
+            this._list.resizeToFit(100000, 10);
+        };
+        return PopupMenu;
+    }());
+    fgui.PopupMenu = PopupMenu;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var RelationItem = (function () {
+        function RelationItem(owner) {
+            this._owner = owner;
+            this._defs = new Array();
+        }
+        Object.defineProperty(RelationItem.prototype, "owner", {
+            get: function () {
+                return this._owner;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RelationItem.prototype, "target", {
+            get: function () {
+                return this._target;
+            },
+            set: function (value) {
+                if (this._target != value) {
+                    if (this._target)
+                        this.releaseRefTarget(this._target);
+                    this._target = value;
+                    if (this._target)
+                        this.addRefTarget(this._target);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RelationItem.prototype.add = function (relationType, usePercent) {
+            if (relationType == fgui.RelationType.Size) {
+                this.add(fgui.RelationType.Width, usePercent);
+                this.add(fgui.RelationType.Height, usePercent);
+                return;
+            }
+            var length = this._defs.length;
+            for (var i = 0; i < length; i++) {
+                var def = this._defs[i];
+                if (def.type == relationType)
+                    return;
+            }
+            this.internalAdd(relationType, usePercent);
+        };
+        RelationItem.prototype.internalAdd = function (relationType, usePercent) {
+            if (relationType == fgui.RelationType.Size) {
+                this.internalAdd(fgui.RelationType.Width, usePercent);
+                this.internalAdd(fgui.RelationType.Height, usePercent);
+                return;
+            }
+            var info = new RelationDef();
+            info.percent = usePercent;
+            info.type = relationType;
+            info.axis = (relationType <= fgui.RelationType.Right_Right || relationType == fgui.RelationType.Width || relationType >= fgui.RelationType.LeftExt_Left && relationType <= fgui.RelationType.RightExt_Right) ? 0 : 1;
+            this._defs.push(info);
+            if (usePercent || relationType == fgui.RelationType.Left_Center || relationType == fgui.RelationType.Center_Center || relationType == fgui.RelationType.Right_Center
+                || relationType == fgui.RelationType.Top_Middle || relationType == fgui.RelationType.Middle_Middle || relationType == fgui.RelationType.Bottom_Middle)
+                this._owner.pixelSnapping = true;
+        };
+        RelationItem.prototype.remove = function (relationType) {
+            if (relationType === void 0) { relationType = 0; }
+            if (relationType == fgui.RelationType.Size) {
+                this.remove(fgui.RelationType.Width);
+                this.remove(fgui.RelationType.Height);
+                return;
+            }
+            var dc = this._defs.length;
+            for (var k = 0; k < dc; k++) {
+                if (this._defs[k].type == relationType) {
+                    this._defs.splice(k, 1);
+                    break;
+                }
+            }
+        };
+        RelationItem.prototype.copyFrom = function (source) {
+            this.target = source.target;
+            this._defs.length = 0;
+            var length = source._defs.length;
+            for (var i = 0; i < length; i++) {
+                var info = source._defs[i];
+                var info2 = new RelationDef();
+                info2.copyFrom(info);
+                this._defs.push(info2);
+            }
+        };
+        RelationItem.prototype.dispose = function () {
+            if (this._target) {
+                this.releaseRefTarget(this._target);
+                this._target = null;
+            }
+        };
+        Object.defineProperty(RelationItem.prototype, "isEmpty", {
+            get: function () {
+                return this._defs.length == 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RelationItem.prototype.applyOnSelfResized = function (dWidth, dHeight, applyPivot) {
+            var ox = this._owner.x;
+            var oy = this._owner.y;
+            var length = this._defs.length;
+            for (var i = 0; i < length; i++) {
+                var info = this._defs[i];
+                switch (info.type) {
+                    case fgui.RelationType.Center_Center:
+                        this._owner.x -= (0.5 - (applyPivot ? this._owner.pivotX : 0)) * dWidth;
+                        break;
+                    case fgui.RelationType.Right_Center:
+                    case fgui.RelationType.Right_Left:
+                    case fgui.RelationType.Right_Right:
+                        this._owner.x -= (1 - (applyPivot ? this._owner.pivotX : 0)) * dWidth;
+                        break;
+                    case fgui.RelationType.Middle_Middle:
+                        this._owner.y -= (0.5 - (applyPivot ? this._owner.pivotY : 0)) * dHeight;
+                        break;
+                    case fgui.RelationType.Bottom_Middle:
+                    case fgui.RelationType.Bottom_Top:
+                    case fgui.RelationType.Bottom_Bottom:
+                        this._owner.y -= (1 - (applyPivot ? this._owner.pivotY : 0)) * dHeight;
+                        break;
+                }
+            }
+            if (ox != this._owner.x || oy != this._owner.y) {
+                ox = this._owner.x - ox;
+                oy = this._owner.y - oy;
+                this._owner.updateGearFromRelations(1, ox, oy);
+                if (this._owner.parent) {
+                    var len = this._owner.parent._transitions.length;
+                    if (len > 0) {
+                        for (var i = 0; i < len; ++i) {
+                            this._owner.parent._transitions[i].updateFromRelations(this._owner.id, ox, oy);
+                        }
+                    }
+                }
+            }
+        };
+        RelationItem.prototype.applyOnXYChanged = function (info, dx, dy) {
+            var tmp;
+            switch (info.type) {
+                case fgui.RelationType.Left_Left:
+                case fgui.RelationType.Left_Center:
+                case fgui.RelationType.Left_Right:
+                case fgui.RelationType.Center_Center:
+                case fgui.RelationType.Right_Left:
+                case fgui.RelationType.Right_Center:
+                case fgui.RelationType.Right_Right:
+                    this._owner.x += dx;
+                    break;
+                case fgui.RelationType.Top_Top:
+                case fgui.RelationType.Top_Middle:
+                case fgui.RelationType.Top_Bottom:
+                case fgui.RelationType.Middle_Middle:
+                case fgui.RelationType.Bottom_Top:
+                case fgui.RelationType.Bottom_Middle:
+                case fgui.RelationType.Bottom_Bottom:
+                    this._owner.y += dy;
+                    break;
+                case fgui.RelationType.Width:
+                case fgui.RelationType.Height:
+                    break;
+                case fgui.RelationType.LeftExt_Left:
+                case fgui.RelationType.LeftExt_Right:
+                    if (this._owner != this._target.parent) {
+                        tmp = this._owner.xMin;
+                        this._owner.width = this._owner._rawWidth - dx;
+                        this._owner.xMin = tmp + dx;
+                    }
+                    else
+                        this._owner.width = this._owner._rawWidth - dx;
+                    break;
+                case fgui.RelationType.RightExt_Left:
+                case fgui.RelationType.RightExt_Right:
+                    if (this._owner != this._target.parent) {
+                        tmp = this._owner.xMin;
+                        this._owner.width = this._owner._rawWidth + dx;
+                        this._owner.xMin = tmp;
+                    }
+                    else
+                        this._owner.width = this._owner._rawWidth + dx;
+                    break;
+                case fgui.RelationType.TopExt_Top:
+                case fgui.RelationType.TopExt_Bottom:
+                    if (this._owner != this._target.parent) {
+                        tmp = this._owner.yMin;
+                        this._owner.height = this._owner._rawHeight - dy;
+                        this._owner.yMin = tmp + dy;
+                    }
+                    else
+                        this._owner.height = this._owner._rawHeight - dy;
+                    break;
+                case fgui.RelationType.BottomExt_Top:
+                case fgui.RelationType.BottomExt_Bottom:
+                    if (this._owner != this._target.parent) {
+                        tmp = this._owner.yMin;
+                        this._owner.height = this._owner._rawHeight + dy;
+                        this._owner.yMin = tmp;
+                    }
+                    else
+                        this._owner.height = this._owner._rawHeight + dy;
+                    break;
+            }
+        };
+        RelationItem.prototype.applyOnSizeChanged = function (info) {
+            var pos = 0, pivot = 0, delta = 0;
+            var v, tmp;
+            if (info.axis == 0) {
+                if (this._target != this._owner.parent) {
+                    pos = this._target.x;
+                    if (this._target.pivotAsAnchor)
+                        pivot = this._target.pivotX;
+                }
+                if (info.percent) {
+                    if (this._targetWidth != 0)
+                        delta = this._target._width / this._targetWidth;
+                }
+                else
+                    delta = this._target._width - this._targetWidth;
+            }
+            else {
+                if (this._target != this._owner.parent) {
+                    pos = this._target.y;
+                    if (this._target.pivotAsAnchor)
+                        pivot = this._target.pivotY;
+                }
+                if (info.percent) {
+                    if (this._targetHeight != 0)
+                        delta = this._target._height / this._targetHeight;
+                }
+                else
+                    delta = this._target._height - this._targetHeight;
+            }
+            switch (info.type) {
+                case fgui.RelationType.Left_Left:
+                    if (info.percent)
+                        this._owner.xMin = pos + (this._owner.xMin - pos) * delta;
+                    else if (pivot != 0)
+                        this._owner.x += delta * (-pivot);
+                    break;
+                case fgui.RelationType.Left_Center:
+                    if (info.percent)
+                        this._owner.xMin = pos + (this._owner.xMin - pos) * delta;
+                    else
+                        this._owner.x += delta * (0.5 - pivot);
+                    break;
+                case fgui.RelationType.Left_Right:
+                    if (info.percent)
+                        this._owner.xMin = pos + (this._owner.xMin - pos) * delta;
+                    else
+                        this._owner.x += delta * (1 - pivot);
+                    break;
+                case fgui.RelationType.Center_Center:
+                    if (info.percent)
+                        this._owner.xMin = pos + (this._owner.xMin + this._owner._rawWidth * 0.5 - pos) * delta - this._owner._rawWidth * 0.5;
+                    else
+                        this._owner.x += delta * (0.5 - pivot);
+                    break;
+                case fgui.RelationType.Right_Left:
+                    if (info.percent)
+                        this._owner.xMin = pos + (this._owner.xMin + this._owner._rawWidth - pos) * delta - this._owner._rawWidth;
+                    else if (pivot != 0)
+                        this._owner.x += delta * (-pivot);
+                    break;
+                case fgui.RelationType.Right_Center:
+                    if (info.percent)
+                        this._owner.xMin = pos + (this._owner.xMin + this._owner._rawWidth - pos) * delta - this._owner._rawWidth;
+                    else
+                        this._owner.x += delta * (0.5 - pivot);
+                    break;
+                case fgui.RelationType.Right_Right:
+                    if (info.percent)
+                        this._owner.xMin = pos + (this._owner.xMin + this._owner._rawWidth - pos) * delta - this._owner._rawWidth;
+                    else
+                        this._owner.x += delta * (1 - pivot);
+                    break;
+                case fgui.RelationType.Top_Top:
+                    if (info.percent)
+                        this._owner.yMin = pos + (this._owner.yMin - pos) * delta;
+                    else if (pivot != 0)
+                        this._owner.y += delta * (-pivot);
+                    break;
+                case fgui.RelationType.Top_Middle:
+                    if (info.percent)
+                        this._owner.yMin = pos + (this._owner.yMin - pos) * delta;
+                    else
+                        this._owner.y += delta * (0.5 - pivot);
+                    break;
+                case fgui.RelationType.Top_Bottom:
+                    if (info.percent)
+                        this._owner.yMin = pos + (this._owner.yMin - pos) * delta;
+                    else
+                        this._owner.y += delta * (1 - pivot);
+                    break;
+                case fgui.RelationType.Middle_Middle:
+                    if (info.percent)
+                        this._owner.yMin = pos + (this._owner.yMin + this._owner._rawHeight * 0.5 - pos) * delta - this._owner._rawHeight * 0.5;
+                    else
+                        this._owner.y += delta * (0.5 - pivot);
+                    break;
+                case fgui.RelationType.Bottom_Top:
+                    if (info.percent)
+                        this._owner.yMin = pos + (this._owner.yMin + this._owner._rawHeight - pos) * delta - this._owner._rawHeight;
+                    else if (pivot != 0)
+                        this._owner.y += delta * (-pivot);
+                    break;
+                case fgui.RelationType.Bottom_Middle:
+                    if (info.percent)
+                        this._owner.yMin = pos + (this._owner.yMin + this._owner._rawHeight - pos) * delta - this._owner._rawHeight;
+                    else
+                        this._owner.y += delta * (0.5 - pivot);
+                    break;
+                case fgui.RelationType.Bottom_Bottom:
+                    if (info.percent)
+                        this._owner.yMin = pos + (this._owner.yMin + this._owner._rawHeight - pos) * delta - this._owner._rawHeight;
+                    else
+                        this._owner.y += delta * (1 - pivot);
+                    break;
+                case fgui.RelationType.Width:
+                    if (this._owner._underConstruct && this._owner == this._target.parent)
+                        v = this._owner.sourceWidth - this._target.initWidth;
+                    else
+                        v = this._owner._rawWidth - this._targetWidth;
+                    if (info.percent)
+                        v = v * delta;
+                    if (this._target == this._owner.parent) {
+                        if (this._owner.pivotAsAnchor) {
+                            tmp = this._owner.xMin;
+                            this._owner.setSize(this._target._width + v, this._owner._rawHeight, true);
+                            this._owner.xMin = tmp;
+                        }
+                        else
+                            this._owner.setSize(this._target._width + v, this._owner._rawHeight, true);
+                    }
+                    else
+                        this._owner.width = this._target._width + v;
+                    break;
+                case fgui.RelationType.Height:
+                    if (this._owner._underConstruct && this._owner == this._target.parent)
+                        v = this._owner.sourceHeight - this._target.initHeight;
+                    else
+                        v = this._owner._rawHeight - this._targetHeight;
+                    if (info.percent)
+                        v = v * delta;
+                    if (this._target == this._owner.parent) {
+                        if (this._owner.pivotAsAnchor) {
+                            tmp = this._owner.yMin;
+                            this._owner.setSize(this._owner._rawWidth, this._target._height + v, true);
+                            this._owner.yMin = tmp;
+                        }
+                        else
+                            this._owner.setSize(this._owner._rawWidth, this._target._height + v, true);
+                    }
+                    else
+                        this._owner.height = this._target._height + v;
+                    break;
+                case fgui.RelationType.LeftExt_Left:
+                    tmp = this._owner.xMin;
+                    if (info.percent)
+                        v = pos + (tmp - pos) * delta - tmp;
+                    else
+                        v = delta * (-pivot);
+                    this._owner.width = this._owner._rawWidth - v;
+                    this._owner.xMin = tmp + v;
+                    break;
+                case fgui.RelationType.LeftExt_Right:
+                    tmp = this._owner.xMin;
+                    if (info.percent)
+                        v = pos + (tmp - pos) * delta - tmp;
+                    else
+                        v = delta * (1 - pivot);
+                    this._owner.width = this._owner._rawWidth - v;
+                    this._owner.xMin = tmp + v;
+                    break;
+                case fgui.RelationType.RightExt_Left:
+                    tmp = this._owner.xMin;
+                    if (info.percent)
+                        v = pos + (tmp + this._owner._rawWidth - pos) * delta - (tmp + this._owner._rawWidth);
+                    else
+                        v = delta * (-pivot);
+                    this._owner.width = this._owner._rawWidth + v;
+                    this._owner.xMin = tmp;
+                    break;
+                case fgui.RelationType.RightExt_Right:
+                    tmp = this._owner.xMin;
+                    if (info.percent) {
+                        if (this._owner == this._target.parent) {
+                            if (this._owner._underConstruct)
+                                this._owner.width = pos + this._target._width - this._target._width * pivot +
+                                    (this._owner.sourceWidth - pos - this._target.initWidth + this._target.initWidth * pivot) * delta;
+                            else
+                                this._owner.width = pos + (this._owner._rawWidth - pos) * delta;
+                        }
+                        else {
+                            v = pos + (tmp + this._owner._rawWidth - pos) * delta - (tmp + this._owner._rawWidth);
+                            this._owner.width = this._owner._rawWidth + v;
+                            this._owner.xMin = tmp;
+                        }
+                    }
+                    else {
+                        if (this._owner == this._target.parent) {
+                            if (this._owner._underConstruct)
+                                this._owner.width = this._owner.sourceWidth + (this._target._width - this._target.initWidth) * (1 - pivot);
+                            else
+                                this._owner.width = this._owner._rawWidth + delta * (1 - pivot);
+                        }
+                        else {
+                            v = delta * (1 - pivot);
+                            this._owner.width = this._owner._rawWidth + v;
+                            this._owner.xMin = tmp;
+                        }
+                    }
+                    break;
+                case fgui.RelationType.TopExt_Top:
+                    tmp = this._owner.yMin;
+                    if (info.percent)
+                        v = pos + (tmp - pos) * delta - tmp;
+                    else
+                        v = delta * (-pivot);
+                    this._owner.height = this._owner._rawHeight - v;
+                    this._owner.yMin = tmp + v;
+                    break;
+                case fgui.RelationType.TopExt_Bottom:
+                    tmp = this._owner.yMin;
+                    if (info.percent)
+                        v = pos + (tmp - pos) * delta - tmp;
+                    else
+                        v = delta * (1 - pivot);
+                    this._owner.height = this._owner._rawHeight - v;
+                    this._owner.yMin = tmp + v;
+                    break;
+                case fgui.RelationType.BottomExt_Top:
+                    tmp = this._owner.yMin;
+                    if (info.percent)
+                        v = pos + (tmp + this._owner._rawHeight - pos) * delta - (tmp + this._owner._rawHeight);
+                    else
+                        v = delta * (-pivot);
+                    this._owner.height = this._owner._rawHeight + v;
+                    this._owner.yMin = tmp;
+                    break;
+                case fgui.RelationType.BottomExt_Bottom:
+                    tmp = this._owner.yMin;
+                    if (info.percent) {
+                        if (this._owner == this._target.parent) {
+                            if (this._owner._underConstruct)
+                                this._owner.height = pos + this._target._height - this._target._height * pivot +
+                                    (this._owner.sourceHeight - pos - this._target.initHeight + this._target.initHeight * pivot) * delta;
+                            else
+                                this._owner.height = pos + (this._owner._rawHeight - pos) * delta;
+                        }
+                        else {
+                            v = pos + (tmp + this._owner._rawHeight - pos) * delta - (tmp + this._owner._rawHeight);
+                            this._owner.height = this._owner._rawHeight + v;
+                            this._owner.yMin = tmp;
+                        }
+                    }
+                    else {
+                        if (this._owner == this._target.parent) {
+                            if (this._owner._underConstruct)
+                                this._owner.height = this._owner.sourceHeight + (this._target._height - this._target.initHeight) * (1 - pivot);
+                            else
+                                this._owner.height = this._owner._rawHeight + delta * (1 - pivot);
+                        }
+                        else {
+                            v = delta * (1 - pivot);
+                            this._owner.height = this._owner._rawHeight + v;
+                            this._owner.yMin = tmp;
+                        }
+                    }
+                    break;
+            }
+        };
+        RelationItem.prototype.addRefTarget = function (target) {
+            if (target != this._owner.parent)
+                target.addEventListener(fgui.GObject.XY_CHANGED, this.__targetXYChanged, this);
+            target.addEventListener(fgui.GObject.SIZE_CHANGED, this.__targetSizeChanged, this);
+            target.addEventListener(fgui.GObject.SIZE_DELAY_CHANGE, this.__targetSizeWillChange, this);
+            this._targetX = this._target.x;
+            this._targetY = this._target.y;
+            this._targetWidth = this._target._width;
+            this._targetHeight = this._target._height;
+        };
+        RelationItem.prototype.releaseRefTarget = function (target) {
+            target.removeEventListener(fgui.GObject.XY_CHANGED, this.__targetXYChanged, this);
+            target.removeEventListener(fgui.GObject.SIZE_CHANGED, this.__targetSizeChanged, this);
+            target.removeEventListener(fgui.GObject.SIZE_DELAY_CHANGE, this.__targetSizeWillChange, this);
+        };
+        RelationItem.prototype.__targetXYChanged = function (evt) {
+            if (this._owner.relations.handling != null || this._owner.group != null && this._owner.group._updating) {
+                this._targetX = this._target.x;
+                this._targetY = this._target.y;
+                return;
+            }
+            this._owner.relations.handling = this._target;
+            var ox = this._owner.x;
+            var oy = this._owner.y;
+            var dx = this._target.x - this._targetX;
+            var dy = this._target.y - this._targetY;
+            var length = this._defs.length;
+            for (var i = 0; i < length; i++) {
+                var info = this._defs[i];
+                this.applyOnXYChanged(info, dx, dy);
+            }
+            this._targetX = this._target.x;
+            this._targetY = this._target.y;
+            if (ox != this._owner.x || oy != this._owner.y) {
+                ox = this._owner.x - ox;
+                oy = this._owner.y - oy;
+                this._owner.updateGearFromRelations(1, ox, oy);
+                if (this._owner.parent) {
+                    var len = this._owner.parent._transitions.length;
+                    if (len > 0) {
+                        for (var i = 0; i < len; ++i) {
+                            this._owner.parent._transitions[i].updateFromRelations(this._owner.id, ox, oy);
+                        }
+                    }
+                }
+            }
+            this._owner.relations.handling = null;
+        };
+        RelationItem.prototype.__targetSizeChanged = function (evt) {
+            if (this._owner.relations.handling != null)
+                return;
+            this._owner.relations.handling = this._target;
+            var ox = this._owner.x;
+            var oy = this._owner.y;
+            var ow = this._owner._rawWidth;
+            var oh = this._owner._rawHeight;
+            var length = this._defs.length;
+            for (var i = 0; i < length; i++) {
+                var info = this._defs[i];
+                this.applyOnSizeChanged(info);
+            }
+            this._targetWidth = this._target._width;
+            this._targetHeight = this._target._height;
+            if (ox != this._owner.x || oy != this._owner.y) {
+                ox = this._owner.x - ox;
+                oy = this._owner.y - oy;
+                this._owner.updateGearFromRelations(1, ox, oy);
+                if (this._owner.parent) {
+                    var len = this._owner.parent._transitions.length;
+                    if (len > 0) {
+                        for (var i = 0; i < len; ++i) {
+                            this._owner.parent._transitions[i].updateFromRelations(this._owner.id, ox, oy);
+                        }
+                    }
+                }
+            }
+            if (ow != this._owner._rawWidth || oh != this._owner._rawHeight) {
+                ow = this._owner._rawWidth - ow;
+                oh = this._owner._rawHeight - oh;
+                this._owner.updateGearFromRelations(2, ow, oh);
+            }
+            this._owner.relations.handling = null;
+        };
+        RelationItem.prototype.__targetSizeWillChange = function (evt) {
+            this._owner.relations.sizeDirty = true;
+        };
+        return RelationItem;
+    }());
+    fgui.RelationItem = RelationItem;
+    var RelationDef = (function () {
+        function RelationDef() {
+        }
+        RelationDef.prototype.copyFrom = function (source) {
+            this.percent = source.percent;
+            this.type = source.type;
+            this.axis = source.axis;
+        };
+        return RelationDef;
+    }());
+    fgui.RelationDef = RelationDef;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var Relations = (function () {
+        function Relations(owner) {
+            this._owner = owner;
+            this._items = new Array();
+        }
+        Relations.prototype.add = function (target, relationType, usePercent) {
+            var length = this._items.length;
+            for (var i = 0; i < length; i++) {
+                var item = this._items[i];
+                if (item.target == target) {
+                    item.add(relationType, usePercent);
+                    return;
+                }
+            }
+            var newItem = new fgui.RelationItem(this._owner);
+            newItem.target = target;
+            newItem.add(relationType, usePercent);
+            this._items.push(newItem);
+        };
+        Relations.prototype.remove = function (target, relationType) {
+            relationType = relationType || 0;
+            var cnt = this._items.length;
+            var i = 0;
+            while (i < cnt) {
+                var item = this._items[i];
+                if (item.target == target) {
+                    item.remove(relationType);
+                    if (item.isEmpty) {
+                        item.dispose();
+                        this._items.splice(i, 1);
+                        cnt--;
+                    }
+                    else
+                        i++;
+                }
+                else
+                    i++;
+            }
+        };
+        Relations.prototype.contains = function (target) {
+            var length = this._items.length;
+            for (var i = 0; i < length; i++) {
+                var item = this._items[i];
+                if (item.target == target)
+                    return true;
+            }
+            return false;
+        };
+        Relations.prototype.clearFor = function (target) {
+            var cnt = this._items.length;
+            var i = 0;
+            while (i < cnt) {
+                var item = this._items[i];
+                if (item.target == target) {
+                    item.dispose();
+                    this._items.splice(i, 1);
+                    cnt--;
+                }
+                else
+                    i++;
+            }
+        };
+        Relations.prototype.clearAll = function () {
+            var length = this._items.length;
+            for (var i = 0; i < length; i++) {
+                var item = this._items[i];
+                item.dispose();
+            }
+            this._items.length = 0;
+        };
+        Relations.prototype.copyFrom = function (source) {
+            this.clearAll();
+            var arr = source._items;
+            var length = arr.length;
+            for (var i = 0; i < length; i++) {
+                var ri = arr[i];
+                var item = new fgui.RelationItem(this._owner);
+                item.copyFrom(ri);
+                this._items.push(item);
+            }
+        };
+        Relations.prototype.dispose = function () {
+            this.clearAll();
+        };
+        Relations.prototype.onOwnerSizeChanged = function (dWidth, dHeight, applyPivot) {
+            if (this._items.length == 0)
+                return;
+            var length = this._items.length;
+            for (var i = 0; i < length; i++) {
+                var item = this._items[i];
+                item.applyOnSelfResized(dWidth, dHeight, applyPivot);
+            }
+        };
+        Relations.prototype.ensureRelationsSizeCorrect = function () {
+            if (this._items.length == 0)
+                return;
+            this.sizeDirty = false;
+            var length = this._items.length;
+            for (var i = 0; i < length; i++) {
+                var item = this._items[i];
+                item.target.ensureSizeCorrect();
+            }
+        };
+        Object.defineProperty(Relations.prototype, "empty", {
+            get: function () {
+                return this._items.length == 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Relations.prototype.setup = function (buffer, parentToChild) {
+            var cnt = buffer.readByte();
+            var target;
+            for (var i = 0; i < cnt; i++) {
+                var targetIndex = buffer.readShort();
+                if (targetIndex == -1)
+                    target = this._owner.parent;
+                else if (parentToChild)
+                    target = this._owner.getChildAt(targetIndex);
+                else
+                    target = this._owner.parent.getChildAt(targetIndex);
+                var newItem = new fgui.RelationItem(this._owner);
+                newItem.target = target;
+                this._items.push(newItem);
+                var cnt2 = buffer.readByte();
+                for (var j = 0; j < cnt2; j++) {
+                    var rt = buffer.readByte();
+                    var usePercent = buffer.readBool();
+                    newItem.internalAdd(rt, usePercent);
+                }
+            }
+        };
+        return Relations;
+    }());
+    fgui.Relations = Relations;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ScrollPane = (function (_super_1) {
+        __extends(ScrollPane, _super_1);
+        function ScrollPane(owner) {
+            var _this = _super_1.call(this) || this;
+            _this._owner = owner;
+            _this._maskContainer = new egret.DisplayObjectContainer();
+            _this._owner._rootContainer.addChild(_this._maskContainer);
+            _this._container = _this._owner._container;
+            _this._container.x = 0;
+            _this._container.y = 0;
+            _this._maskContainer.addChild(_this._container);
+            _this._scrollBarMargin = new fgui.Margin();
+            _this._xPos = 0;
+            _this._yPos = 0;
+            _this._aniFlag = 0;
+            _this._tweening = 0;
+            _this._footerLockedSize = 0;
+            _this._headerLockedSize = 0;
+            _this._viewSize = new egret.Point();
+            _this._contentSize = new egret.Point();
+            _this._pageSize = new egret.Point(1, 1);
+            _this._overlapSize = new egret.Point();
+            _this._tweenTime = new egret.Point();
+            _this._tweenStart = new egret.Point();
+            _this._tweenDuration = new egret.Point();
+            _this._tweenChange = new egret.Point();
+            _this._velocity = new egret.Point();
+            _this._containerPos = new egret.Point();
+            _this._beginTouchPos = new egret.Point();
+            _this._lastTouchPos = new egret.Point();
+            _this._lastTouchGlobalPos = new egret.Point();
+            _this._scrollStep = fgui.UIConfig.defaultScrollStep;
+            _this._decelerationRate = fgui.UIConfig.defaultScrollDecelerationRate;
+            _this._owner.addEventListener(egret.TouchEvent.TOUCH_BEGIN, _this.__touchBegin, _this);
+            return _this;
+        }
+        ScrollPane.prototype.setup = function (buffer) {
+            this._scrollType = buffer.readByte();
+            var scrollBarDisplay = buffer.readByte();
+            var flags = buffer.readInt();
+            if (buffer.readBool()) {
+                this._scrollBarMargin.top = buffer.readInt();
+                this._scrollBarMargin.bottom = buffer.readInt();
+                this._scrollBarMargin.left = buffer.readInt();
+                this._scrollBarMargin.right = buffer.readInt();
+            }
+            var vtScrollBarRes = buffer.readS();
+            var hzScrollBarRes = buffer.readS();
+            var headerRes = buffer.readS();
+            var footerRes = buffer.readS();
+            if ((flags & 1) != 0)
+                this._displayOnLeft = true;
+            if ((flags & 2) != 0)
+                this._snapToItem = true;
+            if ((flags & 4) != 0)
+                this._displayInDemand = true;
+            if ((flags & 8) != 0)
+                this._pageMode = true;
+            if (flags & 16)
+                this._touchEffect = true;
+            else if (flags & 32)
+                this._touchEffect = false;
+            else
+                this._touchEffect = fgui.UIConfig.defaultScrollTouchEffect;
+            if (flags & 64)
+                this._bouncebackEffect = true;
+            else if (flags & 128)
+                this._bouncebackEffect = false;
+            else
+                this._bouncebackEffect = fgui.UIConfig.defaultScrollBounceEffect;
+            if ((flags & 256) != 0)
+                this._inertiaDisabled = true;
+            if ((flags & 512) == 0)
+                this._maskContainer.scrollRect = new egret.Rectangle();
+            if ((flags & 1024) != 0)
+                this._floating = true;
+            if ((flags & 2048) != 0)
+                this._dontClipMargin = true;
+            if (scrollBarDisplay == fgui.ScrollBarDisplayType.Default)
+                scrollBarDisplay = fgui.UIConfig.defaultScrollBarDisplay;
+            if (scrollBarDisplay != fgui.ScrollBarDisplayType.Hidden) {
+                if (this._scrollType == fgui.ScrollType.Both || this._scrollType == fgui.ScrollType.Vertical) {
+                    var res = vtScrollBarRes ? vtScrollBarRes : fgui.UIConfig.verticalScrollBar;
+                    if (res) {
+                        this._vtScrollBar = fgui.UIPackage.createObjectFromURL(res);
+                        if (!this._vtScrollBar)
+                            throw "cannot create scrollbar from " + res;
+                        this._vtScrollBar.setScrollPane(this, true);
+                        this._owner._rootContainer.addChild(this._vtScrollBar.displayObject);
+                    }
+                }
+                if (this._scrollType == fgui.ScrollType.Both || this._scrollType == fgui.ScrollType.Horizontal) {
+                    var res = hzScrollBarRes ? hzScrollBarRes : fgui.UIConfig.horizontalScrollBar;
+                    if (res) {
+                        this._hzScrollBar = fgui.UIPackage.createObjectFromURL(res);
+                        if (!this._hzScrollBar)
+                            throw "cannot create scrollbar from " + res;
+                        this._hzScrollBar.setScrollPane(this, false);
+                        this._owner._rootContainer.addChild(this._hzScrollBar.displayObject);
+                    }
+                }
+                if (scrollBarDisplay == fgui.ScrollBarDisplayType.Auto)
+                    this._scrollBarDisplayAuto = true;
+                if (this._scrollBarDisplayAuto) {
+                    if (this._vtScrollBar)
+                        this._vtScrollBar.displayObject.visible = false;
+                    if (this._hzScrollBar)
+                        this._hzScrollBar.displayObject.visible = false;
+                }
+            }
+            if (headerRes) {
+                this._header = fgui.UIPackage.createObjectFromURL(headerRes);
+                if (!this._header)
+                    throw "cannot create scrollPane header from " + headerRes;
+            }
+            if (footerRes) {
+                this._footer = fgui.UIPackage.createObjectFromURL(footerRes);
+                if (!this._footer)
+                    throw "cannot create scrollPane footer from " + footerRes;
+            }
+            if (this._header || this._footer)
+                this._refreshBarAxis = (this._scrollType == fgui.ScrollType.Both || this._scrollType == fgui.ScrollType.Vertical) ? "y" : "x";
+            this.setSize(this._owner.width, this._owner.height);
+        };
+        ScrollPane.prototype.dispose = function () {
+            if (this._tweening != 0)
+                fgui.GTimers.inst.remove(this.tweenUpdate, this);
+            delete this._pageController;
+            if (this._hzScrollBar)
+                this._hzScrollBar.dispose();
+            if (this._vtScrollBar)
+                this._vtScrollBar.dispose();
+            if (this._header)
+                this._header.dispose();
+            if (this._footer)
+                this._footer.dispose();
+        };
+        Object.defineProperty(ScrollPane.prototype, "owner", {
+            get: function () {
+                return this._owner;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "hzScrollBar", {
+            get: function () {
+                return this._hzScrollBar;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "vtScrollBar", {
+            get: function () {
+                return this._vtScrollBar;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "header", {
+            get: function () {
+                return this._header;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "footer", {
+            get: function () {
+                return this._footer;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "bouncebackEffect", {
+            get: function () {
+                return this._bouncebackEffect;
+            },
+            set: function (sc) {
+                this._bouncebackEffect = sc;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "touchEffect", {
+            get: function () {
+                return this._touchEffect;
+            },
+            set: function (sc) {
+                this._touchEffect = sc;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "scrollStep", {
+            get: function () {
+                return this._scrollStep;
+            },
+            set: function (val) {
+                this._scrollStep = val;
+                if (this._scrollStep == 0)
+                    this._scrollStep = fgui.UIConfig.defaultScrollStep;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "decelerationRate", {
+            get: function () {
+                return this._decelerationRate;
+            },
+            set: function (val) {
+                this._decelerationRate = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "snapToItem", {
+            get: function () {
+                return this._snapToItem;
+            },
+            set: function (value) {
+                this._snapToItem = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "isDragged", {
+            get: function () {
+                return this._dragged;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "percX", {
+            get: function () {
+                return this._overlapSize.x == 0 ? 0 : this._xPos / this._overlapSize.x;
+            },
+            set: function (value) {
+                this.setPercX(value, false);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ScrollPane.prototype.setPercX = function (value, ani) {
+            if (ani === void 0) { ani = false; }
+            this._owner.ensureBoundsCorrect();
+            this.setPosX(this._overlapSize.x * fgui.ToolSet.clamp01(value), ani);
+        };
+        Object.defineProperty(ScrollPane.prototype, "percY", {
+            get: function () {
+                return this._overlapSize.y == 0 ? 0 : this._yPos / this._overlapSize.y;
+            },
+            set: function (value) {
+                this.setPercY(value, false);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ScrollPane.prototype.setPercY = function (value, ani) {
+            if (ani === void 0) { ani = false; }
+            this._owner.ensureBoundsCorrect();
+            this.setPosY(this._overlapSize.y * fgui.ToolSet.clamp01(value), ani);
+        };
+        Object.defineProperty(ScrollPane.prototype, "posX", {
+            get: function () {
+                return this._xPos;
+            },
+            set: function (value) {
+                this.setPosX(value, false);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ScrollPane.prototype.setPosX = function (value, ani) {
+            this._owner.ensureBoundsCorrect();
+            if (this._loop == 1)
+                value = this.loopCheckingNewPos(value, "x");
+            value = fgui.ToolSet.clamp(value, 0, this._overlapSize.x);
+            if (value != this._xPos) {
+                this._xPos = value;
+                this.posChanged(ani);
+            }
+        };
+        Object.defineProperty(ScrollPane.prototype, "posY", {
+            get: function () {
+                return this._yPos;
+            },
+            set: function (value) {
+                this.setPosY(value, false);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ScrollPane.prototype.setPosY = function (value, ani) {
+            this._owner.ensureBoundsCorrect();
+            if (this._loop == 1)
+                value = this.loopCheckingNewPos(value, "y");
+            value = fgui.ToolSet.clamp(value, 0, this._overlapSize.y);
+            if (value != this._yPos) {
+                this._yPos = value;
+                this.posChanged(ani);
+            }
+        };
+        Object.defineProperty(ScrollPane.prototype, "contentWidth", {
+            get: function () {
+                return this._contentSize.x;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "contentHeight", {
+            get: function () {
+                return this._contentSize.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "viewWidth", {
+            get: function () {
+                return this._viewSize.x;
+            },
+            set: function (value) {
+                value = value + this._owner.margin.left + this._owner.margin.right;
+                if (this._vtScrollBar && !this._floating)
+                    value += this._vtScrollBar.width;
+                this._owner.width = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "viewHeight", {
+            get: function () {
+                return this._viewSize.y;
+            },
+            set: function (value) {
+                value = value + this._owner.margin.top + this._owner.margin.bottom;
+                if (this._hzScrollBar && !this._floating)
+                    value += this._hzScrollBar.height;
+                this._owner.height = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "currentPageX", {
+            get: function () {
+                if (!this._pageMode)
+                    return 0;
+                var page = Math.floor(this._xPos / this._pageSize.x);
+                if (this._xPos - page * this._pageSize.x > this._pageSize.x * 0.5)
+                    page++;
+                return page;
+            },
+            set: function (value) {
+                this.setCurrentPageX(value, false);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "currentPageY", {
+            get: function () {
+                if (!this._pageMode)
+                    return 0;
+                var page = Math.floor(this._yPos / this._pageSize.y);
+                if (this._yPos - page * this._pageSize.y > this._pageSize.y * 0.5)
+                    page++;
+                return page;
+            },
+            set: function (value) {
+                this.setCurrentPageY(value, false);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ScrollPane.prototype.setCurrentPageX = function (value, ani) {
+            if (!this._pageMode)
+                return;
+            this._owner.ensureBoundsCorrect();
+            if (this._overlapSize.x > 0)
+                this.setPosX(value * this._pageSize.x, ani);
+        };
+        ScrollPane.prototype.setCurrentPageY = function (value, ani) {
+            if (!this._pageMode)
+                return;
+            this._owner.ensureBoundsCorrect();
+            if (this._overlapSize.y > 0)
+                this.setPosY(value * this._pageSize.y, ani);
+        };
+        Object.defineProperty(ScrollPane.prototype, "isBottomMost", {
+            get: function () {
+                return this._yPos == this._overlapSize.y || this._overlapSize.y == 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "isRightMost", {
+            get: function () {
+                return this._xPos == this._overlapSize.x || this._overlapSize.x == 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "pageController", {
+            get: function () {
+                return this._pageController;
+            },
+            set: function (value) {
+                this._pageController = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "scrollingPosX", {
+            get: function () {
+                return fgui.ToolSet.clamp(-this._container.x, 0, this._overlapSize.x);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ScrollPane.prototype, "scrollingPosY", {
+            get: function () {
+                return fgui.ToolSet.clamp(-this._container.y, 0, this._overlapSize.y);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ScrollPane.prototype.scrollTop = function (ani) {
+            this.setPercY(0, ani);
+        };
+        ScrollPane.prototype.scrollBottom = function (ani) {
+            this.setPercY(1, ani);
+        };
+        ScrollPane.prototype.scrollUp = function (ratio, ani) {
+            ratio = ratio || 1;
+            if (this._pageMode)
+                this.setPosY(this._yPos - this._pageSize.y * ratio, ani);
+            else
+                this.setPosY(this._yPos - this._scrollStep * ratio, ani);
+        };
+        ScrollPane.prototype.scrollDown = function (ratio, ani) {
+            ratio = ratio || 1;
+            if (this._pageMode)
+                this.setPosY(this._yPos + this._pageSize.y * ratio, ani);
+            else
+                this.setPosY(this._yPos + this._scrollStep * ratio, ani);
+        };
+        ScrollPane.prototype.scrollLeft = function (ratio, ani) {
+            ratio = ratio || 1;
+            if (this._pageMode)
+                this.setPosX(this._xPos - this._pageSize.x * ratio, ani);
+            else
+                this.setPosX(this._xPos - this._scrollStep * ratio, ani);
+        };
+        ScrollPane.prototype.scrollRight = function (ratio, ani) {
+            ratio = ratio || 1;
+            if (this._pageMode)
+                this.setPosX(this._xPos + this._pageSize.x * ratio, ani);
+            else
+                this.setPosX(this._xPos + this._scrollStep * ratio, ani);
+        };
+        ScrollPane.prototype.scrollToView = function (target, ani, setFirst) {
+            this._owner.ensureBoundsCorrect();
+            if (this._needRefresh)
+                this.refresh();
+            var rect;
+            if (target instanceof fgui.GObject) {
+                if (target.parent != this._owner) {
+                    target.parent.localToGlobalRect(target.x, target.y, target.width, target.height, s_rect);
+                    rect = this._owner.globalToLocalRect(s_rect.x, s_rect.y, s_rect.width, s_rect.height, s_rect);
+                }
+                else {
+                    rect = s_rect;
+                    rect.setTo(target.x, target.y, target.width, target.height);
+                }
+            }
+            else
+                rect = target;
+            if (this._overlapSize.y > 0) {
+                var bottom = this._yPos + this._viewSize.y;
+                if (setFirst || rect.y <= this._yPos || rect.height >= this._viewSize.y) {
+                    if (this._pageMode)
+                        this.setPosY(Math.floor(rect.y / this._pageSize.y) * this._pageSize.y, ani);
+                    else
+                        this.setPosY(rect.y, ani);
+                }
+                else if (rect.y + rect.height > bottom) {
+                    if (this._pageMode)
+                        this.setPosY(Math.floor(rect.y / this._pageSize.y) * this._pageSize.y, ani);
+                    else if (rect.height <= this._viewSize.y / 2)
+                        this.setPosY(rect.y + rect.height * 2 - this._viewSize.y, ani);
+                    else
+                        this.setPosY(rect.y + rect.height - this._viewSize.y, ani);
+                }
+            }
+            if (this._overlapSize.x > 0) {
+                var right = this._xPos + this._viewSize.x;
+                if (setFirst || rect.x <= this._xPos || rect.width >= this._viewSize.x) {
+                    if (this._pageMode)
+                        this.setPosX(Math.floor(rect.x / this._pageSize.x) * this._pageSize.x, ani);
+                    else
+                        this.setPosX(rect.x, ani);
+                }
+                else if (rect.x + rect.width > right) {
+                    if (this._pageMode)
+                        this.setPosX(Math.floor(rect.x / this._pageSize.x) * this._pageSize.x, ani);
+                    else if (rect.width <= this._viewSize.x / 2)
+                        this.setPosX(rect.x + rect.width * 2 - this._viewSize.x, ani);
+                    else
+                        this.setPosX(rect.x + rect.width - this._viewSize.x, ani);
+                }
+            }
+            if (!ani && this._needRefresh)
+                this.refresh();
+        };
+        ScrollPane.prototype.isChildInView = function (obj) {
+            if (this._overlapSize.y > 0) {
+                var dist = obj.y + this._container.y;
+                if (dist < -obj.height || dist > this._viewSize.y)
+                    return false;
+            }
+            if (this._overlapSize.x > 0) {
+                dist = obj.x + this._container.x;
+                if (dist < -obj.width || dist > this._viewSize.x)
+                    return false;
+            }
+            return true;
+        };
+        ScrollPane.prototype.cancelDragging = function () {
+            this._owner.displayObject.removeEventListener(egret.TouchEvent.TOUCH_MOVE, this.__touchMove, this);
+            this._owner.displayObject.removeEventListener(egret.TouchEvent.TOUCH_END, this.__touchEnd, this);
+            this._owner.displayObject.removeEventListener(egret.TouchEvent.TOUCH_TAP, this.__touchTap, this);
+            if (ScrollPane.draggingPane == this)
+                ScrollPane.draggingPane = null;
+            _gestureFlag = 0;
+            this._dragged = false;
+            this._maskContainer.touchChildren = true;
+        };
+        ScrollPane.prototype.lockHeader = function (size) {
+            if (this._headerLockedSize == size)
+                return;
+            this._headerLockedSize = size;
+            if (!this._refreshEventDispatching && this._container[this._refreshBarAxis] >= 0) {
+                this._tweenStart.setTo(this._container.x, this._container.y);
+                this._tweenChange.setTo(0, 0);
+                this._tweenChange[this._refreshBarAxis] = this._headerLockedSize - this._tweenStart[this._refreshBarAxis];
+                this._tweenDuration.setTo(TWEEN_TIME_DEFAULT, TWEEN_TIME_DEFAULT);
+                this.startTween(2);
+            }
+        };
+        ScrollPane.prototype.lockFooter = function (size) {
+            if (this._footerLockedSize == size)
+                return;
+            this._footerLockedSize = size;
+            if (!this._refreshEventDispatching && this._container[this._refreshBarAxis] <= -this._overlapSize[this._refreshBarAxis]) {
+                this._tweenStart.setTo(this._container.x, this._container.y);
+                this._tweenChange.setTo(0, 0);
+                var max = this._overlapSize[this._refreshBarAxis];
+                if (max == 0)
+                    max = Math.max(this._contentSize[this._refreshBarAxis] + this._footerLockedSize - this._viewSize[this._refreshBarAxis], 0);
+                else
+                    max += this._footerLockedSize;
+                this._tweenChange[this._refreshBarAxis] = -max - this._tweenStart[this._refreshBarAxis];
+                this._tweenDuration.setTo(TWEEN_TIME_DEFAULT, TWEEN_TIME_DEFAULT);
+                this.startTween(2);
+            }
+        };
+        ScrollPane.prototype.onOwnerSizeChanged = function () {
+            this.setSize(this._owner.width, this._owner.height);
+            this.posChanged(false);
+        };
+        ScrollPane.prototype.handleControllerChanged = function (c) {
+            if (this._pageController == c) {
+                if (this._scrollType == fgui.ScrollType.Horizontal)
+                    this.setCurrentPageX(c.selectedIndex, true);
+                else
+                    this.setCurrentPageY(c.selectedIndex, true);
+            }
+        };
+        ScrollPane.prototype.updatePageController = function () {
+            if (this._pageController && !this._pageController.changing) {
+                var index;
+                if (this._scrollType == fgui.ScrollType.Horizontal)
+                    index = this.currentPageX;
+                else
+                    index = this.currentPageY;
+                if (index < this._pageController.pageCount) {
+                    var c = this._pageController;
+                    this._pageController = null;
+                    c.selectedIndex = index;
+                    this._pageController = c;
+                }
+            }
+        };
+        ScrollPane.prototype.adjustMaskContainer = function () {
+            var mx = 0, my = 0;
+            if (this._dontClipMargin) {
+                if (this._displayOnLeft && this._vtScrollBar && !this._floating)
+                    mx = this._vtScrollBar.width;
+            }
+            else {
+                if (this._displayOnLeft && this._vtScrollBar && !this._floating)
+                    mx = this._owner.margin.left + this._vtScrollBar.width;
+                else
+                    mx = this._owner.margin.left;
+                my = this._owner.margin.top;
+            }
+            this._maskContainer.x = mx;
+            this._maskContainer.y = my;
+            mx = this._owner._alignOffset.x;
+            my = this._owner._alignOffset.y;
+            if (mx != 0 || my != 0 || this._dontClipMargin) {
+                if (!this._alignContainer) {
+                    this._alignContainer = new egret.DisplayObjectContainer();
+                    this._maskContainer.addChild(this._alignContainer);
+                    this._alignContainer.addChild(this._container);
+                }
+            }
+            if (this._alignContainer) {
+                if (this._dontClipMargin) {
+                    mx += this._owner.margin.left;
+                    my += this._owner.margin.top;
+                }
+                this._alignContainer.x = mx;
+                this._alignContainer.y = my;
+            }
+        };
+        ScrollPane.prototype.setSize = function (aWidth, aHeight) {
+            this.adjustMaskContainer();
+            if (this._hzScrollBar) {
+                this._hzScrollBar.y = aHeight - this._hzScrollBar.height;
+                if (this._vtScrollBar && !this._vScrollNone) {
+                    this._hzScrollBar.width = aWidth - this._vtScrollBar.width - this._scrollBarMargin.left - this._scrollBarMargin.right;
+                    if (this._displayOnLeft)
+                        this._hzScrollBar.x = this._scrollBarMargin.left + this._vtScrollBar.width;
+                    else
+                        this._hzScrollBar.x = this._scrollBarMargin.left;
+                }
+                else {
+                    this._hzScrollBar.width = aWidth - this._scrollBarMargin.left - this._scrollBarMargin.right;
+                    this._hzScrollBar.x = this._scrollBarMargin.left;
+                }
+            }
+            if (this._vtScrollBar) {
+                if (!this._displayOnLeft)
+                    this._vtScrollBar.x = aWidth - this._vtScrollBar.width;
+                if (this._hzScrollBar)
+                    this._vtScrollBar.height = aHeight - this._hzScrollBar.height - this._scrollBarMargin.top - this._scrollBarMargin.bottom;
+                else
+                    this._vtScrollBar.height = aHeight - this._scrollBarMargin.top - this._scrollBarMargin.bottom;
+                this._vtScrollBar.y = this._scrollBarMargin.top;
+            }
+            this._viewSize.x = aWidth;
+            this._viewSize.y = aHeight;
+            if (this._hzScrollBar && !this._floating)
+                this._viewSize.y -= this._hzScrollBar.height;
+            if (this._vtScrollBar && !this._floating)
+                this._viewSize.x -= this._vtScrollBar.width;
+            this._viewSize.x -= (this._owner.margin.left + this._owner.margin.right);
+            this._viewSize.y -= (this._owner.margin.top + this._owner.margin.bottom);
+            this._viewSize.x = Math.max(1, this._viewSize.x);
+            this._viewSize.y = Math.max(1, this._viewSize.y);
+            this._pageSize.x = this._viewSize.x;
+            this._pageSize.y = this._viewSize.y;
+            this.handleSizeChanged();
+        };
+        ScrollPane.prototype.setContentSize = function (aWidth, aHeight) {
+            if (this._contentSize.x == aWidth && this._contentSize.y == aHeight)
+                return;
+            this._contentSize.x = aWidth;
+            this._contentSize.y = aHeight;
+            this.handleSizeChanged();
+        };
+        ScrollPane.prototype.changeContentSizeOnScrolling = function (deltaWidth, deltaHeight, deltaPosX, deltaPosY) {
+            var isRightmost = this._xPos == this._overlapSize.x;
+            var isBottom = this._yPos == this._overlapSize.y;
+            this._contentSize.x += deltaWidth;
+            this._contentSize.y += deltaHeight;
+            this.handleSizeChanged();
+            if (this._tweening == 1) {
+                if (deltaWidth != 0 && isRightmost && this._tweenChange.x < 0) {
+                    this._xPos = this._overlapSize.x;
+                    this._tweenChange.x = -this._xPos - this._tweenStart.x;
+                }
+                if (deltaHeight != 0 && isBottom && this._tweenChange.y < 0) {
+                    this._yPos = this._overlapSize.y;
+                    this._tweenChange.y = -this._yPos - this._tweenStart.y;
+                }
+            }
+            else if (this._tweening == 2) {
+                if (deltaPosX != 0) {
+                    this._container.x -= deltaPosX;
+                    this._tweenStart.x -= deltaPosX;
+                    this._xPos = -this._container.x;
+                }
+                if (deltaPosY != 0) {
+                    this._container.y -= deltaPosY;
+                    this._tweenStart.y -= deltaPosY;
+                    this._yPos = -this._container.y;
+                }
+            }
+            else if (this._dragged) {
+                if (deltaPosX != 0) {
+                    this._container.x -= deltaPosX;
+                    this._containerPos.x -= deltaPosX;
+                    this._xPos = -this._container.x;
+                }
+                if (deltaPosY != 0) {
+                    this._container.y -= deltaPosY;
+                    this._containerPos.y -= deltaPosY;
+                    this._yPos = -this._container.y;
+                }
+            }
+            else {
+                if (deltaWidth != 0 && isRightmost) {
+                    this._xPos = this._overlapSize.x;
+                    this._container.x = -this._xPos;
+                }
+                if (deltaHeight != 0 && isBottom) {
+                    this._yPos = this._overlapSize.y;
+                    this._container.y = -this._yPos;
+                }
+            }
+            if (this._pageMode)
+                this.updatePageController();
+        };
+        ScrollPane.prototype.handleSizeChanged = function () {
+            if (this._displayInDemand) {
+                this._vScrollNone = this._contentSize.y <= this._viewSize.y;
+                this._hScrollNone = this._contentSize.x <= this._viewSize.x;
+            }
+            if (this._vtScrollBar) {
+                if (this._contentSize.y == 0)
+                    this._vtScrollBar.setDisplayPerc(0);
+                else
+                    this._vtScrollBar.setDisplayPerc(Math.min(1, this._viewSize.y / this._contentSize.y));
+            }
+            if (this._hzScrollBar) {
+                if (this._contentSize.x == 0)
+                    this._hzScrollBar.setDisplayPerc(0);
+                else
+                    this._hzScrollBar.setDisplayPerc(Math.min(1, this._viewSize.x / this._contentSize.x));
+            }
+            this.updateScrollBarVisible();
+            var rect = this._maskContainer.scrollRect;
+            if (rect) {
+                rect.width = this._viewSize.x;
+                rect.height = this._viewSize.y;
+                if (this._vScrollNone && this._vtScrollBar)
+                    rect.width += this._vtScrollBar.width;
+                if (this._hScrollNone && this._hzScrollBar)
+                    rect.height += this._hzScrollBar.height;
+                if (this._dontClipMargin) {
+                    rect.width += (this._owner.margin.left + this._owner.margin.right);
+                    rect.height += (this._owner.margin.top + this._owner.margin.bottom);
+                }
+                this._maskContainer.scrollRect = rect;
+            }
+            if (this._scrollType == fgui.ScrollType.Horizontal || this._scrollType == fgui.ScrollType.Both)
+                this._overlapSize.x = Math.ceil(Math.max(0, this._contentSize.x - this._viewSize.x));
+            else
+                this._overlapSize.x = 0;
+            if (this._scrollType == fgui.ScrollType.Vertical || this._scrollType == fgui.ScrollType.Both)
+                this._overlapSize.y = Math.ceil(Math.max(0, this._contentSize.y - this._viewSize.y));
+            else
+                this._overlapSize.y = 0;
+            this._xPos = fgui.ToolSet.clamp(this._xPos, 0, this._overlapSize.x);
+            this._yPos = fgui.ToolSet.clamp(this._yPos, 0, this._overlapSize.y);
+            if (this._refreshBarAxis != null) {
+                var max = this._overlapSize[this._refreshBarAxis];
+                if (max == 0)
+                    max = Math.max(this._contentSize[this._refreshBarAxis] + this._footerLockedSize - this._viewSize[this._refreshBarAxis], 0);
+                else
+                    max += this._footerLockedSize;
+                if (this._refreshBarAxis == "x") {
+                    this._container.x = fgui.ToolSet.clamp(this._container.x, -max, this._headerLockedSize);
+                    this._container.y = fgui.ToolSet.clamp(this._container.y, -this._overlapSize.y, 0);
+                }
+                else {
+                    this._container.x = fgui.ToolSet.clamp(this._container.x, -this._overlapSize.x, 0);
+                    this._container.y = fgui.ToolSet.clamp(this._container.y, -max, this._headerLockedSize);
+                }
+                if (this._header) {
+                    if (this._refreshBarAxis == "x")
+                        this._header.height = this._viewSize.y;
+                    else
+                        this._header.width = this._viewSize.x;
+                }
+                if (this._footer) {
+                    if (this._refreshBarAxis == "y")
+                        this._footer.height = this._viewSize.y;
+                    else
+                        this._footer.width = this._viewSize.x;
+                }
+            }
+            else {
+                this._container.x = fgui.ToolSet.clamp(this._container.x, -this._overlapSize.x, 0);
+                this._container.y = fgui.ToolSet.clamp(this._container.y, -this._overlapSize.y, 0);
+            }
+            this.updateScrollBarPos();
+            if (this._pageMode)
+                this.updatePageController();
+        };
+        ScrollPane.prototype.posChanged = function (ani) {
+            if (this._aniFlag == 0)
+                this._aniFlag = ani ? 1 : -1;
+            else if (this._aniFlag == 1 && !ani)
+                this._aniFlag = -1;
+            this._needRefresh = true;
+            fgui.GTimers.inst.callLater(this.refresh, this);
+            if (this._tweening != 0)
+                this.killTween();
+        };
+        ScrollPane.prototype.refresh = function () {
+            this._needRefresh = false;
+            fgui.GTimers.inst.remove(this.refresh, this);
+            if (this._pageMode || this._snapToItem) {
+                sEndPos.setTo(-this._xPos, -this._yPos);
+                this.alignPosition(sEndPos, false);
+                this._xPos = -sEndPos.x;
+                this._yPos = -sEndPos.y;
+            }
+            this.refresh2();
+            this.dispatchEventWith(ScrollPane.SCROLL);
+            if (this._needRefresh) {
+                this._needRefresh = false;
+                fgui.GTimers.inst.remove(this.refresh, this);
+                this.refresh2();
+            }
+            this.updateScrollBarPos();
+            this._aniFlag = 0;
+        };
+        ScrollPane.prototype.refresh2 = function () {
+            if (this._aniFlag == 1 && !this._dragged) {
+                var posX;
+                var posY;
+                if (this._overlapSize.x > 0)
+                    posX = -Math.floor(this._xPos);
+                else {
+                    if (this._container.x != 0)
+                        this._container.x = 0;
+                    posX = 0;
+                }
+                if (this._overlapSize.y > 0)
+                    posY = -Math.floor(this._yPos);
+                else {
+                    if (this._container.y != 0)
+                        this._container.y = 0;
+                    posY = 0;
+                }
+                if (posX != this._container.x || posY != this._container.y) {
+                    this._tweenDuration.setTo(TWEEN_TIME_GO, TWEEN_TIME_GO);
+                    this._tweenStart.setTo(this._container.x, this._container.y);
+                    this._tweenChange.setTo(posX - this._tweenStart.x, posY - this._tweenStart.y);
+                    this.startTween(1);
+                }
+                else if (this._tweening != 0)
+                    this.killTween();
+            }
+            else {
+                if (this._tweening != 0)
+                    this.killTween();
+                this._container.x = Math.floor(-this._xPos);
+                this._container.y = Math.floor(-this._yPos);
+                this.loopCheckingCurrent();
+            }
+            if (this._pageMode)
+                this.updatePageController();
+        };
+        ScrollPane.prototype.__touchBegin = function (evt) {
+            if (!this._touchEffect)
+                return;
+            if (this._tweening != 0) {
+                this.killTween();
+                this._dragged = true;
+            }
+            else
+                this._dragged = false;
+            var pt = this._owner.globalToLocal(evt.stageX, evt.stageY, s_vec2);
+            this._containerPos.setTo(this._container.x, this._container.y);
+            this._beginTouchPos.setTo(pt.x, pt.y);
+            this._lastTouchPos.setTo(pt.x, pt.y);
+            this._lastTouchGlobalPos.setTo(evt.stageX, evt.stageY);
+            this._isHoldAreaDone = false;
+            this._velocity.setTo(0, 0);
+            this._velocityScale = 1;
+            this._lastMoveTime = egret.getTimer() / 1000;
+            this._owner.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.__touchMove, this);
+            this._owner.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_END, this.__touchEnd, this);
+            this._owner.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_TAP, this.__touchTap, this);
+        };
+        ScrollPane.prototype.__touchMove = function (evt) {
+            if (this._owner.displayObject.stage == null)
+                return;
+            if (!this._touchEffect)
+                return;
+            if (ScrollPane.draggingPane && ScrollPane.draggingPane != this || fgui.GObject.draggingObject)
+                return;
+            var pt = this._owner.globalToLocal(evt.stageX, evt.stageY, s_vec2);
+            var sensitivity = fgui.UIConfig.touchScrollSensitivity;
+            var diff, diff2;
+            var sv, sh, st;
+            if (this._scrollType == fgui.ScrollType.Vertical) {
+                if (!this._isHoldAreaDone) {
+                    _gestureFlag |= 1;
+                    diff = Math.abs(this._beginTouchPos.y - pt.y);
+                    if (diff < sensitivity)
+                        return;
+                    if ((_gestureFlag & 2) != 0) {
+                        diff2 = Math.abs(this._beginTouchPos.x - pt.x);
+                        if (diff < diff2)
+                            return;
+                    }
+                }
+                sv = true;
+            }
+            else if (this._scrollType == fgui.ScrollType.Horizontal) {
+                if (!this._isHoldAreaDone) {
+                    _gestureFlag |= 2;
+                    diff = Math.abs(this._beginTouchPos.x - pt.x);
+                    if (diff < sensitivity)
+                        return;
+                    if ((_gestureFlag & 1) != 0) {
+                        diff2 = Math.abs(this._beginTouchPos.y - pt.y);
+                        if (diff < diff2)
+                            return;
+                    }
+                }
+                sh = true;
+            }
+            else {
+                _gestureFlag = 3;
+                if (!this._isHoldAreaDone) {
+                    diff = Math.abs(this._beginTouchPos.y - pt.y);
+                    if (diff < sensitivity) {
+                        diff = Math.abs(this._beginTouchPos.x - pt.x);
+                        if (diff < sensitivity)
+                            return;
+                    }
+                }
+                sv = sh = true;
+            }
+            var newPosX = Math.floor(this._containerPos.x + pt.x - this._beginTouchPos.x);
+            var newPosY = Math.floor(this._containerPos.y + pt.y - this._beginTouchPos.y);
+            if (sv) {
+                if (newPosY > 0) {
+                    if (!this._bouncebackEffect)
+                        this._container.y = 0;
+                    else if (this._header && this._header.maxHeight != 0)
+                        this._container.y = Math.floor(Math.min(newPosY * 0.5, this._header.maxHeight));
+                    else
+                        this._container.y = Math.floor(Math.min(newPosY * 0.5, this._viewSize.y * PULL_RATIO));
+                }
+                else if (newPosY < -this._overlapSize.y) {
+                    if (!this._bouncebackEffect)
+                        this._container.y = -this._overlapSize.y;
+                    else if (this._footer && this._footer.maxHeight > 0)
+                        this._container.y = Math.floor(Math.max((newPosY + this._overlapSize.y) * 0.5, -this._footer.maxHeight) - this._overlapSize.y);
+                    else
+                        this._container.y = Math.floor(Math.max((newPosY + this._overlapSize.y) * 0.5, -this._viewSize.y * PULL_RATIO) - this._overlapSize.y);
+                }
+                else
+                    this._container.y = newPosY;
+            }
+            if (sh) {
+                if (newPosX > 0) {
+                    if (!this._bouncebackEffect)
+                        this._container.x = 0;
+                    else if (this._header && this._header.maxWidth != 0)
+                        this._container.x = Math.floor(Math.min(newPosX * 0.5, this._header.maxWidth));
+                    else
+                        this._container.x = Math.floor(Math.min(newPosX * 0.5, this._viewSize.x * PULL_RATIO));
+                }
+                else if (newPosX < 0 - this._overlapSize.x) {
+                    if (!this._bouncebackEffect)
+                        this._container.x = -this._overlapSize.x;
+                    else if (this._footer && this._footer.maxWidth > 0)
+                        this._container.x = Math.floor(Math.max((newPosX + this._overlapSize.x) * 0.5, -this._footer.maxWidth) - this._overlapSize.x);
+                    else
+                        this._container.x = Math.floor(Math.max((newPosX + this._overlapSize.x) * 0.5, -this._viewSize.x * PULL_RATIO) - this._overlapSize.x);
+                }
+                else
+                    this._container.x = newPosX;
+            }
+            var now = egret.getTimer() / 1000;
+            var deltaTime = Math.max(now - this._lastMoveTime, 1 / 60);
+            var deltaPositionX = pt.x - this._lastTouchPos.x;
+            var deltaPositionY = pt.y - this._lastTouchPos.y;
+            if (!sh)
+                deltaPositionX = 0;
+            if (!sv)
+                deltaPositionY = 0;
+            if (deltaTime != 0) {
+                var frameRate = this._owner.displayObject.stage.frameRate;
+                var elapsed = deltaTime * frameRate - 1;
+                if (elapsed > 1) {
+                    var factor = Math.pow(0.833, elapsed);
+                    this._velocity.x = this._velocity.x * factor;
+                    this._velocity.y = this._velocity.y * factor;
+                }
+                this._velocity.x = fgui.ToolSet.lerp(this._velocity.x, deltaPositionX * 60 / frameRate / deltaTime, deltaTime * 10);
+                this._velocity.y = fgui.ToolSet.lerp(this._velocity.y, deltaPositionY * 60 / frameRate / deltaTime, deltaTime * 10);
+            }
+            var deltaGlobalPositionX = this._lastTouchGlobalPos.x - evt.stageX;
+            var deltaGlobalPositionY = this._lastTouchGlobalPos.y - evt.stageY;
+            if (deltaPositionX != 0)
+                this._velocityScale = Math.abs(deltaGlobalPositionX / deltaPositionX);
+            else if (deltaPositionY != 0)
+                this._velocityScale = Math.abs(deltaGlobalPositionY / deltaPositionY);
+            this._lastTouchPos.setTo(pt.x, pt.y);
+            this._lastTouchGlobalPos.setTo(evt.stageX, evt.stageY);
+            this._lastMoveTime = now;
+            if (this._overlapSize.x > 0)
+                this._xPos = fgui.ToolSet.clamp(-this._container.x, 0, this._overlapSize.x);
+            if (this._overlapSize.y > 0)
+                this._yPos = fgui.ToolSet.clamp(-this._container.y, 0, this._overlapSize.y);
+            if (this._loop != 0) {
+                newPosX = this._container.x;
+                newPosY = this._container.y;
+                if (this.loopCheckingCurrent()) {
+                    this._containerPos.x += this._container.x - newPosX;
+                    this._containerPos.y += this._container.y - newPosY;
+                }
+            }
+            ScrollPane.draggingPane = this;
+            this._isHoldAreaDone = true;
+            this._dragged = true;
+            this._maskContainer.touchChildren = false;
+            this.updateScrollBarPos();
+            this.updateScrollBarVisible();
+            if (this._pageMode)
+                this.updatePageController();
+            this.dispatchEventWith(ScrollPane.SCROLL);
+        };
+        ScrollPane.prototype.__touchEnd = function (evt) {
+            evt.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_MOVE, this.__touchMove, this);
+            evt.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_END, this.__touchEnd, this);
+            evt.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_TAP, this.__touchTap, this);
+            if (ScrollPane.draggingPane == this)
+                ScrollPane.draggingPane = null;
+            _gestureFlag = 0;
+            if (!this._dragged || !this._touchEffect || this._owner.displayObject.stage == null) {
+                this._dragged = false;
+                this._maskContainer.touchChildren = true;
+                return;
+            }
+            this._dragged = false;
+            this._maskContainer.touchChildren = true;
+            this._tweenStart.setTo(this._container.x, this._container.y);
+            sEndPos.setTo(this._tweenStart.x, this._tweenStart.y);
+            var flag = false;
+            if (this._container.x > 0) {
+                sEndPos.x = 0;
+                flag = true;
+            }
+            else if (this._container.x < -this._overlapSize.x) {
+                sEndPos.x = -this._overlapSize.x;
+                flag = true;
+            }
+            if (this._container.y > 0) {
+                sEndPos.y = 0;
+                flag = true;
+            }
+            else if (this._container.y < -this._overlapSize.y) {
+                sEndPos.y = -this._overlapSize.y;
+                flag = true;
+            }
+            if (flag) {
+                this._tweenChange.setTo(sEndPos.x - this._tweenStart.x, sEndPos.y - this._tweenStart.y);
+                if (this._tweenChange.x < -fgui.UIConfig.touchDragSensitivity || this._tweenChange.y < -fgui.UIConfig.touchDragSensitivity) {
+                    this._refreshEventDispatching = true;
+                    this.dispatchEventWith(ScrollPane.PULL_DOWN_RELEASE);
+                    this._refreshEventDispatching = false;
+                }
+                else if (this._tweenChange.x > fgui.UIConfig.touchDragSensitivity || this._tweenChange.y > fgui.UIConfig.touchDragSensitivity) {
+                    this._refreshEventDispatching = true;
+                    this.dispatchEventWith(ScrollPane.PULL_UP_RELEASE);
+                    this._refreshEventDispatching = false;
+                }
+                if (this._headerLockedSize > 0 && sEndPos[this._refreshBarAxis] == 0) {
+                    sEndPos[this._refreshBarAxis] = this._headerLockedSize;
+                    this._tweenChange.x = sEndPos.x - this._tweenStart.x;
+                    this._tweenChange.y = sEndPos.y - this._tweenStart.y;
+                }
+                else if (this._footerLockedSize > 0 && sEndPos[this._refreshBarAxis] == -this._overlapSize[this._refreshBarAxis]) {
+                    var max = this._overlapSize[this._refreshBarAxis];
+                    if (max == 0)
+                        max = Math.max(this._contentSize[this._refreshBarAxis] + this._footerLockedSize - this._viewSize[this._refreshBarAxis], 0);
+                    else
+                        max += this._footerLockedSize;
+                    sEndPos[this._refreshBarAxis] = -max;
+                    this._tweenChange.x = sEndPos.x - this._tweenStart.x;
+                    this._tweenChange.y = sEndPos.y - this._tweenStart.y;
+                }
+                this._tweenDuration.setTo(TWEEN_TIME_DEFAULT, TWEEN_TIME_DEFAULT);
+            }
+            else {
+                if (!this._inertiaDisabled) {
+                    var frameRate = this._owner.displayObject.stage.frameRate;
+                    var elapsed = (egret.getTimer() / 1000 - this._lastMoveTime) * frameRate - 1;
+                    if (elapsed > 1) {
+                        var factor = Math.pow(0.833, elapsed);
+                        this._velocity.x = this._velocity.x * factor;
+                        this._velocity.y = this._velocity.y * factor;
+                    }
+                    this.updateTargetAndDuration(this._tweenStart, sEndPos);
+                }
+                else
+                    this._tweenDuration.setTo(TWEEN_TIME_DEFAULT, TWEEN_TIME_DEFAULT);
+                sOldChange.setTo(sEndPos.x - this._tweenStart.x, sEndPos.y - this._tweenStart.y);
+                this.loopCheckingTarget(sEndPos);
+                if (this._pageMode || this._snapToItem)
+                    this.alignPosition(sEndPos, true);
+                this._tweenChange.x = sEndPos.x - this._tweenStart.x;
+                this._tweenChange.y = sEndPos.y - this._tweenStart.y;
+                if (this._tweenChange.x == 0 && this._tweenChange.y == 0) {
+                    this.updateScrollBarVisible();
+                    return;
+                }
+                if (this._pageMode || this._snapToItem) {
+                    this.fixDuration("x", sOldChange.x);
+                    this.fixDuration("y", sOldChange.y);
+                }
+            }
+            this.startTween(2);
+        };
+        ScrollPane.prototype.__touchTap = function (evt) {
+            this._dragged = false;
+        };
+        ScrollPane.prototype.updateScrollBarPos = function () {
+            if (this._vtScrollBar)
+                this._vtScrollBar.setScrollPerc(this._overlapSize.y == 0 ? 0 : fgui.ToolSet.clamp(-this._container.y, 0, this._overlapSize.y) / this._overlapSize.y);
+            if (this._hzScrollBar)
+                this._hzScrollBar.setScrollPerc(this._overlapSize.x == 0 ? 0 : fgui.ToolSet.clamp(-this._container.x, 0, this._overlapSize.x) / this._overlapSize.x);
+            this.checkRefreshBar();
+        };
+        ScrollPane.prototype.updateScrollBarVisible = function () {
+            if (this._vtScrollBar) {
+                if (this._viewSize.y <= this._vtScrollBar.minSize || this._vScrollNone)
+                    this._vtScrollBar.displayObject.visible = false;
+                else
+                    this.updateScrollBarVisible2(this._vtScrollBar);
+            }
+            if (this._hzScrollBar) {
+                if (this._viewSize.x <= this._hzScrollBar.minSize || this._hScrollNone)
+                    this._hzScrollBar.displayObject.visible = false;
+                else
+                    this.updateScrollBarVisible2(this._hzScrollBar);
+            }
+        };
+        ScrollPane.prototype.updateScrollBarVisible2 = function (bar) {
+            if (this._scrollBarDisplayAuto)
+                fgui.GTween.kill(bar, false, "alpha");
+            if (this._scrollBarDisplayAuto && this._tweening == 0 && !this._dragged && !bar.gripDragging) {
+                if (bar.displayObject.visible)
+                    fgui.GTween.to(1, 0, 0.5).setDelay(0.5).onComplete(this.__barTweenComplete, this).setTarget(bar, "alpha");
+            }
+            else {
+                bar.alpha = 1;
+                bar.displayObject.visible = true;
+            }
+        };
+        ScrollPane.prototype.__barTweenComplete = function (tweener) {
+            var bar = (tweener.target);
+            bar.alpha = 1;
+            bar.displayObject.visible = false;
+        };
+        ScrollPane.prototype.getLoopPartSize = function (division, axis) {
+            return (this._contentSize[axis] + (axis == "x" ? this._owner.columnGap : this._owner.lineGap)) / division;
+        };
+        ScrollPane.prototype.loopCheckingCurrent = function () {
+            var changed = false;
+            if (this._loop == 1 && this._overlapSize.x > 0) {
+                if (this._xPos < 0.001) {
+                    this._xPos += this.getLoopPartSize(2, "x");
+                    changed = true;
+                }
+                else if (this._xPos >= this._overlapSize.x) {
+                    this._xPos -= this.getLoopPartSize(2, "x");
+                    changed = true;
+                }
+            }
+            else if (this._loop == 2 && this._overlapSize.y > 0) {
+                if (this._yPos < 0.001) {
+                    this._yPos += this.getLoopPartSize(2, "y");
+                    changed = true;
+                }
+                else if (this._yPos >= this._overlapSize.y) {
+                    this._yPos -= this.getLoopPartSize(2, "y");
+                    changed = true;
+                }
+            }
+            if (changed) {
+                this._container.x = Math.floor(-this._xPos);
+                this._container.y = Math.floor(-this._yPos);
+            }
+            return changed;
+        };
+        ScrollPane.prototype.loopCheckingTarget = function (endPos) {
+            if (this._loop == 1)
+                this.loopCheckingTarget2(endPos, "x");
+            if (this._loop == 2)
+                this.loopCheckingTarget2(endPos, "y");
+        };
+        ScrollPane.prototype.loopCheckingTarget2 = function (endPos, axis) {
+            var halfSize;
+            var tmp;
+            if (endPos[axis] > 0) {
+                halfSize = this.getLoopPartSize(2, axis);
+                tmp = this._tweenStart[axis] - halfSize;
+                if (tmp <= 0 && tmp >= -this._overlapSize[axis]) {
+                    endPos[axis] -= halfSize;
+                    this._tweenStart[axis] = tmp;
+                }
+            }
+            else if (endPos[axis] < -this._overlapSize[axis]) {
+                halfSize = this.getLoopPartSize(2, axis);
+                tmp = this._tweenStart[axis] + halfSize;
+                if (tmp <= 0 && tmp >= -this._overlapSize[axis]) {
+                    endPos[axis] += halfSize;
+                    this._tweenStart[axis] = tmp;
+                }
+            }
+        };
+        ScrollPane.prototype.loopCheckingNewPos = function (value, axis) {
+            if (this._overlapSize[axis] == 0)
+                return value;
+            var pos = axis == "x" ? this._xPos : this._yPos;
+            var changed = false;
+            var v;
+            if (value < 0.001) {
+                value += this.getLoopPartSize(2, axis);
+                if (value > pos) {
+                    v = this.getLoopPartSize(6, axis);
+                    v = Math.ceil((value - pos) / v) * v;
+                    pos = fgui.ToolSet.clamp(pos + v, 0, this._overlapSize[axis]);
+                    changed = true;
+                }
+            }
+            else if (value >= this._overlapSize[axis]) {
+                value -= this.getLoopPartSize(2, axis);
+                if (value < pos) {
+                    v = this.getLoopPartSize(6, axis);
+                    v = Math.ceil((pos - value) / v) * v;
+                    pos = fgui.ToolSet.clamp(pos - v, 0, this._overlapSize[axis]);
+                    changed = true;
+                }
+            }
+            if (changed) {
+                if (axis == "x")
+                    this._container.x = -Math.floor(pos);
+                else
+                    this._container.y = -Math.floor(pos);
+            }
+            return value;
+        };
+        ScrollPane.prototype.alignPosition = function (pos, inertialScrolling) {
+            if (this._pageMode) {
+                pos.x = this.alignByPage(pos.x, "x", inertialScrolling);
+                pos.y = this.alignByPage(pos.y, "y", inertialScrolling);
+            }
+            else if (this._snapToItem) {
+                var pt = this._owner.getSnappingPosition(-pos.x, -pos.y, s_vec2);
+                if (pos.x < 0 && pos.x > -this._overlapSize.x)
+                    pos.x = -pt.x;
+                if (pos.y < 0 && pos.y > -this._overlapSize.y)
+                    pos.y = -pt.y;
+            }
+        };
+        ScrollPane.prototype.alignByPage = function (pos, axis, inertialScrolling) {
+            var page;
+            if (pos > 0)
+                page = 0;
+            else if (pos < -this._overlapSize[axis])
+                page = Math.ceil(this._contentSize[axis] / this._pageSize[axis]) - 1;
+            else {
+                page = Math.floor(-pos / this._pageSize[axis]);
+                var change = inertialScrolling ? (pos - this._containerPos[axis]) : (pos - this._container[axis]);
+                var testPageSize = Math.min(this._pageSize[axis], this._contentSize[axis] - (page + 1) * this._pageSize[axis]);
+                var delta = -pos - page * this._pageSize[axis];
+                if (Math.abs(change) > this._pageSize[axis]) {
+                    if (delta > testPageSize * 0.5)
+                        page++;
+                }
+                else {
+                    if (delta > testPageSize * (change < 0 ? 0.3 : 0.7))
+                        page++;
+                }
+                pos = -page * this._pageSize[axis];
+                if (pos < -this._overlapSize[axis])
+                    pos = -this._overlapSize[axis];
+            }
+            if (inertialScrolling) {
+                var oldPos = this._tweenStart[axis];
+                var oldPage;
+                if (oldPos > 0)
+                    oldPage = 0;
+                else if (oldPos < -this._overlapSize[axis])
+                    oldPage = Math.ceil(this._contentSize[axis] / this._pageSize[axis]) - 1;
+                else
+                    oldPage = Math.floor(-oldPos / this._pageSize[axis]);
+                var startPage = Math.floor(-this._containerPos[axis] / this._pageSize[axis]);
+                if (Math.abs(page - startPage) > 1 && Math.abs(oldPage - startPage) <= 1) {
+                    if (page > startPage)
+                        page = startPage + 1;
+                    else
+                        page = startPage - 1;
+                    pos = -page * this._pageSize[axis];
+                }
+            }
+            return pos;
+        };
+        ScrollPane.prototype.updateTargetAndDuration = function (orignPos, resultPos) {
+            resultPos.x = this.updateTargetAndDuration2(orignPos.x, "x");
+            resultPos.y = this.updateTargetAndDuration2(orignPos.y, "y");
+        };
+        ScrollPane.prototype.updateTargetAndDuration2 = function (pos, axis) {
+            var v = this._velocity[axis];
+            var duration = 0;
+            if (pos > 0)
+                pos = 0;
+            else if (pos < -this._overlapSize[axis])
+                pos = -this._overlapSize[axis];
+            else {
+                var isMobile = egret.Capabilities.isMobile;
+                var v2 = Math.abs(v) * this._velocityScale;
+                if (isMobile)
+                    v2 *= 1136 / Math.max(this._owner.displayObject.stage.stageWidth, this._owner.displayObject.stage.stageHeight);
+                var ratio = 0;
+                if (this._pageMode || !isMobile) {
+                    if (v2 > 500)
+                        ratio = Math.pow((v2 - 500) / 500, 2);
+                }
+                else {
+                    if (v2 > 1000)
+                        ratio = Math.pow((v2 - 1000) / 1000, 2);
+                }
+                if (ratio != 0) {
+                    if (ratio > 1)
+                        ratio = 1;
+                    v2 *= ratio;
+                    v *= ratio;
+                    this._velocity[axis] = v;
+                    duration = Math.log(60 / v2) / Math.log(this._decelerationRate) / 60;
+                    var change = Math.floor(v * duration * 0.4);
+                    pos += change;
+                }
+            }
+            if (duration < TWEEN_TIME_DEFAULT)
+                duration = TWEEN_TIME_DEFAULT;
+            this._tweenDuration[axis] = duration;
+            return pos;
+        };
+        ScrollPane.prototype.fixDuration = function (axis, oldChange) {
+            if (this._tweenChange[axis] == 0 || Math.abs(this._tweenChange[axis]) >= Math.abs(oldChange))
+                return;
+            var newDuration = Math.abs(this._tweenChange[axis] / oldChange) * this._tweenDuration[axis];
+            if (newDuration < TWEEN_TIME_DEFAULT)
+                newDuration = TWEEN_TIME_DEFAULT;
+            this._tweenDuration[axis] = newDuration;
+        };
+        ScrollPane.prototype.startTween = function (type) {
+            this._tweenTime.setTo(0, 0);
+            this._tweening = type;
+            fgui.GTimers.inst.add(1, 0, this.tweenUpdate, this);
+            this.updateScrollBarVisible();
+        };
+        ScrollPane.prototype.killTween = function () {
+            if (this._tweening == 1) {
+                this._container.x = this._tweenStart.x + this._tweenChange.x;
+                this._container.y = this._tweenStart.y + this._tweenChange.y;
+                this.dispatchEventWith(ScrollPane.SCROLL);
+            }
+            this._tweening = 0;
+            fgui.GTimers.inst.remove(this.tweenUpdate, this);
+            this.updateScrollBarVisible();
+            this.dispatchEventWith(ScrollPane.SCROLL_END);
+        };
+        ScrollPane.prototype.checkRefreshBar = function () {
+            if (this._header == null && this._footer == null)
+                return;
+            var pos = this._container[this._refreshBarAxis];
+            if (this._header) {
+                if (pos > 0) {
+                    if (this._header.displayObject.parent == null)
+                        this._maskContainer.addChildAt(this._header.displayObject, 0);
+                    var pt = s_vec2;
+                    pt.setTo(this._header.width, this._header.height);
+                    pt[this._refreshBarAxis] = pos;
+                    this._header.setSize(pt.x, pt.y);
+                }
+                else {
+                    if (this._header.displayObject.parent)
+                        this._maskContainer.removeChild(this._header.displayObject);
+                }
+            }
+            if (this._footer) {
+                var max = this._overlapSize[this._refreshBarAxis];
+                if (pos < -max || max == 0 && this._footerLockedSize > 0) {
+                    if (this._footer.displayObject.parent == null)
+                        this._maskContainer.addChildAt(this._footer.displayObject, 0);
+                    pt = s_vec2;
+                    pt.setTo(this._footer.x, this._footer.y);
+                    if (max > 0)
+                        pt[this._refreshBarAxis] = pos + this._contentSize[this._refreshBarAxis];
+                    else
+                        pt[this._refreshBarAxis] = Math.max(Math.min(pos + this._viewSize[this._refreshBarAxis], this._viewSize[this._refreshBarAxis] - this._footerLockedSize), this._viewSize[this._refreshBarAxis] - this._contentSize[this._refreshBarAxis]);
+                    this._footer.setXY(pt.x, pt.y);
+                    pt.setTo(this._footer.width, this._footer.height);
+                    if (max > 0)
+                        pt[this._refreshBarAxis] = -max - pos;
+                    else
+                        pt[this._refreshBarAxis] = this._viewSize[this._refreshBarAxis] - this._footer[this._refreshBarAxis];
+                    this._footer.setSize(pt.x, pt.y);
+                }
+                else {
+                    if (this._footer.displayObject.parent)
+                        this._maskContainer.removeChild(this._footer.displayObject);
+                }
+            }
+        };
+        ScrollPane.prototype.tweenUpdate = function (timestamp) {
+            var nx = this.runTween("x");
+            var ny = this.runTween("y");
+            this._container.x = nx;
+            this._container.y = ny;
+            if (this._tweening == 2) {
+                if (this._overlapSize.x > 0)
+                    this._xPos = fgui.ToolSet.clamp(-nx, 0, this._overlapSize.x);
+                if (this._overlapSize.y > 0)
+                    this._yPos = fgui.ToolSet.clamp(-ny, 0, this._overlapSize.y);
+                if (this._pageMode)
+                    this.updatePageController();
+            }
+            if (this._tweenChange.x == 0 && this._tweenChange.y == 0) {
+                this._tweening = 0;
+                fgui.GTimers.inst.remove(this.tweenUpdate, this);
+                this.loopCheckingCurrent();
+                this.updateScrollBarPos();
+                this.updateScrollBarVisible();
+                this.dispatchEventWith(ScrollPane.SCROLL);
+                this.dispatchEventWith(ScrollPane.SCROLL_END);
+            }
+            else {
+                this.updateScrollBarPos();
+                this.dispatchEventWith(ScrollPane.SCROLL);
+            }
+            return true;
+        };
+        ScrollPane.prototype.runTween = function (axis) {
+            var newValue;
+            if (this._tweenChange[axis] != 0) {
+                this._tweenTime[axis] += fgui.GTimers.deltaTime / 1000;
+                if (this._tweenTime[axis] >= this._tweenDuration[axis]) {
+                    newValue = this._tweenStart[axis] + this._tweenChange[axis];
+                    this._tweenChange[axis] = 0;
+                }
+                else {
+                    var ratio = easeFunc(this._tweenTime[axis], this._tweenDuration[axis]);
+                    newValue = this._tweenStart[axis] + Math.floor(this._tweenChange[axis] * ratio);
+                }
+                var threshold1 = 0;
+                var threshold2 = -this._overlapSize[axis];
+                if (this._headerLockedSize > 0 && this._refreshBarAxis == axis)
+                    threshold1 = this._headerLockedSize;
+                if (this._footerLockedSize > 0 && this._refreshBarAxis == axis) {
+                    var max = this._overlapSize[this._refreshBarAxis];
+                    if (max == 0)
+                        max = Math.max(this._contentSize[this._refreshBarAxis] + this._footerLockedSize - this._viewSize[this._refreshBarAxis], 0);
+                    else
+                        max += this._footerLockedSize;
+                    threshold2 = -max;
+                }
+                if (this._tweening == 2 && this._bouncebackEffect) {
+                    if (newValue > 20 + threshold1 && this._tweenChange[axis] > 0
+                        || newValue > threshold1 && this._tweenChange[axis] == 0) {
+                        this._tweenTime[axis] = 0;
+                        this._tweenDuration[axis] = TWEEN_TIME_DEFAULT;
+                        this._tweenChange[axis] = -newValue + threshold1;
+                        this._tweenStart[axis] = newValue;
+                    }
+                    else if (newValue < threshold2 - 20 && this._tweenChange[axis] < 0
+                        || newValue < threshold2 && this._tweenChange[axis] == 0) {
+                        this._tweenTime[axis] = 0;
+                        this._tweenDuration[axis] = TWEEN_TIME_DEFAULT;
+                        this._tweenChange[axis] = threshold2 - newValue;
+                        this._tweenStart[axis] = newValue;
+                    }
+                }
+                else {
+                    if (newValue > threshold1) {
+                        newValue = threshold1;
+                        this._tweenChange[axis] = 0;
+                    }
+                    else if (newValue < threshold2) {
+                        newValue = threshold2;
+                        this._tweenChange[axis] = 0;
+                    }
+                }
+            }
+            else
+                newValue = this._container[axis];
+            return newValue;
+        };
+        ScrollPane.SCROLL = "__scroll";
+        ScrollPane.SCROLL_END = "__scrollEnd";
+        ScrollPane.PULL_DOWN_RELEASE = "pullDownRelease";
+        ScrollPane.PULL_UP_RELEASE = "pullUpRelease";
+        return ScrollPane;
+    }(egret.EventDispatcher));
+    fgui.ScrollPane = ScrollPane;
+    var _gestureFlag = 0;
+    var TWEEN_TIME_GO = 0.5;
+    var TWEEN_TIME_DEFAULT = 0.3;
+    var PULL_RATIO = 0.5;
+    var s_vec2 = new egret.Point();
+    var s_rect = new egret.Rectangle();
+    var sEndPos = new egret.Point();
+    var sOldChange = new egret.Point();
+    function easeFunc(t, d) {
+        return (t = t / d - 1) * t * t + 1;
+    }
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var Transition = (function () {
+        function Transition(owner) {
+            this._ownerBaseX = 0;
+            this._ownerBaseY = 0;
+            this._totalTimes = 0;
+            this._totalTasks = 0;
+            this._options = 0;
+            this._totalDuration = 0;
+            this._autoPlayTimes = 1;
+            this._autoPlayDelay = 0;
+            this._timeScale = 1;
+            this._startTime = 0;
+            this._endTime = 0;
+            this._owner = owner;
+            this._items = new Array();
+        }
+        Transition.prototype.play = function (onComplete, onCompleteObj, onCompleteParam, times, delay, startTime, endTime) {
+            this._play(onComplete, onCompleteObj, onCompleteParam, times, delay, startTime, endTime, false);
+        };
+        Transition.prototype.playReverse = function (onComplete, onCompleteObj, onCompleteParam, times, delay) {
+            this._play(onComplete, onCompleteObj, onCompleteParam, times, delay, 0, -1, true);
+        };
+        Transition.prototype.changePlayTimes = function (value) {
+            this._totalTimes = value;
+        };
+        Transition.prototype.setAutoPlay = function (value, times, delay) {
+            if (times == undefined)
+                times = -1;
+            if (delay == undefined)
+                delay = 0;
+            if (this._autoPlay != value) {
+                this._autoPlay = value;
+                this._autoPlayTimes = times;
+                this._autoPlayDelay = delay;
+                if (this._autoPlay) {
+                    if (this._owner.onStage)
+                        this.play(null, null, this._autoPlayTimes, this._autoPlayDelay);
+                }
+                else {
+                    if (!this._owner.onStage)
+                        this.stop(false, true);
+                }
+            }
+        };
+        Transition.prototype._play = function (onComplete, onCompleteCaller, onCompleteParam, times, delay, startTime, endTime, reversed) {
+            if (times == undefined)
+                times = 1;
+            if (delay == undefined)
+                delay = 0;
+            if (startTime == undefined)
+                startTime = 0;
+            if (endTime == undefined)
+                endTime = -1;
+            this.stop(true, true);
+            this._totalTimes = times;
+            this._reversed = reversed;
+            this._startTime = startTime;
+            this._endTime = endTime;
+            this._playing = true;
+            this._paused = false;
+            this._onComplete = onComplete;
+            this._onCompleteParam = onCompleteParam;
+            this._onCompleteCaller = onCompleteCaller;
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (!item.target) {
+                    if (item.targetId)
+                        item.target = this._owner.getChildById(item.targetId);
+                    else
+                        item.target = this._owner;
+                }
+                else if (item.target != this._owner && item.target.parent != this._owner)
+                    item.target = null;
+                if (item.target && item.type == ActionType.Transition) {
+                    var trans = item.target.getTransition(item.value.transName);
+                    if (trans == this)
+                        trans = null;
+                    if (trans) {
+                        if (item.value.playTimes == 0) {
+                            var j;
+                            for (j = i - 1; j >= 0; j--) {
+                                var item2 = this._items[j];
+                                if (item2.type == ActionType.Transition) {
+                                    if (item2.value.trans == trans) {
+                                        item2.value.stopTime = item.time - item2.time;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (j < 0)
+                                item.value.stopTime = 0;
+                            else
+                                trans = null;
+                        }
+                        else
+                            item.value.stopTime = -1;
+                    }
+                    item.value.trans = trans;
+                }
+            }
+            if (delay == 0)
+                this.onDelayedPlay();
+            else
+                fgui.GTween.delayedCall(delay).onComplete(this.onDelayedPlay, this);
+        };
+        Transition.prototype.stop = function (setToComplete, processCallback) {
+            if (setToComplete == undefined)
+                setToComplete = true;
+            if (!this._playing)
+                return;
+            this._playing = false;
+            this._totalTasks = 0;
+            this._totalTimes = 0;
+            var func = this._onComplete;
+            var param = this._onCompleteParam;
+            var thisObj = this._onCompleteCaller;
+            this._onComplete = null;
+            this._onCompleteParam = null;
+            this._onCompleteCaller = null;
+            fgui.GTween.kill(this);
+            var cnt = this._items.length;
+            if (this._reversed) {
+                for (var i = cnt - 1; i >= 0; i--) {
+                    var item = this._items[i];
+                    if (!item.target)
+                        continue;
+                    this.stopItem(item, setToComplete);
+                }
+            }
+            else {
+                for (i = 0; i < cnt; i++) {
+                    item = this._items[i];
+                    if (!item.target)
+                        continue;
+                    this.stopItem(item, setToComplete);
+                }
+            }
+            if (processCallback && func != null) {
+                func.call(thisObj, param);
+            }
+        };
+        Transition.prototype.stopItem = function (item, setToComplete) {
+            if (item.displayLockToken != 0) {
+                item.target.releaseDisplayLock(item.displayLockToken);
+                item.displayLockToken = 0;
+            }
+            if (item.tweener) {
+                item.tweener.kill(setToComplete);
+                item.tweener = null;
+                if (item.type == ActionType.Shake && !setToComplete) {
+                    item.target._gearLocked = true;
+                    item.target.setXY(item.target.x - item.value.lastOffsetX, item.target.y - item.value.lastOffsetY);
+                    item.target._gearLocked = false;
+                }
+            }
+            if (item.type == ActionType.Transition) {
+                var trans = item.value.trans;
+                if (trans)
+                    trans.stop(setToComplete, false);
+            }
+        };
+        Transition.prototype.setPaused = function (paused) {
+            if (!this._playing || this._paused == paused)
+                return;
+            this._paused = paused;
+            var tweener = fgui.GTween.getTween(this);
+            if (tweener)
+                tweener.setPaused(paused);
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (!item.target)
+                    continue;
+                if (item.type == ActionType.Transition) {
+                    if (item.value.trans)
+                        item.value.trans.setPaused(paused);
+                }
+                else if (item.type == ActionType.Animation) {
+                    if (paused) {
+                        item.value.flag = item.target.getProp(fgui.ObjectPropID.Playing);
+                        item.target.setProp(fgui.ObjectPropID.Playing, false);
+                    }
+                    else
+                        item.target.setProp(fgui.ObjectPropID.Playing, item.value.flag);
+                }
+                if (item.tweener)
+                    item.tweener.setPaused(paused);
+            }
+        };
+        Transition.prototype.dispose = function () {
+            if (this._playing)
+                fgui.GTween.kill(this);
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (item.tweener) {
+                    item.tweener.kill();
+                    item.tweener = null;
+                }
+                item.target = null;
+                item.hook = null;
+                if (item.tweenConfig)
+                    item.tweenConfig.endHook = null;
+            }
+            this._items.length = 0;
+            this._playing = false;
+            this._onComplete = null;
+            this._onCompleteCaller = null;
+            this._onCompleteParam = null;
+        };
+        Object.defineProperty(Transition.prototype, "playing", {
+            get: function () {
+                return this._playing;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Transition.prototype.setValue = function (label) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            var cnt = this._items.length;
+            var value;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (item.label == label) {
+                    if (item.tweenConfig)
+                        value = item.tweenConfig.startValue;
+                    else
+                        value = item.value;
+                }
+                else if (item.tweenConfig && item.tweenConfig.endLabel == label) {
+                    value = item.tweenConfig.endValue;
+                }
+                else
+                    continue;
+                switch (item.type) {
+                    case ActionType.XY:
+                    case ActionType.Size:
+                    case ActionType.Pivot:
+                    case ActionType.Scale:
+                    case ActionType.Skew:
+                        value.b1 = true;
+                        value.b2 = true;
+                        value.f1 = parseFloat(args[0]);
+                        value.f2 = parseFloat(args[1]);
+                        break;
+                    case ActionType.Alpha:
+                        value.f1 = parseFloat(args[0]);
+                        break;
+                    case ActionType.Rotation:
+                        value.f1 = parseFloat(args[0]);
+                        break;
+                    case ActionType.Color:
+                        value.f1 = parseFloat(args[0]);
+                        break;
+                    case ActionType.Animation:
+                        value.frame = parseInt(args[0]);
+                        if (args.length > 1)
+                            value.playing = args[1];
+                        break;
+                    case ActionType.Visible:
+                        value.visible = args[0];
+                        break;
+                    case ActionType.Sound:
+                        value.sound = args[0];
+                        if (args.length > 1)
+                            value.volume = parseFloat(args[1]);
+                        break;
+                    case ActionType.Transition:
+                        value.transName = args[0];
+                        if (args.length > 1)
+                            value.playTimes = parseInt(args[1]);
+                        break;
+                    case ActionType.Shake:
+                        value.amplitude = parseFloat(args[0]);
+                        if (args.length > 1)
+                            value.duration = parseFloat(args[1]);
+                        break;
+                    case ActionType.ColorFilter:
+                        value.f1 = parseFloat(args[0]);
+                        value.f2 = parseFloat(args[1]);
+                        value.f3 = parseFloat(args[2]);
+                        value.f4 = parseFloat(args[3]);
+                        break;
+                    case ActionType.Text:
+                    case ActionType.Icon:
+                        value.text = args[0];
+                        break;
+                }
+            }
+        };
+        Transition.prototype.setHook = function (label, callback, caller) {
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (item.label == label) {
+                    item.hook = callback;
+                    item.hookCaller = caller;
+                    break;
+                }
+                else if (item.tweenConfig && item.tweenConfig.endLabel == label) {
+                    item.tweenConfig.endHook = callback;
+                    item.tweenConfig.endHookCaller = caller;
+                    break;
+                }
+            }
+        };
+        Transition.prototype.clearHooks = function () {
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                item.hook = null;
+                item.hookCaller = null;
+                if (item.tweenConfig) {
+                    item.tweenConfig.endHook = null;
+                    item.tweenConfig.endHookCaller = null;
+                }
+            }
+        };
+        Transition.prototype.setTarget = function (label, newTarget) {
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (item.label == label) {
+                    item.targetId = (newTarget == this._owner || !newTarget) ? "" : newTarget.id;
+                    if (this._playing) {
+                        if (item.targetId.length > 0)
+                            item.target = this._owner.getChildById(item.targetId);
+                        else
+                            item.target = this._owner;
+                    }
+                    else
+                        item.target = null;
+                }
+            }
+        };
+        Transition.prototype.setDuration = function (label, value) {
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (item.tweenConfig && item.label == label)
+                    item.tweenConfig.duration = value;
+            }
+        };
+        Transition.prototype.getLabelTime = function (label) {
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (item.label == label)
+                    return item.time;
+                else if (item.tweenConfig && item.tweenConfig.endLabel == label)
+                    return item.time + item.tweenConfig.duration;
+            }
+            return Number.NaN;
+        };
+        Object.defineProperty(Transition.prototype, "timeScale", {
+            get: function () {
+                return this._timeScale;
+            },
+            set: function (value) {
+                if (this._timeScale != value) {
+                    this._timeScale = value;
+                    if (this._playing) {
+                        var cnt = this._items.length;
+                        for (var i = 0; i < cnt; i++) {
+                            var item = this._items[i];
+                            if (item.tweener)
+                                item.tweener.setTimeScale(value);
+                            else if (item.type == ActionType.Transition) {
+                                if (item.value.trans)
+                                    item.value.trans.timeScale = value;
+                            }
+                            else if (item.type == ActionType.Animation) {
+                                if (item.target)
+                                    item.target.setProp(fgui.ObjectPropID.TimeScale, value);
+                            }
+                        }
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Transition.prototype.updateFromRelations = function (targetId, dx, dy) {
+            var cnt = this._items.length;
+            if (cnt == 0)
+                return;
+            for (var i = 0; i < cnt; i++) {
+                var item = this._items[i];
+                if (item.type == ActionType.XY && item.targetId == targetId) {
+                    if (item.tweenConfig) {
+                        item.tweenConfig.startValue.f1 += dx;
+                        item.tweenConfig.startValue.f2 += dy;
+                        item.tweenConfig.endValue.f1 += dx;
+                        item.tweenConfig.endValue.f2 += dy;
+                    }
+                    else {
+                        item.value.f1 += dx;
+                        item.value.f2 += dy;
+                    }
+                }
+            }
+        };
+        Transition.prototype.onOwnerAddedToStage = function () {
+            if (this._autoPlay && !this._playing)
+                this.play(null, null, null, this._autoPlayTimes, this._autoPlayDelay);
+        };
+        Transition.prototype.onOwnerRemovedFromStage = function () {
+            if ((this._options & OPTION_AUTO_STOP_DISABLED) == 0)
+                this.stop((this._options & OPTION_AUTO_STOP_AT_END) != 0 ? true : false, false);
+        };
+        Transition.prototype.onDelayedPlay = function () {
+            this.internalPlay();
+            this._playing = this._totalTasks > 0;
+            if (this._playing) {
+                if ((this._options & OPTION_IGNORE_DISPLAY_CONTROLLER) != 0) {
+                    var cnt = this._items.length;
+                    for (var i = 0; i < cnt; i++) {
+                        var item = this._items[i];
+                        if (item.target && item.target != this._owner)
+                            item.displayLockToken = item.target.addDisplayLock();
+                    }
+                }
+            }
+            else if (this._onComplete != null) {
+                var func = this._onComplete;
+                var param = this._onCompleteParam;
+                var thisObj = this._onCompleteCaller;
+                this._onComplete = null;
+                this._onCompleteParam = null;
+                this._onCompleteCaller = null;
+                func.call(thisObj, param);
+            }
+        };
+        Transition.prototype.internalPlay = function () {
+            this._ownerBaseX = this._owner.x;
+            this._ownerBaseY = this._owner.y;
+            this._totalTasks = 0;
+            var cnt = this._items.length;
+            var item;
+            var needSkipAnimations = false;
+            var i;
+            if (!this._reversed) {
+                for (i = 0; i < cnt; i++) {
+                    item = this._items[i];
+                    if (!item.target)
+                        continue;
+                    if (item.type == ActionType.Animation && this._startTime != 0 && item.time <= this._startTime) {
+                        needSkipAnimations = true;
+                        item.value.flag = false;
+                    }
+                    else
+                        this.playItem(item);
+                }
+            }
+            else {
+                for (i = cnt - 1; i >= 0; i--) {
+                    item = this._items[i];
+                    if (!item.target)
+                        continue;
+                    this.playItem(item);
+                }
+            }
+            if (needSkipAnimations)
+                this.skipAnimations();
+        };
+        Transition.prototype.playItem = function (item) {
+            var time;
+            if (item.tweenConfig) {
+                if (this._reversed)
+                    time = (this._totalDuration - item.time - item.tweenConfig.duration);
+                else
+                    time = item.time;
+                if (this._endTime == -1 || time <= this._endTime) {
+                    var startValue;
+                    var endValue;
+                    if (this._reversed) {
+                        startValue = item.tweenConfig.endValue;
+                        endValue = item.tweenConfig.startValue;
+                    }
+                    else {
+                        startValue = item.tweenConfig.startValue;
+                        endValue = item.tweenConfig.endValue;
+                    }
+                    item.value.b1 = startValue.b1 || endValue.b1;
+                    item.value.b2 = startValue.b2 || endValue.b2;
+                    switch (item.type) {
+                        case ActionType.XY:
+                        case ActionType.Size:
+                        case ActionType.Scale:
+                        case ActionType.Skew:
+                            item.tweener = fgui.GTween.to2(startValue.f1, startValue.f2, endValue.f1, endValue.f2, item.tweenConfig.duration);
+                            break;
+                        case ActionType.Alpha:
+                        case ActionType.Rotation:
+                            item.tweener = fgui.GTween.to(startValue.f1, endValue.f1, item.tweenConfig.duration);
+                            break;
+                        case ActionType.Color:
+                            item.tweener = fgui.GTween.toColor(startValue.f1, endValue.f1, item.tweenConfig.duration);
+                            break;
+                        case ActionType.ColorFilter:
+                            item.tweener = fgui.GTween.to4(startValue.f1, startValue.f2, startValue.f3, startValue.f4, endValue.f1, endValue.f2, endValue.f3, endValue.f4, item.tweenConfig.duration);
+                            break;
+                    }
+                    item.tweener.setDelay(time)
+                        .setEase(item.tweenConfig.easeType)
+                        .setRepeat(item.tweenConfig.repeat, item.tweenConfig.yoyo)
+                        .setTimeScale(this._timeScale)
+                        .setTarget(item)
+                        .onStart(this.onTweenStart, this)
+                        .onUpdate(this.onTweenUpdate, this)
+                        .onComplete(this.onTweenComplete, this);
+                    if (this._endTime >= 0)
+                        item.tweener.setBreakpoint(this._endTime - time);
+                    this._totalTasks++;
+                }
+            }
+            else if (item.type == ActionType.Shake) {
+                if (this._reversed)
+                    time = (this._totalDuration - item.time - item.value.duration);
+                else
+                    time = item.time;
+                item.value.offsetX = item.value.offsetY = 0;
+                item.value.lastOffsetX = item.value.lastOffsetY = 0;
+                item.tweener = fgui.GTween.shake(0, 0, item.value.amplitude, item.value.duration)
+                    .setDelay(time)
+                    .setTimeScale(this._timeScale)
+                    .setTarget(item)
+                    .onUpdate(this.onTweenUpdate, this)
+                    .onComplete(this.onTweenComplete, this);
+                if (this._endTime >= 0)
+                    item.tweener.setBreakpoint(this._endTime - item.time);
+                this._totalTasks++;
+            }
+            else {
+                if (this._reversed)
+                    time = (this._totalDuration - item.time);
+                else
+                    time = item.time;
+                if (time <= this._startTime) {
+                    this.applyValue(item);
+                    this.callHook(item, false);
+                }
+                else if (this._endTime == -1 || time <= this._endTime) {
+                    this._totalTasks++;
+                    item.tweener = fgui.GTween.delayedCall(time)
+                        .setTimeScale(this._timeScale)
+                        .setTarget(item)
+                        .onComplete(this.onDelayedPlayItem, this);
+                }
+            }
+            if (item.tweener != null)
+                item.tweener.seek(this._startTime);
+        };
+        Transition.prototype.skipAnimations = function () {
+            var frame;
+            var playStartTime;
+            var playTotalTime;
+            var value;
+            var target;
+            var item;
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                item = this._items[i];
+                if (item.type != ActionType.Animation || item.time > this._startTime)
+                    continue;
+                value = item.value;
+                if (value.flag)
+                    continue;
+                target = item.target;
+                frame = target.getProp(fgui.ObjectPropID.Frame);
+                playStartTime = target.getProp(fgui.ObjectPropID.Playing) ? 0 : -1;
+                playTotalTime = 0;
+                for (var j = i; j < cnt; j++) {
+                    item = this._items[j];
+                    if (item.type != ActionType.Animation || item.target != target || item.time > this._startTime)
+                        continue;
+                    value = item.value;
+                    value.flag = true;
+                    if (value.frame != -1) {
+                        frame = value.frame;
+                        if (value.playing)
+                            playStartTime = item.time;
+                        else
+                            playStartTime = -1;
+                        playTotalTime = 0;
+                    }
+                    else {
+                        if (value.playing) {
+                            if (playStartTime < 0)
+                                playStartTime = item.time;
+                        }
+                        else {
+                            if (playStartTime >= 0)
+                                playTotalTime += (item.time - playStartTime);
+                            playStartTime = -1;
+                        }
+                    }
+                    this.callHook(item, false);
+                }
+                if (playStartTime >= 0)
+                    playTotalTime += (this._startTime - playStartTime);
+                target.setProp(fgui.ObjectPropID.Playing, playStartTime >= 0);
+                target.setProp(fgui.ObjectPropID.Frame, frame);
+                if (playTotalTime > 0)
+                    target.setProp(fgui.ObjectPropID.DeltaTime, playTotalTime * 1000);
+            }
+        };
+        Transition.prototype.onDelayedPlayItem = function (tweener) {
+            var item = tweener.target;
+            item.tweener = null;
+            this._totalTasks--;
+            this.applyValue(item);
+            this.callHook(item, false);
+            this.checkAllComplete();
+        };
+        Transition.prototype.onTweenStart = function (tweener) {
+            var item = tweener.target;
+            if (item.type == ActionType.XY || item.type == ActionType.Size) {
+                var startValue;
+                var endValue;
+                if (this._reversed) {
+                    startValue = item.tweenConfig.endValue;
+                    endValue = item.tweenConfig.startValue;
+                }
+                else {
+                    startValue = item.tweenConfig.startValue;
+                    endValue = item.tweenConfig.endValue;
+                }
+                if (item.type == ActionType.XY) {
+                    if (item.target != this._owner) {
+                        if (!startValue.b1)
+                            tweener.startValue.x = item.target.x;
+                        else if (startValue.b3)
+                            tweener.startValue.x = startValue.f1 * this._owner.width;
+                        if (!startValue.b2)
+                            tweener.startValue.y = item.target.y;
+                        else if (startValue.b3)
+                            tweener.startValue.y = startValue.f2 * this._owner.height;
+                        if (!endValue.b1)
+                            tweener.endValue.x = tweener.startValue.x;
+                        else if (endValue.b3)
+                            tweener.endValue.x = endValue.f1 * this._owner.width;
+                        if (!endValue.b2)
+                            tweener.endValue.y = tweener.startValue.y;
+                        else if (endValue.b3)
+                            tweener.endValue.y = endValue.f2 * this._owner.height;
+                    }
+                    else {
+                        if (!startValue.b1)
+                            tweener.startValue.x = item.target.x - this._ownerBaseX;
+                        if (!startValue.b2)
+                            tweener.startValue.y = item.target.y - this._ownerBaseY;
+                        if (!endValue.b1)
+                            tweener.endValue.x = tweener.startValue.x;
+                        if (!endValue.b2)
+                            tweener.endValue.y = tweener.startValue.y;
+                    }
+                }
+                else {
+                    if (!startValue.b1)
+                        tweener.startValue.x = item.target.width;
+                    if (!startValue.b2)
+                        tweener.startValue.y = item.target.height;
+                    if (!endValue.b1)
+                        tweener.endValue.x = tweener.startValue.x;
+                    if (!endValue.b2)
+                        tweener.endValue.y = tweener.startValue.y;
+                }
+                if (item.tweenConfig.path) {
+                    item.value.b1 = item.value.b2 = true;
+                    tweener.setPath(item.tweenConfig.path);
+                }
+            }
+            this.callHook(item, false);
+        };
+        Transition.prototype.onTweenUpdate = function (tweener) {
+            var item = tweener.target;
+            switch (item.type) {
+                case ActionType.XY:
+                case ActionType.Size:
+                case ActionType.Scale:
+                case ActionType.Skew:
+                    item.value.f1 = tweener.value.x;
+                    item.value.f2 = tweener.value.y;
+                    if (item.tweenConfig.path) {
+                        item.value.f1 += tweener.startValue.x;
+                        item.value.f2 += tweener.startValue.y;
+                    }
+                    break;
+                case ActionType.Alpha:
+                case ActionType.Rotation:
+                    item.value.f1 = tweener.value.x;
+                    break;
+                case ActionType.Color:
+                    item.value.f1 = tweener.value.color;
+                    break;
+                case ActionType.ColorFilter:
+                    item.value.f1 = tweener.value.x;
+                    item.value.f2 = tweener.value.y;
+                    item.value.f3 = tweener.value.z;
+                    item.value.f4 = tweener.value.w;
+                    break;
+                case ActionType.Shake:
+                    item.value.offsetX = tweener.deltaValue.x;
+                    item.value.offsetY = tweener.deltaValue.y;
+                    break;
+            }
+            this.applyValue(item);
+        };
+        Transition.prototype.onTweenComplete = function (tweener) {
+            var item = tweener.target;
+            item.tweener = null;
+            this._totalTasks--;
+            if (tweener.allCompleted)
+                this.callHook(item, true);
+            this.checkAllComplete();
+        };
+        Transition.prototype.onPlayTransCompleted = function (item) {
+            this._totalTasks--;
+            this.checkAllComplete();
+        };
+        Transition.prototype.callHook = function (item, tweenEnd) {
+            if (tweenEnd) {
+                if (item.tweenConfig && item.tweenConfig.endHook)
+                    item.tweenConfig.endHook.call(item.tweenConfig.endHookCaller);
+            }
+            else {
+                if (item.time >= this._startTime && item.hook != null)
+                    item.hook.call(item.hookCaller);
+            }
+        };
+        Transition.prototype.checkAllComplete = function () {
+            if (this._playing && this._totalTasks == 0) {
+                if (this._totalTimes < 0) {
+                    this.internalPlay();
+                }
+                else {
+                    this._totalTimes--;
+                    if (this._totalTimes > 0)
+                        this.internalPlay();
+                    else {
+                        this._playing = false;
+                        var cnt = this._items.length;
+                        for (var i = 0; i < cnt; i++) {
+                            var item = this._items[i];
+                            if (item.target && item.displayLockToken != 0) {
+                                item.target.releaseDisplayLock(item.displayLockToken);
+                                item.displayLockToken = 0;
+                            }
+                        }
+                        if (this._onComplete != null) {
+                            var func = this._onComplete;
+                            var param = this._onCompleteParam;
+                            var thisObj = this._onCompleteCaller;
+                            this._onComplete = null;
+                            this._onCompleteParam = null;
+                            this._onCompleteCaller = null;
+                            func.call(thisObj, param);
+                        }
+                    }
+                }
+            }
+        };
+        Transition.prototype.applyValue = function (item) {
+            item.target._gearLocked = true;
+            var value = item.value;
+            switch (item.type) {
+                case ActionType.XY:
+                    if (item.target == this._owner) {
+                        if (value.b1 && value.b2)
+                            item.target.setXY(value.f1 + this._ownerBaseX, value.f2 + this._ownerBaseY);
+                        else if (value.b1)
+                            item.target.x = value.f1 + this._ownerBaseX;
+                        else
+                            item.target.y = value.f2 + this._ownerBaseY;
+                    }
+                    else {
+                        if (value.b3) {
+                            if (value.b1 && value.b2)
+                                item.target.setXY(value.f1 * this._owner.width, value.f2 * this._owner.height);
+                            else if (value.b1)
+                                item.target.x = value.f1 * this._owner.width;
+                            else if (value.b2)
+                                item.target.y = value.f2 * this._owner.height;
+                        }
+                        else {
+                            if (value.b1 && value.b2)
+                                item.target.setXY(value.f1, value.f2);
+                            else if (value.b1)
+                                item.target.x = value.f1;
+                            else if (value.b2)
+                                item.target.y = value.f2;
+                        }
+                    }
+                    break;
+                case ActionType.Size:
+                    if (!value.b1)
+                        value.f1 = item.target.width;
+                    if (!value.b2)
+                        value.f2 = item.target.height;
+                    item.target.setSize(value.f1, value.f2);
+                    break;
+                case ActionType.Pivot:
+                    item.target.setPivot(value.f1, value.f2, item.target.pivotAsAnchor);
+                    break;
+                case ActionType.Alpha:
+                    item.target.alpha = value.f1;
+                    break;
+                case ActionType.Rotation:
+                    item.target.rotation = value.f1;
+                    break;
+                case ActionType.Scale:
+                    item.target.setScale(value.f1, value.f2);
+                    break;
+                case ActionType.Skew:
+                    item.target.setSkew(value.f1, value.f2);
+                    break;
+                case ActionType.Color:
+                    item.target.setProp(fgui.ObjectPropID.Color, value.f1);
+                    break;
+                case ActionType.Animation:
+                    if (value.frame >= 0)
+                        item.target.setProp(fgui.ObjectPropID.Frame, value.frame);
+                    item.target.setProp(fgui.ObjectPropID.Playing, value.playing);
+                    item.target.setProp(fgui.ObjectPropID.TimeScale, this._timeScale);
+                    break;
+                case ActionType.Visible:
+                    item.target.visible = value.visible;
+                    break;
+                case ActionType.Transition:
+                    if (this._playing) {
+                        var trans = value.trans;
+                        if (trans) {
+                            this._totalTasks++;
+                            var startTime = this._startTime > item.time ? (this._startTime - item.time) : 0;
+                            var endTime = this._endTime >= 0 ? (this._endTime - item.time) : -1;
+                            if (value.stopTime >= 0 && (endTime < 0 || endTime > value.stopTime))
+                                endTime = value.stopTime;
+                            trans.timeScale = this._timeScale;
+                            trans._play(this.onPlayTransCompleted, this, item, value.playTimes, 0, startTime, endTime, this._reversed);
+                        }
+                    }
+                    break;
+                case ActionType.Sound:
+                    if (this._playing && item.time >= this._startTime) {
+                        if (!value.audioClip) {
+                            var pi = fgui.UIPackage.getItemByURL(value.sound);
+                            if (pi)
+                                value.audioClip = pi.owner.getItemAsset(pi);
+                        }
+                        if (value.audioClip)
+                            fgui.GRoot.inst.playOneShotSound(value.audioClip, value.volume);
+                    }
+                    break;
+                case ActionType.Shake:
+                    item.target.setXY(item.target.x - value.lastOffsetX + value.offsetX, item.target.y - value.lastOffsetY + value.offsetY);
+                    value.lastOffsetX = value.offsetX;
+                    value.lastOffsetY = value.offsetY;
+                    break;
+                case ActionType.ColorFilter:
+                    {
+                        fgui.ToolSet.setColorFilter(item.target.displayObject, [value.f1, value.f2, value.f3, value.f4]);
+                        break;
+                    }
+                case ActionType.Text:
+                    item.target.text = value.text;
+                    break;
+                case ActionType.Icon:
+                    item.target.icon = value.text;
+                    break;
+            }
+            item.target._gearLocked = false;
+        };
+        Transition.prototype.setup = function (buffer) {
+            this.name = buffer.readS();
+            this._options = buffer.readInt();
+            this._autoPlay = buffer.readBool();
+            this._autoPlayTimes = buffer.readInt();
+            this._autoPlayDelay = buffer.readFloat();
+            var cnt = buffer.readShort();
+            for (var i = 0; i < cnt; i++) {
+                var dataLen = buffer.readShort();
+                var curPos = buffer.position;
+                buffer.seek(curPos, 0);
+                var item = new Item(buffer.readByte());
+                this._items[i] = item;
+                item.time = buffer.readFloat();
+                var targetId = buffer.readShort();
+                if (targetId < 0)
+                    item.targetId = "";
+                else
+                    item.targetId = this._owner.getChildAt(targetId).id;
+                item.label = buffer.readS();
+                if (buffer.readBool()) {
+                    buffer.seek(curPos, 1);
+                    item.tweenConfig = new TweenConfig();
+                    item.tweenConfig.duration = buffer.readFloat();
+                    if (item.time + item.tweenConfig.duration > this._totalDuration)
+                        this._totalDuration = item.time + item.tweenConfig.duration;
+                    item.tweenConfig.easeType = buffer.readByte();
+                    item.tweenConfig.repeat = buffer.readInt();
+                    item.tweenConfig.yoyo = buffer.readBool();
+                    item.tweenConfig.endLabel = buffer.readS();
+                    buffer.seek(curPos, 2);
+                    this.decodeValue(item, buffer, item.tweenConfig.startValue);
+                    buffer.seek(curPos, 3);
+                    this.decodeValue(item, buffer, item.tweenConfig.endValue);
+                    if (buffer.version >= 2) {
+                        var pathLen = buffer.readInt();
+                        if (pathLen > 0) {
+                            item.tweenConfig.path = new fgui.GPath();
+                            var pts = new Array();
+                            for (var j = 0; j < pathLen; j++) {
+                                var curveType = buffer.readByte();
+                                switch (curveType) {
+                                    case fgui.CurveType.Bezier:
+                                        pts.push(fgui.GPathPoint.newBezierPoint(buffer.readFloat(), buffer.readFloat(), buffer.readFloat(), buffer.readFloat()));
+                                        break;
+                                    case fgui.CurveType.CubicBezier:
+                                        pts.push(fgui.GPathPoint.newCubicBezierPoint(buffer.readFloat(), buffer.readFloat(), buffer.readFloat(), buffer.readFloat(), buffer.readFloat(), buffer.readFloat()));
+                                        break;
+                                    default:
+                                        pts.push(fgui.GPathPoint.newPoint(buffer.readFloat(), buffer.readFloat(), curveType));
+                                        break;
+                                }
+                            }
+                            item.tweenConfig.path.create(pts);
+                        }
+                    }
+                }
+                else {
+                    if (item.time > this._totalDuration)
+                        this._totalDuration = item.time;
+                    buffer.seek(curPos, 2);
+                    this.decodeValue(item, buffer, item.value);
+                }
+                buffer.position = curPos + dataLen;
+            }
+        };
+        Transition.prototype.decodeValue = function (item, buffer, value) {
+            switch (item.type) {
+                case ActionType.XY:
+                case ActionType.Size:
+                case ActionType.Pivot:
+                case ActionType.Skew:
+                    value.b1 = buffer.readBool();
+                    value.b2 = buffer.readBool();
+                    value.f1 = buffer.readFloat();
+                    value.f2 = buffer.readFloat();
+                    if (buffer.version >= 2 && item.type == ActionType.XY)
+                        value.b3 = buffer.readBool();
+                    break;
+                case ActionType.Alpha:
+                case ActionType.Rotation:
+                    value.f1 = buffer.readFloat();
+                    break;
+                case ActionType.Scale:
+                    value.f1 = buffer.readFloat();
+                    value.f2 = buffer.readFloat();
+                    break;
+                case ActionType.Color:
+                    value.f1 = buffer.readColor();
+                    break;
+                case ActionType.Animation:
+                    value.playing = buffer.readBool();
+                    value.frame = buffer.readInt();
+                    break;
+                case ActionType.Visible:
+                    value.visible = buffer.readBool();
+                    break;
+                case ActionType.Sound:
+                    value.sound = buffer.readS();
+                    value.volume = buffer.readFloat();
+                    break;
+                case ActionType.Transition:
+                    value.transName = buffer.readS();
+                    value.playTimes = buffer.readInt();
+                    break;
+                case ActionType.Shake:
+                    value.amplitude = buffer.readFloat();
+                    value.duration = buffer.readFloat();
+                    break;
+                case ActionType.ColorFilter:
+                    value.f1 = buffer.readFloat();
+                    value.f2 = buffer.readFloat();
+                    value.f3 = buffer.readFloat();
+                    value.f4 = buffer.readFloat();
+                    break;
+                case ActionType.Text:
+                case ActionType.Icon:
+                    value.text = buffer.readS();
+                    break;
+            }
+        };
+        return Transition;
+    }());
+    fgui.Transition = Transition;
+    var OPTION_IGNORE_DISPLAY_CONTROLLER = 1;
+    var OPTION_AUTO_STOP_DISABLED = 2;
+    var OPTION_AUTO_STOP_AT_END = 4;
+    var ActionType = (function () {
+        function ActionType() {
+        }
+        ActionType.XY = 0;
+        ActionType.Size = 1;
+        ActionType.Scale = 2;
+        ActionType.Pivot = 3;
+        ActionType.Alpha = 4;
+        ActionType.Rotation = 5;
+        ActionType.Color = 6;
+        ActionType.Animation = 7;
+        ActionType.Visible = 8;
+        ActionType.Sound = 9;
+        ActionType.Transition = 10;
+        ActionType.Shake = 11;
+        ActionType.ColorFilter = 12;
+        ActionType.Skew = 13;
+        ActionType.Text = 14;
+        ActionType.Icon = 15;
+        ActionType.Unknown = 16;
+        return ActionType;
+    }());
+    var Item = (function () {
+        function Item(type) {
+            this.type = type;
+            this.value = {};
+            this.displayLockToken = 0;
+        }
+        return Item;
+    }());
+    var TweenConfig = (function () {
+        function TweenConfig() {
+            this.duration = 0;
+            this.repeat = 0;
+            this.easeType = fgui.EaseType.QuadOut;
+            this.startValue = { b1: true, b2: true };
+            this.endValue = { b1: true, b2: true };
+        }
+        return TweenConfig;
+    }());
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var TranslationHelper = (function () {
+        function TranslationHelper() {
+        }
+        TranslationHelper.loadFromXML = function (source) {
+            var strings = {};
+            TranslationHelper.strings = strings;
+            var xml = egret.XML.parse(source);
+            var nodes = xml.children;
+            var length1 = nodes.length;
+            for (var i1 = 0; i1 < length1; i1++) {
+                var cxml = nodes[i1];
+                if (cxml.name == "string") {
+                    var key = cxml.attributes.name;
+                    var text = cxml.children.length > 0 ? cxml.children[0].text : "";
+                    var i = key.indexOf("-");
+                    if (i == -1)
+                        continue;
+                    var key2 = key.substr(0, i);
+                    var key3 = key.substr(i + 1);
+                    var col = strings[key2];
+                    if (!col) {
+                        col = {};
+                        strings[key2] = col;
+                    }
+                    col[key3] = text;
+                }
+            }
+        };
+        TranslationHelper.translateComponent = function (item) {
+            if (TranslationHelper.strings == null)
+                return;
+            var compStrings = TranslationHelper.strings[item.owner.id + item.id];
+            if (compStrings == null)
+                return;
+            var elementId, value;
+            var buffer = item.rawData;
+            var nextPos;
+            var itemCount;
+            var i, j, k;
+            var dataLen;
+            var curPos;
+            var valueCnt;
+            var page;
+            buffer.seek(0, 2);
+            var childCount = buffer.readShort();
+            for (i = 0; i < childCount; i++) {
+                dataLen = buffer.readShort();
+                curPos = buffer.position;
+                buffer.seek(curPos, 0);
+                var baseType = buffer.readByte();
+                var type = baseType;
+                buffer.skip(4);
+                elementId = buffer.readS();
+                if (type == fgui.ObjectType.Component) {
+                    if (buffer.seek(curPos, 6))
+                        type = buffer.readByte();
+                }
+                buffer.seek(curPos, 1);
+                if ((value = compStrings[elementId + "-tips"]) != null)
+                    buffer.writeS(value);
+                buffer.seek(curPos, 2);
+                var gearCnt = buffer.readShort();
+                for (j = 0; j < gearCnt; j++) {
+                    nextPos = buffer.readShort();
+                    nextPos += buffer.position;
+                    if (buffer.readByte() == 6) {
+                        buffer.skip(2);
+                        valueCnt = buffer.readShort();
+                        for (k = 0; k < valueCnt; k++) {
+                            page = buffer.readS();
+                            if (page != null) {
+                                if ((value = compStrings[elementId + "-texts_" + k]) != null)
+                                    buffer.writeS(value);
+                                else
+                                    buffer.skip(2);
+                            }
+                        }
+                        if (buffer.readBool() && (value = compStrings[elementId + "-texts_def"]) != null)
+                            buffer.writeS(value);
+                    }
+                    if (baseType == fgui.ObjectType.Component && buffer.version >= 2) {
+                        buffer.seek(curPos, 4);
+                        buffer.skip(2);
+                        buffer.skip(4 * buffer.readShort());
+                        var cpCount = buffer.readShort();
+                        for (var k = 0; k < cpCount; k++) {
+                            var target = buffer.readS();
+                            var propertyId = buffer.readShort();
+                            if (propertyId == 0 && (value = compStrings[elementId + "-cp-" + target]) != null)
+                                buffer.writeS(value);
+                            else
+                                buffer.skip(2);
+                        }
+                    }
+                    buffer.position = nextPos;
+                }
+                switch (type) {
+                    case fgui.ObjectType.Text:
+                    case fgui.ObjectType.RichText:
+                    case fgui.ObjectType.InputText:
+                        {
+                            if ((value = compStrings[elementId]) != null) {
+                                buffer.seek(curPos, 6);
+                                buffer.writeS(value);
+                            }
+                            if ((value = compStrings[elementId + "-prompt"]) != null) {
+                                buffer.seek(curPos, 4);
+                                buffer.writeS(value);
+                            }
+                            break;
+                        }
+                    case fgui.ObjectType.List:
+                    case fgui.ObjectType.Tree:
+                        {
+                            buffer.seek(curPos, 8);
+                            buffer.skip(2);
+                            itemCount = buffer.readShort();
+                            for (j = 0; j < itemCount; j++) {
+                                nextPos = buffer.readShort();
+                                nextPos += buffer.position;
+                                buffer.skip(2);
+                                if (type == fgui.ObjectType.Tree)
+                                    buffer.skip(2);
+                                if ((value = compStrings[elementId + "-" + j]) != null)
+                                    buffer.writeS(value);
+                                else
+                                    buffer.skip(2);
+                                if ((value = compStrings[elementId + "-" + j + "-0"]) != null)
+                                    buffer.writeS(value);
+                                else
+                                    buffer.skip(2);
+                                if (buffer.version >= 2) {
+                                    buffer.skip(6);
+                                    buffer.skip(buffer.readUnsignedShort() * 4);
+                                    var cpCount = buffer.readUnsignedShort();
+                                    for (var k = 0; k < cpCount; k++) {
+                                        var target = buffer.readS();
+                                        var propertyId = buffer.readUnsignedShort();
+                                        if (propertyId == 0 && (value = compStrings[elementId + "-" + j + "-" + target]) != null)
+                                            buffer.writeS(value);
+                                        else
+                                            buffer.skip(2);
+                                    }
+                                }
+                                buffer.position = nextPos;
+                            }
+                            break;
+                        }
+                    case fgui.ObjectType.Label:
+                        {
+                            if (buffer.seek(curPos, 6) && buffer.readByte() == type) {
+                                if ((value = compStrings[elementId]) != null)
+                                    buffer.writeS(value);
+                                else
+                                    buffer.skip(2);
+                                buffer.skip(2);
+                                if (buffer.readBool())
+                                    buffer.skip(4);
+                                buffer.skip(4);
+                                if (buffer.readBool() && (value = compStrings[elementId + "-prompt"]) != null)
+                                    buffer.writeS(value);
+                            }
+                            break;
+                        }
+                    case fgui.ObjectType.Button:
+                        {
+                            if (buffer.seek(curPos, 6) && buffer.readByte() == type) {
+                                if ((value = compStrings[elementId]) != null)
+                                    buffer.writeS(value);
+                                else
+                                    buffer.skip(2);
+                                if ((value = compStrings[elementId + "-0"]) != null)
+                                    buffer.writeS(value);
+                            }
+                            break;
+                        }
+                    case fgui.ObjectType.ComboBox:
+                        {
+                            if (buffer.seek(curPos, 6) && buffer.readByte() == type) {
+                                itemCount = buffer.readShort();
+                                for (j = 0; j < itemCount; j++) {
+                                    nextPos = buffer.readShort();
+                                    nextPos += buffer.position;
+                                    if ((value = compStrings[elementId + "-" + j]) != null)
+                                        buffer.writeS(value);
+                                    buffer.position = nextPos;
+                                }
+                                if ((value = compStrings[elementId]) != null)
+                                    buffer.writeS(value);
+                            }
+                            break;
+                        }
+                }
+                buffer.position = curPos + dataLen;
+            }
+        };
+        return TranslationHelper;
+    }());
+    fgui.TranslationHelper = TranslationHelper;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var UIConfig = (function () {
+        function UIConfig() {
+        }
+        UIConfig.defaultFont = "SimSun";
+        UIConfig.modalLayerColor = 0x333333;
+        UIConfig.modalLayerAlpha = 0.2;
+        UIConfig.buttonSoundVolumeScale = 1;
+        UIConfig.defaultScrollStep = 25;
+        UIConfig.defaultScrollDecelerationRate = 0.967;
+        UIConfig.defaultScrollBarDisplay = fgui.ScrollBarDisplayType.Visible;
+        UIConfig.defaultScrollTouchEffect = true;
+        UIConfig.defaultScrollBounceEffect = true;
+        UIConfig.defaultComboBoxVisibleItemCount = 10;
+        UIConfig.touchScrollSensitivity = 20;
+        UIConfig.touchDragSensitivity = 10;
+        UIConfig.clickDragSensitivity = 2;
+        UIConfig.bringWindowToFrontOnClick = true;
+        UIConfig.frameTimeForAsyncUIConstruction = 2;
+        return UIConfig;
+    }());
+    fgui.UIConfig = UIConfig;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var UIObjectFactory = (function () {
+        function UIObjectFactory() {
+        }
+        UIObjectFactory.setExtension = function (url, type) {
+            if (url == null)
+                throw "Invaild url: " + url;
+            var pi = fgui.UIPackage.getItemByURL(url);
+            if (pi)
+                pi.extensionType = type;
+            UIObjectFactory.extensions[url] = type;
+        };
+        UIObjectFactory.setPackageItemExtension = function (url, type) {
+            UIObjectFactory.setExtension(url, type);
+        };
+        UIObjectFactory.setLoaderExtension = function (type) {
+            UIObjectFactory.loaderType = type;
+        };
+        UIObjectFactory.resolvePackageItemExtension = function (pi) {
+            var extensionType = UIObjectFactory.extensions["ui://" + pi.owner.id + pi.id];
+            if (!extensionType)
+                extensionType = UIObjectFactory.extensions["ui://" + pi.owner.name + "/" + pi.name];
+            if (extensionType)
+                pi.extensionType = extensionType;
+        };
+        UIObjectFactory.newObject = function (type, userClass) {
+            var obj;
+            if (typeof type === 'number') {
+                switch (type) {
+                    case fgui.ObjectType.Image:
+                        return new fgui.GImage();
+                    case fgui.ObjectType.MovieClip:
+                        return new fgui.GMovieClip();
+                    case fgui.ObjectType.Component:
+                        return new fgui.GComponent();
+                    case fgui.ObjectType.Text:
+                        return new fgui.GTextField();
+                    case fgui.ObjectType.RichText:
+                        return new fgui.GRichTextField();
+                    case fgui.ObjectType.InputText:
+                        return new fgui.GTextInput();
+                    case fgui.ObjectType.Group:
+                        return new fgui.GGroup();
+                    case fgui.ObjectType.List:
+                        return new fgui.GList();
+                    case fgui.ObjectType.Graph:
+                        return new fgui.GGraph();
+                    case fgui.ObjectType.Loader:
+                        if (UIObjectFactory.loaderType)
+                            return new UIObjectFactory.loaderType();
+                        else
+                            return new fgui.GLoader();
+                    case fgui.ObjectType.Button:
+                        return new fgui.GButton();
+                    case fgui.ObjectType.Label:
+                        return new fgui.GLabel();
+                    case fgui.ObjectType.ProgressBar:
+                        return new fgui.GProgressBar();
+                    case fgui.ObjectType.Slider:
+                        return new fgui.GSlider();
+                    case fgui.ObjectType.ScrollBar:
+                        return new fgui.GScrollBar();
+                    case fgui.ObjectType.ComboBox:
+                        return new fgui.GComboBox();
+                    case fgui.ObjectType.Tree:
+                        return new fgui.GTree();
+                    case fgui.ObjectType.Loader3D:
+                        return new fgui.GLoader3D();
+                    default:
+                        return null;
+                }
+            }
+            else {
+                if (type.type == fgui.PackageItemType.Component) {
+                    if (userClass)
+                        obj = new userClass();
+                    else if (type.extensionType)
+                        obj = new type.extensionType();
+                    else
+                        obj = UIObjectFactory.newObject(type.objectType);
+                }
+                else
+                    obj = UIObjectFactory.newObject(type.objectType);
+                if (obj)
+                    obj.packageItem = type;
+            }
+            return obj;
+        };
+        UIObjectFactory.extensions = {};
+        return UIObjectFactory;
+    }());
+    fgui.UIObjectFactory = UIObjectFactory;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var UIPackage = (function () {
+        function UIPackage() {
+            this._items = [];
+            this._itemsById = {};
+            this._itemsByName = {};
+            this._sprites = {};
+            this._dependencies = [];
+            this._branches = [];
+            this._branchIndex = -1;
+        }
+        Object.defineProperty(UIPackage, "branch", {
+            get: function () {
+                return UIPackage._branch;
+            },
+            set: function (value) {
+                UIPackage._branch = value;
+                for (var pkgId in UIPackage._instById) {
+                    var pkg = UIPackage._instById[pkgId];
+                    if (pkg._branches) {
+                        pkg._branchIndex = pkg._branches.indexOf(value);
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        UIPackage.getVar = function (key) {
+            return UIPackage._vars[key];
+        };
+        UIPackage.setVar = function (key, value) {
+            UIPackage._vars[key] = value;
+        };
+        UIPackage.getById = function (id) {
+            return UIPackage._instById[id];
+        };
+        UIPackage.getByName = function (name) {
+            return UIPackage._instByName[name];
+        };
+        UIPackage.loadPackage = function (resKey) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    return [2, new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
+                            var pkg, asset, cnt, tasks, i, pi;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        pkg = UIPackage._instById[resKey];
+                                        if (pkg) {
+                                            resolve(pkg);
+                                            return [2];
+                                        }
+                                        return [4, RES.getResAsync(getAssetResKey(resKey, "fui"))];
+                                    case 1:
+                                        asset = _a.sent();
+                                        pkg = new UIPackage();
+                                        pkg._resKey = resKey;
+                                        pkg.loadPackage(new fgui.ByteBuffer(asset));
+                                        cnt = pkg._items.length;
+                                        tasks = [];
+                                        for (i = 0; i < cnt; i++) {
+                                            pi = pkg._items[i];
+                                            if (pi.type == fgui.PackageItemType.Atlas || pi.type == fgui.PackageItemType.Sound) {
+                                                tasks.push(RES.getResAsync(pi.file));
+                                            }
+                                        }
+                                        if (!(tasks.length > 0)) return [3, 3];
+                                        return [4, Promise.all(tasks)];
+                                    case 2:
+                                        _a.sent();
+                                        _a.label = 3;
+                                    case 3:
+                                        UIPackage._instById[pkg.id] = pkg;
+                                        UIPackage._instByName[pkg.name] = pkg;
+                                        UIPackage._instById[pkg._resKey] = pkg;
+                                        resolve(pkg);
+                                        return [2];
+                                }
+                            });
+                        }); })];
+                });
+            });
+        };
+        UIPackage.addPackage = function (resKey, descData) {
+            if (!descData) {
+                descData = RES.getRes(resKey);
+                if (!descData)
+                    throw "Resource '" + resKey + "' not found, please check default.res.json!";
+            }
+            var pkg = new UIPackage();
+            pkg._resKey = resKey;
+            pkg.loadPackage(new fgui.ByteBuffer(descData));
+            UIPackage._instById[pkg.id] = pkg;
+            UIPackage._instByName[pkg.name] = pkg;
+            UIPackage._instById[resKey] = pkg;
+            return pkg;
+        };
+        UIPackage.removePackage = function (packageIdOrName) {
+            var pkg = UIPackage._instById[packageIdOrName];
+            if (!pkg)
+                pkg = UIPackage._instByName[packageIdOrName];
+            if (!pkg)
+                throw new Error("unknown package: " + packageIdOrName);
+            pkg.dispose();
+            delete UIPackage._instById[pkg.id];
+            delete UIPackage._instByName[pkg.name];
+            delete UIPackage._instById[pkg._resKey];
+            if (pkg._customId != null)
+                delete UIPackage._instById[pkg._customId];
+        };
+        UIPackage.createObject = function (pkgName, resName, userClass) {
+            var pkg = UIPackage.getByName(pkgName);
+            if (pkg)
+                return pkg.createObject(resName, userClass);
+            else
+                return null;
+        };
+        UIPackage.createObjectFromURL = function (url, userClass) {
+            var pi = UIPackage.getItemByURL(url);
+            if (pi)
+                return pi.owner.internalCreateObject(pi, userClass);
+            else
+                return null;
+        };
+        UIPackage.getItemURL = function (pkgName, resName) {
+            var pkg = UIPackage.getByName(pkgName);
+            if (!pkg)
+                return null;
+            var pi = pkg._itemsByName[resName];
+            if (!pi)
+                return null;
+            return "ui://" + pkg.id + pi.id;
+        };
+        UIPackage.getItemByURL = function (url) {
+            var pos1 = url.indexOf("//");
+            if (pos1 == -1)
+                return null;
+            var pos2 = url.indexOf("/", pos1 + 2);
+            if (pos2 == -1) {
+                if (url.length > 13) {
+                    var pkgId = url.substr(5, 8);
+                    var pkg = UIPackage.getById(pkgId);
+                    if (pkg != null) {
+                        var srcId = url.substr(13);
+                        return pkg.getItemById(srcId);
+                    }
+                }
+            }
+            else {
+                var pkgName = url.substr(pos1 + 2, pos2 - pos1 - 2);
+                pkg = UIPackage.getByName(pkgName);
+                if (pkg != null) {
+                    var srcName = url.substr(pos2 + 1);
+                    return pkg.getItemByName(srcName);
+                }
+            }
+            return null;
+        };
+        UIPackage.normalizeURL = function (url) {
+            if (url == null)
+                return null;
+            var pos1 = url.indexOf("//");
+            if (pos1 == -1)
+                return null;
+            var pos2 = url.indexOf("/", pos1 + 2);
+            if (pos2 == -1)
+                return url;
+            var pkgName = url.substr(pos1 + 2, pos2 - pos1 - 2);
+            var srcName = url.substr(pos2 + 1);
+            return UIPackage.getItemURL(pkgName, srcName);
+        };
+        UIPackage.setStringsSource = function (source) {
+            fgui.TranslationHelper.loadFromXML(source);
+        };
+        UIPackage.prototype.loadPackage = function (buffer) {
+            if (buffer.readUnsignedInt() != 0x46475549)
+                throw "FairyGUI: old package format found in '" + this._resKey + "'";
+            buffer.version = buffer.readInt();
+            var compressed = buffer.readBool();
+            this._id = buffer.readUTF();
+            this._name = buffer.readUTF();
+            buffer.skip(20);
+            if (compressed) {
+                var buf = new Uint8Array(buffer.buffer, buffer.position, buffer.length - buffer.position);
+                var inflater = new Zlib.RawInflate(buf);
+                var buffer2 = new fgui.ByteBuffer(inflater.decompress());
+                buffer2.version = buffer.version;
+                buffer = buffer2;
+            }
+            var ver2 = buffer.version >= 2;
+            var indexTablePos = buffer.position;
+            var cnt;
+            var i;
+            var nextPos;
+            var str;
+            var branchIncluded;
+            buffer.seek(indexTablePos, 4);
+            cnt = buffer.readInt();
+            var stringTable = new Array(cnt);
+            stringTable.reduceRight;
+            for (i = 0; i < cnt; i++)
+                stringTable[i] = buffer.readUTF();
+            buffer.stringTable = stringTable;
+            buffer.seek(indexTablePos, 0);
+            cnt = buffer.readShort();
+            for (i = 0; i < cnt; i++)
+                this._dependencies.push({ id: buffer.readS(), name: buffer.readS() });
+            if (ver2) {
+                cnt = buffer.readShort();
+                if (cnt > 0) {
+                    this._branches = buffer.readSArray(cnt);
+                    if (UIPackage._branch)
+                        this._branchIndex = this._branches.indexOf(UIPackage._branch);
+                }
+                branchIncluded = cnt > 0;
+            }
+            buffer.seek(indexTablePos, 1);
+            var pi;
+            var path = this._resKey;
+            var pos = path.lastIndexOf('/');
+            var shortPath = pos == -1 ? "" : path.substr(0, pos + 1);
+            path = path + "_";
+            cnt = buffer.readShort();
+            for (i = 0; i < cnt; i++) {
+                nextPos = buffer.readInt();
+                nextPos += buffer.position;
+                pi = new fgui.PackageItem();
+                pi.owner = this;
+                pi.type = buffer.readByte();
+                pi.id = buffer.readS();
+                pi.name = buffer.readS();
+                buffer.readS();
+                pi.file = buffer.readS();
+                buffer.readBool();
+                pi.width = buffer.readInt();
+                pi.height = buffer.readInt();
+                switch (pi.type) {
+                    case fgui.PackageItemType.Image:
+                        {
+                            pi.objectType = fgui.ObjectType.Image;
+                            var scaleOption = buffer.readByte();
+                            if (scaleOption == 1) {
+                                pi.scale9Grid = new egret.Rectangle();
+                                pi.scale9Grid.x = buffer.readInt();
+                                pi.scale9Grid.y = buffer.readInt();
+                                pi.scale9Grid.width = buffer.readInt();
+                                pi.scale9Grid.height = buffer.readInt();
+                                pi.tileGridIndice = buffer.readInt();
+                            }
+                            else if (scaleOption == 2)
+                                pi.scaleByTile = true;
+                            pi.smoothing = buffer.readBool();
+                            break;
+                        }
+                    case fgui.PackageItemType.MovieClip:
+                        {
+                            pi.smoothing = buffer.readBool();
+                            pi.objectType = fgui.ObjectType.MovieClip;
+                            pi.rawData = buffer.readBuffer();
+                            break;
+                        }
+                    case fgui.PackageItemType.Font:
+                        {
+                            pi.rawData = buffer.readBuffer();
+                            break;
+                        }
+                    case fgui.PackageItemType.Component:
+                        {
+                            var extension = buffer.readByte();
+                            if (extension > 0)
+                                pi.objectType = extension;
+                            else
+                                pi.objectType = fgui.ObjectType.Component;
+                            pi.rawData = buffer.readBuffer();
+                            fgui.UIObjectFactory.resolvePackageItemExtension(pi);
+                            break;
+                        }
+                    case fgui.PackageItemType.Atlas:
+                    case fgui.PackageItemType.Sound:
+                    case fgui.PackageItemType.Misc:
+                        {
+                            var pos_1 = pi.file.lastIndexOf(".");
+                            pi.file = path + (pos_1 == -1 ? pi.file : getAssetResKey(pi.file.substring(0, pos_1), pi.file.substring(pos_1 + 1)));
+                            break;
+                        }
+                    case fgui.PackageItemType.Spine:
+                    case fgui.PackageItemType.DragonBones:
+                        {
+                            var pos_2 = pi.file.lastIndexOf(".");
+                            pi.file = shortPath + (pos_2 == -1 ? pi.file : pi.file.substring(0, pos_2));
+                            pi.skeletonAnchor = new egret.Point();
+                            pi.skeletonAnchor.x = buffer.readFloat();
+                            pi.skeletonAnchor.y = buffer.readFloat();
+                            break;
+                        }
+                }
+                if (ver2) {
+                    str = buffer.readS();
+                    if (str)
+                        pi.name = str + "/" + pi.name;
+                    var branchCnt = buffer.readUnsignedByte();
+                    if (branchCnt > 0) {
+                        if (branchIncluded)
+                            pi.branches = buffer.readSArray(branchCnt);
+                        else
+                            this._itemsById[buffer.readS()] = pi;
+                    }
+                    var highResCnt = buffer.readUnsignedByte();
+                    if (highResCnt > 0)
+                        pi.highResolution = buffer.readSArray(highResCnt);
+                }
+                this._items.push(pi);
+                this._itemsById[pi.id] = pi;
+                if (pi.name != null)
+                    this._itemsByName[pi.name] = pi;
+                buffer.position = nextPos;
+            }
+            buffer.seek(indexTablePos, 2);
+            cnt = buffer.readShort();
+            for (i = 0; i < cnt; i++) {
+                nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                var itemId = buffer.readS();
+                pi = this._itemsById[buffer.readS()];
+                var sprite = { atlas: pi, rect: new egret.Rectangle(), offset: new egret.Point(), originalSize: new egret.Point() };
+                sprite.rect.x = buffer.readInt();
+                sprite.rect.y = buffer.readInt();
+                sprite.rect.width = buffer.readInt();
+                sprite.rect.height = buffer.readInt();
+                sprite.rotated = buffer.readBool();
+                if (ver2 && buffer.readBool()) {
+                    sprite.offset.x = buffer.readInt();
+                    sprite.offset.y = buffer.readInt();
+                    sprite.originalSize.x = buffer.readInt();
+                    sprite.originalSize.y = buffer.readInt();
+                }
+                else {
+                    sprite.originalSize.x = sprite.rect.width;
+                    sprite.originalSize.y = sprite.rect.height;
+                }
+                this._sprites[itemId] = sprite;
+                buffer.position = nextPos;
+            }
+            if (buffer.seek(indexTablePos, 3)) {
+                cnt = buffer.readShort();
+                for (i = 0; i < cnt; i++) {
+                    nextPos = buffer.readInt();
+                    nextPos += buffer.position;
+                    pi = this._itemsById[buffer.readS()];
+                    if (pi && pi.type == fgui.PackageItemType.Image) {
+                        pi.pixelHitTestData = new fgui.PixelHitTestData();
+                        pi.pixelHitTestData.load(buffer);
+                    }
+                    buffer.position = nextPos;
+                }
+            }
+        };
+        UIPackage.prototype.dispose = function () {
+            var cnt = this._items.length;
+            for (var i = 0; i < cnt; i++) {
+                var pi = this._items[i];
+                if (pi.type == fgui.PackageItemType.Atlas) {
+                    RES.destroyRes(pi.file, false);
+                }
+                else if (pi.type == fgui.PackageItemType.Sound) {
+                }
+            }
+        };
+        Object.defineProperty(UIPackage.prototype, "id", {
+            get: function () {
+                return this._id;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(UIPackage.prototype, "name", {
+            get: function () {
+                return this._name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(UIPackage.prototype, "customId", {
+            get: function () {
+                return this._customId;
+            },
+            set: function (value) {
+                if (this._customId != null)
+                    delete UIPackage._instById[this._customId];
+                this._customId = value;
+                if (this._customId != null)
+                    UIPackage._instById[this._customId] = this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        UIPackage.prototype.createObject = function (resName, userClass) {
+            var pi = this._itemsByName[resName];
+            if (pi)
+                return this.internalCreateObject(pi, userClass);
+            else
+                return null;
+        };
+        UIPackage.prototype.internalCreateObject = function (item, userClass) {
+            var g = fgui.UIObjectFactory.newObject(item, userClass);
+            if (g == null)
+                return null;
+            UIPackage._constructing++;
+            g.constructFromResource();
+            UIPackage._constructing--;
+            return g;
+        };
+        UIPackage.prototype.getItemById = function (itemId) {
+            return this._itemsById[itemId];
+        };
+        UIPackage.prototype.getItemByName = function (resName) {
+            return this._itemsByName[resName];
+        };
+        UIPackage.prototype.getItemAssetByName = function (resName) {
+            var pi = this._itemsByName[resName];
+            if (pi == null) {
+                throw "Resource not found -" + resName;
+            }
+            return this.getItemAsset(pi);
+        };
+        UIPackage.prototype.getItemAsset = function (item) {
+            switch (item.type) {
+                case fgui.PackageItemType.Image:
+                    if (!item.decoded) {
+                        item.decoded = true;
+                        var sprite = this._sprites[item.id];
+                        if (sprite) {
+                            var atlas = this.getItemAsset(sprite.atlas);
+                            item.asset = new egret.Texture();
+                            item.asset.bitmapData = atlas.bitmapData;
+                            item.asset.$initData(atlas.$bitmapX + sprite.rect.x, atlas.$bitmapY + sprite.rect.y, sprite.rect.width, sprite.rect.height, sprite.offset.x, sprite.offset.y, sprite.originalSize.x, sprite.originalSize.y, atlas.$sourceWidth, atlas.$sourceHeight, sprite.rotated);
+                        }
+                    }
+                    return item.asset;
+                case fgui.PackageItemType.Atlas:
+                case fgui.PackageItemType.Sound:
+                    if (!item.decoded) {
+                        item.decoded = true;
+                        item.asset = RES.getRes(item.file);
+                        if (!item.asset)
+                            console.log("Resource '" + item.file + "' not found, please check default.res.json!");
+                    }
+                    return item.asset;
+                case fgui.PackageItemType.Font:
+                    if (!item.decoded) {
+                        item.decoded = true;
+                        this.loadFont(item);
+                    }
+                    return item.bitmapFont;
+                case fgui.PackageItemType.MovieClip:
+                    if (!item.decoded) {
+                        item.decoded = true;
+                        this.loadMovieClip(item);
+                    }
+                    return item.frames;
+                case fgui.PackageItemType.Misc:
+                    if (item.file)
+                        return RES.getRes(item.file);
+                    else
+                        return null;
+                default:
+                    return null;
+            }
+        };
+        UIPackage.prototype.getItemAssetAsync = function (item, onComplete) {
+            if (item.decoded) {
+                onComplete(null, item);
+                return;
+            }
+            if (item.loading) {
+                item.loading.push(onComplete);
+                return;
+            }
+            switch (item.type) {
+                case fgui.PackageItemType.DragonBones:
+                    item.loading = [onComplete];
+                    this.loadDragonBones(item);
+                    break;
+                default:
+                    this.getItemAsset(item);
+                    onComplete(null, item);
+                    break;
+            }
+        };
+        UIPackage.prototype.loadMovieClip = function (item) {
+            var buffer = item.rawData;
+            buffer.seek(0, 0);
+            item.interval = buffer.readInt();
+            item.swing = buffer.readBool();
+            item.repeatDelay = buffer.readInt();
+            buffer.seek(0, 1);
+            var frameCount = buffer.readShort();
+            item.frames = Array(frameCount);
+            var spriteId;
+            var sprite;
+            var fx;
+            var fy;
+            for (var i = 0; i < frameCount; i++) {
+                var nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                var frame = {};
+                fx = buffer.readInt();
+                fy = buffer.readInt();
+                buffer.readInt();
+                buffer.readInt();
+                frame.addDelay = buffer.readInt();
+                spriteId = buffer.readS();
+                if (spriteId != null && (sprite = this._sprites[spriteId]) != null) {
+                    var atlas = this.getItemAsset(sprite.atlas);
+                    frame.texture = new egret.Texture();
+                    frame.texture.bitmapData = atlas.bitmapData;
+                    frame.texture.$initData(atlas.$bitmapX + sprite.rect.x, atlas.$bitmapY + sprite.rect.y, sprite.rect.width, sprite.rect.height, fx, fy, item.width, item.height, atlas.$sourceWidth, atlas.$sourceHeight, sprite.rotated);
+                }
+                item.frames[i] = frame;
+                buffer.position = nextPos;
+            }
+        };
+        UIPackage.prototype.loadFont = function (item) {
+            var font = new fgui.BitmapFont();
+            item.bitmapFont = font;
+            var buffer = item.rawData;
+            buffer.seek(0, 0);
+            font.ttf = buffer.readBool();
+            font.tint = buffer.readBool();
+            font.resizable = buffer.readBool();
+            buffer.readBool();
+            font.size = buffer.readInt();
+            var xadvance = buffer.readInt();
+            var lineHeight = buffer.readInt();
+            var mainTexture;
+            var mainSprite = this._sprites[item.id];
+            if (mainSprite)
+                mainTexture = (this.getItemAsset(mainSprite.atlas));
+            buffer.seek(0, 1);
+            var bg;
+            var cnt = buffer.readInt();
+            for (var i = 0; i < cnt; i++) {
+                var nextPos = buffer.readShort();
+                nextPos += buffer.position;
+                bg = {};
+                var ch = buffer.readChar();
+                font.glyphs[ch] = bg;
+                var img = buffer.readS();
+                var bx = buffer.readInt();
+                var by = buffer.readInt();
+                bg.x = buffer.readInt();
+                bg.y = buffer.readInt();
+                bg.width = buffer.readInt();
+                bg.height = buffer.readInt();
+                bg.advance = buffer.readInt();
+                bg.channel = buffer.readByte();
+                if (bg.channel == 1)
+                    bg.channel = 3;
+                else if (bg.channel == 2)
+                    bg.channel = 2;
+                else if (bg.channel == 3)
+                    bg.channel = 1;
+                if (font.ttf) {
+                    bg.texture = new egret.Texture();
+                    bg.texture.bitmapData = mainTexture.bitmapData;
+                    bg.texture.$initData(mainTexture.$bitmapX + bx + mainSprite.rect.x, mainTexture.$bitmapY + by + mainSprite.rect.y, bg.width, bg.height, mainSprite.offset.x, mainSprite.offset.y, mainSprite.originalSize.x, mainSprite.originalSize.y, mainTexture.$sourceWidth, mainTexture.$sourceHeight, mainSprite.rotated);
+                    bg.lineHeight = lineHeight;
+                }
+                else {
+                    var charImg = this._itemsById[img];
+                    if (charImg) {
+                        this.getItemAsset(charImg);
+                        bg.width = charImg.width;
+                        bg.height = charImg.height;
+                        bg.texture = charImg.asset;
+                    }
+                    if (bg.advance == 0) {
+                        if (xadvance == 0)
+                            bg.advance = bg.x + bg.width;
+                        else
+                            bg.advance = xadvance;
+                    }
+                    bg.lineHeight = bg.y < 0 ? bg.height : (bg.y + bg.height);
+                    if (bg.lineHeight < font.size)
+                        bg.lineHeight = font.size;
+                }
+                buffer.position = nextPos;
+            }
+        };
+        UIPackage.prototype.loadDragonBones = function (item) {
+            var jsonFile = getAssetResKey(item.file, ["json", "dbbin"]);
+            var str = item.file.replace("_ske", "_tex");
+            var atlasFile = getAssetResKey(str, "json");
+            var texFile = getAssetResKey(str, "png");
+            var task1 = RES.getResAsync(jsonFile);
+            var task2 = RES.getResAsync(atlasFile);
+            var task3 = RES.getResAsync(texFile);
+            Promise.all([task1, task2, task3]).then(function (values) {
+                var egretFactory = dragonBones.EgretFactory.factory;
+                item.asset = egretFactory.parseDragonBonesData(values[0]);
+                item.atlasAsset = egretFactory.parseTextureAtlasData(values[1], values[2]);
+                item.armatureName = item.asset.armatureNames[0];
+                var arr = item.loading;
+                delete item.loading;
+                arr.forEach(function (e) { return e(null, item); });
+            }).catch(function (reason) {
+                var arr = item.loading;
+                delete item.loading;
+                arr.forEach(function (e) { return e(reason, item); });
+            });
+        };
+        UIPackage._constructing = 0;
+        UIPackage._instById = {};
+        UIPackage._instByName = {};
+        UIPackage._branch = "";
+        UIPackage._vars = {};
+        return UIPackage;
+    }());
+    fgui.UIPackage = UIPackage;
+    function getAssetResKey(file, types) {
+        if (Array.isArray(types)) {
+            for (var i = 0; i < types.length; i++) {
+                var key = file + "_" + types[i];
+                if (RES.hasRes(key))
+                    return key;
+            }
+            return file;
+        }
+        else {
+            var key = file + "_" + types;
+            if (RES.hasRes(key))
+                return key;
+            return file;
+        }
+    }
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var Window = (function (_super_1) {
+        __extends(Window, _super_1);
+        function Window() {
+            var _this = _super_1.call(this) || this;
+            _this._requestingCmd = 0;
+            _this._uiSources = new Array();
+            _this.bringToFontOnClick = fgui.UIConfig.bringWindowToFrontOnClick;
+            _this.displayObject.addEventListener(egret.Event.ADDED_TO_STAGE, _this.__onShown, _this);
+            _this.displayObject.addEventListener(egret.Event.REMOVED_FROM_STAGE, _this.__onHidden, _this);
+            _this.displayObject.addEventListener(egret.TouchEvent.TOUCH_BEGIN, _this.__mouseDown, _this, true);
+            return _this;
+        }
+        Window.prototype.addUISource = function (source) {
+            this._uiSources.push(source);
+        };
+        Object.defineProperty(Window.prototype, "contentPane", {
+            get: function () {
+                return this._contentPane;
+            },
+            set: function (val) {
+                if (this._contentPane != val) {
+                    if (this._contentPane)
+                        this.removeChild(this._contentPane);
+                    this._contentPane = val;
+                    if (this._contentPane) {
+                        this.addChild(this._contentPane);
+                        this.setSize(this._contentPane.width, this._contentPane.height);
+                        this._contentPane.addRelation(this, fgui.RelationType.Size);
+                        this._frame = (this._contentPane.getChild("frame"));
+                        if (this._frame) {
+                            this.closeButton = this._frame.getChild("closeButton");
+                            this.dragArea = this._frame.getChild("dragArea");
+                            this.contentArea = this._frame.getChild("contentArea");
+                        }
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Window.prototype, "frame", {
+            get: function () {
+                return this._frame;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Window.prototype, "closeButton", {
+            get: function () {
+                return this._closeButton;
+            },
+            set: function (value) {
+                if (this._closeButton)
+                    this._closeButton.removeClickListener(this.closeEventHandler, this);
+                this._closeButton = value;
+                if (this._closeButton)
+                    this._closeButton.addClickListener(this.closeEventHandler, this);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Window.prototype, "dragArea", {
+            get: function () {
+                return this._dragArea;
+            },
+            set: function (value) {
+                if (this._dragArea != value) {
+                    if (this._dragArea) {
+                        this._dragArea.draggable = false;
+                        this._dragArea.removeEventListener(fgui.DragEvent.DRAG_START, this.__dragStart, this);
+                    }
+                    this._dragArea = value;
+                    if (this._dragArea) {
+                        if ((this._dragArea instanceof fgui.GGraph) && this._dragArea.displayObject == null)
+                            this._dragArea.asGraph.drawRect(0, 0, 0, 0, 0);
+                        this._dragArea.draggable = true;
+                        this._dragArea.addEventListener(fgui.DragEvent.DRAG_START, this.__dragStart, this);
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Window.prototype, "contentArea", {
+            get: function () {
+                return this._contentArea;
+            },
+            set: function (value) {
+                this._contentArea = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Window.prototype.show = function () {
+            fgui.GRoot.inst.showWindow(this);
+        };
+        Window.prototype.showOn = function (root) {
+            root.showWindow(this);
+        };
+        Window.prototype.hide = function () {
+            if (this.isShowing)
+                this.doHideAnimation();
+        };
+        Window.prototype.hideImmediately = function () {
+            var r = (this.parent instanceof fgui.GRoot) ? this.parent : null;
+            if (!r)
+                r = fgui.GRoot.inst;
+            r.hideWindowImmediately(this);
+        };
+        Window.prototype.centerOn = function (r, restraint) {
+            this.setXY(Math.round((r.width - this.width) / 2), Math.round((r.height - this.height) / 2));
+            if (restraint) {
+                this.addRelation(r, fgui.RelationType.Center_Center);
+                this.addRelation(r, fgui.RelationType.Middle_Middle);
+            }
+        };
+        Window.prototype.toggleStatus = function () {
+            if (this.isTop)
+                this.hide();
+            else
+                this.show();
+        };
+        Object.defineProperty(Window.prototype, "isShowing", {
+            get: function () {
+                return this.parent != null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Window.prototype, "isTop", {
+            get: function () {
+                return this.parent != null && this.parent.getChildIndex(this) == this.parent.numChildren - 1;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Window.prototype, "modal", {
+            get: function () {
+                return this._modal;
+            },
+            set: function (val) {
+                this._modal = val;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Window.prototype.bringToFront = function () {
+            this.root.bringToFront(this);
+        };
+        Window.prototype.showModalWait = function (requestingCmd) {
+            if (requestingCmd != undefined)
+                this._requestingCmd = requestingCmd;
+            if (fgui.UIConfig.windowModalWaiting) {
+                if (!this._modalWaitPane)
+                    this._modalWaitPane = fgui.UIPackage.createObjectFromURL(fgui.UIConfig.windowModalWaiting);
+                this.layoutModalWaitPane();
+                this.addChild(this._modalWaitPane);
+            }
+        };
+        Window.prototype.layoutModalWaitPane = function () {
+            if (this._contentArea) {
+                var pt = this._frame.localToGlobal();
+                pt = this.globalToLocal(pt.x, pt.y, pt);
+                this._modalWaitPane.setXY(pt.x + this._contentArea.x, pt.y + this._contentArea.y);
+                this._modalWaitPane.setSize(this._contentArea.width, this._contentArea.height);
+            }
+            else
+                this._modalWaitPane.setSize(this.width, this.height);
+        };
+        Window.prototype.closeModalWait = function (requestingCmd) {
+            if (requestingCmd != null && requestingCmd != 0) {
+                if (this._requestingCmd != requestingCmd)
+                    return false;
+            }
+            this._requestingCmd = 0;
+            if (this._modalWaitPane && this._modalWaitPane.parent != null)
+                this.removeChild(this._modalWaitPane);
+            return true;
+        };
+        Object.defineProperty(Window.prototype, "modalWaiting", {
+            get: function () {
+                return this._modalWaitPane && this._modalWaitPane.parent != null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Window.prototype.init = function () {
+            if (this._inited || this._loading)
+                return;
+            if (this._uiSources.length > 0) {
+                this._loading = false;
+                var cnt = this._uiSources.length;
+                for (var i = 0; i < cnt; i++) {
+                    var lib = this._uiSources[i];
+                    if (!lib.loaded) {
+                        lib.load(this.__uiLoadComplete, this);
+                        this._loading = true;
+                    }
+                }
+                if (!this._loading)
+                    this._init();
+            }
+            else
+                this._init();
+        };
+        Window.prototype.onInit = function () {
+        };
+        Window.prototype.onShown = function () {
+        };
+        Window.prototype.onHide = function () {
+        };
+        Window.prototype.doShowAnimation = function () {
+            this.onShown();
+        };
+        Window.prototype.doHideAnimation = function () {
+            this.hideImmediately();
+        };
+        Window.prototype.__uiLoadComplete = function () {
+            var cnt = this._uiSources.length;
+            for (var i = 0; i < cnt; i++) {
+                var lib = this._uiSources[i];
+                if (!lib.loaded)
+                    return;
+            }
+            this._loading = false;
+            this._init();
+        };
+        Window.prototype._init = function () {
+            this._inited = true;
+            this.onInit();
+            if (this.isShowing)
+                this.doShowAnimation();
+        };
+        Window.prototype.dispose = function () {
+            this.displayObject.removeEventListener(egret.Event.ADDED_TO_STAGE, this.__onShown, this);
+            this.displayObject.removeEventListener(egret.Event.REMOVED_FROM_STAGE, this.__onHidden, this);
+            if (this.parent)
+                this.hideImmediately();
+            _super_1.prototype.dispose.call(this);
+        };
+        Window.prototype.closeEventHandler = function (evt) {
+            this.hide();
+        };
+        Window.prototype.__onShown = function (evt) {
+            if (!this._inited)
+                this.init();
+            else
+                this.doShowAnimation();
+        };
+        Window.prototype.__onHidden = function (evt) {
+            this.closeModalWait();
+            this.onHide();
+        };
+        Window.prototype.__mouseDown = function (evt) {
+            if (this.isShowing && this.bringToFontOnClick)
+                this.bringToFront();
+        };
+        Window.prototype.__dragStart = function (evt) {
+            evt.preventDefault();
+            this.startDrag(evt.touchPointID, evt.stageX, evt.stageY);
+        };
+        return Window;
+    }(fgui.GComponent));
+    fgui.Window = Window;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ControllerAction = (function () {
+        function ControllerAction() {
+        }
+        ControllerAction.createAction = function (type) {
+            switch (type) {
+                case 0:
+                    return new fgui.PlayTransitionAction();
+                case 1:
+                    return new fgui.ChangePageAction();
+            }
+            return null;
+        };
+        ControllerAction.prototype.run = function (controller, prevPage, curPage) {
+            if ((this.fromPage == null || this.fromPage.length == 0 || this.fromPage.indexOf(prevPage) != -1)
+                && (this.toPage == null || this.toPage.length == 0 || this.toPage.indexOf(curPage) != -1))
+                this.enter(controller);
+            else
+                this.leave(controller);
+        };
+        ControllerAction.prototype.enter = function (controller) {
+        };
+        ControllerAction.prototype.leave = function (controller) {
+        };
+        ControllerAction.prototype.setup = function (buffer) {
+            var cnt;
+            var i;
+            cnt = buffer.readShort();
+            this.fromPage = [];
+            for (i = 0; i < cnt; i++)
+                this.fromPage[i] = buffer.readS();
+            cnt = buffer.readShort();
+            this.toPage = [];
+            for (i = 0; i < cnt; i++)
+                this.toPage[i] = buffer.readS();
+        };
+        return ControllerAction;
+    }());
+    fgui.ControllerAction = ControllerAction;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ChangePageAction = (function (_super_1) {
+        __extends(ChangePageAction, _super_1);
+        function ChangePageAction() {
+            return _super_1.call(this) || this;
+        }
+        ChangePageAction.prototype.enter = function (controller) {
+            if (!this.controllerName)
+                return;
+            var gcom;
+            if (this.objectId) {
+                var obj = controller.parent.getChildById(this.objectId);
+                if (obj instanceof fgui.GComponent)
+                    gcom = obj;
+                else
+                    return;
+            }
+            else
+                gcom = controller.parent;
+            if (gcom) {
+                var cc = gcom.getController(this.controllerName);
+                if (cc && cc != controller && !cc.changing) {
+                    if (this.targetPage == "~1") {
+                        if (controller.selectedIndex < cc.pageCount)
+                            cc.selectedIndex = controller.selectedIndex;
+                    }
+                    else if (this.targetPage == "~2")
+                        cc.selectedPage = controller.selectedPage;
+                    else
+                        cc.selectedPageId = this.targetPage;
+                }
+            }
+        };
+        ChangePageAction.prototype.setup = function (buffer) {
+            _super_1.prototype.setup.call(this, buffer);
+            this.objectId = buffer.readS();
+            this.controllerName = buffer.readS();
+            this.targetPage = buffer.readS();
+        };
+        return ChangePageAction;
+    }(fgui.ControllerAction));
+    fgui.ChangePageAction = ChangePageAction;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var PlayTransitionAction = (function (_super_1) {
+        __extends(PlayTransitionAction, _super_1);
+        function PlayTransitionAction() {
+            var _this = _super_1.call(this) || this;
+            _this.playTimes = 1;
+            _this.delay = 0;
+            _this.stopOnExit = false;
+            return _this;
+        }
+        PlayTransitionAction.prototype.enter = function (controller) {
+            var trans = controller.parent.getTransition(this.transitionName);
+            if (trans) {
+                if (this._currentTransition && this._currentTransition.playing)
+                    trans.changePlayTimes(this.playTimes);
+                else
+                    trans.play(null, null, null, this.playTimes, this.delay);
+                this._currentTransition = trans;
+            }
+        };
+        PlayTransitionAction.prototype.leave = function (controller) {
+            if (this.stopOnExit && this._currentTransition) {
+                this._currentTransition.stop();
+                this._currentTransition = null;
+            }
+        };
+        PlayTransitionAction.prototype.setup = function (buffer) {
+            _super_1.prototype.setup.call(this, buffer);
+            this.transitionName = buffer.readS();
+            this.playTimes = buffer.readInt();
+            this.delay = buffer.readFloat();
+            this.stopOnExit = buffer.readBool();
+        };
+        return PlayTransitionAction;
+    }(fgui.ControllerAction));
+    fgui.PlayTransitionAction = PlayTransitionAction;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var BitmapFont = (function () {
+        function BitmapFont() {
+            this.size = 0;
+            this.glyphs = {};
+        }
+        return BitmapFont;
+    }());
+    fgui.BitmapFont = BitmapFont;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    function fillImage(w, h, method, origin, clockwise, amount) {
+        if (amount <= 0)
+            return null;
+        else if (amount >= 0.9999)
+            return [0, 0, w, 0, w, h, 0, h];
+        var points;
+        switch (method) {
+            case fgui.FillMethod.Horizontal:
+                points = fillHorizontal(w, h, origin, amount);
+                break;
+            case fgui.FillMethod.Vertical:
+                points = fillVertical(w, h, origin, amount);
+                break;
+            case fgui.FillMethod.Radial90:
+                points = fillRadial90(w, h, origin, clockwise, amount);
+                break;
+            case fgui.FillMethod.Radial180:
+                points = fillRadial180(w, h, origin, clockwise, amount);
+                break;
+            case fgui.FillMethod.Radial360:
+                points = fillRadial360(w, h, origin, clockwise, amount);
+                break;
+        }
+        return points;
+    }
+    fgui.fillImage = fillImage;
+    function fillHorizontal(w, h, origin, amount) {
+        var w2 = w * amount;
+        if (origin == fgui.FillOrigin.Left || origin == fgui.FillOrigin.Top)
+            return [0, 0, w2, 0, w2, h, 0, h];
+        else
+            return [w, 0, w, h, w - w2, h, w - w2, 0];
+    }
+    function fillVertical(w, h, origin, amount) {
+        var h2 = h * amount;
+        if (origin == fgui.FillOrigin.Left || origin == fgui.FillOrigin.Top)
+            return [0, 0, 0, h2, w, h2, w, 0];
+        else
+            return [0, h, w, h, w, h - h2, 0, h - h2];
+    }
+    function fillRadial90(w, h, origin, clockwise, amount) {
+        if (clockwise && (origin == fgui.FillOrigin.TopRight || origin == fgui.FillOrigin.BottomLeft)
+            || !clockwise && (origin == fgui.FillOrigin.TopLeft || origin == fgui.FillOrigin.BottomRight)) {
+            amount = 1 - amount;
+        }
+        var v, v2, h2;
+        v = Math.tan(Math.PI / 2 * amount);
+        h2 = w * v;
+        v2 = (h2 - h) / h2;
+        var points;
+        switch (origin) {
+            case fgui.FillOrigin.TopLeft:
+                if (clockwise) {
+                    if (h2 <= h)
+                        points = [0, 0, w, h2, w, 0];
+                    else
+                        points = [0, 0, w * (1 - v2), h, w, h, w, 0];
+                }
+                else {
+                    if (h2 <= h)
+                        points = [0, 0, w, h2, w, h, 0, h];
+                    else
+                        points = [0, 0, w * (1 - v2), h, 0, h];
+                }
+                break;
+            case fgui.FillOrigin.TopRight:
+                if (clockwise) {
+                    if (h2 <= h)
+                        points = [w, 0, 0, h2, 0, h, w, h];
+                    else
+                        points = [w, 0, w * v2, h, w, h];
+                }
+                else {
+                    if (h2 <= h)
+                        points = [w, 0, 0, h2, 0, 0];
+                    else
+                        points = [w, 0, w * v2, h, 0, h, 0, 0];
+                }
+                break;
+            case fgui.FillOrigin.BottomLeft:
+                if (clockwise) {
+                    if (h2 <= h)
+                        points = [0, h, w, h - h2, w, 0, 0, 0];
+                    else
+                        points = [0, h, w * (1 - v2), 0, 0, 0];
+                }
+                else {
+                    if (h2 <= h)
+                        points = [0, h, w, h - h2, w, h];
+                    else
+                        points = [0, h, w * (1 - v2), 0, w, 0, w, h];
+                }
+                break;
+            case fgui.FillOrigin.BottomRight:
+                if (clockwise) {
+                    if (h2 <= h)
+                        points = [w, h, 0, h - h2, 0, h];
+                    else
+                        points = [w, h, w * v2, 0, 0, 0, 0, h];
+                }
+                else {
+                    if (h2 <= h)
+                        points = [w, h, 0, h - h2, 0, 0, w, 0];
+                    else
+                        points = [w, h, w * v2, 0, w, 0];
+                }
+                break;
+        }
+        return points;
+    }
+    function movePoints(points, offsetX, offsetY) {
+        var cnt = points.length;
+        for (var i = 0; i < cnt; i += 2) {
+            points[i] += offsetX;
+            points[i + 1] += offsetY;
+        }
+    }
+    function fillRadial180(w, h, origin, clockwise, amount) {
+        var points;
+        switch (origin) {
+            case fgui.FillOrigin.Top:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial90(w / 2, h, clockwise ? fgui.FillOrigin.TopLeft : fgui.FillOrigin.TopRight, clockwise, amount);
+                    if (clockwise)
+                        movePoints(points, w / 2, 0);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial90(w / 2, h, clockwise ? fgui.FillOrigin.TopRight : fgui.FillOrigin.TopLeft, clockwise, amount);
+                    if (clockwise)
+                        points.push(w, h, w, 0);
+                    else {
+                        movePoints(points, w / 2, 0);
+                        points.push(0, h, 0, 0);
+                    }
+                }
+                break;
+            case fgui.FillOrigin.Bottom:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial90(w / 2, h, clockwise ? fgui.FillOrigin.BottomRight : fgui.FillOrigin.BottomLeft, clockwise, amount);
+                    if (!clockwise)
+                        movePoints(points, w / 2, 0);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial90(w / 2, h, clockwise ? fgui.FillOrigin.BottomLeft : fgui.FillOrigin.BottomRight, clockwise, amount);
+                    if (clockwise) {
+                        movePoints(points, w / 2, 0);
+                        points.push(0, 0, 0, h);
+                    }
+                    else
+                        points.push(w, 0, w, h);
+                }
+                break;
+            case fgui.FillOrigin.Left:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial90(w, h / 2, clockwise ? fgui.FillOrigin.BottomLeft : fgui.FillOrigin.TopLeft, clockwise, amount);
+                    if (!clockwise)
+                        movePoints(points, 0, h / 2);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial90(w, h / 2, clockwise ? fgui.FillOrigin.TopLeft : fgui.FillOrigin.BottomLeft, clockwise, amount);
+                    if (clockwise) {
+                        movePoints(points, 0, h / 2);
+                        points.push(w, 0, 0, 0);
+                    }
+                    else
+                        points.push(w, h, 0, h);
+                }
+                break;
+            case fgui.FillOrigin.Right:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial90(w, h / 2, clockwise ? fgui.FillOrigin.TopRight : fgui.FillOrigin.BottomRight, clockwise, amount);
+                    if (clockwise)
+                        movePoints(points, 0, h / 2);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial90(w, h / 2, clockwise ? fgui.FillOrigin.BottomRight : fgui.FillOrigin.TopRight, clockwise, amount);
+                    if (clockwise)
+                        points.push(0, h, w, h);
+                    else {
+                        movePoints(points, 0, h / 2);
+                        points.push(0, 0, w, 0);
+                    }
+                }
+                break;
+        }
+        return points;
+    }
+    function fillRadial360(w, h, origin, clockwise, amount) {
+        var points;
+        switch (origin) {
+            case fgui.FillOrigin.Top:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial180(w / 2, h, clockwise ? fgui.FillOrigin.Left : fgui.FillOrigin.Right, clockwise, amount);
+                    if (clockwise)
+                        movePoints(points, w / 2, 0);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial180(w / 2, h, clockwise ? fgui.FillOrigin.Right : fgui.FillOrigin.Left, clockwise, amount);
+                    if (clockwise)
+                        points.push(w, h, w, 0, w / 2, 0);
+                    else {
+                        movePoints(points, w / 2, 0);
+                        points.push(0, h, 0, 0, w / 2, 0);
+                    }
+                }
+                break;
+            case fgui.FillOrigin.Bottom:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial180(w / 2, h, clockwise ? fgui.FillOrigin.Right : fgui.FillOrigin.Left, clockwise, amount);
+                    if (!clockwise)
+                        movePoints(points, w / 2, 0);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial180(w / 2, h, clockwise ? fgui.FillOrigin.Left : fgui.FillOrigin.Right, clockwise, amount);
+                    if (clockwise) {
+                        movePoints(points, w / 2, 0);
+                        points.push(0, 0, 0, h, w / 2, h);
+                    }
+                    else
+                        points.push(w, 0, w, h, w / 2, h);
+                }
+                break;
+            case fgui.FillOrigin.Left:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial180(w, h / 2, clockwise ? fgui.FillOrigin.Bottom : fgui.FillOrigin.Top, clockwise, amount);
+                    if (!clockwise)
+                        movePoints(points, 0, h / 2);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial180(w, h / 2, clockwise ? fgui.FillOrigin.Top : fgui.FillOrigin.Bottom, clockwise, amount);
+                    if (clockwise) {
+                        movePoints(points, 0, h / 2);
+                        points.push(w, 0, 0, 0, 0, h / 2);
+                    }
+                    else
+                        points.push(w, h, 0, h, 0, h / 2);
+                }
+                break;
+            case fgui.FillOrigin.Right:
+                if (amount <= 0.5) {
+                    amount = amount / 0.5;
+                    points = fillRadial180(w, h / 2, clockwise ? fgui.FillOrigin.Top : fgui.FillOrigin.Bottom, clockwise, amount);
+                    if (clockwise)
+                        movePoints(points, 0, h / 2);
+                }
+                else {
+                    amount = (amount - 0.5) / 0.5;
+                    points = fillRadial180(w, h / 2, clockwise ? fgui.FillOrigin.Bottom : fgui.FillOrigin.Top, clockwise, amount);
+                    if (clockwise)
+                        points.push(0, h, w, h, w, h / 2);
+                    else {
+                        movePoints(points, 0, h / 2);
+                        points.push(0, 0, w, 0, w, h / 2);
+                    }
+                }
+                break;
+        }
+        return points;
+    }
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var Image = (function (_super_1) {
+        __extends(Image, _super_1);
+        function Image() {
+            var _this = _super_1.call(this) || this;
+            _this._fillMethod = 0;
+            _this._fillOrigin = 0;
+            _this._fillAmount = 0;
+            _this._color = 0xFFFFFF;
+            return _this;
+        }
+        Object.defineProperty(Image.prototype, "color", {
+            get: function () {
+                return this._color;
+            },
+            set: function (value) {
+                if (this._color != value) {
+                    this._color = value;
+                    if (this.tint == undefined)
+                        fgui.ToolSet.setColorFilter(this, value);
+                    else
+                        this.tint = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Image.prototype.$setX = function (value) {
+            if (this.mask)
+                this.mask.x = value;
+            return _super_1.prototype.$setX.call(this, value);
+        };
+        Image.prototype.$setY = function (value) {
+            if (this.mask)
+                this.mask.y = value;
+            return _super_1.prototype.$setY.call(this, value);
+        };
+        Object.defineProperty(Image.prototype, "fillMethod", {
+            get: function () {
+                return this._fillMethod;
+            },
+            set: function (value) {
+                if (this._fillMethod != value) {
+                    this._fillMethod = value;
+                    if (this._fillMethod != 0) {
+                        if (!this._mask) {
+                            this._mask = new egret.Shape();
+                            this._mask.touchEnabled = false;
+                        }
+                        this.mask = this._mask;
+                        this._mask.x = this.x;
+                        this._mask.y = this.y;
+                        this.addEventListener(egret.Event.RESIZE, this.markChanged, this);
+                        this.markChanged();
+                    }
+                    else if (this.mask) {
+                        this._mask.graphics.clear();
+                        this.mask = null;
+                        this.removeEventListener(egret.Event.RESIZE, this.markChanged, this);
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Image.prototype, "fillOrigin", {
+            get: function () {
+                return this._fillOrigin;
+            },
+            set: function (value) {
+                if (this._fillOrigin != value) {
+                    this._fillOrigin = value;
+                    if (this._fillMethod != 0)
+                        this.markChanged();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Image.prototype, "fillClockwise", {
+            get: function () {
+                return this._fillClockwise;
+            },
+            set: function (value) {
+                if (this._fillClockwise != value) {
+                    this._fillClockwise = value;
+                    if (this._fillMethod != 0)
+                        this.markChanged();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Image.prototype, "fillAmount", {
+            get: function () {
+                return this._fillAmount;
+            },
+            set: function (value) {
+                if (this._fillAmount != value) {
+                    this._fillAmount = value;
+                    if (this._fillMethod != 0)
+                        this.markChanged();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Image.prototype.markChanged = function () {
+            if (!this._maskDirtyFlag) {
+                this._maskDirtyFlag = true;
+                fgui.GTimers.inst.callLater(this.doFill, this);
+            }
+        };
+        Image.prototype.doFill = function () {
+            this._maskDirtyFlag = false;
+            if (!this._mask.parent && this.parent)
+                this.parent.addChild(this._mask);
+            var w = this.width;
+            var h = this.height;
+            var g = this._mask.graphics;
+            g.clear();
+            if (w == 0 || h == 0)
+                return;
+            var points = fgui.fillImage(w, h, this._fillMethod, this._fillOrigin, this._fillClockwise, this._fillAmount);
+            if (!points)
+                return;
+            g.beginFill(0, 1);
+            fgui.ToolSet.fillPath(g, points, 0, 0);
+            g.endFill();
+        };
+        return Image;
+    }(egret.Bitmap));
+    fgui.Image = Image;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var MovieClip = (function (_super_1) {
+        __extends(MovieClip, _super_1);
+        function MovieClip() {
+            var _this = _super_1.call(this) || this;
+            _this.interval = 0;
+            _this.repeatDelay = 0;
+            _this.timeScale = 1;
+            _this._playing = true;
+            _this._frameCount = 0;
+            _this._frame = 0;
+            _this._start = 0;
+            _this._end = 0;
+            _this._times = 0;
+            _this._endAt = 0;
+            _this._status = 0;
+            _this._frameElapsed = 0;
+            _this._reversed = false;
+            _this._repeatedCount = 0;
+            _this.touchEnabled = false;
+            _this.setPlaySettings();
+            return _this;
+        }
+        Object.defineProperty(MovieClip.prototype, "frames", {
+            get: function () {
+                return this._frames;
+            },
+            set: function (value) {
+                this._frames = value;
+                this.scale9Grid = null;
+                this.fillMode = egret.BitmapFillMode.SCALE;
+                if (this._frames)
+                    this._frameCount = this._frames.length;
+                else
+                    this._frameCount = 0;
+                if (this._end == -1 || this._end > this._frameCount - 1)
+                    this._end = this._frameCount - 1;
+                if (this._endAt == -1 || this._endAt > this._frameCount - 1)
+                    this._endAt = this._frameCount - 1;
+                if (this._frame < 0 || this._frame > this._frameCount - 1)
+                    this._frame = this._frameCount - 1;
+                this.drawFrame();
+                this._frameElapsed = 0;
+                this._repeatedCount = 0;
+                this._reversed = false;
+                this.checkTimer();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieClip.prototype, "frameCount", {
+            get: function () {
+                return this._frameCount;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieClip.prototype, "frame", {
+            get: function () {
+                return this._frame;
+            },
+            set: function (value) {
+                if (this._frame != value) {
+                    if (this._frames && value >= this._frameCount)
+                        value = this._frameCount - 1;
+                    this._frame = value;
+                    this._frameElapsed = 0;
+                    this.drawFrame();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieClip.prototype, "playing", {
+            get: function () {
+                return this._playing;
+            },
+            set: function (value) {
+                if (this._playing != value) {
+                    this._playing = value;
+                    this.checkTimer();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieClip.prototype, "smoothing", {
+            get: function () {
+                return this._smoothing;
+            },
+            set: function (value) {
+                this._smoothing = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        MovieClip.prototype.rewind = function () {
+            this._frame = 0;
+            this._frameElapsed = 0;
+            this._reversed = false;
+            this._repeatedCount = 0;
+            this.drawFrame();
+        };
+        MovieClip.prototype.syncStatus = function (anotherMc) {
+            this._frame = anotherMc._frame;
+            this._frameElapsed = anotherMc._frameElapsed;
+            this._reversed = anotherMc._reversed;
+            this._repeatedCount = anotherMc._repeatedCount;
+            this.drawFrame();
+        };
+        MovieClip.prototype.advance = function (timeInMiniseconds) {
+            var beginFrame = this._frame;
+            var beginReversed = this._reversed;
+            var backupTime = timeInMiniseconds;
+            while (true) {
+                var tt = this.interval + this._frames[this._frame].addDelay;
+                if (this._frame == 0 && this._repeatedCount > 0)
+                    tt += this.repeatDelay;
+                if (timeInMiniseconds < tt) {
+                    this._frameElapsed = 0;
+                    break;
+                }
+                timeInMiniseconds -= tt;
+                if (this.swing) {
+                    if (this._reversed) {
+                        this._frame--;
+                        if (this._frame <= 0) {
+                            this._frame = 0;
+                            this._repeatedCount++;
+                            this._reversed = !this._reversed;
+                        }
+                    }
+                    else {
+                        this._frame++;
+                        if (this._frame > this._frameCount - 1) {
+                            this._frame = Math.max(0, this._frameCount - 2);
+                            this._repeatedCount++;
+                            this._reversed = !this._reversed;
+                        }
+                    }
+                }
+                else {
+                    this._frame++;
+                    if (this._frame > this._frameCount - 1) {
+                        this._frame = 0;
+                        this._repeatedCount++;
+                    }
+                }
+                if (this._frame == beginFrame && this._reversed == beginReversed) {
+                    var roundTime = backupTime - timeInMiniseconds;
+                    timeInMiniseconds -= Math.floor(timeInMiniseconds / roundTime) * roundTime;
+                }
+            }
+            this.drawFrame();
+        };
+        MovieClip.prototype.setPlaySettings = function (start, end, times, endAt, endCallback, callbackObj) {
+            if (start == undefined)
+                start = 0;
+            if (end == undefined)
+                end = -1;
+            if (times == undefined)
+                times = 0;
+            if (endAt == undefined)
+                endAt = -1;
+            this._start = start;
+            this._end = end;
+            if (this._end == -1 || this._end > this._frameCount - 1)
+                this._end = this._frameCount - 1;
+            this._times = times;
+            this._endAt = endAt;
+            if (this._endAt == -1)
+                this._endAt = this._end;
+            this._status = 0;
+            this._callback = endCallback;
+            this._callbackObj = callbackObj;
+            this.frame = start;
+        };
+        MovieClip.prototype.update = function () {
+            if (!this._playing || this._frameCount == 0 || this._status == 3)
+                return;
+            var dt = fgui.GTimers.deltaTime;
+            if (this.timeScale != 1)
+                dt *= this.timeScale;
+            this._frameElapsed += dt;
+            var tt = this.interval + this._frames[this._frame].addDelay;
+            if (this._frame == 0 && this._repeatedCount > 0)
+                tt += this.repeatDelay;
+            if (this._frameElapsed < tt)
+                return;
+            this._frameElapsed -= tt;
+            if (this._frameElapsed > this.interval)
+                this._frameElapsed = this.interval;
+            if (this.swing) {
+                if (this._reversed) {
+                    this._frame--;
+                    if (this._frame <= 0) {
+                        this._frame = 0;
+                        this._repeatedCount++;
+                        this._reversed = !this._reversed;
+                    }
+                }
+                else {
+                    this._frame++;
+                    if (this._frame > this._frameCount - 1) {
+                        this._frame = Math.max(0, this._frameCount - 2);
+                        this._repeatedCount++;
+                        this._reversed = !this._reversed;
+                    }
+                }
+            }
+            else {
+                this._frame++;
+                if (this._frame > this._frameCount - 1) {
+                    this._frame = 0;
+                    this._repeatedCount++;
+                }
+            }
+            if (this._status == 1) {
+                this._frame = this._start;
+                this._frameElapsed = 0;
+                this._status = 0;
+            }
+            else if (this._status == 2) {
+                this._frame = this._endAt;
+                this._frameElapsed = 0;
+                this._status = 3;
+                if (this._callback != null) {
+                    var callback = this._callback;
+                    var caller = this._callbackObj;
+                    this._callback = null;
+                    this._callbackObj = null;
+                    callback.call(caller);
+                }
+            }
+            else {
+                if (this._frame == this._end) {
+                    if (this._times > 0) {
+                        this._times--;
+                        if (this._times == 0)
+                            this._status = 2;
+                        else
+                            this._status = 1;
+                    }
+                    else if (this._start != 0)
+                        this._status = 1;
+                }
+            }
+            this.drawFrame();
+        };
+        MovieClip.prototype.drawFrame = function () {
+            if (this._frameCount > 0 && this._frame < this._frames.length) {
+                var frame = this._frames[this._frame];
+                this.texture = frame.texture;
+            }
+            else
+                this.texture = null;
+        };
+        MovieClip.prototype.checkTimer = function () {
+            if (this._playing && this._frameCount > 0 && this.stage != null)
+                fgui.GTimers.inst.add(1, 0, this.update, this);
+            else
+                fgui.GTimers.inst.remove(this.update, this);
+        };
+        MovieClip.prototype.$onAddToStage = function (stage, nestLevel) {
+            _super_1.prototype.$onAddToStage.call(this, stage, nestLevel);
+            if (this._playing && this._frameCount > 0)
+                fgui.GTimers.inst.add(1, 0, this.update, this);
+        };
+        MovieClip.prototype.$onRemoveFromStage = function () {
+            _super_1.prototype.$onRemoveFromStage.call(this);
+            fgui.GTimers.inst.remove(this.update, this);
+        };
+        return MovieClip;
+    }(fgui.Image));
+    fgui.MovieClip = MovieClip;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var UIContainer = (function (_super_1) {
+        __extends(UIContainer, _super_1);
+        function UIContainer() {
+            var _this = _super_1.call(this) || this;
+            _this.touchEnabled = true;
+            _this.touchChildren = true;
+            return _this;
+        }
+        UIContainer.prototype.cacheHitArea = function (value) {
+            this._cachedHitArea = value;
+            if (value) {
+                if (!this._cachedMatrix)
+                    this._cachedMatrix = new egret.Matrix();
+                this._cachedMatrix.copyFrom(this.$getInvertedConcatenatedMatrix());
+            }
+        };
+        Object.defineProperty(UIContainer.prototype, "hitArea", {
+            get: function () {
+                return this._hitArea;
+            },
+            set: function (value) {
+                this._hitArea = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(UIContainer.prototype, "opaque", {
+            get: function () {
+                return this._opaque;
+            },
+            set: function (value) {
+                this._opaque = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        UIContainer.prototype.$hitTest = function (stageX, stageY) {
+            if (!this.$visible)
+                return null;
+            if (this._hitArea) {
+                if (!this.touchEnabled)
+                    return null;
+                if (this._hitArea.$graphics) {
+                    if (!this._hitArea.$graphics.$hitTest(stageX, stageY))
+                        return null;
+                }
+                else {
+                    var m = this._cachedHitArea ? this._cachedMatrix : this.$getInvertedConcatenatedMatrix();
+                    var localX = m.a * stageX + m.c * stageY + m.tx;
+                    var localY = m.b * stageX + m.d * stageY + m.ty;
+                    if (!this._hitArea.contains(localX, localY))
+                        return null;
+                }
+                return this;
+            }
+            var ret = _super_1.prototype.$hitTest.call(this, stageX, stageY);
+            if (ret == this && !this.touchEnabled)
+                return null;
+            if (ret == null && this._opaque) {
+                var m = this._cachedHitArea ? this._cachedMatrix : this.$getInvertedConcatenatedMatrix();
+                var localX = m.a * stageX + m.c * stageY + m.tx;
+                var localY = m.b * stageX + m.d * stageY + m.ty;
+                if (localX >= 0 && localY >= 0 && localX <= this.$explicitWidth && localY <= this.$explicitHeight)
+                    return this;
+                else
+                    return null;
+            }
+            else if (ret == this && !this._opaque)
+                return null;
+            else
+                return ret;
+        };
+        return UIContainer;
+    }(egret.DisplayObjectContainer));
+    fgui.UIContainer = UIContainer;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var DragEvent = (function (_super_1) {
+        __extends(DragEvent, _super_1);
+        function DragEvent(type, stageX, stageY, touchPointID) {
+            if (stageX === void 0) { stageX = 0; }
+            if (stageY === void 0) { stageY = 0; }
+            if (touchPointID === void 0) { touchPointID = -1; }
+            var _this = _super_1.call(this, type, false) || this;
+            _this.touchPointID = 0;
+            _this.stageX = stageX;
+            _this.stageY = stageY;
+            _this.touchPointID = touchPointID;
+            return _this;
+        }
+        DragEvent.prototype.preventDefault = function () {
+            this._prevented = true;
+        };
+        DragEvent.prototype.isDefaultPrevented = function () {
+            return this._prevented;
+        };
+        DragEvent.DRAG_START = "__dragStart";
+        DragEvent.DRAG_END = "__dragEnd";
+        DragEvent.DRAG_MOVING = "__dragMoving";
+        return DragEvent;
+    }(egret.Event));
+    fgui.DragEvent = DragEvent;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var DropEvent = (function (_super_1) {
+        __extends(DropEvent, _super_1);
+        function DropEvent(type, source) {
+            var _this = _super_1.call(this, type, false) || this;
+            _this.source = source;
+            return _this;
+        }
+        DropEvent.DROP = "__drop";
+        return DropEvent;
+    }(egret.Event));
+    fgui.DropEvent = DropEvent;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ItemEvent = (function (_super_1) {
+        __extends(ItemEvent, _super_1);
+        function ItemEvent(type, itemObject, stageX, stageY) {
+            if (itemObject === void 0) { itemObject = null; }
+            if (stageX === void 0) { stageX = 0; }
+            if (stageY === void 0) { stageY = 0; }
+            var _this = _super_1.call(this, type, false) || this;
+            _this.itemObject = itemObject;
+            _this.stageX = stageX;
+            _this.stageY = stageY;
+            return _this;
+        }
+        ItemEvent.CLICK = "___itemClick";
+        return ItemEvent;
+    }(egret.Event));
+    fgui.ItemEvent = ItemEvent;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var StateChangeEvent = (function (_super_1) {
+        __extends(StateChangeEvent, _super_1);
+        function StateChangeEvent(type) {
+            return _super_1.call(this, type, false) || this;
+        }
+        StateChangeEvent.CHANGED = "___stateChanged";
+        return StateChangeEvent;
+    }(egret.Event));
+    fgui.StateChangeEvent = StateChangeEvent;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearBase = (function () {
+        function GearBase(owner) {
+            this._owner = owner;
+        }
+        GearBase.create = function (owner, index) {
+            if (!Classes)
+                Classes = [
+                    fgui.GearDisplay, fgui.GearXY, fgui.GearSize, fgui.GearLook, fgui.GearColor,
+                    fgui.GearAnimation, fgui.GearText, fgui.GearIcon, fgui.GearDisplay2, fgui.GearFontSize
+                ];
+            return new (Classes[index])(owner);
+        };
+        GearBase.prototype.dispose = function () {
+            if (this._tweenConfig && this._tweenConfig._tweener) {
+                this._tweenConfig._tweener.kill();
+                this._tweenConfig._tweener = null;
+            }
+        };
+        Object.defineProperty(GearBase.prototype, "controller", {
+            get: function () {
+                return this._controller;
+            },
+            set: function (val) {
+                if (val != this._controller) {
+                    this._controller = val;
+                    if (this._controller)
+                        this.init();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GearBase.prototype, "tweenConfig", {
+            get: function () {
+                if (!this._tweenConfig)
+                    this._tweenConfig = new GearTweenConfig();
+                return this._tweenConfig;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GearBase.prototype.setup = function (buffer) {
+            this._controller = this._owner.parent.getControllerAt(buffer.readShort());
+            this.init();
+            var i;
+            var page;
+            var cnt = buffer.readShort();
+            if (this instanceof fgui.GearDisplay) {
+                this.pages = buffer.readSArray(cnt);
+            }
+            else if (this instanceof fgui.GearDisplay2) {
+                this.pages = buffer.readSArray(cnt);
+            }
+            else {
+                for (i = 0; i < cnt; i++) {
+                    page = buffer.readS();
+                    if (page == null)
+                        continue;
+                    this.addStatus(page, buffer);
+                }
+                if (buffer.readBool())
+                    this.addStatus(null, buffer);
+            }
+            if (buffer.readBool()) {
+                this._tweenConfig = new GearTweenConfig();
+                this._tweenConfig.easeType = buffer.readByte();
+                this._tweenConfig.duration = buffer.readFloat();
+                this._tweenConfig.delay = buffer.readFloat();
+            }
+            if (buffer.version >= 2) {
+                if (this instanceof fgui.GearXY) {
+                    if (buffer.readBool()) {
+                        this.positionsInPercent = true;
+                        for (i = 0; i < cnt; i++) {
+                            page = buffer.readS();
+                            if (page == null)
+                                continue;
+                            this.addExtStatus(page, buffer);
+                        }
+                        if (buffer.readBool())
+                            this.addExtStatus(null, buffer);
+                    }
+                }
+                else if (this instanceof fgui.GearDisplay2)
+                    this.condition = buffer.readByte();
+            }
+        };
+        GearBase.prototype.updateFromRelations = function (dx, dy) {
+        };
+        GearBase.prototype.addStatus = function (pageId, buffer) {
+        };
+        GearBase.prototype.init = function () {
+        };
+        GearBase.prototype.apply = function () {
+        };
+        GearBase.prototype.updateState = function () {
+        };
+        return GearBase;
+    }());
+    fgui.GearBase = GearBase;
+    var Classes;
+    var GearTweenConfig = (function () {
+        function GearTweenConfig() {
+            this.tween = true;
+            this.easeType = fgui.EaseType.QuadOut;
+            this.duration = 0.3;
+            this.delay = 0;
+        }
+        return GearTweenConfig;
+    }());
+    fgui.GearTweenConfig = GearTweenConfig;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearAnimation = (function (_super_1) {
+        __extends(GearAnimation, _super_1);
+        function GearAnimation(owner) {
+            return _super_1.call(this, owner) || this;
+        }
+        GearAnimation.prototype.init = function () {
+            this._default = {
+                playing: this._owner.getProp(fgui.ObjectPropID.Playing),
+                frame: this._owner.getProp(fgui.ObjectPropID.Frame)
+            };
+            this._storage = {};
+        };
+        GearAnimation.prototype.addStatus = function (pageId, buffer) {
+            var gv;
+            if (pageId == null)
+                gv = this._default;
+            else
+                this._storage[pageId] = gv = {};
+            gv.playing = buffer.readBool();
+            gv.frame = buffer.readInt();
+        };
+        GearAnimation.prototype.apply = function () {
+            this._owner._gearLocked = true;
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                gv = this._default;
+            this._owner.setProp(fgui.ObjectPropID.Playing, gv.playing);
+            this._owner.setProp(fgui.ObjectPropID.Frame, gv.frame);
+            this._owner._gearLocked = false;
+        };
+        GearAnimation.prototype.updateState = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                this._storage[this._controller.selectedPageId] = gv = {};
+            gv.playing = this._owner.getProp(fgui.ObjectPropID.Playing);
+            gv.frame = this._owner.getProp(fgui.ObjectPropID.Frame);
+        };
+        return GearAnimation;
+    }(fgui.GearBase));
+    fgui.GearAnimation = GearAnimation;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearColor = (function (_super_1) {
+        __extends(GearColor, _super_1);
+        function GearColor(owner) {
+            return _super_1.call(this, owner) || this;
+        }
+        GearColor.prototype.init = function () {
+            this._default = {
+                color: this._owner.getProp(fgui.ObjectPropID.Color),
+                strokeColor: this._owner.getProp(fgui.ObjectPropID.OutlineColor)
+            };
+            this._storage = {};
+        };
+        GearColor.prototype.addStatus = function (pageId, buffer) {
+            var gv;
+            if (pageId == null)
+                gv = this._default;
+            else
+                this._storage[pageId] = gv = {};
+            gv.color = buffer.readColor();
+            gv.strokeColor = buffer.readColor();
+        };
+        GearColor.prototype.apply = function () {
+            this._owner._gearLocked = true;
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                gv = this._default;
+            this._owner.setProp(fgui.ObjectPropID.Color, gv.color);
+            this._owner.setProp(fgui.ObjectPropID.OutlineColor, gv.strokeColor);
+            this._owner._gearLocked = false;
+        };
+        GearColor.prototype.updateState = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                this._storage[this._controller.selectedPageId] = gv = {};
+            gv.color = this._owner.getProp(fgui.ObjectPropID.Color);
+            gv.strokeColor = this._owner.getProp(fgui.ObjectPropID.OutlineColor);
+        };
+        return GearColor;
+    }(fgui.GearBase));
+    fgui.GearColor = GearColor;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearDisplay = (function (_super_1) {
+        __extends(GearDisplay, _super_1);
+        function GearDisplay(owner) {
+            var _this = _super_1.call(this, owner) || this;
+            _this._displayLockToken = 1;
+            _this._visible = 0;
+            return _this;
+        }
+        GearDisplay.prototype.init = function () {
+            this.pages = null;
+        };
+        GearDisplay.prototype.apply = function () {
+            this._displayLockToken++;
+            if (this._displayLockToken == 0)
+                this._displayLockToken = 1;
+            if (this.pages == null || this.pages.length == 0
+                || this.pages.indexOf(this._controller.selectedPageId) != -1)
+                this._visible = 1;
+            else
+                this._visible = 0;
+        };
+        GearDisplay.prototype.addLock = function () {
+            this._visible++;
+            return this._displayLockToken;
+        };
+        GearDisplay.prototype.releaseLock = function (token) {
+            if (token == this._displayLockToken)
+                this._visible--;
+        };
+        Object.defineProperty(GearDisplay.prototype, "connected", {
+            get: function () {
+                return this._controller == null || this._visible > 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return GearDisplay;
+    }(fgui.GearBase));
+    fgui.GearDisplay = GearDisplay;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearDisplay2 = (function (_super_1) {
+        __extends(GearDisplay2, _super_1);
+        function GearDisplay2(owner) {
+            var _this = _super_1.call(this, owner) || this;
+            _this._visible = 0;
+            return _this;
+        }
+        GearDisplay2.prototype.init = function () {
+            this.pages = null;
+        };
+        GearDisplay2.prototype.apply = function () {
+            if (this.pages == null || this.pages.length == 0
+                || this.pages.indexOf(this._controller.selectedPageId) != -1)
+                this._visible = 1;
+            else
+                this._visible = 0;
+        };
+        GearDisplay2.prototype.evaluate = function (connected) {
+            var v = this._controller == null || this._visible > 0;
+            if (this.condition == 0)
+                v = v && connected;
+            else
+                v = v || connected;
+            return v;
+        };
+        return GearDisplay2;
+    }(fgui.GearBase));
+    fgui.GearDisplay2 = GearDisplay2;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearFontSize = (function (_super_1) {
+        __extends(GearFontSize, _super_1);
+        function GearFontSize(owner) {
+            var _this = _super_1.call(this, owner) || this;
+            _this._default = 0;
+            return _this;
+        }
+        GearFontSize.prototype.init = function () {
+            this._default = this._owner.getProp(fgui.ObjectPropID.FontSize);
+            this._storage = {};
+        };
+        GearFontSize.prototype.addStatus = function (pageId, buffer) {
+            if (pageId == null)
+                this._default = buffer.readInt();
+            else
+                this._storage[pageId] = buffer.readInt();
+        };
+        GearFontSize.prototype.apply = function () {
+            this._owner._gearLocked = true;
+            var data = this._storage[this._controller.selectedPageId];
+            if (data != undefined)
+                this._owner.setProp(fgui.ObjectPropID.FontSize, data);
+            else
+                this._owner.setProp(fgui.ObjectPropID.FontSize, this._default);
+            this._owner._gearLocked = false;
+        };
+        GearFontSize.prototype.updateState = function () {
+            this._storage[this._controller.selectedPageId] = this._owner.getProp(fgui.ObjectPropID.FontSize);
+        };
+        return GearFontSize;
+    }(fgui.GearBase));
+    fgui.GearFontSize = GearFontSize;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearIcon = (function (_super_1) {
+        __extends(GearIcon, _super_1);
+        function GearIcon(owner) {
+            return _super_1.call(this, owner) || this;
+        }
+        GearIcon.prototype.init = function () {
+            this._default = this._owner.icon;
+            this._storage = {};
+        };
+        GearIcon.prototype.addStatus = function (pageId, buffer) {
+            if (pageId == null)
+                this._default = buffer.readS();
+            else
+                this._storage[pageId] = buffer.readS();
+        };
+        GearIcon.prototype.apply = function () {
+            this._owner._gearLocked = true;
+            var data = this._storage[this._controller.selectedPageId];
+            if (data !== undefined)
+                this._owner.icon = data;
+            else
+                this._owner.icon = this._default;
+            this._owner._gearLocked = false;
+        };
+        GearIcon.prototype.updateState = function () {
+            this._storage[this._controller.selectedPageId] = this._owner.icon;
+        };
+        return GearIcon;
+    }(fgui.GearBase));
+    fgui.GearIcon = GearIcon;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearLook = (function (_super_1) {
+        __extends(GearLook, _super_1);
+        function GearLook(owner) {
+            return _super_1.call(this, owner) || this;
+        }
+        GearLook.prototype.init = function () {
+            this._default = {
+                alpha: this._owner.alpha,
+                rotation: this._owner.rotation,
+                grayed: this._owner.grayed,
+                touchable: this._owner.touchable
+            };
+            this._storage = {};
+        };
+        GearLook.prototype.addStatus = function (pageId, buffer) {
+            var gv;
+            if (pageId == null)
+                gv = this._default;
+            else
+                this._storage[pageId] = gv = {};
+            gv.alpha = buffer.readFloat();
+            gv.rotation = buffer.readFloat();
+            gv.grayed = buffer.readBool();
+            gv.touchable = buffer.readBool();
+        };
+        GearLook.prototype.apply = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                gv = this._default;
+            if (this._tweenConfig && this._tweenConfig.tween && !fgui.UIPackage._constructing && !fgui.GearBase.disableAllTweenEffect) {
+                this._owner._gearLocked = true;
+                this._owner.grayed = gv.grayed;
+                this._owner.touchable = gv.touchable;
+                this._owner._gearLocked = false;
+                if (this._tweenConfig._tweener) {
+                    if (this._tweenConfig._tweener.endValue.x != gv.alpha || this._tweenConfig._tweener.endValue.y != gv.rotation) {
+                        this._tweenConfig._tweener.kill(true);
+                        this._tweenConfig._tweener = null;
+                    }
+                    else
+                        return;
+                }
+                var a = gv.alpha != this._owner.alpha;
+                var b = gv.rotation != this._owner.rotation;
+                if (a || b) {
+                    if (this._owner.checkGearController(0, this._controller))
+                        this._tweenConfig._displayLockToken = this._owner.addDisplayLock();
+                    this._tweenConfig._tweener = fgui.GTween.to2(this._owner.alpha, this._owner.rotation, gv.alpha, gv.rotation, this._tweenConfig.duration)
+                        .setDelay(this._tweenConfig.delay)
+                        .setEase(this._tweenConfig.easeType)
+                        .setUserData((a ? 1 : 0) + (b ? 2 : 0))
+                        .setTarget(this)
+                        .onUpdate(this.__tweenUpdate, this)
+                        .onComplete(this.__tweenComplete, this);
+                }
+            }
+            else {
+                this._owner._gearLocked = true;
+                this._owner.grayed = gv.grayed;
+                this._owner.touchable = gv.touchable;
+                this._owner.alpha = gv.alpha;
+                this._owner.rotation = gv.rotation;
+                this._owner._gearLocked = false;
+            }
+        };
+        GearLook.prototype.__tweenUpdate = function (tweener) {
+            var flag = tweener.userData;
+            this._owner._gearLocked = true;
+            if ((flag & 1) != 0)
+                this._owner.alpha = tweener.value.x;
+            if ((flag & 2) != 0)
+                this._owner.rotation = tweener.value.y;
+            this._owner._gearLocked = false;
+        };
+        GearLook.prototype.__tweenComplete = function () {
+            if (this._tweenConfig._displayLockToken != 0) {
+                this._owner.releaseDisplayLock(this._tweenConfig._displayLockToken);
+                this._tweenConfig._displayLockToken = 0;
+            }
+            this._tweenConfig._tweener = null;
+        };
+        GearLook.prototype.updateState = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                this._storage[this._controller.selectedPageId] = gv = {};
+            gv.alpha = this._owner.alpha;
+            gv.rotation = this._owner.rotation;
+            gv.grayed = this._owner.grayed;
+            gv.touchable = this._owner.touchable;
+        };
+        return GearLook;
+    }(fgui.GearBase));
+    fgui.GearLook = GearLook;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearSize = (function (_super_1) {
+        __extends(GearSize, _super_1);
+        function GearSize(owner) {
+            return _super_1.call(this, owner) || this;
+        }
+        GearSize.prototype.init = function () {
+            this._default = {
+                width: this._owner.width,
+                height: this._owner.height,
+                scaleX: this._owner.scaleX,
+                scaleY: this._owner.scaleY
+            };
+            this._storage = {};
+        };
+        GearSize.prototype.addStatus = function (pageId, buffer) {
+            var gv;
+            if (pageId == null)
+                gv = this._default;
+            else
+                this._storage[pageId] = gv = {};
+            gv.width = buffer.readInt();
+            gv.height = buffer.readInt();
+            gv.scaleX = buffer.readFloat();
+            gv.scaleY = buffer.readFloat();
+        };
+        GearSize.prototype.apply = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                gv = this._default;
+            if (this._tweenConfig && this._tweenConfig.tween && !fgui.UIPackage._constructing && !fgui.GearBase.disableAllTweenEffect) {
+                if (this._tweenConfig._tweener) {
+                    if (this._tweenConfig._tweener.endValue.x != gv.width || this._tweenConfig._tweener.endValue.y != gv.height
+                        || this._tweenConfig._tweener.endValue.z != gv.scaleX || this._tweenConfig._tweener.endValue.w != gv.scaleY) {
+                        this._tweenConfig._tweener.kill(true);
+                        this._tweenConfig._tweener = null;
+                    }
+                    else
+                        return;
+                }
+                var a = gv.width != this._owner.width || gv.height != this._owner.height;
+                var b = gv.scaleX != this._owner.scaleX || gv.scaleY != this._owner.scaleY;
+                if (a || b) {
+                    if (this._owner.checkGearController(0, this._controller))
+                        this._tweenConfig._displayLockToken = this._owner.addDisplayLock();
+                    this._tweenConfig._tweener = fgui.GTween.to4(this._owner.width, this._owner.height, this._owner.scaleX, this._owner.scaleY, gv.width, gv.height, gv.scaleX, gv.scaleY, this._tweenConfig.duration)
+                        .setDelay(this._tweenConfig.delay)
+                        .setEase(this._tweenConfig.easeType)
+                        .setUserData((a ? 1 : 0) + (b ? 2 : 0))
+                        .setTarget(this)
+                        .onUpdate(this.__tweenUpdate, this)
+                        .onComplete(this.__tweenComplete, this);
+                }
+            }
+            else {
+                this._owner._gearLocked = true;
+                this._owner.setSize(gv.width, gv.height, this._owner.gearXY.controller == this._controller);
+                this._owner.setScale(gv.scaleX, gv.scaleY);
+                this._owner._gearLocked = false;
+            }
+        };
+        GearSize.prototype.__tweenUpdate = function (tweener) {
+            var flag = tweener.userData;
+            this._owner._gearLocked = true;
+            if ((flag & 1) != 0)
+                this._owner.setSize(tweener.value.x, tweener.value.y, this._owner.checkGearController(1, this._controller));
+            if ((flag & 2) != 0)
+                this._owner.setScale(tweener.value.z, tweener.value.w);
+            this._owner._gearLocked = false;
+        };
+        GearSize.prototype.__tweenComplete = function () {
+            if (this._tweenConfig._displayLockToken != 0) {
+                this._owner.releaseDisplayLock(this._tweenConfig._displayLockToken);
+                this._tweenConfig._displayLockToken = 0;
+            }
+            this._tweenConfig._tweener = null;
+        };
+        GearSize.prototype.updateState = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                this._storage[this._controller.selectedPageId] = gv = {};
+            gv.width = this._owner.width;
+            gv.height = this._owner.height;
+            gv.scaleX = this._owner.scaleX;
+            gv.scaleY = this._owner.scaleY;
+        };
+        GearSize.prototype.updateFromRelations = function (dx, dy) {
+            if (this._controller == null || this._storage == null)
+                return;
+            for (var key in this._storage) {
+                var gv = this._storage[key];
+                gv.width += dx;
+                gv.height += dy;
+            }
+            this._default.width += dx;
+            this._default.height += dy;
+            this.updateState();
+        };
+        return GearSize;
+    }(fgui.GearBase));
+    fgui.GearSize = GearSize;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearText = (function (_super_1) {
+        __extends(GearText, _super_1);
+        function GearText(owner) {
+            return _super_1.call(this, owner) || this;
+        }
+        GearText.prototype.init = function () {
+            this._default = this._owner.text;
+            this._storage = {};
+        };
+        GearText.prototype.addStatus = function (pageId, buffer) {
+            if (pageId == null)
+                this._default = buffer.readS();
+            else
+                this._storage[pageId] = buffer.readS();
+        };
+        GearText.prototype.apply = function () {
+            this._owner._gearLocked = true;
+            var data = this._storage[this._controller.selectedPageId];
+            if (data !== undefined)
+                this._owner.text = data;
+            else
+                this._owner.text = this._default;
+            this._owner._gearLocked = false;
+        };
+        GearText.prototype.updateState = function () {
+            this._storage[this._controller.selectedPageId] = this._owner.text;
+        };
+        return GearText;
+    }(fgui.GearBase));
+    fgui.GearText = GearText;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GearXY = (function (_super_1) {
+        __extends(GearXY, _super_1);
+        function GearXY(owner) {
+            return _super_1.call(this, owner) || this;
+        }
+        GearXY.prototype.init = function () {
+            this._default = {
+                x: this._owner.x,
+                y: this._owner.y,
+                px: this._owner.x / this._owner.parent.width,
+                py: this._owner.y / this._owner.parent.height
+            };
+            this._storage = {};
+        };
+        GearXY.prototype.addStatus = function (pageId, buffer) {
+            var gv;
+            if (pageId == null)
+                gv = this._default;
+            else
+                this._storage[pageId] = gv = {};
+            gv.x = buffer.readInt();
+            gv.y = buffer.readInt();
+        };
+        GearXY.prototype.addExtStatus = function (pageId, buffer) {
+            var gv;
+            if (pageId == null)
+                gv = this._default;
+            else
+                gv = this._storage[pageId];
+            gv.px = buffer.readFloat();
+            gv.py = buffer.readFloat();
+        };
+        GearXY.prototype.apply = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                gv = this._default;
+            var ex;
+            var ey;
+            if (this.positionsInPercent && this._owner.parent) {
+                ex = gv.px * this._owner.parent.width;
+                ey = gv.py * this._owner.parent.height;
+            }
+            else {
+                ex = gv.x;
+                ey = gv.y;
+            }
+            if (this._tweenConfig && this._tweenConfig.tween && !fgui.UIPackage._constructing && !fgui.GearBase.disableAllTweenEffect) {
+                if (this._tweenConfig._tweener) {
+                    if (this._tweenConfig._tweener.endValue.x != ex || this._tweenConfig._tweener.endValue.y != ey) {
+                        this._tweenConfig._tweener.kill(true);
+                        this._tweenConfig._tweener = null;
+                    }
+                    else
+                        return;
+                }
+                var ox = this._owner.x;
+                var oy = this._owner.y;
+                if (ox != ex || oy != ey) {
+                    if (this._owner.checkGearController(0, this._controller))
+                        this._tweenConfig._displayLockToken = this._owner.addDisplayLock();
+                    this._tweenConfig._tweener = fgui.GTween.to2(ox, oy, ex, ey, this._tweenConfig.duration)
+                        .setDelay(this._tweenConfig.delay)
+                        .setEase(this._tweenConfig.easeType)
+                        .setTarget(this)
+                        .onUpdate(this.__tweenUpdate, this)
+                        .onComplete(this.__tweenComplete, this);
+                }
+            }
+            else {
+                this._owner._gearLocked = true;
+                this._owner.setXY(ex, ey);
+                this._owner._gearLocked = false;
+            }
+        };
+        GearXY.prototype.__tweenUpdate = function (tweener) {
+            this._owner._gearLocked = true;
+            this._owner.setXY(tweener.value.x, tweener.value.y);
+            this._owner._gearLocked = false;
+        };
+        GearXY.prototype.__tweenComplete = function () {
+            if (this._tweenConfig._displayLockToken != 0) {
+                this._owner.releaseDisplayLock(this._tweenConfig._displayLockToken);
+                this._tweenConfig._displayLockToken = 0;
+            }
+            this._tweenConfig._tweener = null;
+        };
+        GearXY.prototype.updateState = function () {
+            var gv = this._storage[this._controller.selectedPageId];
+            if (!gv)
+                this._storage[this._controller.selectedPageId] = gv = {};
+            gv.x = this._owner.x;
+            gv.y = this._owner.y;
+            gv.px = this._owner.x / this._owner.parent.width;
+            gv.py = this._owner.y / this._owner.parent.height;
+        };
+        GearXY.prototype.updateFromRelations = function (dx, dy) {
+            if (this._controller == null || this._storage == null || this.positionsInPercent)
+                return;
+            for (var key in this._storage) {
+                var pt = this._storage[key];
+                pt.x += dx;
+                pt.y += dy;
+            }
+            this._default.x += dx;
+            this._default.y += dy;
+            this.updateState();
+        };
+        return GearXY;
+    }(fgui.GearBase));
+    fgui.GearXY = GearXY;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var _PiOver2 = Math.PI * 0.5;
+    var _TwoPi = Math.PI * 2;
+    function evaluateEase(easeType, time, duration, overshootOrAmplitude, period) {
+        switch (easeType) {
+            case fgui.EaseType.Linear:
+                return time / duration;
+            case fgui.EaseType.SineIn:
+                return -Math.cos(time / duration * _PiOver2) + 1;
+            case fgui.EaseType.SineOut:
+                return Math.sin(time / duration * _PiOver2);
+            case fgui.EaseType.SineInOut:
+                return -0.5 * (Math.cos(Math.PI * time / duration) - 1);
+            case fgui.EaseType.QuadIn:
+                return (time /= duration) * time;
+            case fgui.EaseType.QuadOut:
+                return -(time /= duration) * (time - 2);
+            case fgui.EaseType.QuadInOut:
+                if ((time /= duration * 0.5) < 1)
+                    return 0.5 * time * time;
+                return -0.5 * ((--time) * (time - 2) - 1);
+            case fgui.EaseType.CubicIn:
+                return (time /= duration) * time * time;
+            case fgui.EaseType.CubicOut:
+                return ((time = time / duration - 1) * time * time + 1);
+            case fgui.EaseType.CubicInOut:
+                if ((time /= duration * 0.5) < 1)
+                    return 0.5 * time * time * time;
+                return 0.5 * ((time -= 2) * time * time + 2);
+            case fgui.EaseType.QuartIn:
+                return (time /= duration) * time * time * time;
+            case fgui.EaseType.QuartOut:
+                return -((time = time / duration - 1) * time * time * time - 1);
+            case fgui.EaseType.QuartInOut:
+                if ((time /= duration * 0.5) < 1)
+                    return 0.5 * time * time * time * time;
+                return -0.5 * ((time -= 2) * time * time * time - 2);
+            case fgui.EaseType.QuintIn:
+                return (time /= duration) * time * time * time * time;
+            case fgui.EaseType.QuintOut:
+                return ((time = time / duration - 1) * time * time * time * time + 1);
+            case fgui.EaseType.QuintInOut:
+                if ((time /= duration * 0.5) < 1)
+                    return 0.5 * time * time * time * time * time;
+                return 0.5 * ((time -= 2) * time * time * time * time + 2);
+            case fgui.EaseType.ExpoIn:
+                return (time == 0) ? 0 : Math.pow(2, 10 * (time / duration - 1));
+            case fgui.EaseType.ExpoOut:
+                if (time == duration)
+                    return 1;
+                return (-Math.pow(2, -10 * time / duration) + 1);
+            case fgui.EaseType.ExpoInOut:
+                if (time == 0)
+                    return 0;
+                if (time == duration)
+                    return 1;
+                if ((time /= duration * 0.5) < 1)
+                    return 0.5 * Math.pow(2, 10 * (time - 1));
+                return 0.5 * (-Math.pow(2, -10 * --time) + 2);
+            case fgui.EaseType.CircIn:
+                return -(Math.sqrt(1 - (time /= duration) * time) - 1);
+            case fgui.EaseType.CircOut:
+                return Math.sqrt(1 - (time = time / duration - 1) * time);
+            case fgui.EaseType.CircInOut:
+                if ((time /= duration * 0.5) < 1)
+                    return -0.5 * (Math.sqrt(1 - time * time) - 1);
+                return 0.5 * (Math.sqrt(1 - (time -= 2) * time) + 1);
+            case fgui.EaseType.ElasticIn:
+                var s0;
+                if (time == 0)
+                    return 0;
+                if ((time /= duration) == 1)
+                    return 1;
+                if (period == 0)
+                    period = duration * 0.3;
+                if (overshootOrAmplitude < 1) {
+                    overshootOrAmplitude = 1;
+                    s0 = period / 4;
+                }
+                else
+                    s0 = period / _TwoPi * Math.asin(1 / overshootOrAmplitude);
+                return -(overshootOrAmplitude * Math.pow(2, 10 * (time -= 1)) * Math.sin((time * duration - s0) * _TwoPi / period));
+            case fgui.EaseType.ElasticOut:
+                var s1;
+                if (time == 0)
+                    return 0;
+                if ((time /= duration) == 1)
+                    return 1;
+                if (period == 0)
+                    period = duration * 0.3;
+                if (overshootOrAmplitude < 1) {
+                    overshootOrAmplitude = 1;
+                    s1 = period / 4;
+                }
+                else
+                    s1 = period / _TwoPi * Math.asin(1 / overshootOrAmplitude);
+                return (overshootOrAmplitude * Math.pow(2, -10 * time) * Math.sin((time * duration - s1) * _TwoPi / period) + 1);
+            case fgui.EaseType.ElasticInOut:
+                var s;
+                if (time == 0)
+                    return 0;
+                if ((time /= duration * 0.5) == 2)
+                    return 1;
+                if (period == 0)
+                    period = duration * (0.3 * 1.5);
+                if (overshootOrAmplitude < 1) {
+                    overshootOrAmplitude = 1;
+                    s = period / 4;
+                }
+                else
+                    s = period / _TwoPi * Math.asin(1 / overshootOrAmplitude);
+                if (time < 1)
+                    return -0.5 * (overshootOrAmplitude * Math.pow(2, 10 * (time -= 1)) * Math.sin((time * duration - s) * _TwoPi / period));
+                return overshootOrAmplitude * Math.pow(2, -10 * (time -= 1)) * Math.sin((time * duration - s) * _TwoPi / period) * 0.5 + 1;
+            case fgui.EaseType.BackIn:
+                return (time /= duration) * time * ((overshootOrAmplitude + 1) * time - overshootOrAmplitude);
+            case fgui.EaseType.BackOut:
+                return ((time = time / duration - 1) * time * ((overshootOrAmplitude + 1) * time + overshootOrAmplitude) + 1);
+            case fgui.EaseType.BackInOut:
+                if ((time /= duration * 0.5) < 1)
+                    return 0.5 * (time * time * (((overshootOrAmplitude *= (1.525)) + 1) * time - overshootOrAmplitude));
+                return 0.5 * ((time -= 2) * time * (((overshootOrAmplitude *= (1.525)) + 1) * time + overshootOrAmplitude) + 2);
+            case fgui.EaseType.BounceIn:
+                return bounce_easeIn(time, duration);
+            case fgui.EaseType.BounceOut:
+                return bounce_easeOut(time, duration);
+            case fgui.EaseType.BounceInOut:
+                return bounce_easeInOut(time, duration);
+            default:
+                return -(time /= duration) * (time - 2);
+        }
+    }
+    fgui.evaluateEase = evaluateEase;
+    function bounce_easeIn(time, duration) {
+        return 1 - bounce_easeOut(duration - time, duration);
+    }
+    function bounce_easeOut(time, duration) {
+        if ((time /= duration) < (1 / 2.75)) {
+            return (7.5625 * time * time);
+        }
+        if (time < (2 / 2.75)) {
+            return (7.5625 * (time -= (1.5 / 2.75)) * time + 0.75);
+        }
+        if (time < (2.5 / 2.75)) {
+            return (7.5625 * (time -= (2.25 / 2.75)) * time + 0.9375);
+        }
+        return (7.5625 * (time -= (2.625 / 2.75)) * time + 0.984375);
+    }
+    function bounce_easeInOut(time, duration) {
+        if (time < duration * 0.5) {
+            return bounce_easeIn(time * 2, duration) * 0.5;
+        }
+        return bounce_easeOut(time * 2 - duration, duration) * 0.5 + 0.5;
+    }
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var EaseType = (function () {
+        function EaseType() {
+        }
+        EaseType.Linear = 0;
+        EaseType.SineIn = 1;
+        EaseType.SineOut = 2;
+        EaseType.SineInOut = 3;
+        EaseType.QuadIn = 4;
+        EaseType.QuadOut = 5;
+        EaseType.QuadInOut = 6;
+        EaseType.CubicIn = 7;
+        EaseType.CubicOut = 8;
+        EaseType.CubicInOut = 9;
+        EaseType.QuartIn = 10;
+        EaseType.QuartOut = 11;
+        EaseType.QuartInOut = 12;
+        EaseType.QuintIn = 13;
+        EaseType.QuintOut = 14;
+        EaseType.QuintInOut = 15;
+        EaseType.ExpoIn = 16;
+        EaseType.ExpoOut = 17;
+        EaseType.ExpoInOut = 18;
+        EaseType.CircIn = 19;
+        EaseType.CircOut = 20;
+        EaseType.CircInOut = 21;
+        EaseType.ElasticIn = 22;
+        EaseType.ElasticOut = 23;
+        EaseType.ElasticInOut = 24;
+        EaseType.BackIn = 25;
+        EaseType.BackOut = 26;
+        EaseType.BackInOut = 27;
+        EaseType.BounceIn = 28;
+        EaseType.BounceOut = 29;
+        EaseType.BounceInOut = 30;
+        EaseType.Custom = 31;
+        return EaseType;
+    }());
+    fgui.EaseType = EaseType;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GPath = (function () {
+        function GPath() {
+            this._segments = new Array();
+            this._points = new Array();
+        }
+        Object.defineProperty(GPath.prototype, "length", {
+            get: function () {
+                return this._fullLength;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GPath.prototype.create = function (pt1, pt2, pt3, pt4) {
+            var points;
+            if (Array.isArray(pt1))
+                points = pt1;
+            else {
+                points = new Array();
+                points.push(pt1);
+                points.push(pt2);
+                if (pt3)
+                    points.push(pt3);
+                if (pt4)
+                    points.push(pt4);
+            }
+            this._segments.length = 0;
+            this._points.length = 0;
+            this._fullLength = 0;
+            var cnt = points.length;
+            if (cnt == 0)
+                return;
+            var splinePoints = s_points;
+            splinePoints.length = 0;
+            var prev = points[0];
+            if (prev.curveType == fgui.CurveType.CRSpline)
+                splinePoints.push(new egret.Point(prev.x, prev.y));
+            for (var i = 1; i < cnt; i++) {
+                var current = points[i];
+                if (prev.curveType != fgui.CurveType.CRSpline) {
+                    var seg = {};
+                    seg.type = prev.curveType;
+                    seg.ptStart = this._points.length;
+                    if (prev.curveType == fgui.CurveType.Straight) {
+                        seg.ptCount = 2;
+                        this._points.push(new egret.Point(prev.x, prev.y));
+                        this._points.push(new egret.Point(current.x, current.y));
+                    }
+                    else if (prev.curveType == fgui.CurveType.Bezier) {
+                        seg.ptCount = 3;
+                        this._points.push(new egret.Point(prev.x, prev.y));
+                        this._points.push(new egret.Point(current.x, current.y));
+                        this._points.push(new egret.Point(prev.control1_x, prev.control1_y));
+                    }
+                    else if (prev.curveType == fgui.CurveType.CubicBezier) {
+                        seg.ptCount = 4;
+                        this._points.push(new egret.Point(prev.x, prev.y));
+                        this._points.push(new egret.Point(current.x, current.y));
+                        this._points.push(new egret.Point(prev.control1_x, prev.control1_y));
+                        this._points.push(new egret.Point(prev.control2_x, prev.control2_y));
+                    }
+                    seg.length = fgui.ToolSet.distance(prev.x, prev.y, current.x, current.y);
+                    this._fullLength += seg.length;
+                    this._segments.push(seg);
+                }
+                if (current.curveType != fgui.CurveType.CRSpline) {
+                    if (splinePoints.length > 0) {
+                        splinePoints.push(new egret.Point(current.x, current.y));
+                        this.createSplineSegment();
+                    }
+                }
+                else
+                    splinePoints.push(new egret.Point(current.x, current.y));
+                prev = current;
+            }
+            if (splinePoints.length > 1)
+                this.createSplineSegment();
+        };
+        GPath.prototype.createSplineSegment = function () {
+            var splinePoints = s_points;
+            var cnt = splinePoints.length;
+            splinePoints.splice(0, 0, splinePoints[0]);
+            splinePoints.push(splinePoints[cnt]);
+            splinePoints.push(splinePoints[cnt]);
+            cnt += 3;
+            var seg = {};
+            seg.type = fgui.CurveType.CRSpline;
+            seg.ptStart = this._points.length;
+            seg.ptCount = cnt;
+            this._points = this._points.concat(splinePoints);
+            seg.length = 0;
+            for (var i = 1; i < cnt; i++) {
+                seg.length += fgui.ToolSet.distance(splinePoints[i - 1].x, splinePoints[i - 1].y, splinePoints[i].x, splinePoints[i].y);
+            }
+            this._fullLength += seg.length;
+            this._segments.push(seg);
+            splinePoints.length = 0;
+        };
+        GPath.prototype.clear = function () {
+            this._segments.length = 0;
+            this._points.length = 0;
+        };
+        GPath.prototype.getPointAt = function (t, result) {
+            if (!result)
+                result = new egret.Point();
+            else
+                result.x = result.y = 0;
+            t = fgui.ToolSet.clamp01(t);
+            var cnt = this._segments.length;
+            if (cnt == 0) {
+                return result;
+            }
+            var seg;
+            if (t == 1) {
+                seg = this._segments[cnt - 1];
+                if (seg.type == fgui.CurveType.Straight) {
+                    result.x = fgui.ToolSet.lerp(this._points[seg.ptStart].x, this._points[seg.ptStart + 1].x, t);
+                    result.y = fgui.ToolSet.lerp(this._points[seg.ptStart].y, this._points[seg.ptStart + 1].y, t);
+                    return result;
+                }
+                else if (seg.type == fgui.CurveType.Bezier || seg.type == fgui.CurveType.CubicBezier)
+                    return this.onBezierCurve(seg.ptStart, seg.ptCount, t, result);
+                else
+                    return this.onCRSplineCurve(seg.ptStart, seg.ptCount, t, result);
+            }
+            var len = t * this._fullLength;
+            for (var i = 0; i < cnt; i++) {
+                seg = this._segments[i];
+                len -= seg.length;
+                if (len < 0) {
+                    t = 1 + len / seg.length;
+                    if (seg.type == fgui.CurveType.Straight) {
+                        result.x = fgui.ToolSet.lerp(this._points[seg.ptStart].x, this._points[seg.ptStart + 1].x, t);
+                        result.y = fgui.ToolSet.lerp(this._points[seg.ptStart].y, this._points[seg.ptStart + 1].y, t);
+                    }
+                    else if (seg.type == fgui.CurveType.Bezier || seg.type == fgui.CurveType.CubicBezier)
+                        result = this.onBezierCurve(seg.ptStart, seg.ptCount, t, result);
+                    else
+                        result = this.onCRSplineCurve(seg.ptStart, seg.ptCount, t, result);
+                    break;
+                }
+            }
+            return result;
+        };
+        Object.defineProperty(GPath.prototype, "segmentCount", {
+            get: function () {
+                return this._segments.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GPath.prototype.getAnchorsInSegment = function (segmentIndex, points) {
+            if (points == null)
+                points = new Array();
+            var seg = this._segments[segmentIndex];
+            for (var i = 0; i < seg.ptCount; i++)
+                points.push(new egret.Point(this._points[seg.ptStart + i].x, this._points[seg.ptStart + i].y));
+            return points;
+        };
+        GPath.prototype.getPointsInSegment = function (segmentIndex, t0, t1, points, ts, pointDensity) {
+            if (points == null)
+                points = new Array();
+            if (!pointDensity || isNaN(pointDensity))
+                pointDensity = 0.1;
+            if (ts)
+                ts.push(t0);
+            var seg = this._segments[segmentIndex];
+            if (seg.type == fgui.CurveType.Straight) {
+                points.push(new egret.Point(fgui.ToolSet.lerp(this._points[seg.ptStart].x, this._points[seg.ptStart + 1].x, t0), fgui.ToolSet.lerp(this._points[seg.ptStart].y, this._points[seg.ptStart + 1].y, t0)));
+                points.push(new egret.Point(fgui.ToolSet.lerp(this._points[seg.ptStart].x, this._points[seg.ptStart + 1].x, t1), fgui.ToolSet.lerp(this._points[seg.ptStart].y, this._points[seg.ptStart + 1].y, t1)));
+            }
+            else {
+                var func;
+                if (seg.type == fgui.CurveType.Bezier || seg.type == fgui.CurveType.CubicBezier)
+                    func = this.onBezierCurve;
+                else
+                    func = this.onCRSplineCurve;
+                points.push(func.call(this, seg.ptStart, seg.ptCount, t0, new egret.Point()));
+                var SmoothAmount = Math.min(seg.length * pointDensity, 50);
+                for (var j = 0; j <= SmoothAmount; j++) {
+                    var t = j / SmoothAmount;
+                    if (t > t0 && t < t1) {
+                        points.push(func.call(this, seg.ptStart, seg.ptCount, t, new egret.Point()));
+                        if (ts != null)
+                            ts.push(t);
+                    }
+                }
+                points.push(func.call(this, seg.ptStart, seg.ptCount, t1, new egret.Point()));
+            }
+            if (ts != null)
+                ts.push(t1);
+            return points;
+        };
+        GPath.prototype.getAllPoints = function (points, ts, pointDensity) {
+            if (points == null)
+                points = new Array();
+            if (!pointDensity || isNaN(pointDensity))
+                pointDensity = 0.1;
+            var cnt = this._segments.length;
+            for (var i = 0; i < cnt; i++)
+                this.getPointsInSegment(i, 0, 1, points, ts, pointDensity);
+            return points;
+        };
+        GPath.prototype.onCRSplineCurve = function (ptStart, ptCount, t, result) {
+            var adjustedIndex = Math.floor(t * (ptCount - 4)) + ptStart;
+            var p0x = this._points[adjustedIndex].x;
+            var p0y = this._points[adjustedIndex].y;
+            var p1x = this._points[adjustedIndex + 1].x;
+            var p1y = this._points[adjustedIndex + 1].y;
+            var p2x = this._points[adjustedIndex + 2].x;
+            var p2y = this._points[adjustedIndex + 2].y;
+            var p3x = this._points[adjustedIndex + 3].x;
+            var p3y = this._points[adjustedIndex + 3].y;
+            var adjustedT = (t == 1) ? 1 : fgui.ToolSet.repeat(t * (ptCount - 4), 1);
+            var t0 = ((-adjustedT + 2) * adjustedT - 1) * adjustedT * 0.5;
+            var t1 = (((3 * adjustedT - 5) * adjustedT) * adjustedT + 2) * 0.5;
+            var t2 = ((-3 * adjustedT + 4) * adjustedT + 1) * adjustedT * 0.5;
+            var t3 = ((adjustedT - 1) * adjustedT * adjustedT) * 0.5;
+            result.x = p0x * t0 + p1x * t1 + p2x * t2 + p3x * t3;
+            result.y = p0y * t0 + p1y * t1 + p2y * t2 + p3y * t3;
+            return result;
+        };
+        GPath.prototype.onBezierCurve = function (ptStart, ptCount, t, result) {
+            var t2 = 1 - t;
+            var p0x = this._points[ptStart].x;
+            var p0y = this._points[ptStart].y;
+            var p1x = this._points[ptStart + 1].x;
+            var p1y = this._points[ptStart + 1].y;
+            var cp0x = this._points[ptStart + 2].x;
+            var cp0y = this._points[ptStart + 2].y;
+            if (ptCount == 4) {
+                var cp1x = this._points[ptStart + 3].x;
+                var cp1y = this._points[ptStart + 3].y;
+                result.x = t2 * t2 * t2 * p0x + 3 * t2 * t2 * t * cp0x + 3 * t2 * t * t * cp1x + t * t * t * p1x;
+                result.y = t2 * t2 * t2 * p0y + 3 * t2 * t2 * t * cp0y + 3 * t2 * t * t * cp1y + t * t * t * p1y;
+            }
+            else {
+                result.x = t2 * t2 * p0x + 2 * t2 * t * cp0x + t * t * p1x;
+                result.y = t2 * t2 * p0y + 2 * t2 * t * cp0y + t * t * p1y;
+            }
+            return result;
+        };
+        return GPath;
+    }());
+    fgui.GPath = GPath;
+    var s_points = new Array();
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var CurveType;
+    (function (CurveType) {
+        CurveType[CurveType["CRSpline"] = 0] = "CRSpline";
+        CurveType[CurveType["Bezier"] = 1] = "Bezier";
+        CurveType[CurveType["CubicBezier"] = 2] = "CubicBezier";
+        CurveType[CurveType["Straight"] = 3] = "Straight";
+    })(CurveType = fgui.CurveType || (fgui.CurveType = {}));
+    var GPathPoint = (function () {
+        function GPathPoint() {
+            this.x = 0;
+            this.y = 0;
+            this.control1_x = 0;
+            this.control1_y = 0;
+            this.control2_x = 0;
+            this.control2_y = 0;
+            this.curveType = 0;
+        }
+        GPathPoint.newPoint = function (x, y, curveType) {
+            if (x === void 0) { x = 0; }
+            if (y === void 0) { y = 0; }
+            if (curveType === void 0) { curveType = 0; }
+            var pt = new GPathPoint();
+            pt.x = x;
+            pt.y = y;
+            pt.control1_x = 0;
+            pt.control1_y = 0;
+            pt.control2_x = 0;
+            pt.control2_y = 0;
+            pt.curveType = curveType;
+            return pt;
+        };
+        GPathPoint.newBezierPoint = function (x, y, control1_x, control1_y) {
+            if (x === void 0) { x = 0; }
+            if (y === void 0) { y = 0; }
+            if (control1_x === void 0) { control1_x = 0; }
+            if (control1_y === void 0) { control1_y = 0; }
+            var pt = new GPathPoint();
+            pt.x = x;
+            pt.y = y;
+            pt.control1_x = control1_x;
+            pt.control1_y = control1_y;
+            pt.control2_x = 0;
+            pt.control2_y = 0;
+            pt.curveType = CurveType.Bezier;
+            return pt;
+        };
+        GPathPoint.newCubicBezierPoint = function (x, y, control1_x, control1_y, control2_x, control2_y) {
+            if (x === void 0) { x = 0; }
+            if (y === void 0) { y = 0; }
+            if (control1_x === void 0) { control1_x = 0; }
+            if (control1_y === void 0) { control1_y = 0; }
+            if (control2_x === void 0) { control2_x = 0; }
+            if (control2_y === void 0) { control2_y = 0; }
+            var pt = new GPathPoint();
+            pt.x = x;
+            pt.y = y;
+            pt.control1_x = control1_x;
+            pt.control1_y = control1_y;
+            pt.control2_x = control2_x;
+            pt.control2_y = control2_y;
+            pt.curveType = CurveType.CubicBezier;
+            return pt;
+        };
+        GPathPoint.prototype.clone = function () {
+            var ret = new GPathPoint();
+            ret.x = this.x;
+            ret.y = this.y;
+            ret.control1_x = this.control1_x;
+            ret.control1_y = this.control1_y;
+            ret.control2_x = this.control2_x;
+            ret.control2_y = this.control2_y;
+            ret.curveType = this.curveType;
+            return ret;
+        };
+        return GPathPoint;
+    }());
+    fgui.GPathPoint = GPathPoint;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GTween = (function () {
+        function GTween() {
+        }
+        GTween.to = function (start, end, duration) {
+            return fgui.TweenManager.createTween()._to(start, end, duration);
+        };
+        GTween.to2 = function (start, start2, end, end2, duration) {
+            return fgui.TweenManager.createTween()._to2(start, start2, end, end2, duration);
+        };
+        GTween.to3 = function (start, start2, start3, end, end2, end3, duration) {
+            return fgui.TweenManager.createTween()._to3(start, start2, start3, end, end2, end3, duration);
+        };
+        GTween.to4 = function (start, start2, start3, start4, end, end2, end3, end4, duration) {
+            return fgui.TweenManager.createTween()._to4(start, start2, start3, start4, end, end2, end3, end4, duration);
+        };
+        GTween.toColor = function (start, end, duration) {
+            return fgui.TweenManager.createTween()._toColor(start, end, duration);
+        };
+        GTween.delayedCall = function (delay) {
+            return fgui.TweenManager.createTween().setDelay(delay);
+        };
+        GTween.shake = function (startX, startY, amplitude, duration) {
+            return fgui.TweenManager.createTween()._shake(startX, startY, amplitude, duration);
+        };
+        GTween.isTweening = function (target, propType) {
+            return fgui.TweenManager.isTweening(target, propType);
+        };
+        GTween.kill = function (target, complete, propType) {
+            fgui.TweenManager.killTweens(target, complete, propType);
+        };
+        GTween.getTween = function (target, propType) {
+            return fgui.TweenManager.getTween(target, propType);
+        };
+        GTween.catchCallbackExceptions = true;
+        return GTween;
+    }());
+    fgui.GTween = GTween;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GTweener = (function () {
+        function GTweener() {
+            this._startValue = new fgui.TweenValue();
+            this._endValue = new fgui.TweenValue();
+            this._value = new fgui.TweenValue();
+            this._deltaValue = new fgui.TweenValue();
+            this._reset();
+        }
+        GTweener.prototype.setDelay = function (value) {
+            this._delay = value;
+            return this;
+        };
+        Object.defineProperty(GTweener.prototype, "delay", {
+            get: function () {
+                return this._delay;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTweener.prototype.setDuration = function (value) {
+            this._duration = value;
+            return this;
+        };
+        Object.defineProperty(GTweener.prototype, "duration", {
+            get: function () {
+                return this._duration;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTweener.prototype.setBreakpoint = function (value) {
+            this._breakpoint = value;
+            return this;
+        };
+        GTweener.prototype.setEase = function (value) {
+            this._easeType = value;
+            return this;
+        };
+        GTweener.prototype.setEasePeriod = function (value) {
+            this._easePeriod = value;
+            return this;
+        };
+        GTweener.prototype.setEaseOvershootOrAmplitude = function (value) {
+            this._easeOvershootOrAmplitude = value;
+            return this;
+        };
+        GTweener.prototype.setRepeat = function (repeat, yoyo) {
+            this._repeat = repeat;
+            this._yoyo = yoyo;
+            return this;
+        };
+        Object.defineProperty(GTweener.prototype, "repeat", {
+            get: function () {
+                return this._repeat;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTweener.prototype.setTimeScale = function (value) {
+            this._timeScale = value;
+            return this;
+        };
+        GTweener.prototype.setSnapping = function (value) {
+            this._snapping = value;
+            return this;
+        };
+        GTweener.prototype.setTarget = function (value, propType) {
+            this._target = value;
+            this._propType = propType;
+            return this;
+        };
+        Object.defineProperty(GTweener.prototype, "target", {
+            get: function () {
+                return this._target;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTweener.prototype.setUserData = function (value) {
+            this._userData = value;
+            return this;
+        };
+        Object.defineProperty(GTweener.prototype, "userData", {
+            get: function () {
+                return this._userData;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTweener.prototype.setPath = function (value) {
+            this._path = value;
+            return this;
+        };
+        GTweener.prototype.onUpdate = function (callback, caller) {
+            this._onUpdate = callback;
+            this._onUpdateCaller = caller;
+            return this;
+        };
+        GTweener.prototype.onStart = function (callback, caller) {
+            this._onStart = callback;
+            this._onStartCaller = caller;
+            return this;
+        };
+        GTweener.prototype.onComplete = function (callback, caller) {
+            this._onComplete = callback;
+            this._onCompleteCaller = caller;
+            return this;
+        };
+        Object.defineProperty(GTweener.prototype, "startValue", {
+            get: function () {
+                return this._startValue;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTweener.prototype, "endValue", {
+            get: function () {
+                return this._endValue;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTweener.prototype, "value", {
+            get: function () {
+                return this._value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTweener.prototype, "deltaValue", {
+            get: function () {
+                return this._deltaValue;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTweener.prototype, "normalizedTime", {
+            get: function () {
+                return this._normalizedTime;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTweener.prototype, "completed", {
+            get: function () {
+                return this._ended != 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(GTweener.prototype, "allCompleted", {
+            get: function () {
+                return this._ended == 1;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GTweener.prototype.setPaused = function (paused) {
+            this._paused = paused;
+            return this;
+        };
+        GTweener.prototype.seek = function (time) {
+            if (this._killed)
+                return;
+            this._elapsedTime = time;
+            if (this._elapsedTime < this._delay) {
+                if (this._started)
+                    this._elapsedTime = this._delay;
+                else
+                    return;
+            }
+            this.update();
+        };
+        GTweener.prototype.kill = function (complete) {
+            if (this._killed)
+                return;
+            if (complete) {
+                if (this._ended == 0) {
+                    if (this._breakpoint >= 0)
+                        this._elapsedTime = this._delay + this._breakpoint;
+                    else if (this._repeat >= 0)
+                        this._elapsedTime = this._delay + this._duration * (this._repeat + 1);
+                    else
+                        this._elapsedTime = this._delay + this._duration * 2;
+                    this.update();
+                }
+                this.callCompleteCallback();
+            }
+            this._killed = true;
+        };
+        GTweener.prototype._to = function (start, end, duration) {
+            this._valueSize = 1;
+            this._startValue.x = start;
+            this._endValue.x = end;
+            this._value.x = start;
+            this._duration = duration;
+            return this;
+        };
+        GTweener.prototype._to2 = function (start, start2, end, end2, duration) {
+            this._valueSize = 2;
+            this._startValue.x = start;
+            this._endValue.x = end;
+            this._startValue.y = start2;
+            this._endValue.y = end2;
+            this._value.x = start;
+            this._value.y = start2;
+            this._duration = duration;
+            return this;
+        };
+        GTweener.prototype._to3 = function (start, start2, start3, end, end2, end3, duration) {
+            this._valueSize = 3;
+            this._startValue.x = start;
+            this._endValue.x = end;
+            this._startValue.y = start2;
+            this._endValue.y = end2;
+            this._startValue.z = start3;
+            this._endValue.z = end3;
+            this._value.x = start;
+            this._value.y = start2;
+            this._value.z = start3;
+            this._duration = duration;
+            return this;
+        };
+        GTweener.prototype._to4 = function (start, start2, start3, start4, end, end2, end3, end4, duration) {
+            this._valueSize = 4;
+            this._startValue.x = start;
+            this._endValue.x = end;
+            this._startValue.y = start2;
+            this._endValue.y = end2;
+            this._startValue.z = start3;
+            this._endValue.z = end3;
+            this._startValue.w = start4;
+            this._endValue.w = end4;
+            this._value.x = start;
+            this._value.y = start2;
+            this._value.z = start3;
+            this._value.w = start4;
+            this._duration = duration;
+            return this;
+        };
+        GTweener.prototype._toColor = function (start, end, duration) {
+            this._valueSize = 4;
+            this._startValue.color = start;
+            this._endValue.color = end;
+            this._value.color = start;
+            this._duration = duration;
+            return this;
+        };
+        GTweener.prototype._shake = function (startX, startY, amplitude, duration) {
+            this._valueSize = 5;
+            this._startValue.x = startX;
+            this._startValue.y = startY;
+            this._startValue.w = amplitude;
+            this._duration = duration;
+            return this;
+        };
+        GTweener.prototype._init = function () {
+            this._delay = 0;
+            this._duration = 0;
+            this._breakpoint = -1;
+            this._easeType = fgui.EaseType.QuadOut;
+            this._timeScale = 1;
+            this._easePeriod = 0;
+            this._easeOvershootOrAmplitude = 1.70158;
+            this._snapping = false;
+            this._repeat = 0;
+            this._yoyo = false;
+            this._valueSize = 0;
+            this._started = false;
+            this._paused = false;
+            this._killed = false;
+            this._elapsedTime = 0;
+            this._normalizedTime = 0;
+            this._ended = 0;
+        };
+        GTweener.prototype._reset = function () {
+            this._target = null;
+            this._propType = null;
+            this._userData = null;
+            this._path = null;
+            this._onStart = this._onUpdate = this._onComplete = null;
+            this._onStartCaller = this._onUpdateCaller = this._onCompleteCaller = null;
+        };
+        GTweener.prototype._update = function (dt) {
+            if (this._timeScale != 1)
+                dt *= this._timeScale;
+            if (dt == 0)
+                return;
+            if (this._ended != 0) {
+                this.callCompleteCallback();
+                this._killed = true;
+                return;
+            }
+            this._elapsedTime += dt;
+            this.update();
+            if (this._ended != 0) {
+                if (!this._killed) {
+                    this.callCompleteCallback();
+                    this._killed = true;
+                }
+            }
+        };
+        GTweener.prototype.update = function () {
+            this._ended = 0;
+            if (this._valueSize == 0) {
+                if (this._elapsedTime >= this._delay + this._duration)
+                    this._ended = 1;
+                return;
+            }
+            if (!this._started) {
+                if (this._elapsedTime < this._delay)
+                    return;
+                this._started = true;
+                this.callStartCallback();
+                if (this._killed)
+                    return;
+            }
+            var reversed = false;
+            var tt = this._elapsedTime - this._delay;
+            if (this._breakpoint >= 0 && tt >= this._breakpoint) {
+                tt = this._breakpoint;
+                this._ended = 2;
+            }
+            if (this._repeat != 0) {
+                var round = Math.floor(tt / this._duration);
+                tt -= this._duration * round;
+                if (this._yoyo)
+                    reversed = round % 2 == 1;
+                if (this._repeat > 0 && this._repeat - round < 0) {
+                    if (this._yoyo)
+                        reversed = this._repeat % 2 == 1;
+                    tt = this._duration;
+                    this._ended = 1;
+                }
+            }
+            else if (tt >= this._duration) {
+                tt = this._duration;
+                this._ended = 1;
+            }
+            this._normalizedTime = fgui.evaluateEase(this._easeType, reversed ? (this._duration - tt) : tt, this._duration, this._easeOvershootOrAmplitude, this._easePeriod);
+            this._value.setZero();
+            this._deltaValue.setZero();
+            if (this._valueSize == 5) {
+                if (this._ended == 0) {
+                    var r = this._startValue.w * (1 - this._normalizedTime);
+                    var rx = r * (Math.random() > 0.5 ? 1 : -1);
+                    var ry = r * (Math.random() > 0.5 ? 1 : -1);
+                    this._deltaValue.x = rx;
+                    this._deltaValue.y = ry;
+                    this._value.x = this._startValue.x + rx;
+                    this._value.y = this._startValue.y + ry;
+                }
+                else {
+                    this._value.x = this._startValue.x;
+                    this._value.y = this._startValue.y;
+                }
+            }
+            else if (this._path) {
+                var pt = s_vec2;
+                this._path.getPointAt(this._normalizedTime, pt);
+                if (this._snapping) {
+                    pt.x = Math.round(pt.x);
+                    pt.y = Math.round(pt.y);
+                }
+                this._deltaValue.x = pt.x - this._value.x;
+                this._deltaValue.y = pt.y - this._value.y;
+                this._value.x = pt.x;
+                this._value.y = pt.y;
+            }
+            else {
+                for (var i = 0; i < this._valueSize; i++) {
+                    var n1 = this._startValue.getField(i);
+                    var n2 = this._endValue.getField(i);
+                    var f = n1 + (n2 - n1) * this._normalizedTime;
+                    if (this._snapping)
+                        f = Math.round(f);
+                    this._deltaValue.setField(i, f - this._value.getField(i));
+                    this._value.setField(i, f);
+                }
+            }
+            if (this._target != null && this._propType != null) {
+                if (this._propType instanceof Function) {
+                    switch (this._valueSize) {
+                        case 1:
+                            this._propType.call(this._target, this._value.x);
+                            break;
+                        case 2:
+                            this._propType.call(this._target, this._value.x, this._value.y);
+                            break;
+                        case 3:
+                            this._propType.call(this._target, this._value.x, this._value.y, this._value.z);
+                            break;
+                        case 4:
+                            this._propType.call(this._target, this._value.x, this._value.y, this._value.z, this._value.w);
+                            break;
+                        case 5:
+                            this._propType.call(this._target, this._value.color);
+                            break;
+                        case 6:
+                            this._propType.call(this._target, this._value.x, this._value.y);
+                            break;
+                    }
+                }
+                else {
+                    if (this._valueSize == 5)
+                        this._target[this._propType] = this._value.color;
+                    else
+                        this._target[this._propType] = this._value.x;
+                }
+            }
+            this.callUpdateCallback();
+        };
+        GTweener.prototype.callStartCallback = function () {
+            if (this._onStart != null) {
+                try {
+                    this._onStart.call(this._onStartCaller, this);
+                }
+                catch (err) {
+                    console.log("FairyGUI: error in start callback > " + err);
+                }
+            }
+        };
+        GTweener.prototype.callUpdateCallback = function () {
+            if (this._onUpdate != null) {
+                try {
+                    this._onUpdate.call(this._onUpdateCaller, this);
+                }
+                catch (err) {
+                    console.log("FairyGUI: error in update callback > " + err);
+                }
+            }
+        };
+        GTweener.prototype.callCompleteCallback = function () {
+            if (this._onComplete != null) {
+                try {
+                    this._onComplete.call(this._onCompleteCaller, this);
+                }
+                catch (err) {
+                    console.log("FairyGUI: error in complete callback > " + err);
+                }
+            }
+        };
+        return GTweener;
+    }());
+    fgui.GTweener = GTweener;
+    var s_vec2 = new egret.Point();
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var TweenManager = (function () {
+        function TweenManager() {
+        }
+        TweenManager.createTween = function () {
+            if (!_inited) {
+                egret.startTick(TweenManager.update, null);
+                _inited = true;
+                _lastTime = egret.getTimer();
+            }
+            var tweener;
+            var cnt = _tweenerPool.length;
+            if (cnt > 0) {
+                tweener = _tweenerPool.pop();
+            }
+            else
+                tweener = new fgui.GTweener();
+            tweener._init();
+            _activeTweens[_totalActiveTweens++] = tweener;
+            if (_totalActiveTweens == _activeTweens.length)
+                _activeTweens.length = _activeTweens.length + Math.ceil(_activeTweens.length * 0.5);
+            return tweener;
+        };
+        TweenManager.isTweening = function (target, propType) {
+            if (target == null)
+                return false;
+            var anyType = propType == null;
+            for (var i = 0; i < _totalActiveTweens; i++) {
+                var tweener = _activeTweens[i];
+                if (tweener != null && tweener.target == target && !tweener._killed
+                    && (anyType || tweener._propType == propType))
+                    return true;
+            }
+            return false;
+        };
+        TweenManager.killTweens = function (target, completed, propType) {
+            if (target == null)
+                return false;
+            var flag = false;
+            var cnt = _totalActiveTweens;
+            var anyType = propType == null;
+            for (var i = 0; i < cnt; i++) {
+                var tweener = _activeTweens[i];
+                if (tweener != null && tweener.target == target && !tweener._killed
+                    && (anyType || tweener._propType == propType)) {
+                    tweener.kill(completed);
+                    flag = true;
+                }
+            }
+            return flag;
+        };
+        TweenManager.getTween = function (target, propType) {
+            if (target == null)
+                return null;
+            var cnt = _totalActiveTweens;
+            var anyType = propType == null;
+            for (var i = 0; i < cnt; i++) {
+                var tweener = _activeTweens[i];
+                if (tweener != null && tweener.target == target && !tweener._killed
+                    && (anyType || tweener._propType == propType)) {
+                    return tweener;
+                }
+            }
+            return null;
+        };
+        TweenManager.update = function (timestamp) {
+            var dt = timestamp - _lastTime;
+            _lastTime = timestamp;
+            dt /= 1000;
+            var cnt = _totalActiveTweens;
+            var freePosStart = -1;
+            var freePosCount = 0;
+            for (var i = 0; i < cnt; i++) {
+                var tweener = _activeTweens[i];
+                if (tweener == null) {
+                    if (freePosStart == -1)
+                        freePosStart = i;
+                    freePosCount++;
+                }
+                else if (tweener._killed) {
+                    tweener._reset();
+                    _tweenerPool.push(tweener);
+                    _activeTweens[i] = null;
+                    if (freePosStart == -1)
+                        freePosStart = i;
+                    freePosCount++;
+                }
+                else {
+                    if ((tweener._target instanceof fgui.GObject) && (tweener._target).isDisposed)
+                        tweener._killed = true;
+                    else if (!tweener._paused)
+                        tweener._update(dt);
+                    if (freePosStart != -1) {
+                        _activeTweens[freePosStart] = tweener;
+                        _activeTweens[i] = null;
+                        freePosStart++;
+                    }
+                }
+            }
+            if (freePosStart >= 0) {
+                if (_totalActiveTweens != cnt) {
+                    var j = cnt;
+                    cnt = _totalActiveTweens - cnt;
+                    for (i = 0; i < cnt; i++)
+                        _activeTweens[freePosStart++] = _activeTweens[j++];
+                }
+                _totalActiveTweens = freePosStart;
+            }
+            return false;
+        };
+        return TweenManager;
+    }());
+    fgui.TweenManager = TweenManager;
+    var _activeTweens = new Array(30);
+    var _tweenerPool = new Array();
+    var _totalActiveTweens = 0;
+    var _lastTime = 0;
+    var _inited;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var TweenValue = (function () {
+        function TweenValue() {
+            this.x = this.y = this.z = this.w = 0;
+        }
+        Object.defineProperty(TweenValue.prototype, "color", {
+            get: function () {
+                return (this.w << 24) + (this.x << 16) + (this.y << 8) + this.z;
+            },
+            set: function (value) {
+                this.x = (value & 0xFF0000) >> 16;
+                this.y = (value & 0x00FF00) >> 8;
+                this.z = (value & 0x0000FF);
+                this.w = (value & 0xFF000000) >> 24;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TweenValue.prototype.getField = function (index) {
+            switch (index) {
+                case 0:
+                    return this.x;
+                case 1:
+                    return this.y;
+                case 2:
+                    return this.z;
+                case 3:
+                    return this.w;
+                default:
+                    throw new Error("Index out of bounds: " + index);
+            }
+        };
+        TweenValue.prototype.setField = function (index, value) {
+            switch (index) {
+                case 0:
+                    this.x = value;
+                    break;
+                case 1:
+                    this.y = value;
+                    break;
+                case 2:
+                    this.z = value;
+                    break;
+                case 3:
+                    this.w = value;
+                    break;
+                default:
+                    throw new Error("Index out of bounds: " + index);
+            }
+        };
+        TweenValue.prototype.setZero = function () {
+            this.x = this.y = this.z = this.w = 0;
+        };
+        return TweenValue;
+    }());
+    fgui.TweenValue = TweenValue;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ByteBuffer = (function (_super_1) {
+        __extends(ByteBuffer, _super_1);
+        function ByteBuffer(buffer, bufferExtSize) {
+            var _this = _super_1.call(this, buffer, bufferExtSize) || this;
+            _this.version = 0;
+            return _this;
+        }
+        ByteBuffer.prototype.skip = function (count) {
+            this.position += count;
+        };
+        ByteBuffer.prototype.readBool = function () {
+            return this.readByte() == 1;
+        };
+        ByteBuffer.prototype.readS = function () {
+            var index = this.readUnsignedShort();
+            if (index == 65534)
+                return null;
+            else if (index == 65533)
+                return "";
+            else
+                return this.stringTable[index];
+        };
+        ByteBuffer.prototype.readSArray = function (cnt) {
+            var ret = new Array(cnt);
+            for (var i = 0; i < cnt; i++)
+                ret[i] = this.readS();
+            return ret;
+        };
+        ByteBuffer.prototype.writeS = function (value) {
+            var index = this.readUnsignedShort();
+            if (index != 65534 && index != 65533)
+                this.stringTable[index] = value;
+        };
+        ByteBuffer.prototype.readColor = function (hasAlpha) {
+            var r = this.readUnsignedByte();
+            var g = this.readUnsignedByte();
+            var b = this.readUnsignedByte();
+            var a = this.readUnsignedByte();
+            return (hasAlpha ? (a << 24) : 0) + (r << 16) + (g << 8) + b;
+        };
+        ByteBuffer.prototype.readChar = function () {
+            var i = this.readUnsignedShort();
+            return String.fromCharCode(i);
+        };
+        ByteBuffer.prototype.readBuffer = function () {
+            var count = this.readUnsignedInt();
+            var ba = new ByteBuffer(new Uint8Array(this.buffer, this.position, count));
+            ba.stringTable = this.stringTable;
+            ba.version = this.version;
+            this.position += count;
+            return ba;
+        };
+        ByteBuffer.prototype.seek = function (indexTablePos, blockIndex) {
+            var tmp = this.position;
+            this.position = indexTablePos;
+            var segCount = this.readByte();
+            if (blockIndex < segCount) {
+                var useShort = this.readByte() == 1;
+                var newPos;
+                if (useShort) {
+                    this.position += 2 * blockIndex;
+                    newPos = this.readUnsignedShort();
+                }
+                else {
+                    this.position += 4 * blockIndex;
+                    newPos = this.readUnsignedInt();
+                }
+                if (newPos > 0) {
+                    this.position = indexTablePos + newPos;
+                    return true;
+                }
+                else {
+                    this.position = tmp;
+                    return false;
+                }
+            }
+            else {
+                this.position = tmp;
+                return false;
+            }
+        };
+        return ByteBuffer;
+    }(egret.ByteArray));
+    fgui.ByteBuffer = ByteBuffer;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ColorMatrix = (function () {
+        function ColorMatrix(p_brightness, p_contrast, p_saturation, p_hue) {
+            this.matrix = new Array(LENGTH);
+            this.reset();
+            if (p_brightness !== undefined || p_contrast !== undefined || p_saturation !== undefined || p_hue !== undefined)
+                this.adjustColor(p_brightness, p_contrast, p_saturation, p_hue);
+        }
+        ColorMatrix.prototype.reset = function () {
+            for (var i = 0; i < LENGTH; i++) {
+                this.matrix[i] = IDENTITY_MATRIX[i];
+            }
+        };
+        ColorMatrix.prototype.invert = function () {
+            this.multiplyMatrix([-1, 0, 0, 0, 255,
+                0, -1, 0, 0, 255,
+                0, 0, -1, 0, 255,
+                0, 0, 0, 1, 0]);
+        };
+        ColorMatrix.prototype.adjustColor = function (p_brightness, p_contrast, p_saturation, p_hue) {
+            this.adjustHue(p_hue || 0);
+            this.adjustContrast(p_contrast || 0);
+            this.adjustBrightness(p_brightness || 0);
+            this.adjustSaturation(p_saturation || 0);
+        };
+        ColorMatrix.prototype.adjustBrightness = function (p_val) {
+            p_val = this.cleanValue(p_val, 1) * 255;
+            this.multiplyMatrix([
+                1, 0, 0, 0, p_val,
+                0, 1, 0, 0, p_val,
+                0, 0, 1, 0, p_val,
+                0, 0, 0, 1, 0
+            ]);
+        };
+        ColorMatrix.prototype.adjustContrast = function (p_val) {
+            p_val = this.cleanValue(p_val, 1);
+            var s = p_val + 1;
+            var o = 128 * (1 - s);
+            this.multiplyMatrix([
+                s, 0, 0, 0, o,
+                0, s, 0, 0, o,
+                0, 0, s, 0, o,
+                0, 0, 0, 1, 0
+            ]);
+        };
+        ColorMatrix.prototype.adjustSaturation = function (p_val) {
+            p_val = this.cleanValue(p_val, 1);
+            p_val += 1;
+            var invSat = 1 - p_val;
+            var invLumR = invSat * LUMA_R;
+            var invLumG = invSat * LUMA_G;
+            var invLumB = invSat * LUMA_B;
+            this.multiplyMatrix([
+                (invLumR + p_val), invLumG, invLumB, 0, 0,
+                invLumR, (invLumG + p_val), invLumB, 0, 0,
+                invLumR, invLumG, (invLumB + p_val), 0, 0,
+                0, 0, 0, 1, 0
+            ]);
+        };
+        ColorMatrix.prototype.adjustHue = function (p_val) {
+            p_val = this.cleanValue(p_val, 1);
+            p_val *= Math.PI;
+            var cos = Math.cos(p_val);
+            var sin = Math.sin(p_val);
+            this.multiplyMatrix([
+                ((LUMA_R + (cos * (1 - LUMA_R))) + (sin * -(LUMA_R))), ((LUMA_G + (cos * -(LUMA_G))) + (sin * -(LUMA_G))), ((LUMA_B + (cos * -(LUMA_B))) + (sin * (1 - LUMA_B))), 0, 0,
+                ((LUMA_R + (cos * -(LUMA_R))) + (sin * 0.143)), ((LUMA_G + (cos * (1 - LUMA_G))) + (sin * 0.14)), ((LUMA_B + (cos * -(LUMA_B))) + (sin * -0.283)), 0, 0,
+                ((LUMA_R + (cos * -(LUMA_R))) + (sin * -((1 - LUMA_R)))), ((LUMA_G + (cos * -(LUMA_G))) + (sin * LUMA_G)), ((LUMA_B + (cos * (1 - LUMA_B))) + (sin * LUMA_B)), 0, 0,
+                0, 0, 0, 1, 0
+            ]);
+        };
+        ColorMatrix.prototype.concat = function (p_matrix) {
+            if (p_matrix.length != LENGTH) {
+                return;
+            }
+            this.multiplyMatrix(p_matrix);
+        };
+        ColorMatrix.prototype.clone = function () {
+            var result = new ColorMatrix();
+            result.copyMatrix(this.matrix);
+            return result;
+        };
+        ColorMatrix.prototype.copyMatrix = function (p_matrix) {
+            var l = LENGTH;
+            for (var i = 0; i < l; i++) {
+                this.matrix[i] = p_matrix[i];
+            }
+        };
+        ColorMatrix.prototype.multiplyMatrix = function (p_matrix) {
+            var col = [];
+            var i = 0;
+            for (var y = 0; y < 4; ++y) {
+                for (var x = 0; x < 5; ++x) {
+                    col[i + x] = p_matrix[i] * this.matrix[x] +
+                        p_matrix[i + 1] * this.matrix[x + 5] +
+                        p_matrix[i + 2] * this.matrix[x + 10] +
+                        p_matrix[i + 3] * this.matrix[x + 15] +
+                        (x == 4 ? p_matrix[i + 4] : 0);
+                }
+                i += 5;
+            }
+            this.copyMatrix(col);
+        };
+        ColorMatrix.prototype.cleanValue = function (p_val, p_limit) {
+            return Math.min(p_limit, Math.max(-p_limit, p_val));
+        };
+        return ColorMatrix;
+    }());
+    fgui.ColorMatrix = ColorMatrix;
+    var IDENTITY_MATRIX = [
+        1, 0, 0, 0, 0,
+        0, 1, 0, 0, 0,
+        0, 0, 1, 0, 0,
+        0, 0, 0, 1, 0
+    ];
+    var LENGTH = IDENTITY_MATRIX.length;
+    var LUMA_R = 0.299;
+    var LUMA_G = 0.587;
+    var LUMA_B = 0.114;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var GTimers = (function () {
+        function GTimers() {
+            this._enumI = 0;
+            this._enumCount = 0;
+            this._lastTime = 0;
+            this._items = new Array();
+            this._itemPool = new Array();
+            this._lastTime = egret.getTimer();
+            GTimers.time = this._lastTime;
+            egret.startTick(this.__timer, this);
+        }
+        GTimers.prototype.getItem = function () {
+            if (this._itemPool.length)
+                return this._itemPool.pop();
+            else
+                return new TimerItem();
+        };
+        GTimers.prototype.findItem = function (callback, thisObj) {
+            var len = this._items.length;
+            for (var i = 0; i < len; i++) {
+                var item = this._items[i];
+                if (item.callback == callback && item.thisObj == thisObj)
+                    return item;
+            }
+            return null;
+        };
+        GTimers.prototype.add = function (delayInMiniseconds, repeat, callback, thisObj, callbackParam) {
+            var item = this.findItem(callback, thisObj);
+            if (!item) {
+                item = this.getItem();
+                item.callback = callback;
+                item.hasParam = callback.length == 1;
+                item.thisObj = thisObj;
+                this._items.push(item);
+            }
+            item.delay = delayInMiniseconds;
+            item.counter = 0;
+            item.repeat = repeat;
+            item.param = callbackParam;
+            item.end = false;
+        };
+        GTimers.prototype.callLater = function (callback, thisObj, callbackParam) {
+            this.add(1, 1, callback, thisObj, callbackParam);
+        };
+        GTimers.prototype.callDelay = function (delay, callback, thisObj, callbackParam) {
+            this.add(delay, 1, callback, thisObj, callbackParam);
+        };
+        GTimers.prototype.exists = function (callback, thisObj) {
+            var item = this.findItem(callback, thisObj);
+            return item != null;
+        };
+        GTimers.prototype.remove = function (callback, thisObj) {
+            var item = this.findItem(callback, thisObj);
+            if (item) {
+                var i = this._items.indexOf(item);
+                this._items.splice(i, 1);
+                if (i < this._enumI)
+                    this._enumI--;
+                this._enumCount--;
+                item.reset();
+                this._itemPool.push(item);
+            }
+        };
+        GTimers.prototype.__timer = function (timeStamp) {
+            GTimers.time = timeStamp;
+            GTimers.deltaTime = timeStamp - this._lastTime;
+            this._lastTime = timeStamp;
+            this._enumI = 0;
+            this._enumCount = this._items.length;
+            while (this._enumI < this._enumCount) {
+                var item = this._items[this._enumI];
+                this._enumI++;
+                if (item.advance(GTimers.deltaTime)) {
+                    if (item.end) {
+                        this._enumI--;
+                        this._enumCount--;
+                        this._items.splice(this._enumI, 1);
+                    }
+                    if (item.hasParam)
+                        item.callback.call(item.thisObj, item.param);
+                    else
+                        item.callback.call(item.thisObj);
+                    if (item.end) {
+                        item.reset();
+                        this._itemPool.push(item);
+                    }
+                }
+            }
+            return false;
+        };
+        GTimers.deltaTime = 0;
+        GTimers.time = 0;
+        GTimers.inst = new GTimers();
+        return GTimers;
+    }());
+    fgui.GTimers = GTimers;
+    var TimerItem = (function () {
+        function TimerItem() {
+            this.delay = 0;
+            this.counter = 0;
+            this.repeat = 0;
+        }
+        TimerItem.prototype.advance = function (elapsed) {
+            this.counter += elapsed;
+            if (this.counter >= this.delay) {
+                this.counter -= this.delay;
+                if (this.counter > this.delay)
+                    this.counter = this.delay;
+                if (this.repeat > 0) {
+                    this.repeat--;
+                    if (this.repeat == 0)
+                        this.end = true;
+                }
+                return true;
+            }
+            else
+                return false;
+        };
+        TimerItem.prototype.reset = function () {
+            this.callback = null;
+            this.thisObj = null;
+            this.param = null;
+        };
+        return TimerItem;
+    }());
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var UBBParser = (function () {
+        function UBBParser() {
+            this._readPos = 0;
+            this.smallFontSize = 12;
+            this.normalFontSize = 14;
+            this.largeFontSize = 16;
+            this.defaultImgWidth = 0;
+            this.defaultImgHeight = 0;
+            this._handlers = {};
+            this._handlers["url"] = this.onTag_URL;
+            this._handlers["img"] = this.onTag_IMG;
+            this._handlers["b"] = this.onTag_Simple;
+            this._handlers["i"] = this.onTag_Simple;
+            this._handlers["u"] = this.onTag_Simple;
+            this._handlers["sup"] = this.onTag_Simple;
+            this._handlers["sub"] = this.onTag_Simple;
+            this._handlers["color"] = this.onTag_COLOR;
+            this._handlers["font"] = this.onTag_FONT;
+            this._handlers["size"] = this.onTag_SIZE;
+        }
+        UBBParser.prototype.onTag_URL = function (tagName, end, attr) {
+            if (!end) {
+                if (attr != null)
+                    return "<a href=\"" + attr + "\" target=\"_blank\">";
+                else {
+                    var href = this.getTagText();
+                    return "<a href=\"" + href + "\" target=\"_blank\">";
+                }
+            }
+            else
+                return "</a>";
+        };
+        UBBParser.prototype.onTag_IMG = function (tagName, end, attr) {
+            if (!end) {
+                var src = this.getTagText(true);
+                if (!src)
+                    return null;
+                if (this.defaultImgWidth)
+                    return "<img src=\"" + src + "\" width=\"" + this.defaultImgWidth + "\" height=\"" + this.defaultImgHeight + "\"/>";
+                else
+                    return "<img src=\"" + src + "\"/>";
+            }
+            else
+                return null;
+        };
+        UBBParser.prototype.onTag_Simple = function (tagName, end, attr) {
+            return end ? ("</" + tagName + ">") : ("<" + tagName + ">");
+        };
+        UBBParser.prototype.onTag_COLOR = function (tagName, end, attr) {
+            if (!end)
+                return "<font color=\"" + attr + "\">";
+            else
+                return "</font>";
+        };
+        UBBParser.prototype.onTag_FONT = function (tagName, end, attr) {
+            if (!end)
+                return "<font face=\"" + attr + "\">";
+            else
+                return "</font>";
+        };
+        UBBParser.prototype.onTag_SIZE = function (tagName, end, attr) {
+            if (!end) {
+                if (attr == "normal")
+                    attr = "" + this.normalFontSize;
+                else if (attr == "small")
+                    attr = "" + this.smallFontSize;
+                else if (attr == "large")
+                    attr = "" + this.largeFontSize;
+                else if (attr.length && attr.charAt(0) == "+")
+                    attr = "" + (this.smallFontSize + parseInt(attr.substr(1)));
+                else if (attr.length && attr.charAt(0) == "-")
+                    attr = "" + (this.smallFontSize - parseInt(attr.substr(1)));
+                return "<font size=\"" + attr + "\">";
+            }
+            else
+                return "</font>";
+        };
+        UBBParser.prototype.getTagText = function (remove) {
+            if (remove === void 0) { remove = false; }
+            var pos1 = this._readPos;
+            var pos2;
+            var result = "";
+            while ((pos2 = this._text.indexOf("[", pos1)) != -1) {
+                if (this._text.charCodeAt(pos2 - 1) == 92) {
+                    result += this._text.substring(pos1, pos2 - 1);
+                    result += "[";
+                    pos1 = pos2 + 1;
+                }
+                else {
+                    result += this._text.substring(pos1, pos2);
+                    break;
+                }
+            }
+            if (pos2 == -1)
+                return null;
+            if (remove)
+                this._readPos = pos2;
+            return result;
+        };
+        UBBParser.prototype.parse = function (text, remove) {
+            this._text = text;
+            var pos1 = 0, pos2, pos3;
+            var end;
+            var tag, attr;
+            var repl;
+            var func;
+            var result = "";
+            while ((pos2 = this._text.indexOf("[", pos1)) != -1) {
+                if (pos2 > 0 && this._text.charCodeAt(pos2 - 1) == 92) {
+                    result += this._text.substring(pos1, pos2 - 1);
+                    result += "[";
+                    pos1 = pos2 + 1;
+                    continue;
+                }
+                result += this._text.substring(pos1, pos2);
+                pos1 = pos2;
+                pos2 = this._text.indexOf("]", pos1);
+                if (pos2 == -1)
+                    break;
+                end = this._text.charAt(pos1 + 1) == '/';
+                tag = this._text.substring(end ? pos1 + 2 : pos1 + 1, pos2);
+                this._readPos = pos2 + 1;
+                attr = null;
+                repl = null;
+                pos3 = tag.indexOf("=");
+                if (pos3 != -1) {
+                    attr = tag.substring(pos3 + 1);
+                    tag = tag.substring(0, pos3);
+                }
+                tag = tag.toLowerCase();
+                func = this._handlers[tag];
+                if (func != null) {
+                    if (!remove) {
+                        repl = func.call(this, tag, end, attr);
+                        if (repl != null)
+                            result += repl;
+                    }
+                }
+                else
+                    result += this._text.substring(pos1, this._readPos);
+                pos1 = this._readPos;
+            }
+            if (pos1 < this._text.length)
+                result += this._text.substr(pos1);
+            this._text = null;
+            return result;
+        };
+        UBBParser.inst = new UBBParser();
+        return UBBParser;
+    }());
+    fgui.UBBParser = UBBParser;
+})(fgui || (fgui = {}));
+
+(function (fgui) {
+    var ToolSet = (function () {
+        function ToolSet() {
+        }
+        ToolSet.startsWith = function (source, str, ignoreCase) {
+            if (!source)
+                return false;
+            else if (source.length < str.length)
+                return false;
+            else {
+                source = source.substring(0, str.length);
+                if (!ignoreCase)
+                    return source == str;
+                else
+                    return source.toLowerCase() == str.toLowerCase();
+            }
+        };
+        ToolSet.trimRight = function (targetString) {
+            var tempChar = "";
+            for (var i = targetString.length - 1; i >= 0; i--) {
+                tempChar = targetString.charAt(i);
+                if (tempChar != " " && tempChar != "\n" && tempChar != "\r") {
+                    break;
+                }
+            }
+            return targetString.substring(0, i + 1);
+        };
+        ToolSet.convertToHtmlColor = function (argb, hasAlpha) {
+            var alpha;
+            if (hasAlpha)
+                alpha = (argb >> 24 & 0xFF).toString(16);
+            else
+                alpha = "";
+            var red = (argb >> 16 & 0xFF).toString(16);
+            var green = (argb >> 8 & 0xFF).toString(16);
+            var blue = (argb & 0xFF).toString(16);
+            if (alpha.length == 1)
+                alpha = "0" + alpha;
+            if (red.length == 1)
+                red = "0" + red;
+            if (green.length == 1)
+                green = "0" + green;
+            if (blue.length == 1)
+                blue = "0" + blue;
+            return "#" + alpha + red + green + blue;
+        };
+        ToolSet.convertFromHtmlColor = function (str, hasAlpha) {
+            if (str.length < 1)
+                return 0;
+            if (str.charAt(0) == "#")
+                str = str.substr(1);
+            if (str.length == 8)
+                return (parseInt(str.substr(0, 2), 16) << 24) + parseInt(str.substr(2), 16);
+            else if (hasAlpha)
+                return 0xFF000000 + parseInt(str, 16);
+            else
+                return parseInt(str, 16);
+        };
+        ToolSet.displayObjectToGObject = function (obj) {
+            while (obj && !(obj instanceof egret.Stage)) {
+                if (obj["$owner"])
+                    return fgui.GObject.cast(obj);
+                obj = obj.parent;
+            }
+            return null;
+        };
+        ToolSet.encodeHTML = function (str) {
+            if (!str)
+                return "";
+            else
+                return str.replace(/&/g, "&amp;").replace(/</g, "&lt;")
+                    .replace(/>/g, "&gt;").replace(/'/g, "&apos;").replace(/"/g, "&quot;");
+        };
+        ToolSet.clamp = function (value, min, max) {
+            if (value < min)
+                value = min;
+            else if (value > max)
+                value = max;
+            return value;
+        };
+        ToolSet.clamp01 = function (value) {
+            if (value > 1)
+                value = 1;
+            else if (value < 0)
+                value = 0;
+            return value;
+        };
+        ToolSet.lerp = function (start, end, percent) {
+            return (start + percent * (end - start));
+        };
+        ToolSet.repeat = function (t, length) {
+            return t - Math.floor(t / length) * length;
+        };
+        ToolSet.distance = function (x1, y1, x2, y2) {
+            return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+        };
+        ToolSet.fillPath = function (ctx, points, px, py) {
+            var cnt = points.length;
+            ctx.moveTo(points[0] + px, points[1] + py);
+            for (var i = 2; i < cnt; i += 2)
+                ctx.lineTo(points[i] + px, points[i + 1] + py);
+            ctx.lineTo(points[0] + px, points[1] + py);
+        };
+        ToolSet.setColorFilter = function (obj, color) {
+            var filter = obj.$_colorFilter_;
+            var filters = obj.filters;
+            var toApplyColor;
+            var toApplyGray;
+            var tp = typeof (color);
+            if (tp == "boolean") {
+                toApplyColor = filter ? filter.$_color_ : null;
+                toApplyGray = color;
+            }
+            else {
+                toApplyColor = color == 0xFFFFFF ? null : color;
+                toApplyGray = filter ? filter.$_grayed_ : false;
+            }
+            if ((!toApplyColor && toApplyColor !== 0) && !toApplyGray) {
+                if (filters && filter) {
+                    var i = filters.indexOf(filter);
+                    if (i != -1) {
+                        filters.splice(i, 1);
+                        if (filters.length > 0)
+                            obj.filters = filters;
+                        else
+                            obj.filters = null;
+                    }
+                }
+                return;
+            }
+            if (!filter) {
+                filter = new egret.ColorMatrixFilter();
+                obj.$_colorFilter_ = filter;
+            }
+            if (!filters)
+                filters = [filter];
+            else {
+                var i_1 = filters.indexOf(filter);
+                if (i_1 == -1)
+                    filters.push(filter);
+            }
+            obj.filters = filters;
+            filter.$_color_ = toApplyColor;
+            filter.$_grayed_ = toApplyGray;
+            var mat = filter.matrix;
+            if (toApplyGray) {
+                for (var i_2 = 0; i_2 < 20; i_2++)
+                    mat[i_2] = grayScaleMatrix[i_2];
+            }
+            else if (toApplyColor instanceof Array) {
+                getColorMatrix(toApplyColor[0], toApplyColor[1], toApplyColor[2], toApplyColor[3], mat);
+            }
+            else {
+                for (var i_3 = 0; i_3 < 20; i_3++) {
+                    mat[i_3] = (i_3 == 0 || i_3 == 6 || i_3 == 12 || i_3 == 18) ? 1 : 0;
+                }
+                mat[0] = ((color >> 16) & 0xFF) / 255;
+                mat[6] = ((color >> 8) & 0xFF) / 255;
+                mat[12] = (color & 0xFF) / 255;
+            }
+            filter.matrix = mat;
+        };
+        return ToolSet;
+    }());
+    fgui.ToolSet = ToolSet;
+    var grayScaleMatrix = [
+        0.3, 0.6, 0, 0, 0,
+        0.3, 0.6, 0, 0, 0,
+        0.3, 0.6, 0, 0, 0,
+        0, 0, 0, 1, 0
+    ];
+    var helper = new fgui.ColorMatrix();
+    function getColorMatrix(p_brightness, p_contrast, p_saturation, p_hue, result) {
+        if (!result)
+            result = new Array(fgui.ColorMatrix.length);
+        helper.reset();
+        helper.adjustColor(p_brightness, p_contrast, p_saturation, p_hue);
+        helper.matrix.forEach(function (e, i) { return result[i] = e; });
+    }
+})(fgui || (fgui = {}));
diff --git a/demo/libs/fairygui/fairygui.min.js b/demo/libs/fairygui/fairygui.min.js
new file mode 100644
index 00000000..180e2cf7
--- /dev/null
+++ b/demo/libs/fairygui/fairygui.min.js
@@ -0,0 +1 @@
+window.fgui={},window.fairygui=window.fgui,window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var i in e)e.hasOwnProperty(i)&&(t[i]=e[i])};return function(e,i){function n(){this.constructor=e}t(e,i),e.prototype=null===i?Object.create(i):(n.prototype=i.prototype,new n)}}();var __awaiter=this&&this.__awaiter||function(t,e,i,n){return new(i||(i=Promise))(function(o,r){function s(t){try{h(n.next(t))}catch(t){r(t)}}function a(t){try{h(n.throw(t))}catch(t){r(t)}}function h(t){t.done?o(t.value):new i(function(e){e(t.value)}).then(s,a)}h((n=n.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var i,n,o,r,s={label:0,sent:function(){if(1&o[0])throw o[1];return o[1]},trys:[],ops:[]};return r={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(r[Symbol.iterator]=function(){return this}),r;function a(r){return function(a){return function(r){if(i)throw new TypeError("Generator is already executing.");for(;s;)try{if(i=1,n&&(o=2&r[0]?n.return:r[0]?n.throw||((o=n.return)&&o.call(n),0):n.next)&&!(o=o.call(n,r[1])).done)return o;switch(n=0,o&&(r=[2&r[0],o.value]),r[0]){case 0:case 1:o=r;break;case 4:return s.label++,{value:r[1],done:!1};case 5:s.label++,n=r[1],r=[0];continue;case 7:r=s.ops.pop(),s.trys.pop();continue;default:if(!(o=(o=s.trys).length>0&&o[o.length-1])&&(6===r[0]||2===r[0])){s=0;continue}if(3===r[0]&&(!o||r[1]>o[0]&&r[1]<o[3])){s.label=r[1];break}if(6===r[0]&&s.label<o[1]){s.label=o[1],o=r;break}if(o&&s.label<o[2]){s.label=o[2],s.ops.push(r);break}o[2]&&s.ops.pop(),s.trys.pop();continue}r=e.call(t,s)}catch(t){r=[6,t],n=0}finally{i=o=0}if(5&r[0])throw r[1];return{value:r[0]?r[1]:void 0,done:!0}}([r,a])}}};!function(t){var e=function(){function e(){this._itemList=new Array,this._objectPool=new Array}return e.prototype.createObject=function(e,i){var n=t.UIPackage.getByName(e);if(!n)throw new Error("package not found: "+e);var o=n.getItemByName(i);if(!o)throw new Error("resource not found: "+i);this.internalCreateObject(o)},e.prototype.createObjectFromURL=function(e){var i=t.UIPackage.getItemByURL(e);if(!i)throw new Error("resource not found: "+e);this.internalCreateObject(i)},e.prototype.cancel=function(){t.GTimers.inst.remove(this.run,this),this._itemList.length=0;var e=this._objectPool.length;if(e>0){for(var i=0;i<e;i++)this._objectPool[i].dispose();this._objectPool.length=0}},e.prototype.internalCreateObject=function(e){this._itemList.length=0,this._objectPool.length=0;var i={pi:e,type:e.objectType};i.childCount=this.collectComponentChildren(e),this._itemList.push(i),this._index=0,t.GTimers.inst.add(1,0,this.run,this)},e.prototype.collectComponentChildren=function(e){var i,n,o,r,s,a,h=e.rawData;h.seek(0,2);var l=h.readShort();for(o=0;o<l;o++){r=h.readShort(),s=h.position,h.seek(s,0);var c=h.readByte(),u=h.readS(),_=h.readS();h.position=s,null!=u?(i={pi:n=null!=(a=null!=_?t.UIPackage.getById(_):e.owner)?a.getItemById(u):null,type:c},null!=n&&n.type==t.PackageItemType.Component&&(i.childCount=this.collectComponentChildren(n))):(i={type:c},c==t.ObjectType.List&&(i.listItemCount=this.collectListChildren(h))),this._itemList.push(i),h.position=s+r}return l},e.prototype.collectListChildren=function(e){e.seek(e.position,8);var i,n,o,r,s,a=0,h=e.readS(),l=e.readShort();for(i=0;i<l;i++)n=e.readShort(),n+=e.position,null==(o=e.readS())&&(o=h),o&&(r=t.UIPackage.getItemByURL(o))&&(s={pi:r,type:r.objectType},r.type==t.PackageItemType.Component&&(s.childCount=this.collectComponentChildren(r)),this._itemList.push(s),a++),e.position=n;return a},e.prototype.run=function(){for(var e,i,n,o,r=egret.getTimer(),s=t.UIConfig.frameTimeForAsyncUIConstruction,a=this._itemList.length;this._index<a;){if((i=this._itemList[this._index]).pi)e=t.UIObjectFactory.newObject(i.pi),this._objectPool.push(e),t.UIPackage._constructing++,i.pi.type==t.PackageItemType.Component?(n=this._objectPool.length-i.childCount-1,e.constructFromResource2(this._objectPool,n),this._objectPool.splice(n,i.childCount)):e.constructFromResource(),t.UIPackage._constructing--;else if(e=t.UIObjectFactory.newObject(i.type),this._objectPool.push(e),i.type==t.ObjectType.List&&i.listItemCount>0){for(n=this._objectPool.length-i.listItemCount-1,o=0;o<i.listItemCount;o++)e.itemPool.returnObject(this._objectPool[o+n]);this._objectPool.splice(n,i.listItemCount)}if(this._index++,this._index%5==0&&egret.getTimer()-r>=s)return}t.GTimers.inst.remove(this.run,this);var h=this._objectPool[0];this._itemList.length=0,this._objectPool.length=0,null!=this.callback&&this.callback.call(this.callbackObj,h)},e}();t.AsyncOperation=e}(fgui||(fgui={})),function(t){var e=0,i=function(i){function n(){var t=i.call(this)||this;return t._pageIds=[],t._pageNames=[],t._selectedIndex=-1,t._previousIndex=-1,t}return __extends(n,i),n.prototype.dispose=function(){},Object.defineProperty(n.prototype,"selectedIndex",{get:function(){return this._selectedIndex},set:function(e){if(this._selectedIndex!=e){if(e>this._pageIds.length-1)throw"index out of bounds: "+e;this.changing=!0,this._previousIndex=this._selectedIndex,this._selectedIndex=e,this.parent.applyController(this),this.dispatchEvent(new t.StateChangeEvent(t.StateChangeEvent.CHANGED)),this.changing=!1}},enumerable:!0,configurable:!0}),n.prototype.setSelectedIndex=function(t){if(this._selectedIndex!=t){if(t>this._pageIds.length-1)throw"index out of bounds: "+t;this.changing=!0,this._previousIndex=this._selectedIndex,this._selectedIndex=t,this.parent.applyController(this),this.changing=!1}},Object.defineProperty(n.prototype,"previsousIndex",{get:function(){return this._previousIndex},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"selectedPage",{get:function(){return-1==this._selectedIndex?null:this._pageNames[this._selectedIndex]},set:function(t){var e=this._pageNames.indexOf(t);-1==e&&(e=0),this.selectedIndex=e},enumerable:!0,configurable:!0}),n.prototype.setSelectedPage=function(t){var e=this._pageNames.indexOf(t);-1==e&&(e=0),this.setSelectedIndex(e)},Object.defineProperty(n.prototype,"previousPage",{get:function(){return-1==this._previousIndex?null:this._pageNames[this._previousIndex]},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"pageCount",{get:function(){return this._pageIds.length},enumerable:!0,configurable:!0}),n.prototype.getPageName=function(t){return this._pageNames[t]},n.prototype.addPage=function(t){this.addPageAt(t||"",this._pageIds.length)},n.prototype.addPageAt=function(t,i){var n=""+e++;i==this._pageIds.length?(this._pageIds.push(n),this._pageNames.push(t)):(this._pageIds.splice(i,0,n),this._pageNames.splice(i,0,t))},n.prototype.removePage=function(t){var e=this._pageNames.indexOf(t);-1!=e&&(this._pageIds.splice(e,1),this._pageNames.splice(e,1),this._selectedIndex>=this._pageIds.length?this.selectedIndex=this._selectedIndex-1:this.parent.applyController(this))},n.prototype.removePageAt=function(t){void 0===t&&(t=0),this._pageIds.splice(t,1),this._pageNames.splice(t,1),this._selectedIndex>=this._pageIds.length?this.selectedIndex=this._selectedIndex-1:this.parent.applyController(this)},n.prototype.clearPages=function(){this._pageIds.length=0,this._pageNames.length=0,-1!=this._selectedIndex?this.selectedIndex=-1:this.parent.applyController(this)},n.prototype.hasPage=function(t){return-1!=this._pageNames.indexOf(t)},n.prototype.getPageIndexById=function(t){return this._pageIds.indexOf(t)},n.prototype.getPageIdByName=function(t){var e=this._pageNames.indexOf(t);return-1!=e?this._pageIds[e]:null},n.prototype.getPageNameById=function(t){var e=this._pageIds.indexOf(t);return-1!=e?this._pageNames[e]:null},n.prototype.getPageId=function(t){return void 0===t&&(t=0),this._pageIds[t]},Object.defineProperty(n.prototype,"selectedPageId",{get:function(){return-1==this._selectedIndex?null:this._pageIds[this._selectedIndex]},set:function(t){var e=this._pageIds.indexOf(t);this.selectedIndex=e},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"oppositePageId",{set:function(t){this._pageIds.indexOf(t)>0?this.selectedIndex=0:this._pageIds.length>1&&(this.selectedIndex=1)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"previousPageId",{get:function(){return-1==this._previousIndex?null:this._pageIds[this._previousIndex]},enumerable:!0,configurable:!0}),n.prototype.runActions=function(){if(this._actions)for(var t=this._actions.length,e=0;e<t;e++)this._actions[e].run(this,this.previousPageId,this.selectedPageId)},n.prototype.setup=function(e){var i,n,o=e.position;e.seek(o,0),this.name=e.readS(),e.readBool()&&(this.autoRadioGroupDepth=!0),e.seek(o,1);var r=e.readShort();for(i=0;i<r;i++)this._pageIds.push(e.readS()),this._pageNames.push(e.readS());var s=0;if(e.version>=2)switch(e.readByte()){case 1:s=e.readShort();break;case 2:-1==(s=this._pageNames.indexOf(t.UIPackage.branch))&&(s=0);break;case 3:-1==(s=this._pageNames.indexOf(t.UIPackage.getVar(e.readS())))&&(s=0)}if(e.seek(o,2),(r=e.readShort())>0)for(this._actions||(this._actions=new Array),i=0;i<r;i++){n=e.readShort(),n+=e.position;var a=t.ControllerAction.createAction(e.readByte());a.setup(e),this._actions.push(a),e.position=n}this.parent&&this._pageIds.length>0?this._selectedIndex=s:this._selectedIndex=-1},n}(egret.EventDispatcher);t.Controller=i}(fgui||(fgui={})),function(t){var e=function(){function e(){this._agent=new t.GLoader,this._agent.draggable=!0,this._agent.touchable=!1,this._agent.setSize(100,100),this._agent.setPivot(.5,.5,!0),this._agent.align=t.AlignType.Center,this._agent.verticalAlign=t.VertAlignType.Middle,this._agent.sortingOrder=1e6,this._agent.addEventListener(t.DragEvent.DRAG_END,this.__dragEnd,this)}return Object.defineProperty(e,"inst",{get:function(){return null==e._inst&&(e._inst=new e),e._inst},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dragAgent",{get:function(){return this._agent},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dragging",{get:function(){return null!=this._agent.parent},enumerable:!0,configurable:!0}),e.prototype.startDrag=function(e,i,n,o){if(!this._agent.parent){this._sourceData=n,this._agent.url=i,t.GRoot.inst.addChild(this._agent);var r=t.GRoot.inst.globalToLocal(t.GRoot.mouseX,t.GRoot.mouseY);this._agent.setXY(r.x,r.y),this._agent.startDrag(o)}},e.prototype.cancel=function(){this._agent.parent&&(this._agent.stopDrag(),t.GRoot.inst.removeChild(this._agent),this._sourceData=null)},e.prototype.__dragEnd=function(e){if(null!=this._agent.parent){t.GRoot.inst.removeChild(this._agent);var i=this._sourceData;this._sourceData=null;for(var n=t.GRoot.inst.getObjectUnderPoint(e.stageX,e.stageY);n;){if(n.hasEventListener(t.DropEvent.DROP)){var o=new t.DropEvent(t.DropEvent.DROP,i);return n.requestFocus(),void n.dispatchEvent(o)}n=n.parent}}},e}();t.DragDropManager=e}(fgui||(fgui={})),function(t){!function(t){t[t.Common=0]="Common",t[t.Check=1]="Check",t[t.Radio=2]="Radio"}(t.ButtonMode||(t.ButtonMode={})),function(t){t[t.None=0]="None",t[t.Both=1]="Both",t[t.Height=2]="Height"}(t.AutoSizeType||(t.AutoSizeType={})),function(t){t[t.Left=0]="Left",t[t.Center=1]="Center",t[t.Right=2]="Right"}(t.AlignType||(t.AlignType={})),function(t){t[t.Top=0]="Top",t[t.Middle=1]="Middle",t[t.Bottom=2]="Bottom"}(t.VertAlignType||(t.VertAlignType={})),function(t){t[t.None=0]="None",t[t.Scale=1]="Scale",t[t.ScaleMatchHeight=2]="ScaleMatchHeight",t[t.ScaleMatchWidth=3]="ScaleMatchWidth",t[t.ScaleFree=4]="ScaleFree",t[t.ScaleNoBorder=5]="ScaleNoBorder"}(t.LoaderFillType||(t.LoaderFillType={})),function(t){t[t.SingleColumn=0]="SingleColumn",t[t.SingleRow=1]="SingleRow",t[t.FlowHorizontal=2]="FlowHorizontal",t[t.FlowVertical=3]="FlowVertical",t[t.Pagination=4]="Pagination"}(t.ListLayoutType||(t.ListLayoutType={})),function(t){t[t.Single=0]="Single",t[t.Multiple=1]="Multiple",t[t.Multiple_SingleClick=2]="Multiple_SingleClick",t[t.None=3]="None"}(t.ListSelectionMode||(t.ListSelectionMode={})),function(t){t[t.Visible=0]="Visible",t[t.Hidden=1]="Hidden",t[t.Scroll=2]="Scroll"}(t.OverflowType||(t.OverflowType={})),function(t){t[t.Image=0]="Image",t[t.MovieClip=1]="MovieClip",t[t.Sound=2]="Sound",t[t.Component=3]="Component",t[t.Atlas=4]="Atlas",t[t.Font=5]="Font",t[t.Swf=6]="Swf",t[t.Misc=7]="Misc",t[t.Unknown=8]="Unknown",t[t.Spine=9]="Spine",t[t.DragonBones=10]="DragonBones"}(t.PackageItemType||(t.PackageItemType={})),function(t){t[t.Image=0]="Image",t[t.MovieClip=1]="MovieClip",t[t.Swf=2]="Swf",t[t.Graph=3]="Graph",t[t.Loader=4]="Loader",t[t.Group=5]="Group",t[t.Text=6]="Text",t[t.RichText=7]="RichText",t[t.InputText=8]="InputText",t[t.Component=9]="Component",t[t.List=10]="List",t[t.Label=11]="Label",t[t.Button=12]="Button",t[t.ComboBox=13]="ComboBox",t[t.ProgressBar=14]="ProgressBar",t[t.Slider=15]="Slider",t[t.ScrollBar=16]="ScrollBar",t[t.Tree=17]="Tree",t[t.Loader3D=18]="Loader3D"}(t.ObjectType||(t.ObjectType={})),function(t){t[t.Percent=0]="Percent",t[t.ValueAndMax=1]="ValueAndMax",t[t.Value=2]="Value",t[t.Max=3]="Max"}(t.ProgressTitleType||(t.ProgressTitleType={})),function(t){t[t.Default=0]="Default",t[t.Visible=1]="Visible",t[t.Auto=2]="Auto",t[t.Hidden=3]="Hidden"}(t.ScrollBarDisplayType||(t.ScrollBarDisplayType={})),function(t){t[t.Horizontal=0]="Horizontal",t[t.Vertical=1]="Vertical",t[t.Both=2]="Both"}(t.ScrollType||(t.ScrollType={})),function(t){t[t.None=0]="None",t[t.Horizontal=1]="Horizontal",t[t.Vertical=2]="Vertical",t[t.Both=3]="Both"}(t.FlipType||(t.FlipType={})),function(t){t[t.Ascent=0]="Ascent",t[t.Descent=1]="Descent",t[t.Arch=2]="Arch"}(t.ChildrenRenderOrder||(t.ChildrenRenderOrder={})),function(t){t[t.None=0]="None",t[t.Horizontal=1]="Horizontal",t[t.Vertical=2]="Vertical"}(t.GroupLayoutType||(t.GroupLayoutType={})),function(t){t[t.Auto=0]="Auto",t[t.Up=1]="Up",t[t.Down=2]="Down"}(t.PopupDirection||(t.PopupDirection={})),function(t){t[t.Left_Left=0]="Left_Left",t[t.Left_Center=1]="Left_Center",t[t.Left_Right=2]="Left_Right",t[t.Center_Center=3]="Center_Center",t[t.Right_Left=4]="Right_Left",t[t.Right_Center=5]="Right_Center",t[t.Right_Right=6]="Right_Right",t[t.Top_Top=7]="Top_Top",t[t.Top_Middle=8]="Top_Middle",t[t.Top_Bottom=9]="Top_Bottom",t[t.Middle_Middle=10]="Middle_Middle",t[t.Bottom_Top=11]="Bottom_Top",t[t.Bottom_Middle=12]="Bottom_Middle",t[t.Bottom_Bottom=13]="Bottom_Bottom",t[t.Width=14]="Width",t[t.Height=15]="Height",t[t.LeftExt_Left=16]="LeftExt_Left",t[t.LeftExt_Right=17]="LeftExt_Right",t[t.RightExt_Left=18]="RightExt_Left",t[t.RightExt_Right=19]="RightExt_Right",t[t.TopExt_Top=20]="TopExt_Top",t[t.TopExt_Bottom=21]="TopExt_Bottom",t[t.BottomExt_Top=22]="BottomExt_Top",t[t.BottomExt_Bottom=23]="BottomExt_Bottom",t[t.Size=24]="Size"}(t.RelationType||(t.RelationType={})),function(t){t[t.None=0]="None",t[t.Horizontal=1]="Horizontal",t[t.Vertical=2]="Vertical",t[t.Radial90=3]="Radial90",t[t.Radial180=4]="Radial180",t[t.Radial360=5]="Radial360"}(t.FillMethod||(t.FillMethod={})),function(t){t[t.Top=0]="Top",t[t.Bottom=1]="Bottom",t[t.Left=2]="Left",t[t.Right=3]="Right",t[t.TopLeft=0]="TopLeft",t[t.TopRight=1]="TopRight",t[t.BottomLeft=2]="BottomLeft",t[t.BottomRight=3]="BottomRight"}(t.FillOrigin||(t.FillOrigin={})),function(t){t[t.TopLeft=0]="TopLeft",t[t.TopRight=1]="TopRight",t[t.BottomLeft=2]="BottomLeft",t[t.BottomRight=3]="BottomRight"}(t.FillOrigin90||(t.FillOrigin90={})),function(t){t[t.Text=0]="Text",t[t.Icon=1]="Icon",t[t.Color=2]="Color",t[t.OutlineColor=3]="OutlineColor",t[t.Playing=4]="Playing",t[t.Frame=5]="Frame",t[t.DeltaTime=6]="DeltaTime",t[t.TimeScale=7]="TimeScale",t[t.FontSize=8]="FontSize",t[t.Selected=9]="Selected"}(t.ObjectPropID||(t.ObjectPropID={}))}(fgui||(fgui={})),function(t){var e=function(e){function h(){var i=e.call(this)||this;return i._x=0,i._y=0,i._alpha=1,i._rotation=0,i._visible=!0,i._touchable=!0,i._scaleX=1,i._scaleY=1,i._skewX=0,i._skewY=0,i._pivotX=0,i._pivotY=0,i._pivotOffsetX=0,i._pivotOffsetY=0,i._sortingOrder=0,i._internalVisible=!0,i._disposed=!1,i.sourceWidth=0,i.sourceHeight=0,i.initWidth=0,i.initHeight=0,i.minWidth=0,i.minHeight=0,i.maxWidth=0,i.maxHeight=0,i._width=0,i._height=0,i._rawWidth=0,i._rawHeight=0,i._sizePercentInGroup=0,i._id=""+n++,i._name="",i.createDisplayObject(),i._relations=new t.Relations(i),i._gears=new Array(10),i}return __extends(h,e),Object.defineProperty(h.prototype,"id",{get:function(){return this._id},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"name",{get:function(){return this._name},set:function(t){this._name=t},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"x",{get:function(){return this._x},set:function(t){this.setXY(t,this._y)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"y",{get:function(){return this._y},set:function(t){this.setXY(this._x,t)},enumerable:!0,configurable:!0}),h.prototype.setXY=function(e,n){if(this._x!=e||this._y!=n){var o=e-this._x,s=n-this._y;this._x=e,this._y=n,this.handleXYChanged(),this instanceof t.GGroup&&this.moveChildren(o,s),this.updateGear(1),!this._parent||this._parent instanceof t.GList||(this._parent.setBoundsChangedFlag(),this._group&&this._group.setBoundsChangedFlag(!0),this.dispatchEventWith(h.XY_CHANGED)),h.draggingObject!=this||i||this.localToGlobalRect(0,0,this._width,this._height,r)}},Object.defineProperty(h.prototype,"xMin",{get:function(){return this._pivotAsAnchor?this._x-this._width*this._pivotX:this._x},set:function(t){this._pivotAsAnchor?this.setXY(t+this._width*this._pivotX,this._y):this.setXY(t,this._y)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"yMin",{get:function(){return this._pivotAsAnchor?this._y-this._height*this._pivotY:this._y},set:function(t){this._pivotAsAnchor?this.setXY(this._x,t+this._height*this._pivotY):this.setXY(this._x,t)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"pixelSnapping",{get:function(){return this._pixelSnapping},set:function(t){this._pixelSnapping!=t&&(this._pixelSnapping=t,this.handleXYChanged())},enumerable:!0,configurable:!0}),h.prototype.center=function(e){var i;i=this._parent?this.parent:this.root,this.setXY((i.width-this._width)/2,(i.height-this._height)/2),e&&(this.addRelation(i,t.RelationType.Center_Center),this.addRelation(i,t.RelationType.Middle_Middle))},Object.defineProperty(h.prototype,"width",{get:function(){return this.ensureSizeCorrect(),this._relations.sizeDirty&&this._relations.ensureRelationsSizeCorrect(),this._width},set:function(t){this.setSize(t,this._rawHeight)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"height",{get:function(){return this.ensureSizeCorrect(),this._relations.sizeDirty&&this._relations.ensureRelationsSizeCorrect(),this._height},set:function(t){this.setSize(this._rawWidth,t)},enumerable:!0,configurable:!0}),h.prototype.setSize=function(e,i,n){if(this._rawWidth!=e||this._rawHeight!=i){this._rawWidth=e,this._rawHeight=i,e<this.minWidth&&(e=this.minWidth),i<this.minHeight&&(i=this.minHeight),this.maxWidth>0&&e>this.maxWidth&&(e=this.maxWidth),this.maxHeight>0&&i>this.maxHeight&&(i=this.maxHeight);var o=e-this._width,r=i-this._height;this._width=e,this._height=i,this.handleSizeChanged(),0==this._pivotX&&0==this._pivotY||(this._pivotAsAnchor?this.applyPivot():(n||this.setXY(this.x-this._pivotX*o,this.y-this._pivotY*r),this.updatePivotOffset())),this instanceof t.GGroup&&this.resizeChildren(o,r),this.updateGear(2),this._parent&&(this._relations.onOwnerSizeChanged(o,r,this._pivotAsAnchor||!n),this._parent.setBoundsChangedFlag(),this._group&&this._group.setBoundsChangedFlag()),this.dispatchEventWith(h.SIZE_CHANGED)}},h.prototype.makeFullScreen=function(){this.setSize(t.GRoot.inst.width,t.GRoot.inst.height)},h.prototype.ensureSizeCorrect=function(){},Object.defineProperty(h.prototype,"actualWidth",{get:function(){return this.width*Math.abs(this._scaleX)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"actualHeight",{get:function(){return this.height*Math.abs(this._scaleY)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"scaleX",{get:function(){return this._scaleX},set:function(t){this.setScale(t,this._scaleY)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"scaleY",{get:function(){return this._scaleY},set:function(t){this.setScale(this._scaleX,t)},enumerable:!0,configurable:!0}),h.prototype.setScale=function(t,e){this._scaleX==t&&this._scaleY==e||(this._scaleX=t,this._scaleY=e,this.handleScaleChanged(),this.applyPivot(),this.updateGear(2))},Object.defineProperty(h.prototype,"skewX",{get:function(){return this._skewX},set:function(t){this.setSkew(t,this._skewY)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"skewY",{get:function(){return this._skewY},set:function(t){this.setSkew(this._skewX,t)},enumerable:!0,configurable:!0}),h.prototype.setSkew=function(t,e){this._skewX==t&&this._skewY==e||(this._skewX=t,this._skewY=e,this._displayObject&&(this._displayObject.skewX=t,this._displayObject.skewY=e),this.applyPivot())},Object.defineProperty(h.prototype,"pivotX",{get:function(){return this._pivotX},set:function(t){this.setPivot(t,this._pivotY)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"pivotY",{get:function(){return this._pivotY},set:function(t){this.setPivot(this._pivotX,t)},enumerable:!0,configurable:!0}),h.prototype.setPivot=function(t,e,i){this._pivotX==t&&this._pivotY==e&&this._pivotAsAnchor==i||(this._pivotX=t,this._pivotY=e,this._pivotAsAnchor=i,this.updatePivotOffset(),this.handleXYChanged())},Object.defineProperty(h.prototype,"pivotAsAnchor",{get:function(){return this._pivotAsAnchor},enumerable:!0,configurable:!0}),h.prototype.internalSetPivot=function(t,e,i){this._pivotX=t,this._pivotY=e,this._pivotAsAnchor=i,i&&this.handleXYChanged()},h.prototype.updatePivotOffset=function(){if(this._displayObject)if(0!=this._pivotX||0!=this._pivotY){var t=this._pivotX*this._width,e=this._pivotY*this._height,i=this._displayObject.matrix.transformPoint(t,e,s);this._pivotOffsetX=this._pivotX*this._width-(i.x-this._displayObject.x),this._pivotOffsetY=this._pivotY*this._height-(i.y-this._displayObject.y)}else this._pivotOffsetX=0,this._pivotOffsetY=0},h.prototype.applyPivot=function(){0==this._pivotX&&0==this._pivotY||(this.updatePivotOffset(),this.handleXYChanged())},Object.defineProperty(h.prototype,"touchable",{get:function(){return this._touchable},set:function(e){if(this._touchable!=e){if(this._touchable=e,this.updateGear(3),this instanceof t.GImage||this instanceof t.GMovieClip||this instanceof t.GTextField&&!(this instanceof t.GTextInput)&&!(this instanceof t.GRichTextField))return;this._displayObject&&(this._displayObject.touchEnabled=this._touchable,this._displayObject instanceof egret.DisplayObjectContainer&&(this._displayObject.touchChildren=this._touchable))}},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"grayed",{get:function(){return this._grayed},set:function(t){this._grayed!=t&&(this._grayed=t,this.handleGrayedChanged(),this.updateGear(3))},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"enabled",{get:function(){return!this._grayed&&this._touchable},set:function(t){this.grayed=!t,this.touchable=t},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"rotation",{get:function(){return this._rotation},set:function(t){this._rotation!=t&&(this._rotation=t,this._displayObject&&(this._displayObject.rotation=this.normalizeRotation),this.applyPivot(),this.updateGear(3))},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"normalizeRotation",{get:function(){var t=this._rotation%360;return t>180?t-=360:t<-180&&(t+=360),t},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"alpha",{get:function(){return this._alpha},set:function(t){this._alpha!=t&&(this._alpha=t,this.handleAlphaChanged(),this.updateGear(3))},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"visible",{get:function(){return this._visible},set:function(t){this._visible!=t&&(this._visible=t,this.handleVisibleChanged(),this._parent&&this._parent.setBoundsChangedFlag(),this._group&&this._group.excludeInvisibles&&this._group.setBoundsChangedFlag())},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"internalVisible",{get:function(){return this._internalVisible&&(!this._group||this._group.internalVisible)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"internalVisible2",{get:function(){return this._visible&&(!this._group||this._group.internalVisible2)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"internalVisible3",{get:function(){return this._visible&&this._internalVisible},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"sortingOrder",{get:function(){return this._sortingOrder},set:function(t){if(t<0&&(t=0),this._sortingOrder!=t){var e=this._sortingOrder;this._sortingOrder=t,this._parent&&this._parent.childSortingOrderChanged(this,e,this._sortingOrder)}},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"focused",{get:function(){return this.root.focus==this},enumerable:!0,configurable:!0}),h.prototype.requestFocus=function(){this.root.focus=this},Object.defineProperty(h.prototype,"tooltips",{get:function(){return this._tooltips},set:function(t){this._tooltips=t},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"blendMode",{get:function(){return this._displayObject.blendMode},set:function(t){this._displayObject.blendMode=t},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"filters",{get:function(){return this._displayObject.filters},set:function(t){this._displayObject.filters=t},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"inContainer",{get:function(){return null!=this._displayObject&&null!=this._displayObject.parent},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"onStage",{get:function(){return null!=this._displayObject&&null!=this._displayObject.stage},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"resourceURL",{get:function(){return this.packageItem?"ui://"+this.packageItem.owner.id+this.packageItem.id:null},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"group",{get:function(){return this._group},set:function(t){this._group!=t&&(this._group&&this._group.setBoundsChangedFlag(),this._group=t,this._group&&this._group.setBoundsChangedFlag())},enumerable:!0,configurable:!0}),h.prototype.getGear=function(e){var i=this._gears[e];return null==i&&(this._gears[e]=i=t.GearBase.create(this,e)),i},h.prototype.updateGear=function(t){if(!this._underConstruct&&!this._gearLocked){var e=this._gears[t];e&&e.controller&&e.updateState()}},h.prototype.checkGearController=function(t,e){return null!=this._gears[t]&&this._gears[t].controller==e},h.prototype.updateGearFromRelations=function(t,e,i){this._gears[t]&&this._gears[t].updateFromRelations(e,i)},h.prototype.addDisplayLock=function(){var t=this._gears[0];if(t&&t.controller){var e=t.addLock();return this.checkGearDisplay(),e}return 0},h.prototype.releaseDisplayLock=function(t){var e=this._gears[0];e&&e.controller&&(e.releaseLock(t),this.checkGearDisplay())},h.prototype.checkGearDisplay=function(){if(!this._handlingController){var t=null==this._gears[0]||this._gears[0].connected;this._gears[8]&&(t=this._gears[8].evaluate(t)),t!=this._internalVisible&&(this._internalVisible=t,this._parent&&this._parent.childStateChanged(this),this._group&&this._group.excludeInvisibles&&this._group.setBoundsChangedFlag())}},Object.defineProperty(h.prototype,"gearXY",{get:function(){return this.getGear(1)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"gearSize",{get:function(){return this.getGear(2)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"gearLook",{get:function(){return this.getGear(3)},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"relations",{get:function(){return this._relations},enumerable:!0,configurable:!0}),h.prototype.addRelation=function(t,e,i){this._relations.add(t,e,i)},h.prototype.removeRelation=function(t,e){this._relations.remove(t,e||0)},Object.defineProperty(h.prototype,"displayObject",{get:function(){return this._displayObject},enumerable:!0,configurable:!0}),h.prototype.setDisplayObject=function(t){this._displayObject!=t&&(this._displayObject&&delete this._displayObject.$owner,this._displayObject=t,this._displayObject.$owner=this)},Object.defineProperty(h.prototype,"parent",{get:function(){return this._parent},set:function(t){this._parent=t},enumerable:!0,configurable:!0}),h.prototype.removeFromParent=function(){this._parent&&this._parent.removeChild(this)},Object.defineProperty(h.prototype,"root",{get:function(){if(this instanceof t.GRoot)return this;for(var e=this._parent;e;){if(e instanceof t.GRoot)return e;e=e.parent}return t.GRoot.inst},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asCom",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asButton",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asLabel",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asProgress",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asTextField",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asRichTextField",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asTextInput",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asLoader",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asList",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asTree",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asGraph",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asGroup",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asSlider",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asComboBox",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asImage",{get:function(){return this},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"asMovieClip",{get:function(){return this},enumerable:!0,configurable:!0}),h.cast=function(t){return t.$owner},Object.defineProperty(h.prototype,"text",{get:function(){return null},set:function(t){},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"icon",{get:function(){return null},set:function(t){},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"isDisposed",{get:function(){return this._disposed},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"treeNode",{get:function(){return this._treeNode},enumerable:!0,configurable:!0}),h.prototype.dispose=function(){if(!this._disposed){this._disposed=!0,this.removeFromParent(),this._relations.dispose(),this._displayObject=null;for(var t=0;t<10;t++){var e=this._gears[t];e&&e.dispose()}}},h.prototype.addClickListener=function(t,e){this.addEventListener(egret.TouchEvent.TOUCH_TAP,t,e)},h.prototype.removeClickListener=function(t,e){this.removeEventListener(egret.TouchEvent.TOUCH_TAP,t,e)},h.prototype.hasClickListener=function(){return this.hasEventListener(egret.TouchEvent.TOUCH_TAP)},h.prototype.addEventListener=function(t,i,n){e.prototype.addEventListener.call(this,t,i,n),this._displayObject&&this._displayObject.addEventListener(t,this._reDispatch,this)},h.prototype.removeEventListener=function(t,i,n){e.prototype.removeEventListener.call(this,t,i,n),this._displayObject&&!this.hasEventListener(t)&&this._displayObject.removeEventListener(t,this._reDispatch,this)},h.prototype._reDispatch=function(t){this.dispatchEvent(t)},Object.defineProperty(h.prototype,"draggable",{get:function(){return this._draggable},set:function(t){this._draggable!=t&&(this._draggable=t,this.initDrag())},enumerable:!0,configurable:!0}),Object.defineProperty(h.prototype,"dragBounds",{get:function(){return this._dragBounds},set:function(t){this._dragBounds=t},enumerable:!0,configurable:!0}),h.prototype.startDrag=function(t,e,i){null!=this._displayObject.stage&&this.dragBegin(t,e,i)},h.prototype.stopDrag=function(){this.dragEnd()},Object.defineProperty(h.prototype,"dragging",{get:function(){return h.draggingObject==this},enumerable:!0,configurable:!0}),h.prototype.localToGlobal=function(t,e,i){return t=t||0,e=e||0,this._pivotAsAnchor&&(t+=this._pivotX*this._width,e+=this._pivotY*this._height),this._displayObject.localToGlobal(t,e,i)},h.prototype.globalToLocal=function(t,e,i){t=t||0,e=e||0;var n=this._displayObject.globalToLocal(t,e,i);return this._pivotAsAnchor&&(n.x-=this._pivotX*this._width,n.y-=this._pivotY*this._height),n},h.prototype.localToRoot=function(e,i,n){e=e||0,i=i||0;var o=this._displayObject.localToGlobal(e,i,n);return o.x/=t.GRoot.contentScaleFactor,o.y/=t.GRoot.contentScaleFactor,o},h.prototype.rootToLocal=function(e,i,n){return e=e||0,i=i||0,e*=t.GRoot.contentScaleFactor,i*=t.GRoot.contentScaleFactor,this._displayObject.globalToLocal(e,i,n)},h.prototype.localToGlobalRect=function(t,e,i,n,o){t=t||0,e=e||0,i=i||0,n=n||0,o=o||new egret.Rectangle;var r=this.localToGlobal(t,e);return o.x=r.x,o.y=r.y,r=this.localToGlobal(t+i,e+n),o.right=r.x,o.bottom=r.y,o},h.prototype.globalToLocalRect=function(t,e,i,n,o){t=t||0,e=e||0,i=i||0,n=n||0,o=o||new egret.Rectangle;var r=this.globalToLocal(t,e);return o.x=r.x,o.y=r.y,r=this.globalToLocal(t+i,e+n),o.right=r.x,o.bottom=r.y,o},h.prototype.handleControllerChanged=function(t){this._handlingController=!0;for(var e=0;e<10;e++){var i=this._gears[e];i&&i.controller==t&&i.apply()}this._handlingController=!1,this.checkGearDisplay()},h.prototype.createDisplayObject=function(){},h.prototype.switchDisplayObject=function(e){if(e!=this._displayObject){var i=this._displayObject;if(this._displayObject&&this._displayObject.parent){var n=this._displayObject.parent.getChildIndex(this._displayObject);this._displayObject.parent.addChildAt(e,n),this._displayObject.parent.removeChild(this._displayObject)}this._displayObject=e,this._displayObject.x=i.x,this._displayObject.y=i.y,this._displayObject.rotation=i.rotation,this._displayObject.alpha=i.alpha,this._displayObject.visible=i.visible,this._displayObject.touchEnabled=i.touchEnabled,this._displayObject.scaleX=i.scaleX,this._displayObject.scaleY=i.scaleY,t.ToolSet.setColorFilter(this._displayObject,this._grayed),this._displayObject instanceof egret.DisplayObjectContainer&&(this._displayObject.touchChildren=this._touchable)}},h.prototype.handleXYChanged=function(){if(this._displayObject){var t=this._x,e=this._y;this._pivotAsAnchor&&(t-=this._pivotX*this._width,e-=this._pivotY*this._height),this._pixelSnapping&&(t=Math.round(t),e=Math.round(e)),this._displayObject.x=t+this._pivotOffsetX,this._displayObject.y=e+this._pivotOffsetY}},h.prototype.handleSizeChanged=function(){this._displayObject&&(this._displayObject.width=this._width,this._displayObject.height=this._height)},h.prototype.handleScaleChanged=function(){this._displayObject&&(this._displayObject.scaleX=this._scaleX,this._displayObject.scaleY=this._scaleY)},h.prototype.handleGrayedChanged=function(){this._displayObject&&t.ToolSet.setColorFilter(this._displayObject,this._grayed)},h.prototype.handleAlphaChanged=function(){this._displayObject&&(this._displayObject.alpha=this._alpha)},h.prototype.handleVisibleChanged=function(){this._displayObject&&(this._displayObject.visible=this.internalVisible2),this instanceof t.GGroup&&this.handleVisibleChanged()},h.prototype.getProp=function(e){switch(e){case t.ObjectPropID.Text:return this.text;case t.ObjectPropID.Icon:return this.icon;case t.ObjectPropID.Color:case t.ObjectPropID.OutlineColor:return NaN;case t.ObjectPropID.Playing:return!1;case t.ObjectPropID.Frame:case t.ObjectPropID.DeltaTime:return 0;case t.ObjectPropID.TimeScale:return 1;case t.ObjectPropID.FontSize:return 0;case t.ObjectPropID.Selected:return!1;default:return}},h.prototype.setProp=function(e,i){switch(e){case t.ObjectPropID.Text:this.text=i;break;case t.ObjectPropID.Icon:this.icon=i}},h.prototype.constructFromResource=function(){},h.prototype.setup_beforeAdd=function(e,i){var n,o;e.seek(i,0),e.skip(5),this._id=e.readS(),this._name=e.readS(),n=e.readInt(),o=e.readInt(),this.setXY(n,o),e.readBool()&&(this.initWidth=e.readInt(),this.initHeight=e.readInt(),this.setSize(this.initWidth,this.initHeight,!0)),e.readBool()&&(this.minWidth=e.readInt(),this.maxWidth=e.readInt(),this.minHeight=e.readInt(),this.maxHeight=e.readInt()),e.readBool()&&(n=e.readFloat(),o=e.readFloat(),this.setScale(n,o)),e.readBool()&&(n=e.readFloat(),o=e.readFloat(),this.setSkew(n,o)),e.readBool()&&(n=e.readFloat(),o=e.readFloat(),this.setPivot(n,o,e.readBool())),1!=(n=e.readFloat())&&(this.alpha=n),0!=(n=e.readFloat())&&(this.rotation=n),e.readBool()||(this.visible=!1),e.readBool()||(this.touchable=!1),e.readBool()&&(this.grayed=!0);var r=e.readByte();2==r?this.blendMode=egret.BlendMode.ADD:5==r&&(this.blendMode=egret.BlendMode.ERASE),1==e.readByte()&&this._displayObject&&t.ToolSet.setColorFilter(this._displayObject,[e.readFloat(),e.readFloat(),e.readFloat(),e.readFloat()]);var s=e.readS();null!=s&&(this.data=s)},h.prototype.setup_afterAdd=function(t,e){t.seek(e,1);var i=t.readS();null!=i&&(this.tooltips=i);var n=t.readShort();n>=0&&(this.group=this.parent.getChildAt(n)),t.seek(e,2);for(var o=t.readShort(),r=0;r<o;r++){var s=t.readShort();s+=t.position,this.getGear(t.readByte()).setup(t),t.position=s}},h.prototype.initDrag=function(){this._draggable?this.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__begin,this):this.removeEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__begin,this)},h.prototype.dragBegin=function(e,i,n){if(h.draggingObject){var s=h.draggingObject;s.stopDrag(),h.draggingObject=null;var a=new t.DragEvent(t.DragEvent.DRAG_END);a.stageX=i||t.GRoot.mouseX,a.stageY=n||t.GRoot.mouseY,a.touchPointID=e||0,s.dispatchEvent(a)}o.x=i||t.GRoot.mouseX,o.y=n||t.GRoot.mouseY,this.localToGlobalRect(0,0,this._width,this._height,r),this._dragTesting=!0,h.draggingObject=this,t.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.__moving,this),t.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END,this.__end,this)},h.prototype.dragEnd=function(){h.draggingObject==this&&(this.reset(),this._dragTesting=!1,h.draggingObject=null)},h.prototype.reset=function(){t.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_MOVE,this.__moving,this),t.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_END,this.__end,this)},h.prototype.__begin=function(e){null==this._dragStartPos&&(this._dragStartPos=new egret.Point),this._dragStartPos.x=e.stageX,this._dragStartPos.y=e.stageY,this._dragTesting=!0,t.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.__moving,this),t.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END,this.__end,this)},h.prototype.__moving=function(e){if(h.draggingObject!=this&&this._draggable&&this._dragTesting){var n=t.UIConfig.touchDragSensitivity;if(this._dragStartPos&&Math.abs(this._dragStartPos.x-e.stageX)<n&&Math.abs(this._dragStartPos.y-e.stageY)<n)return;this._dragTesting=!1,(_=new t.DragEvent(t.DragEvent.DRAG_START)).stageX=e.stageX,_.stageY=e.stageY,_.touchPointID=e.touchPointID,this.dispatchEvent(_),_.isDefaultPrevented()||this.dragBegin(e.touchPointID,e.stageX,e.stageY)}if(h.draggingObject==this){var l=e.stageX-o.x+r.x,c=e.stageY-o.y+r.y;if(this._dragBounds){var u=t.GRoot.inst.localToGlobalRect(this._dragBounds.x,this._dragBounds.y,this._dragBounds.width,this._dragBounds.height,a);l<u.x?l=u.x:l+r.width>u.right&&(l=u.right-r.width)<u.x&&(l=u.x),c<u.y?c=u.y:c+r.height>u.bottom&&(c=u.bottom-r.height)<u.y&&(c=u.y)}i=!0;var _,p=this.parent.globalToLocal(l,c,s);this.setXY(Math.round(p.x),Math.round(p.y)),i=!1,(_=new t.DragEvent(t.DragEvent.DRAG_MOVING)).stageX=e.stageX,_.stageY=e.stageY,_.touchPointID=e.touchPointID,this.dispatchEvent(_)}},h.prototype.__end=function(e){if(h.draggingObject==this){h.draggingObject=null,this.reset();var i=new t.DragEvent(t.DragEvent.DRAG_END);i.stageX=e.stageX,i.stageY=e.stageY,i.touchPointID=e.touchPointID,this.dispatchEvent(i)}else this._dragTesting&&(this._dragTesting=!1,this.reset())},h.XY_CHANGED="__xyChanged",h.SIZE_CHANGED="__sizeChanged",h.SIZE_DELAY_CHANGE="__sizeDelayChange",h.GEAR_STOP="gearStop",h}(egret.EventDispatcher);t.GObject=e;var i,n=0,o=new egret.Point,r=new egret.Rectangle,s=new egret.Point,a=new egret.Rectangle}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._sortingChildCount=0,i._childrenRenderOrder=t.ChildrenRenderOrder.Ascent,i._apexIndex=0,i._children=new Array,i._controllers=new Array,i._transitions=new Array,i._margin=new t.Margin,i._alignOffset=new egret.Point,i}return __extends(i,e),i.prototype.createDisplayObject=function(){this._rootContainer=new t.UIContainer,this.setDisplayObject(this._rootContainer),this._container=this._rootContainer},i.prototype.dispose=function(){var t,i;for(i=this._transitions.length,t=0;t<i;++t){this._transitions[t].dispose()}for(i=this._controllers.length,t=0;t<i;++t){this._controllers[t].dispose()}for(this._scrollPane&&this._scrollPane.dispose(),t=(i=this._children.length)-1;t>=0;--t){var n=this._children[t];n.parent=null,n.dispose()}this._boundsChanged=!1,e.prototype.dispose.call(this)},Object.defineProperty(i.prototype,"displayListContainer",{get:function(){return this._container},enumerable:!0,configurable:!0}),i.prototype.addChild=function(t){return this.addChildAt(t,this._children.length),t},i.prototype.addChildAt=function(t,e){if(void 0===e&&(e=0),!t)throw"child is null";var i=this._children.length;if(e>=0&&e<=i){if(t.parent==this)this.setChildIndex(t,e);else{t.removeFromParent(),t.parent=this;var n=this._children.length;0!=t.sortingOrder?(this._sortingChildCount++,e=this.getInsertPosForSortingChild(t)):this._sortingChildCount>0&&e>n-this._sortingChildCount&&(e=n-this._sortingChildCount),e==n?this._children.push(t):this._children.splice(e,0,t),this.childStateChanged(t),this.setBoundsChangedFlag()}return t}throw"Invalid child index"},i.prototype.getInsertPosForSortingChild=function(t){var e=this._children.length,i=0;for(i=0;i<e;i++){var n=this._children[i];if(n!=t&&t.sortingOrder<n.sortingOrder)break}return i},i.prototype.removeChild=function(t,e){var i=this._children.indexOf(t);return-1!=i&&this.removeChildAt(i,e),t},i.prototype.removeChildAt=function(e,i){if(e>=0&&e<this.numChildren){var n=this._children[e];return n.parent=null,0!=n.sortingOrder&&this._sortingChildCount--,this._children.splice(e,1),n.group=null,n.inContainer&&(this._container.removeChild(n.displayObject),this._childrenRenderOrder==t.ChildrenRenderOrder.Arch&&t.GTimers.inst.callLater(this.buildNativeDisplayList,this)),i&&n.dispose(),this.setBoundsChangedFlag(),n}throw"Invalid child index"},i.prototype.removeChildren=function(t,e,i){null==t&&(t=0),null==e&&(e=-1),(e<0||e>=this.numChildren)&&(e=this.numChildren-1);for(var n=t;n<=e;++n)this.removeChildAt(t,i)},i.prototype.getChildAt=function(t){if(t>=0&&t<this.numChildren)return this._children[t];throw"Invalid child index"},i.prototype.getChild=function(t){for(var e=this._children.length,i=0;i<e;++i)if(this._children[i].name==t)return this._children[i];return null},i.prototype.getChildByPath=function(t){for(var e,n=t.split("."),o=n.length,r=this,s=0;s<o&&(e=r.getChild(n[s]));++s)if(s!=o-1){if(!(e instanceof i)){e=null;break}r=e}return e},i.prototype.getVisibleChild=function(t){for(var e=this._children.length,i=0;i<e;++i){var n=this._children[i];if(n.internalVisible&&n.internalVisible&&n.name==t)return n}return null},i.prototype.getChildInGroup=function(t,e){for(var i=this._children.length,n=0;n<i;++n){var o=this._children[n];if(o.group==e&&o.name==t)return o}return null},i.prototype.getChildById=function(t){for(var e=this._children.length,i=0;i<e;++i)if(this._children[i]._id==t)return this._children[i];return null},i.prototype.getChildIndex=function(t){return this._children.indexOf(t)},i.prototype.setChildIndex=function(t,e){var i=this._children.indexOf(t);if(-1==i)throw"Not a child of this container";if(0==t.sortingOrder){var n=this._children.length;this._sortingChildCount>0&&e>n-this._sortingChildCount-1&&(e=n-this._sortingChildCount-1),this._setChildIndex(t,i,e)}},i.prototype.setChildIndexBefore=function(t,e){var i=this._children.indexOf(t);if(-1==i)throw"Not a child of this container";if(0!=t.sortingOrder)return i;var n=this._children.length;return this._sortingChildCount>0&&e>n-this._sortingChildCount-1&&(e=n-this._sortingChildCount-1),i<e?this._setChildIndex(t,i,e-1):this._setChildIndex(t,i,e)},i.prototype._setChildIndex=function(e,i,n){var o=this._children.length;if(n>o&&(n=o),i==n)return i;if(this._children.splice(i,1),this._children.splice(n,0,e),e.inContainer){var r,s=0;if(this._childrenRenderOrder==t.ChildrenRenderOrder.Ascent){for(r=0;r<n;r++)this._children[r].inContainer&&s++;s==this._container.numChildren&&s--,this._container.setChildIndex(e.displayObject,s)}else if(this._childrenRenderOrder==t.ChildrenRenderOrder.Descent){for(r=o-1;r>n;r--)this._children[r].inContainer&&s++;s==this._container.numChildren&&s--,this._container.setChildIndex(e.displayObject,s)}else t.GTimers.inst.callLater(this.buildNativeDisplayList,this);this.setBoundsChangedFlag()}return n},i.prototype.swapChildren=function(t,e){var i=this._children.indexOf(t),n=this._children.indexOf(e);if(-1==i||-1==n)throw"Not a child of this container";this.swapChildrenAt(i,n)},i.prototype.swapChildrenAt=function(t,e){var i=this._children[t],n=this._children[e];this.setChildIndex(i,e),this.setChildIndex(n,t)},Object.defineProperty(i.prototype,"numChildren",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),i.prototype.isAncestorOf=function(t){if(!t)return!1;for(var e=t.parent;e;){if(e==this)return!0;e=e.parent}return!1},i.prototype.addController=function(t){this._controllers.push(t),t.parent=this,this.applyController(t)},i.prototype.getControllerAt=function(t){return this._controllers[t]},i.prototype.getController=function(t){for(var e=this._controllers.length,i=0;i<e;++i){var n=this._controllers[i];if(n.name==t)return n}return null},i.prototype.removeController=function(t){var e=this._controllers.indexOf(t);if(-1==e)throw"controller not exists";t.parent=null,this._controllers.splice(e,1);for(var i=this._children.length,n=0;n<i;n++){this._children[n].handleControllerChanged(t)}},Object.defineProperty(i.prototype,"controllers",{get:function(){return this._controllers},enumerable:!0,configurable:!0}),i.prototype.childStateChanged=function(e){if(!this._buildingDisplayList){var i,n,o=this._children.length;if(e instanceof t.GGroup)for(n=0;n<o;n++)(i=this._children[n]).group==e&&this.childStateChanged(i);else if(e.displayObject)if(e.internalVisible){if(!e.displayObject.parent){var r=0;if(this._childrenRenderOrder==t.ChildrenRenderOrder.Ascent){for(n=0;n<o&&(i=this._children[n])!=e;n++)i.displayObject&&i.displayObject.parent&&r++;this._container.addChildAt(e.displayObject,r)}else if(this._childrenRenderOrder==t.ChildrenRenderOrder.Descent){for(n=o-1;n>=0&&(i=this._children[n])!=e;n--)i.displayObject&&i.displayObject.parent&&r++;this._container.addChildAt(e.displayObject,r)}else this._container.addChild(e.displayObject),t.GTimers.inst.callLater(this.buildNativeDisplayList,this)}}else e.displayObject.parent&&this._container.removeChild(e.displayObject)}},i.prototype.buildNativeDisplayList=function(){var e,i,n=this._children.length;if(0!=n)switch(this._childrenRenderOrder){case t.ChildrenRenderOrder.Ascent:for(e=0;e<n;e++)(i=this._children[e]).displayObject&&i.internalVisible&&this._container.addChild(i.displayObject);break;case t.ChildrenRenderOrder.Descent:for(e=n-1;e>=0;e--)(i=this._children[e]).displayObject&&i.internalVisible&&this._container.addChild(i.displayObject);break;case t.ChildrenRenderOrder.Arch:var o=t.ToolSet.clamp(this._apexIndex,0,n);for(e=0;e<o;e++)(i=this._children[e]).displayObject&&i.internalVisible&&this._container.addChild(i.displayObject);for(e=n-1;e>=o;e--)(i=this._children[e]).displayObject&&i.internalVisible&&this._container.addChild(i.displayObject)}},i.prototype.applyController=function(t){this._applyingController=t;for(var e=this._children.length,i=0;i<e;i++)this._children[i].handleControllerChanged(t);this._applyingController=null,t.runActions()},i.prototype.applyAllControllers=function(){for(var t=this._controllers.length,e=0;e<t;++e)this.applyController(this._controllers[e])},i.prototype.adjustRadioGroupDepth=function(e,i){var n,o,r=this._children.length,s=-1,a=-1;for(n=0;n<r;n++)(o=this._children[n])==e?s=n:o instanceof t.GButton&&o.relatedController==i&&n>a&&(a=n);s<a&&(this._applyingController&&this._children[a].handleControllerChanged(this._applyingController),this.swapChildrenAt(s,a))},i.prototype.getTransitionAt=function(t){return this._transitions[t]},i.prototype.getTransition=function(t){for(var e=this._transitions.length,i=0;i<e;++i){var n=this._transitions[i];if(n.name==t)return n}return null},i.prototype.isChildInView=function(t){return this._rootContainer.scrollRect?t.x+t.width>=0&&t.x<=this.width&&t.y+t.height>=0&&t.y<=this.height:!this._scrollPane||this._scrollPane.isChildInView(t)},i.prototype.getFirstChildInView=function(){for(var t=this._children.length,e=0;e<t;++e){var i=this._children[e];if(this.isChildInView(i))return e}return-1},Object.defineProperty(i.prototype,"scrollPane",{get:function(){return this._scrollPane},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"opaque",{get:function(){return this._rootContainer.opaque},set:function(t){this._rootContainer.opaque=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"margin",{get:function(){return this._margin},set:function(t){this._margin.copy(t),this._rootContainer.scrollRect&&(this._container.x=this._margin.left+this._alignOffset.x,this._container.y=this._margin.top+this._alignOffset.y),this.handleSizeChanged()},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"childrenRenderOrder",{get:function(){return this._childrenRenderOrder},set:function(t){this._childrenRenderOrder!=t&&(this._childrenRenderOrder=t,this.buildNativeDisplayList())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"apexIndex",{get:function(){return this._apexIndex},set:function(e){this._apexIndex!=e&&(this._apexIndex=e,this._childrenRenderOrder==t.ChildrenRenderOrder.Arch&&this.buildNativeDisplayList())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"mask",{get:function(){return this._rootContainer.mask},set:function(t){this._rootContainer.mask=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"baseUserData",{get:function(){var t=this.packageItem.rawData;return t.seek(0,4),t.readS()},enumerable:!0,configurable:!0}),i.prototype.updateScrollRect=function(){var t=this._rootContainer.scrollRect;null==t&&(t=new egret.Rectangle);var e=this.width-this._margin.right,i=this.height-this._margin.bottom;t.setTo(0,0,e,i),this._rootContainer.scrollRect=t},i.prototype.setupScroll=function(e){this._rootContainer==this._container&&(this._container=new egret.DisplayObjectContainer,this._rootContainer.addChild(this._container)),this._scrollPane=new t.ScrollPane(this),this._scrollPane.setup(e),this.setBoundsChangedFlag()},i.prototype.setupOverflow=function(e){e==t.OverflowType.Hidden?(this._rootContainer==this._container&&(this._container=new egret.DisplayObjectContainer,this._rootContainer.addChild(this._container)),this.updateScrollRect(),this._container.x=this._margin.left,this._container.y=this._margin.top):0==this._margin.left&&0==this._margin.top||(this._rootContainer==this._container&&(this._container=new egret.DisplayObjectContainer,this._rootContainer.addChild(this._container)),this._container.x=this._margin.left,this._container.y=this._margin.top),this.setBoundsChangedFlag()},i.prototype.handleSizeChanged=function(){if(e.prototype.handleSizeChanged.call(this),this._scrollPane?this._scrollPane.onOwnerSizeChanged():this._rootContainer.scrollRect&&this.updateScrollRect(),this._rootContainer.hitArea instanceof t.PixelHitTest){var i=this._rootContainer.hitArea;0!=this.sourceWidth&&(i.scaleX=this._width/this.sourceWidth),0!=this.sourceHeight&&(i.scaleY=this._height/this.sourceHeight)}},i.prototype.handleGrayedChanged=function(){var t=this.getController("grayed");if(t)t.selectedIndex=this.grayed?1:0;else for(var e=this.grayed,i=this._children.length,n=0;n<i;++n)this._children[n].grayed=e},i.prototype.handleControllerChanged=function(t){e.prototype.handleControllerChanged.call(this,t),this._scrollPane&&this._scrollPane.handleControllerChanged(t)},i.prototype.setBoundsChangedFlag=function(){(this._scrollPane||this._trackBounds)&&(this._boundsChanged||(this._boundsChanged=!0,egret.callLater(this.__render,this)))},i.prototype.__render=function(){if(this._boundsChanged){var t=this._children.length;if(t>0)for(var e=0;e<t;e++){this._children[e].ensureSizeCorrect()}this.updateBounds()}},i.prototype.ensureBoundsCorrect=function(){var t=this._children.length;if(t>0)for(var e=0;e<t;e++){this._children[e].ensureSizeCorrect()}this._boundsChanged&&this.updateBounds()},i.prototype.updateBounds=function(){var t=0,e=0,i=0,n=0,o=this._children.length;if(o>0){t=Number.POSITIVE_INFINITY,e=Number.POSITIVE_INFINITY;var r=Number.NEGATIVE_INFINITY,s=Number.NEGATIVE_INFINITY,a=0,h=0;for(h=0;h<o;h++){var l=this._children[h];(a=l.x)<t&&(t=a),(a=l.y)<e&&(e=a),(a=l.x+l.actualWidth)>r&&(r=a),(a=l.y+l.actualHeight)>s&&(s=a)}i=r-t,n=s-e}this.setBounds(t,e,i,n)},i.prototype.setBounds=function(t,e,i,n){void 0===n&&(n=0),this._boundsChanged=!1,this._scrollPane&&this._scrollPane.setContentSize(Math.round(t+i),Math.round(e+n))},Object.defineProperty(i.prototype,"viewWidth",{get:function(){return this._scrollPane?this._scrollPane.viewWidth:this.width-this._margin.left-this._margin.right},set:function(t){this._scrollPane?this._scrollPane.viewWidth=t:this.width=t+this._margin.left+this._margin.right},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"viewHeight",{get:function(){return this._scrollPane?this._scrollPane.viewHeight:this.height-this._margin.top-this._margin.bottom},set:function(t){this._scrollPane?this._scrollPane.viewHeight=t:this.height=t+this._margin.top+this._margin.bottom},enumerable:!0,configurable:!0}),i.prototype.getSnappingPosition=function(t,e,i){i||(i=new egret.Point);var n=this._children.length;if(0==n)return i.x=0,i.y=0,i;this.ensureBoundsCorrect();var o=null,r=null,s=0;if(0!=e){for(;s<n;s++)if(e<(o=this._children[s]).y){if(0==s){e=0;break}e=e<(r=this._children[s-1]).y+r.actualHeight/2?r.y:o.y;break}s==n&&(e=o.y)}if(0!=t){for(s>0&&s--;s<n;s++)if(t<(o=this._children[s]).x){if(0==s){t=0;break}t=t<(r=this._children[s-1]).x+r.actualWidth/2?r.x:o.x;break}s==n&&(t=o.x)}return i.x=t,i.y=e,i},i.prototype.childSortingOrderChanged=function(t,e,i){if(void 0===i&&(i=0),0==i)this._sortingChildCount--,this.setChildIndex(t,this._children.length);else{0==e&&this._sortingChildCount++;var n=this._children.indexOf(t),o=this.getInsertPosForSortingChild(t);n<o?this._setChildIndex(t,n,o-1):this._setChildIndex(t,n,o)}},i.prototype.constructFromResource=function(){this.constructFromResource2(null,0)},i.prototype.constructFromResource2=function(e,i){var n,o,r,s,a,h,l,c,u=this.packageItem.getBranch();u.decoded||(u.decoded=!0,t.TranslationHelper.translateComponent(u));var _=u.rawData;_.seek(0,0),this._underConstruct=!0,this.sourceWidth=_.readInt(),this.sourceHeight=_.readInt(),this.initWidth=this.sourceWidth,this.initHeight=this.sourceHeight,this.setSize(this.sourceWidth,this.sourceHeight),_.readBool()&&(this.minWidth=_.readInt(),this.maxWidth=_.readInt(),this.minHeight=_.readInt(),this.maxHeight=_.readInt()),_.readBool()&&(a=_.readFloat(),h=_.readFloat(),this.internalSetPivot(a,h,_.readBool())),_.readBool()&&(this._margin.top=_.readInt(),this._margin.bottom=_.readInt(),this._margin.left=_.readInt(),this._margin.right=_.readInt());var p=_.readByte();if(p==t.OverflowType.Scroll){var d=_.position;_.seek(0,7),this.setupScroll(_),_.position=d}else this.setupOverflow(p);_.readBool()&&_.skip(8),this._buildingDisplayList=!0,_.seek(0,1);var g,f=_.readShort();for(n=0;n<f;n++){s=_.readShort(),s+=_.position;var y=new t.Controller;this._controllers.push(y),y.parent=this,y.setup(_),_.position=s}_.seek(0,2);var m=_.readShort();for(n=0;n<m;n++){if(o=_.readShort(),r=_.position,e)g=e[i+n];else{_.seek(r,0);var b,v=_.readByte(),w=_.readS(),C=_.readS(),S=null;if(null!=w)S=(b=null!=C?t.UIPackage.getById(C):u.owner)?b.getItemById(w):null;S?(g=t.UIObjectFactory.newObject(S)).constructFromResource():g=t.UIObjectFactory.newObject(v)}g._underConstruct=!0,g.setup_beforeAdd(_,r),g.parent=this,this._children.push(g),_.position=r+o}for(_.seek(0,3),this.relations.setup(_,!0),_.seek(0,2),_.skip(2),n=0;n<m;n++)s=_.readShort(),s+=_.position,_.seek(_.position,3),this._children[n].relations.setup(_,!1),_.position=s;for(_.seek(0,2),_.skip(2),n=0;n<m;n++)s=_.readShort(),s+=_.position,(g=this._children[n]).setup_afterAdd(_,_.position),g._underConstruct=!1,_.position=s;_.seek(0,4),_.skip(2),this.opaque=_.readBool();var x=_.readShort();-1!=x&&(this.mask=this.getChildAt(x).displayObject,_.readBool());var T=_.readS();l=_.readInt(),c=_.readInt(),null!=T?(S=u.owner.getItemById(T))&&S.pixelHitTestData&&(this._rootContainer.hitArea=new t.PixelHitTest(S.pixelHitTestData,l,c)):0!=l&&-1!=c&&(this._rootContainer.hitArea=this.getChildAt(c).displayObject),_.seek(0,5);var I=_.readShort();for(n=0;n<I;n++){s=_.readShort(),s+=_.position;var P=new t.Transition(this);P.setup(_),this._transitions.push(P),_.position=s}this._transitions.length>0&&(this.displayObject.addEventListener(egret.Event.ADDED_TO_STAGE,this.___added,this),this.displayObject.addEventListener(egret.Event.REMOVED_FROM_STAGE,this.___removed,this)),this.applyAllControllers(),this._buildingDisplayList=!1,this._underConstruct=!1,this.buildNativeDisplayList(),this.setBoundsChangedFlag(),u.objectType!=t.ObjectType.Component&&this.constructExtension(_),this.onConstruct()},i.prototype.onConstruct=function(){this.constructFromXML(null)},i.prototype.constructExtension=function(t){},i.prototype.constructFromXML=function(t){},i.prototype.setup_afterAdd=function(t,i){e.prototype.setup_afterAdd.call(this,t,i),t.seek(i,4);var n=t.readShort();-1!=n&&this._scrollPane&&(this._scrollPane.pageController=this._parent.getControllerAt(n));for(var o=t.readShort(),r=0;r<o;r++){var s=this.getController(t.readS()),a=t.readS();s&&(s.selectedPageId=a)}if(t.version>=2)for(o=t.readShort(),r=0;r<o;r++){var h=t.readS(),l=t.readShort(),c=t.readS(),u=this.getChildByPath(h);u&&u.setProp(l,c)}},i.prototype.___added=function(t){for(var e=this._transitions.length,i=0;i<e;++i)this._transitions[i].onOwnerAddedToStage()},i.prototype.___removed=function(t){for(var e=this._transitions.length,i=0;i<e;++i)this._transitions[i].onOwnerRemovedFromStage()},i}(t.GObject);t.GComponent=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._mode=t.ButtonMode.Common,i._title="",i._icon="",i._sound=t.UIConfig.buttonSound,i._soundVolumeScale=t.UIConfig.buttonSoundVolumeScale,i._changeStateOnClick=!0,i._downEffect=0,i._downEffectValue=.8,i}return __extends(i,e),Object.defineProperty(i.prototype,"icon",{get:function(){return this._icon},set:function(t){this._icon=t,t=this._selected&&this._selectedIcon?this._selectedIcon:this._icon,this._iconObject&&(this._iconObject.icon=t),this.updateGear(7)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"selectedIcon",{get:function(){return this._selectedIcon},set:function(t){this._selectedIcon=t,t=this._selected&&this._selectedIcon?this._selectedIcon:this._icon,this._iconObject&&(this._iconObject.icon=t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"title",{get:function(){return this._title},set:function(t){this._title=t,this._titleObject&&(this._titleObject.text=this._selected&&this._selectedTitle?this._selectedTitle:this._title),this.updateGear(6)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"text",{get:function(){return this.title},set:function(t){this.title=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"selectedTitle",{get:function(){return this._selectedTitle},set:function(t){this._selectedTitle=t,this._titleObject&&(this._titleObject.text=this._selected&&this._selectedTitle?this._selectedTitle:this._title)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"titleColor",{get:function(){var t=this.getTextField();return t?t.color:0},set:function(t){var e=this.getTextField();e&&(e.color=t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"titleFontSize",{get:function(){var t=this.getTextField();return t?t.fontSize:0},set:function(t){var e=this.getTextField();e&&(e.fontSize=t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"sound",{get:function(){return this._sound},set:function(t){this._sound=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"soundVolumeScale",{get:function(){return this._soundVolumeScale},set:function(t){this._soundVolumeScale=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"selected",{get:function(){return this._selected},set:function(e){if(this._mode!=t.ButtonMode.Common&&this._selected!=e){if(this._selected=e,this.grayed&&this._buttonController&&this._buttonController.hasPage(i.DISABLED)?this._selected?this.setState(i.SELECTED_DISABLED):this.setState(i.DISABLED):this._selected?this.setState(this._over?i.SELECTED_OVER:i.DOWN):this.setState(this._over?i.OVER:i.UP),this._selectedTitle&&this._titleObject&&(this._titleObject.text=this._selected?this._selectedTitle:this._title),this._selectedIcon){var n=this._selected?this._selectedIcon:this._icon;this._iconObject&&(this._iconObject.icon=n)}this._relatedController&&this._parent&&!this._parent._buildingDisplayList&&(this._selected?(this._relatedController.selectedPageId=this._relatedPageId,this._relatedController.autoRadioGroupDepth&&this._parent.adjustRadioGroupDepth(this,this._relatedController)):this._mode==t.ButtonMode.Check&&this._relatedController.selectedPageId==this._relatedPageId&&(this._relatedController.oppositePageId=this._relatedPageId))}},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"mode",{get:function(){return this._mode},set:function(e){this._mode!=e&&(e==t.ButtonMode.Common&&(this.selected=!1),this._mode=e)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"relatedController",{get:function(){return this._relatedController},set:function(t){this._relatedController=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"relatedPageId",{get:function(){return this._relatedPageId},set:function(t){this._relatedPageId=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"changeStateOnClick",{get:function(){return this._changeStateOnClick},set:function(t){this._changeStateOnClick=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"linkedPopup",{get:function(){return this._linkedPopup},set:function(t){this._linkedPopup=t},enumerable:!0,configurable:!0}),i.prototype.getTextField=function(){return this._titleObject instanceof t.GTextField?this._titleObject:this._titleObject instanceof t.GLabel||this._titleObject instanceof i?this._titleObject.getTextField():null},i.prototype.addStateListener=function(e,i){this.addEventListener(t.StateChangeEvent.CHANGED,e,i)},i.prototype.removeStateListener=function(e,i){this.removeEventListener(t.StateChangeEvent.CHANGED,e,i)},i.prototype.fireClick=function(e){e&&this._mode==t.ButtonMode.Common&&(this.setState(i.OVER),t.GTimers.inst.add(100,1,function(){this.setState(i.DOWN)},this),t.GTimers.inst.add(200,1,function(){this.setState(i.UP)},this)),this.__click(null)},i.prototype.setState=function(e){if(this._buttonController&&(this._buttonController.selectedPage=e),1==this._downEffect){var n=this.numChildren;if(e==i.DOWN||e==i.SELECTED_OVER||e==i.SELECTED_DISABLED)for(var o=255*this._downEffectValue,r=(o<<16)+(o<<8)+o,s=0;s<n;s++){null==(a=this.getChildAt(s)).color||a instanceof t.GTextField||(a.color=r)}else for(s=0;s<n;s++){var a;null==(a=this.getChildAt(s)).color||a instanceof t.GTextField||(a.color=16777215)}}else 2==this._downEffect&&(e==i.DOWN||e==i.SELECTED_OVER||e==i.SELECTED_DISABLED?this._downScaled||(this._downScaled=!0,this._rootContainer.cacheHitArea(!0),this.setScale(this.scaleX*this._downEffectValue,this.scaleY*this._downEffectValue)):this._downScaled&&(this._downScaled=!1,this._rootContainer.cacheHitArea(!1),this.setScale(this.scaleX/this._downEffectValue,this.scaleY/this._downEffectValue)))},i.prototype.handleControllerChanged=function(t){e.prototype.handleControllerChanged.call(this,t),this._relatedController==t&&(this.selected=this._relatedPageId==t.selectedPageId)},i.prototype.handleGrayedChanged=function(){this._buttonController&&this._buttonController.hasPage(i.DISABLED)?this.grayed?this._selected&&this._buttonController.hasPage(i.SELECTED_DISABLED)?this.setState(i.SELECTED_DISABLED):this.setState(i.DISABLED):this._selected?this.setState(i.DOWN):this.setState(i.UP):e.prototype.handleGrayedChanged.call(this)},i.prototype.getProp=function(i){switch(i){case t.ObjectPropID.Color:return this.titleColor;case t.ObjectPropID.OutlineColor:var n=this.getTextField();return n?n.strokeColor:0;case t.ObjectPropID.FontSize:return this.titleFontSize;case t.ObjectPropID.Selected:return this.selected;default:return e.prototype.getProp.call(this,i)}},i.prototype.setProp=function(i,n){switch(i){case t.ObjectPropID.Color:this.titleColor=n;break;case t.ObjectPropID.OutlineColor:var o=this.getTextField();o&&(o.strokeColor=n);break;case t.ObjectPropID.FontSize:this.titleFontSize=n;break;case t.ObjectPropID.Selected:this.selected=n;break;default:e.prototype.setProp.call(this,i,n)}},i.prototype.constructExtension=function(e){e.seek(0,6),this._mode=e.readByte();var n=e.readS();n&&(this._sound=n),this._soundVolumeScale=e.readFloat(),this._downEffect=e.readByte(),this._downEffectValue=e.readFloat(),2==this._downEffect&&this.setPivot(.5,.5,this.pivotAsAnchor),this._buttonController=this.getController("button"),this._titleObject=this.getChild("title"),this._iconObject=this.getChild("icon"),this._titleObject&&(this._title=this._titleObject.text),this._iconObject&&(this._icon=this._iconObject.icon),this._mode==t.ButtonMode.Common&&this.setState(i.UP),this.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__mousedown,this),this.addEventListener(egret.TouchEvent.TOUCH_TAP,this.__click,this)},i.prototype.setup_afterAdd=function(t,i){var n,o;(e.prototype.setup_afterAdd.call(this,t,i),t.seek(i,6))&&(t.readByte()==this.packageItem.objectType&&(null!=(n=t.readS())&&(this.title=n),null!=(n=t.readS())&&(this.selectedTitle=n),null!=(n=t.readS())&&(this.icon=n),null!=(n=t.readS())&&(this.selectedIcon=n),t.readBool()&&(this.titleColor=t.readColor()),0!=(o=t.readInt())&&(this.titleFontSize=o),(o=t.readShort())>=0&&(this._relatedController=this.parent.getControllerAt(o)),this._relatedPageId=t.readS(),null!=(n=t.readS())&&(this._sound=n),t.readBool()&&(this._soundVolumeScale=t.readFloat()),this.selected=t.readBool()))},i.prototype.__mousedown=function(e){this._down=!0,t.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END,this.__mouseup,this),this._mode==t.ButtonMode.Common&&(this.grayed&&this._buttonController&&this._buttonController.hasPage(i.DISABLED)?this.setState(i.SELECTED_DISABLED):this.setState(i.DOWN)),this._linkedPopup&&(this._linkedPopup instanceof t.Window?this._linkedPopup.toggleStatus():this.root.togglePopup(this._linkedPopup,this))},i.prototype.__mouseup=function(e){if(this._down){if(t.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_END,this.__mouseup,this),this._down=!1,!this.displayObject)return;this._mode==t.ButtonMode.Common&&(this.grayed&&this._buttonController&&this._buttonController.hasPage(i.DISABLED)?this.setState(i.DISABLED):this._over?this.setState(i.OVER):this.setState(i.UP))}},i.prototype.__click=function(e){if(this._sound){var i=t.UIPackage.getItemByURL(this._sound);if(i){var n=i.owner.getItemAsset(i);n&&t.GRoot.inst.playOneShotSound(n,this._soundVolumeScale)}}this._mode==t.ButtonMode.Check?this._changeStateOnClick&&(this.selected=!this._selected,this.dispatchEvent(new t.StateChangeEvent(t.StateChangeEvent.CHANGED))):this._mode==t.ButtonMode.Radio?this._changeStateOnClick&&!this._selected&&(this.selected=!0,this.dispatchEvent(new t.StateChangeEvent(t.StateChangeEvent.CHANGED))):this._relatedController&&(this._relatedController.selectedPageId=this._relatedPageId)},i.UP="up",i.DOWN="down",i.OVER="over",i.SELECTED_OVER="selectedOver",i.DISABLED="disabled",i.SELECTED_DISABLED="selectedDisabled",i}(t.GComponent);t.GButton=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._visibleItemCount=0,i._selectedIndex=0,i._popupDirection=t.PopupDirection.Auto,i._visibleItemCount=t.UIConfig.defaultComboBoxVisibleItemCount,i._itemsUpdated=!0,i._selectedIndex=-1,i._items=[],i._values=[],i}return __extends(i,e),Object.defineProperty(i.prototype,"text",{get:function(){return this._titleObject?this._titleObject.text:null},set:function(t){this._titleObject&&(this._titleObject.text=t),this.updateGear(6)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"icon",{get:function(){return this._iconObject?this._iconObject.icon:null},set:function(t){this._iconObject&&(this._iconObject.icon=t),this.updateGear(7)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"titleColor",{get:function(){var t=this.getTextField();return t?t.color:0},set:function(t){var e=this.getTextField();e&&(e.color=t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"titleFontSize",{get:function(){var t=this.getTextField();return t?t.fontSize:0},set:function(t){var e=this.getTextField();e&&(e.fontSize=t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"visibleItemCount",{get:function(){return this._visibleItemCount},set:function(t){this._visibleItemCount=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"popupDirection",{get:function(){return this._popupDirection},set:function(t){this._popupDirection=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"items",{get:function(){return this._items},set:function(t){t?this._items=t.concat():this._items.length=0,this._items.length>0?(this._selectedIndex>=this._items.length?this._selectedIndex=this._items.length-1:-1==this._selectedIndex&&(this._selectedIndex=0),this.text=this._items[this._selectedIndex],this._icons&&this._selectedIndex<this._icons.length&&(this.icon=this._icons[this._selectedIndex])):(this.text="",this._icons&&(this.icon=null),this._selectedIndex=-1),this._itemsUpdated=!0},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"icons",{get:function(){return this._icons},set:function(t){this._icons=t,this._icons&&-1!=this._selectedIndex&&this._selectedIndex<this._icons.length&&(this.icon=this._icons[this._selectedIndex])},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"values",{get:function(){return this._values},set:function(t){t?this._values=t.concat():this._values.length=0},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"selectedIndex",{get:function(){return this._selectedIndex},set:function(t){this._selectedIndex!=t&&(this._selectedIndex=t,this._selectedIndex>=0&&this._selectedIndex<this._items.length?(this.text=this._items[this._selectedIndex],this._icons&&this._selectedIndex<this._icons.length&&(this.icon=this._icons[this._selectedIndex])):(this.text="",this._icons&&(this.icon=null)),this.updateSelectionController())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"value",{get:function(){return this._values[this._selectedIndex]},set:function(t){var e=this._values.indexOf(t);-1==e&&null==t&&(e=this._values.indexOf("")),this.selectedIndex=e},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"selectionController",{get:function(){return this._selectionController},set:function(t){this._selectionController=t},enumerable:!0,configurable:!0}),i.prototype.getTextField=function(){return this._titleObject instanceof t.GTextField?this._titleObject:this._titleObject instanceof t.GLabel||this._titleObject instanceof t.GButton?this._titleObject.getTextField():null},i.prototype.setState=function(t){this._buttonController&&(this._buttonController.selectedPage=t)},i.prototype.getProp=function(i){switch(i){case t.ObjectPropID.Color:return this.titleColor;case t.ObjectPropID.OutlineColor:var n=this.getTextField();return n?n.strokeColor:0;case t.ObjectPropID.FontSize:return(n=this.getTextField())?n.fontSize:0;default:return e.prototype.getProp.call(this,i)}},i.prototype.setProp=function(i,n){switch(i){case t.ObjectPropID.Color:this.titleColor=n;break;case t.ObjectPropID.OutlineColor:var o=this.getTextField();o&&(o.strokeColor=n);break;case t.ObjectPropID.FontSize:(o=this.getTextField())&&(o.fontSize=n);break;default:e.prototype.setProp.call(this,i,n)}},i.prototype.constructExtension=function(e){var i;if(this._buttonController=this.getController("button"),this._titleObject=this.getChild("title"),this._iconObject=this.getChild("icon"),i=e.readS()){if(this.dropdown=t.UIPackage.createObjectFromURL(i),!this.dropdown)return void console.error("下拉框必须为元件");if(this.dropdown.name="this.dropdown",this._list=this.dropdown.getChild("list").asList,null==this._list)return void console.error(this.resourceURL+": 下拉框的弹出元件里必须包含名为list的列表");this._list.addEventListener(t.ItemEvent.CLICK,this.__clickItem,this),this._list.addRelation(this.dropdown,t.RelationType.Width),this._list.removeRelation(this.dropdown,t.RelationType.Height),this.dropdown.addRelation(this._list,t.RelationType.Height),this.dropdown.removeRelation(this._list,t.RelationType.Width),this.dropdown.displayObject.addEventListener(egret.Event.REMOVED_FROM_STAGE,this.__popupWinClosed,this)}this.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__mousedown,this)},i.prototype.handleControllerChanged=function(t){e.prototype.handleControllerChanged.call(this,t),this._selectionController==t&&(this.selectedIndex=t.selectedIndex)},i.prototype.updateSelectionController=function(){if(this._selectionController&&!this._selectionController.changing&&this._selectedIndex<this._selectionController.pageCount){var t=this._selectionController;this._selectionController=null,t.selectedIndex=this._selectedIndex,this._selectionController=t}},i.prototype.dispose=function(){this.dropdown&&(this.dropdown.dispose(),this.dropdown=null),e.prototype.dispose.call(this)},i.prototype.setup_afterAdd=function(t,i){if(e.prototype.setup_afterAdd.call(this,t,i),t.seek(i,6)&&t.readByte()==this.packageItem.objectType){var n,o,r,s,a=t.readShort();for(n=0;n<a;n++)r=t.readShort(),r+=t.position,this._items[n]=t.readS(),this._values[n]=t.readS(),null!=(s=t.readS())&&(null==this._icons&&(this._icons=new Array),this._icons[n]=s),t.position=r;null!=(s=t.readS())?(this.text=s,this._selectedIndex=this._items.indexOf(s)):this._items.length>0?(this._selectedIndex=0,this.text=this._items[0]):this._selectedIndex=-1,null!=(s=t.readS())&&(this.icon=s),t.readBool()&&(this.titleColor=t.readColor()),(o=t.readInt())>0&&(this._visibleItemCount=o),this._popupDirection=t.readByte(),(o=t.readShort())>=0&&(this._selectionController=this.parent.getControllerAt(o))}},i.prototype.showDropdown=function(){if(this._itemsUpdated){this._itemsUpdated=!1,this._list.removeChildrenToPool();for(var e=this._items.length,i=0;i<e;i++){var n=this._list.addItemFromPool();n.name=i<this._values.length?this._values[i]:"",n.text=this._items[i],n.icon=this._icons&&i<this._icons.length?this._icons[i]:null}this._list.resizeToFit(this._visibleItemCount)}this._list.selectedIndex=-1,this.dropdown.width=this.width,this._list.ensureBoundsCorrect(),this.root.togglePopup(this.dropdown,this,this._popupDirection),this.dropdown.parent&&this.setState(t.GButton.DOWN)},i.prototype.__popupWinClosed=function(e){this._over?this.setState(t.GButton.OVER):this.setState(t.GButton.UP)},i.prototype.__clickItem=function(e){t.GTimers.inst.add(100,1,this.__clickItem2,this,this._list.getChildIndex(e.itemObject))},i.prototype.__clickItem2=function(e){this.dropdown.parent instanceof t.GRoot&&this.dropdown.parent.hidePopup(),this._selectedIndex=-1,this.selectedIndex=e,this.dispatchEvent(new t.StateChangeEvent(t.StateChangeEvent.CHANGED))},i.prototype.__mousedown=function(e){e.target instanceof egret.TextField&&e.target.type==egret.TextFieldType.INPUT||(this._down=!0,t.GRoot.inst.nativeStage.addEventListener(egret.TouchEvent.TOUCH_END,this.__mouseup,this),this.dropdown&&this.showDropdown())},i.prototype.__mouseup=function(e){this._down&&(this._down=!1,t.GRoot.inst.nativeStage.removeEventListener(egret.TouchEvent.TOUCH_END,this.__mouseup,this),this.dropdown&&!this.dropdown.parent&&(this._over?this.setState(t.GButton.OVER):this.setState(t.GButton.UP)))},i}(t.GComponent);t.GComboBox=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var t=e.call(this)||this;return t._type=0,t._lineSize=0,t._lineColor=0,t._fillColor=0,t._lineSize=1,t._lineAlpha=1,t._fillAlpha=1,t._fillColor=16777215,t}return __extends(i,e),Object.defineProperty(i.prototype,"graphics",{get:function(){return this._graphics},enumerable:!0,configurable:!0}),i.prototype.drawRect=function(t,e,i,n,o,r){this._type=1,this._lineSize=t,this._lineColor=e,this._lineAlpha=i,this._fillColor=n,this._fillAlpha=o,this._cornerRadius=r,this.updateGraph()},i.prototype.drawEllipse=function(t,e,i,n,o){this._type=2,this._lineSize=t,this._lineColor=e,this._lineAlpha=i,this._fillColor=n,this._fillAlpha=o,this._cornerRadius=null,this.updateGraph()},i.prototype.drawRegularPolygon=function(t,e,i,n,o,r,s,a){this._type=4,this._lineSize=t,this._lineColor=e,this._lineAlpha=i,this._fillColor=n,this._fillAlpha=o,this._sides=r,this._startAngle=s||0,this._distances=a,this.updateGraph()},i.prototype.drawPolygon=function(t,e,i,n,o,r){this._type=3,this._lineSize=t,this._lineColor=e,this._lineAlpha=i,this._fillColor=n,this._fillAlpha=o,this._polygonPoints=r,this.updateGraph()},Object.defineProperty(i.prototype,"distances",{get:function(){return this._distances},set:function(t){this._distances=t,3==this._type&&this.updateGraph()},enumerable:!0,configurable:!0}),i.prototype.clearGraphics=function(){this._graphics&&(this._type=0,this._graphics.clear())},Object.defineProperty(i.prototype,"color",{get:function(){return this._fillColor},set:function(t){this._fillColor=t,0!=this._type&&this.updateGraph()},enumerable:!0,configurable:!0}),i.prototype.updateGraph=function(){var e=this.graphics;e.clear();var i=this.width,n=this.height;if(0!=i&&0!=n){if(0==this._lineSize?e.lineStyle(0,0,0):e.lineStyle(this._lineSize,this._lineColor,this._lineAlpha),e.beginFill(this._fillColor,this._fillAlpha),1==this._type)this._cornerRadius?1==this._cornerRadius.length?e.drawRoundRect(0,0,i,n,2*this._cornerRadius[0],2*this._cornerRadius[0]):e.drawRoundRect(0,0,i,n,2*this._cornerRadius[0],2*this._cornerRadius[1]):e.drawRect(0,0,i,n);else if(2==this._type)e.drawEllipse(0,0,i,n);else if(3==this._type)t.ToolSet.fillPath(e,this._polygonPoints,0,0);else if(4==this._type){this._polygonPoints||(this._polygonPoints=[]);var o=Math.min(this._width,this._height)/2;this._polygonPoints.length=0;for(var r,s=this._startAngle*Math.PI/180,a=2*Math.PI/this._sides,h=0;h<this._sides;h++){this._distances?(r=this._distances[h],isNaN(r)&&(r=1)):r=1;var l=o+o*r*Math.cos(s),c=o+o*r*Math.sin(s);this._polygonPoints.push(l,c),s+=a}t.ToolSet.fillPath(e,this._polygonPoints,0,0)}e.endFill()}},i.prototype.replaceMe=function(t){if(!this._parent)throw"parent not set";t.name=this.name,t.alpha=this.alpha,t.rotation=this.rotation,t.visible=this.visible,t.touchable=this.touchable,t.grayed=this.grayed,t.setXY(this.x,this.y),t.setSize(this.width,this.height);var e=this._parent.getChildIndex(this);this._parent.addChildAt(t,e),t.relations.copyFrom(this.relations),this._parent.removeChild(this,!0)},i.prototype.addBeforeMe=function(t){if(null==this._parent)throw"parent not set";var e=this._parent.getChildIndex(this);this._parent.addChildAt(t,e)},i.prototype.addAfterMe=function(t){if(null==this._parent)throw"parent not set";var e=this._parent.getChildIndex(this);e++,this._parent.addChildAt(t,e)},i.prototype.setNativeObject=function(t){var e=new egret.Sprite;this.setDisplayObject(e),this._parent&&this._parent.childStateChanged(this),this.handleXYChanged(),e.alpha=this.alpha,e.rotation=this.rotation,e.visible=this.visible,e.touchEnabled=this.touchable,e.touchChildren=this.touchable,e.addChild(t)},i.prototype.createDisplayObject=function(){var t=new egret.Sprite;t.touchEnabled=!0,this._graphics=t.graphics,this.setDisplayObject(t)},i.prototype.getProp=function(i){return i==t.ObjectPropID.Color?this.color:e.prototype.getProp.call(this,i)},i.prototype.setProp=function(i,n){i==t.ObjectPropID.Color?this.color=n:e.prototype.setProp.call(this,i,n)},i.prototype.handleSizeChanged=function(){e.prototype.handleSizeChanged.call(this),0!=this._type&&this.updateGraph()},i.prototype.setup_beforeAdd=function(t,i){if(e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,5),this._type=t.readByte(),0!=this._type){var n,o;this._lineSize=t.readInt();var r=t.readColor(!0);if(this._lineColor=16777215&r,this._lineAlpha=(r>>24&255)/255,r=t.readColor(!0),this._fillColor=16777215&r,this._fillAlpha=(r>>24&255)/255,t.readBool())for(this._cornerRadius=new Array(4),n=0;n<4;n++)this._cornerRadius[n]=t.readFloat();if(3==this._type)for(o=t.readShort(),this._polygonPoints=[],this._polygonPoints.length=o,n=0;n<o;n++)this._polygonPoints[n]=t.readFloat();else if(4==this._type&&(this._sides=t.readShort(),this._startAngle=t.readFloat(),(o=t.readShort())>0))for(this._distances=[],n=0;n<o;n++)this._distances[n]=t.readFloat();this.updateGraph()}},i}(t.GObject);t.GGraph=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var t=e.call(this)||this;return t._layout=0,t._lineGap=0,t._columnGap=0,t._mainGridIndex=-1,t._mainGridMinSize=50,t._mainChildIndex=-1,t._totalSize=0,t._numChildren=0,t._updating=0,t}return __extends(i,e),i.prototype.dispose=function(){this._boundsChanged=!1,e.prototype.dispose.call(this)},Object.defineProperty(i.prototype,"layout",{get:function(){return this._layout},set:function(t){this._layout!=t&&(this._layout=t,this.setBoundsChangedFlag())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"lineGap",{get:function(){return this._lineGap},set:function(t){this._lineGap!=t&&(this._lineGap=t,this.setBoundsChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"columnGap",{get:function(){return this._columnGap},set:function(t){this._columnGap!=t&&(this._columnGap=t,this.setBoundsChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"excludeInvisibles",{get:function(){return this._excludeInvisibles},set:function(t){this._excludeInvisibles!=t&&(this._excludeInvisibles=t,this.setBoundsChangedFlag())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"autoSizeDisabled",{get:function(){return this._autoSizeDisabled},set:function(t){this._autoSizeDisabled=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"mainGridMinSize",{get:function(){return this._mainGridMinSize},set:function(t){this._mainGridMinSize!=t&&(this._mainGridMinSize=t,this.setBoundsChangedFlag())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"mainGridIndex",{get:function(){return this._mainGridIndex},set:function(t){this._mainGridIndex!=t&&(this._mainGridIndex=t,this.setBoundsChangedFlag())},enumerable:!0,configurable:!0}),i.prototype.setBoundsChangedFlag=function(e){0==this._updating&&this._parent&&(e||(this._percentReady=!1),this._boundsChanged||(this._boundsChanged=!0,this._layout!=t.GroupLayoutType.None&&t.GTimers.inst.callLater(this.ensureBoundsCorrect,this)))},i.prototype.ensureSizeCorrect=function(){null!=this._parent&&this._boundsChanged&&0!=this._layout&&(this._boundsChanged=!1,this._autoSizeDisabled?this.resizeChildren(0,0):(this.handleLayout(),this.updateBounds()))},i.prototype.ensureBoundsCorrect=function(){null!=this._parent&&this._boundsChanged&&(this._boundsChanged=!1,0==this._layout?this.updateBounds():this._autoSizeDisabled?this.resizeChildren(0,0):(this.handleLayout(),this.updateBounds()))},i.prototype.updateBounds=function(){t.GTimers.inst.remove(this.ensureBoundsCorrect,this);var e,i,n,o=this._parent.numChildren,r=Number.POSITIVE_INFINITY,s=Number.POSITIVE_INFINITY,a=Number.NEGATIVE_INFINITY,h=Number.NEGATIVE_INFINITY,l=!0;for(e=0;e<o;e++)(i=this._parent.getChildAt(e)).group!=this||this._excludeInvisibles&&!i.internalVisible3||((n=i.xMin)<r&&(r=n),(n=i.yMin)<s&&(s=n),(n=i.xMin+i.width)>a&&(a=n),(n=i.yMin+i.height)>h&&(h=n),l=!1);var c=0,u=0;l||(this._updating|=1,this.setXY(r,s),this._updating&=2,c=a-r,u=h-s),0==(2&this._updating)?(this._updating|=2,this.setSize(c,u),this._updating&=1):(this._updating&=1,this.resizeChildren(this._width-c,this._height-u))},i.prototype.handleLayout=function(){var e,i,n;if(this._updating|=1,this._layout==t.GroupLayoutType.Horizontal){var o=this.x;for(n=this._parent.numChildren,i=0;i<n;i++)(e=this._parent.getChildAt(i)).group==this&&(this._excludeInvisibles&&!e.internalVisible3||(e.xMin=o,0!=e.width&&(o+=e.width+this._columnGap)))}else if(this._layout==t.GroupLayoutType.Vertical){var r=this.y;for(n=this._parent.numChildren,i=0;i<n;i++)(e=this._parent.getChildAt(i)).group==this&&(this._excludeInvisibles&&!e.internalVisible3||(e.yMin=r,0!=e.height&&(r+=e.height+this._lineGap)))}this._updating&=2},i.prototype.moveChildren=function(t,e){if(0==(1&this._updating)&&null!=this._parent){this._updating|=1;var i,n,o=this._parent.numChildren;for(i=0;i<o;i++)(n=this._parent.getChildAt(i)).group==this&&n.setXY(n.x+t,n.y+e);this._updating&=2}},i.prototype.resizeChildren=function(e,i){if(this._layout!=t.GroupLayoutType.None&&0==(2&this._updating)&&null!=this._parent)if(this._updating|=2,!this._boundsChanged||(this._boundsChanged=!1,this._autoSizeDisabled)){var n,o,r=this._parent.numChildren;if(!this._percentReady){this._percentReady=!0,this._numChildren=0,this._totalSize=0,this._mainChildIndex=-1;var s=0;for(n=0;n<r;n++)(o=this._parent.getChildAt(n)).group==this&&(this._excludeInvisibles&&!o.internalVisible3||(s==this._mainGridIndex&&(this._mainChildIndex=n),this._numChildren++,1==this._layout?this._totalSize+=o.width:this._totalSize+=o.height),s++);for(-1!=this._mainChildIndex&&(1==this._layout?(o=this._parent.getChildAt(this._mainChildIndex),this._totalSize+=this._mainGridMinSize-o.width,o._sizePercentInGroup=this._mainGridMinSize/this._totalSize):(o=this._parent.getChildAt(this._mainChildIndex),this._totalSize+=this._mainGridMinSize-o.height,o._sizePercentInGroup=this._mainGridMinSize/this._totalSize)),n=0;n<r;n++)(o=this._parent.getChildAt(n)).group==this&&n!=this._mainChildIndex&&(this._totalSize>0?o._sizePercentInGroup=(1==this._layout?o.width:o.height)/this._totalSize:o._sizePercentInGroup=0)}var a=0,h=1,l=!1;if(1==this._layout){a=this.width-(this._numChildren-1)*this._columnGap,-1!=this._mainChildIndex&&a>=this._totalSize&&((o=this._parent.getChildAt(this._mainChildIndex)).setSize(a-(this._totalSize-this._mainGridMinSize),o._rawHeight+i,!0),a-=o.width,h-=o._sizePercentInGroup,l=!0);var c=this.x;for(n=0;n<r;n++)(o=this._parent.getChildAt(n)).group==this&&(!this._excludeInvisibles||o.internalVisible3?(l&&n==this._mainChildIndex||(o.setSize(Math.round(o._sizePercentInGroup/h*a),o._rawHeight+i,!0),h-=o._sizePercentInGroup,a-=o.width),o.xMin=c,0!=o.width&&(c+=o.width+this._columnGap)):o.setSize(o._rawWidth,o._rawHeight+i,!0))}else{a=this.height-(this._numChildren-1)*this._lineGap,-1!=this._mainChildIndex&&a>=this._totalSize&&((o=this._parent.getChildAt(this._mainChildIndex)).setSize(o._rawWidth+e,a-(this._totalSize-this._mainGridMinSize),!0),a-=o.height,h-=o._sizePercentInGroup,l=!0);var u=this.y;for(n=0;n<r;n++)(o=this._parent.getChildAt(n)).group==this&&(!this._excludeInvisibles||o.internalVisible3?(l&&n==this._mainChildIndex||(o.setSize(o._rawWidth+e,Math.round(o._sizePercentInGroup/h*a),!0),h-=o._sizePercentInGroup,a-=o.height),o.yMin=u,0!=o.height&&(u+=o.height+this._lineGap)):o.setSize(o._rawWidth+e,o._rawHeight,!0))}this._updating&=1}else this.updateBounds()},i.prototype.handleAlphaChanged=function(){if(!this._underConstruct)for(var t=this._parent.numChildren,e=0;e<t;e++){var i=this._parent.getChildAt(e);i.group==this&&(i.alpha=this.alpha)}},i.prototype.handleVisibleChanged=function(){if(this._parent)for(var t=this._parent.numChildren,e=0;e<t;e++){var i=this._parent.getChildAt(e);i.group==this&&i.handleVisibleChanged()}},i.prototype.setup_beforeAdd=function(t,i){e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,5),this._layout=t.readByte(),this._lineGap=t.readInt(),this._columnGap=t.readInt(),t.version>=2&&(this._excludeInvisibles=t.readBool(),this._autoSizeDisabled=t.readBool(),this._mainChildIndex=t.readInt())},i.prototype.setup_afterAdd=function(t,i){e.prototype.setup_afterAdd.call(this,t,i),this.visible||this.handleVisibleChanged()},i}(t.GObject);t.GGroup=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._flip=t.FlipType.None,i}return __extends(i,e),Object.defineProperty(i.prototype,"color",{get:function(){return this._content.color},set:function(t){this._content.color!=t&&(this._content.color=t,this.updateGear(4))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"flip",{get:function(){return this._flip},set:function(e){if(this._flip!=e){this._flip=e;var i=1,n=1;this._flip!=t.FlipType.Horizontal&&this._flip!=t.FlipType.Both||(i=-1),this._flip!=t.FlipType.Vertical&&this._flip!=t.FlipType.Both||(n=-1),this._content.scaleX=i,this._content.scaleY=n,this.handleXYChanged()}},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillMethod",{get:function(){return this._content.fillMethod},set:function(t){this._content.fillMethod=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillOrigin",{get:function(){return this._content.fillOrigin},set:function(t){this._content.fillOrigin=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillClockwise",{get:function(){return this._content.fillClockwise},set:function(t){this._content.fillClockwise=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillAmount",{get:function(){return this._content.fillAmount},set:function(t){this._content.fillAmount=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"texture",{get:function(){return this._content.texture},set:function(t){t?(this.sourceWidth=t.textureWidth,this.sourceHeight=t.textureHeight):(this.sourceWidth=0,this.sourceHeight=0),this.initWidth=this.sourceWidth,this.initHeight=this.sourceHeight,this._content.scale9Grid=null,this._content.fillMode=egret.BitmapFillMode.SCALE,this._content.texture=t},enumerable:!0,configurable:!0}),i.prototype.createDisplayObject=function(){this._content=new t.Image,this._content.touchEnabled=!1,this.setDisplayObject(this._content)},i.prototype.constructFromResource=function(){var t=this.packageItem.getBranch();this.sourceWidth=t.width,this.sourceHeight=t.height,this.initWidth=this.sourceWidth,this.initHeight=this.sourceHeight,this.setSize(this.sourceWidth,this.sourceHeight),(t=t.getHighResolution()).load(),this._content.scale9Grid=t.scale9Grid,this._content.smoothing=t.smoothing,t.scaleByTile&&(this._content.fillMode=egret.BitmapFillMode.REPEAT),this.setSize(this.sourceWidth,this.sourceHeight),this._content.texture=t.asset},i.prototype.handleXYChanged=function(){e.prototype.handleXYChanged.call(this),this._flip!=t.FlipType.None&&(-1==this._content.scaleX&&(this._content.x+=this.width),-1==this._content.scaleY&&(this._content.y+=this.height))},i.prototype.getProp=function(i){return i==t.ObjectPropID.Color?this.color:e.prototype.getProp.call(this,i)},i.prototype.setProp=function(i,n){i==t.ObjectPropID.Color?this.color=n:e.prototype.setProp.call(this,i,n)},i.prototype.setup_beforeAdd=function(t,i){e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,5),t.readBool()&&(this.color=t.readColor()),this.flip=t.readByte(),this._content.fillMethod=t.readByte(),0!=this._content.fillMethod&&(this._content.fillOrigin=t.readByte(),this._content.fillClockwise=t.readBool(),this._content.fillAmount=t.readFloat())},i}(t.GObject);t.GImage=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){return e.call(this)||this}return __extends(i,e),Object.defineProperty(i.prototype,"icon",{get:function(){if(this._iconObject)return this._iconObject.icon},set:function(t){this._iconObject&&(this._iconObject.icon=t),this.updateGear(7)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"title",{get:function(){return this._titleObject?this._titleObject.text:null},set:function(t){this._titleObject&&(this._titleObject.text=t),this.updateGear(6)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"text",{get:function(){return this.title},set:function(t){this.title=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"titleColor",{get:function(){var t=this.getTextField();return t?t.color:0},set:function(t){var e=this.getTextField();e&&(e.color=t),this.updateGear(4)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"titleFontSize",{get:function(){var t=this.getTextField();return t?t.fontSize:0},set:function(t){var e=this.getTextField();e&&(e.fontSize=t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"editable",{get:function(){return!!(this._titleObject&&this._titleObject instanceof t.GTextInput)&&this._titleObject.asTextInput.editable},set:function(t){this._titleObject&&(this._titleObject.asTextInput.editable=t)},enumerable:!0,configurable:!0}),i.prototype.getTextField=function(){return this._titleObject instanceof t.GTextField?this._titleObject:this._titleObject instanceof i||this._titleObject instanceof t.GButton?this._titleObject.getTextField():null},i.prototype.getProp=function(i){switch(i){case t.ObjectPropID.Color:return this.titleColor;case t.ObjectPropID.OutlineColor:var n=this.getTextField();return n?n.strokeColor:0;case t.ObjectPropID.FontSize:return this.titleFontSize;default:return e.prototype.getProp.call(this,i)}},i.prototype.setProp=function(i,n){switch(i){case t.ObjectPropID.Color:this.titleColor=n;break;case t.ObjectPropID.OutlineColor:var o=this.getTextField();o&&(o.strokeColor=n);break;case t.ObjectPropID.FontSize:this.titleFontSize=n;break;default:e.prototype.setProp.call(this,i,n)}},i.prototype.constructExtension=function(t){this._titleObject=this.getChild("title"),this._iconObject=this.getChild("icon")},i.prototype.setup_afterAdd=function(i,n){if(e.prototype.setup_afterAdd.call(this,i,n),i.seek(n,6)&&i.readByte()==this.packageItem.objectType){var o;null!=(o=i.readS())&&(this.title=o),null!=(o=i.readS())&&(this.icon=o),i.readBool()&&(this.titleColor=i.readColor());var r=i.readInt();if(0!=r&&(this.titleFontSize=r),i.readBool()){var s=this.getTextField();s instanceof t.GTextInput?(null!=(o=i.readS())&&(s.promptText=o),null!=(o=i.readS())&&(s.restrict=o),0!=(r=i.readInt())&&(s.maxLength=r),r=i.readInt(),i.readBool()&&(s.password=!0)):i.skip(13)}}},i}(t.GComponent);t.GLabel=e}(fgui||(fgui={})),function(t){var e=function(e){function n(){var i=e.call(this)||this;return i.scrollItemToViewOnClick=!0,i.foldInvisibleItems=!1,i._lineCount=0,i._columnCount=0,i._lineGap=0,i._columnGap=0,i._lastSelectedIndex=0,i._numItems=0,i._realNumItems=0,i._firstIndex=0,i._curLineItemCount=0,i._curLineItemCount2=0,i._virtualListChanged=0,i.itemInfoVer=0,i._trackBounds=!0,i._pool=new t.GObjectPool,i._layout=t.ListLayoutType.SingleColumn,i._autoResizeItem=!0,i._lastSelectedIndex=-1,i._selectionMode=t.ListSelectionMode.Single,i.opaque=!0,i._align=t.AlignType.Left,i._verticalAlign=t.VertAlignType.Top,i._container=new egret.DisplayObjectContainer,i._rootContainer.addChild(i._container),i}return __extends(n,e),n.prototype.dispose=function(){this._pool.clear(),e.prototype.dispose.call(this)},Object.defineProperty(n.prototype,"layout",{get:function(){return this._layout},set:function(t){this._layout!=t&&(this._layout=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"lineCount",{get:function(){return this._lineCount},set:function(t){this._lineCount!=t&&(this._lineCount=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"columnCount",{get:function(){return this._columnCount},set:function(t){this._columnCount!=t&&(this._columnCount=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"lineGap",{get:function(){return this._lineGap},set:function(t){this._lineGap!=t&&(this._lineGap=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"columnGap",{get:function(){return this._columnGap},set:function(t){this._columnGap!=t&&(this._columnGap=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"align",{get:function(){return this._align},set:function(t){this._align!=t&&(this._align=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"verticalAlign",{get:function(){return this._verticalAlign},set:function(t){this._verticalAlign!=t&&(this._verticalAlign=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"virtualItemSize",{get:function(){return this._itemSize},set:function(t){this._virtual&&(this._itemSize||(this._itemSize=new egret.Point),this._itemSize.copyFrom(t),this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"defaultItem",{get:function(){return this._defaultItem},set:function(t){this._defaultItem=t},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"autoResizeItem",{get:function(){return this._autoResizeItem},set:function(t){this._autoResizeItem!=t&&(this._autoResizeItem=t,this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"selectionMode",{get:function(){return this._selectionMode},set:function(t){this._selectionMode=t},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"selectionController",{get:function(){return this._selectionController},set:function(t){this._selectionController=t},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"itemPool",{get:function(){return this._pool},enumerable:!0,configurable:!0}),n.prototype.getFromPool=function(t){t||(t=this._defaultItem);var e=this._pool.getObject(t);return e&&(e.visible=!0),e},n.prototype.returnToPool=function(t){t.displayObject.cacheAsBitmap=!1,this._pool.returnObject(t)},n.prototype.addChildAt=function(i,n){return e.prototype.addChildAt.call(this,i,n),i instanceof t.GButton&&(i.selected=!1,i.changeStateOnClick=!1),i.addEventListener(egret.TouchEvent.TOUCH_TAP,this.__clickItem,this),i},n.prototype.addItem=function(e){return e||(e=this._defaultItem),this.addChild(t.UIPackage.createObjectFromURL(e))},n.prototype.addItemFromPool=function(t){return this.addChild(this.getFromPool(t))},n.prototype.removeChildAt=function(t,i){var n=e.prototype.removeChildAt.call(this,t,i);return n.removeEventListener(egret.TouchEvent.TOUCH_TAP,this.__clickItem,this),n},n.prototype.removeChildToPoolAt=function(t){var i=e.prototype.removeChildAt.call(this,t);this.returnToPool(i)},n.prototype.removeChildToPool=function(t){e.prototype.removeChild.call(this,t),this.returnToPool(t)},n.prototype.removeChildrenToPool=function(t,e){null==t&&(t=0),null==e&&(e=-1),(e<0||e>=this._children.length)&&(e=this._children.length-1);for(var i=t;i<=e;++i)this.removeChildToPoolAt(t)},Object.defineProperty(n.prototype,"selectedIndex",{get:function(){var e;if(this._virtual)for(e=0;e<this._realNumItems;e++){var i=this._virtualItems[e];if(i.obj instanceof t.GButton&&i.obj.selected||null==i.obj&&i.selected)return this._loop?e%this._numItems:e}else{var n=this._children.length;for(e=0;e<n;e++){var o=this._children[e];if(o instanceof t.GButton&&o.selected)return e}}return-1},set:function(e){e>=0&&e<this.numItems?(this._selectionMode!=t.ListSelectionMode.Single&&this.clearSelection(),this.addSelection(e)):this.clearSelection()},enumerable:!0,configurable:!0}),n.prototype.getSelection=function(e){var i;if(e||(e=new Array),this._virtual)for(i=0;i<this._realNumItems;i++){var n=this._virtualItems[i];if(n.obj instanceof t.GButton&&n.obj.selected||null==n.obj&&n.selected){var o=i;if(this._loop&&(o=i%this._numItems,-1!=e.indexOf(o)))continue;e.push(o)}}else{var r=this._children.length;for(i=0;i<r;i++){var s=this._children[i];s instanceof t.GButton&&s.selected&&e.push(i)}}return e},n.prototype.addSelection=function(e,i){if(this._selectionMode!=t.ListSelectionMode.None){var n;if(this.checkVirtualList(),this._selectionMode==t.ListSelectionMode.Single&&this.clearSelection(),i&&this.scrollToView(e),this._lastSelectedIndex=e,this._virtual){var o=this._virtualItems[e];o.obj&&(n=o.obj),o.selected=!0}else n=this.getChildAt(e);n instanceof t.GButton&&!n.selected&&(n.selected=!0,this.updateSelectionController(e))}},n.prototype.removeSelection=function(e){if(this._selectionMode!=t.ListSelectionMode.None){var i;if(this._virtual){var n=this._virtualItems[e];n.obj&&(i=n.obj),n.selected=!1}else i=this.getChildAt(e);i instanceof t.GButton&&(i.selected=!1)}},n.prototype.clearSelection=function(){var e;if(this._virtual)for(e=0;e<this._realNumItems;e++){var i=this._virtualItems[e];i.obj instanceof t.GButton&&(i.obj.selected=!1),i.selected=!1}else{var n=this._children.length;for(e=0;e<n;e++){var o=this._children[e];o instanceof t.GButton&&(o.selected=!1)}}},n.prototype.clearSelectionExcept=function(e){var i;if(this._virtual)for(i=0;i<this._realNumItems;i++){var n=this._virtualItems[i];n.obj!=e&&(n.obj instanceof t.GButton&&(n.obj.selected=!1),n.selected=!1)}else{var o=this._children.length;for(i=0;i<o;i++){var r=this._children[i];r instanceof t.GButton&&r!=e&&(r.selected=!1)}}},n.prototype.selectAll=function(){this.checkVirtualList();var e,i=-1;if(this._virtual)for(e=0;e<this._realNumItems;e++){var n=this._virtualItems[e];n.obj instanceof t.GButton&&!n.obj.selected&&(n.obj.selected=!0,i=e),n.selected=!0}else{var o=this._children.length;for(e=0;e<o;e++){var r=this._children[e];r instanceof t.GButton&&!r.selected&&(r.selected=!0,i=e)}}-1!=i&&this.updateSelectionController(i)},n.prototype.selectNone=function(){this.clearSelection()},n.prototype.selectReverse=function(){this.checkVirtualList();var e,i=-1;if(this._virtual)for(e=0;e<this._realNumItems;e++){var n=this._virtualItems[e];n.obj instanceof t.GButton&&(n.obj.selected=!n.obj.selected,n.obj.selected&&(i=e)),n.selected=!n.selected}else{var o=this._children.length;for(e=0;e<o;e++){var r=this._children[e];r instanceof t.GButton&&(r.selected=!r.selected,r.selected&&(i=e))}}-1!=i&&this.updateSelectionController(i)},n.prototype.handleArrowKey=function(e){var i=this.selectedIndex;if(-1!=i)switch(e){case 1:if(this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowVertical)--i>=0&&(this.clearSelection(),this.addSelection(i,!0));else if(this._layout==t.ListLayoutType.FlowHorizontal||this._layout==t.ListLayoutType.Pagination){for(var n=this._children[i],o=0,r=i-1;r>=0;r--){var s=this._children[r];if(s.y!=n.y){n=s;break}o++}for(;r>=0;r--)if((s=this._children[r]).y!=n.y){this.clearSelection(),this.addSelection(r+o+1,!0);break}}break;case 3:if(this._layout==t.ListLayoutType.SingleRow||this._layout==t.ListLayoutType.FlowHorizontal||this._layout==t.ListLayoutType.Pagination)++i<this._children.length&&(this.clearSelection(),this.addSelection(i,!0));else if(this._layout==t.ListLayoutType.FlowVertical){n=this._children[i],o=0;var a=this._children.length;for(r=i+1;r<a;r++){if((s=this._children[r]).x!=n.x){n=s;break}o++}for(;r<a;r++)if((s=this._children[r]).x!=n.x){this.clearSelection(),this.addSelection(r-o-1,!0);break}}break;case 5:if(this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowVertical)++i<this._children.length&&(this.clearSelection(),this.addSelection(i,!0));else if(this._layout==t.ListLayoutType.FlowHorizontal||this._layout==t.ListLayoutType.Pagination){for(n=this._children[i],o=0,a=this._children.length,r=i+1;r<a;r++){if((s=this._children[r]).y!=n.y){n=s;break}o++}for(;r<a;r++)if((s=this._children[r]).y!=n.y){this.clearSelection(),this.addSelection(r-o-1,!0);break}}break;case 7:if(this._layout==t.ListLayoutType.SingleRow||this._layout==t.ListLayoutType.FlowHorizontal||this._layout==t.ListLayoutType.Pagination)--i>=0&&(this.clearSelection(),this.addSelection(i,!0));else if(this._layout==t.ListLayoutType.FlowVertical){for(n=this._children[i],o=0,r=i-1;r>=0;r--){if((s=this._children[r]).x!=n.x){n=s;break}o++}for(;r>=0;r--)if((s=this._children[r]).x!=n.x){this.clearSelection(),this.addSelection(r+o+1,!0);break}}}},n.prototype.__clickItem=function(e){if(!this._scrollPane||!this._scrollPane.isDragged){var i=e.currentTarget;this.setSelectionOnEvent(i),this._scrollPane&&this.scrollItemToViewOnClick&&this._scrollPane.scrollToView(i,!0);var n=new t.ItemEvent(t.ItemEvent.CLICK,i);n.stageX=e.stageX,n.stageY=e.stageY,this.dispatchItemEvent(n)}},n.prototype.dispatchItemEvent=function(t){this.dispatchEvent(t)},n.prototype.setSelectionOnEvent=function(e){if(e instanceof t.GButton&&this._selectionMode!=t.ListSelectionMode.None){var i=!1,n=this.childIndexToItemIndex(this.getChildIndex(e));if(this._selectionMode==t.ListSelectionMode.Single)e.selected||(this.clearSelectionExcept(e),e.selected=!0);else if(t.GRoot.shiftKeyDown){if(!e.selected)if(-1!=this._lastSelectedIndex){var o,r=Math.min(this._lastSelectedIndex,n),s=Math.max(this._lastSelectedIndex,n);if(s=Math.min(s,this.numItems-1),this._virtual)for(o=r;o<=s;o++){var a=this._virtualItems[o];a.obj instanceof t.GButton&&(a.obj.selected=!0),a.selected=!0}else for(o=r;o<=s;o++){var h=this.getChildAt(o);h instanceof t.GButton&&(h.selected=!0)}i=!0}else e.selected=!0}else t.GRoot.ctrlKeyDown||this._selectionMode==t.ListSelectionMode.Multiple_SingleClick?e.selected=!e.selected:e.selected?this.clearSelectionExcept(e):(this.clearSelectionExcept(e),e.selected=!0);i||(this._lastSelectedIndex=n),e.selected&&this.updateSelectionController(n)}},n.prototype.resizeToFit=function(e,i){void 0===e&&(e=Number.POSITIVE_INFINITY),void 0===i&&(i=0),this.ensureBoundsCorrect();var n=this.numItems;if(e>n&&(e=n),this._virtual){var o=Math.ceil(e/this._curLineItemCount);this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal?this.viewHeight=o*this._itemSize.y+Math.max(0,o-1)*this._lineGap:this.viewWidth=o*this._itemSize.x+Math.max(0,o-1)*this._columnGap}else if(0==e)this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal?this.viewHeight=i:this.viewWidth=i;else{for(var r,s=e-1;s>=0&&(r=this.getChildAt(s),this.foldInvisibleItems&&!r.visible);)s--;if(s<0)this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal?this.viewHeight=i:this.viewWidth=i;else{var a=0;this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal?((a=r.y+r.height)<i&&(a=i),this.viewHeight=a):((a=r.x+r.width)<i&&(a=i),this.viewWidth=a)}}},n.prototype.getMaxItemWidth=function(){for(var t=this._children.length,e=0,i=0;i<t;i++){var n=this.getChildAt(i);n.width>e&&(e=n.width)}return e},n.prototype.handleSizeChanged=function(){e.prototype.handleSizeChanged.call(this),this.setBoundsChangedFlag(),this._virtual&&this.setVirtualListChangedFlag(!0)},n.prototype.handleControllerChanged=function(t){e.prototype.handleControllerChanged.call(this,t),this._selectionController==t&&(this.selectedIndex=t.selectedIndex)},n.prototype.updateSelectionController=function(t){if(this._selectionController&&!this._selectionController.changing&&t<this._selectionController.pageCount){var e=this._selectionController;this._selectionController=null,e.selectedIndex=t,this._selectionController=e}},n.prototype.getSnappingPosition=function(n,o,r){var s,a;return this._virtual?(r||(r=new egret.Point),this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal?(s=o,i=o,a=this.getIndexOnPos1(!1),o=i,a<this._virtualItems.length&&s-o>this._virtualItems[a].height/2&&a<this._realNumItems&&(o+=this._virtualItems[a].height+this._lineGap)):this._layout==t.ListLayoutType.SingleRow||this._layout==t.ListLayoutType.FlowVertical?(s=n,i=n,a=this.getIndexOnPos2(!1),n=i,a<this._virtualItems.length&&s-n>this._virtualItems[a].width/2&&a<this._realNumItems&&(n+=this._virtualItems[a].width+this._columnGap)):(s=n,i=n,a=this.getIndexOnPos3(!1),n=i,a<this._virtualItems.length&&s-n>this._virtualItems[a].width/2&&a<this._realNumItems&&(n+=this._virtualItems[a].width+this._columnGap)),r.x=n,r.y=o,r):e.prototype.getSnappingPosition.call(this,n,o,r)},n.prototype.scrollToView=function(e,i,n){if(this._virtual){if(0==this._numItems)return;if(this.checkVirtualList(),e>=this._virtualItems.length)throw"Invalid child index: "+e+">"+this._virtualItems.length;var o;this._loop&&(e=Math.floor(this._firstIndex/this._numItems)*this._numItems+e);var r,s=this._virtualItems[e],a=0;if(this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal){for(r=this._curLineItemCount-1;r<e;r+=this._curLineItemCount)a+=this._virtualItems[r].height+this._lineGap;o=new egret.Rectangle(0,a,this._itemSize.x,s.height)}else if(this._layout==t.ListLayoutType.SingleRow||this._layout==t.ListLayoutType.FlowVertical){for(r=this._curLineItemCount-1;r<e;r+=this._curLineItemCount)a+=this._virtualItems[r].width+this._columnGap;o=new egret.Rectangle(a,0,s.width,this._itemSize.y)}else{var h=e/(this._curLineItemCount*this._curLineItemCount2);o=new egret.Rectangle(h*this.viewWidth+e%this._curLineItemCount*(s.width+this._columnGap),e/this._curLineItemCount%this._curLineItemCount2*(s.height+this._lineGap),s.width,s.height)}this._scrollPane&&this._scrollPane.scrollToView(o,i,n)}else{var l=this.getChildAt(e);l&&(this._scrollPane?this._scrollPane.scrollToView(l,i,n):this.parent&&this.parent.scrollPane&&this.parent.scrollPane.scrollToView(l,i,n))}},n.prototype.getFirstChildInView=function(){return this.childIndexToItemIndex(e.prototype.getFirstChildInView.call(this))},n.prototype.childIndexToItemIndex=function(e){if(!this._virtual)return e;if(this._layout==t.ListLayoutType.Pagination){for(var i=this._firstIndex;i<this._realNumItems;i++)if(this._virtualItems[i].obj&&--e<0)return i;return e}return e+=this._firstIndex,this._loop&&this._numItems>0&&(e%=this._numItems),e},n.prototype.itemIndexToChildIndex=function(e){if(!this._virtual)return e;if(this._layout==t.ListLayoutType.Pagination)return this.getChildIndex(this._virtualItems[e].obj);if(this._loop&&this._numItems>0){var i=this._firstIndex%this._numItems;e>=i?e-=i:e=this._numItems-i+e}else e-=this._firstIndex;return e},n.prototype.setVirtual=function(){this._setVirtual(!1)},n.prototype.setVirtualAndLoop=function(){this._setVirtual(!0)},n.prototype._setVirtual=function(e){if(!this._virtual){if(null==this._scrollPane)throw"Virtual list must be scrollable!";if(e){if(this._layout==t.ListLayoutType.FlowHorizontal||this._layout==t.ListLayoutType.FlowVertical)throw"Loop list is not supported for FlowHorizontal or FlowVertical layout!";this._scrollPane.bouncebackEffect=!1}if(this._virtual=!0,this._loop=e,this._virtualItems=new Array,this.removeChildrenToPool(),null==this._itemSize){this._itemSize=new egret.Point;var i=this.getFromPool(null);if(null==i)throw"Virtual List must have a default list item resource.";this._itemSize.x=i.width,this._itemSize.y=i.height,this.returnToPool(i)}this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal?(this._scrollPane.scrollStep=this._itemSize.y,this._loop&&(this._scrollPane._loop=2)):(this._scrollPane.scrollStep=this._itemSize.x,this._loop&&(this._scrollPane._loop=1)),this._scrollPane.addEventListener(t.ScrollPane.SCROLL,this.__scrolled,this),this.setVirtualListChangedFlag(!0)}},Object.defineProperty(n.prototype,"numItems",{get:function(){return this._virtual?this._numItems:this._children.length},set:function(e){if(this._virtual){if(null==this.itemRenderer)throw"Set itemRenderer first!";this._numItems=e,this._loop?this._realNumItems=6*this._numItems:this._realNumItems=this._numItems;var i=this._virtualItems.length;if(this._realNumItems>i)for(r=i;r<this._realNumItems;r++){var n={width:this._itemSize.x,height:this._itemSize.y,updateFlag:0};this._virtualItems.push(n)}else for(r=this._realNumItems;r<i;r++)this._virtualItems[r].selected=!1;0!=this._virtualListChanged&&t.GTimers.inst.remove(this._refreshVirtualList,this),this._refreshVirtualList()}else{var o=this._children.length;if(e>o)for(var r=o;r<e;r++)null==this.itemProvider?this.addItemFromPool():this.addItemFromPool(this.itemProvider.call(this.callbackThisObj,r));else this.removeChildrenToPool(e,o);if(null!=this.itemRenderer)for(r=0;r<e;r++)this.itemRenderer.call(this.callbackThisObj,r,this.getChildAt(r))}},enumerable:!0,configurable:!0}),n.prototype.refreshVirtualList=function(){this.setVirtualListChangedFlag(!1)},n.prototype.checkVirtualList=function(){0!=this._virtualListChanged&&(this._refreshVirtualList(),t.GTimers.inst.remove(this._refreshVirtualList,this))},n.prototype.setVirtualListChangedFlag=function(e){e?this._virtualListChanged=2:0==this._virtualListChanged&&(this._virtualListChanged=1),t.GTimers.inst.callLater(this._refreshVirtualList,this)},n.prototype._refreshVirtualList=function(){var e=2==this._virtualListChanged;this._virtualListChanged=0,this._eventLocked=!0,e&&(this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.SingleRow?this._curLineItemCount=1:this._layout==t.ListLayoutType.FlowHorizontal?this._columnCount>0?this._curLineItemCount=this._columnCount:(this._curLineItemCount=Math.floor((this._scrollPane.viewWidth+this._columnGap)/(this._itemSize.x+this._columnGap)),this._curLineItemCount<=0&&(this._curLineItemCount=1)):this._layout==t.ListLayoutType.FlowVertical?this._lineCount>0?this._curLineItemCount=this._lineCount:(this._curLineItemCount=Math.floor((this._scrollPane.viewHeight+this._lineGap)/(this._itemSize.y+this._lineGap)),this._curLineItemCount<=0&&(this._curLineItemCount=1)):(this._columnCount>0?this._curLineItemCount=this._columnCount:(this._curLineItemCount=Math.floor((this._scrollPane.viewWidth+this._columnGap)/(this._itemSize.x+this._columnGap)),this._curLineItemCount<=0&&(this._curLineItemCount=1)),this._lineCount>0?this._curLineItemCount2=this._lineCount:(this._curLineItemCount2=Math.floor((this._scrollPane.viewHeight+this._lineGap)/(this._itemSize.y+this._lineGap)),this._curLineItemCount2<=0&&(this._curLineItemCount2=1))));var i=0,n=0;if(this._realNumItems>0){var o,r=Math.ceil(this._realNumItems/this._curLineItemCount)*this._curLineItemCount,s=Math.min(this._curLineItemCount,this._realNumItems);if(this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal){for(o=0;o<r;o+=this._curLineItemCount)i+=this._virtualItems[o].height+this._lineGap;if(i>0&&(i-=this._lineGap),this._autoResizeItem)n=this._scrollPane.viewWidth;else{for(o=0;o<s;o++)n+=this._virtualItems[o].width+this._columnGap;n>0&&(n-=this._columnGap)}}else if(this._layout==t.ListLayoutType.SingleRow||this._layout==t.ListLayoutType.FlowVertical){for(o=0;o<r;o+=this._curLineItemCount)n+=this._virtualItems[o].width+this._columnGap;if(n>0&&(n-=this._columnGap),this._autoResizeItem)i=this._scrollPane.viewHeight;else{for(o=0;o<s;o++)i+=this._virtualItems[o].height+this._lineGap;i>0&&(i-=this._lineGap)}}else{n=Math.ceil(r/(this._curLineItemCount*this._curLineItemCount2))*this.viewWidth,i=this.viewHeight}}this.handleAlign(n,i),this._scrollPane.setContentSize(n,i),this._eventLocked=!1,this.handleScroll(!0)},n.prototype.__scrolled=function(t){this.handleScroll(!1)},n.prototype.getIndexOnPos1=function(t){if(this._realNumItems<this._curLineItemCount)return i=0,0;var e,n,o;if(this.numChildren>0&&!t){if((n=this.getChildAt(0).y)>i){for(e=this._firstIndex-this._curLineItemCount;e>=0;e-=this._curLineItemCount)if((n-=this._virtualItems[e].height+this._lineGap)<=i)return i=n,e;return i=0,0}for(e=this._firstIndex;e<this._realNumItems;e+=this._curLineItemCount){if((o=n+this._virtualItems[e].height+this._lineGap)>i)return i=n,e;n=o}return i=n,this._realNumItems-this._curLineItemCount}for(n=0,e=0;e<this._realNumItems;e+=this._curLineItemCount){if((o=n+this._virtualItems[e].height+this._lineGap)>i)return i=n,e;n=o}return i=n,this._realNumItems-this._curLineItemCount},n.prototype.getIndexOnPos2=function(t){if(this._realNumItems<this._curLineItemCount)return i=0,0;var e,n,o;if(this.numChildren>0&&!t){if((n=this.getChildAt(0).x)>i){for(e=this._firstIndex-this._curLineItemCount;e>=0;e-=this._curLineItemCount)if((n-=this._virtualItems[e].width+this._columnGap)<=i)return i=n,e;return i=0,0}for(e=this._firstIndex;e<this._realNumItems;e+=this._curLineItemCount){if((o=n+this._virtualItems[e].width+this._columnGap)>i)return i=n,e;n=o}return i=n,this._realNumItems-this._curLineItemCount}for(n=0,e=0;e<this._realNumItems;e+=this._curLineItemCount){if((o=n+this._virtualItems[e].width+this._columnGap)>i)return i=n,e;n=o}return i=n,this._realNumItems-this._curLineItemCount},n.prototype.getIndexOnPos3=function(t){if(this._realNumItems<this._curLineItemCount)return i=0,0;var e,n,o=this.viewWidth,r=Math.floor(i/o),s=r*(this._curLineItemCount*this._curLineItemCount2),a=r*o;for(e=0;e<this._curLineItemCount;e++){if((n=a+this._virtualItems[s+e].width+this._columnGap)>i)return i=a,s+e;a=n}return i=a,s+this._curLineItemCount-1},n.prototype.handleScroll=function(e){if(!this._eventLocked){if(this._layout==t.ListLayoutType.SingleColumn||this._layout==t.ListLayoutType.FlowHorizontal){for(var i=0;this.handleScroll1(e);)if(e=!1,++i>20){console.log("FairyGUI: list will never be filled as the item renderer function always returns a different size.");break}this.handleArchOrder1()}else if(this._layout==t.ListLayoutType.SingleRow||this._layout==t.ListLayoutType.FlowVertical){for(i=0;this.handleScroll2(e);)if(e=!1,++i>20){console.log("FairyGUI: list will never be filled as the item renderer function always returns a different size.");break}this.handleArchOrder2()}else this.handleScroll3(e);this._boundsChanged=!1}},n.prototype.handleScroll1=function(e){var n=this._scrollPane.scrollingPosY,o=n+this._scrollPane.viewHeight,r=o==this._scrollPane.contentHeight;i=n;var s=this.getIndexOnPos1(e);if(n=i,s==this._firstIndex&&!e)return!1;var a=this._firstIndex;this._firstIndex=s;var h,l,c,u,_,p=s,d=a>s,g=this.numChildren,f=a+g-1,y=d?f:a,m=0,b=n,v=0,w=0,C=this.defaultItem,S=(this._scrollPane.viewWidth-this._columnGap*(this._curLineItemCount-1))/this._curLineItemCount;for(this.itemInfoVer++;p<this._realNumItems&&(r||b<o);){if((null==(l=this._virtualItems[p]).obj||e)&&(null!=this.itemProvider&&(null==(C=this.itemProvider.call(this.callbackThisObj,p%this._numItems))&&(C=this._defaultItem),C=t.UIPackage.normalizeURL(C)),l.obj&&l.obj.resourceURL!=C&&(l.obj instanceof t.GButton&&(l.selected=l.obj.selected),this.removeChildToPool(l.obj),l.obj=null)),null==l.obj){if(d){for(_=y;_>=a;_--)if((c=this._virtualItems[_]).obj&&c.updateFlag!=this.itemInfoVer&&c.obj.resourceURL==C){c.obj instanceof t.GButton&&(c.selected=c.obj.selected),l.obj=c.obj,c.obj=null,_==y&&y--;break}}else for(_=y;_<=f;_++)if((c=this._virtualItems[_]).obj&&c.updateFlag!=this.itemInfoVer&&c.obj.resourceURL==C){c.obj instanceof t.GButton&&(c.selected=c.obj.selected),l.obj=c.obj,c.obj=null,_==y&&y++;break}l.obj?this.setChildIndex(l.obj,d?p-s:this.numChildren):(l.obj=this._pool.getObject(C),d?this.addChildAt(l.obj,p-s):this.addChild(l.obj)),l.obj instanceof t.GButton&&(l.obj.selected=l.selected),h=!0}else h=e;h&&(this._autoResizeItem&&(this._layout==t.ListLayoutType.SingleColumn||this._columnCount>0)&&l.obj.setSize(S,l.obj.height,!0),this.itemRenderer.call(this.callbackThisObj,p%this._numItems,l.obj),p%this._curLineItemCount==0&&(v+=Math.ceil(l.obj.height)-l.height,p==s&&a>s&&(w=Math.ceil(l.obj.height)-l.height)),l.width=Math.ceil(l.obj.width),l.height=Math.ceil(l.obj.height)),l.updateFlag=this.itemInfoVer,l.obj.setXY(m,b),p==s&&(o+=l.height),m+=l.width+this._columnGap,p%this._curLineItemCount==this._curLineItemCount-1&&(m=0,b+=l.height+this._lineGap),p++}for(u=0;u<g;u++)(l=this._virtualItems[a+u]).updateFlag!=this.itemInfoVer&&l.obj&&(l.obj instanceof t.GButton&&(l.selected=l.obj.selected),this.removeChildToPool(l.obj),l.obj=null);for(g=this._children.length,u=0;u<g;u++){var x=this._virtualItems[s+u].obj;this._children[u]!=x&&this.setChildIndex(x,u)}return 0==v&&0==w||this._scrollPane.changeContentSizeOnScrolling(0,v,0,w),p>0&&this.numChildren>0&&this._container.y<=0&&this.getChildAt(0).y>-this._container.y},n.prototype.handleScroll2=function(e){var n=this._scrollPane.scrollingPosX,o=n+this._scrollPane.viewWidth,r=n==this._scrollPane.contentWidth;i=n;var s=this.getIndexOnPos2(e);if(n=i,s==this._firstIndex&&!e)return!1;var a=this._firstIndex;this._firstIndex=s;var h,l,c,u,_,p=s,d=a>s,g=this.numChildren,f=a+g-1,y=d?f:a,m=n,b=0,v=0,w=0,C=this.defaultItem,S=(this._scrollPane.viewHeight-this._lineGap*(this._curLineItemCount-1))/this._curLineItemCount;for(this.itemInfoVer++;p<this._realNumItems&&(r||m<o);){if((null==(l=this._virtualItems[p]).obj||e)&&(null!=this.itemProvider&&(null==(C=this.itemProvider.call(this.callbackThisObj,p%this._numItems))&&(C=this._defaultItem),C=t.UIPackage.normalizeURL(C)),l.obj&&l.obj.resourceURL!=C&&(l.obj instanceof t.GButton&&(l.selected=l.obj.selected),this.removeChildToPool(l.obj),l.obj=null)),null==l.obj){if(d){for(_=y;_>=a;_--)if((c=this._virtualItems[_]).obj&&c.updateFlag!=this.itemInfoVer&&c.obj.resourceURL==C){c.obj instanceof t.GButton&&(c.selected=c.obj.selected),l.obj=c.obj,c.obj=null,_==y&&y--;break}}else for(_=y;_<=f;_++)if((c=this._virtualItems[_]).obj&&c.updateFlag!=this.itemInfoVer&&c.obj.resourceURL==C){c.obj instanceof t.GButton&&(c.selected=c.obj.selected),l.obj=c.obj,c.obj=null,_==y&&y++;break}l.obj?this.setChildIndex(l.obj,d?p-s:this.numChildren):(l.obj=this._pool.getObject(C),d?this.addChildAt(l.obj,p-s):this.addChild(l.obj)),l.obj instanceof t.GButton&&(l.obj.selected=l.selected),h=!0}else h=e;h&&(this._autoResizeItem&&(this._layout==t.ListLayoutType.SingleRow||this._lineCount>0)&&l.obj.setSize(l.obj.width,S,!0),this.itemRenderer.call(this.callbackThisObj,p%this._numItems,l.obj),p%this._curLineItemCount==0&&(v+=Math.ceil(l.obj.width)-l.width,p==s&&a>s&&(w=Math.ceil(l.obj.width)-l.width)),l.width=Math.ceil(l.obj.width),l.height=Math.ceil(l.obj.height)),l.updateFlag=this.itemInfoVer,l.obj.setXY(m,b),p==s&&(o+=l.width),b+=l.height+this._lineGap,p%this._curLineItemCount==this._curLineItemCount-1&&(b=0,m+=l.width+this._columnGap),p++}for(u=0;u<g;u++)(l=this._virtualItems[a+u]).updateFlag!=this.itemInfoVer&&l.obj&&(l.obj instanceof t.GButton&&(l.selected=l.obj.selected),this.removeChildToPool(l.obj),l.obj=null);for(g=this._children.length,u=0;u<g;u++){var x=this._virtualItems[s+u].obj;this._children[u]!=x&&this.setChildIndex(x,u)}return 0==v&&0==w||this._scrollPane.changeContentSizeOnScrolling(v,0,w,0),p>0&&this.numChildren>0&&this._container.x<=0&&this.getChildAt(0).x>-this._container.x},n.prototype.handleScroll3=function(e){var n=this._scrollPane.scrollingPosX;i=n;var o=this.getIndexOnPos3(e);if(n=i,o!=this._firstIndex||e){var r=this._firstIndex;this._firstIndex=o;var s,a,h,l,c,u,_=r,p=this._virtualItems.length,d=this._curLineItemCount*this._curLineItemCount2,g=o%this._curLineItemCount,f=this.viewWidth,y=Math.floor(o/d)*d,m=y+2*d,b=this._defaultItem,v=(this._scrollPane.viewWidth-this._columnGap*(this._curLineItemCount-1))/this._curLineItemCount,w=(this._scrollPane.viewHeight-this._lineGap*(this._curLineItemCount2-1))/this._curLineItemCount2;for(this.itemInfoVer++,a=y;a<m;a++)if(!(a>=this._realNumItems)){if(c=a%this._curLineItemCount,a-y<d){if(c<g)continue}else if(c>g)continue;(h=this._virtualItems[a]).updateFlag=this.itemInfoVer}var C=0;for(a=y;a<m;a++)if(!(a>=this._realNumItems)&&(h=this._virtualItems[a]).updateFlag==this.itemInfoVer){if(null==h.obj){for(;_<p;){if((l=this._virtualItems[_]).obj&&l.updateFlag!=this.itemInfoVer){l.obj instanceof t.GButton&&(l.selected=l.obj.selected),h.obj=l.obj,l.obj=null;break}_++}-1==C&&(C=this.getChildIndex(u)+1),null==h.obj?(null!=this.itemProvider&&(null==(b=this.itemProvider.call(this.callbackThisObj,a%this._numItems))&&(b=this._defaultItem),b=t.UIPackage.normalizeURL(b)),h.obj=this._pool.getObject(b),this.addChildAt(h.obj,C)):C=this.setChildIndexBefore(h.obj,C),C++,h.obj instanceof t.GButton&&(h.obj.selected=h.selected),s=!0}else s=e,C=-1,u=h.obj;s&&(this._autoResizeItem&&(this._curLineItemCount==this._columnCount&&this._curLineItemCount2==this._lineCount?h.obj.setSize(v,w,!0):this._curLineItemCount==this._columnCount?h.obj.setSize(v,h.obj.height,!0):this._curLineItemCount2==this._lineCount&&h.obj.setSize(h.obj.width,w,!0)),this.itemRenderer.call(this.callbackThisObj,a%this._numItems,h.obj),h.width=Math.ceil(h.obj.width),h.height=Math.ceil(h.obj.height))}var S=y/d*f,x=S,T=0,I=0;for(a=y;a<m;a++)a>=this._realNumItems||((h=this._virtualItems[a]).updateFlag==this.itemInfoVer&&h.obj.setXY(x,T),h.height>I&&(I=h.height),a%this._curLineItemCount==this._curLineItemCount-1?(x=S,T+=I+this._lineGap,I=0,a==y+d-1&&(x=S+=f,T=0)):x+=h.width+this._columnGap);for(a=_;a<p;a++)(h=this._virtualItems[a]).updateFlag!=this.itemInfoVer&&h.obj&&(h.obj instanceof t.GButton&&(h.selected=h.obj.selected),this.removeChildToPool(h.obj),h.obj=null)}},n.prototype.handleArchOrder1=function(){if(this._childrenRenderOrder==t.ChildrenRenderOrder.Arch){for(var e=this._scrollPane.posY+this.viewHeight/2,i=Number.POSITIVE_INFINITY,n=0,o=0,r=this.numChildren,s=0;s<r;s++){var a=this.getChildAt(s);this.foldInvisibleItems&&!a.visible||(n=Math.abs(e-a.y-a.height/2))<i&&(i=n,o=s)}this.apexIndex=o}},n.prototype.handleArchOrder2=function(){if(this._childrenRenderOrder==t.ChildrenRenderOrder.Arch){for(var e=this._scrollPane.posX+this.viewWidth/2,i=Number.POSITIVE_INFINITY,n=0,o=0,r=this.numChildren,s=0;s<r;s++){var a=this.getChildAt(s);this.foldInvisibleItems&&!a.visible||(n=Math.abs(e-a.x-a.width/2))<i&&(i=n,o=s)}this.apexIndex=o}},n.prototype.handleAlign=function(e,i){var n=0,o=0;i<this.viewHeight&&(this._verticalAlign==t.VertAlignType.Middle?o=Math.floor((this.viewHeight-i)/2):this._verticalAlign==t.VertAlignType.Bottom&&(o=this.viewHeight-i)),e<this.viewWidth&&(this._align==t.AlignType.Center?n=Math.floor((this.viewWidth-e)/2):this._align==t.AlignType.Right&&(n=this.viewWidth-e)),n==this._alignOffset.x&&o==this._alignOffset.y||(this._alignOffset.setTo(n,o),this._scrollPane?this._scrollPane.adjustMaskContainer():(this._container.x=this._margin.left+this._alignOffset.x,this._container.y=this._margin.top+this._alignOffset.y))},n.prototype.updateBounds=function(){if(!this._virtual){var e,i,n=0,o=0,r=0,s=0,a=0,h=0,l=0,c=0,u=0,_=this._children.length,p=this.viewWidth,d=this.viewHeight,g=0,f=0,y=0;if(this._layout==t.ListLayoutType.SingleColumn){for(e=0;e<_;e++)i=this.getChildAt(e),this.foldInvisibleItems&&!i.visible||(0!=o&&(o+=this._lineGap),i.y=o,this._autoResizeItem&&i.setSize(p,i.height,!0),o+=Math.ceil(i.height),i.width>r&&(r=i.width));if((h=o)<=d&&this._autoResizeItem&&this._scrollPane&&this._scrollPane._displayInDemand&&this._scrollPane.vtScrollBar)for(p+=this._scrollPane.vtScrollBar.width,e=0;e<_;e++)i=this.getChildAt(e),this.foldInvisibleItems&&!i.visible||(i.setSize(p,i.height,!0),i.width>r&&(r=i.width));a=Math.ceil(r)}else if(this._layout==t.ListLayoutType.SingleRow){for(e=0;e<_;e++)i=this.getChildAt(e),this.foldInvisibleItems&&!i.visible||(0!=n&&(n+=this._columnGap),i.x=n,this._autoResizeItem&&i.setSize(i.width,d,!0),n+=Math.ceil(i.width),i.height>s&&(s=i.height));if((a=n)<=p&&this._autoResizeItem&&this._scrollPane&&this._scrollPane._displayInDemand&&this._scrollPane.hzScrollBar)for(d+=this._scrollPane.hzScrollBar.height,e=0;e<_;e++)i=this.getChildAt(e),this.foldInvisibleItems&&!i.visible||(i.setSize(i.width,d,!0),i.height>s&&(s=i.height));h=Math.ceil(s)}else if(this._layout==t.ListLayoutType.FlowHorizontal)if(this._autoResizeItem&&this._columnCount>0){for(e=0;e<_;e++)if(i=this.getChildAt(e),(!this.foldInvisibleItems||i.visible)&&(g+=i.sourceWidth,++l==this._columnCount||e==_-1)){for(y=(p-g-(l-1)*this._columnGap)/g,n=0,l=f;l<=e;l++)i=this.getChildAt(l),this.foldInvisibleItems&&!i.visible||(i.setXY(n,o),l<e?(i.setSize(i.sourceWidth+Math.round(i.sourceWidth*y),i.height,!0),n+=Math.ceil(i.width)+this._columnGap):i.setSize(p-n,i.height,!0),i.height>s&&(s=i.height));o+=Math.ceil(s)+this._lineGap,s=0,l=0,f=e+1,g=0}h=o+Math.ceil(s),a=p}else{for(e=0;e<_;e++)i=this.getChildAt(e),this.foldInvisibleItems&&!i.visible||(0!=n&&(n+=this._columnGap),(0!=this._columnCount&&l>=this._columnCount||0==this._columnCount&&n+i.width>p&&0!=s)&&(n=0,o+=Math.ceil(s)+this._lineGap,s=0,l=0),i.setXY(n,o),(n+=Math.ceil(i.width))>r&&(r=n),i.height>s&&(s=i.height),l++);h=o+Math.ceil(s),a=Math.ceil(r)}else if(this._layout==t.ListLayoutType.FlowVertical)if(this._autoResizeItem&&this._lineCount>0){for(e=0;e<_;e++)if(i=this.getChildAt(e),(!this.foldInvisibleItems||i.visible)&&(g+=i.sourceHeight,++l==this._lineCount||e==_-1)){for(y=(d-g-(l-1)*this._lineGap)/g,o=0,l=f;l<=e;l++)i=this.getChildAt(l),this.foldInvisibleItems&&!i.visible||(i.setXY(n,o),l<e?(i.setSize(i.width,i.sourceHeight+Math.round(i.sourceHeight*y),!0),o+=Math.ceil(i.height)+this._lineGap):i.setSize(i.width,d-o,!0),i.width>r&&(r=i.width));n+=Math.ceil(r)+this._columnGap,r=0,l=0,f=e+1,g=0}a=n+Math.ceil(r),h=d}else{for(e=0;e<_;e++)i=this.getChildAt(e),this.foldInvisibleItems&&!i.visible||(0!=o&&(o+=this._lineGap),(0!=this._lineCount&&l>=this._lineCount||0==this._lineCount&&o+i.height>d&&0!=r)&&(o=0,n+=Math.ceil(r)+this._columnGap,r=0,l=0),i.setXY(n,o),(o+=Math.ceil(i.height))>s&&(s=o),i.width>r&&(r=i.width),l++);a=n+Math.ceil(r),h=Math.ceil(s)}else{var m;if(this._autoResizeItem&&this._lineCount>0&&(m=Math.floor((d-(this._lineCount-1)*this._lineGap)/this._lineCount)),this._autoResizeItem&&this._columnCount>0){for(e=0;e<_;e++)if(i=this.getChildAt(e),(!this.foldInvisibleItems||i.visible)&&(0==l&&(0!=this._lineCount&&u>=this._lineCount||0==this._lineCount&&o+(this._lineCount>0?m:i.height)>d)&&(c++,o=0,u=0),g+=i.sourceWidth,++l==this._columnCount||e==_-1)){for(y=(p-g-(l-1)*this._columnGap)/g,n=0,l=f;l<=e;l++)i=this.getChildAt(l),this.foldInvisibleItems&&!i.visible||(i.setXY(c*p+n,o),l<e?(i.setSize(i.sourceWidth+Math.round(i.sourceWidth*y),this._lineCount>0?m:i.height,!0),n+=Math.ceil(i.width)+this._columnGap):i.setSize(p-n,this._lineCount>0?m:i.height,!0),i.height>s&&(s=i.height));o+=Math.ceil(s)+this._lineGap,s=0,l=0,f=e+1,g=0,u++}}else for(e=0;e<_;e++)i=this.getChildAt(e),this.foldInvisibleItems&&!i.visible||(0!=n&&(n+=this._columnGap),this._autoResizeItem&&this._lineCount>0&&i.setSize(i.width,m,!0),(0!=this._columnCount&&l>=this._columnCount||0==this._columnCount&&n+i.width>p&&0!=s)&&(n=0,o+=Math.ceil(s)+this._lineGap,s=0,l=0,u++,(0!=this._lineCount&&u>=this._lineCount||0==this._lineCount&&o+i.height>d&&0!=r)&&(c++,o=0,u=0)),i.setXY(c*p+n,o),(n+=Math.ceil(i.width))>r&&(r=n),i.height>s&&(s=i.height),l++);h=c>0?d:o+Math.ceil(s),a=(c+1)*p}this.handleAlign(a,h),this.setBounds(0,0,a,h)}},n.prototype.setup_beforeAdd=function(i,n){e.prototype.setup_beforeAdd.call(this,i,n),i.seek(n,5),this._layout=i.readByte(),this._selectionMode=i.readByte(),this._align=i.readByte(),this._verticalAlign=i.readByte(),this._lineGap=i.readShort(),this._columnGap=i.readShort(),this._lineCount=i.readShort(),this._columnCount=i.readShort(),this._autoResizeItem=i.readBool(),this._childrenRenderOrder=i.readByte(),this._apexIndex=i.readShort(),i.readBool()&&(this._margin.top=i.readInt(),this._margin.bottom=i.readInt(),this._margin.left=i.readInt(),this._margin.right=i.readInt());var o=i.readByte();if(o==t.OverflowType.Scroll){var r=i.position;i.seek(n,7),this.setupScroll(i),i.position=r}else this.setupOverflow(o);i.readBool()&&i.skip(8),i.version>=2&&(this.scrollItemToViewOnClick=i.readBool(),this.foldInvisibleItems=i.readBool()),i.seek(n,8),this._defaultItem=i.readS(),this.readItems(i)},n.prototype.readItems=function(t){var e,i,n,o;for(e=t.readShort(),i=0;i<e;i++)if(n=t.readShort(),n+=t.position,null!=(o=t.readS())||(o=this.defaultItem)){var r=this.getFromPool(o);null!=r&&(this.addChild(r),this.setupItem(t,r)),t.position=n}else t.position=n},n.prototype.setupItem=function(e,i){var n,o,r;if(null!=(n=e.readS())&&(i.text=n),null!=(n=e.readS())&&i instanceof t.GButton&&(i.selectedTitle=n),null!=(n=e.readS())&&(i.icon=n),null!=(n=e.readS())&&i instanceof t.GButton&&(i.selectedIcon=n),null!=(n=e.readS())&&(i.name=n),i instanceof t.GComponent){for(o=e.readShort(),r=0;r<o;r++){var s=i.getController(e.readS());n=e.readS(),s&&(s.selectedPageId=n)}if(e.version>=2)for(o=e.readShort(),r=0;r<o;r++){var a=e.readS(),h=e.readShort(),l=e.readS(),c=i.getChildByPath(a);c&&c.setProp(h,l)}}},n.prototype.setup_afterAdd=function(t,i){e.prototype.setup_afterAdd.call(this,t,i),t.seek(i,6);var n=t.readShort();-1!=n&&(this._selectionController=this.parent.getControllerAt(n))},n}(t.GComponent);t.GList=e;var i=0}(fgui||(fgui={})),function(t){var e=function(){function e(){this._count=0,this._pool={}}return e.prototype.clear=function(){for(var t in this._pool)for(var e=this._pool[t],i=e.length,n=0;n<i;n++)e[n].dispose();this._pool={},this._count=0},Object.defineProperty(e.prototype,"count",{get:function(){return this._count},enumerable:!0,configurable:!0}),e.prototype.getObject=function(e){if(null==(e=t.UIPackage.normalizeURL(e)))return null;var i=this._pool[e];return i&&i.length?(this._count--,i.shift()):t.UIPackage.createObjectFromURL(e)},e.prototype.returnObject=function(t){var e=t.resourceURL;if(e){var i=this._pool[e];null==i&&(i=new Array,this._pool[e]=i),this._count++,i.push(t)}},e}();t.GObjectPool=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._url="",i._fill=t.LoaderFillType.None,i._align=t.AlignType.Left,i._verticalAlign=t.VertAlignType.Top,i._showErrorSign=!0,i}return __extends(i,e),i.prototype.createDisplayObject=function(){this._container=new t.UIContainer,this._container.opaque=!0,this.setDisplayObject(this._container),this._content=new t.MovieClip,this._container.addChild(this._content)},i.prototype.dispose=function(){if(!this._contentItem){var t=this._content.texture;t&&this.freeExternal(t)}this._content2&&this._content2.dispose(),e.prototype.dispose.call(this)},Object.defineProperty(i.prototype,"url",{get:function(){return this._url},set:function(t){this._url!=t&&(this.clearContent(),this._url=t,this.loadContent(),this.updateGear(7))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"icon",{get:function(){return this._url},set:function(t){this.url=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"align",{get:function(){return this._align},set:function(t){this._align!=t&&(this._align=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"verticalAlign",{get:function(){return this._verticalAlign},set:function(t){this._verticalAlign!=t&&(this._verticalAlign=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fill",{get:function(){return this._fill},set:function(t){this._fill!=t&&(this._fill=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"shrinkOnly",{get:function(){return this._shrinkOnly},set:function(t){this._shrinkOnly!=t&&(this._shrinkOnly=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"autoSize",{get:function(){return this._autoSize},set:function(t){this._autoSize!=t&&(this._autoSize=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"playing",{get:function(){return this._content.playing},set:function(t){this._content.playing!=t&&(this._content.playing=t,this.updateGear(5))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"frame",{get:function(){return this._content.frame},set:function(t){this._content.frame!=t&&(this._content.frame=t,this.updateGear(5))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"color",{get:function(){return this._content.color},set:function(t){this._content.color!=t&&(this._content.color=t,this.updateGear(4))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"showErrorSign",{get:function(){return this._showErrorSign},set:function(t){this._showErrorSign=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"content",{get:function(){return this._content},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"component",{get:function(){return this._content2},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"texture",{get:function(){return this._content.texture},set:function(t){this.url=null,this._content.frames=null,this._content.texture=t,t?(this.sourceWidth=t.textureWidth,this.sourceHeight=t.textureHeight):this.sourceWidth=this.sourceHeight=0,this.updateLayout()},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillMethod",{get:function(){return this._content.fillMethod},set:function(t){this._content.fillMethod=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillOrigin",{get:function(){return this._content.fillOrigin},set:function(t){this._content.fillOrigin=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillClockwise",{get:function(){return this._content.fillClockwise},set:function(t){this._content.fillClockwise=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillAmount",{get:function(){return this._content.fillAmount},set:function(t){this._content.fillAmount=t},enumerable:!0,configurable:!0}),i.prototype.loadContent=function(){this._url&&(t.ToolSet.startsWith(this._url,"ui://")?this.loadFromPackage(this._url):this.loadExternal())},i.prototype.loadFromPackage=function(e){if(this._contentItem=t.UIPackage.getItemByURL(e),this._contentItem)if(this._contentItem=this._contentItem.getBranch(),this.sourceWidth=this._contentItem.width,this.sourceHeight=this._contentItem.height,this._contentItem=this._contentItem.getHighResolution(),this._contentItem.load(),this._autoSize&&this.setSize(this.sourceWidth,this.sourceHeight),this._contentItem.type==t.PackageItemType.Image)null==this._contentItem.asset?this.setErrorState():(this._content.texture=this._contentItem.asset,this._content.scale9Grid=this._contentItem.scale9Grid,this._contentItem.scaleByTile?this._content.fillMode=egret.BitmapFillMode.REPEAT:this._content.fillMode=egret.BitmapFillMode.SCALE,this.updateLayout());else if(this._contentItem.type==t.PackageItemType.MovieClip)this._content.interval=this._contentItem.interval,this._content.swing=this._contentItem.swing,this._content.repeatDelay=this._contentItem.repeatDelay,this._content.frames=this._contentItem.frames,this.updateLayout();else if(this._contentItem.type==t.PackageItemType.Component){var i=t.UIPackage.createObjectFromURL(e);i?i instanceof t.GComponent?(this._content2=i.asCom,this._container.addChild(this._content2.displayObject),this.updateLayout()):(i.dispose(),this.setErrorState()):this.setErrorState()}else this.setErrorState();else this.setErrorState()},i.prototype.loadExternal=function(){RES.getResByUrl(this._url,this.__getResCompleted,this)},i.prototype.freeExternal=function(t){},i.prototype.onExternalLoadSuccess=function(t){this._content.texture=t,this._content.scale9Grid=null,this._content.fillMode=egret.BitmapFillMode.SCALE,this.sourceWidth=t.textureWidth,this.sourceHeight=t.textureHeight,this.updateLayout()},i.prototype.onExternalLoadFailed=function(){this.setErrorState()},i.prototype.__getResCompleted=function(t,e){t instanceof egret.Texture?this.onExternalLoadSuccess(t):this.onExternalLoadFailed()},i.prototype.setErrorState=function(){this._showErrorSign&&(null==this._errorSign&&null!=t.UIConfig.loaderErrorSign&&(this._errorSign=i._errorSignPool.getObject(t.UIConfig.loaderErrorSign)),this._errorSign&&(this._errorSign.setSize(this.width,this.height),this._container.addChild(this._errorSign.displayObject)))},i.prototype.clearErrorState=function(){this._errorSign&&(this._container.removeChild(this._errorSign.displayObject),i._errorSignPool.returnObject(this._errorSign),this._errorSign=null)},i.prototype.updateLayout=function(){if(this._content2||this._content){var e=this.sourceWidth,i=this.sourceHeight;if(this._autoSize&&(this._updatingLayout=!0,0==e&&(e=50),0==i&&(i=30),this.setSize(e,i),this._updatingLayout=!1,e==this._width&&i==this._height))this._content2?(this._content2.setXY(0,0),this._content2.setScale(1,1)):(this._content.x=0,this._content.y=0,this._content.width=e,this._content.height=i);else{var n,o,r=1,s=1;this._fill!=t.LoaderFillType.None&&(r=this.width/this.sourceWidth,s=this.height/this.sourceHeight,1==r&&1==s||(this._fill==t.LoaderFillType.ScaleMatchHeight?r=s:this._fill==t.LoaderFillType.ScaleMatchWidth?s=r:this._fill==t.LoaderFillType.Scale?r>s?r=s:s=r:this._fill==t.LoaderFillType.ScaleNoBorder&&(r>s?s=r:r=s),this._shrinkOnly&&(r>1&&(r=1),s>1&&(s=1)),e=this.sourceWidth*r,i=this.sourceHeight*s)),this._content2?this._content2.setScale(r,s):(this._content.width=e,this._content.height=i),n=this._align==t.AlignType.Center?Math.floor((this.width-e)/2):this._align==t.AlignType.Right?this.width-e:0,o=this._verticalAlign==t.VertAlignType.Middle?Math.floor((this.height-i)/2):this._verticalAlign==t.VertAlignType.Bottom?this.height-i:0,this._content2?this._content2.setXY(n,o):(this._content.x=n,this._content.y=o)}}else this._autoSize&&(this._updatingLayout=!0,this.setSize(50,30),this._updatingLayout=!1)},i.prototype.clearContent=function(){this.clearErrorState(),!this._contentItem&&this._content.texture&&this.freeExternal(this._content.texture),this._content.texture=null,this._content.frames=null,this._content2&&(this._container.removeChild(this._content2.displayObject),this._content2.dispose(),this._content2=null),this._contentItem=null},i.prototype.handleSizeChanged=function(){e.prototype.handleSizeChanged.call(this),this._updatingLayout||this.updateLayout()},i.prototype.getProp=function(i){switch(i){case t.ObjectPropID.Color:return this.color;case t.ObjectPropID.Playing:return this.playing;case t.ObjectPropID.Frame:return this.frame;case t.ObjectPropID.TimeScale:return this._content.timeScale;default:return e.prototype.getProp.call(this,i)}},i.prototype.setProp=function(i,n){switch(i){case t.ObjectPropID.Color:this.color=n;break;case t.ObjectPropID.Playing:this.playing=n;break;case t.ObjectPropID.Frame:this.frame=n;break;case t.ObjectPropID.TimeScale:this._content.timeScale=n;break;case t.ObjectPropID.DeltaTime:this._content.advance(n);break;default:e.prototype.setProp.call(this,i,n)}},i.prototype.setup_beforeAdd=function(t,i){e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,5),this._url=t.readS(),this._align=t.readByte(),this._verticalAlign=t.readByte(),this._fill=t.readByte(),this._shrinkOnly=t.readBool(),this._autoSize=t.readBool(),this._showErrorSign=t.readBool(),this._content.playing=t.readBool(),this._content.frame=t.readInt(),t.readBool()&&(this.color=t.readColor()),this._content.fillMethod=t.readByte(),0!=this._content.fillMethod&&(this._content.fillOrigin=t.readByte(),this._content.fillClockwise=t.readBool(),this._content.fillAmount=t.readFloat()),this._url&&this.loadContent()},i._errorSignPool=new t.GObjectPool,i}(t.GObject);t.GLoader=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._frame=0,i._playing=!0,i._url="",i._fill=t.LoaderFillType.None,i._align=t.AlignType.Left,i._verticalAlign=t.VertAlignType.Top,i._color=16777215,i}return __extends(i,e),i.prototype.createDisplayObject=function(){var e=new t.UIContainer;e.opaque=!0,this.setDisplayObject(e),this._container=new egret.DisplayObjectContainer,e.addChild(this._container)},i.prototype.dispose=function(){e.prototype.dispose.call(this)},Object.defineProperty(i.prototype,"url",{get:function(){return this._url},set:function(t){this._url!=t&&(this._url=t,this.loadContent(),this.updateGear(7))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"icon",{get:function(){return this._url},set:function(t){this.url=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"align",{get:function(){return this._align},set:function(t){this._align!=t&&(this._align=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"verticalAlign",{get:function(){return this._verticalAlign},set:function(t){this._verticalAlign!=t&&(this._verticalAlign=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fill",{get:function(){return this._fill},set:function(t){this._fill!=t&&(this._fill=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"shrinkOnly",{get:function(){return this._shrinkOnly},set:function(t){this._shrinkOnly!=t&&(this._shrinkOnly=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"autoSize",{get:function(){return this._autoSize},set:function(t){this._autoSize!=t&&(this._autoSize=t,this.updateLayout())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"playing",{get:function(){return this._playing},set:function(t){this._playing!=t&&(this._playing=t,this.updateGear(5),this.onChange())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"frame",{get:function(){return this._frame},set:function(t){this._frame!=t&&(this._frame=t,this.updateGear(5),this.onChange())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"animationName",{get:function(){return this._animationName},set:function(t){this._animationName!=t&&(this._animationName=t,this.onChange())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"skinName",{get:function(){return this._skinName},set:function(t){this._skinName!=t&&(this._skinName=t,this.onChange())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"loop",{get:function(){return this._loop},set:function(t){this._loop!=t&&(this._loop=t,this.onChange())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"color",{get:function(){return this._color},set:function(t){this._color!=t&&(this._color=t,this.updateGear(4),this._content&&(this._content.tint=t))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"content",{get:function(){},enumerable:!0,configurable:!0}),i.prototype.loadContent=function(){this.clearContent(),this._url&&(t.ToolSet.startsWith(this._url,"ui://")?this.loadFromPackage(this._url):this.loadExternal())},i.prototype.loadFromPackage=function(e){this._contentItem=t.UIPackage.getItemByURL(e),this._contentItem&&(this._contentItem=this._contentItem.getBranch(),this.sourceWidth=this._contentItem.width,this.sourceHeight=this._contentItem.height,this._contentItem=this._contentItem.getHighResolution(),this._autoSize&&this.setSize(this.sourceWidth,this.sourceHeight),this._contentItem.type!=t.PackageItemType.Spine&&this._contentItem.type!=t.PackageItemType.DragonBones||this._contentItem.owner.getItemAssetAsync(this._contentItem,this.onLoaded.bind(this)))},i.prototype.onLoaded=function(e,i){this._contentItem==i&&(e&&console.warn(e),this._contentItem.asset&&this._contentItem.type==t.PackageItemType.DragonBones&&this.setDragonBones(this._contentItem.armatureName,this._contentItem.asset.name,this._contentItem.atlasAsset.name,this._skinName,this._contentItem.skeletonAnchor))},i.prototype.setDragonBones=function(t,e,i,n,o){this.url=null;var r=dragonBones.EgretFactory.factory;this._content=r.buildArmatureDisplay(t,e,i,n),this._container.addChild(this._content),this._content.x=o.x,this._content.y=o.y,this._content.tint=this._color,this.onChangeDragonBones(),this.updateLayout()},i.prototype.onChange=function(){this.onChangeDragonBones()},i.prototype.onChangeDragonBones=function(){this._content instanceof dragonBones.EgretArmatureDisplay&&(this._animationName?this._playing?this._content.animation.play(this._animationName,this._loop?0:1):this._content.animation.gotoAndStopByFrame(this._animationName,this._frame):this._content.animation.reset())},i.prototype.loadExternal=function(){},i.prototype.updateLayout=function(){var e=this.sourceWidth,i=this.sourceHeight;if(this._autoSize&&(this._updatingLayout=!0,0==e&&(e=50),0==i&&(i=30),this.setSize(e,i),this._updatingLayout=!1,e==this._width&&i==this._height))return this._container.scaleX=this._container.scaleY=1,void(this._container.x=this._container.y=0);var n,o,r=1,s=1;this._fill!=t.LoaderFillType.None&&(r=this.width/this.sourceWidth,s=this.height/this.sourceHeight,1==r&&1==s||(this._fill==t.LoaderFillType.ScaleMatchHeight?r=s:this._fill==t.LoaderFillType.ScaleMatchWidth?s=r:this._fill==t.LoaderFillType.Scale?r>s?r=s:s=r:this._fill==t.LoaderFillType.ScaleNoBorder&&(r>s?s=r:r=s),this._shrinkOnly&&(r>1&&(r=1),s>1&&(s=1)),e=this.sourceWidth*r,i=this.sourceHeight*s)),this._container.scaleX=r,this._container.scaleY=s,n=this._align==t.AlignType.Center?Math.floor((this.width-e)/2):this._align==t.AlignType.Right?this.width-e:0,o=this._verticalAlign==t.VertAlignType.Middle?Math.floor((this.height-i)/2):this._verticalAlign==t.VertAlignType.Bottom?this.height-i:0,this._container.x=n,this._container.y=o},i.prototype.clearContent=function(){this._contentItem=null,this._content&&(this._container.removeChild(this._content),"dispose"in this._content&&this._content.dispose(),this._content=null)},i.prototype.handleSizeChanged=function(){e.prototype.handleSizeChanged.call(this),this._updatingLayout||this.updateLayout()},i.prototype.handleGrayedChanged=function(){},i.prototype.getProp=function(i){switch(i){case t.ObjectPropID.Color:return this.color;case t.ObjectPropID.Playing:return this.playing;case t.ObjectPropID.Frame:return this.frame;case t.ObjectPropID.TimeScale:return 1;default:return e.prototype.getProp.call(this,i)}},i.prototype.setProp=function(i,n){switch(i){case t.ObjectPropID.Color:this.color=n;break;case t.ObjectPropID.Playing:this.playing=n;break;case t.ObjectPropID.Frame:this.frame=n;break;case t.ObjectPropID.TimeScale:case t.ObjectPropID.DeltaTime:break;default:e.prototype.setProp.call(this,i,n)}},i.prototype.setup_beforeAdd=function(t,i){e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,5),this._url=t.readS(),this._align=t.readByte(),this._verticalAlign=t.readByte(),this._fill=t.readByte(),this._shrinkOnly=t.readBool(),this._autoSize=t.readBool(),this._animationName=t.readS(),this._skinName=t.readS(),this._playing=t.readBool(),this._frame=t.readInt(),this._loop=t.readBool(),t.readBool()&&(this.color=t.readColor()),this._url&&this.loadContent()},i}(t.GObject);t.GLoader3D=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){return e.call(this)||this}return __extends(i,e),Object.defineProperty(i.prototype,"color",{get:function(){return this._content.color},set:function(t){this._content.color!=t&&(this._content.color=t,this.updateGear(4))},enumerable:!0,configurable:!0}),i.prototype.createDisplayObject=function(){this._content=new t.MovieClip,this._content.touchEnabled=!1,this.setDisplayObject(this._content)},Object.defineProperty(i.prototype,"playing",{get:function(){return this._content.playing},set:function(t){this._content.playing!=t&&(this._content.playing=t,this.updateGear(5))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"frame",{get:function(){return this._content.frame},set:function(t){this._content.frame!=t&&(this._content.frame=t,this.updateGear(5))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"timeScale",{get:function(){return this._content.timeScale},set:function(t){this._content.timeScale=t},enumerable:!0,configurable:!0}),i.prototype.rewind=function(){this._content.rewind()},i.prototype.syncStatus=function(t){this._content.syncStatus(t._content)},i.prototype.advance=function(t){this._content.advance(t)},i.prototype.setPlaySettings=function(t,e,i,n,o,r){this._content.setPlaySettings(t,e,i,n,o,r)},i.prototype.getProp=function(i){switch(i){case t.ObjectPropID.Color:return this.color;case t.ObjectPropID.Playing:return this.playing;case t.ObjectPropID.Frame:return this.frame;case t.ObjectPropID.TimeScale:return this.timeScale;default:return e.prototype.getProp.call(this,i)}},i.prototype.setProp=function(i,n){switch(i){case t.ObjectPropID.Color:this.color=n;break;case t.ObjectPropID.Playing:this.playing=n;break;case t.ObjectPropID.Frame:this.frame=n;break;case t.ObjectPropID.TimeScale:this.timeScale=n;break;case t.ObjectPropID.DeltaTime:this.advance(n);break;default:e.prototype.setProp.call(this,i,n)}},i.prototype.constructFromResource=function(){var t=this.packageItem.getBranch();this.sourceWidth=t.width,this.sourceHeight=t.height,this.initWidth=this.sourceWidth,this.initHeight=this.sourceHeight,this.setSize(this.sourceWidth,this.sourceHeight),(t=t.getHighResolution()).load(),this._content.interval=t.interval,this._content.swing=t.swing,this._content.repeatDelay=t.repeatDelay,this._content.frames=t.frames,this._content.smoothing=t.smoothing},i.prototype.setup_beforeAdd=function(t,i){e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,5),t.readBool()&&(this.color=t.readColor()),t.readByte(),this._content.frame=t.readInt(),this._content.playing=t.readBool()},i}(t.GObject);t.GMovieClip=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._min=0,i._max=0,i._value=0,i._barMaxWidth=0,i._barMaxHeight=0,i._barMaxWidthDelta=0,i._barMaxHeightDelta=0,i._barStartX=0,i._barStartY=0,i._titleType=t.ProgressTitleType.Percent,i._value=50,i._max=100,i}return __extends(i,e),Object.defineProperty(i.prototype,"titleType",{get:function(){return this._titleType},set:function(t){this._titleType!=t&&(this._titleType=t,this.update(this._value))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"min",{get:function(){return this._min},set:function(t){this._min!=t&&(this._min=t,this.update(this._value))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"max",{get:function(){return this._max},set:function(t){this._max!=t&&(this._max=t,this.update(this._value))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"value",{get:function(){return this._value},set:function(e){this._value!=e&&(t.GTween.kill(this,!1,this.update),this._value=e,this.update(e))},enumerable:!0,configurable:!0}),i.prototype.tweenValue=function(e,i){var n,o=t.GTween.getTween(this,this.update);return o?(n=o.value.x,o.kill()):n=this._value,this._value=e,t.GTween.to(n,this._value,i).setTarget(this,this.update).setEase(t.EaseType.Linear)},i.prototype.update=function(e){var i=t.ToolSet.clamp01((e-this._min)/(this._max-this._min));if(this._titleObject)switch(this._titleType){case t.ProgressTitleType.Percent:this._titleObject.text=Math.floor(100*i)+"%";break;case t.ProgressTitleType.ValueAndMax:this._titleObject.text=Math.floor(e)+"/"+Math.floor(this._max);break;case t.ProgressTitleType.Value:this._titleObject.text=""+Math.floor(e);break;case t.ProgressTitleType.Max:this._titleObject.text=""+Math.floor(this._max)}var n=this.width-this._barMaxWidthDelta,o=this.height-this._barMaxHeightDelta;this._reverse?(this._barObjectH&&(this.setFillAmount(this._barObjectH,1-i)||(this._barObjectH.width=Math.round(n*i),this._barObjectH.x=this._barStartX+(n-this._barObjectH.width))),this._barObjectV&&(this.setFillAmount(this._barObjectV,1-i)||(this._barObjectV.height=Math.round(o*i),this._barObjectV.y=this._barStartY+(o-this._barObjectV.height)))):(this._barObjectH&&(this.setFillAmount(this._barObjectH,i)||(this._barObjectH.width=Math.round(n*i))),this._barObjectV&&(this.setFillAmount(this._barObjectV,i)||(this._barObjectV.height=Math.round(o*i)))),this._aniObject&&this._aniObject.setProp(t.ObjectPropID.Frame,Math.floor(100*i))},i.prototype.setFillAmount=function(e,i){return(e instanceof t.GImage||e instanceof t.GLoader)&&e.fillMethod!=t.FillMethod.None&&(e.fillAmount=i,!0)},i.prototype.constructExtension=function(t){t.seek(0,6),this._titleType=t.readByte(),this._reverse=t.readBool(),this._titleObject=this.getChild("title"),this._barObjectH=this.getChild("bar"),this._barObjectV=this.getChild("bar_v"),this._aniObject=this.getChild("ani"),this._barObjectH&&(this._barMaxWidth=this._barObjectH.width,this._barMaxWidthDelta=this.width-this._barMaxWidth,this._barStartX=this._barObjectH.x),this._barObjectV&&(this._barMaxHeight=this._barObjectV.height,this._barMaxHeightDelta=this.height-this._barMaxHeight,this._barStartY=this._barObjectV.y)},i.prototype.handleSizeChanged=function(){e.prototype.handleSizeChanged.call(this),this._barObjectH&&(this._barMaxWidth=this.width-this._barMaxWidthDelta),this._barObjectV&&(this._barMaxHeight=this.height-this._barMaxHeightDelta),this._underConstruct||this.update(this._value)},i.prototype.setup_afterAdd=function(t,i){e.prototype.setup_afterAdd.call(this,t,i),t.seek(i,6)&&t.readByte()==this.packageItem.objectType?(this._value=t.readInt(),this._max=t.readInt(),t.version>=2&&(this._min=t.readInt()),this.update(this._value)):this.update(this._value)},i}(t.GComponent);t.GProgressBar=e}(fgui||(fgui={})),function(t){var e=function(e){function s(){var i=e.call(this)||this;return i._fontSize=0,i._leading=0,i._letterSpacing=0,i._textWidth=0,i._textHeight=0,i._fontSize=12,i._align=t.AlignType.Left,i._verticalAlign=t.VertAlignType.Top,i._text="",i._leading=3,i._color=0,i._autoSize=t.AutoSizeType.Both,i._widthAutoSize=!0,i._heightAutoSize=!0,i}return __extends(s,e),s.prototype.createDisplayObject=function(){this._textField=new egret.TextField,this._textField.touchEnabled=!1,this.setDisplayObject(this._textField)},s.prototype.switchBitmapMode=function(t){t&&this.displayObject==this._textField?(null==this._bitmapContainer&&(this._bitmapContainer=new egret.Sprite),this.switchDisplayObject(this._bitmapContainer)):t||this.displayObject!=this._bitmapContainer||this.switchDisplayObject(this._textField)},s.prototype.dispose=function(){e.prototype.dispose.call(this),this._bitmapFont=null,this._requireRender=!1},Object.defineProperty(s.prototype,"text",{get:function(){return this._text},set:function(t){this._text=t,null==this._text&&(this._text=""),this.updateGear(6),this.parent&&this.parent._underConstruct?this.renderNow():this.render()},enumerable:!0,configurable:!0}),s.prototype.updateTextFieldText=function(){var e=this._text;if(this._templateVars&&(e=this.parseTemplate(e)),this._ubbEnabled){var i=s._htmlParser.parser(t.UBBParser.inst.parse(t.ToolSet.encodeHTML(e)));if(this._underline)for(var n=0;n<i.length;n++){var o=i[n];o.style?o.style.underline=!0:o.style={underline:!0}}this._textField.textFlow=i}else if(this._underline){(i=new Array(1))[0]={text:e,style:{underline:!0}},this._textField.textFlow=i}else this._textField.text=e},Object.defineProperty(s.prototype,"font",{get:function(){return this._font},set:function(t){this._font!=t&&(this._font=t,this.updateTextFormat())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"fontSize",{get:function(){return this._fontSize},set:function(t){t<0||this._fontSize!=t&&(this._fontSize=t,this.updateTextFormat())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"color",{get:function(){return this._color},set:function(t){this._color!=t&&(this._color=t,this.updateGear(4),this.updateTextFormat())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"align",{get:function(){return this._align},set:function(t){this._align!=t&&(this._align=t,this._textField.textAlign=this.getAlignTypeString(this._align),this._bitmapFont&&!this._underConstruct&&this.render())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"verticalAlign",{get:function(){return this._verticalAlign},set:function(t){this._verticalAlign!=t&&(this._verticalAlign=t,this._textField.verticalAlign=this.getVertAlignTypeString(this._verticalAlign),this._bitmapFont&&!this._underConstruct&&this.render())},enumerable:!0,configurable:!0}),s.prototype.getAlignTypeString=function(e){return e==t.AlignType.Left?egret.HorizontalAlign.LEFT:e==t.AlignType.Center?egret.HorizontalAlign.CENTER:egret.HorizontalAlign.RIGHT},s.prototype.getVertAlignTypeString=function(e){return e==t.VertAlignType.Top?egret.VerticalAlign.TOP:e==t.VertAlignType.Middle?egret.VerticalAlign.MIDDLE:egret.VerticalAlign.BOTTOM},Object.defineProperty(s.prototype,"leading",{get:function(){return this._leading},set:function(t){this._leading!=t&&(this._leading=t,this.updateTextFormat())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"letterSpacing",{get:function(){return this._letterSpacing},set:function(t){this._letterSpacing!=t&&(this._letterSpacing=t,this.updateTextFormat())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"underline",{get:function(){return this._underline},set:function(t){this._underline=t},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"bold",{get:function(){return this._textField.bold},set:function(t){this._textField.bold=t},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"italic",{get:function(){return this._textField.italic},set:function(t){this._textField.italic=t},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"singleLine",{get:function(){return!this._textField.multiline},set:function(t){t=!t,this._textField.multiline!=t&&(this._textField.multiline=t,this.render())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"stroke",{get:function(){return this._textField.stroke},set:function(t){this._textField.stroke=t},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"strokeColor",{get:function(){return this._textField.strokeColor},set:function(t){this._textField.strokeColor=t,this.updateGear(4)},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"ubbEnabled",{get:function(){return this._ubbEnabled},set:function(t){this._ubbEnabled!=t&&(this._ubbEnabled=t,this.render())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"autoSize",{get:function(){return this._autoSize},set:function(e){this._autoSize!=e&&(this._autoSize=e,this._widthAutoSize=e==t.AutoSizeType.Both,this._heightAutoSize=e==t.AutoSizeType.Both||e==t.AutoSizeType.Height,this.render())},enumerable:!0,configurable:!0}),Object.defineProperty(s.prototype,"textWidth",{get:function(){return this._requireRender&&this.renderNow(),this._textWidth},enumerable:!0,configurable:!0}),s.prototype.ensureSizeCorrect=function(){this._sizeDirty&&this._requireRender&&this.renderNow()},s.prototype.updateTextFormat=function(){if(this._textField.size=this._fontSize,this._bitmapFont=null,t.ToolSet.startsWith(this._font,"ui://")){var e=t.UIPackage.getItemByURL(this._font);e&&(this._bitmapFont=e.owner.getItemAsset(e))}null==this._bitmapFont&&(this._font?this._textField.fontFamily=this._font:this._textField.fontFamily=t.UIConfig.defaultFont),this.grayed?this._textField.textColor=11184810:this._textField.textColor=this._color,this._textField.lineSpacing=this._leading,this._underConstruct||this.render()},s.prototype.render=function(){this._requireRender||(this._requireRender=!0,egret.callLater(this.__render,this)),this._sizeDirty||!this._widthAutoSize&&!this._heightAutoSize||(this._sizeDirty=!0,this.dispatchEventWith(t.GObject.SIZE_DELAY_CHANGE))},s.prototype.__render=function(){this._requireRender&&this.renderNow()},s.prototype.renderNow=function(t){if(void 0===t&&(t=!0),this._requireRender=!1,this._sizeDirty=!1,this._bitmapFont)this.renderWithBitmapFont(t);else{this.switchBitmapMode(!1),this._textField.width=this._widthAutoSize?this.maxWidth<=0?1e4:this.maxWidth:Math.ceil(this.width),this.updateTextFieldText(),this._textWidth=Math.ceil(this._textField.textWidth),this._textWidth>0&&(this._textWidth+=4),this._textHeight=Math.ceil(this._textField.textHeight),this._textHeight>0&&(this._textHeight+=4);var e,i=0;this._widthAutoSize?(e=this._textWidth,this._textField.width=e):e=this.width,this._heightAutoSize?(i=this._textHeight,this._textField.height!=this._textHeight&&(this._textField.height=this._textHeight)):(i=this.height,this._textHeight>i&&(this._textHeight=i)),t&&(this._updatingSize=!0,this.setSize(e,i),this._updatingSize=!1)}},s.prototype.renderWithBitmapFont=function(e){this.switchBitmapMode(!0),this._bitmapPool||(this._bitmapPool=[]);for(var s=this._bitmapContainer.numChildren,a=0;a<s;a++){var h=this._bitmapContainer.getChildAt(a);this._bitmapPool.push(h)}this._bitmapContainer.removeChildren(),this._lines?function(t){for(var e=t.length,n=0;n<e;n++){var o=t[n];i.push(o)}t.length=0}(this._lines):this._lines=new Array;var l,c=this._letterSpacing,u=this._leading-1,_=this.width-2*o,p=0,d=0,g=0,f=0,y=0,m=0,b=0,v=0,w=0,C="",S=r,x=!this._widthAutoSize&&this._textField.multiline,T=this._bitmapFont.resizable?this._fontSize/this._bitmapFont.size:1,I=this._bitmapFont.tint;this._textWidth=0,this._textHeight=0;var P=this._text;this._templateVars&&(P=this.parseTemplate(P));for(var O=P.length,j=0;j<O;++j){var k=P.charAt(j),B=k.charCodeAt(0);if(10!=B){if(B>=65&&B<=90||B>=97&&B<=122?(0==m&&(b=p),m++):(m>0&&(v=p),m=0),32==B)f=Math.ceil(this._fontSize/2),y=this._fontSize;else{var L=this._bitmapFont.glyphs[k];L?(f=Math.ceil(L.advance*T),y=Math.ceil(L.lineHeight*T)):(f=0,y=0)}if(y>g&&(g=y),y>d&&(d=y),0!=p&&(p+=c),p+=f,!x||p<=_)C+=k;else{if((l=n()).height=d,l.textHeight=g,0==C.length)l.text=k;else if(m>0&&v>0){var A=(C+=k).length-m;l.text=t.ToolSet.trimRight(C.substr(0,A)),l.width=v,C=C.substr(A),p-=b}else l.text=C,l.width=p-(f+c),C=k,p=f,d=y,g=y;l.y=S,S+=l.height+u,l.width>this._textWidth&&(this._textWidth=l.width),m=0,b=0,v=0,this._lines.push(l)}}else C+=k,(l=n()).width=p,0==g&&(0==w&&(w=this._fontSize),0==d&&(d=w),g=d),l.height=d,w=d,l.textHeight=g,l.text=C,l.y=S,S+=l.height+u,l.width>this._textWidth&&(this._textWidth=l.width),this._lines.push(l),C="",p=0,d=0,g=0,m=0,b=0,v=0}C.length>0&&((l=n()).width=p,0==d&&(d=w),0==g&&(g=d),l.height=d,l.textHeight=g,l.text=C,l.y=S,l.width>this._textWidth&&(this._textWidth=l.width),this._lines.push(l)),this._textWidth>0&&(this._textWidth+=2*o),0==this._lines.length?this._textHeight=0:(l=this._lines[this._lines.length-1],this._textHeight=l.y+l.height+r);var z,E=0;if(z=this._widthAutoSize?0==this._textWidth?0:this._textWidth:this.width,E=this._heightAutoSize?0==this._textHeight?0:this._textHeight:this.height,e&&(this._updatingSize=!0,this.setSize(z,E),this._updatingSize=!1),0!=z&&0!=E){var M=o,F=0,R=0;_=this.width-2*o;var D=this._lines.length;for(a=0;a<D;a++){l=this._lines[a],M=o,F=this._align==t.AlignType.Center?(_-l.width)/2:this._align==t.AlignType.Right?_-l.width:0,O=l.text.length;for(var G=0;G<O;G++){var H;if(10!=(B=(k=l.text.charAt(G)).charCodeAt(0)))if(32!=B)if(L=this._bitmapFont.glyphs[k])R=(l.height+l.textHeight)/2-Math.ceil(L.lineHeight*T),this._bitmapPool.length?H=this._bitmapPool.pop():(H=new egret.Bitmap).smoothing=!0,H.x=M+F+Math.ceil(L.x*T),H.y=l.y+R+Math.ceil(L.y*T),H.$backupY=H.y,H.texture=L.texture,H.scaleX=T,H.scaleY=T,H.tint=I?this._color:16777215,this._bitmapContainer.addChild(H),M+=c+Math.ceil(L.advance*T);else M+=c;else M+=c+Math.ceil(this._fontSize/2)}}this.doAlign()}},s.prototype.handleSizeChanged=function(){this._updatingSize||(this._bitmapFont?this._widthAutoSize?this.doAlign():this.render():this._underConstruct?(this._textField.width=this.width,this._textField.height=this.height):this._widthAutoSize||(this._heightAutoSize?this._textField.width=this.width:(this._textField.width=this.width,this._textField.height=this.height)))},s.prototype.parseTemplate=function(t){for(var e,i,n,o,r=0,s="";-1!=(e=t.indexOf("{",r));)if(e>0&&92==t.charCodeAt(e-1))s+=t.substring(r,e-1),s+="{",r=e+1;else{if(s+=t.substring(r,e),r=e,-1==(e=t.indexOf("}",r)))break;e!=r+1?(-1!=(i=(n=t.substring(r+1,e)).indexOf("="))?s+=null==(o=this._templateVars[n.substring(0,i)])?n.substring(i+1):o:null!=(o=this._templateVars[n])&&(s+=o),r=e+1):(s+=t.substr(r,2),r=e+1)}return r<t.length&&(s+=t.substr(r)),s},Object.defineProperty(s.prototype,"templateVars",{get:function(){return this._templateVars},set:function(t){(this._templateVars||t)&&(this._templateVars=t,this.flushVars())},enumerable:!0,configurable:!0}),s.prototype.setVar=function(t,e){return this._templateVars||(this._templateVars={}),this._templateVars[t]=e,this},s.prototype.flushVars=function(){this.render()},s.prototype.handleGrayedChanged=function(){e.prototype.handleGrayedChanged.call(this),this.updateTextFormat()},s.prototype.doAlign=function(){var e;if(this._verticalAlign==t.VertAlignType.Top||0==this._textHeight)e=r;else{var i=this.height-this._textHeight;i<0&&(i=0),e=this._verticalAlign==t.VertAlignType.Middle?Math.floor(i/2):Math.floor(i)}for(var n=this._bitmapContainer.numChildren,o=0;o<n;o++){var s=this._bitmapContainer.getChildAt(o);s.y=s.$backupY+e}},s.prototype.getProp=function(i){switch(i){case t.ObjectPropID.Color:return this.color;case t.ObjectPropID.OutlineColor:return this.strokeColor;case t.ObjectPropID.FontSize:return this.fontSize;default:return e.prototype.getProp.call(this,i)}},s.prototype.setProp=function(i,n){switch(i){case t.ObjectPropID.Color:this.color=n;break;case t.ObjectPropID.OutlineColor:this.strokeColor=n;break;case t.ObjectPropID.FontSize:this.fontSize=n;break;default:e.prototype.setProp.call(this,i,n)}},s.prototype.setup_beforeAdd=function(i,n){e.prototype.setup_beforeAdd.call(this,i,n),i.seek(n,5),this._font=i.readS(),this._fontSize=i.readShort(),this._color=i.readColor(),this.align=i.readByte(),this.verticalAlign=i.readByte(),this._leading=i.readShort(),this._letterSpacing=i.readShort(),this._ubbEnabled=i.readBool(),this._autoSize=i.readByte(),this._widthAutoSize=this._autoSize==t.AutoSizeType.Both,this._heightAutoSize=this._autoSize==t.AutoSizeType.Both||this._autoSize==t.AutoSizeType.Height,this._underline=i.readBool(),this._textField.italic=i.readBool(),this._textField.bold=i.readBool(),this._textField.multiline=!i.readBool(),i.readBool()&&(this._textField.strokeColor=i.readColor(),this.stroke=i.readFloat()+1),i.readBool()&&i.skip(12),i.readBool()&&(this._templateVars={})},s.prototype.setup_afterAdd=function(t,i){e.prototype.setup_afterAdd.call(this,t,i),this.updateTextFormat(),t.seek(i,6);var n=t.readS();null!=n&&(this.text=n),this._sizeDirty=!1},s._htmlParser=new egret.HtmlTextParser,s}(t.GObject);t.GTextField=e;var i=[];function n(){if(i.length){var t=i.pop();return t.width=0,t.height=0,t.textHeight=0,t.text=null,t.y=0,t}return{width:0,height:0,textHeight:0,text:null,y:0}}var o=2,r=2}(fgui||(fgui={})),function(t){var e=function(e){function i(){var t=e.call(this)||this;return t._textField.touchEnabled=!0,t}return __extends(i,e),i.prototype.updateTextFieldText=function(){var e,i=this._text;if(this._templateVars&&(i=this.parseTemplate(i)),e=this._ubbEnabled?t.GTextField._htmlParser.parser(t.UBBParser.inst.parse(i)):t.GTextField._htmlParser.parser(i),this._underline)for(var n=0;n<e.length;n++){var o=e[n];o.style?o.style.underline=!0:o.style={underline:!0}}this._textField.textFlow=e},i}(t.GTextField);t.GRichTextField=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var t=e.call(this)||this;return null==i._inst&&(i._inst=t),t.opaque=!1,t._volumeScale=1,t._popupStack=new Array,t._justClosedPopups=new Array,t.displayObject.addEventListener(egret.Event.ADDED_TO_STAGE,t.__addedToStage,t),t}return __extends(i,e),Object.defineProperty(i,"inst",{get:function(){return null==i._inst&&new i,i._inst},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"nativeStage",{get:function(){return this._nativeStage},enumerable:!0,configurable:!0}),i.prototype.showWindow=function(t){this.addChild(t),t.requestFocus(),t.x>this.width?t.x=this.width-t.width:t.x+t.width<0&&(t.x=0),t.y>this.height?t.y=this.height-t.height:t.y+t.height<0&&(t.y=0),this.adjustModalLayer()},i.prototype.hideWindow=function(t){t.hide()},i.prototype.hideWindowImmediately=function(t){t.parent==this&&this.removeChild(t),this.adjustModalLayer()},i.prototype.bringToFront=function(e){var i,n=this.numChildren;for(i=null==this._modalLayer.parent||e.modal?n-1:this.getChildIndex(this._modalLayer)-1;i>=0;i--){var o=this.getChildAt(i);if(o==e)return;if(o instanceof t.Window)break}i>=0&&this.setChildIndex(e,i)},i.prototype.showModalWait=function(e){null!=t.UIConfig.globalModalWaiting&&(null==this._modalWaitPane&&(this._modalWaitPane=t.UIPackage.createObjectFromURL(t.UIConfig.globalModalWaiting)),this._modalWaitPane.setSize(this.width,this.height),this._modalWaitPane.addRelation(this,t.RelationType.Size),this.addChild(this._modalWaitPane),this._modalWaitPane.text=e)},i.prototype.closeModalWait=function(){null!=this._modalWaitPane&&null!=this._modalWaitPane.parent&&this.removeChild(this._modalWaitPane)},i.prototype.closeAllExceptModals=function(){for(var e=this._children.slice(),i=e.length,n=0;n<i;n++){var o=e[n];o instanceof t.Window&&!o.modal&&o.hide()}},i.prototype.closeAllWindows=function(){for(var e=this._children.slice(),i=e.length,n=0;n<i;n++){var o=e[n];o instanceof t.Window&&o.hide()}},i.prototype.getTopWindow=function(){for(var e=this.numChildren-1;e>=0;e--){var i=this.getChildAt(e);if(i instanceof t.Window)return i}return null},Object.defineProperty(i.prototype,"modalLayer",{get:function(){return this._modalLayer},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"hasModalWindow",{get:function(){return null!=this._modalLayer.parent},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"modalWaiting",{get:function(){return this._modalWaitPane&&this._modalWaitPane.inContainer},enumerable:!0,configurable:!0}),i.prototype.showPopup=function(e,n,o){if(this._popupStack.length>0){var r=this._popupStack.indexOf(e);if(-1!=r)for(var s=this._popupStack.length-1;s>=r;s--)this.removeChild(this._popupStack.pop())}if(this._popupStack.push(e),n)for(var a=n;a;){if(a.parent==this){e.sortingOrder<a.sortingOrder&&(e.sortingOrder=a.sortingOrder);break}a=a.parent}var h;this.addChild(e),this.adjustModalLayer();var l,c,u=0,_=0;n?(h=n.localToRoot(),u=n.width,_=n.height):h=this.globalToLocal(i.mouseX,i.mouseY),(l=h.x)+e.width>this.width&&(l=l+u-e.width),c=h.y+_,((void 0===o||o===t.PopupDirection.Auto)&&h.y+e.height>this.height||!1===o||o===t.PopupDirection.Up)&&(c=h.y-e.height-1)<0&&(c=0,l+=u/2),e.x=l,e.y=c},i.prototype.togglePopup=function(t,e,i){-1==this._justClosedPopups.indexOf(t)&&this.showPopup(t,e,i)},i.prototype.hidePopup=function(t){if(t){var e=this._popupStack.indexOf(t);if(-1!=e)for(var i=this._popupStack.length-1;i>=e;i--)this.closePopup(this._popupStack.pop())}else{for(i=this._popupStack.length-1;i>=0;i--)this.closePopup(this._popupStack[i]);this._popupStack.length=0}},Object.defineProperty(i.prototype,"hasAnyPopup",{get:function(){return 0!=this._popupStack.length},enumerable:!0,configurable:!0}),i.prototype.closePopup=function(e){e.parent&&(e instanceof t.Window?e.hide():this.removeChild(e))},i.prototype.showTooltips=function(e){if(null==this._defaultTooltipWin){var i=t.UIConfig.tooltipsWin;if(!i)return void console.error("UIConfig.tooltipsWin not defined");this._defaultTooltipWin=t.UIPackage.createObjectFromURL(i)}this._defaultTooltipWin.text=e,this.showTooltipsWin(this._defaultTooltipWin)},i.prototype.showTooltipsWin=function(t,e){this.hideTooltips(),this._tooltipWin=t;var n=0,o=0;e?(n=e.x,o=e.y):(n=i.mouseX+10,o=i.mouseY+20);var r=this.globalToLocal(n,o);n=r.x,o=r.y,n+this._tooltipWin.width>this.width&&(n=n-this._tooltipWin.width-1)<0&&(n=10),o+this._tooltipWin.height>this.height&&(o=o-this._tooltipWin.height-1,n-this._tooltipWin.width-1>0&&(n=n-this._tooltipWin.width-1),o<0&&(o=10)),this._tooltipWin.x=n,this._tooltipWin.y=o,this.addChild(this._tooltipWin)},i.prototype.hideTooltips=function(){this._tooltipWin&&(this._tooltipWin.parent&&this.removeChild(this._tooltipWin),this._tooltipWin=null)},i.prototype.getObjectUnderPoint=function(e,i){var n=this._nativeStage.$hitTest(e,i);return n?t.ToolSet.displayObjectToGObject(n):null},Object.defineProperty(i.prototype,"focus",{get:function(){return null},set:function(t){},enumerable:!0,configurable:!0}),i.prototype.setFocus=function(t){},Object.defineProperty(i.prototype,"volumeScale",{get:function(){return this._volumeScale},set:function(t){this._volumeScale=t},enumerable:!0,configurable:!0}),i.prototype.playOneShotSound=function(t,e){e=e||1;var i=this._volumeScale*e;t.play(0,1).volume=i},i.prototype.adjustModalLayer=function(){var e=this.numChildren;this._modalWaitPane&&this._modalWaitPane.parent&&this.setChildIndex(this._modalWaitPane,e-1);for(var i=e-1;i>=0;i--){var n=this.getChildAt(i);if(n instanceof t.Window&&n.modal)return void(null==this._modalLayer.parent?this.addChildAt(this._modalLayer,i):this.setChildIndexBefore(this._modalLayer,i))}this._modalLayer.parent&&this.removeChild(this._modalLayer)},i.prototype.__addedToStage=function(e){this.displayObject.removeEventListener(egret.Event.ADDED_TO_STAGE,this.__addedToStage,this),this._nativeStage=this.displayObject.stage,this._nativeStage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__stageMouseDownCapture,this,!0),this._nativeStage.addEventListener(egret.TouchEvent.TOUCH_END,this.__stageMouseUpCapture,this,!0),this._nativeStage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.__stageMouseMoveCapture,this,!0),this._modalLayer=new t.GGraph,this._modalLayer.setSize(this.width,this.height),this._modalLayer.drawRect(0,0,0,t.UIConfig.modalLayerColor,t.UIConfig.modalLayerAlpha),this._modalLayer.addRelation(this,t.RelationType.Size),this.displayObject.stage.addEventListener(egret.Event.RESIZE,this.__winResize,this),this.__winResize(null)},i.prototype.__stageMouseDownCapture=function(t){if(i.mouseX=t.stageX,i.mouseY=t.stageY,i.touchDown=!0,this._tooltipWin&&this.hideTooltips(),this._justClosedPopups.length=0,this._popupStack.length>0){for(var e=t.target;e!=this.displayObject.stage&&e;){if(e.$owner){var n=this._popupStack.indexOf(e.$owner);if(-1!=n){for(var o=this._popupStack.length-1;o>n;o--){var r=this._popupStack.pop();this.closePopup(r),this._justClosedPopups.push(r)}return}}e=e.parent}for(o=this._popupStack.length-1;o>=0;o--)r=this._popupStack[o],this.closePopup(r),this._justClosedPopups.push(r);this._popupStack.length=0}},i.prototype.__stageMouseMoveCapture=function(t){i.mouseX=t.stageX,i.mouseY=t.stageY},i.prototype.__stageMouseUpCapture=function(t){i.touchDown=!1},i.prototype.__winResize=function(t){this.setSize(this._nativeStage.stageWidth,this._nativeStage.stageHeight)},i.prototype.updateContentScaleLevel=function(){i.contentScaleLevel=0},i.contentScaleLevel=0,i.contentScaleFactor=1,i}(t.GComponent);t.GRoot=e}(fgui||(fgui={})),function(t){var e=function(t){function e(){var e=t.call(this)||this;return e._dragOffset=new egret.Point,e._scrollPerc=0,e}return __extends(e,t),e.prototype.setScrollPane=function(t,e){this._target=t,this._vertical=e},e.prototype.setDisplayPerc=function(t){this._vertical?(this._fixedGripSize||(this._grip.height=Math.floor(t*this._bar.height)),this._grip.y=this._bar.y+(this._bar.height-this._grip.height)*this._scrollPerc):(this._fixedGripSize||(this._grip.width=Math.floor(t*this._bar.width)),this._grip.x=this._bar.x+(this._bar.width-this._grip.width)*this._scrollPerc),this._grip.visible=0!=t&&1!=t},e.prototype.setScrollPerc=function(t){this._scrollPerc=t,this._vertical?this._grip.y=this._bar.y+(this._bar.height-this._grip.height)*this._scrollPerc:this._grip.x=this._bar.x+(this._bar.width-this._grip.width)*this._scrollPerc},Object.defineProperty(e.prototype,"minSize",{get:function(){return this._vertical?(this._arrowButton1?this._arrowButton1.height:0)+(this._arrowButton2?this._arrowButton2.height:0):(this._arrowButton1?this._arrowButton1.width:0)+(this._arrowButton2?this._arrowButton2.width:0)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"gripDragging",{get:function(){return this._gripDragging},enumerable:!0,configurable:!0}),e.prototype.constructExtension=function(t){t.seek(0,6),this._fixedGripSize=t.readBool(),this._grip=this.getChild("grip"),this._grip?(this._bar=this.getChild("bar"),this._bar?(this._arrowButton1=this.getChild("arrow1"),this._arrowButton2=this.getChild("arrow2"),this._grip.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__gripMouseDown,this),this._arrowButton1&&this._arrowButton1.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__arrowButton1Click,this),this._arrowButton2&&this._arrowButton2.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__arrowButton2Click,this),this.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__barMouseDown,this)):console.error("需要定义bar")):console.error("需要定义grip")},e.prototype.__gripMouseDown=function(t){this._gripDragging=!0,this._target.updateScrollBarVisible(),t.stopPropagation(),this.globalToLocal(t.stageX,t.stageY,this._dragOffset),this._dragOffset.x-=this._grip.x,this._dragOffset.y-=this._grip.y,this._grip.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.__gripMouseMove,this),this._grip.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_END,this.__gripMouseUp,this)},e.prototype.__gripMouseMove=function(t){if(this.onStage){var e=this.globalToLocal(t.stageX,t.stageY,i);if(this._vertical){var n=e.y-this._dragOffset.y;this._target.setPercY((n-this._bar.y)/(this._bar.height-this._grip.height),!1)}else{var o=e.x-this._dragOffset.x;this._target.setPercX((o-this._bar.x)/(this._bar.width-this._grip.width),!1)}}},e.prototype.__gripMouseUp=function(t){var e=t.currentTarget;e.removeEventListener(egret.TouchEvent.TOUCH_MOVE,this.__gripMouseMove,this),e.removeEventListener(egret.TouchEvent.TOUCH_END,this.__gripMouseUp,this),this.onStage||(this._gripDragging=!1,this._target.updateScrollBarVisible())},e.prototype.__arrowButton1Click=function(t){t.stopPropagation(),this._vertical?this._target.scrollUp():this._target.scrollLeft()},e.prototype.__arrowButton2Click=function(t){t.stopPropagation(),this._vertical?this._target.scrollDown():this._target.scrollRight()},e.prototype.__barMouseDown=function(t){var e=this._grip.globalToLocal(t.stageX,t.stageY,i);this._vertical?e.y<0?this._target.scrollUp(4):this._target.scrollDown(4):e.x<0?this._target.scrollLeft(4):this._target.scrollRight(4)},e}(t.GComponent);t.GScrollBar=e;var i=new egret.Point}(fgui||(fgui={})),function(t){var e=function(e){function n(){var i=e.call(this)||this;return i._min=0,i._max=0,i._value=0,i._barMaxWidth=0,i._barMaxHeight=0,i._barMaxWidthDelta=0,i._barMaxHeightDelta=0,i._clickPercent=0,i._barStartX=0,i._barStartY=0,i.changeOnClick=!0,i.canDrag=!0,i._titleType=t.ProgressTitleType.Percent,i._value=50,i._max=100,i._clickPos=new egret.Point,i}return __extends(n,e),Object.defineProperty(n.prototype,"titleType",{get:function(){return this._titleType},set:function(t){this._titleType=t},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"wholeNumbers",{get:function(){return this._wholeNumbers},set:function(t){this._wholeNumbers!=t&&(this._wholeNumbers=t,this.update())},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"min",{get:function(){return this._min},set:function(t){this._min!=t&&(this._min=t,this.update())},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"max",{get:function(){return this._max},set:function(t){this._max!=t&&(this._max=t,this.update())},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"value",{get:function(){return this._value},set:function(t){this._value!=t&&(this._value=t,this.update())},enumerable:!0,configurable:!0}),n.prototype.update=function(){this.updateWithPercent((this._value-this._min)/(this._max-this._min))},n.prototype.updateWithPercent=function(e,i){if(e=t.ToolSet.clamp01(e),i){var n=t.ToolSet.clamp(this._min+(this._max-this._min)*e,this._min,this._max);this._wholeNumbers&&(n=Math.round(n),e=t.ToolSet.clamp01((n-this._min)/(this._max-this._min))),n!=this._value&&(this._value=n,this.dispatchEvent(new t.StateChangeEvent(t.StateChangeEvent.CHANGED)))}if(this._titleObject)switch(this._titleType){case t.ProgressTitleType.Percent:this._titleObject.text=Math.floor(100*e)+"%";break;case t.ProgressTitleType.ValueAndMax:this._titleObject.text=this._value+"/"+this._max;break;case t.ProgressTitleType.Value:this._titleObject.text=""+this._value;break;case t.ProgressTitleType.Max:this._titleObject.text=""+this._max}var o=this.width-this._barMaxWidthDelta,r=this.height-this._barMaxHeightDelta;this._reverse?(this._barObjectH&&(this._barObjectH.width=Math.round(o*e),this._barObjectH.x=this._barStartX+(o-this._barObjectH.width)),this._barObjectV&&(this._barObjectV.height=Math.round(r*e),this._barObjectV.y=this._barStartY+(r-this._barObjectV.height))):(this._barObjectH&&(this._barObjectH.width=Math.round(o*e)),this._barObjectV&&(this._barObjectV.height=Math.round(r*e)))},n.prototype.constructExtension=function(t){t.seek(0,6),this._titleType=t.readByte(),this._reverse=t.readBool(),t.version>=2&&(this._wholeNumbers=t.readBool(),this.changeOnClick=t.readBool()),this._titleObject=this.getChild("title"),this._barObjectH=this.getChild("bar"),this._barObjectV=this.getChild("bar_v"),this._gripObject=this.getChild("grip"),this._barObjectH&&(this._barMaxWidth=this._barObjectH.width,this._barMaxWidthDelta=this.width-this._barMaxWidth,this._barStartX=this._barObjectH.x),this._barObjectV&&(this._barMaxHeight=this._barObjectV.height,this._barMaxHeightDelta=this.height-this._barMaxHeight,this._barStartY=this._barObjectV.y),this._gripObject&&this._gripObject.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__gripMouseDown,this),this.displayObject.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__barMouseDown,this)},n.prototype.handleSizeChanged=function(){e.prototype.handleSizeChanged.call(this),this._barObjectH&&(this._barMaxWidth=this.width-this._barMaxWidthDelta),this._barObjectV&&(this._barMaxHeight=this.height-this._barMaxHeightDelta),this._underConstruct||this.update()},n.prototype.setup_afterAdd=function(t,i){e.prototype.setup_afterAdd.call(this,t,i),t.seek(i,6)&&t.readByte()==this.packageItem.objectType?(this._value=t.readInt(),this._max=t.readInt(),t.version>=2&&(this._min=t.readInt()),this.update()):this.update()},n.prototype.__gripMouseDown=function(e){this.canDrag=!0,e.stopPropagation(),this._clickPos=this.globalToLocal(e.stageX,e.stageY),this._clickPercent=t.ToolSet.clamp01((this._value-this._min)/(this._max-this._min)),this._gripObject.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.__gripMouseMove,this),this._gripObject.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_END,this.__gripMouseUp,this)},n.prototype.__gripMouseMove=function(t){if(this.canDrag){var e,n=this.globalToLocal(t.stageX,t.stageY,i),o=n.x-this._clickPos.x,r=n.y-this._clickPos.y;this._reverse&&(o=-o,r=-r),e=this._barObjectH?this._clickPercent+o/this._barMaxWidth:this._clickPercent+r/this._barMaxHeight,this.updateWithPercent(e,!0)}},n.prototype.__gripMouseUp=function(t){t.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_MOVE,this.__gripMouseMove,this),t.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_END,this.__gripMouseUp,this)},n.prototype.__barMouseDown=function(e){if(this.changeOnClick){var n,o=this._gripObject.globalToLocal(e.stageX,e.stageY,i),r=t.ToolSet.clamp01((this._value-this._min)/(this._max-this._min));this._barObjectH&&(n=o.x/this._barMaxWidth),this._barObjectV&&(n=o.y/this._barMaxHeight),this._reverse?r-=n:r+=n,this.updateWithPercent(r,!0)}},n}(t.GComponent);t.GSlider=e;var i=new egret.Point}(fgui||(fgui={})),function(t){var e=function(e){function i(){var t=e.call(this)||this;return t._widthAutoSize=!1,t._heightAutoSize=!1,t.displayObject.touchChildren=!0,t._textField.type=egret.TextFieldType.INPUT,t._textField.addEventListener(egret.Event.CHANGE,t.__textChanged,t),t._textField.addEventListener(egret.FocusEvent.FOCUS_IN,t.__focusIn,t),t._textField.addEventListener(egret.FocusEvent.FOCUS_OUT,t.__focusOut,t),t}return __extends(i,e),i.prototype.dispose=function(){e.prototype.dispose.call(this)},Object.defineProperty(i.prototype,"editable",{get:function(){return this._textField.type==egret.TextFieldType.INPUT},set:function(t){this._textField.type=t?egret.TextFieldType.INPUT:egret.TextFieldType.DYNAMIC},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"maxLength",{get:function(){return this._textField.maxChars},set:function(t){this._textField.maxChars=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"promptText",{get:function(){return this._promptText},set:function(t){this._promptText=t,this.updateTextFieldText()},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"restrict",{get:function(){return this._textField.restrict},set:function(t){this._textField.restrict=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"password",{get:function(){return this._password},set:function(t){this._password!=t&&(this._password=t,this._textField.displayAsPassword=this._password,this._textField.inputType=t?egret.TextFieldInputType.PASSWORD:egret.TextFieldInputType.TEXT,this.render())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"verticalAlign",{get:function(){return this._verticalAlign},set:function(t){this._verticalAlign!=t&&(this._verticalAlign=t,this.updateVertAlign())},enumerable:!0,configurable:!0}),i.prototype.updateVertAlign=function(){switch(this._verticalAlign){case t.VertAlignType.Top:this._textField.verticalAlign=egret.VerticalAlign.TOP;break;case t.VertAlignType.Middle:this._textField.verticalAlign=egret.VerticalAlign.MIDDLE;break;case t.VertAlignType.Bottom:this._textField.verticalAlign=egret.VerticalAlign.BOTTOM}},i.prototype.updateTextFieldText=function(){!this._text&&this._promptText?(this._textField.displayAsPassword=!1,this._textField.textFlow=(new egret.HtmlTextParser).parser(t.UBBParser.inst.parse(this._promptText))):(this._textField.displayAsPassword=this._password,this._ubbEnabled?this._textField.textFlow=(new egret.HtmlTextParser).parser(t.UBBParser.inst.parse(t.ToolSet.encodeHTML(this._text))):this._textField.text=this._text)},i.prototype.handleSizeChanged=function(){this._updatingSize||(this._textField.width=Math.ceil(this.width),this._textField.height=Math.ceil(this.height))},i.prototype.setup_beforeAdd=function(t,i){e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,4);var n=t.readS();null!=n&&(this._promptText=n),null!=(n=t.readS())&&(this._textField.restrict=n);var o=t.readInt();0!=o&&(this._textField.maxChars=o),o=t.readInt(),t.readBool()&&(this.password=!0),this.updateVertAlign()},i.prototype.setup_afterAdd=function(i,n){e.prototype.setup_afterAdd.call(this,i,n),!this._text&&this._promptText&&(this._textField.displayAsPassword=!1,this._textField.textFlow=(new egret.HtmlTextParser).parser(t.UBBParser.inst.parse(t.ToolSet.encodeHTML(this._promptText))))},i.prototype.__textChanged=function(t){this._text=this._textField.text},i.prototype.__focusIn=function(t){!this._text&&this._promptText&&(this._textField.displayAsPassword=this._password,this._textField.text="")},i.prototype.__focusOut=function(e){this._text=this._textField.text,!this._text&&this._promptText&&(this._textField.displayAsPassword=!1,this._textField.textFlow=(new egret.HtmlTextParser).parser(t.UBBParser.inst.parse(t.ToolSet.encodeHTML(this._promptText))))},i}(t.GTextField);t.GTextInput=e}(fgui||(fgui={})),function(t){var e=function(e){function n(){var i=e.call(this)||this;return i._indent=15,i._rootNode=new t.GTreeNode(!0),i._rootNode._setTree(i),i._rootNode.expanded=!0,i}return __extends(n,e),Object.defineProperty(n.prototype,"rootNode",{get:function(){return this._rootNode},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"indent",{get:function(){return this._indent},set:function(t){this._indent=t},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"clickToExpand",{get:function(){return this._clickToExpand},set:function(t){this._clickToExpand=t},enumerable:!0,configurable:!0}),n.prototype.getSelectedNode=function(){return-1!=this.selectedIndex?this.getChildAt(this.selectedIndex)._treeNode:null},n.prototype.getSelectedNodes=function(t){t||(t=new Array),i.length=0,e.prototype.getSelection.call(this,i);for(var n=i.length,o=new Array,r=0;r<n;r++){var s=this.getChildAt(i[r])._treeNode;o.push(s)}return o},n.prototype.selectNode=function(t,e){for(var i=t.parent;i&&i!=this._rootNode;)i.expanded=!0,i=i.parent;t._cell&&this.addSelection(this.getChildIndex(t._cell),e)},n.prototype.unselectNode=function(t){t._cell&&this.removeSelection(this.getChildIndex(t._cell))},n.prototype.expandAll=function(t){t||(t=this._rootNode),t.expanded=!0;for(var e=t.numChildren,i=0;i<e;i++){var n=t.getChildAt(i);n.isFolder&&this.expandAll(n)}},n.prototype.collapseAll=function(t){t||(t=this._rootNode),t!=this._rootNode&&(t.expanded=!1);for(var e=t.numChildren,i=0;i<e;i++){var n=t.getChildAt(i);n.isFolder&&this.collapseAll(n)}},n.prototype.createCell=function(e){var i=this.getFromPool(e._resURL?e._resURL:this.defaultItem);if(!(i instanceof t.GComponent))throw new Error("cannot create tree node object.");i._treeNode=e,e._cell=i;var n,o=i.getChild("indent");null!=o&&(o.width=(e.level-1)*this._indent),(n=i.getController("expanded"))&&(n.addEventListener(t.StateChangeEvent.CHANGED,this.__expandedStateChanged,this),n.selectedIndex=e.expanded?1:0),(n=i.getController("leaf"))&&(n.selectedIndex=e.isFolder?0:1),e.isFolder&&i.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.__cellMouseDown,this),this.treeNodeRender&&this.treeNodeRender.call(this.callbackThisObj,e,i)},n.prototype._afterInserted=function(t){t._cell||this.createCell(t);var e=this.getInsertIndexForNode(t);this.addChildAt(t._cell,e),this.treeNodeRender&&this.treeNodeRender.call(this.callbackThisObj,t,t._cell),t.isFolder&&t.expanded&&this.checkChildren(t,e)},n.prototype.getInsertIndexForNode=function(t){var e=t.getPrevSibling();null==e&&(e=t.parent);for(var i=this.getChildIndex(e._cell)+1,n=t.level,o=this.numChildren,r=i;r<o;r++){if(this.getChildAt(r)._treeNode.level<=n)break;i++}return i},n.prototype._afterRemoved=function(t){this.removeNode(t)},n.prototype._afterExpanded=function(t){if(t!=this._rootNode){if(null!=this.treeNodeWillExpand&&this.treeNodeWillExpand.call(this.callbackThisObj,t,!0),null!=t._cell){this.treeNodeRender&&this.treeNodeRender.call(this.callbackThisObj,t,t._cell);var e=t._cell.getController("expanded");e&&(e.selectedIndex=1),t._cell.parent&&this.checkChildren(t,this.getChildIndex(t._cell))}}else this.checkChildren(this._rootNode,0)},n.prototype._afterCollapsed=function(t){if(t!=this._rootNode){if(this.treeNodeWillExpand&&this.treeNodeWillExpand.call(this.callbackThisObj,t,!1),null!=t._cell){this.treeNodeRender&&this.treeNodeRender.call(this.callbackThisObj,t,t._cell);var e=t._cell.getController("expanded");e&&(e.selectedIndex=0),t._cell.parent&&this.hideFolderNode(t)}}else this.checkChildren(this._rootNode,0)},n.prototype._afterMoved=function(t){var e,i=this.getChildIndex(t._cell);e=t.isFolder?this.getFolderEndIndex(i,t.level):i+1;var n,o,r=this.getInsertIndexForNode(t),s=e-i;if(r<i)for(n=0;n<s;n++)o=this.getChildAt(i+n),this.setChildIndex(o,r+n);else for(n=0;n<s;n++)o=this.getChildAt(i),this.setChildIndex(o,r)},n.prototype.getFolderEndIndex=function(t,e){for(var i=this.numChildren,n=t+1;n<i;n++){if(this.getChildAt(n)._treeNode.level<=e)return n}return i},n.prototype.checkChildren=function(t,e){for(var i=t.numChildren,n=0;n<i;n++){e++;var o=t.getChildAt(n);null==o._cell&&this.createCell(o),o._cell.parent||this.addChildAt(o._cell,e),o.isFolder&&o.expanded&&(e=this.checkChildren(o,e))}return e},n.prototype.hideFolderNode=function(t){for(var e=t.numChildren,i=0;i<e;i++){var n=t.getChildAt(i);n._cell&&this.removeChild(n._cell),n.isFolder&&n.expanded&&this.hideFolderNode(n)}},n.prototype.removeNode=function(t){if(t._cell&&(t._cell.parent&&this.removeChild(t._cell),this.returnToPool(t._cell),t._cell._treeNode=null,t._cell=null),t.isFolder)for(var e=t.numChildren,i=0;i<e;i++){var n=t.getChildAt(i);this.removeNode(n)}},n.prototype.__cellMouseDown=function(t){var e=t.currentTarget._treeNode;this._expandedStatusInEvt=e.expanded},n.prototype.__expandedStateChanged=function(t){var e=t.currentTarget;e.parent._treeNode.expanded=1==e.selectedIndex},n.prototype.dispatchItemEvent=function(t){if(0!=this._clickToExpand){var i=t.itemObject._treeNode;i&&i.isFolder&&this._expandedStatusInEvt==i.expanded&&(2==this._clickToExpand||(i.expanded=!i.expanded))}e.prototype.dispatchItemEvent.call(this,t)},n.prototype.setup_beforeAdd=function(t,i){e.prototype.setup_beforeAdd.call(this,t,i),t.seek(i,9),this._indent=t.readInt(),this._clickToExpand=t.readByte()},n.prototype.readItems=function(e){var i,n,o,r,s,a,h,l=0;for(i=e.readShort(),n=0;n<i;n++)if(o=e.readShort(),o+=e.position,null!=(r=e.readS())||(r=this.defaultItem)){s=e.readBool(),h=e.readByte();var c=new t.GTreeNode(s,r);if(c.expanded=!0,0==n)this._rootNode.addChild(c);else if(h>l)a.addChild(c);else if(h<l){for(var u=h;u<=l;u++)a=a.parent;a.addChild(c)}else a.parent.addChild(c);a=c,l=h,this.setupItem(e,c.cell),e.position=o}else e.position=o},n}(t.GList);t.GTree=e;var i=new Array}(fgui||(fgui={})),function(t){var e=function(){function t(t,e){this._level=0,this._resURL=e,t&&(this._children=new Array)}return Object.defineProperty(t.prototype,"expanded",{get:function(){return this._expanded},set:function(t){this._children&&this._expanded!=t&&(this._expanded=t,this._tree&&(this._expanded?this._tree._afterExpanded(this):this._tree._afterCollapsed(this)))},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"isFolder",{get:function(){return null!=this._children},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"parent",{get:function(){return this._parent},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"text",{get:function(){return this._cell?this._cell.text:null},set:function(t){this._cell&&(this._cell.text=t)},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"icon",{get:function(){return this._cell?this._cell.icon:null},set:function(t){this._cell&&(this._cell.icon=t)},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"cell",{get:function(){return this._cell},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"level",{get:function(){return this._level},enumerable:!0,configurable:!0}),t.prototype._setLevel=function(t){this._level=t},t.prototype.addChild=function(t){return this.addChildAt(t,this._children.length),t},t.prototype.addChildAt=function(t,e){if(!t)throw new Error("child is null");var i=this._children.length;if(e>=0&&e<=i){if(t._parent==this)this.setChildIndex(t,e);else t._parent&&t._parent.removeChild(t),e==this._children.length?this._children.push(t):this._children.splice(e,0,t),t._parent=this,t._level=this._level+1,t._setTree(this._tree),(this._tree&&this==this._tree.rootNode||this._cell&&this._cell.parent&&this._expanded)&&this._tree._afterInserted(t);return t}throw new RangeError("Invalid child index")},t.prototype.removeChild=function(t){var e=this._children.indexOf(t);return-1!=e&&this.removeChildAt(e),t},t.prototype.removeChildAt=function(t){if(t>=0&&t<this.numChildren){var e=this._children[t];return this._children.splice(t,1),e._parent=null,this._tree&&(e._setTree(null),this._tree._afterRemoved(e)),e}throw"Invalid child index"},t.prototype.removeChildren=function(t,e){t=t||0,null==e&&(e=-1),(e<0||e>=this.numChildren)&&(e=this.numChildren-1);for(var i=t;i<=e;++i)this.removeChildAt(t)},t.prototype.getChildAt=function(t){if(t>=0&&t<this.numChildren)return this._children[t];throw"Invalid child index"},t.prototype.getChildIndex=function(t){return this._children.indexOf(t)},t.prototype.getPrevSibling=function(){if(null==this._parent)return null;var t=this._parent._children.indexOf(this);return t<=0?null:this._parent._children[t-1]},t.prototype.getNextSibling=function(){if(null==this._parent)return null;var t=this._parent._children.indexOf(this);return t<0||t>=this._parent._children.length-1?null:this._parent._children[t+1]},t.prototype.setChildIndex=function(t,e){var i=this._children.indexOf(t);if(-1==i)throw"Not a child of this container";var n=this._children.length;e<0?e=0:e>n&&(e=n),i!=e&&(this._children.splice(i,1),this._children.splice(e,0,t),(this._tree&&this==this._tree.rootNode||this._cell&&this._cell.parent&&this._expanded)&&this._tree._afterMoved(t))},t.prototype.swapChildren=function(t,e){var i=this._children.indexOf(t),n=this._children.indexOf(e);if(-1==i||-1==n)throw"Not a child of this container";this.swapChildrenAt(i,n)},t.prototype.swapChildrenAt=function(t,e){var i=this._children[t],n=this._children[e];this.setChildIndex(i,e),this.setChildIndex(n,t)},Object.defineProperty(t.prototype,"numChildren",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),t.prototype.expandToRoot=function(){for(var t=this;t;)t.expanded=!0,t=t.parent},Object.defineProperty(t.prototype,"tree",{get:function(){return this._tree},enumerable:!0,configurable:!0}),t.prototype._setTree=function(t){if(this._tree=t,this._tree&&this._tree.treeNodeWillExpand&&this._expanded&&this._tree.treeNodeWillExpand(this,!0),this._children)for(var e=this._children.length,i=0;i<e;i++){var n=this._children[i];n._level=this._level+1,n._setTree(t)}},t}();t.GTreeNode=e}(fgui||(fgui={})),function(t){var e=function(){function t(){this.left=0,this.right=0,this.top=0,this.bottom=0}return t.prototype.copy=function(t){this.top=t.top,this.bottom=t.bottom,this.left=t.left,this.right=t.right},t}();t.Margin=e}(fgui||(fgui={})),function(t){var e=function(){function t(t,e,i){this._data=t,this.offsetX=e,this.offsetY=i,this.scaleX=1,this.scaleY=1}return t.prototype.contains=function(t,e){if(t=Math.floor((t/this.scaleX-this.offsetX)*this._data.scale),e=Math.floor((e/this.scaleY-this.offsetY)*this._data.scale),t<0||e<0||t>=this._data.pixelWidth)return!1;var i=e*this._data.pixelWidth+t,n=Math.floor(i/8),o=i%8;return n>=0&&n<this._data.pixels.length&&1==(this._data.pixels[n]>>o&1)},t}();t.PixelHitTest=e;var i=function(){function t(){}return t.prototype.load=function(t){t.readInt(),this.pixelWidth=t.readInt(),this.scale=1/t.readByte();var e=t.readInt();this.pixels=[];for(var i=0;i<e;i++){var n=t.readByte();n<0&&(n+=256),this.pixels[i]=n}},t}();t.PixelHitTestData=i}(fgui||(fgui={})),function(t){var e=function(){function e(){this.width=0,this.height=0}return e.prototype.load=function(){return this.owner.getItemAsset(this)},e.prototype.getBranch=function(){if(this.branches&&-1!=this.owner._branchIndex){var t=this.branches[this.owner._branchIndex];if(t)return this.owner.getItemById(t)}return this},e.prototype.getHighResolution=function(){if(this.highResolution&&t.GRoot.contentScaleLevel>0){var e=this.highResolution[t.GRoot.contentScaleLevel-1];if(e)return this.owner.getItemById(e)}return this},e.prototype.toString=function(){return this.name},e}();t.PackageItem=e}(fgui||(fgui={})),function(t){var e=function(){function e(e){if(!e&&!(e=t.UIConfig.popupMenu))throw"UIConfig.popupMenu not defined";this._contentPane=t.UIPackage.createObjectFromURL(e).asCom,this._contentPane.addEventListener(egret.Event.ADDED_TO_STAGE,this.__addedToStage,this),this._list=this._contentPane.getChild("list"),this._list.removeChildrenToPool(),this._list.addRelation(this._contentPane,t.RelationType.Width),this._list.removeRelation(this._contentPane,t.RelationType.Height),this._contentPane.addRelation(this._list,t.RelationType.Height),this._list.addEventListener(t.ItemEvent.CLICK,this.__clickItem,this)}return e.prototype.dispose=function(){this._contentPane.dispose()},e.prototype.addItem=function(t,e){var i=this._list.addItemFromPool().asButton;i.title=t,i.data=e,i.grayed=!1;var n=i.getController("checked");return n&&(n.selectedIndex=0),i},e.prototype.addItemAt=function(t,e,i){var n=this._list.getFromPool().asButton;this._list.addChildAt(n,e),n.title=t,n.data=i,n.grayed=!1;var o=n.getController("checked");return o&&(o.selectedIndex=0),n},e.prototype.addSeperator=function(){if(null==t.UIConfig.popupMenu_seperator)throw"UIConfig.popupMenu_seperator not defined";this.list.addItemFromPool(t.UIConfig.popupMenu_seperator)},e.prototype.getItemName=function(t){return this._list.getChildAt(t).name},e.prototype.setItemText=function(t,e){this._list.getChild(t).asButton.title=e},e.prototype.setItemVisible=function(t,e){var i=this._list.getChild(t).asButton;i.visible!=e&&(i.visible=e,this._list.setBoundsChangedFlag())},e.prototype.setItemGrayed=function(t,e){this._list.getChild(t).asButton.grayed=e},e.prototype.setItemCheckable=function(t,e){var i=this._list.getChild(t).asButton.getController("checked");i&&(e?0==i.selectedIndex&&(i.selectedIndex=1):i.selectedIndex=0)},e.prototype.setItemChecked=function(t,e){var i=this._list.getChild(t).asButton.getController("checked");i&&(i.selectedIndex=e?2:1)},e.prototype.isItemChecked=function(t){var e=this._list.getChild(t).asButton.getController("checked");return!!e&&2==e.selectedIndex},e.prototype.removeItem=function(t){var e=this._list.getChild(t);if(e){var i=this._list.getChildIndex(e);return this._list.removeChildToPoolAt(i),!0}return!1},e.prototype.clearItems=function(){this._list.removeChildrenToPool()},Object.defineProperty(e.prototype,"itemCount",{get:function(){return this._list.numChildren},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"contentPane",{get:function(){return this._contentPane},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"list",{get:function(){return this._list},enumerable:!0,configurable:!0}),e.prototype.show=function(e,i){(e?e.root:t.GRoot.inst).showPopup(this.contentPane,e instanceof t.GRoot?null:e,i)},e.prototype.__clickItem=function(e){t.GTimers.inst.add(100,1,this.__clickItem2,this,e)},e.prototype.__clickItem2=function(t){var e=t.itemObject.asButton;if(null!=e)if(e.grayed)this._list.selectedIndex=-1;else{var i=e.getController("checked");i&&0!=i.selectedIndex&&(1==i.selectedIndex?i.selectedIndex=2:i.selectedIndex=1),this._contentPane.parent.hidePopup(this.contentPane),null!=e.data&&(1==e.data.length?e.data(t):e.data())}},e.prototype.__addedToStage=function(t){this._list.selectedIndex=-1,this._list.resizeToFit(1e5,10)},e}();t.PopupMenu=e}(fgui||(fgui={})),function(t){var e=function(){function e(t){this._owner=t,this._defs=new Array}return Object.defineProperty(e.prototype,"owner",{get:function(){return this._owner},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"target",{get:function(){return this._target},set:function(t){this._target!=t&&(this._target&&this.releaseRefTarget(this._target),this._target=t,this._target&&this.addRefTarget(this._target))},enumerable:!0,configurable:!0}),e.prototype.add=function(e,i){if(e==t.RelationType.Size)return this.add(t.RelationType.Width,i),void this.add(t.RelationType.Height,i);for(var n=this._defs.length,o=0;o<n;o++){if(this._defs[o].type==e)return}this.internalAdd(e,i)},e.prototype.internalAdd=function(e,n){if(e==t.RelationType.Size)return this.internalAdd(t.RelationType.Width,n),void this.internalAdd(t.RelationType.Height,n);var o=new i;o.percent=n,o.type=e,o.axis=e<=t.RelationType.Right_Right||e==t.RelationType.Width||e>=t.RelationType.LeftExt_Left&&e<=t.RelationType.RightExt_Right?0:1,this._defs.push(o),(n||e==t.RelationType.Left_Center||e==t.RelationType.Center_Center||e==t.RelationType.Right_Center||e==t.RelationType.Top_Middle||e==t.RelationType.Middle_Middle||e==t.RelationType.Bottom_Middle)&&(this._owner.pixelSnapping=!0)},e.prototype.remove=function(e){if(void 0===e&&(e=0),e==t.RelationType.Size)return this.remove(t.RelationType.Width),void this.remove(t.RelationType.Height);for(var i=this._defs.length,n=0;n<i;n++)if(this._defs[n].type==e){this._defs.splice(n,1);break}},e.prototype.copyFrom=function(t){this.target=t.target,this._defs.length=0;for(var e=t._defs.length,n=0;n<e;n++){var o=t._defs[n],r=new i;r.copyFrom(o),this._defs.push(r)}},e.prototype.dispose=function(){this._target&&(this.releaseRefTarget(this._target),this._target=null)},Object.defineProperty(e.prototype,"isEmpty",{get:function(){return 0==this._defs.length},enumerable:!0,configurable:!0}),e.prototype.applyOnSelfResized=function(e,i,n){for(var o=this._owner.x,r=this._owner.y,s=this._defs.length,a=0;a<s;a++){switch(this._defs[a].type){case t.RelationType.Center_Center:this._owner.x-=(.5-(n?this._owner.pivotX:0))*e;break;case t.RelationType.Right_Center:case t.RelationType.Right_Left:case t.RelationType.Right_Right:this._owner.x-=(1-(n?this._owner.pivotX:0))*e;break;case t.RelationType.Middle_Middle:this._owner.y-=(.5-(n?this._owner.pivotY:0))*i;break;case t.RelationType.Bottom_Middle:case t.RelationType.Bottom_Top:case t.RelationType.Bottom_Bottom:this._owner.y-=(1-(n?this._owner.pivotY:0))*i}}if((o!=this._owner.x||r!=this._owner.y)&&(o=this._owner.x-o,r=this._owner.y-r,this._owner.updateGearFromRelations(1,o,r),this._owner.parent)){var h=this._owner.parent._transitions.length;if(h>0)for(a=0;a<h;++a)this._owner.parent._transitions[a].updateFromRelations(this._owner.id,o,r)}},e.prototype.applyOnXYChanged=function(e,i,n){var o;switch(e.type){case t.RelationType.Left_Left:case t.RelationType.Left_Center:case t.RelationType.Left_Right:case t.RelationType.Center_Center:case t.RelationType.Right_Left:case t.RelationType.Right_Center:case t.RelationType.Right_Right:this._owner.x+=i;break;case t.RelationType.Top_Top:case t.RelationType.Top_Middle:case t.RelationType.Top_Bottom:case t.RelationType.Middle_Middle:case t.RelationType.Bottom_Top:case t.RelationType.Bottom_Middle:case t.RelationType.Bottom_Bottom:this._owner.y+=n;break;case t.RelationType.Width:case t.RelationType.Height:break;case t.RelationType.LeftExt_Left:case t.RelationType.LeftExt_Right:this._owner!=this._target.parent?(o=this._owner.xMin,this._owner.width=this._owner._rawWidth-i,this._owner.xMin=o+i):this._owner.width=this._owner._rawWidth-i;break;case t.RelationType.RightExt_Left:case t.RelationType.RightExt_Right:this._owner!=this._target.parent?(o=this._owner.xMin,this._owner.width=this._owner._rawWidth+i,this._owner.xMin=o):this._owner.width=this._owner._rawWidth+i;break;case t.RelationType.TopExt_Top:case t.RelationType.TopExt_Bottom:this._owner!=this._target.parent?(o=this._owner.yMin,this._owner.height=this._owner._rawHeight-n,this._owner.yMin=o+n):this._owner.height=this._owner._rawHeight-n;break;case t.RelationType.BottomExt_Top:case t.RelationType.BottomExt_Bottom:this._owner!=this._target.parent?(o=this._owner.yMin,this._owner.height=this._owner._rawHeight+n,this._owner.yMin=o):this._owner.height=this._owner._rawHeight+n}},e.prototype.applyOnSizeChanged=function(e){var i,n,o=0,r=0,s=0;switch(0==e.axis?(this._target!=this._owner.parent&&(o=this._target.x,this._target.pivotAsAnchor&&(r=this._target.pivotX)),e.percent?0!=this._targetWidth&&(s=this._target._width/this._targetWidth):s=this._target._width-this._targetWidth):(this._target!=this._owner.parent&&(o=this._target.y,this._target.pivotAsAnchor&&(r=this._target.pivotY)),e.percent?0!=this._targetHeight&&(s=this._target._height/this._targetHeight):s=this._target._height-this._targetHeight),e.type){case t.RelationType.Left_Left:e.percent?this._owner.xMin=o+(this._owner.xMin-o)*s:0!=r&&(this._owner.x+=s*-r);break;case t.RelationType.Left_Center:e.percent?this._owner.xMin=o+(this._owner.xMin-o)*s:this._owner.x+=s*(.5-r);break;case t.RelationType.Left_Right:e.percent?this._owner.xMin=o+(this._owner.xMin-o)*s:this._owner.x+=s*(1-r);break;case t.RelationType.Center_Center:e.percent?this._owner.xMin=o+(this._owner.xMin+.5*this._owner._rawWidth-o)*s-.5*this._owner._rawWidth:this._owner.x+=s*(.5-r);break;case t.RelationType.Right_Left:e.percent?this._owner.xMin=o+(this._owner.xMin+this._owner._rawWidth-o)*s-this._owner._rawWidth:0!=r&&(this._owner.x+=s*-r);break;case t.RelationType.Right_Center:e.percent?this._owner.xMin=o+(this._owner.xMin+this._owner._rawWidth-o)*s-this._owner._rawWidth:this._owner.x+=s*(.5-r);break;case t.RelationType.Right_Right:e.percent?this._owner.xMin=o+(this._owner.xMin+this._owner._rawWidth-o)*s-this._owner._rawWidth:this._owner.x+=s*(1-r);break;case t.RelationType.Top_Top:e.percent?this._owner.yMin=o+(this._owner.yMin-o)*s:0!=r&&(this._owner.y+=s*-r);break;case t.RelationType.Top_Middle:e.percent?this._owner.yMin=o+(this._owner.yMin-o)*s:this._owner.y+=s*(.5-r);break;case t.RelationType.Top_Bottom:e.percent?this._owner.yMin=o+(this._owner.yMin-o)*s:this._owner.y+=s*(1-r);break;case t.RelationType.Middle_Middle:e.percent?this._owner.yMin=o+(this._owner.yMin+.5*this._owner._rawHeight-o)*s-.5*this._owner._rawHeight:this._owner.y+=s*(.5-r);break;case t.RelationType.Bottom_Top:e.percent?this._owner.yMin=o+(this._owner.yMin+this._owner._rawHeight-o)*s-this._owner._rawHeight:0!=r&&(this._owner.y+=s*-r);break;case t.RelationType.Bottom_Middle:e.percent?this._owner.yMin=o+(this._owner.yMin+this._owner._rawHeight-o)*s-this._owner._rawHeight:this._owner.y+=s*(.5-r);break;case t.RelationType.Bottom_Bottom:e.percent?this._owner.yMin=o+(this._owner.yMin+this._owner._rawHeight-o)*s-this._owner._rawHeight:this._owner.y+=s*(1-r);break;case t.RelationType.Width:i=this._owner._underConstruct&&this._owner==this._target.parent?this._owner.sourceWidth-this._target.initWidth:this._owner._rawWidth-this._targetWidth,e.percent&&(i*=s),this._target==this._owner.parent?this._owner.pivotAsAnchor?(n=this._owner.xMin,this._owner.setSize(this._target._width+i,this._owner._rawHeight,!0),this._owner.xMin=n):this._owner.setSize(this._target._width+i,this._owner._rawHeight,!0):this._owner.width=this._target._width+i;break;case t.RelationType.Height:i=this._owner._underConstruct&&this._owner==this._target.parent?this._owner.sourceHeight-this._target.initHeight:this._owner._rawHeight-this._targetHeight,e.percent&&(i*=s),this._target==this._owner.parent?this._owner.pivotAsAnchor?(n=this._owner.yMin,this._owner.setSize(this._owner._rawWidth,this._target._height+i,!0),this._owner.yMin=n):this._owner.setSize(this._owner._rawWidth,this._target._height+i,!0):this._owner.height=this._target._height+i;break;case t.RelationType.LeftExt_Left:n=this._owner.xMin,i=e.percent?o+(n-o)*s-n:s*-r,this._owner.width=this._owner._rawWidth-i,this._owner.xMin=n+i;break;case t.RelationType.LeftExt_Right:n=this._owner.xMin,i=e.percent?o+(n-o)*s-n:s*(1-r),this._owner.width=this._owner._rawWidth-i,this._owner.xMin=n+i;break;case t.RelationType.RightExt_Left:n=this._owner.xMin,i=e.percent?o+(n+this._owner._rawWidth-o)*s-(n+this._owner._rawWidth):s*-r,this._owner.width=this._owner._rawWidth+i,this._owner.xMin=n;break;case t.RelationType.RightExt_Right:n=this._owner.xMin,e.percent?this._owner==this._target.parent?this._owner._underConstruct?this._owner.width=o+this._target._width-this._target._width*r+(this._owner.sourceWidth-o-this._target.initWidth+this._target.initWidth*r)*s:this._owner.width=o+(this._owner._rawWidth-o)*s:(i=o+(n+this._owner._rawWidth-o)*s-(n+this._owner._rawWidth),this._owner.width=this._owner._rawWidth+i,this._owner.xMin=n):this._owner==this._target.parent?this._owner._underConstruct?this._owner.width=this._owner.sourceWidth+(this._target._width-this._target.initWidth)*(1-r):this._owner.width=this._owner._rawWidth+s*(1-r):(i=s*(1-r),this._owner.width=this._owner._rawWidth+i,this._owner.xMin=n);break;case t.RelationType.TopExt_Top:n=this._owner.yMin,i=e.percent?o+(n-o)*s-n:s*-r,this._owner.height=this._owner._rawHeight-i,this._owner.yMin=n+i;break;case t.RelationType.TopExt_Bottom:n=this._owner.yMin,i=e.percent?o+(n-o)*s-n:s*(1-r),this._owner.height=this._owner._rawHeight-i,this._owner.yMin=n+i;break;case t.RelationType.BottomExt_Top:n=this._owner.yMin,i=e.percent?o+(n+this._owner._rawHeight-o)*s-(n+this._owner._rawHeight):s*-r,this._owner.height=this._owner._rawHeight+i,this._owner.yMin=n;break;case t.RelationType.BottomExt_Bottom:n=this._owner.yMin,e.percent?this._owner==this._target.parent?this._owner._underConstruct?this._owner.height=o+this._target._height-this._target._height*r+(this._owner.sourceHeight-o-this._target.initHeight+this._target.initHeight*r)*s:this._owner.height=o+(this._owner._rawHeight-o)*s:(i=o+(n+this._owner._rawHeight-o)*s-(n+this._owner._rawHeight),this._owner.height=this._owner._rawHeight+i,this._owner.yMin=n):this._owner==this._target.parent?this._owner._underConstruct?this._owner.height=this._owner.sourceHeight+(this._target._height-this._target.initHeight)*(1-r):this._owner.height=this._owner._rawHeight+s*(1-r):(i=s*(1-r),this._owner.height=this._owner._rawHeight+i,this._owner.yMin=n)}},e.prototype.addRefTarget=function(e){e!=this._owner.parent&&e.addEventListener(t.GObject.XY_CHANGED,this.__targetXYChanged,this),e.addEventListener(t.GObject.SIZE_CHANGED,this.__targetSizeChanged,this),e.addEventListener(t.GObject.SIZE_DELAY_CHANGE,this.__targetSizeWillChange,this),this._targetX=this._target.x,this._targetY=this._target.y,this._targetWidth=this._target._width,this._targetHeight=this._target._height},e.prototype.releaseRefTarget=function(e){e.removeEventListener(t.GObject.XY_CHANGED,this.__targetXYChanged,this),e.removeEventListener(t.GObject.SIZE_CHANGED,this.__targetSizeChanged,this),e.removeEventListener(t.GObject.SIZE_DELAY_CHANGE,this.__targetSizeWillChange,this)},e.prototype.__targetXYChanged=function(t){if(null!=this._owner.relations.handling||null!=this._owner.group&&this._owner.group._updating)return this._targetX=this._target.x,void(this._targetY=this._target.y);this._owner.relations.handling=this._target;for(var e=this._owner.x,i=this._owner.y,n=this._target.x-this._targetX,o=this._target.y-this._targetY,r=this._defs.length,s=0;s<r;s++){var a=this._defs[s];this.applyOnXYChanged(a,n,o)}if(this._targetX=this._target.x,this._targetY=this._target.y,(e!=this._owner.x||i!=this._owner.y)&&(e=this._owner.x-e,i=this._owner.y-i,this._owner.updateGearFromRelations(1,e,i),this._owner.parent)){var h=this._owner.parent._transitions.length;if(h>0)for(s=0;s<h;++s)this._owner.parent._transitions[s].updateFromRelations(this._owner.id,e,i)}this._owner.relations.handling=null},e.prototype.__targetSizeChanged=function(t){if(null==this._owner.relations.handling){this._owner.relations.handling=this._target;for(var e=this._owner.x,i=this._owner.y,n=this._owner._rawWidth,o=this._owner._rawHeight,r=this._defs.length,s=0;s<r;s++){var a=this._defs[s];this.applyOnSizeChanged(a)}if(this._targetWidth=this._target._width,this._targetHeight=this._target._height,(e!=this._owner.x||i!=this._owner.y)&&(e=this._owner.x-e,i=this._owner.y-i,this._owner.updateGearFromRelations(1,e,i),this._owner.parent)){var h=this._owner.parent._transitions.length;if(h>0)for(s=0;s<h;++s)this._owner.parent._transitions[s].updateFromRelations(this._owner.id,e,i)}n==this._owner._rawWidth&&o==this._owner._rawHeight||(n=this._owner._rawWidth-n,o=this._owner._rawHeight-o,this._owner.updateGearFromRelations(2,n,o)),this._owner.relations.handling=null}},e.prototype.__targetSizeWillChange=function(t){this._owner.relations.sizeDirty=!0},e}();t.RelationItem=e;var i=function(){function t(){}return t.prototype.copyFrom=function(t){this.percent=t.percent,this.type=t.type,this.axis=t.axis},t}();t.RelationDef=i}(fgui||(fgui={})),function(t){var e=function(){function e(t){this._owner=t,this._items=new Array}return e.prototype.add=function(e,i,n){for(var o=this._items.length,r=0;r<o;r++){var s=this._items[r];if(s.target==e)return void s.add(i,n)}var a=new t.RelationItem(this._owner);a.target=e,a.add(i,n),this._items.push(a)},e.prototype.remove=function(t,e){e=e||0;for(var i=this._items.length,n=0;n<i;){var o=this._items[n];o.target==t?(o.remove(e),o.isEmpty?(o.dispose(),this._items.splice(n,1),i--):n++):n++}},e.prototype.contains=function(t){for(var e=this._items.length,i=0;i<e;i++){if(this._items[i].target==t)return!0}return!1},e.prototype.clearFor=function(t){for(var e=this._items.length,i=0;i<e;){var n=this._items[i];n.target==t?(n.dispose(),this._items.splice(i,1),e--):i++}},e.prototype.clearAll=function(){for(var t=this._items.length,e=0;e<t;e++){this._items[e].dispose()}this._items.length=0},e.prototype.copyFrom=function(e){this.clearAll();for(var i=e._items,n=i.length,o=0;o<n;o++){var r=i[o],s=new t.RelationItem(this._owner);s.copyFrom(r),this._items.push(s)}},e.prototype.dispose=function(){this.clearAll()},e.prototype.onOwnerSizeChanged=function(t,e,i){if(0!=this._items.length)for(var n=this._items.length,o=0;o<n;o++){this._items[o].applyOnSelfResized(t,e,i)}},e.prototype.ensureRelationsSizeCorrect=function(){if(0!=this._items.length){this.sizeDirty=!1;for(var t=this._items.length,e=0;e<t;e++){this._items[e].target.ensureSizeCorrect()}}},Object.defineProperty(e.prototype,"empty",{get:function(){return 0==this._items.length},enumerable:!0,configurable:!0}),e.prototype.setup=function(e,i){for(var n,o=e.readByte(),r=0;r<o;r++){var s=e.readShort();n=-1==s?this._owner.parent:i?this._owner.getChildAt(s):this._owner.parent.getChildAt(s);var a=new t.RelationItem(this._owner);a.target=n,this._items.push(a);for(var h=e.readByte(),l=0;l<h;l++){var c=e.readByte(),u=e.readBool();a.internalAdd(c,u)}}},e}();t.Relations=e}(fgui||(fgui={})),function(t){var e=function(e){function c(i){var n=e.call(this)||this;return n._owner=i,n._maskContainer=new egret.DisplayObjectContainer,n._owner._rootContainer.addChild(n._maskContainer),n._container=n._owner._container,n._container.x=0,n._container.y=0,n._maskContainer.addChild(n._container),n._scrollBarMargin=new t.Margin,n._xPos=0,n._yPos=0,n._aniFlag=0,n._tweening=0,n._footerLockedSize=0,n._headerLockedSize=0,n._viewSize=new egret.Point,n._contentSize=new egret.Point,n._pageSize=new egret.Point(1,1),n._overlapSize=new egret.Point,n._tweenTime=new egret.Point,n._tweenStart=new egret.Point,n._tweenDuration=new egret.Point,n._tweenChange=new egret.Point,n._velocity=new egret.Point,n._containerPos=new egret.Point,n._beginTouchPos=new egret.Point,n._lastTouchPos=new egret.Point,n._lastTouchGlobalPos=new egret.Point,n._scrollStep=t.UIConfig.defaultScrollStep,n._decelerationRate=t.UIConfig.defaultScrollDecelerationRate,n._owner.addEventListener(egret.TouchEvent.TOUCH_BEGIN,n.__touchBegin,n),n}return __extends(c,e),c.prototype.setup=function(e){this._scrollType=e.readByte();var i=e.readByte(),n=e.readInt();e.readBool()&&(this._scrollBarMargin.top=e.readInt(),this._scrollBarMargin.bottom=e.readInt(),this._scrollBarMargin.left=e.readInt(),this._scrollBarMargin.right=e.readInt());var o=e.readS(),r=e.readS(),s=e.readS(),a=e.readS();if(0!=(1&n)&&(this._displayOnLeft=!0),0!=(2&n)&&(this._snapToItem=!0),0!=(4&n)&&(this._displayInDemand=!0),0!=(8&n)&&(this._pageMode=!0),this._touchEffect=!!(16&n)||!(32&n)&&t.UIConfig.defaultScrollTouchEffect,this._bouncebackEffect=!!(64&n)||!(128&n)&&t.UIConfig.defaultScrollBounceEffect,0!=(256&n)&&(this._inertiaDisabled=!0),0==(512&n)&&(this._maskContainer.scrollRect=new egret.Rectangle),0!=(1024&n)&&(this._floating=!0),0!=(2048&n)&&(this._dontClipMargin=!0),i==t.ScrollBarDisplayType.Default&&(i=t.UIConfig.defaultScrollBarDisplay),i!=t.ScrollBarDisplayType.Hidden){var h;if(this._scrollType==t.ScrollType.Both||this._scrollType==t.ScrollType.Vertical)if(h=o||t.UIConfig.verticalScrollBar){if(this._vtScrollBar=t.UIPackage.createObjectFromURL(h),!this._vtScrollBar)throw"cannot create scrollbar from "+h;this._vtScrollBar.setScrollPane(this,!0),this._owner._rootContainer.addChild(this._vtScrollBar.displayObject)}if(this._scrollType==t.ScrollType.Both||this._scrollType==t.ScrollType.Horizontal)if(h=r||t.UIConfig.horizontalScrollBar){if(this._hzScrollBar=t.UIPackage.createObjectFromURL(h),!this._hzScrollBar)throw"cannot create scrollbar from "+h;this._hzScrollBar.setScrollPane(this,!1),this._owner._rootContainer.addChild(this._hzScrollBar.displayObject)}i==t.ScrollBarDisplayType.Auto&&(this._scrollBarDisplayAuto=!0),this._scrollBarDisplayAuto&&(this._vtScrollBar&&(this._vtScrollBar.displayObject.visible=!1),this._hzScrollBar&&(this._hzScrollBar.displayObject.visible=!1))}if(s&&(this._header=t.UIPackage.createObjectFromURL(s),!this._header))throw"cannot create scrollPane header from "+s;if(a&&(this._footer=t.UIPackage.createObjectFromURL(a),!this._footer))throw"cannot create scrollPane footer from "+a;(this._header||this._footer)&&(this._refreshBarAxis=this._scrollType==t.ScrollType.Both||this._scrollType==t.ScrollType.Vertical?"y":"x"),this.setSize(this._owner.width,this._owner.height)},c.prototype.dispose=function(){0!=this._tweening&&t.GTimers.inst.remove(this.tweenUpdate,this),delete this._pageController,this._hzScrollBar&&this._hzScrollBar.dispose(),this._vtScrollBar&&this._vtScrollBar.dispose(),this._header&&this._header.dispose(),this._footer&&this._footer.dispose()},Object.defineProperty(c.prototype,"owner",{get:function(){return this._owner},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"hzScrollBar",{get:function(){return this._hzScrollBar},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"vtScrollBar",{get:function(){return this._vtScrollBar},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"header",{get:function(){return this._header},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"footer",{get:function(){return this._footer},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"bouncebackEffect",{get:function(){return this._bouncebackEffect},set:function(t){this._bouncebackEffect=t},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"touchEffect",{get:function(){return this._touchEffect},set:function(t){this._touchEffect=t},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"scrollStep",{get:function(){return this._scrollStep},set:function(e){this._scrollStep=e,0==this._scrollStep&&(this._scrollStep=t.UIConfig.defaultScrollStep)},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"decelerationRate",{get:function(){return this._decelerationRate},set:function(t){this._decelerationRate=t},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"snapToItem",{get:function(){return this._snapToItem},set:function(t){this._snapToItem=t},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"isDragged",{get:function(){return this._dragged},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"percX",{get:function(){return 0==this._overlapSize.x?0:this._xPos/this._overlapSize.x},set:function(t){this.setPercX(t,!1)},enumerable:!0,configurable:!0}),c.prototype.setPercX=function(e,i){void 0===i&&(i=!1),this._owner.ensureBoundsCorrect(),this.setPosX(this._overlapSize.x*t.ToolSet.clamp01(e),i)},Object.defineProperty(c.prototype,"percY",{get:function(){return 0==this._overlapSize.y?0:this._yPos/this._overlapSize.y},set:function(t){this.setPercY(t,!1)},enumerable:!0,configurable:!0}),c.prototype.setPercY=function(e,i){void 0===i&&(i=!1),this._owner.ensureBoundsCorrect(),this.setPosY(this._overlapSize.y*t.ToolSet.clamp01(e),i)},Object.defineProperty(c.prototype,"posX",{get:function(){return this._xPos},set:function(t){this.setPosX(t,!1)},enumerable:!0,configurable:!0}),c.prototype.setPosX=function(e,i){this._owner.ensureBoundsCorrect(),1==this._loop&&(e=this.loopCheckingNewPos(e,"x")),(e=t.ToolSet.clamp(e,0,this._overlapSize.x))!=this._xPos&&(this._xPos=e,this.posChanged(i))},Object.defineProperty(c.prototype,"posY",{get:function(){return this._yPos},set:function(t){this.setPosY(t,!1)},enumerable:!0,configurable:!0}),c.prototype.setPosY=function(e,i){this._owner.ensureBoundsCorrect(),1==this._loop&&(e=this.loopCheckingNewPos(e,"y")),(e=t.ToolSet.clamp(e,0,this._overlapSize.y))!=this._yPos&&(this._yPos=e,this.posChanged(i))},Object.defineProperty(c.prototype,"contentWidth",{get:function(){return this._contentSize.x},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"contentHeight",{get:function(){return this._contentSize.y},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"viewWidth",{get:function(){return this._viewSize.x},set:function(t){t=t+this._owner.margin.left+this._owner.margin.right,this._vtScrollBar&&!this._floating&&(t+=this._vtScrollBar.width),this._owner.width=t},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"viewHeight",{get:function(){return this._viewSize.y},set:function(t){t=t+this._owner.margin.top+this._owner.margin.bottom,this._hzScrollBar&&!this._floating&&(t+=this._hzScrollBar.height),this._owner.height=t},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"currentPageX",{get:function(){if(!this._pageMode)return 0;var t=Math.floor(this._xPos/this._pageSize.x);return this._xPos-t*this._pageSize.x>.5*this._pageSize.x&&t++,t},set:function(t){this.setCurrentPageX(t,!1)},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"currentPageY",{get:function(){if(!this._pageMode)return 0;var t=Math.floor(this._yPos/this._pageSize.y);return this._yPos-t*this._pageSize.y>.5*this._pageSize.y&&t++,t},set:function(t){this.setCurrentPageY(t,!1)},enumerable:!0,configurable:!0}),c.prototype.setCurrentPageX=function(t,e){this._pageMode&&(this._owner.ensureBoundsCorrect(),this._overlapSize.x>0&&this.setPosX(t*this._pageSize.x,e))},c.prototype.setCurrentPageY=function(t,e){this._pageMode&&(this._owner.ensureBoundsCorrect(),this._overlapSize.y>0&&this.setPosY(t*this._pageSize.y,e))},Object.defineProperty(c.prototype,"isBottomMost",{get:function(){return this._yPos==this._overlapSize.y||0==this._overlapSize.y},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"isRightMost",{get:function(){return this._xPos==this._overlapSize.x||0==this._overlapSize.x},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"pageController",{get:function(){return this._pageController},set:function(t){this._pageController=t},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"scrollingPosX",{get:function(){return t.ToolSet.clamp(-this._container.x,0,this._overlapSize.x)},enumerable:!0,configurable:!0}),Object.defineProperty(c.prototype,"scrollingPosY",{get:function(){return t.ToolSet.clamp(-this._container.y,0,this._overlapSize.y)},enumerable:!0,configurable:!0}),c.prototype.scrollTop=function(t){this.setPercY(0,t)},c.prototype.scrollBottom=function(t){this.setPercY(1,t)},c.prototype.scrollUp=function(t,e){t=t||1,this._pageMode?this.setPosY(this._yPos-this._pageSize.y*t,e):this.setPosY(this._yPos-this._scrollStep*t,e)},c.prototype.scrollDown=function(t,e){t=t||1,this._pageMode?this.setPosY(this._yPos+this._pageSize.y*t,e):this.setPosY(this._yPos+this._scrollStep*t,e)},c.prototype.scrollLeft=function(t,e){t=t||1,this._pageMode?this.setPosX(this._xPos-this._pageSize.x*t,e):this.setPosX(this._xPos-this._scrollStep*t,e)},c.prototype.scrollRight=function(t,e){t=t||1,this._pageMode?this.setPosX(this._xPos+this._pageSize.x*t,e):this.setPosX(this._xPos+this._scrollStep*t,e)},c.prototype.scrollToView=function(e,i,n){var o;if(this._owner.ensureBoundsCorrect(),this._needRefresh&&this.refresh(),e instanceof t.GObject?e.parent!=this._owner?(e.parent.localToGlobalRect(e.x,e.y,e.width,e.height,a),o=this._owner.globalToLocalRect(a.x,a.y,a.width,a.height,a)):(o=a).setTo(e.x,e.y,e.width,e.height):o=e,this._overlapSize.y>0){var r=this._yPos+this._viewSize.y;n||o.y<=this._yPos||o.height>=this._viewSize.y?this._pageMode?this.setPosY(Math.floor(o.y/this._pageSize.y)*this._pageSize.y,i):this.setPosY(o.y,i):o.y+o.height>r&&(this._pageMode?this.setPosY(Math.floor(o.y/this._pageSize.y)*this._pageSize.y,i):o.height<=this._viewSize.y/2?this.setPosY(o.y+2*o.height-this._viewSize.y,i):this.setPosY(o.y+o.height-this._viewSize.y,i))}if(this._overlapSize.x>0){var s=this._xPos+this._viewSize.x;n||o.x<=this._xPos||o.width>=this._viewSize.x?this._pageMode?this.setPosX(Math.floor(o.x/this._pageSize.x)*this._pageSize.x,i):this.setPosX(o.x,i):o.x+o.width>s&&(this._pageMode?this.setPosX(Math.floor(o.x/this._pageSize.x)*this._pageSize.x,i):o.width<=this._viewSize.x/2?this.setPosX(o.x+2*o.width-this._viewSize.x,i):this.setPosX(o.x+o.width-this._viewSize.x,i))}!i&&this._needRefresh&&this.refresh()},c.prototype.isChildInView=function(t){if(this._overlapSize.y>0){var e=t.y+this._container.y;if(e<-t.height||e>this._viewSize.y)return!1}return!(this._overlapSize.x>0&&((e=t.x+this._container.x)<-t.width||e>this._viewSize.x))},c.prototype.cancelDragging=function(){this._owner.displayObject.removeEventListener(egret.TouchEvent.TOUCH_MOVE,this.__touchMove,this),this._owner.displayObject.removeEventListener(egret.TouchEvent.TOUCH_END,this.__touchEnd,this),this._owner.displayObject.removeEventListener(egret.TouchEvent.TOUCH_TAP,this.__touchTap,this),c.draggingPane==this&&(c.draggingPane=null),i=0,this._dragged=!1,this._maskContainer.touchChildren=!0},c.prototype.lockHeader=function(t){this._headerLockedSize!=t&&(this._headerLockedSize=t,!this._refreshEventDispatching&&this._container[this._refreshBarAxis]>=0&&(this._tweenStart.setTo(this._container.x,this._container.y),this._tweenChange.setTo(0,0),this._tweenChange[this._refreshBarAxis]=this._headerLockedSize-this._tweenStart[this._refreshBarAxis],this._tweenDuration.setTo(o,o),this.startTween(2)))},c.prototype.lockFooter=function(t){if(this._footerLockedSize!=t&&(this._footerLockedSize=t,!this._refreshEventDispatching&&this._container[this._refreshBarAxis]<=-this._overlapSize[this._refreshBarAxis])){this._tweenStart.setTo(this._container.x,this._container.y),this._tweenChange.setTo(0,0);var e=this._overlapSize[this._refreshBarAxis];0==e?e=Math.max(this._contentSize[this._refreshBarAxis]+this._footerLockedSize-this._viewSize[this._refreshBarAxis],0):e+=this._footerLockedSize,this._tweenChange[this._refreshBarAxis]=-e-this._tweenStart[this._refreshBarAxis],this._tweenDuration.setTo(o,o),this.startTween(2)}},c.prototype.onOwnerSizeChanged=function(){this.setSize(this._owner.width,this._owner.height),this.posChanged(!1)},c.prototype.handleControllerChanged=function(e){this._pageController==e&&(this._scrollType==t.ScrollType.Horizontal?this.setCurrentPageX(e.selectedIndex,!0):this.setCurrentPageY(e.selectedIndex,!0))},c.prototype.updatePageController=function(){var e;if(this._pageController&&!this._pageController.changing&&(e=this._scrollType==t.ScrollType.Horizontal?this.currentPageX:this.currentPageY)<this._pageController.pageCount){var i=this._pageController;this._pageController=null,i.selectedIndex=e,this._pageController=i}},c.prototype.adjustMaskContainer=function(){var t=0,e=0;this._dontClipMargin?this._displayOnLeft&&this._vtScrollBar&&!this._floating&&(t=this._vtScrollBar.width):(t=this._displayOnLeft&&this._vtScrollBar&&!this._floating?this._owner.margin.left+this._vtScrollBar.width:this._owner.margin.left,e=this._owner.margin.top),this._maskContainer.x=t,this._maskContainer.y=e,t=this._owner._alignOffset.x,e=this._owner._alignOffset.y,(0!=t||0!=e||this._dontClipMargin)&&(this._alignContainer||(this._alignContainer=new egret.DisplayObjectContainer,this._maskContainer.addChild(this._alignContainer),this._alignContainer.addChild(this._container))),this._alignContainer&&(this._dontClipMargin&&(t+=this._owner.margin.left,e+=this._owner.margin.top),this._alignContainer.x=t,this._alignContainer.y=e)},c.prototype.setSize=function(t,e){this.adjustMaskContainer(),this._hzScrollBar&&(this._hzScrollBar.y=e-this._hzScrollBar.height,this._vtScrollBar&&!this._vScrollNone?(this._hzScrollBar.width=t-this._vtScrollBar.width-this._scrollBarMargin.left-this._scrollBarMargin.right,this._displayOnLeft?this._hzScrollBar.x=this._scrollBarMargin.left+this._vtScrollBar.width:this._hzScrollBar.x=this._scrollBarMargin.left):(this._hzScrollBar.width=t-this._scrollBarMargin.left-this._scrollBarMargin.right,this._hzScrollBar.x=this._scrollBarMargin.left)),this._vtScrollBar&&(this._displayOnLeft||(this._vtScrollBar.x=t-this._vtScrollBar.width),this._hzScrollBar?this._vtScrollBar.height=e-this._hzScrollBar.height-this._scrollBarMargin.top-this._scrollBarMargin.bottom:this._vtScrollBar.height=e-this._scrollBarMargin.top-this._scrollBarMargin.bottom,this._vtScrollBar.y=this._scrollBarMargin.top),this._viewSize.x=t,this._viewSize.y=e,this._hzScrollBar&&!this._floating&&(this._viewSize.y-=this._hzScrollBar.height),this._vtScrollBar&&!this._floating&&(this._viewSize.x-=this._vtScrollBar.width),this._viewSize.x-=this._owner.margin.left+this._owner.margin.right,this._viewSize.y-=this._owner.margin.top+this._owner.margin.bottom,this._viewSize.x=Math.max(1,this._viewSize.x),this._viewSize.y=Math.max(1,this._viewSize.y),this._pageSize.x=this._viewSize.x,this._pageSize.y=this._viewSize.y,this.handleSizeChanged()},c.prototype.setContentSize=function(t,e){this._contentSize.x==t&&this._contentSize.y==e||(this._contentSize.x=t,this._contentSize.y=e,this.handleSizeChanged())},c.prototype.changeContentSizeOnScrolling=function(t,e,i,n){var o=this._xPos==this._overlapSize.x,r=this._yPos==this._overlapSize.y;this._contentSize.x+=t,this._contentSize.y+=e,this.handleSizeChanged(),1==this._tweening?(0!=t&&o&&this._tweenChange.x<0&&(this._xPos=this._overlapSize.x,this._tweenChange.x=-this._xPos-this._tweenStart.x),0!=e&&r&&this._tweenChange.y<0&&(this._yPos=this._overlapSize.y,this._tweenChange.y=-this._yPos-this._tweenStart.y)):2==this._tweening?(0!=i&&(this._container.x-=i,this._tweenStart.x-=i,this._xPos=-this._container.x),0!=n&&(this._container.y-=n,this._tweenStart.y-=n,this._yPos=-this._container.y)):this._dragged?(0!=i&&(this._container.x-=i,this._containerPos.x-=i,this._xPos=-this._container.x),0!=n&&(this._container.y-=n,this._containerPos.y-=n,this._yPos=-this._container.y)):(0!=t&&o&&(this._xPos=this._overlapSize.x,this._container.x=-this._xPos),0!=e&&r&&(this._yPos=this._overlapSize.y,this._container.y=-this._yPos)),this._pageMode&&this.updatePageController()},c.prototype.handleSizeChanged=function(){this._displayInDemand&&(this._vScrollNone=this._contentSize.y<=this._viewSize.y,this._hScrollNone=this._contentSize.x<=this._viewSize.x),this._vtScrollBar&&(0==this._contentSize.y?this._vtScrollBar.setDisplayPerc(0):this._vtScrollBar.setDisplayPerc(Math.min(1,this._viewSize.y/this._contentSize.y))),this._hzScrollBar&&(0==this._contentSize.x?this._hzScrollBar.setDisplayPerc(0):this._hzScrollBar.setDisplayPerc(Math.min(1,this._viewSize.x/this._contentSize.x))),this.updateScrollBarVisible();var e=this._maskContainer.scrollRect;if(e&&(e.width=this._viewSize.x,e.height=this._viewSize.y,this._vScrollNone&&this._vtScrollBar&&(e.width+=this._vtScrollBar.width),this._hScrollNone&&this._hzScrollBar&&(e.height+=this._hzScrollBar.height),this._dontClipMargin&&(e.width+=this._owner.margin.left+this._owner.margin.right,e.height+=this._owner.margin.top+this._owner.margin.bottom),this._maskContainer.scrollRect=e),this._scrollType==t.ScrollType.Horizontal||this._scrollType==t.ScrollType.Both?this._overlapSize.x=Math.ceil(Math.max(0,this._contentSize.x-this._viewSize.x)):this._overlapSize.x=0,this._scrollType==t.ScrollType.Vertical||this._scrollType==t.ScrollType.Both?this._overlapSize.y=Math.ceil(Math.max(0,this._contentSize.y-this._viewSize.y)):this._overlapSize.y=0,this._xPos=t.ToolSet.clamp(this._xPos,0,this._overlapSize.x),this._yPos=t.ToolSet.clamp(this._yPos,0,this._overlapSize.y),null!=this._refreshBarAxis){var i=this._overlapSize[this._refreshBarAxis];0==i?i=Math.max(this._contentSize[this._refreshBarAxis]+this._footerLockedSize-this._viewSize[this._refreshBarAxis],0):i+=this._footerLockedSize,"x"==this._refreshBarAxis?(this._container.x=t.ToolSet.clamp(this._container.x,-i,this._headerLockedSize),this._container.y=t.ToolSet.clamp(this._container.y,-this._overlapSize.y,0)):(this._container.x=t.ToolSet.clamp(this._container.x,-this._overlapSize.x,0),this._container.y=t.ToolSet.clamp(this._container.y,-i,this._headerLockedSize)),this._header&&("x"==this._refreshBarAxis?this._header.height=this._viewSize.y:this._header.width=this._viewSize.x),this._footer&&("y"==this._refreshBarAxis?this._footer.height=this._viewSize.y:this._footer.width=this._viewSize.x)}else this._container.x=t.ToolSet.clamp(this._container.x,-this._overlapSize.x,0),this._container.y=t.ToolSet.clamp(this._container.y,-this._overlapSize.y,0);this.updateScrollBarPos(),this._pageMode&&this.updatePageController()},c.prototype.posChanged=function(e){0==this._aniFlag?this._aniFlag=e?1:-1:1!=this._aniFlag||e||(this._aniFlag=-1),this._needRefresh=!0,t.GTimers.inst.callLater(this.refresh,this),0!=this._tweening&&this.killTween()},c.prototype.refresh=function(){this._needRefresh=!1,t.GTimers.inst.remove(this.refresh,this),(this._pageMode||this._snapToItem)&&(h.setTo(-this._xPos,-this._yPos),this.alignPosition(h,!1),this._xPos=-h.x,this._yPos=-h.y),this.refresh2(),this.dispatchEventWith(c.SCROLL),this._needRefresh&&(this._needRefresh=!1,t.GTimers.inst.remove(this.refresh,this),this.refresh2()),this.updateScrollBarPos(),this._aniFlag=0},c.prototype.refresh2=function(){var t,e;1!=this._aniFlag||this._dragged?(0!=this._tweening&&this.killTween(),this._container.x=Math.floor(-this._xPos),this._container.y=Math.floor(-this._yPos),this.loopCheckingCurrent()):(this._overlapSize.x>0?t=-Math.floor(this._xPos):(0!=this._container.x&&(this._container.x=0),t=0),this._overlapSize.y>0?e=-Math.floor(this._yPos):(0!=this._container.y&&(this._container.y=0),e=0),t!=this._container.x||e!=this._container.y?(this._tweenDuration.setTo(n,n),this._tweenStart.setTo(this._container.x,this._container.y),this._tweenChange.setTo(t-this._tweenStart.x,e-this._tweenStart.y),this.startTween(1)):0!=this._tweening&&this.killTween());this._pageMode&&this.updatePageController()},c.prototype.__touchBegin=function(t){if(this._touchEffect){0!=this._tweening?(this.killTween(),this._dragged=!0):this._dragged=!1;var e=this._owner.globalToLocal(t.stageX,t.stageY,s);this._containerPos.setTo(this._container.x,this._container.y),this._beginTouchPos.setTo(e.x,e.y),this._lastTouchPos.setTo(e.x,e.y),this._lastTouchGlobalPos.setTo(t.stageX,t.stageY),this._isHoldAreaDone=!1,this._velocity.setTo(0,0),this._velocityScale=1,this._lastMoveTime=egret.getTimer()/1e3,this._owner.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.__touchMove,this),this._owner.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_END,this.__touchEnd,this),this._owner.displayObject.stage.addEventListener(egret.TouchEvent.TOUCH_TAP,this.__touchTap,this)}},c.prototype.__touchMove=function(e){if(null!=this._owner.displayObject.stage&&this._touchEffect&&!(c.draggingPane&&c.draggingPane!=this||t.GObject.draggingObject)){var n,o,a,h=this._owner.globalToLocal(e.stageX,e.stageY,s),l=t.UIConfig.touchScrollSensitivity;if(this._scrollType==t.ScrollType.Vertical){if(!this._isHoldAreaDone){if(i|=1,(n=Math.abs(this._beginTouchPos.y-h.y))<l)return;if(0!=(2&i)&&n<Math.abs(this._beginTouchPos.x-h.x))return}o=!0}else if(this._scrollType==t.ScrollType.Horizontal){if(!this._isHoldAreaDone){if(i|=2,(n=Math.abs(this._beginTouchPos.x-h.x))<l)return;if(0!=(1&i)&&n<Math.abs(this._beginTouchPos.y-h.y))return}a=!0}else{if(i=3,!this._isHoldAreaDone&&(n=Math.abs(this._beginTouchPos.y-h.y))<l&&(n=Math.abs(this._beginTouchPos.x-h.x))<l)return;o=a=!0}var u=Math.floor(this._containerPos.x+h.x-this._beginTouchPos.x),_=Math.floor(this._containerPos.y+h.y-this._beginTouchPos.y);o&&(_>0?this._bouncebackEffect?this._header&&0!=this._header.maxHeight?this._container.y=Math.floor(Math.min(.5*_,this._header.maxHeight)):this._container.y=Math.floor(Math.min(.5*_,this._viewSize.y*r)):this._container.y=0:_<-this._overlapSize.y?this._bouncebackEffect?this._footer&&this._footer.maxHeight>0?this._container.y=Math.floor(Math.max(.5*(_+this._overlapSize.y),-this._footer.maxHeight)-this._overlapSize.y):this._container.y=Math.floor(Math.max(.5*(_+this._overlapSize.y),-this._viewSize.y*r)-this._overlapSize.y):this._container.y=-this._overlapSize.y:this._container.y=_),a&&(u>0?this._bouncebackEffect?this._header&&0!=this._header.maxWidth?this._container.x=Math.floor(Math.min(.5*u,this._header.maxWidth)):this._container.x=Math.floor(Math.min(.5*u,this._viewSize.x*r)):this._container.x=0:u<0-this._overlapSize.x?this._bouncebackEffect?this._footer&&this._footer.maxWidth>0?this._container.x=Math.floor(Math.max(.5*(u+this._overlapSize.x),-this._footer.maxWidth)-this._overlapSize.x):this._container.x=Math.floor(Math.max(.5*(u+this._overlapSize.x),-this._viewSize.x*r)-this._overlapSize.x):this._container.x=-this._overlapSize.x:this._container.x=u);var p=egret.getTimer()/1e3,d=Math.max(p-this._lastMoveTime,1/60),g=h.x-this._lastTouchPos.x,f=h.y-this._lastTouchPos.y;if(a||(g=0),o||(f=0),0!=d){var y=this._owner.displayObject.stage.frameRate,m=d*y-1;if(m>1){var b=Math.pow(.833,m);this._velocity.x=this._velocity.x*b,this._velocity.y=this._velocity.y*b}this._velocity.x=t.ToolSet.lerp(this._velocity.x,60*g/y/d,10*d),this._velocity.y=t.ToolSet.lerp(this._velocity.y,60*f/y/d,10*d)}var v=this._lastTouchGlobalPos.x-e.stageX,w=this._lastTouchGlobalPos.y-e.stageY;0!=g?this._velocityScale=Math.abs(v/g):0!=f&&(this._velocityScale=Math.abs(w/f)),this._lastTouchPos.setTo(h.x,h.y),this._lastTouchGlobalPos.setTo(e.stageX,e.stageY),this._lastMoveTime=p,this._overlapSize.x>0&&(this._xPos=t.ToolSet.clamp(-this._container.x,0,this._overlapSize.x)),this._overlapSize.y>0&&(this._yPos=t.ToolSet.clamp(-this._container.y,0,this._overlapSize.y)),0!=this._loop&&(u=this._container.x,_=this._container.y,this.loopCheckingCurrent()&&(this._containerPos.x+=this._container.x-u,this._containerPos.y+=this._container.y-_)),c.draggingPane=this,this._isHoldAreaDone=!0,this._dragged=!0,this._maskContainer.touchChildren=!1,this.updateScrollBarPos(),this.updateScrollBarVisible(),this._pageMode&&this.updatePageController(),this.dispatchEventWith(c.SCROLL)}},c.prototype.__touchEnd=function(e){if(e.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_MOVE,this.__touchMove,this),e.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_END,this.__touchEnd,this),e.currentTarget.removeEventListener(egret.TouchEvent.TOUCH_TAP,this.__touchTap,this),c.draggingPane==this&&(c.draggingPane=null),i=0,!this._dragged||!this._touchEffect||null==this._owner.displayObject.stage)return this._dragged=!1,void(this._maskContainer.touchChildren=!0);this._dragged=!1,this._maskContainer.touchChildren=!0,this._tweenStart.setTo(this._container.x,this._container.y),h.setTo(this._tweenStart.x,this._tweenStart.y);var n=!1;if(this._container.x>0?(h.x=0,n=!0):this._container.x<-this._overlapSize.x&&(h.x=-this._overlapSize.x,n=!0),this._container.y>0?(h.y=0,n=!0):this._container.y<-this._overlapSize.y&&(h.y=-this._overlapSize.y,n=!0),n){if(this._tweenChange.setTo(h.x-this._tweenStart.x,h.y-this._tweenStart.y),this._tweenChange.x<-t.UIConfig.touchDragSensitivity||this._tweenChange.y<-t.UIConfig.touchDragSensitivity?(this._refreshEventDispatching=!0,this.dispatchEventWith(c.PULL_DOWN_RELEASE),this._refreshEventDispatching=!1):(this._tweenChange.x>t.UIConfig.touchDragSensitivity||this._tweenChange.y>t.UIConfig.touchDragSensitivity)&&(this._refreshEventDispatching=!0,this.dispatchEventWith(c.PULL_UP_RELEASE),this._refreshEventDispatching=!1),this._headerLockedSize>0&&0==h[this._refreshBarAxis])h[this._refreshBarAxis]=this._headerLockedSize,this._tweenChange.x=h.x-this._tweenStart.x,this._tweenChange.y=h.y-this._tweenStart.y;else if(this._footerLockedSize>0&&h[this._refreshBarAxis]==-this._overlapSize[this._refreshBarAxis]){var r=this._overlapSize[this._refreshBarAxis];0==r?r=Math.max(this._contentSize[this._refreshBarAxis]+this._footerLockedSize-this._viewSize[this._refreshBarAxis],0):r+=this._footerLockedSize,h[this._refreshBarAxis]=-r,this._tweenChange.x=h.x-this._tweenStart.x,this._tweenChange.y=h.y-this._tweenStart.y}this._tweenDuration.setTo(o,o)}else{if(this._inertiaDisabled)this._tweenDuration.setTo(o,o);else{var s=this._owner.displayObject.stage.frameRate,a=(egret.getTimer()/1e3-this._lastMoveTime)*s-1;if(a>1){var u=Math.pow(.833,a);this._velocity.x=this._velocity.x*u,this._velocity.y=this._velocity.y*u}this.updateTargetAndDuration(this._tweenStart,h)}if(l.setTo(h.x-this._tweenStart.x,h.y-this._tweenStart.y),this.loopCheckingTarget(h),(this._pageMode||this._snapToItem)&&this.alignPosition(h,!0),this._tweenChange.x=h.x-this._tweenStart.x,this._tweenChange.y=h.y-this._tweenStart.y,0==this._tweenChange.x&&0==this._tweenChange.y)return void this.updateScrollBarVisible();(this._pageMode||this._snapToItem)&&(this.fixDuration("x",l.x),this.fixDuration("y",l.y))}this.startTween(2)},c.prototype.__touchTap=function(t){this._dragged=!1},c.prototype.updateScrollBarPos=function(){this._vtScrollBar&&this._vtScrollBar.setScrollPerc(0==this._overlapSize.y?0:t.ToolSet.clamp(-this._container.y,0,this._overlapSize.y)/this._overlapSize.y),this._hzScrollBar&&this._hzScrollBar.setScrollPerc(0==this._overlapSize.x?0:t.ToolSet.clamp(-this._container.x,0,this._overlapSize.x)/this._overlapSize.x),this.checkRefreshBar()},c.prototype.updateScrollBarVisible=function(){this._vtScrollBar&&(this._viewSize.y<=this._vtScrollBar.minSize||this._vScrollNone?this._vtScrollBar.displayObject.visible=!1:this.updateScrollBarVisible2(this._vtScrollBar)),this._hzScrollBar&&(this._viewSize.x<=this._hzScrollBar.minSize||this._hScrollNone?this._hzScrollBar.displayObject.visible=!1:this.updateScrollBarVisible2(this._hzScrollBar))},c.prototype.updateScrollBarVisible2=function(e){this._scrollBarDisplayAuto&&t.GTween.kill(e,!1,"alpha"),!this._scrollBarDisplayAuto||0!=this._tweening||this._dragged||e.gripDragging?(e.alpha=1,e.displayObject.visible=!0):e.displayObject.visible&&t.GTween.to(1,0,.5).setDelay(.5).onComplete(this.__barTweenComplete,this).setTarget(e,"alpha")},c.prototype.__barTweenComplete=function(t){var e=t.target;e.alpha=1,e.displayObject.visible=!1},c.prototype.getLoopPartSize=function(t,e){return(this._contentSize[e]+("x"==e?this._owner.columnGap:this._owner.lineGap))/t},c.prototype.loopCheckingCurrent=function(){var t=!1;return 1==this._loop&&this._overlapSize.x>0?this._xPos<.001?(this._xPos+=this.getLoopPartSize(2,"x"),t=!0):this._xPos>=this._overlapSize.x&&(this._xPos-=this.getLoopPartSize(2,"x"),t=!0):2==this._loop&&this._overlapSize.y>0&&(this._yPos<.001?(this._yPos+=this.getLoopPartSize(2,"y"),t=!0):this._yPos>=this._overlapSize.y&&(this._yPos-=this.getLoopPartSize(2,"y"),t=!0)),t&&(this._container.x=Math.floor(-this._xPos),this._container.y=Math.floor(-this._yPos)),t},c.prototype.loopCheckingTarget=function(t){1==this._loop&&this.loopCheckingTarget2(t,"x"),2==this._loop&&this.loopCheckingTarget2(t,"y")},c.prototype.loopCheckingTarget2=function(t,e){var i,n;t[e]>0?(i=this.getLoopPartSize(2,e),(n=this._tweenStart[e]-i)<=0&&n>=-this._overlapSize[e]&&(t[e]-=i,this._tweenStart[e]=n)):t[e]<-this._overlapSize[e]&&(i=this.getLoopPartSize(2,e),(n=this._tweenStart[e]+i)<=0&&n>=-this._overlapSize[e]&&(t[e]+=i,this._tweenStart[e]=n))},c.prototype.loopCheckingNewPos=function(e,i){if(0==this._overlapSize[i])return e;var n,o="x"==i?this._xPos:this._yPos,r=!1;return e<.001?(e+=this.getLoopPartSize(2,i))>o&&(n=this.getLoopPartSize(6,i),n=Math.ceil((e-o)/n)*n,o=t.ToolSet.clamp(o+n,0,this._overlapSize[i]),r=!0):e>=this._overlapSize[i]&&(e-=this.getLoopPartSize(2,i))<o&&(n=this.getLoopPartSize(6,i),n=Math.ceil((o-e)/n)*n,o=t.ToolSet.clamp(o-n,0,this._overlapSize[i]),r=!0),r&&("x"==i?this._container.x=-Math.floor(o):this._container.y=-Math.floor(o)),e},c.prototype.alignPosition=function(t,e){if(this._pageMode)t.x=this.alignByPage(t.x,"x",e),t.y=this.alignByPage(t.y,"y",e);else if(this._snapToItem){var i=this._owner.getSnappingPosition(-t.x,-t.y,s);t.x<0&&t.x>-this._overlapSize.x&&(t.x=-i.x),t.y<0&&t.y>-this._overlapSize.y&&(t.y=-i.y)}},c.prototype.alignByPage=function(t,e,i){var n;if(t>0)n=0;else if(t<-this._overlapSize[e])n=Math.ceil(this._contentSize[e]/this._pageSize[e])-1;else{n=Math.floor(-t/this._pageSize[e]);var o=i?t-this._containerPos[e]:t-this._container[e],r=Math.min(this._pageSize[e],this._contentSize[e]-(n+1)*this._pageSize[e]),s=-t-n*this._pageSize[e];Math.abs(o)>this._pageSize[e]?s>.5*r&&n++:s>r*(o<0?.3:.7)&&n++,(t=-n*this._pageSize[e])<-this._overlapSize[e]&&(t=-this._overlapSize[e])}if(i){var a,h=this._tweenStart[e];a=h>0?0:h<-this._overlapSize[e]?Math.ceil(this._contentSize[e]/this._pageSize[e])-1:Math.floor(-h/this._pageSize[e]);var l=Math.floor(-this._containerPos[e]/this._pageSize[e]);Math.abs(n-l)>1&&Math.abs(a-l)<=1&&(t=-(n=n>l?l+1:l-1)*this._pageSize[e])}return t},c.prototype.updateTargetAndDuration=function(t,e){e.x=this.updateTargetAndDuration2(t.x,"x"),e.y=this.updateTargetAndDuration2(t.y,"y")},c.prototype.updateTargetAndDuration2=function(t,e){var i=this._velocity[e],n=0;if(t>0)t=0;else if(t<-this._overlapSize[e])t=-this._overlapSize[e];else{var r=egret.Capabilities.isMobile,s=Math.abs(i)*this._velocityScale;r&&(s*=1136/Math.max(this._owner.displayObject.stage.stageWidth,this._owner.displayObject.stage.stageHeight));var a=0;if(this._pageMode||!r?s>500&&(a=Math.pow((s-500)/500,2)):s>1e3&&(a=Math.pow((s-1e3)/1e3,2)),0!=a)a>1&&(a=1),s*=a,i*=a,this._velocity[e]=i,n=Math.log(60/s)/Math.log(this._decelerationRate)/60,t+=Math.floor(i*n*.4)}return n<o&&(n=o),this._tweenDuration[e]=n,t},c.prototype.fixDuration=function(t,e){if(!(0==this._tweenChange[t]||Math.abs(this._tweenChange[t])>=Math.abs(e))){var i=Math.abs(this._tweenChange[t]/e)*this._tweenDuration[t];i<o&&(i=o),this._tweenDuration[t]=i}},c.prototype.startTween=function(e){this._tweenTime.setTo(0,0),this._tweening=e,t.GTimers.inst.add(1,0,this.tweenUpdate,this),this.updateScrollBarVisible()},c.prototype.killTween=function(){1==this._tweening&&(this._container.x=this._tweenStart.x+this._tweenChange.x,this._container.y=this._tweenStart.y+this._tweenChange.y,this.dispatchEventWith(c.SCROLL)),this._tweening=0,t.GTimers.inst.remove(this.tweenUpdate,this),this.updateScrollBarVisible(),this.dispatchEventWith(c.SCROLL_END)},c.prototype.checkRefreshBar=function(){if(null!=this._header||null!=this._footer){var t=this._container[this._refreshBarAxis];if(this._header)if(t>0){null==this._header.displayObject.parent&&this._maskContainer.addChildAt(this._header.displayObject,0);var e=s;e.setTo(this._header.width,this._header.height),e[this._refreshBarAxis]=t,this._header.setSize(e.x,e.y)}else this._header.displayObject.parent&&this._maskContainer.removeChild(this._header.displayObject);if(this._footer){var i=this._overlapSize[this._refreshBarAxis];t<-i||0==i&&this._footerLockedSize>0?(null==this._footer.displayObject.parent&&this._maskContainer.addChildAt(this._footer.displayObject,0),(e=s).setTo(this._footer.x,this._footer.y),e[this._refreshBarAxis]=i>0?t+this._contentSize[this._refreshBarAxis]:Math.max(Math.min(t+this._viewSize[this._refreshBarAxis],this._viewSize[this._refreshBarAxis]-this._footerLockedSize),this._viewSize[this._refreshBarAxis]-this._contentSize[this._refreshBarAxis]),this._footer.setXY(e.x,e.y),e.setTo(this._footer.width,this._footer.height),e[this._refreshBarAxis]=i>0?-i-t:this._viewSize[this._refreshBarAxis]-this._footer[this._refreshBarAxis],this._footer.setSize(e.x,e.y)):this._footer.displayObject.parent&&this._maskContainer.removeChild(this._footer.displayObject)}}},c.prototype.tweenUpdate=function(e){var i=this.runTween("x"),n=this.runTween("y");return this._container.x=i,this._container.y=n,2==this._tweening&&(this._overlapSize.x>0&&(this._xPos=t.ToolSet.clamp(-i,0,this._overlapSize.x)),this._overlapSize.y>0&&(this._yPos=t.ToolSet.clamp(-n,0,this._overlapSize.y)),this._pageMode&&this.updatePageController()),0==this._tweenChange.x&&0==this._tweenChange.y?(this._tweening=0,t.GTimers.inst.remove(this.tweenUpdate,this),this.loopCheckingCurrent(),this.updateScrollBarPos(),this.updateScrollBarVisible(),this.dispatchEventWith(c.SCROLL),this.dispatchEventWith(c.SCROLL_END)):(this.updateScrollBarPos(),this.dispatchEventWith(c.SCROLL)),!0},c.prototype.runTween=function(e){var i,n,r;if(0!=this._tweenChange[e]){if(this._tweenTime[e]+=t.GTimers.deltaTime/1e3,this._tweenTime[e]>=this._tweenDuration[e])i=this._tweenStart[e]+this._tweenChange[e],this._tweenChange[e]=0;else{var s=(n=this._tweenTime[e],r=this._tweenDuration[e],(n=n/r-1)*n*n+1);i=this._tweenStart[e]+Math.floor(this._tweenChange[e]*s)}var a=0,h=-this._overlapSize[e];if(this._headerLockedSize>0&&this._refreshBarAxis==e&&(a=this._headerLockedSize),this._footerLockedSize>0&&this._refreshBarAxis==e){var l=this._overlapSize[this._refreshBarAxis];0==l?l=Math.max(this._contentSize[this._refreshBarAxis]+this._footerLockedSize-this._viewSize[this._refreshBarAxis],0):l+=this._footerLockedSize,h=-l}2==this._tweening&&this._bouncebackEffect?i>20+a&&this._tweenChange[e]>0||i>a&&0==this._tweenChange[e]?(this._tweenTime[e]=0,this._tweenDuration[e]=o,this._tweenChange[e]=-i+a,this._tweenStart[e]=i):(i<h-20&&this._tweenChange[e]<0||i<h&&0==this._tweenChange[e])&&(this._tweenTime[e]=0,this._tweenDuration[e]=o,this._tweenChange[e]=h-i,this._tweenStart[e]=i):i>a?(i=a,this._tweenChange[e]=0):i<h&&(i=h,this._tweenChange[e]=0)}else i=this._container[e];return i},c.SCROLL="__scroll",c.SCROLL_END="__scrollEnd",c.PULL_DOWN_RELEASE="pullDownRelease",c.PULL_UP_RELEASE="pullUpRelease",c}(egret.EventDispatcher);t.ScrollPane=e;var i=0,n=.5,o=.3,r=.5,s=new egret.Point,a=new egret.Rectangle,h=new egret.Point,l=new egret.Point}(fgui||(fgui={})),function(t){var e=function(){function e(t){this._ownerBaseX=0,this._ownerBaseY=0,this._totalTimes=0,this._totalTasks=0,this._options=0,this._totalDuration=0,this._autoPlayTimes=1,this._autoPlayDelay=0,this._timeScale=1,this._startTime=0,this._endTime=0,this._owner=t,this._items=new Array}return e.prototype.play=function(t,e,i,n,o,r,s){this._play(t,e,i,n,o,r,s,!1)},e.prototype.playReverse=function(t,e,i,n,o){this._play(t,e,i,n,o,0,-1,!0)},e.prototype.changePlayTimes=function(t){this._totalTimes=t},e.prototype.setAutoPlay=function(t,e,i){null==e&&(e=-1),null==i&&(i=0),this._autoPlay!=t&&(this._autoPlay=t,this._autoPlayTimes=e,this._autoPlayDelay=i,this._autoPlay?this._owner.onStage&&this.play(null,null,this._autoPlayTimes,this._autoPlayDelay):this._owner.onStage||this.stop(!1,!0))},e.prototype._play=function(e,i,n,o,s,a,h,l){null==o&&(o=1),null==s&&(s=0),null==a&&(a=0),null==h&&(h=-1),this.stop(!0,!0),this._totalTimes=o,this._reversed=l,this._startTime=a,this._endTime=h,this._playing=!0,this._paused=!1,this._onComplete=e,this._onCompleteParam=n,this._onCompleteCaller=i;for(var c=this._items.length,u=0;u<c;u++){var _=this._items[u];if(_.target?_.target!=this._owner&&_.target.parent!=this._owner&&(_.target=null):_.targetId?_.target=this._owner.getChildById(_.targetId):_.target=this._owner,_.target&&_.type==r.Transition){var p=_.target.getTransition(_.value.transName);if(p==this&&(p=null),p)if(0==_.value.playTimes){var d;for(d=u-1;d>=0;d--){var g=this._items[d];if(g.type==r.Transition&&g.value.trans==p){g.value.stopTime=_.time-g.time;break}}d<0?_.value.stopTime=0:p=null}else _.value.stopTime=-1;_.value.trans=p}}0==s?this.onDelayedPlay():t.GTween.delayedCall(s).onComplete(this.onDelayedPlay,this)},e.prototype.stop=function(e,i){if(null==e&&(e=!0),this._playing){this._playing=!1,this._totalTasks=0,this._totalTimes=0;var n=this._onComplete,o=this._onCompleteParam,r=this._onCompleteCaller;this._onComplete=null,this._onCompleteParam=null,this._onCompleteCaller=null,t.GTween.kill(this);var s=this._items.length;if(this._reversed)for(var a=s-1;a>=0;a--){var h=this._items[a];h.target&&this.stopItem(h,e)}else for(a=0;a<s;a++)(h=this._items[a]).target&&this.stopItem(h,e);i&&null!=n&&n.call(r,o)}},e.prototype.stopItem=function(t,e){if(0!=t.displayLockToken&&(t.target.releaseDisplayLock(t.displayLockToken),t.displayLockToken=0),t.tweener&&(t.tweener.kill(e),t.tweener=null,t.type!=r.Shake||e||(t.target._gearLocked=!0,t.target.setXY(t.target.x-t.value.lastOffsetX,t.target.y-t.value.lastOffsetY),t.target._gearLocked=!1)),t.type==r.Transition){var i=t.value.trans;i&&i.stop(e,!1)}},e.prototype.setPaused=function(e){if(this._playing&&this._paused!=e){this._paused=e;var i=t.GTween.getTween(this);i&&i.setPaused(e);for(var n=this._items.length,o=0;o<n;o++){var s=this._items[o];s.target&&(s.type==r.Transition?s.value.trans&&s.value.trans.setPaused(e):s.type==r.Animation&&(e?(s.value.flag=s.target.getProp(t.ObjectPropID.Playing),s.target.setProp(t.ObjectPropID.Playing,!1)):s.target.setProp(t.ObjectPropID.Playing,s.value.flag)),s.tweener&&s.tweener.setPaused(e))}}},e.prototype.dispose=function(){this._playing&&t.GTween.kill(this);for(var e=this._items.length,i=0;i<e;i++){var n=this._items[i];n.tweener&&(n.tweener.kill(),n.tweener=null),n.target=null,n.hook=null,n.tweenConfig&&(n.tweenConfig.endHook=null)}this._items.length=0,this._playing=!1,this._onComplete=null,this._onCompleteCaller=null,this._onCompleteParam=null},Object.defineProperty(e.prototype,"playing",{get:function(){return this._playing},enumerable:!0,configurable:!0}),e.prototype.setValue=function(t){for(var e=[],i=1;i<arguments.length;i++)e[i-1]=arguments[i];for(var n,o=this._items.length,s=0;s<o;s++){var a=this._items[s];if(a.label==t)n=a.tweenConfig?a.tweenConfig.startValue:a.value;else{if(!a.tweenConfig||a.tweenConfig.endLabel!=t)continue;n=a.tweenConfig.endValue}switch(a.type){case r.XY:case r.Size:case r.Pivot:case r.Scale:case r.Skew:n.b1=!0,n.b2=!0,n.f1=parseFloat(e[0]),n.f2=parseFloat(e[1]);break;case r.Alpha:case r.Rotation:case r.Color:n.f1=parseFloat(e[0]);break;case r.Animation:n.frame=parseInt(e[0]),e.length>1&&(n.playing=e[1]);break;case r.Visible:n.visible=e[0];break;case r.Sound:n.sound=e[0],e.length>1&&(n.volume=parseFloat(e[1]));break;case r.Transition:n.transName=e[0],e.length>1&&(n.playTimes=parseInt(e[1]));break;case r.Shake:n.amplitude=parseFloat(e[0]),e.length>1&&(n.duration=parseFloat(e[1]));break;case r.ColorFilter:n.f1=parseFloat(e[0]),n.f2=parseFloat(e[1]),n.f3=parseFloat(e[2]),n.f4=parseFloat(e[3]);break;case r.Text:case r.Icon:n.text=e[0]}}},e.prototype.setHook=function(t,e,i){for(var n=this._items.length,o=0;o<n;o++){var r=this._items[o];if(r.label==t){r.hook=e,r.hookCaller=i;break}if(r.tweenConfig&&r.tweenConfig.endLabel==t){r.tweenConfig.endHook=e,r.tweenConfig.endHookCaller=i;break}}},e.prototype.clearHooks=function(){for(var t=this._items.length,e=0;e<t;e++){var i=this._items[e];i.hook=null,i.hookCaller=null,i.tweenConfig&&(i.tweenConfig.endHook=null,i.tweenConfig.endHookCaller=null)}},e.prototype.setTarget=function(t,e){for(var i=this._items.length,n=0;n<i;n++){var o=this._items[n];o.label==t&&(o.targetId=e!=this._owner&&e?e.id:"",this._playing?o.targetId.length>0?o.target=this._owner.getChildById(o.targetId):o.target=this._owner:o.target=null)}},e.prototype.setDuration=function(t,e){for(var i=this._items.length,n=0;n<i;n++){var o=this._items[n];o.tweenConfig&&o.label==t&&(o.tweenConfig.duration=e)}},e.prototype.getLabelTime=function(t){for(var e=this._items.length,i=0;i<e;i++){var n=this._items[i];if(n.label==t)return n.time;if(n.tweenConfig&&n.tweenConfig.endLabel==t)return n.time+n.tweenConfig.duration}return Number.NaN},Object.defineProperty(e.prototype,"timeScale",{get:function(){return this._timeScale},set:function(e){if(this._timeScale!=e&&(this._timeScale=e,this._playing))for(var i=this._items.length,n=0;n<i;n++){var o=this._items[n];o.tweener?o.tweener.setTimeScale(e):o.type==r.Transition?o.value.trans&&(o.value.trans.timeScale=e):o.type==r.Animation&&o.target&&o.target.setProp(t.ObjectPropID.TimeScale,e)}},enumerable:!0,configurable:!0}),e.prototype.updateFromRelations=function(t,e,i){var n=this._items.length;if(0!=n)for(var o=0;o<n;o++){var s=this._items[o];s.type==r.XY&&s.targetId==t&&(s.tweenConfig?(s.tweenConfig.startValue.f1+=e,s.tweenConfig.startValue.f2+=i,s.tweenConfig.endValue.f1+=e,s.tweenConfig.endValue.f2+=i):(s.value.f1+=e,s.value.f2+=i))}},e.prototype.onOwnerAddedToStage=function(){this._autoPlay&&!this._playing&&this.play(null,null,null,this._autoPlayTimes,this._autoPlayDelay)},e.prototype.onOwnerRemovedFromStage=function(){0==(this._options&n)&&this.stop(0!=(this._options&o),!1)},e.prototype.onDelayedPlay=function(){if(this.internalPlay(),this._playing=this._totalTasks>0,this._playing){if(0!=(this._options&i))for(var t=this._items.length,e=0;e<t;e++){var n=this._items[e];n.target&&n.target!=this._owner&&(n.displayLockToken=n.target.addDisplayLock())}}else if(null!=this._onComplete){var o=this._onComplete,r=this._onCompleteParam,s=this._onCompleteCaller;this._onComplete=null,this._onCompleteParam=null,this._onCompleteCaller=null,o.call(s,r)}},e.prototype.internalPlay=function(){this._ownerBaseX=this._owner.x,this._ownerBaseY=this._owner.y,this._totalTasks=0;var t,e,i=this._items.length,n=!1;if(this._reversed)for(e=i-1;e>=0;e--)(t=this._items[e]).target&&this.playItem(t);else for(e=0;e<i;e++)(t=this._items[e]).target&&(t.type==r.Animation&&0!=this._startTime&&t.time<=this._startTime?(n=!0,t.value.flag=!1):this.playItem(t));n&&this.skipAnimations()},e.prototype.playItem=function(e){var i;if(e.tweenConfig){if(i=this._reversed?this._totalDuration-e.time-e.tweenConfig.duration:e.time,-1==this._endTime||i<=this._endTime){var n,o;switch(this._reversed?(n=e.tweenConfig.endValue,o=e.tweenConfig.startValue):(n=e.tweenConfig.startValue,o=e.tweenConfig.endValue),e.value.b1=n.b1||o.b1,e.value.b2=n.b2||o.b2,e.type){case r.XY:case r.Size:case r.Scale:case r.Skew:e.tweener=t.GTween.to2(n.f1,n.f2,o.f1,o.f2,e.tweenConfig.duration);break;case r.Alpha:case r.Rotation:e.tweener=t.GTween.to(n.f1,o.f1,e.tweenConfig.duration);break;case r.Color:e.tweener=t.GTween.toColor(n.f1,o.f1,e.tweenConfig.duration);break;case r.ColorFilter:e.tweener=t.GTween.to4(n.f1,n.f2,n.f3,n.f4,o.f1,o.f2,o.f3,o.f4,e.tweenConfig.duration)}e.tweener.setDelay(i).setEase(e.tweenConfig.easeType).setRepeat(e.tweenConfig.repeat,e.tweenConfig.yoyo).setTimeScale(this._timeScale).setTarget(e).onStart(this.onTweenStart,this).onUpdate(this.onTweenUpdate,this).onComplete(this.onTweenComplete,this),this._endTime>=0&&e.tweener.setBreakpoint(this._endTime-i),this._totalTasks++}}else e.type==r.Shake?(i=this._reversed?this._totalDuration-e.time-e.value.duration:e.time,e.value.offsetX=e.value.offsetY=0,e.value.lastOffsetX=e.value.lastOffsetY=0,e.tweener=t.GTween.shake(0,0,e.value.amplitude,e.value.duration).setDelay(i).setTimeScale(this._timeScale).setTarget(e).onUpdate(this.onTweenUpdate,this).onComplete(this.onTweenComplete,this),this._endTime>=0&&e.tweener.setBreakpoint(this._endTime-e.time),this._totalTasks++):(i=this._reversed?this._totalDuration-e.time:e.time)<=this._startTime?(this.applyValue(e),this.callHook(e,!1)):(-1==this._endTime||i<=this._endTime)&&(this._totalTasks++,e.tweener=t.GTween.delayedCall(i).setTimeScale(this._timeScale).setTarget(e).onComplete(this.onDelayedPlayItem,this));null!=e.tweener&&e.tweener.seek(this._startTime)},e.prototype.skipAnimations=function(){for(var e,i,n,o,s,a,h=this._items.length,l=0;l<h;l++)if(!((a=this._items[l]).type!=r.Animation||a.time>this._startTime||(o=a.value).flag)){e=(s=a.target).getProp(t.ObjectPropID.Frame),i=s.getProp(t.ObjectPropID.Playing)?0:-1,n=0;for(var c=l;c<h;c++)(a=this._items[c]).type!=r.Animation||a.target!=s||a.time>this._startTime||((o=a.value).flag=!0,-1!=o.frame?(e=o.frame,i=o.playing?a.time:-1,n=0):o.playing?i<0&&(i=a.time):(i>=0&&(n+=a.time-i),i=-1),this.callHook(a,!1));i>=0&&(n+=this._startTime-i),s.setProp(t.ObjectPropID.Playing,i>=0),s.setProp(t.ObjectPropID.Frame,e),n>0&&s.setProp(t.ObjectPropID.DeltaTime,1e3*n)}},e.prototype.onDelayedPlayItem=function(t){var e=t.target;e.tweener=null,this._totalTasks--,this.applyValue(e),this.callHook(e,!1),this.checkAllComplete()},e.prototype.onTweenStart=function(t){var e,i,n=t.target;n.type!=r.XY&&n.type!=r.Size||(this._reversed?(e=n.tweenConfig.endValue,i=n.tweenConfig.startValue):(e=n.tweenConfig.startValue,i=n.tweenConfig.endValue),n.type==r.XY?n.target!=this._owner?(e.b1?e.b3&&(t.startValue.x=e.f1*this._owner.width):t.startValue.x=n.target.x,e.b2?e.b3&&(t.startValue.y=e.f2*this._owner.height):t.startValue.y=n.target.y,i.b1?i.b3&&(t.endValue.x=i.f1*this._owner.width):t.endValue.x=t.startValue.x,i.b2?i.b3&&(t.endValue.y=i.f2*this._owner.height):t.endValue.y=t.startValue.y):(e.b1||(t.startValue.x=n.target.x-this._ownerBaseX),e.b2||(t.startValue.y=n.target.y-this._ownerBaseY),i.b1||(t.endValue.x=t.startValue.x),i.b2||(t.endValue.y=t.startValue.y)):(e.b1||(t.startValue.x=n.target.width),e.b2||(t.startValue.y=n.target.height),i.b1||(t.endValue.x=t.startValue.x),i.b2||(t.endValue.y=t.startValue.y)),n.tweenConfig.path&&(n.value.b1=n.value.b2=!0,t.setPath(n.tweenConfig.path)));this.callHook(n,!1)},e.prototype.onTweenUpdate=function(t){var e=t.target;switch(e.type){case r.XY:case r.Size:case r.Scale:case r.Skew:e.value.f1=t.value.x,e.value.f2=t.value.y,e.tweenConfig.path&&(e.value.f1+=t.startValue.x,e.value.f2+=t.startValue.y);break;case r.Alpha:case r.Rotation:e.value.f1=t.value.x;break;case r.Color:e.value.f1=t.value.color;break;case r.ColorFilter:e.value.f1=t.value.x,e.value.f2=t.value.y,e.value.f3=t.value.z,e.value.f4=t.value.w;break;case r.Shake:e.value.offsetX=t.deltaValue.x,e.value.offsetY=t.deltaValue.y}this.applyValue(e)},e.prototype.onTweenComplete=function(t){var e=t.target;e.tweener=null,this._totalTasks--,t.allCompleted&&this.callHook(e,!0),this.checkAllComplete()},e.prototype.onPlayTransCompleted=function(t){this._totalTasks--,this.checkAllComplete()},e.prototype.callHook=function(t,e){e?t.tweenConfig&&t.tweenConfig.endHook&&t.tweenConfig.endHook.call(t.tweenConfig.endHookCaller):t.time>=this._startTime&&null!=t.hook&&t.hook.call(t.hookCaller)},e.prototype.checkAllComplete=function(){if(this._playing&&0==this._totalTasks)if(this._totalTimes<0)this.internalPlay();else if(this._totalTimes--,this._totalTimes>0)this.internalPlay();else{this._playing=!1;for(var t=this._items.length,e=0;e<t;e++){var i=this._items[e];i.target&&0!=i.displayLockToken&&(i.target.releaseDisplayLock(i.displayLockToken),i.displayLockToken=0)}if(null!=this._onComplete){var n=this._onComplete,o=this._onCompleteParam,r=this._onCompleteCaller;this._onComplete=null,this._onCompleteParam=null,this._onCompleteCaller=null,n.call(r,o)}}},e.prototype.applyValue=function(e){e.target._gearLocked=!0;var i=e.value;switch(e.type){case r.XY:e.target==this._owner?i.b1&&i.b2?e.target.setXY(i.f1+this._ownerBaseX,i.f2+this._ownerBaseY):i.b1?e.target.x=i.f1+this._ownerBaseX:e.target.y=i.f2+this._ownerBaseY:i.b3?i.b1&&i.b2?e.target.setXY(i.f1*this._owner.width,i.f2*this._owner.height):i.b1?e.target.x=i.f1*this._owner.width:i.b2&&(e.target.y=i.f2*this._owner.height):i.b1&&i.b2?e.target.setXY(i.f1,i.f2):i.b1?e.target.x=i.f1:i.b2&&(e.target.y=i.f2);break;case r.Size:i.b1||(i.f1=e.target.width),i.b2||(i.f2=e.target.height),e.target.setSize(i.f1,i.f2);break;case r.Pivot:e.target.setPivot(i.f1,i.f2,e.target.pivotAsAnchor);break;case r.Alpha:e.target.alpha=i.f1;break;case r.Rotation:e.target.rotation=i.f1;break;case r.Scale:e.target.setScale(i.f1,i.f2);break;case r.Skew:e.target.setSkew(i.f1,i.f2);break;case r.Color:e.target.setProp(t.ObjectPropID.Color,i.f1);break;case r.Animation:i.frame>=0&&e.target.setProp(t.ObjectPropID.Frame,i.frame),e.target.setProp(t.ObjectPropID.Playing,i.playing),e.target.setProp(t.ObjectPropID.TimeScale,this._timeScale);break;case r.Visible:e.target.visible=i.visible;break;case r.Transition:if(this._playing){var n=i.trans;if(n){this._totalTasks++;var o=this._startTime>e.time?this._startTime-e.time:0,s=this._endTime>=0?this._endTime-e.time:-1;i.stopTime>=0&&(s<0||s>i.stopTime)&&(s=i.stopTime),n.timeScale=this._timeScale,n._play(this.onPlayTransCompleted,this,e,i.playTimes,0,o,s,this._reversed)}}break;case r.Sound:if(this._playing&&e.time>=this._startTime){if(!i.audioClip){var a=t.UIPackage.getItemByURL(i.sound);a&&(i.audioClip=a.owner.getItemAsset(a))}i.audioClip&&t.GRoot.inst.playOneShotSound(i.audioClip,i.volume)}break;case r.Shake:e.target.setXY(e.target.x-i.lastOffsetX+i.offsetX,e.target.y-i.lastOffsetY+i.offsetY),i.lastOffsetX=i.offsetX,i.lastOffsetY=i.offsetY;break;case r.ColorFilter:t.ToolSet.setColorFilter(e.target.displayObject,[i.f1,i.f2,i.f3,i.f4]);break;case r.Text:e.target.text=i.text;break;case r.Icon:e.target.icon=i.text}e.target._gearLocked=!1},e.prototype.setup=function(e){this.name=e.readS(),this._options=e.readInt(),this._autoPlay=e.readBool(),this._autoPlayTimes=e.readInt(),this._autoPlayDelay=e.readFloat();for(var i=e.readShort(),n=0;n<i;n++){var o=e.readShort(),r=e.position;e.seek(r,0);var h=new s(e.readByte());this._items[n]=h,h.time=e.readFloat();var l=e.readShort();if(h.targetId=l<0?"":this._owner.getChildAt(l).id,h.label=e.readS(),e.readBool()){if(e.seek(r,1),h.tweenConfig=new a,h.tweenConfig.duration=e.readFloat(),h.time+h.tweenConfig.duration>this._totalDuration&&(this._totalDuration=h.time+h.tweenConfig.duration),h.tweenConfig.easeType=e.readByte(),h.tweenConfig.repeat=e.readInt(),h.tweenConfig.yoyo=e.readBool(),h.tweenConfig.endLabel=e.readS(),e.seek(r,2),this.decodeValue(h,e,h.tweenConfig.startValue),e.seek(r,3),this.decodeValue(h,e,h.tweenConfig.endValue),e.version>=2){var c=e.readInt();if(c>0){h.tweenConfig.path=new t.GPath;for(var u=new Array,_=0;_<c;_++){var p=e.readByte();switch(p){case t.CurveType.Bezier:u.push(t.GPathPoint.newBezierPoint(e.readFloat(),e.readFloat(),e.readFloat(),e.readFloat()));break;case t.CurveType.CubicBezier:u.push(t.GPathPoint.newCubicBezierPoint(e.readFloat(),e.readFloat(),e.readFloat(),e.readFloat(),e.readFloat(),e.readFloat()));break;default:u.push(t.GPathPoint.newPoint(e.readFloat(),e.readFloat(),p))}}h.tweenConfig.path.create(u)}}}else h.time>this._totalDuration&&(this._totalDuration=h.time),e.seek(r,2),this.decodeValue(h,e,h.value);e.position=r+o}},e.prototype.decodeValue=function(t,e,i){switch(t.type){case r.XY:case r.Size:case r.Pivot:case r.Skew:i.b1=e.readBool(),i.b2=e.readBool(),i.f1=e.readFloat(),i.f2=e.readFloat(),e.version>=2&&t.type==r.XY&&(i.b3=e.readBool());break;case r.Alpha:case r.Rotation:i.f1=e.readFloat();break;case r.Scale:i.f1=e.readFloat(),i.f2=e.readFloat();break;case r.Color:i.f1=e.readColor();break;case r.Animation:i.playing=e.readBool(),i.frame=e.readInt();break;case r.Visible:i.visible=e.readBool();break;case r.Sound:i.sound=e.readS(),i.volume=e.readFloat();break;case r.Transition:i.transName=e.readS(),i.playTimes=e.readInt();break;case r.Shake:i.amplitude=e.readFloat(),i.duration=e.readFloat();break;case r.ColorFilter:i.f1=e.readFloat(),i.f2=e.readFloat(),i.f3=e.readFloat(),i.f4=e.readFloat();break;case r.Text:case r.Icon:i.text=e.readS()}},e}();t.Transition=e;var i=1,n=2,o=4,r=function(){function t(){}return t.XY=0,t.Size=1,t.Scale=2,t.Pivot=3,t.Alpha=4,t.Rotation=5,t.Color=6,t.Animation=7,t.Visible=8,t.Sound=9,t.Transition=10,t.Shake=11,t.ColorFilter=12,t.Skew=13,t.Text=14,t.Icon=15,t.Unknown=16,t}(),s=function(){return function(t){this.type=t,this.value={},this.displayLockToken=0}}(),a=function(){return function(){this.duration=0,this.repeat=0,this.easeType=t.EaseType.QuadOut,this.startValue={b1:!0,b2:!0},this.endValue={b1:!0,b2:!0}}}()}(fgui||(fgui={})),function(t){var e=function(){function e(){}return e.loadFromXML=function(t){var i={};e.strings=i;for(var n=egret.XML.parse(t).children,o=n.length,r=0;r<o;r++){var s=n[r];if("string"==s.name){var a=s.attributes.name,h=s.children.length>0?s.children[0].text:"",l=a.indexOf("-");if(-1==l)continue;var c=a.substr(0,l),u=a.substr(l+1),_=i[c];_||(_={},i[c]=_),_[u]=h}}},e.translateComponent=function(i){if(null!=e.strings){var n=e.strings[i.owner.id+i.id];if(null!=n){var o,r,s,a,h,l,c,u,_,p=i.rawData;p.seek(0,2);var d=p.readShort();for(h=0;h<d;h++){c=p.readShort(),u=p.position,p.seek(u,0);var g=p.readByte(),f=g;p.skip(4),o=p.readS(),f==t.ObjectType.Component&&p.seek(u,6)&&(f=p.readByte()),p.seek(u,1),null!=(r=n[o+"-tips"])&&p.writeS(r),p.seek(u,2);var y=p.readShort();for(l=0;l<y;l++){if(s=p.readShort(),s+=p.position,6==p.readByte()){for(p.skip(2),_=p.readShort(),b=0;b<_;b++)null!=p.readS()&&(null!=(r=n[o+"-texts_"+b])?p.writeS(r):p.skip(2));p.readBool()&&null!=(r=n[o+"-texts_def"])&&p.writeS(r)}if(g==t.ObjectType.Component&&p.version>=2){p.seek(u,4),p.skip(2),p.skip(4*p.readShort());for(var m=p.readShort(),b=0;b<m;b++){var v=p.readS();0==p.readShort()&&null!=(r=n[o+"-cp-"+v])?p.writeS(r):p.skip(2)}}p.position=s}switch(f){case t.ObjectType.Text:case t.ObjectType.RichText:case t.ObjectType.InputText:null!=(r=n[o])&&(p.seek(u,6),p.writeS(r)),null!=(r=n[o+"-prompt"])&&(p.seek(u,4),p.writeS(r));break;case t.ObjectType.List:case t.ObjectType.Tree:for(p.seek(u,8),p.skip(2),a=p.readShort(),l=0;l<a;l++){if(s=p.readShort(),s+=p.position,p.skip(2),f==t.ObjectType.Tree&&p.skip(2),null!=(r=n[o+"-"+l])?p.writeS(r):p.skip(2),null!=(r=n[o+"-"+l+"-0"])?p.writeS(r):p.skip(2),p.version>=2){p.skip(6),p.skip(4*p.readUnsignedShort());for(m=p.readUnsignedShort(),b=0;b<m;b++){v=p.readS();0==p.readUnsignedShort()&&null!=(r=n[o+"-"+l+"-"+v])?p.writeS(r):p.skip(2)}}p.position=s}break;case t.ObjectType.Label:p.seek(u,6)&&p.readByte()==f&&(null!=(r=n[o])?p.writeS(r):p.skip(2),p.skip(2),p.readBool()&&p.skip(4),p.skip(4),p.readBool()&&null!=(r=n[o+"-prompt"])&&p.writeS(r));break;case t.ObjectType.Button:p.seek(u,6)&&p.readByte()==f&&(null!=(r=n[o])?p.writeS(r):p.skip(2),null!=(r=n[o+"-0"])&&p.writeS(r));break;case t.ObjectType.ComboBox:if(p.seek(u,6)&&p.readByte()==f){for(a=p.readShort(),l=0;l<a;l++)s=p.readShort(),s+=p.position,null!=(r=n[o+"-"+l])&&p.writeS(r),p.position=s;null!=(r=n[o])&&p.writeS(r)}}p.position=u+c}}}},e}();t.TranslationHelper=e}(fgui||(fgui={})),function(t){var e=function(){function e(){}return e.defaultFont="SimSun",e.modalLayerColor=3355443,e.modalLayerAlpha=.2,e.buttonSoundVolumeScale=1,e.defaultScrollStep=25,e.defaultScrollDecelerationRate=.967,e.defaultScrollBarDisplay=t.ScrollBarDisplayType.Visible,e.defaultScrollTouchEffect=!0,e.defaultScrollBounceEffect=!0,e.defaultComboBoxVisibleItemCount=10,e.touchScrollSensitivity=20,e.touchDragSensitivity=10,e.clickDragSensitivity=2,e.bringWindowToFrontOnClick=!0,e.frameTimeForAsyncUIConstruction=2,e}();t.UIConfig=e}(fgui||(fgui={})),function(t){var e=function(){function e(){}return e.setExtension=function(i,n){if(null==i)throw"Invaild url: "+i;var o=t.UIPackage.getItemByURL(i);o&&(o.extensionType=n),e.extensions[i]=n},e.setPackageItemExtension=function(t,i){e.setExtension(t,i)},e.setLoaderExtension=function(t){e.loaderType=t},e.resolvePackageItemExtension=function(t){var i=e.extensions["ui://"+t.owner.id+t.id];i||(i=e.extensions["ui://"+t.owner.name+"/"+t.name]),i&&(t.extensionType=i)},e.newObject=function(i,n){var o;if("number"==typeof i)switch(i){case t.ObjectType.Image:return new t.GImage;case t.ObjectType.MovieClip:return new t.GMovieClip;case t.ObjectType.Component:return new t.GComponent;case t.ObjectType.Text:return new t.GTextField;case t.ObjectType.RichText:return new t.GRichTextField;case t.ObjectType.InputText:return new t.GTextInput;case t.ObjectType.Group:return new t.GGroup;case t.ObjectType.List:return new t.GList;case t.ObjectType.Graph:return new t.GGraph;case t.ObjectType.Loader:return e.loaderType?new e.loaderType:new t.GLoader;case t.ObjectType.Button:return new t.GButton;case t.ObjectType.Label:return new t.GLabel;case t.ObjectType.ProgressBar:return new t.GProgressBar;case t.ObjectType.Slider:return new t.GSlider;case t.ObjectType.ScrollBar:return new t.GScrollBar;case t.ObjectType.ComboBox:return new t.GComboBox;case t.ObjectType.Tree:return new t.GTree;case t.ObjectType.Loader3D:return new t.GLoader3D;default:return null}else(o=i.type==t.PackageItemType.Component?n?new n:i.extensionType?new i.extensionType:e.newObject(i.objectType):e.newObject(i.objectType))&&(o.packageItem=i);return o},e.extensions={},e}();t.UIObjectFactory=e}(fgui||(fgui={})),function(t){var e=function(){function e(){this._items=[],this._itemsById={},this._itemsByName={},this._sprites={},this._dependencies=[],this._branches=[],this._branchIndex=-1}return Object.defineProperty(e,"branch",{get:function(){return e._branch},set:function(t){for(var i in e._branch=t,e._instById){var n=e._instById[i];n._branches&&(n._branchIndex=n._branches.indexOf(t))}},enumerable:!0,configurable:!0}),e.getVar=function(t){return e._vars[t]},e.setVar=function(t,i){e._vars[t]=i},e.getById=function(t){return e._instById[t]},e.getByName=function(t){return e._instByName[t]},e.loadPackage=function(n){return __awaiter(this,void 0,void 0,function(){var o=this;return __generator(this,function(r){return[2,new Promise(function(r){return __awaiter(o,void 0,void 0,function(){var o,s,a,h,l,c;return __generator(this,function(u){switch(u.label){case 0:return(o=e._instById[n])?(r(o),[2]):[4,RES.getResAsync(i(n,"fui"))];case 1:for(s=u.sent(),(o=new e)._resKey=n,o.loadPackage(new t.ByteBuffer(s)),a=o._items.length,h=[],l=0;l<a;l++)(c=o._items[l]).type!=t.PackageItemType.Atlas&&c.type!=t.PackageItemType.Sound||h.push(RES.getResAsync(c.file));return h.length>0?[4,Promise.all(h)]:[3,3];case 2:u.sent(),u.label=3;case 3:return e._instById[o.id]=o,e._instByName[o.name]=o,e._instById[o._resKey]=o,r(o),[2]}})})})]})})},e.addPackage=function(i,n){if(!n&&!(n=RES.getRes(i)))throw"Resource '"+i+"' not found, please check default.res.json!";var o=new e;return o._resKey=i,o.loadPackage(new t.ByteBuffer(n)),e._instById[o.id]=o,e._instByName[o.name]=o,e._instById[i]=o,o},e.removePackage=function(t){var i=e._instById[t];if(i||(i=e._instByName[t]),!i)throw new Error("unknown package: "+t);i.dispose(),delete e._instById[i.id],delete e._instByName[i.name],delete e._instById[i._resKey],null!=i._customId&&delete e._instById[i._customId]},e.createObject=function(t,i,n){var o=e.getByName(t);return o?o.createObject(i,n):null},e.createObjectFromURL=function(t,i){var n=e.getItemByURL(t);return n?n.owner.internalCreateObject(n,i):null},e.getItemURL=function(t,i){var n=e.getByName(t);if(!n)return null;var o=n._itemsByName[i];return o?"ui://"+n.id+o.id:null},e.getItemByURL=function(t){var i=t.indexOf("//");if(-1==i)return null;var n=t.indexOf("/",i+2);if(-1==n){if(t.length>13){var o=t.substr(5,8),r=e.getById(o);if(null!=r){var s=t.substr(13);return r.getItemById(s)}}}else{var a=t.substr(i+2,n-i-2);if(null!=(r=e.getByName(a))){var h=t.substr(n+1);return r.getItemByName(h)}}return null},e.normalizeURL=function(t){if(null==t)return null;var i=t.indexOf("//");if(-1==i)return null;var n=t.indexOf("/",i+2);if(-1==n)return t;var o=t.substr(i+2,n-i-2),r=t.substr(n+1);return e.getItemURL(o,r)},e.setStringsSource=function(e){t.TranslationHelper.loadFromXML(e)},e.prototype.loadPackage=function(n){if(1179080009!=n.readUnsignedInt())throw"FairyGUI: old package format found in '"+this._resKey+"'";n.version=n.readInt();var o=n.readBool();if(this._id=n.readUTF(),this._name=n.readUTF(),n.skip(20),o){var r=new Uint8Array(n.buffer,n.position,n.length-n.position),s=new Zlib.RawInflate(r),a=new t.ByteBuffer(s.decompress());a.version=n.version,n=a}var h,l,c,u,_,p=n.version>=2,d=n.position;n.seek(d,4),h=n.readInt();var g,f=new Array(h);for(f.reduceRight,l=0;l<h;l++)f[l]=n.readUTF();for(n.stringTable=f,n.seek(d,0),h=n.readShort(),l=0;l<h;l++)this._dependencies.push({id:n.readS(),name:n.readS()});p&&((h=n.readShort())>0&&(this._branches=n.readSArray(h),e._branch&&(this._branchIndex=this._branches.indexOf(e._branch))),_=h>0),n.seek(d,1);var y=this._resKey,m=y.lastIndexOf("/"),b=-1==m?"":y.substr(0,m+1);for(y+="_",h=n.readShort(),l=0;l<h;l++){switch(c=n.readInt(),c+=n.position,(g=new t.PackageItem).owner=this,g.type=n.readByte(),g.id=n.readS(),g.name=n.readS(),n.readS(),g.file=n.readS(),n.readBool(),g.width=n.readInt(),g.height=n.readInt(),g.type){case t.PackageItemType.Image:g.objectType=t.ObjectType.Image;var v=n.readByte();1==v?(g.scale9Grid=new egret.Rectangle,g.scale9Grid.x=n.readInt(),g.scale9Grid.y=n.readInt(),g.scale9Grid.width=n.readInt(),g.scale9Grid.height=n.readInt(),g.tileGridIndice=n.readInt()):2==v&&(g.scaleByTile=!0),g.smoothing=n.readBool();break;case t.PackageItemType.MovieClip:g.smoothing=n.readBool(),g.objectType=t.ObjectType.MovieClip,g.rawData=n.readBuffer();break;case t.PackageItemType.Font:g.rawData=n.readBuffer();break;case t.PackageItemType.Component:var w=n.readByte();g.objectType=w>0?w:t.ObjectType.Component,g.rawData=n.readBuffer(),t.UIObjectFactory.resolvePackageItemExtension(g);break;case t.PackageItemType.Atlas:case t.PackageItemType.Sound:case t.PackageItemType.Misc:var C=g.file.lastIndexOf(".");g.file=y+(-1==C?g.file:i(g.file.substring(0,C),g.file.substring(C+1)));break;case t.PackageItemType.Spine:case t.PackageItemType.DragonBones:var S=g.file.lastIndexOf(".");g.file=b+(-1==S?g.file:g.file.substring(0,S)),g.skeletonAnchor=new egret.Point,g.skeletonAnchor.x=n.readFloat(),g.skeletonAnchor.y=n.readFloat()}if(p){(u=n.readS())&&(g.name=u+"/"+g.name);var x=n.readUnsignedByte();x>0&&(_?g.branches=n.readSArray(x):this._itemsById[n.readS()]=g);var T=n.readUnsignedByte();T>0&&(g.highResolution=n.readSArray(T))}this._items.push(g),this._itemsById[g.id]=g,null!=g.name&&(this._itemsByName[g.name]=g),n.position=c}for(n.seek(d,2),h=n.readShort(),l=0;l<h;l++){c=n.readShort(),c+=n.position;var I=n.readS(),P={atlas:g=this._itemsById[n.readS()],rect:new egret.Rectangle,offset:new egret.Point,originalSize:new egret.Point};P.rect.x=n.readInt(),P.rect.y=n.readInt(),P.rect.width=n.readInt(),P.rect.height=n.readInt(),P.rotated=n.readBool(),p&&n.readBool()?(P.offset.x=n.readInt(),P.offset.y=n.readInt(),P.originalSize.x=n.readInt(),P.originalSize.y=n.readInt()):(P.originalSize.x=P.rect.width,P.originalSize.y=P.rect.height),this._sprites[I]=P,n.position=c}if(n.seek(d,3))for(h=n.readShort(),l=0;l<h;l++)c=n.readInt(),c+=n.position,(g=this._itemsById[n.readS()])&&g.type==t.PackageItemType.Image&&(g.pixelHitTestData=new t.PixelHitTestData,g.pixelHitTestData.load(n)),n.position=c},e.prototype.dispose=function(){for(var e=this._items.length,i=0;i<e;i++){var n=this._items[i];n.type==t.PackageItemType.Atlas?RES.destroyRes(n.file,!1):(n.type,t.PackageItemType.Sound)}},Object.defineProperty(e.prototype,"id",{get:function(){return this._id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"name",{get:function(){return this._name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"customId",{get:function(){return this._customId},set:function(t){null!=this._customId&&delete e._instById[this._customId],this._customId=t,null!=this._customId&&(e._instById[this._customId]=this)},enumerable:!0,configurable:!0}),e.prototype.createObject=function(t,e){var i=this._itemsByName[t];return i?this.internalCreateObject(i,e):null},e.prototype.internalCreateObject=function(i,n){var o=t.UIObjectFactory.newObject(i,n);return null==o?null:(e._constructing++,o.constructFromResource(),e._constructing--,o)},e.prototype.getItemById=function(t){return this._itemsById[t]},e.prototype.getItemByName=function(t){return this._itemsByName[t]},e.prototype.getItemAssetByName=function(t){var e=this._itemsByName[t];if(null==e)throw"Resource not found -"+t;return this.getItemAsset(e)},e.prototype.getItemAsset=function(e){switch(e.type){case t.PackageItemType.Image:if(!e.decoded){e.decoded=!0;var i=this._sprites[e.id];if(i){var n=this.getItemAsset(i.atlas);e.asset=new egret.Texture,e.asset.bitmapData=n.bitmapData,e.asset.$initData(n.$bitmapX+i.rect.x,n.$bitmapY+i.rect.y,i.rect.width,i.rect.height,i.offset.x,i.offset.y,i.originalSize.x,i.originalSize.y,n.$sourceWidth,n.$sourceHeight,i.rotated)}}return e.asset;case t.PackageItemType.Atlas:case t.PackageItemType.Sound:return e.decoded||(e.decoded=!0,e.asset=RES.getRes(e.file),e.asset||console.log("Resource '"+e.file+"' not found, please check default.res.json!")),e.asset;case t.PackageItemType.Font:return e.decoded||(e.decoded=!0,this.loadFont(e)),e.bitmapFont;case t.PackageItemType.MovieClip:return e.decoded||(e.decoded=!0,this.loadMovieClip(e)),e.frames;case t.PackageItemType.Misc:return e.file?RES.getRes(e.file):null;default:return null}},e.prototype.getItemAssetAsync=function(e,i){if(e.decoded)i(null,e);else if(e.loading)e.loading.push(i);else switch(e.type){case t.PackageItemType.DragonBones:e.loading=[i],this.loadDragonBones(e);break;default:this.getItemAsset(e),i(null,e)}},e.prototype.loadMovieClip=function(t){var e=t.rawData;e.seek(0,0),t.interval=e.readInt(),t.swing=e.readBool(),t.repeatDelay=e.readInt(),e.seek(0,1);var i,n,o,r,s=e.readShort();t.frames=Array(s);for(var a=0;a<s;a++){var h=e.readShort();h+=e.position;var l={};if(o=e.readInt(),r=e.readInt(),e.readInt(),e.readInt(),l.addDelay=e.readInt(),null!=(i=e.readS())&&null!=(n=this._sprites[i])){var c=this.getItemAsset(n.atlas);l.texture=new egret.Texture,l.texture.bitmapData=c.bitmapData,l.texture.$initData(c.$bitmapX+n.rect.x,c.$bitmapY+n.rect.y,n.rect.width,n.rect.height,o,r,t.width,t.height,c.$sourceWidth,c.$sourceHeight,n.rotated)}t.frames[a]=l,e.position=h}},e.prototype.loadFont=function(e){var i=new t.BitmapFont;e.bitmapFont=i;var n=e.rawData;n.seek(0,0),i.ttf=n.readBool(),i.tint=n.readBool(),i.resizable=n.readBool(),n.readBool(),i.size=n.readInt();var o,r,s=n.readInt(),a=n.readInt(),h=this._sprites[e.id];h&&(o=this.getItemAsset(h.atlas)),n.seek(0,1);for(var l=n.readInt(),c=0;c<l;c++){var u=n.readShort();u+=n.position,r={};var _=n.readChar();i.glyphs[_]=r;var p=n.readS(),d=n.readInt(),g=n.readInt();if(r.x=n.readInt(),r.y=n.readInt(),r.width=n.readInt(),r.height=n.readInt(),r.advance=n.readInt(),r.channel=n.readByte(),1==r.channel?r.channel=3:2==r.channel?r.channel=2:3==r.channel&&(r.channel=1),i.ttf)r.texture=new egret.Texture,r.texture.bitmapData=o.bitmapData,r.texture.$initData(o.$bitmapX+d+h.rect.x,o.$bitmapY+g+h.rect.y,r.width,r.height,h.offset.x,h.offset.y,h.originalSize.x,h.originalSize.y,o.$sourceWidth,o.$sourceHeight,h.rotated),r.lineHeight=a;else{var f=this._itemsById[p];f&&(this.getItemAsset(f),r.width=f.width,r.height=f.height,r.texture=f.asset),0==r.advance&&(r.advance=0==s?r.x+r.width:s),r.lineHeight=r.y<0?r.height:r.y+r.height,r.lineHeight<i.size&&(r.lineHeight=i.size)}n.position=u}},e.prototype.loadDragonBones=function(t){var e=i(t.file,["json","dbbin"]),n=t.file.replace("_ske","_tex"),o=i(n,"json"),r=i(n,"png"),s=RES.getResAsync(e),a=RES.getResAsync(o),h=RES.getResAsync(r);Promise.all([s,a,h]).then(function(e){var i=dragonBones.EgretFactory.factory;t.asset=i.parseDragonBonesData(e[0]),t.atlasAsset=i.parseTextureAtlasData(e[1],e[2]),t.armatureName=t.asset.armatureNames[0];var n=t.loading;delete t.loading,n.forEach(function(e){return e(null,t)})}).catch(function(e){var i=t.loading;delete t.loading,i.forEach(function(i){return i(e,t)})})},e._constructing=0,e._instById={},e._instByName={},e._branch="",e._vars={},e}();function i(t,e){if(Array.isArray(e)){for(var i=0;i<e.length;i++){var n=t+"_"+e[i];if(RES.hasRes(n))return n}return t}n=t+"_"+e;return RES.hasRes(n)?n:t}t.UIPackage=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i._requestingCmd=0,i._uiSources=new Array,i.bringToFontOnClick=t.UIConfig.bringWindowToFrontOnClick,i.displayObject.addEventListener(egret.Event.ADDED_TO_STAGE,i.__onShown,i),i.displayObject.addEventListener(egret.Event.REMOVED_FROM_STAGE,i.__onHidden,i),i.displayObject.addEventListener(egret.TouchEvent.TOUCH_BEGIN,i.__mouseDown,i,!0),i}return __extends(i,e),i.prototype.addUISource=function(t){this._uiSources.push(t)},Object.defineProperty(i.prototype,"contentPane",{get:function(){return this._contentPane},set:function(e){this._contentPane!=e&&(this._contentPane&&this.removeChild(this._contentPane),this._contentPane=e,this._contentPane&&(this.addChild(this._contentPane),this.setSize(this._contentPane.width,this._contentPane.height),this._contentPane.addRelation(this,t.RelationType.Size),this._frame=this._contentPane.getChild("frame"),this._frame&&(this.closeButton=this._frame.getChild("closeButton"),this.dragArea=this._frame.getChild("dragArea"),this.contentArea=this._frame.getChild("contentArea"))))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"frame",{get:function(){return this._frame},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"closeButton",{get:function(){return this._closeButton},set:function(t){this._closeButton&&this._closeButton.removeClickListener(this.closeEventHandler,this),this._closeButton=t,this._closeButton&&this._closeButton.addClickListener(this.closeEventHandler,this)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"dragArea",{get:function(){return this._dragArea},set:function(e){this._dragArea!=e&&(this._dragArea&&(this._dragArea.draggable=!1,this._dragArea.removeEventListener(t.DragEvent.DRAG_START,this.__dragStart,this)),this._dragArea=e,this._dragArea&&(this._dragArea instanceof t.GGraph&&null==this._dragArea.displayObject&&this._dragArea.asGraph.drawRect(0,0,0,0,0),this._dragArea.draggable=!0,this._dragArea.addEventListener(t.DragEvent.DRAG_START,this.__dragStart,this)))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"contentArea",{get:function(){return this._contentArea},set:function(t){this._contentArea=t},enumerable:!0,configurable:!0}),i.prototype.show=function(){t.GRoot.inst.showWindow(this)},i.prototype.showOn=function(t){t.showWindow(this)},i.prototype.hide=function(){this.isShowing&&this.doHideAnimation()},i.prototype.hideImmediately=function(){var e=this.parent instanceof t.GRoot?this.parent:null;e||(e=t.GRoot.inst),e.hideWindowImmediately(this)},i.prototype.centerOn=function(e,i){this.setXY(Math.round((e.width-this.width)/2),Math.round((e.height-this.height)/2)),i&&(this.addRelation(e,t.RelationType.Center_Center),this.addRelation(e,t.RelationType.Middle_Middle))},i.prototype.toggleStatus=function(){this.isTop?this.hide():this.show()},Object.defineProperty(i.prototype,"isShowing",{get:function(){return null!=this.parent},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"isTop",{get:function(){return null!=this.parent&&this.parent.getChildIndex(this)==this.parent.numChildren-1},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"modal",{get:function(){return this._modal},set:function(t){this._modal=t},enumerable:!0,configurable:!0}),i.prototype.bringToFront=function(){this.root.bringToFront(this)},i.prototype.showModalWait=function(e){null!=e&&(this._requestingCmd=e),t.UIConfig.windowModalWaiting&&(this._modalWaitPane||(this._modalWaitPane=t.UIPackage.createObjectFromURL(t.UIConfig.windowModalWaiting)),this.layoutModalWaitPane(),this.addChild(this._modalWaitPane))},i.prototype.layoutModalWaitPane=function(){if(this._contentArea){var t=this._frame.localToGlobal();t=this.globalToLocal(t.x,t.y,t),this._modalWaitPane.setXY(t.x+this._contentArea.x,t.y+this._contentArea.y),this._modalWaitPane.setSize(this._contentArea.width,this._contentArea.height)}else this._modalWaitPane.setSize(this.width,this.height)},i.prototype.closeModalWait=function(t){return(null==t||0==t||this._requestingCmd==t)&&(this._requestingCmd=0,this._modalWaitPane&&null!=this._modalWaitPane.parent&&this.removeChild(this._modalWaitPane),!0)},Object.defineProperty(i.prototype,"modalWaiting",{get:function(){return this._modalWaitPane&&null!=this._modalWaitPane.parent},enumerable:!0,configurable:!0}),i.prototype.init=function(){if(!this._inited&&!this._loading)if(this._uiSources.length>0){this._loading=!1;for(var t=this._uiSources.length,e=0;e<t;e++){var i=this._uiSources[e];i.loaded||(i.load(this.__uiLoadComplete,this),this._loading=!0)}this._loading||this._init()}else this._init()},i.prototype.onInit=function(){},i.prototype.onShown=function(){},i.prototype.onHide=function(){},i.prototype.doShowAnimation=function(){this.onShown()},i.prototype.doHideAnimation=function(){this.hideImmediately()},i.prototype.__uiLoadComplete=function(){for(var t=this._uiSources.length,e=0;e<t;e++){if(!this._uiSources[e].loaded)return}this._loading=!1,this._init()},i.prototype._init=function(){this._inited=!0,this.onInit(),this.isShowing&&this.doShowAnimation()},i.prototype.dispose=function(){this.displayObject.removeEventListener(egret.Event.ADDED_TO_STAGE,this.__onShown,this),this.displayObject.removeEventListener(egret.Event.REMOVED_FROM_STAGE,this.__onHidden,this),this.parent&&this.hideImmediately(),e.prototype.dispose.call(this)},i.prototype.closeEventHandler=function(t){this.hide()},i.prototype.__onShown=function(t){this._inited?this.doShowAnimation():this.init()},i.prototype.__onHidden=function(t){this.closeModalWait(),this.onHide()},i.prototype.__mouseDown=function(t){this.isShowing&&this.bringToFontOnClick&&this.bringToFront()},i.prototype.__dragStart=function(t){t.preventDefault(),this.startDrag(t.touchPointID,t.stageX,t.stageY)},i}(t.GComponent);t.Window=e}(fgui||(fgui={})),function(t){var e=function(){function e(){}return e.createAction=function(e){switch(e){case 0:return new t.PlayTransitionAction;case 1:return new t.ChangePageAction}return null},e.prototype.run=function(t,e,i){null!=this.fromPage&&0!=this.fromPage.length&&-1==this.fromPage.indexOf(e)||null!=this.toPage&&0!=this.toPage.length&&-1==this.toPage.indexOf(i)?this.leave(t):this.enter(t)},e.prototype.enter=function(t){},e.prototype.leave=function(t){},e.prototype.setup=function(t){var e,i;for(e=t.readShort(),this.fromPage=[],i=0;i<e;i++)this.fromPage[i]=t.readS();for(e=t.readShort(),this.toPage=[],i=0;i<e;i++)this.toPage[i]=t.readS()},e}();t.ControllerAction=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){return e.call(this)||this}return __extends(i,e),i.prototype.enter=function(e){if(this.controllerName){var i;if(this.objectId){var n=e.parent.getChildById(this.objectId);if(!(n instanceof t.GComponent))return;i=n}else i=e.parent;if(i){var o=i.getController(this.controllerName);o&&o!=e&&!o.changing&&("~1"==this.targetPage?e.selectedIndex<o.pageCount&&(o.selectedIndex=e.selectedIndex):"~2"==this.targetPage?o.selectedPage=e.selectedPage:o.selectedPageId=this.targetPage)}}},i.prototype.setup=function(t){e.prototype.setup.call(this,t),this.objectId=t.readS(),this.controllerName=t.readS(),this.targetPage=t.readS()},i}(t.ControllerAction);t.ChangePageAction=e}(fgui||(fgui={})),function(t){var e=function(t){function e(){var e=t.call(this)||this;return e.playTimes=1,e.delay=0,e.stopOnExit=!1,e}return __extends(e,t),e.prototype.enter=function(t){var e=t.parent.getTransition(this.transitionName);e&&(this._currentTransition&&this._currentTransition.playing?e.changePlayTimes(this.playTimes):e.play(null,null,null,this.playTimes,this.delay),this._currentTransition=e)},e.prototype.leave=function(t){this.stopOnExit&&this._currentTransition&&(this._currentTransition.stop(),this._currentTransition=null)},e.prototype.setup=function(e){t.prototype.setup.call(this,e),this.transitionName=e.readS(),this.playTimes=e.readInt(),this.delay=e.readFloat(),this.stopOnExit=e.readBool()},e}(t.ControllerAction);t.PlayTransitionAction=e}(fgui||(fgui={})),function(t){var e=function(){return function(){this.size=0,this.glyphs={}}}();t.BitmapFont=e}(fgui||(fgui={})),function(t){function e(e,i,n,o,r){var s,a,h;switch((!o||n!=t.FillOrigin.TopRight&&n!=t.FillOrigin.BottomLeft)&&(o||n!=t.FillOrigin.TopLeft&&n!=t.FillOrigin.BottomRight)||(r=1-r),s=((a=e*Math.tan(Math.PI/2*r))-i)/a,n){case t.FillOrigin.TopLeft:h=o?a<=i?[0,0,e,a,e,0]:[0,0,e*(1-s),i,e,i,e,0]:a<=i?[0,0,e,a,e,i,0,i]:[0,0,e*(1-s),i,0,i];break;case t.FillOrigin.TopRight:h=o?a<=i?[e,0,0,a,0,i,e,i]:[e,0,e*s,i,e,i]:a<=i?[e,0,0,a,0,0]:[e,0,e*s,i,0,i,0,0];break;case t.FillOrigin.BottomLeft:h=o?a<=i?[0,i,e,i-a,e,0,0,0]:[0,i,e*(1-s),0,0,0]:a<=i?[0,i,e,i-a,e,i]:[0,i,e*(1-s),0,e,0,e,i];break;case t.FillOrigin.BottomRight:h=o?a<=i?[e,i,0,i-a,0,i]:[e,i,e*s,0,0,0,0,i]:a<=i?[e,i,0,i-a,0,0,e,0]:[e,i,e*s,0,e,0]}return h}function i(t,e,i){for(var n=t.length,o=0;o<n;o+=2)t[o]+=e,t[o+1]+=i}function n(n,o,r,s,a){var h;switch(r){case t.FillOrigin.Top:a<=.5?(a/=.5,h=e(n/2,o,s?t.FillOrigin.TopLeft:t.FillOrigin.TopRight,s,a),s&&i(h,n/2,0)):(a=(a-.5)/.5,h=e(n/2,o,s?t.FillOrigin.TopRight:t.FillOrigin.TopLeft,s,a),s?h.push(n,o,n,0):(i(h,n/2,0),h.push(0,o,0,0)));break;case t.FillOrigin.Bottom:a<=.5?(a/=.5,h=e(n/2,o,s?t.FillOrigin.BottomRight:t.FillOrigin.BottomLeft,s,a),s||i(h,n/2,0)):(a=(a-.5)/.5,h=e(n/2,o,s?t.FillOrigin.BottomLeft:t.FillOrigin.BottomRight,s,a),s?(i(h,n/2,0),h.push(0,0,0,o)):h.push(n,0,n,o));break;case t.FillOrigin.Left:a<=.5?(a/=.5,h=e(n,o/2,s?t.FillOrigin.BottomLeft:t.FillOrigin.TopLeft,s,a),s||i(h,0,o/2)):(a=(a-.5)/.5,h=e(n,o/2,s?t.FillOrigin.TopLeft:t.FillOrigin.BottomLeft,s,a),s?(i(h,0,o/2),h.push(n,0,0,0)):h.push(n,o,0,o));break;case t.FillOrigin.Right:a<=.5?(a/=.5,h=e(n,o/2,s?t.FillOrigin.TopRight:t.FillOrigin.BottomRight,s,a),s&&i(h,0,o/2)):(a=(a-.5)/.5,h=e(n,o/2,s?t.FillOrigin.BottomRight:t.FillOrigin.TopRight,s,a),s?h.push(0,o,n,o):(i(h,0,o/2),h.push(0,0,n,0)))}return h}t.fillImage=function(o,r,s,a,h,l){if(l<=0)return null;if(l>=.9999)return[0,0,o,0,o,r,0,r];var c;switch(s){case t.FillMethod.Horizontal:c=function(e,i,n,o){var r=e*o;return n==t.FillOrigin.Left||n==t.FillOrigin.Top?[0,0,r,0,r,i,0,i]:[e,0,e,i,e-r,i,e-r,0]}(o,r,a,l);break;case t.FillMethod.Vertical:c=function(e,i,n,o){var r=i*o;return n==t.FillOrigin.Left||n==t.FillOrigin.Top?[0,0,0,r,e,r,e,0]:[0,i,e,i,e,i-r,0,i-r]}(o,r,a,l);break;case t.FillMethod.Radial90:c=e(o,r,a,h,l);break;case t.FillMethod.Radial180:c=n(o,r,a,h,l);break;case t.FillMethod.Radial360:c=function(e,o,r,s,a){var h;switch(r){case t.FillOrigin.Top:a<=.5?(a/=.5,h=n(e/2,o,s?t.FillOrigin.Left:t.FillOrigin.Right,s,a),s&&i(h,e/2,0)):(a=(a-.5)/.5,h=n(e/2,o,s?t.FillOrigin.Right:t.FillOrigin.Left,s,a),s?h.push(e,o,e,0,e/2,0):(i(h,e/2,0),h.push(0,o,0,0,e/2,0)));break;case t.FillOrigin.Bottom:a<=.5?(a/=.5,h=n(e/2,o,s?t.FillOrigin.Right:t.FillOrigin.Left,s,a),s||i(h,e/2,0)):(a=(a-.5)/.5,h=n(e/2,o,s?t.FillOrigin.Left:t.FillOrigin.Right,s,a),s?(i(h,e/2,0),h.push(0,0,0,o,e/2,o)):h.push(e,0,e,o,e/2,o));break;case t.FillOrigin.Left:a<=.5?(a/=.5,h=n(e,o/2,s?t.FillOrigin.Bottom:t.FillOrigin.Top,s,a),s||i(h,0,o/2)):(a=(a-.5)/.5,h=n(e,o/2,s?t.FillOrigin.Top:t.FillOrigin.Bottom,s,a),s?(i(h,0,o/2),h.push(e,0,0,0,0,o/2)):h.push(e,o,0,o,0,o/2));break;case t.FillOrigin.Right:a<=.5?(a/=.5,h=n(e,o/2,s?t.FillOrigin.Top:t.FillOrigin.Bottom,s,a),s&&i(h,0,o/2)):(a=(a-.5)/.5,h=n(e,o/2,s?t.FillOrigin.Bottom:t.FillOrigin.Top,s,a),s?h.push(0,o,e,o,e,o/2):(i(h,0,o/2),h.push(0,0,e,0,e,o/2)))}return h}(o,r,a,h,l)}return c}}(fgui||(fgui={})),function(t){var e=function(e){function i(){var t=e.call(this)||this;return t._fillMethod=0,t._fillOrigin=0,t._fillAmount=0,t._color=16777215,t}return __extends(i,e),Object.defineProperty(i.prototype,"color",{get:function(){return this._color},set:function(e){this._color!=e&&(this._color=e,null==this.tint?t.ToolSet.setColorFilter(this,e):this.tint=e)},enumerable:!0,configurable:!0}),i.prototype.$setX=function(t){return this.mask&&(this.mask.x=t),e.prototype.$setX.call(this,t)},i.prototype.$setY=function(t){return this.mask&&(this.mask.y=t),e.prototype.$setY.call(this,t)},Object.defineProperty(i.prototype,"fillMethod",{get:function(){return this._fillMethod},set:function(t){this._fillMethod!=t&&(this._fillMethod=t,0!=this._fillMethod?(this._mask||(this._mask=new egret.Shape,this._mask.touchEnabled=!1),this.mask=this._mask,this._mask.x=this.x,this._mask.y=this.y,this.addEventListener(egret.Event.RESIZE,this.markChanged,this),this.markChanged()):this.mask&&(this._mask.graphics.clear(),this.mask=null,this.removeEventListener(egret.Event.RESIZE,this.markChanged,this)))},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillOrigin",{get:function(){return this._fillOrigin},set:function(t){this._fillOrigin!=t&&(this._fillOrigin=t,0!=this._fillMethod&&this.markChanged())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillClockwise",{get:function(){return this._fillClockwise},set:function(t){this._fillClockwise!=t&&(this._fillClockwise=t,0!=this._fillMethod&&this.markChanged())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"fillAmount",{get:function(){return this._fillAmount},set:function(t){this._fillAmount!=t&&(this._fillAmount=t,0!=this._fillMethod&&this.markChanged())},enumerable:!0,configurable:!0}),i.prototype.markChanged=function(){this._maskDirtyFlag||(this._maskDirtyFlag=!0,t.GTimers.inst.callLater(this.doFill,this))},i.prototype.doFill=function(){this._maskDirtyFlag=!1,!this._mask.parent&&this.parent&&this.parent.addChild(this._mask);var e=this.width,i=this.height,n=this._mask.graphics;if(n.clear(),0!=e&&0!=i){var o=t.fillImage(e,i,this._fillMethod,this._fillOrigin,this._fillClockwise,this._fillAmount);o&&(n.beginFill(0,1),t.ToolSet.fillPath(n,o,0,0),n.endFill())}},i}(egret.Bitmap);t.Image=e}(fgui||(fgui={})),function(t){var e=function(e){function i(){var t=e.call(this)||this;return t.interval=0,t.repeatDelay=0,t.timeScale=1,t._playing=!0,t._frameCount=0,t._frame=0,t._start=0,t._end=0,t._times=0,t._endAt=0,t._status=0,t._frameElapsed=0,t._reversed=!1,t._repeatedCount=0,t.touchEnabled=!1,t.setPlaySettings(),t}return __extends(i,e),Object.defineProperty(i.prototype,"frames",{get:function(){return this._frames},set:function(t){this._frames=t,this.scale9Grid=null,this.fillMode=egret.BitmapFillMode.SCALE,this._frames?this._frameCount=this._frames.length:this._frameCount=0,(-1==this._end||this._end>this._frameCount-1)&&(this._end=this._frameCount-1),(-1==this._endAt||this._endAt>this._frameCount-1)&&(this._endAt=this._frameCount-1),(this._frame<0||this._frame>this._frameCount-1)&&(this._frame=this._frameCount-1),this.drawFrame(),this._frameElapsed=0,this._repeatedCount=0,this._reversed=!1,this.checkTimer()},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"frameCount",{get:function(){return this._frameCount},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"frame",{get:function(){return this._frame},set:function(t){this._frame!=t&&(this._frames&&t>=this._frameCount&&(t=this._frameCount-1),this._frame=t,this._frameElapsed=0,this.drawFrame())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"playing",{get:function(){return this._playing},set:function(t){this._playing!=t&&(this._playing=t,this.checkTimer())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"smoothing",{get:function(){return this._smoothing},set:function(t){this._smoothing=t},enumerable:!0,configurable:!0}),i.prototype.rewind=function(){this._frame=0,this._frameElapsed=0,this._reversed=!1,this._repeatedCount=0,this.drawFrame()},i.prototype.syncStatus=function(t){this._frame=t._frame,this._frameElapsed=t._frameElapsed,this._reversed=t._reversed,this._repeatedCount=t._repeatedCount,this.drawFrame()},i.prototype.advance=function(t){for(var e=this._frame,i=this._reversed,n=t;;){var o=this.interval+this._frames[this._frame].addDelay;if(0==this._frame&&this._repeatedCount>0&&(o+=this.repeatDelay),t<o){this._frameElapsed=0;break}if(t-=o,this.swing?this._reversed?(this._frame--,this._frame<=0&&(this._frame=0,this._repeatedCount++,this._reversed=!this._reversed)):(this._frame++,this._frame>this._frameCount-1&&(this._frame=Math.max(0,this._frameCount-2),this._repeatedCount++,this._reversed=!this._reversed)):(this._frame++,this._frame>this._frameCount-1&&(this._frame=0,this._repeatedCount++)),this._frame==e&&this._reversed==i){var r=n-t;t-=Math.floor(t/r)*r}}this.drawFrame()},i.prototype.setPlaySettings=function(t,e,i,n,o,r){null==t&&(t=0),null==e&&(e=-1),null==i&&(i=0),null==n&&(n=-1),this._start=t,this._end=e,(-1==this._end||this._end>this._frameCount-1)&&(this._end=this._frameCount-1),this._times=i,this._endAt=n,-1==this._endAt&&(this._endAt=this._end),this._status=0,this._callback=o,this._callbackObj=r,this.frame=t},i.prototype.update=function(){if(this._playing&&0!=this._frameCount&&3!=this._status){var e=t.GTimers.deltaTime;1!=this.timeScale&&(e*=this.timeScale),this._frameElapsed+=e;var i=this.interval+this._frames[this._frame].addDelay;if(0==this._frame&&this._repeatedCount>0&&(i+=this.repeatDelay),!(this._frameElapsed<i)){if(this._frameElapsed-=i,this._frameElapsed>this.interval&&(this._frameElapsed=this.interval),this.swing?this._reversed?(this._frame--,this._frame<=0&&(this._frame=0,this._repeatedCount++,this._reversed=!this._reversed)):(this._frame++,this._frame>this._frameCount-1&&(this._frame=Math.max(0,this._frameCount-2),this._repeatedCount++,this._reversed=!this._reversed)):(this._frame++,this._frame>this._frameCount-1&&(this._frame=0,this._repeatedCount++)),1==this._status)this._frame=this._start,this._frameElapsed=0,this._status=0;else if(2==this._status){if(this._frame=this._endAt,this._frameElapsed=0,this._status=3,null!=this._callback){var n=this._callback,o=this._callbackObj;this._callback=null,this._callbackObj=null,n.call(o)}}else this._frame==this._end&&(this._times>0?(this._times--,0==this._times?this._status=2:this._status=1):0!=this._start&&(this._status=1));this.drawFrame()}}},i.prototype.drawFrame=function(){if(this._frameCount>0&&this._frame<this._frames.length){var t=this._frames[this._frame];this.texture=t.texture}else this.texture=null},i.prototype.checkTimer=function(){this._playing&&this._frameCount>0&&null!=this.stage?t.GTimers.inst.add(1,0,this.update,this):t.GTimers.inst.remove(this.update,this)},i.prototype.$onAddToStage=function(i,n){e.prototype.$onAddToStage.call(this,i,n),this._playing&&this._frameCount>0&&t.GTimers.inst.add(1,0,this.update,this)},i.prototype.$onRemoveFromStage=function(){e.prototype.$onRemoveFromStage.call(this),t.GTimers.inst.remove(this.update,this)},i}(t.Image);t.MovieClip=e}(fgui||(fgui={})),function(t){var e=function(t){function e(){var e=t.call(this)||this;return e.touchEnabled=!0,e.touchChildren=!0,e}return __extends(e,t),e.prototype.cacheHitArea=function(t){this._cachedHitArea=t,t&&(this._cachedMatrix||(this._cachedMatrix=new egret.Matrix),this._cachedMatrix.copyFrom(this.$getInvertedConcatenatedMatrix()))},Object.defineProperty(e.prototype,"hitArea",{get:function(){return this._hitArea},set:function(t){this._hitArea=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"opaque",{get:function(){return this._opaque},set:function(t){this._opaque=t},enumerable:!0,configurable:!0}),e.prototype.$hitTest=function(e,i){if(!this.$visible)return null;if(this._hitArea){if(!this.touchEnabled)return null;if(this._hitArea.$graphics){if(!this._hitArea.$graphics.$hitTest(e,i))return null}else{var n=(s=this._cachedHitArea?this._cachedMatrix:this.$getInvertedConcatenatedMatrix()).a*e+s.c*i+s.tx,o=s.b*e+s.d*i+s.ty;if(!this._hitArea.contains(n,o))return null}return this}var r=t.prototype.$hitTest.call(this,e,i);if(r==this&&!this.touchEnabled)return null;if(null==r&&this._opaque){var s;n=(s=this._cachedHitArea?this._cachedMatrix:this.$getInvertedConcatenatedMatrix()).a*e+s.c*i+s.tx,o=s.b*e+s.d*i+s.ty;return n>=0&&o>=0&&n<=this.$explicitWidth&&o<=this.$explicitHeight?this:null}return r!=this||this._opaque?r:null},e}(egret.DisplayObjectContainer);t.UIContainer=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e,i,n,o){void 0===i&&(i=0),void 0===n&&(n=0),void 0===o&&(o=-1);var r=t.call(this,e,!1)||this;return r.touchPointID=0,r.stageX=i,r.stageY=n,r.touchPointID=o,r}return __extends(e,t),e.prototype.preventDefault=function(){this._prevented=!0},e.prototype.isDefaultPrevented=function(){return this._prevented},e.DRAG_START="__dragStart",e.DRAG_END="__dragEnd",e.DRAG_MOVING="__dragMoving",e}(egret.Event);t.DragEvent=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e,i){var n=t.call(this,e,!1)||this;return n.source=i,n}return __extends(e,t),e.DROP="__drop",e}(egret.Event);t.DropEvent=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e,i,n,o){void 0===i&&(i=null),void 0===n&&(n=0),void 0===o&&(o=0);var r=t.call(this,e,!1)||this;return r.itemObject=i,r.stageX=n,r.stageY=o,r}return __extends(e,t),e.CLICK="___itemClick",e}(egret.Event);t.ItemEvent=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e){return t.call(this,e,!1)||this}return __extends(e,t),e.CHANGED="___stateChanged",e}(egret.Event);t.StateChangeEvent=e}(fgui||(fgui={})),function(t){var e,i=function(){function i(t){this._owner=t}return i.create=function(i,n){return e||(e=[t.GearDisplay,t.GearXY,t.GearSize,t.GearLook,t.GearColor,t.GearAnimation,t.GearText,t.GearIcon,t.GearDisplay2,t.GearFontSize]),new e[n](i)},i.prototype.dispose=function(){this._tweenConfig&&this._tweenConfig._tweener&&(this._tweenConfig._tweener.kill(),this._tweenConfig._tweener=null)},Object.defineProperty(i.prototype,"controller",{get:function(){return this._controller},set:function(t){t!=this._controller&&(this._controller=t,this._controller&&this.init())},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"tweenConfig",{get:function(){return this._tweenConfig||(this._tweenConfig=new n),this._tweenConfig},enumerable:!0,configurable:!0}),i.prototype.setup=function(e){var i,o;this._controller=this._owner.parent.getControllerAt(e.readShort()),this.init();var r=e.readShort();if(this instanceof t.GearDisplay)this.pages=e.readSArray(r);else if(this instanceof t.GearDisplay2)this.pages=e.readSArray(r);else{for(i=0;i<r;i++)null!=(o=e.readS())&&this.addStatus(o,e);e.readBool()&&this.addStatus(null,e)}if(e.readBool()&&(this._tweenConfig=new n,this._tweenConfig.easeType=e.readByte(),this._tweenConfig.duration=e.readFloat(),this._tweenConfig.delay=e.readFloat()),e.version>=2)if(this instanceof t.GearXY){if(e.readBool()){for(this.positionsInPercent=!0,i=0;i<r;i++)null!=(o=e.readS())&&this.addExtStatus(o,e);e.readBool()&&this.addExtStatus(null,e)}}else this instanceof t.GearDisplay2&&(this.condition=e.readByte())},i.prototype.updateFromRelations=function(t,e){},i.prototype.addStatus=function(t,e){},i.prototype.init=function(){},i.prototype.apply=function(){},i.prototype.updateState=function(){},i}();t.GearBase=i;var n=function(){return function(){this.tween=!0,this.easeType=t.EaseType.QuadOut,this.duration=.3,this.delay=0}}();t.GearTweenConfig=n}(fgui||(fgui={})),function(t){var e=function(e){function i(t){return e.call(this,t)||this}return __extends(i,e),i.prototype.init=function(){this._default={playing:this._owner.getProp(t.ObjectPropID.Playing),frame:this._owner.getProp(t.ObjectPropID.Frame)},this._storage={}},i.prototype.addStatus=function(t,e){var i;null==t?i=this._default:this._storage[t]=i={},i.playing=e.readBool(),i.frame=e.readInt()},i.prototype.apply=function(){this._owner._gearLocked=!0;var e=this._storage[this._controller.selectedPageId];e||(e=this._default),this._owner.setProp(t.ObjectPropID.Playing,e.playing),this._owner.setProp(t.ObjectPropID.Frame,e.frame),this._owner._gearLocked=!1},i.prototype.updateState=function(){var e=this._storage[this._controller.selectedPageId];e||(this._storage[this._controller.selectedPageId]=e={}),e.playing=this._owner.getProp(t.ObjectPropID.Playing),e.frame=this._owner.getProp(t.ObjectPropID.Frame)},i}(t.GearBase);t.GearAnimation=e}(fgui||(fgui={})),function(t){var e=function(e){function i(t){return e.call(this,t)||this}return __extends(i,e),i.prototype.init=function(){this._default={color:this._owner.getProp(t.ObjectPropID.Color),strokeColor:this._owner.getProp(t.ObjectPropID.OutlineColor)},this._storage={}},i.prototype.addStatus=function(t,e){var i;null==t?i=this._default:this._storage[t]=i={},i.color=e.readColor(),i.strokeColor=e.readColor()},i.prototype.apply=function(){this._owner._gearLocked=!0;var e=this._storage[this._controller.selectedPageId];e||(e=this._default),this._owner.setProp(t.ObjectPropID.Color,e.color),this._owner.setProp(t.ObjectPropID.OutlineColor,e.strokeColor),this._owner._gearLocked=!1},i.prototype.updateState=function(){var e=this._storage[this._controller.selectedPageId];e||(this._storage[this._controller.selectedPageId]=e={}),e.color=this._owner.getProp(t.ObjectPropID.Color),e.strokeColor=this._owner.getProp(t.ObjectPropID.OutlineColor)},i}(t.GearBase);t.GearColor=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e){var i=t.call(this,e)||this;return i._displayLockToken=1,i._visible=0,i}return __extends(e,t),e.prototype.init=function(){this.pages=null},e.prototype.apply=function(){this._displayLockToken++,0==this._displayLockToken&&(this._displayLockToken=1),null==this.pages||0==this.pages.length||-1!=this.pages.indexOf(this._controller.selectedPageId)?this._visible=1:this._visible=0},e.prototype.addLock=function(){return this._visible++,this._displayLockToken},e.prototype.releaseLock=function(t){t==this._displayLockToken&&this._visible--},Object.defineProperty(e.prototype,"connected",{get:function(){return null==this._controller||this._visible>0},enumerable:!0,configurable:!0}),e}(t.GearBase);t.GearDisplay=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e){var i=t.call(this,e)||this;return i._visible=0,i}return __extends(e,t),e.prototype.init=function(){this.pages=null},e.prototype.apply=function(){null==this.pages||0==this.pages.length||-1!=this.pages.indexOf(this._controller.selectedPageId)?this._visible=1:this._visible=0},e.prototype.evaluate=function(t){var e=null==this._controller||this._visible>0;return e=0==this.condition?e&&t:e||t},e}(t.GearBase);t.GearDisplay2=e}(fgui||(fgui={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i._default=0,i}return __extends(i,e),i.prototype.init=function(){this._default=this._owner.getProp(t.ObjectPropID.FontSize),this._storage={}},i.prototype.addStatus=function(t,e){null==t?this._default=e.readInt():this._storage[t]=e.readInt()},i.prototype.apply=function(){this._owner._gearLocked=!0;var e=this._storage[this._controller.selectedPageId];null!=e?this._owner.setProp(t.ObjectPropID.FontSize,e):this._owner.setProp(t.ObjectPropID.FontSize,this._default),this._owner._gearLocked=!1},i.prototype.updateState=function(){this._storage[this._controller.selectedPageId]=this._owner.getProp(t.ObjectPropID.FontSize)},i}(t.GearBase);t.GearFontSize=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.init=function(){this._default=this._owner.icon,this._storage={}},e.prototype.addStatus=function(t,e){null==t?this._default=e.readS():this._storage[t]=e.readS()},e.prototype.apply=function(){this._owner._gearLocked=!0;var t=this._storage[this._controller.selectedPageId];this._owner.icon=void 0!==t?t:this._default,this._owner._gearLocked=!1},e.prototype.updateState=function(){this._storage[this._controller.selectedPageId]=this._owner.icon},e}(t.GearBase);t.GearIcon=e}(fgui||(fgui={})),function(t){var e=function(e){function i(t){return e.call(this,t)||this}return __extends(i,e),i.prototype.init=function(){this._default={alpha:this._owner.alpha,rotation:this._owner.rotation,grayed:this._owner.grayed,touchable:this._owner.touchable},this._storage={}},i.prototype.addStatus=function(t,e){var i;null==t?i=this._default:this._storage[t]=i={},i.alpha=e.readFloat(),i.rotation=e.readFloat(),i.grayed=e.readBool(),i.touchable=e.readBool()},i.prototype.apply=function(){var e=this._storage[this._controller.selectedPageId];if(e||(e=this._default),this._tweenConfig&&this._tweenConfig.tween&&!t.UIPackage._constructing&&!t.GearBase.disableAllTweenEffect){if(this._owner._gearLocked=!0,this._owner.grayed=e.grayed,this._owner.touchable=e.touchable,this._owner._gearLocked=!1,this._tweenConfig._tweener){if(this._tweenConfig._tweener.endValue.x==e.alpha&&this._tweenConfig._tweener.endValue.y==e.rotation)return;this._tweenConfig._tweener.kill(!0),this._tweenConfig._tweener=null}var i=e.alpha!=this._owner.alpha,n=e.rotation!=this._owner.rotation;(i||n)&&(this._owner.checkGearController(0,this._controller)&&(this._tweenConfig._displayLockToken=this._owner.addDisplayLock()),this._tweenConfig._tweener=t.GTween.to2(this._owner.alpha,this._owner.rotation,e.alpha,e.rotation,this._tweenConfig.duration).setDelay(this._tweenConfig.delay).setEase(this._tweenConfig.easeType).setUserData((i?1:0)+(n?2:0)).setTarget(this).onUpdate(this.__tweenUpdate,this).onComplete(this.__tweenComplete,this))}else this._owner._gearLocked=!0,this._owner.grayed=e.grayed,this._owner.touchable=e.touchable,this._owner.alpha=e.alpha,this._owner.rotation=e.rotation,this._owner._gearLocked=!1},i.prototype.__tweenUpdate=function(t){var e=t.userData;this._owner._gearLocked=!0,0!=(1&e)&&(this._owner.alpha=t.value.x),0!=(2&e)&&(this._owner.rotation=t.value.y),this._owner._gearLocked=!1},i.prototype.__tweenComplete=function(){0!=this._tweenConfig._displayLockToken&&(this._owner.releaseDisplayLock(this._tweenConfig._displayLockToken),this._tweenConfig._displayLockToken=0),this._tweenConfig._tweener=null},i.prototype.updateState=function(){var t=this._storage[this._controller.selectedPageId];t||(this._storage[this._controller.selectedPageId]=t={}),t.alpha=this._owner.alpha,t.rotation=this._owner.rotation,t.grayed=this._owner.grayed,t.touchable=this._owner.touchable},i}(t.GearBase);t.GearLook=e}(fgui||(fgui={})),function(t){var e=function(e){function i(t){return e.call(this,t)||this}return __extends(i,e),i.prototype.init=function(){this._default={width:this._owner.width,height:this._owner.height,scaleX:this._owner.scaleX,scaleY:this._owner.scaleY},this._storage={}},i.prototype.addStatus=function(t,e){var i;null==t?i=this._default:this._storage[t]=i={},i.width=e.readInt(),i.height=e.readInt(),i.scaleX=e.readFloat(),i.scaleY=e.readFloat()},i.prototype.apply=function(){var e=this._storage[this._controller.selectedPageId];if(e||(e=this._default),this._tweenConfig&&this._tweenConfig.tween&&!t.UIPackage._constructing&&!t.GearBase.disableAllTweenEffect){if(this._tweenConfig._tweener){if(this._tweenConfig._tweener.endValue.x==e.width&&this._tweenConfig._tweener.endValue.y==e.height&&this._tweenConfig._tweener.endValue.z==e.scaleX&&this._tweenConfig._tweener.endValue.w==e.scaleY)return;this._tweenConfig._tweener.kill(!0),this._tweenConfig._tweener=null}var i=e.width!=this._owner.width||e.height!=this._owner.height,n=e.scaleX!=this._owner.scaleX||e.scaleY!=this._owner.scaleY;(i||n)&&(this._owner.checkGearController(0,this._controller)&&(this._tweenConfig._displayLockToken=this._owner.addDisplayLock()),this._tweenConfig._tweener=t.GTween.to4(this._owner.width,this._owner.height,this._owner.scaleX,this._owner.scaleY,e.width,e.height,e.scaleX,e.scaleY,this._tweenConfig.duration).setDelay(this._tweenConfig.delay).setEase(this._tweenConfig.easeType).setUserData((i?1:0)+(n?2:0)).setTarget(this).onUpdate(this.__tweenUpdate,this).onComplete(this.__tweenComplete,this))}else this._owner._gearLocked=!0,this._owner.setSize(e.width,e.height,this._owner.gearXY.controller==this._controller),this._owner.setScale(e.scaleX,e.scaleY),this._owner._gearLocked=!1},i.prototype.__tweenUpdate=function(t){var e=t.userData;this._owner._gearLocked=!0,0!=(1&e)&&this._owner.setSize(t.value.x,t.value.y,this._owner.checkGearController(1,this._controller)),0!=(2&e)&&this._owner.setScale(t.value.z,t.value.w),this._owner._gearLocked=!1},i.prototype.__tweenComplete=function(){0!=this._tweenConfig._displayLockToken&&(this._owner.releaseDisplayLock(this._tweenConfig._displayLockToken),this._tweenConfig._displayLockToken=0),this._tweenConfig._tweener=null},i.prototype.updateState=function(){var t=this._storage[this._controller.selectedPageId];t||(this._storage[this._controller.selectedPageId]=t={}),t.width=this._owner.width,t.height=this._owner.height,t.scaleX=this._owner.scaleX,t.scaleY=this._owner.scaleY},i.prototype.updateFromRelations=function(t,e){if(null!=this._controller&&null!=this._storage){for(var i in this._storage){var n=this._storage[i];n.width+=t,n.height+=e}this._default.width+=t,this._default.height+=e,this.updateState()}},i}(t.GearBase);t.GearSize=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.init=function(){this._default=this._owner.text,this._storage={}},e.prototype.addStatus=function(t,e){null==t?this._default=e.readS():this._storage[t]=e.readS()},e.prototype.apply=function(){this._owner._gearLocked=!0;var t=this._storage[this._controller.selectedPageId];this._owner.text=void 0!==t?t:this._default,this._owner._gearLocked=!1},e.prototype.updateState=function(){this._storage[this._controller.selectedPageId]=this._owner.text},e}(t.GearBase);t.GearText=e}(fgui||(fgui={})),function(t){var e=function(e){function i(t){return e.call(this,t)||this}return __extends(i,e),i.prototype.init=function(){this._default={x:this._owner.x,y:this._owner.y,px:this._owner.x/this._owner.parent.width,py:this._owner.y/this._owner.parent.height},this._storage={}},i.prototype.addStatus=function(t,e){var i;null==t?i=this._default:this._storage[t]=i={},i.x=e.readInt(),i.y=e.readInt()},i.prototype.addExtStatus=function(t,e){var i;(i=null==t?this._default:this._storage[t]).px=e.readFloat(),i.py=e.readFloat()},i.prototype.apply=function(){var e,i,n=this._storage[this._controller.selectedPageId];if(n||(n=this._default),this.positionsInPercent&&this._owner.parent?(e=n.px*this._owner.parent.width,i=n.py*this._owner.parent.height):(e=n.x,i=n.y),this._tweenConfig&&this._tweenConfig.tween&&!t.UIPackage._constructing&&!t.GearBase.disableAllTweenEffect){if(this._tweenConfig._tweener){if(this._tweenConfig._tweener.endValue.x==e&&this._tweenConfig._tweener.endValue.y==i)return;this._tweenConfig._tweener.kill(!0),this._tweenConfig._tweener=null}var o=this._owner.x,r=this._owner.y;o==e&&r==i||(this._owner.checkGearController(0,this._controller)&&(this._tweenConfig._displayLockToken=this._owner.addDisplayLock()),this._tweenConfig._tweener=t.GTween.to2(o,r,e,i,this._tweenConfig.duration).setDelay(this._tweenConfig.delay).setEase(this._tweenConfig.easeType).setTarget(this).onUpdate(this.__tweenUpdate,this).onComplete(this.__tweenComplete,this))}else this._owner._gearLocked=!0,this._owner.setXY(e,i),this._owner._gearLocked=!1},i.prototype.__tweenUpdate=function(t){this._owner._gearLocked=!0,this._owner.setXY(t.value.x,t.value.y),this._owner._gearLocked=!1},i.prototype.__tweenComplete=function(){0!=this._tweenConfig._displayLockToken&&(this._owner.releaseDisplayLock(this._tweenConfig._displayLockToken),this._tweenConfig._displayLockToken=0),this._tweenConfig._tweener=null},i.prototype.updateState=function(){var t=this._storage[this._controller.selectedPageId];t||(this._storage[this._controller.selectedPageId]=t={}),t.x=this._owner.x,t.y=this._owner.y,t.px=this._owner.x/this._owner.parent.width,t.py=this._owner.y/this._owner.parent.height},i.prototype.updateFromRelations=function(t,e){if(null!=this._controller&&null!=this._storage&&!this.positionsInPercent){for(var i in this._storage){var n=this._storage[i];n.x+=t,n.y+=e}this._default.x+=t,this._default.y+=e,this.updateState()}},i}(t.GearBase);t.GearXY=e}(fgui||(fgui={})),function(t){var e=.5*Math.PI,i=2*Math.PI;function n(t,e){return 1-o(e-t,e)}function o(t,e){return(t/=e)<1/2.75?7.5625*t*t:t<2/2.75?7.5625*(t-=1.5/2.75)*t+.75:t<2.5/2.75?7.5625*(t-=2.25/2.75)*t+.9375:7.5625*(t-=2.625/2.75)*t+.984375}t.evaluateEase=function(r,s,a,h,l){switch(r){case t.EaseType.Linear:return s/a;case t.EaseType.SineIn:return 1-Math.cos(s/a*e);case t.EaseType.SineOut:return Math.sin(s/a*e);case t.EaseType.SineInOut:return-.5*(Math.cos(Math.PI*s/a)-1);case t.EaseType.QuadIn:return(s/=a)*s;case t.EaseType.QuadOut:return-(s/=a)*(s-2);case t.EaseType.QuadInOut:return(s/=.5*a)<1?.5*s*s:-.5*(--s*(s-2)-1);case t.EaseType.CubicIn:return(s/=a)*s*s;case t.EaseType.CubicOut:return(s=s/a-1)*s*s+1;case t.EaseType.CubicInOut:return(s/=.5*a)<1?.5*s*s*s:.5*((s-=2)*s*s+2);case t.EaseType.QuartIn:return(s/=a)*s*s*s;case t.EaseType.QuartOut:return-((s=s/a-1)*s*s*s-1);case t.EaseType.QuartInOut:return(s/=.5*a)<1?.5*s*s*s*s:-.5*((s-=2)*s*s*s-2);case t.EaseType.QuintIn:return(s/=a)*s*s*s*s;case t.EaseType.QuintOut:return(s=s/a-1)*s*s*s*s+1;case t.EaseType.QuintInOut:return(s/=.5*a)<1?.5*s*s*s*s*s:.5*((s-=2)*s*s*s*s+2);case t.EaseType.ExpoIn:return 0==s?0:Math.pow(2,10*(s/a-1));case t.EaseType.ExpoOut:return s==a?1:1-Math.pow(2,-10*s/a);case t.EaseType.ExpoInOut:return 0==s?0:s==a?1:(s/=.5*a)<1?.5*Math.pow(2,10*(s-1)):.5*(2-Math.pow(2,-10*--s));case t.EaseType.CircIn:return-(Math.sqrt(1-(s/=a)*s)-1);case t.EaseType.CircOut:return Math.sqrt(1-(s=s/a-1)*s);case t.EaseType.CircInOut:return(s/=.5*a)<1?-.5*(Math.sqrt(1-s*s)-1):.5*(Math.sqrt(1-(s-=2)*s)+1);case t.EaseType.ElasticIn:var c;return 0==s?0:1==(s/=a)?1:(0==l&&(l=.3*a),h<1?(h=1,c=l/4):c=l/i*Math.asin(1/h),-h*Math.pow(2,10*(s-=1))*Math.sin((s*a-c)*i/l));case t.EaseType.ElasticOut:var u;return 0==s?0:1==(s/=a)?1:(0==l&&(l=.3*a),h<1?(h=1,u=l/4):u=l/i*Math.asin(1/h),h*Math.pow(2,-10*s)*Math.sin((s*a-u)*i/l)+1);case t.EaseType.ElasticInOut:var _;return 0==s?0:2==(s/=.5*a)?1:(0==l&&(l=a*(.3*1.5)),h<1?(h=1,_=l/4):_=l/i*Math.asin(1/h),s<1?h*Math.pow(2,10*(s-=1))*Math.sin((s*a-_)*i/l)*-.5:h*Math.pow(2,-10*(s-=1))*Math.sin((s*a-_)*i/l)*.5+1);case t.EaseType.BackIn:return(s/=a)*s*((h+1)*s-h);case t.EaseType.BackOut:return(s=s/a-1)*s*((h+1)*s+h)+1;case t.EaseType.BackInOut:return(s/=.5*a)<1?s*s*((1+(h*=1.525))*s-h)*.5:.5*((s-=2)*s*((1+(h*=1.525))*s+h)+2);case t.EaseType.BounceIn:return n(s,a);case t.EaseType.BounceOut:return o(s,a);case t.EaseType.BounceInOut:return function(t,e){return t<.5*e?.5*n(2*t,e):.5*o(2*t-e,e)+.5}(s,a);default:return-(s/=a)*(s-2)}}}(fgui||(fgui={})),function(t){var e=function(){function t(){}return t.Linear=0,t.SineIn=1,t.SineOut=2,t.SineInOut=3,t.QuadIn=4,t.QuadOut=5,t.QuadInOut=6,t.CubicIn=7,t.CubicOut=8,t.CubicInOut=9,t.QuartIn=10,t.QuartOut=11,t.QuartInOut=12,t.QuintIn=13,t.QuintOut=14,t.QuintInOut=15,t.ExpoIn=16,t.ExpoOut=17,t.ExpoInOut=18,t.CircIn=19,t.CircOut=20,t.CircInOut=21,t.ElasticIn=22,t.ElasticOut=23,t.ElasticInOut=24,t.BackIn=25,t.BackOut=26,t.BackInOut=27,t.BounceIn=28,t.BounceOut=29,t.BounceInOut=30,t.Custom=31,t}();t.EaseType=e}(fgui||(fgui={})),function(t){var e=function(){function e(){this._segments=new Array,this._points=new Array}return Object.defineProperty(e.prototype,"length",{get:function(){return this._fullLength},enumerable:!0,configurable:!0}),e.prototype.create=function(e,n,o,r){var s;Array.isArray(e)?s=e:((s=new Array).push(e),s.push(n),o&&s.push(o),r&&s.push(r)),this._segments.length=0,this._points.length=0,this._fullLength=0;var a=s.length;if(0!=a){var h=i;h.length=0;var l=s[0];l.curveType==t.CurveType.CRSpline&&h.push(new egret.Point(l.x,l.y));for(var c=1;c<a;c++){var u=s[c];if(l.curveType!=t.CurveType.CRSpline){var _={};_.type=l.curveType,_.ptStart=this._points.length,l.curveType==t.CurveType.Straight?(_.ptCount=2,this._points.push(new egret.Point(l.x,l.y)),this._points.push(new egret.Point(u.x,u.y))):l.curveType==t.CurveType.Bezier?(_.ptCount=3,this._points.push(new egret.Point(l.x,l.y)),this._points.push(new egret.Point(u.x,u.y)),this._points.push(new egret.Point(l.control1_x,l.control1_y))):l.curveType==t.CurveType.CubicBezier&&(_.ptCount=4,this._points.push(new egret.Point(l.x,l.y)),this._points.push(new egret.Point(u.x,u.y)),this._points.push(new egret.Point(l.control1_x,l.control1_y)),this._points.push(new egret.Point(l.control2_x,l.control2_y))),_.length=t.ToolSet.distance(l.x,l.y,u.x,u.y),this._fullLength+=_.length,this._segments.push(_)}u.curveType!=t.CurveType.CRSpline?h.length>0&&(h.push(new egret.Point(u.x,u.y)),this.createSplineSegment()):h.push(new egret.Point(u.x,u.y)),l=u}h.length>1&&this.createSplineSegment()}},e.prototype.createSplineSegment=function(){var e=i,n=e.length;e.splice(0,0,e[0]),e.push(e[n]),e.push(e[n]),n+=3;var o={};o.type=t.CurveType.CRSpline,o.ptStart=this._points.length,o.ptCount=n,this._points=this._points.concat(e),o.length=0;for(var r=1;r<n;r++)o.length+=t.ToolSet.distance(e[r-1].x,e[r-1].y,e[r].x,e[r].y);this._fullLength+=o.length,this._segments.push(o),e.length=0},e.prototype.clear=function(){this._segments.length=0,this._points.length=0},e.prototype.getPointAt=function(e,i){i?i.x=i.y=0:i=new egret.Point,e=t.ToolSet.clamp01(e);var n,o=this._segments.length;if(0==o)return i;if(1==e)return(n=this._segments[o-1]).type==t.CurveType.Straight?(i.x=t.ToolSet.lerp(this._points[n.ptStart].x,this._points[n.ptStart+1].x,e),i.y=t.ToolSet.lerp(this._points[n.ptStart].y,this._points[n.ptStart+1].y,e),i):n.type==t.CurveType.Bezier||n.type==t.CurveType.CubicBezier?this.onBezierCurve(n.ptStart,n.ptCount,e,i):this.onCRSplineCurve(n.ptStart,n.ptCount,e,i);for(var r=e*this._fullLength,s=0;s<o;s++)if((r-=(n=this._segments[s]).length)<0){e=1+r/n.length,n.type==t.CurveType.Straight?(i.x=t.ToolSet.lerp(this._points[n.ptStart].x,this._points[n.ptStart+1].x,e),i.y=t.ToolSet.lerp(this._points[n.ptStart].y,this._points[n.ptStart+1].y,e)):i=n.type==t.CurveType.Bezier||n.type==t.CurveType.CubicBezier?this.onBezierCurve(n.ptStart,n.ptCount,e,i):this.onCRSplineCurve(n.ptStart,n.ptCount,e,i);break}return i},Object.defineProperty(e.prototype,"segmentCount",{get:function(){return this._segments.length},enumerable:!0,configurable:!0}),e.prototype.getAnchorsInSegment=function(t,e){null==e&&(e=new Array);for(var i=this._segments[t],n=0;n<i.ptCount;n++)e.push(new egret.Point(this._points[i.ptStart+n].x,this._points[i.ptStart+n].y));return e},e.prototype.getPointsInSegment=function(e,i,n,o,r,s){null==o&&(o=new Array),s&&!isNaN(s)||(s=.1),r&&r.push(i);var a=this._segments[e];if(a.type==t.CurveType.Straight)o.push(new egret.Point(t.ToolSet.lerp(this._points[a.ptStart].x,this._points[a.ptStart+1].x,i),t.ToolSet.lerp(this._points[a.ptStart].y,this._points[a.ptStart+1].y,i))),o.push(new egret.Point(t.ToolSet.lerp(this._points[a.ptStart].x,this._points[a.ptStart+1].x,n),t.ToolSet.lerp(this._points[a.ptStart].y,this._points[a.ptStart+1].y,n)));else{var h;h=a.type==t.CurveType.Bezier||a.type==t.CurveType.CubicBezier?this.onBezierCurve:this.onCRSplineCurve,o.push(h.call(this,a.ptStart,a.ptCount,i,new egret.Point));for(var l=Math.min(a.length*s,50),c=0;c<=l;c++){var u=c/l;u>i&&u<n&&(o.push(h.call(this,a.ptStart,a.ptCount,u,new egret.Point)),null!=r&&r.push(u))}o.push(h.call(this,a.ptStart,a.ptCount,n,new egret.Point))}return null!=r&&r.push(n),o},e.prototype.getAllPoints=function(t,e,i){null==t&&(t=new Array),i&&!isNaN(i)||(i=.1);for(var n=this._segments.length,o=0;o<n;o++)this.getPointsInSegment(o,0,1,t,e,i);return t},e.prototype.onCRSplineCurve=function(e,i,n,o){var r=Math.floor(n*(i-4))+e,s=this._points[r].x,a=this._points[r].y,h=this._points[r+1].x,l=this._points[r+1].y,c=this._points[r+2].x,u=this._points[r+2].y,_=this._points[r+3].x,p=this._points[r+3].y,d=1==n?1:t.ToolSet.repeat(n*(i-4),1),g=((2-d)*d-1)*d*.5,f=.5*((3*d-5)*d*d+2),y=((-3*d+4)*d+1)*d*.5,m=(d-1)*d*d*.5;return o.x=s*g+h*f+c*y+_*m,o.y=a*g+l*f+u*y+p*m,o},e.prototype.onBezierCurve=function(t,e,i,n){var o=1-i,r=this._points[t].x,s=this._points[t].y,a=this._points[t+1].x,h=this._points[t+1].y,l=this._points[t+2].x,c=this._points[t+2].y;if(4==e){var u=this._points[t+3].x,_=this._points[t+3].y;n.x=o*o*o*r+3*o*o*i*l+3*o*i*i*u+i*i*i*a,n.y=o*o*o*s+3*o*o*i*c+3*o*i*i*_+i*i*i*h}else n.x=o*o*r+2*o*i*l+i*i*a,n.y=o*o*s+2*o*i*c+i*i*h;return n},e}();t.GPath=e;var i=new Array}(fgui||(fgui={})),function(t){var e;!function(t){t[t.CRSpline=0]="CRSpline",t[t.Bezier=1]="Bezier",t[t.CubicBezier=2]="CubicBezier",t[t.Straight=3]="Straight"}(e=t.CurveType||(t.CurveType={}));var i=function(){function t(){this.x=0,this.y=0,this.control1_x=0,this.control1_y=0,this.control2_x=0,this.control2_y=0,this.curveType=0}return t.newPoint=function(e,i,n){void 0===e&&(e=0),void 0===i&&(i=0),void 0===n&&(n=0);var o=new t;return o.x=e,o.y=i,o.control1_x=0,o.control1_y=0,o.control2_x=0,o.control2_y=0,o.curveType=n,o},t.newBezierPoint=function(i,n,o,r){void 0===i&&(i=0),void 0===n&&(n=0),void 0===o&&(o=0),void 0===r&&(r=0);var s=new t;return s.x=i,s.y=n,s.control1_x=o,s.control1_y=r,s.control2_x=0,s.control2_y=0,s.curveType=e.Bezier,s},t.newCubicBezierPoint=function(i,n,o,r,s,a){void 0===i&&(i=0),void 0===n&&(n=0),void 0===o&&(o=0),void 0===r&&(r=0),void 0===s&&(s=0),void 0===a&&(a=0);var h=new t;return h.x=i,h.y=n,h.control1_x=o,h.control1_y=r,h.control2_x=s,h.control2_y=a,h.curveType=e.CubicBezier,h},t.prototype.clone=function(){var e=new t;return e.x=this.x,e.y=this.y,e.control1_x=this.control1_x,e.control1_y=this.control1_y,e.control2_x=this.control2_x,e.control2_y=this.control2_y,e.curveType=this.curveType,e},t}();t.GPathPoint=i}(fgui||(fgui={})),function(t){var e=function(){function e(){}return e.to=function(e,i,n){return t.TweenManager.createTween()._to(e,i,n)},e.to2=function(e,i,n,o,r){return t.TweenManager.createTween()._to2(e,i,n,o,r)},e.to3=function(e,i,n,o,r,s,a){return t.TweenManager.createTween()._to3(e,i,n,o,r,s,a)},e.to4=function(e,i,n,o,r,s,a,h,l){return t.TweenManager.createTween()._to4(e,i,n,o,r,s,a,h,l)},e.toColor=function(e,i,n){return t.TweenManager.createTween()._toColor(e,i,n)},e.delayedCall=function(e){return t.TweenManager.createTween().setDelay(e)},e.shake=function(e,i,n,o){return t.TweenManager.createTween()._shake(e,i,n,o)},e.isTweening=function(e,i){return t.TweenManager.isTweening(e,i)},e.kill=function(e,i,n){t.TweenManager.killTweens(e,i,n)},e.getTween=function(e,i){return t.TweenManager.getTween(e,i)},e.catchCallbackExceptions=!0,e}();t.GTween=e}(fgui||(fgui={})),function(t){var e=function(){function e(){this._startValue=new t.TweenValue,this._endValue=new t.TweenValue,this._value=new t.TweenValue,this._deltaValue=new t.TweenValue,this._reset()}return e.prototype.setDelay=function(t){return this._delay=t,this},Object.defineProperty(e.prototype,"delay",{get:function(){return this._delay},enumerable:!0,configurable:!0}),e.prototype.setDuration=function(t){return this._duration=t,this},Object.defineProperty(e.prototype,"duration",{get:function(){return this._duration},enumerable:!0,configurable:!0}),e.prototype.setBreakpoint=function(t){return this._breakpoint=t,this},e.prototype.setEase=function(t){return this._easeType=t,this},e.prototype.setEasePeriod=function(t){return this._easePeriod=t,this},e.prototype.setEaseOvershootOrAmplitude=function(t){return this._easeOvershootOrAmplitude=t,this},e.prototype.setRepeat=function(t,e){return this._repeat=t,this._yoyo=e,this},Object.defineProperty(e.prototype,"repeat",{get:function(){return this._repeat},enumerable:!0,configurable:!0}),e.prototype.setTimeScale=function(t){return this._timeScale=t,this},e.prototype.setSnapping=function(t){return this._snapping=t,this},e.prototype.setTarget=function(t,e){return this._target=t,this._propType=e,this},Object.defineProperty(e.prototype,"target",{get:function(){return this._target},enumerable:!0,configurable:!0}),e.prototype.setUserData=function(t){return this._userData=t,this},Object.defineProperty(e.prototype,"userData",{get:function(){return this._userData},enumerable:!0,configurable:!0}),e.prototype.setPath=function(t){return this._path=t,this},e.prototype.onUpdate=function(t,e){return this._onUpdate=t,this._onUpdateCaller=e,this},e.prototype.onStart=function(t,e){return this._onStart=t,this._onStartCaller=e,this},e.prototype.onComplete=function(t,e){return this._onComplete=t,this._onCompleteCaller=e,this},Object.defineProperty(e.prototype,"startValue",{get:function(){return this._startValue},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"endValue",{get:function(){return this._endValue},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"value",{get:function(){return this._value},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"deltaValue",{get:function(){return this._deltaValue},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"normalizedTime",{get:function(){return this._normalizedTime},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"completed",{get:function(){return 0!=this._ended},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"allCompleted",{get:function(){return 1==this._ended},enumerable:!0,configurable:!0}),e.prototype.setPaused=function(t){return this._paused=t,this},e.prototype.seek=function(t){if(!this._killed){if(this._elapsedTime=t,this._elapsedTime<this._delay){if(!this._started)return;this._elapsedTime=this._delay}this.update()}},e.prototype.kill=function(t){this._killed||(t&&(0==this._ended&&(this._breakpoint>=0?this._elapsedTime=this._delay+this._breakpoint:this._repeat>=0?this._elapsedTime=this._delay+this._duration*(this._repeat+1):this._elapsedTime=this._delay+2*this._duration,this.update()),this.callCompleteCallback()),this._killed=!0)},e.prototype._to=function(t,e,i){return this._valueSize=1,this._startValue.x=t,this._endValue.x=e,this._value.x=t,this._duration=i,this},e.prototype._to2=function(t,e,i,n,o){return this._valueSize=2,this._startValue.x=t,this._endValue.x=i,this._startValue.y=e,this._endValue.y=n,this._value.x=t,this._value.y=e,this._duration=o,this},e.prototype._to3=function(t,e,i,n,o,r,s){return this._valueSize=3,this._startValue.x=t,this._endValue.x=n,this._startValue.y=e,this._endValue.y=o,this._startValue.z=i,this._endValue.z=r,this._value.x=t,this._value.y=e,this._value.z=i,this._duration=s,this},e.prototype._to4=function(t,e,i,n,o,r,s,a,h){return this._valueSize=4,this._startValue.x=t,this._endValue.x=o,this._startValue.y=e,this._endValue.y=r,this._startValue.z=i,this._endValue.z=s,this._startValue.w=n,this._endValue.w=a,this._value.x=t,this._value.y=e,this._value.z=i,this._value.w=n,this._duration=h,this},e.prototype._toColor=function(t,e,i){return this._valueSize=4,this._startValue.color=t,this._endValue.color=e,this._value.color=t,this._duration=i,this},e.prototype._shake=function(t,e,i,n){return this._valueSize=5,this._startValue.x=t,this._startValue.y=e,this._startValue.w=i,this._duration=n,this},e.prototype._init=function(){this._delay=0,this._duration=0,this._breakpoint=-1,this._easeType=t.EaseType.QuadOut,this._timeScale=1,this._easePeriod=0,this._easeOvershootOrAmplitude=1.70158,this._snapping=!1,this._repeat=0,this._yoyo=!1,this._valueSize=0,this._started=!1,this._paused=!1,this._killed=!1,this._elapsedTime=0,this._normalizedTime=0,this._ended=0},e.prototype._reset=function(){this._target=null,this._propType=null,this._userData=null,this._path=null,this._onStart=this._onUpdate=this._onComplete=null,this._onStartCaller=this._onUpdateCaller=this._onCompleteCaller=null},e.prototype._update=function(t){if(1!=this._timeScale&&(t*=this._timeScale),0!=t){if(0!=this._ended)return this.callCompleteCallback(),void(this._killed=!0);this._elapsedTime+=t,this.update(),0!=this._ended&&(this._killed||(this.callCompleteCallback(),this._killed=!0))}},e.prototype.update=function(){if(this._ended=0,0!=this._valueSize){if(!this._started){if(this._elapsedTime<this._delay)return;if(this._started=!0,this.callStartCallback(),this._killed)return}var e=!1,n=this._elapsedTime-this._delay;if(this._breakpoint>=0&&n>=this._breakpoint&&(n=this._breakpoint,this._ended=2),0!=this._repeat){var o=Math.floor(n/this._duration);n-=this._duration*o,this._yoyo&&(e=o%2==1),this._repeat>0&&this._repeat-o<0&&(this._yoyo&&(e=this._repeat%2==1),n=this._duration,this._ended=1)}else n>=this._duration&&(n=this._duration,this._ended=1);if(this._normalizedTime=t.evaluateEase(this._easeType,e?this._duration-n:n,this._duration,this._easeOvershootOrAmplitude,this._easePeriod),this._value.setZero(),this._deltaValue.setZero(),5==this._valueSize)if(0==this._ended){var r=this._startValue.w*(1-this._normalizedTime),s=r*(Math.random()>.5?1:-1),a=r*(Math.random()>.5?1:-1);this._deltaValue.x=s,this._deltaValue.y=a,this._value.x=this._startValue.x+s,this._value.y=this._startValue.y+a}else this._value.x=this._startValue.x,this._value.y=this._startValue.y;else if(this._path){var h=i;this._path.getPointAt(this._normalizedTime,h),this._snapping&&(h.x=Math.round(h.x),h.y=Math.round(h.y)),this._deltaValue.x=h.x-this._value.x,this._deltaValue.y=h.y-this._value.y,this._value.x=h.x,this._value.y=h.y}else for(var l=0;l<this._valueSize;l++){var c=this._startValue.getField(l),u=c+(this._endValue.getField(l)-c)*this._normalizedTime;this._snapping&&(u=Math.round(u)),this._deltaValue.setField(l,u-this._value.getField(l)),this._value.setField(l,u)}if(null!=this._target&&null!=this._propType)if(this._propType instanceof Function)switch(this._valueSize){case 1:this._propType.call(this._target,this._value.x);break;case 2:this._propType.call(this._target,this._value.x,this._value.y);break;case 3:this._propType.call(this._target,this._value.x,this._value.y,this._value.z);break;case 4:this._propType.call(this._target,this._value.x,this._value.y,this._value.z,this._value.w);break;case 5:this._propType.call(this._target,this._value.color);break;case 6:this._propType.call(this._target,this._value.x,this._value.y)}else 5==this._valueSize?this._target[this._propType]=this._value.color:this._target[this._propType]=this._value.x;this.callUpdateCallback()}else this._elapsedTime>=this._delay+this._duration&&(this._ended=1)},e.prototype.callStartCallback=function(){if(null!=this._onStart)try{this._onStart.call(this._onStartCaller,this)}catch(t){console.log("FairyGUI: error in start callback > "+t)}},e.prototype.callUpdateCallback=function(){if(null!=this._onUpdate)try{this._onUpdate.call(this._onUpdateCaller,this)}catch(t){console.log("FairyGUI: error in update callback > "+t)}},e.prototype.callCompleteCallback=function(){if(null!=this._onComplete)try{this._onComplete.call(this._onCompleteCaller,this)}catch(t){console.log("FairyGUI: error in complete callback > "+t)}},e}();t.GTweener=e;var i=new egret.Point}(fgui||(fgui={})),function(t){var e=function(){function e(){}return e.createTween=function(){var a;return i||(egret.startTick(e.update,null),i=!0,s=egret.getTimer()),(a=o.length>0?o.pop():new t.GTweener)._init(),n[r++]=a,r==n.length&&(n.length=n.length+Math.ceil(.5*n.length)),a},e.isTweening=function(t,e){if(null==t)return!1;for(var i=null==e,o=0;o<r;o++){var s=n[o];if(null!=s&&s.target==t&&!s._killed&&(i||s._propType==e))return!0}return!1},e.killTweens=function(t,e,i){if(null==t)return!1;for(var o=!1,s=r,a=null==i,h=0;h<s;h++){var l=n[h];null==l||l.target!=t||l._killed||!a&&l._propType!=i||(l.kill(e),o=!0)}return o},e.getTween=function(t,e){if(null==t)return null;for(var i=r,o=null==e,s=0;s<i;s++){var a=n[s];if(null!=a&&a.target==t&&!a._killed&&(o||a._propType==e))return a}return null},e.update=function(e){var i=e-s;s=e,i/=1e3;for(var a=r,h=-1,l=0;l<a;l++){var c=n[l];null==c?(-1==h&&(h=l),0):c._killed?(c._reset(),o.push(c),n[l]=null,-1==h&&(h=l),0):(c._target instanceof t.GObject&&c._target.isDisposed?c._killed=!0:c._paused||c._update(i),-1!=h&&(n[h]=c,n[l]=null,h++))}if(h>=0){if(r!=a){var u=a;for(a=r-a,l=0;l<a;l++)n[h++]=n[u++]}r=h}return!1},e}();t.TweenManager=e;var i,n=new Array(30),o=new Array,r=0,s=0}(fgui||(fgui={})),function(t){var e=function(){function t(){this.x=this.y=this.z=this.w=0}return Object.defineProperty(t.prototype,"color",{get:function(){return(this.w<<24)+(this.x<<16)+(this.y<<8)+this.z},set:function(t){this.x=(16711680&t)>>16,this.y=(65280&t)>>8,this.z=255&t,this.w=(4278190080&t)>>24},enumerable:!0,configurable:!0}),t.prototype.getField=function(t){switch(t){case 0:return this.x;case 1:return this.y;case 2:return this.z;case 3:return this.w;default:throw new Error("Index out of bounds: "+t)}},t.prototype.setField=function(t,e){switch(t){case 0:this.x=e;break;case 1:this.y=e;break;case 2:this.z=e;break;case 3:this.w=e;break;default:throw new Error("Index out of bounds: "+t)}},t.prototype.setZero=function(){this.x=this.y=this.z=this.w=0},t}();t.TweenValue=e}(fgui||(fgui={})),function(t){var e=function(t){function e(e,i){var n=t.call(this,e,i)||this;return n.version=0,n}return __extends(e,t),e.prototype.skip=function(t){this.position+=t},e.prototype.readBool=function(){return 1==this.readByte()},e.prototype.readS=function(){var t=this.readUnsignedShort();return 65534==t?null:65533==t?"":this.stringTable[t]},e.prototype.readSArray=function(t){for(var e=new Array(t),i=0;i<t;i++)e[i]=this.readS();return e},e.prototype.writeS=function(t){var e=this.readUnsignedShort();65534!=e&&65533!=e&&(this.stringTable[e]=t)},e.prototype.readColor=function(t){var e=this.readUnsignedByte(),i=this.readUnsignedByte(),n=this.readUnsignedByte(),o=this.readUnsignedByte();return(t?o<<24:0)+(e<<16)+(i<<8)+n},e.prototype.readChar=function(){var t=this.readUnsignedShort();return String.fromCharCode(t)},e.prototype.readBuffer=function(){var t=this.readUnsignedInt(),i=new e(new Uint8Array(this.buffer,this.position,t));return i.stringTable=this.stringTable,i.version=this.version,this.position+=t,i},e.prototype.seek=function(t,e){var i,n=this.position;return this.position=t,e<this.readByte()?(1==this.readByte()?(this.position+=2*e,i=this.readUnsignedShort()):(this.position+=4*e,i=this.readUnsignedInt()),i>0?(this.position=t+i,!0):(this.position=n,!1)):(this.position=n,!1)},e}(egret.ByteArray);t.ByteBuffer=e}(fgui||(fgui={})),function(t){var e=function(){function t(t,e,i,o){this.matrix=new Array(n),this.reset(),void 0===t&&void 0===e&&void 0===i&&void 0===o||this.adjustColor(t,e,i,o)}return t.prototype.reset=function(){for(var t=0;t<n;t++)this.matrix[t]=i[t]},t.prototype.invert=function(){this.multiplyMatrix([-1,0,0,0,255,0,-1,0,0,255,0,0,-1,0,255,0,0,0,1,0])},t.prototype.adjustColor=function(t,e,i,n){this.adjustHue(n||0),this.adjustContrast(e||0),this.adjustBrightness(t||0),this.adjustSaturation(i||0)},t.prototype.adjustBrightness=function(t){t=255*this.cleanValue(t,1),this.multiplyMatrix([1,0,0,0,t,0,1,0,0,t,0,0,1,0,t,0,0,0,1,0])},t.prototype.adjustContrast=function(t){var e=(t=this.cleanValue(t,1))+1,i=128*(1-e);this.multiplyMatrix([e,0,0,0,i,0,e,0,0,i,0,0,e,0,i,0,0,0,1,0])},t.prototype.adjustSaturation=function(t){t=this.cleanValue(t,1);var e=1-(t+=1),i=e*o,n=e*r,a=e*s;this.multiplyMatrix([i+t,n,a,0,0,i,n+t,a,0,0,i,n,a+t,0,0,0,0,0,1,0])},t.prototype.adjustHue=function(t){t=this.cleanValue(t,1),t*=Math.PI;var e=Math.cos(t),i=Math.sin(t);this.multiplyMatrix([o+e*(1-o)+i*-o,r+e*-r+i*-r,s+e*-s+i*(1-s),0,0,o+e*-o+.143*i,r+e*(1-r)+.14*i,s+e*-s+-.283*i,0,0,o+e*-o+i*-(1-o),r+e*-r+i*r,s+e*(1-s)+i*s,0,0,0,0,0,1,0])},t.prototype.concat=function(t){t.length==n&&this.multiplyMatrix(t)},t.prototype.clone=function(){var e=new t;return e.copyMatrix(this.matrix),e},t.prototype.copyMatrix=function(t){for(var e=n,i=0;i<e;i++)this.matrix[i]=t[i]},t.prototype.multiplyMatrix=function(t){for(var e=[],i=0,n=0;n<4;++n){for(var o=0;o<5;++o)e[i+o]=t[i]*this.matrix[o]+t[i+1]*this.matrix[o+5]+t[i+2]*this.matrix[o+10]+t[i+3]*this.matrix[o+15]+(4==o?t[i+4]:0);i+=5}this.copyMatrix(e)},t.prototype.cleanValue=function(t,e){return Math.min(e,Math.max(-e,t))},t}();t.ColorMatrix=e;var i=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0],n=i.length,o=.299,r=.587,s=.114}(fgui||(fgui={})),function(t){var e=function(){function t(){this._enumI=0,this._enumCount=0,this._lastTime=0,this._items=new Array,this._itemPool=new Array,this._lastTime=egret.getTimer(),t.time=this._lastTime,egret.startTick(this.__timer,this)}return t.prototype.getItem=function(){return this._itemPool.length?this._itemPool.pop():new i},t.prototype.findItem=function(t,e){for(var i=this._items.length,n=0;n<i;n++){var o=this._items[n];if(o.callback==t&&o.thisObj==e)return o}return null},t.prototype.add=function(t,e,i,n,o){var r=this.findItem(i,n);r||((r=this.getItem()).callback=i,r.hasParam=1==i.length,r.thisObj=n,this._items.push(r)),r.delay=t,r.counter=0,r.repeat=e,r.param=o,r.end=!1},t.prototype.callLater=function(t,e,i){this.add(1,1,t,e,i)},t.prototype.callDelay=function(t,e,i,n){this.add(t,1,e,i,n)},t.prototype.exists=function(t,e){return null!=this.findItem(t,e)},t.prototype.remove=function(t,e){var i=this.findItem(t,e);if(i){var n=this._items.indexOf(i);this._items.splice(n,1),n<this._enumI&&this._enumI--,this._enumCount--,i.reset(),this._itemPool.push(i)}},t.prototype.__timer=function(e){for(t.time=e,t.deltaTime=e-this._lastTime,this._lastTime=e,this._enumI=0,this._enumCount=this._items.length;this._enumI<this._enumCount;){var i=this._items[this._enumI];this._enumI++,i.advance(t.deltaTime)&&(i.end&&(this._enumI--,this._enumCount--,this._items.splice(this._enumI,1)),i.hasParam?i.callback.call(i.thisObj,i.param):i.callback.call(i.thisObj),i.end&&(i.reset(),this._itemPool.push(i)))}return!1},t.deltaTime=0,t.time=0,t.inst=new t,t}();t.GTimers=e;var i=function(){function t(){this.delay=0,this.counter=0,this.repeat=0}return t.prototype.advance=function(t){return this.counter+=t,this.counter>=this.delay&&(this.counter-=this.delay,this.counter>this.delay&&(this.counter=this.delay),this.repeat>0&&(this.repeat--,0==this.repeat&&(this.end=!0)),!0)},t.prototype.reset=function(){this.callback=null,this.thisObj=null,this.param=null},t}()}(fgui||(fgui={})),function(t){var e=function(){function t(){this._readPos=0,this.smallFontSize=12,this.normalFontSize=14,this.largeFontSize=16,this.defaultImgWidth=0,this.defaultImgHeight=0,this._handlers={},this._handlers.url=this.onTag_URL,this._handlers.img=this.onTag_IMG,this._handlers.b=this.onTag_Simple,this._handlers.i=this.onTag_Simple,this._handlers.u=this.onTag_Simple,this._handlers.sup=this.onTag_Simple,this._handlers.sub=this.onTag_Simple,this._handlers.color=this.onTag_COLOR,this._handlers.font=this.onTag_FONT,this._handlers.size=this.onTag_SIZE}return t.prototype.onTag_URL=function(t,e,i){return e?"</a>":null!=i?'<a href="'+i+'" target="_blank">':'<a href="'+this.getTagText()+'" target="_blank">'},t.prototype.onTag_IMG=function(t,e,i){if(e)return null;var n=this.getTagText(!0);return n?this.defaultImgWidth?'<img src="'+n+'" width="'+this.defaultImgWidth+'" height="'+this.defaultImgHeight+'"/>':'<img src="'+n+'"/>':null},t.prototype.onTag_Simple=function(t,e,i){return e?"</"+t+">":"<"+t+">"},t.prototype.onTag_COLOR=function(t,e,i){return e?"</font>":'<font color="'+i+'">'},t.prototype.onTag_FONT=function(t,e,i){return e?"</font>":'<font face="'+i+'">'},t.prototype.onTag_SIZE=function(t,e,i){return e?"</font>":("normal"==i?i=""+this.normalFontSize:"small"==i?i=""+this.smallFontSize:"large"==i?i=""+this.largeFontSize:i.length&&"+"==i.charAt(0)?i=""+(this.smallFontSize+parseInt(i.substr(1))):i.length&&"-"==i.charAt(0)&&(i=""+(this.smallFontSize-parseInt(i.substr(1)))),'<font size="'+i+'">')},t.prototype.getTagText=function(t){void 0===t&&(t=!1);for(var e,i=this._readPos,n="";-1!=(e=this._text.indexOf("[",i));){if(92!=this._text.charCodeAt(e-1)){n+=this._text.substring(i,e);break}n+=this._text.substring(i,e-1),n+="[",i=e+1}return-1==e?null:(t&&(this._readPos=e),n)},t.prototype.parse=function(t,e){this._text=t;for(var i,n,o,r,s,a,h,l=0,c="";-1!=(i=this._text.indexOf("[",l));)if(i>0&&92==this._text.charCodeAt(i-1))c+=this._text.substring(l,i-1),c+="[",l=i+1;else{if(c+=this._text.substring(l,i),l=i,-1==(i=this._text.indexOf("]",l)))break;o="/"==this._text.charAt(l+1),r=this._text.substring(o?l+2:l+1,i),this._readPos=i+1,s=null,a=null,-1!=(n=r.indexOf("="))&&(s=r.substring(n+1),r=r.substring(0,n)),r=r.toLowerCase(),null!=(h=this._handlers[r])?e||null!=(a=h.call(this,r,o,s))&&(c+=a):c+=this._text.substring(l,this._readPos),l=this._readPos}return l<this._text.length&&(c+=this._text.substr(l)),this._text=null,c},t.inst=new t,t}();t.UBBParser=e}(fgui||(fgui={})),function(t){var e=function(){function e(){}return e.startsWith=function(t,e,i){return!!t&&(!(t.length<e.length)&&(t=t.substring(0,e.length),i?t.toLowerCase()==e.toLowerCase():t==e))},e.trimRight=function(t){for(var e="",i=t.length-1;i>=0&&(" "==(e=t.charAt(i))||"\n"==e||"\r"==e);i--);return t.substring(0,i+1)},e.convertToHtmlColor=function(t,e){var i;i=e?(t>>24&255).toString(16):"";var n=(t>>16&255).toString(16),o=(t>>8&255).toString(16),r=(255&t).toString(16);return 1==i.length&&(i="0"+i),1==n.length&&(n="0"+n),1==o.length&&(o="0"+o),1==r.length&&(r="0"+r),"#"+i+n+o+r},e.convertFromHtmlColor=function(t,e){return t.length<1?0:("#"==t.charAt(0)&&(t=t.substr(1)),8==t.length?(parseInt(t.substr(0,2),16)<<24)+parseInt(t.substr(2),16):e?4278190080+parseInt(t,16):parseInt(t,16))},e.displayObjectToGObject=function(e){for(;e&&!(e instanceof egret.Stage);){if(e.$owner)return t.GObject.cast(e);e=e.parent}return null},e.encodeHTML=function(t){return t?t.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/'/g,"&apos;").replace(/"/g,"&quot;"):""},e.clamp=function(t,e,i){return t<e?t=e:t>i&&(t=i),t},e.clamp01=function(t){return t>1?t=1:t<0&&(t=0),t},e.lerp=function(t,e,i){return t+i*(e-t)},e.repeat=function(t,e){return t-Math.floor(t/e)*e},e.distance=function(t,e,i,n){return Math.sqrt(Math.pow(t-i,2)+Math.pow(e-n,2))},e.fillPath=function(t,e,i,n){var o=e.length;t.moveTo(e[0]+i,e[1]+n);for(var r=2;r<o;r+=2)t.lineTo(e[r]+i,e[r+1]+n);t.lineTo(e[0]+i,e[1]+n)},e.setColorFilter=function(e,o){var r,s,a=e.$_colorFilter_,h=e.filters;if("boolean"==typeof o?(r=a?a.$_color_:null,s=o):(r=16777215==o?null:o,s=!!a&&a.$_grayed_),r||0===r||s){if(a||(a=new egret.ColorMatrixFilter,e.$_colorFilter_=a),h)-1==h.indexOf(a)&&h.push(a);else h=[a];e.filters=h,a.$_color_=r,a.$_grayed_=s;var l=a.matrix;if(s)for(var c=0;c<20;c++)l[c]=i[c];else if(r instanceof Array)!function(e,i,o,r,s){s||(s=new Array(t.ColorMatrix.length));n.reset(),n.adjustColor(e,i,o,r),n.matrix.forEach(function(t,e){return s[e]=t})}(r[0],r[1],r[2],r[3],l);else{for(var u=0;u<20;u++)l[u]=0==u||6==u||12==u||18==u?1:0;l[0]=(o>>16&255)/255,l[6]=(o>>8&255)/255,l[12]=(255&o)/255}a.matrix=l}else if(h&&a){var _=h.indexOf(a);-1!=_&&(h.splice(_,1),h.length>0?e.filters=h:e.filters=null)}},e}();t.ToolSet=e;var i=[.3,.6,0,0,0,.3,.6,0,0,0,.3,.6,0,0,0,0,0,0,1,0],n=new t.ColorMatrix}(fgui||(fgui={}));
\ No newline at end of file
diff --git a/demo/libs/framework/framework.d.ts b/demo/libs/framework/framework.d.ts
index e2631a2e..dff79797 100644
--- a/demo/libs/framework/framework.d.ts
+++ b/demo/libs/framework/framework.d.ts
@@ -328,6 +328,7 @@ declare module es {
         onAddedToScene(): void;
         onRemovedFromScene(): void;
         update(): void;
+        debugRender(): void;
         addComponent<T extends Component>(component: T): T;
         getComponent<T extends Component>(type: any): T;
         hasComponent<T extends Component>(type: any): boolean;
@@ -923,6 +924,7 @@ declare module es {
         onEntityTransformChanged(comp: transform.Component): void;
         onEntityEnabled(): void;
         onEntityDisabled(): void;
+        debugRender(): void;
     }
 }
 declare module es {
@@ -1008,6 +1010,7 @@ declare module es {
         isVisible: boolean;
         isVisibleFromCamera(camera: Camera): any;
         render(camera: Camera): any;
+        debugRender(): any;
     }
     class RenderableComparer {
         compare(self: IRenderable, other: IRenderable): number;
@@ -1152,6 +1155,9 @@ declare module es {
     abstract class Renderer {
         camera: Camera;
         readonly renderOrder: number;
+        renderTexture: egret.RenderTexture;
+        shouldDebugRender: boolean;
+        readonly wantsToRenderToSceneRenderTarget: boolean;
         protected constructor(renderOrder: number, camera?: Camera);
         onAddedToScene(scene: Scene): void;
         unload(): void;
@@ -1160,6 +1166,7 @@ declare module es {
         compareTo(other: Renderer): number;
         protected beginRender(cam: Camera): void;
         protected renderAfterStateCheck(renderable: IRenderable, cam: Camera): void;
+        protected debugRender(scene: Scene, cam: Camera): void;
     }
 }
 declare module es {
@@ -1168,9 +1175,21 @@ declare module es {
         render(scene: Scene): void;
     }
 }
+declare module es {
+    class RenderLayerExcludeRenderer extends Renderer {
+        excludedRenderLayers: number[];
+        constructor(renderOrder: number, ...excludedRenderLayers: number[]);
+        render(scene: es.Scene): void;
+        protected debugRender(scene: es.Scene, cam: es.Camera): void;
+    }
+}
 declare module es {
     class ScreenSpaceRenderer extends Renderer {
+        renderLayers: number[];
+        constructor(renderOrder: number, ...renderLayers: number[]);
         render(scene: Scene): void;
+        protected debugRender(scene: es.Scene, cam: es.Camera): void;
+        onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): void;
     }
 }
 declare module es {
diff --git a/demo/libs/framework/framework.js b/demo/libs/framework/framework.js
index b25829a9..edc88ec3 100644
--- a/demo/libs/framework/framework.js
+++ b/demo/libs/framework/framework.js
@@ -1536,6 +1536,9 @@ var es;
         Entity.prototype.update = function () {
             this.components.update();
         };
+        Entity.prototype.debugRender = function () {
+            this.components.debugRender();
+        };
         Entity.prototype.addComponent = function (component) {
             component.entity = this;
             this.components.add(component);
@@ -2712,6 +2715,8 @@ var es;
             this._areBoundsDirty = true;
         };
         RenderableComponent.prototype.isVisibleFromCamera = function (camera) {
+            if (!camera)
+                return false;
             this.isVisible = camera.bounds.intersects(this.displayObject.getBounds().union(this.bounds));
             return this.isVisible;
         };
@@ -4230,6 +4235,12 @@ var es;
             for (var i = 0; i < this._components.length; i++)
                 this._components[i].onDisabled();
         };
+        ComponentList.prototype.debugRender = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                if (this._components[i].enabled)
+                    this._components[i].debugRender();
+            }
+        };
         ComponentList.compareUpdatableOrder = new es.IUpdatableComparer();
         return ComponentList;
     }());
@@ -5444,9 +5455,17 @@ var es;
         function Renderer(renderOrder, camera) {
             if (camera === void 0) { camera = null; }
             this.renderOrder = 0;
+            this.shouldDebugRender = true;
             this.camera = camera;
             this.renderOrder = renderOrder;
         }
+        Object.defineProperty(Renderer.prototype, "wantsToRenderToSceneRenderTarget", {
+            get: function () {
+                return !!this.renderTexture;
+            },
+            enumerable: true,
+            configurable: true
+        });
         Renderer.prototype.onAddedToScene = function (scene) {
         };
         Renderer.prototype.unload = function () {
@@ -5461,6 +5480,13 @@ var es;
         Renderer.prototype.renderAfterStateCheck = function (renderable, cam) {
             renderable.render(cam);
         };
+        Renderer.prototype.debugRender = function (scene, cam) {
+            for (var i = 0; i < scene.entities.count; i++) {
+                var entity = scene.entities.buffer[i];
+                if (entity.enabled)
+                    entity.debugRender();
+            }
+        };
         return Renderer;
     }());
     es.Renderer = Renderer;
@@ -5486,13 +5512,85 @@ var es;
     es.DefaultRenderer = DefaultRenderer;
 })(es || (es = {}));
 var es;
+(function (es) {
+    var RenderLayerExcludeRenderer = (function (_super) {
+        __extends(RenderLayerExcludeRenderer, _super);
+        function RenderLayerExcludeRenderer(renderOrder) {
+            var excludedRenderLayers = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                excludedRenderLayers[_i - 1] = arguments[_i];
+            }
+            var _this = _super.call(this, renderOrder, null) || this;
+            _this.excludedRenderLayers = excludedRenderLayers;
+            return _this;
+        }
+        RenderLayerExcludeRenderer.prototype.render = function (scene) {
+            var cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
+            for (var i = 0; i < scene.renderableComponents.count; i++) {
+                var renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
+            if (this.shouldDebugRender && es.Core.debugRenderEndabled)
+                this.debugRender(scene, cam);
+        };
+        RenderLayerExcludeRenderer.prototype.debugRender = function (scene, cam) {
+            for (var i = 0; i < scene.renderableComponents.count; i++) {
+                var renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    renderable.debugRender();
+            }
+            _super.prototype.debugRender.call(this, scene, cam);
+        };
+        return RenderLayerExcludeRenderer;
+    }(es.Renderer));
+    es.RenderLayerExcludeRenderer = RenderLayerExcludeRenderer;
+})(es || (es = {}));
+var es;
 (function (es) {
     var ScreenSpaceRenderer = (function (_super) {
         __extends(ScreenSpaceRenderer, _super);
-        function ScreenSpaceRenderer() {
-            return _super !== null && _super.apply(this, arguments) || this;
+        function ScreenSpaceRenderer(renderOrder) {
+            var renderLayers = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                renderLayers[_i - 1] = arguments[_i];
+            }
+            var _this = _super.call(this, renderOrder, null) || this;
+            renderLayers.sort();
+            renderLayers.reverse();
+            _this.renderLayers = renderLayers;
+            return _this;
         }
         ScreenSpaceRenderer.prototype.render = function (scene) {
+            this.beginRender(this.camera);
+            for (var i = 0; i < this.renderLayers.length; i++) {
+                var renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (var j = 0; j < renderables.length; j++) {
+                    var renderable = renderables[j];
+                    if (renderable.enabled && renderable.isVisibleFromCamera(this.camera))
+                        this.renderAfterStateCheck(renderable, this.camera);
+                }
+            }
+            if (this.shouldDebugRender && es.Core.debugRenderEndabled)
+                this.debugRender(scene, this.camera);
+        };
+        ScreenSpaceRenderer.prototype.debugRender = function (scene, cam) {
+            for (var i = 0; i < this.renderLayers.length; i++) {
+                var renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (var j = 0; j < renderables.length; j++) {
+                    var entity = renderables[j];
+                    if (entity.enabled)
+                        entity.debugRender();
+                }
+            }
+        };
+        ScreenSpaceRenderer.prototype.onSceneBackBufferSizeChanged = function (newWidth, newHeight) {
+            _super.prototype.onSceneBackBufferSizeChanged.call(this, newWidth, newHeight);
+            if (!this.camera)
+                this.camera = es.Core.scene.createEntity("screenspace camera").addComponent(new es.Camera());
         };
         return ScreenSpaceRenderer;
     }(es.Renderer));
@@ -8102,22 +8200,21 @@ var es;
         };
         TiledMapLoader.parseTmxTileset = function (map, xTileset) {
             return __awaiter(this, void 0, void 0, function () {
-                var xFirstGid, firstGid, source, xDocTileset, tileset;
+                var xFirstGid, firstGid, source, xDocTileset;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
                             xFirstGid = xTileset["firstgid"];
                             firstGid = xFirstGid;
-                            source = xTileset["image"];
+                            source = xTileset["source"];
                             if (!(source != undefined)) return [3, 2];
                             source = map.tmxDirectory + source;
-                            return [4, RES.getResByUrl(source, null, this, RES.ResourceItem.TYPE_IMAGE).catch(function (err) {
+                            return [4, RES.getResByUrl(source).catch(function (err) {
                                     throw new Error(err);
                                 })];
                         case 1:
                             xDocTileset = _a.sent();
-                            tileset = this.loadTmxTileset(new es.TmxTileset(), map, xDocTileset["tileset"], firstGid);
-                            return [2, tileset];
+                            return [2, this.loadTmxTileset(new es.TmxTileset(), map, xDocTileset["tileset"], firstGid)];
                         case 2: return [2, this.loadTmxTileset(new es.TmxTileset(), map, xTileset, firstGid)];
                     }
                 });
@@ -8125,9 +8222,9 @@ var es;
         };
         TiledMapLoader.loadTmxTileset = function (tileset, map, xTileset, firstGid) {
             return __awaiter(this, void 0, void 0, function () {
-                var xImage, _a, _i, _b, e, _c, _d, _e, t, xTile, tile, id, y, column, x;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
+                var xImage, _i, _a, e, _b, _c, _d, t, xTile, tile, id, y, column, x;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
                         case 0:
                             tileset.map = map;
                             tileset.firstGid = firstGid;
@@ -8141,38 +8238,39 @@ var es;
                             tileset.tileOffset = this.parseTmxTileOffset(xTileset["tileoffset"]);
                             xImage = xTileset["image"];
                             if (!xImage) return [3, 2];
-                            _a = tileset;
-                            return [4, this.loadTmxImage(new es.TmxImage(), xTileset, map.tmxDirectory).catch(function (err) {
+                            return [4, this.loadTmxImage(new es.TmxImage(), xTileset, map.tmxDirectory).then(function (image) {
+                                    tileset.image = image;
+                                }).catch(function (err) {
                                     throw new Error(err);
                                 })];
                         case 1:
-                            _a.image = _f.sent();
-                            _f.label = 2;
+                            _e.sent();
+                            _e.label = 2;
                         case 2:
                             tileset.terrains = [];
                             if (xTileset["terrains"])
-                                for (_i = 0, _b = xTileset["terrains"]; _i < _b.length; _i++) {
-                                    e = _b[_i];
+                                for (_i = 0, _a = xTileset["terrains"]; _i < _a.length; _i++) {
+                                    e = _a[_i];
                                     tileset.terrains.push(this.parseTmxTerrain(e));
                                 }
                             tileset.tiles = new Map();
-                            _c = [];
-                            for (_d in xTileset["tiles"])
-                                _c.push(_d);
-                            _e = 0;
-                            _f.label = 3;
+                            _b = [];
+                            for (_c in xTileset["tiles"])
+                                _b.push(_c);
+                            _d = 0;
+                            _e.label = 3;
                         case 3:
-                            if (!(_e < _c.length)) return [3, 6];
-                            t = _c[_e];
+                            if (!(_d < _b.length)) return [3, 6];
+                            t = _b[_d];
                             if (!xTileset["tiles"].hasOwnProperty(t)) return [3, 5];
                             xTile = xTileset["tiles"][t];
                             return [4, this.loadTmxTilesetTile(new es.TmxTilesetTile(), tileset, xTile, tileset.terrains, map.tmxDirectory)];
                         case 4:
-                            tile = _f.sent();
+                            tile = _e.sent();
                             tileset.tiles.set(tile.id == undefined ? Number(t) + 1 : tile.id, tile);
-                            _f.label = 5;
+                            _e.label = 5;
                         case 5:
-                            _e++;
+                            _d++;
                             return [3, 3];
                         case 6:
                             tileset.properties = this.parsePropertyDict(xTileset["properties"]);
diff --git a/demo/libs/framework/framework.min.js b/demo/libs/framework/framework.min.js
index 79523ccc..ce6c6fd2 100644
--- a/demo/libs/framework/framework.min.js
+++ b/demo/libs/framework/framework.min.js
@@ -1 +1 @@
-window.es={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var i in e)e.hasOwnProperty(i)&&(t[i]=e[i])};return function(e,i){function n(){this.constructor=e}t(e,i),e.prototype=null===i?Object.create(i):(n.prototype=i.prototype,new n)}}();var transform,__awaiter=this&&this.__awaiter||function(t,e,i,n){return new(i||(i=Promise))(function(r,o){function s(t){try{h(n.next(t))}catch(t){o(t)}}function a(t){try{h(n.throw(t))}catch(t){o(t)}}function h(t){t.done?r(t.value):new i(function(e){e(t.value)}).then(s,a)}h((n=n.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var i,n,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(i)throw new TypeError("Generator is already executing.");for(;s;)try{if(i=1,n&&(r=2&o[0]?n.return:o[0]?n.throw||((r=n.return)&&r.call(n),0):n.next)&&!(r=r.call(n,o[1])).done)return r;switch(n=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,n=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],n=0}finally{i=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++)if(e.call(arguments[2],t[i],i,t))return i;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var i=t.findIndex(e);return-1==i?null:t[i]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return e.call(arguments[2],n,r,t)&&i.push(n),i},[]);for(var i=[],n=0,r=t.length;n<r;n++){var o=t[n];e.call(arguments[2],o,n,t)&&i.push(o)}return i}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++){if(t[i]instanceof egret.HashObject&&e instanceof egret.HashObject&&t[i].hashCode==e.hashCode)return!0;if(t[i]==e)return!0}return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var i;do{(i=t.findIndex(e))>=0&&t.splice(i,1)}while(i>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var i=t.findIndex(function(t){return t===e});return i>=0&&(t.splice(i,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,i){t.splice(e,i)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return i.push(e.call(arguments[2],n,r,t)),i},[]);for(var i=[],n=0,r=t.length;n<r;n++)i.push(e.call(arguments[2],t[n],n,t));return i}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?i(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?-i(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var i=[];return t.reduce(function(n,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=i.findIndex(function(t){return t===s});return a<0&&(a=i.push(s)-1),n[a]||(n[a]=[]),n[a].push(r),n},[])}for(var n=[],r=[],o=function(i,o){var a=JSON.stringify(e.call(s[1],t[i],i,t)),h=r.findIndex(function(t){return t===a});h<0&&(h=r.push(a)-1),n[h]||(n[h]=[]),n[h].push(t[i])},s=arguments,a=0,h=t.length;a<h;a++)o(a);return n}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var i,n=0,r=t.length;n<r;n++)0==n?i=e?e.call(arguments[2],t[n],n,t):t[n]:i+=e?e.call(arguments[2],t[n],n,t):t[n];return i}(this,t)},function(t){var e=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}();t.PriorityQueueNode=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new i(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";e.getNeighbors(t.data).forEach(function(n){var s=h.get(t.data)+e.cost(t.data,n);if(!o.hasKey(h,n)||s<h.get(n)){h.set(n,s);var u=s+e.heuristic(n,r);c.enqueue(new i(n),u),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},e.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},e}();t.AStarPathfinder=e;var i=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.AStarNode=i}(es||(es={})),function(t){var e=function(){function e(e,i){this.dirs=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=i}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.AStarPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this.dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},e}();t.AstarGridGraph=e}(es||(es={})),function(t){var e=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var i=e+1;if(i<this._nodes.length&&this._nodes[i]&&this.hasHigherPriority(this._nodes[i],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),i=this._nodes[e];e>0&&this.hasHigherPriority(t,i)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,i=t.queueIndex;;){e=t;var n=2*i;if(n>this._numNodes){t.queueIndex=i,this._nodes[i]=t;break}var r=this._nodes[n];this.hasHigherPriority(r,e)&&(e=r);var o=n+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=i,this._nodes[i]=t;break}this._nodes[i]=e;var a=e.queueIndex;e.queueIndex=i,i=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var i=this._nodes[e];if(this.hasHigherPriority(i,t))break;this.swap(t,i),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var i=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=i},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}();t.PriorityQueue=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,i,n){var r=this,o=!1,s=[];s.unshift(i);var a=new Map;a.set(i,i);for(var h=function(){var t=s.shift();if(JSON.stringify(t)==JSON.stringify(n))return o=!0,"break";e.getNeighbors(t).forEach(function(e){r.hasKey(a,e)||(s.unshift(e),a.set(e,t))})};s.length>0;){if("break"===h())break}return o?t.AStarPathfinder.recontructPath(a,i,n):null},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e}();t.BreadthFirstPathfinder=e}(es||(es={})),function(t){var e=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}();t.UnweightedGraph=e}(es||(es={})),function(t){var e=function(){function e(t,e){this.x=0,this.y=0,this.x=t||0,this.y=null!=e?e:this.x}return Object.defineProperty(e,"zero",{get:function(){return e.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"one",{get:function(){return e.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitX",{get:function(){return e.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitY",{get:function(){return e.unitYVector},enumerable:!0,configurable:!0}),e.add=function(t,i){var n=new e(0,0);return n.x=t.x+i.x,n.y=t.y+i.y,n},e.divide=function(t,i){var n=new e(0,0);return n.x=t.x/i.x,n.y=t.y/i.y,n},e.multiply=function(t,i){var n=new e(0,0);return n.x=t.x*i.x,n.y=t.y*i.y,n},e.subtract=function(t,i){var n=new e(0,0);return n.x=t.x-i.x,n.y=t.y-i.y,n},e.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},e.dot=function(t,e){return t.x*e.x+t.y*e.y},e.distanceSquared=function(t,e){var i=t.x-e.x,n=t.y-e.y;return i*i+n*n},e.clamp=function(i,n,r){return new e(t.MathHelper.clamp(i.x,n.x,r.x),t.MathHelper.clamp(i.y,n.y,r.y))},e.lerp=function(i,n,r){return new e(t.MathHelper.lerp(i.x,n.x,r),t.MathHelper.lerp(i.y,n.y,r))},e.transform=function(t,i){return new e(t.x*i.m11+t.y*i.m21+i.m31,t.x*i.m12+t.y*i.m22+i.m32)},e.distance=function(t,e){var i=t.x-e.x,n=t.y-e.y;return Math.sqrt(i*i+n*n)},e.angle=function(i,n){return i=e.normalize(i),n=e.normalize(n),Math.acos(t.MathHelper.clamp(e.dot(i,n),-1,1))*t.MathHelper.Rad2Deg},e.negate=function(t){var i=new e;return i.x=-t.x,i.y=-t.y,i},e.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this},e.prototype.divide=function(t){return this.x/=t.x,this.y/=t.y,this},e.prototype.multiply=function(t){return this.x*=t.x,this.y*=t.y,this},e.prototype.subtract=function(t){return this.x-=t.x,this.y-=t.y,this},e.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);return this.x*=t,this.y*=t,this},e.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},e.prototype.lengthSquared=function(){return this.x*this.x+this.y*this.y},e.prototype.round=function(){return new e(Math.round(this.x),Math.round(this.y))},e.prototype.equals=function(t){return t.x==this.x&&t.y==this.y},e.unitYVector=new e(0,1),e.unitXVector=new e(1,0),e.unitVector2=new e(1,1),e.zeroVector2=new e(0,0),e}();t.Vector2=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this._neighbors=new Array(4),this._width=t,this._hegiht=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.search=function(e,i){return t.BreadthFirstPathfinder.search(this,e,i)},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,-1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.UnweightedGridGraph=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.WeightedPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.WeightedGridGraph=e}(es||(es={})),function(t){var e=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.WeightedNode=e;var i=function(){function i(){}return i.search=function(i,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new e(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";i.getNeighbors(t.data).forEach(function(n){var r=h.get(t.data)+i.cost(t.data,n);if(!o.hasKey(h,n)||r<h.get(n)){h.set(n,r);var s=r;c.enqueue(new e(n),s),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},i.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},i.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},i.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},i}();t.WeightedPathfinder=i}(es||(es={})),function(t){var e=function(){function e(){}return e.drawHollowRect=function(e,i,n){void 0===n&&(n=0),this._debugDrawItems.push(new t.DebugDrawItem(e,i,n))},e.render=function(){if(this._debugDrawItems.length>0){var e=new egret.Shape;t.Core.scene&&t.Core.scene.addChild(e);for(var i=this._debugDrawItems.length-1;i>=0;i--){this._debugDrawItems[i].draw(e)&&this._debugDrawItems.removeAt(i)}}},e._debugDrawItems=[],e}();t.Debug=e}(es||(es={})),function(t){var e=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();t.DebugDefaults=e}(es||(es={})),function(t){var e;!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(e=t.DebugDrawType||(t.DebugDrawType={}));var i=function(){function i(t,i,n){this.rectangle=t,this.color=i,this.duration=n,this.drawType=e.hollowRectangle}return i.prototype.draw=function(i){switch(this.drawType){case e.line:case e.hollowRectangle:case e.pixel:case e.text:}return this.duration-=t.Time.deltaTime,this.duration<0},i}();t.DebugDrawItem=i}(es||(es={})),function(t){var e=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.updateInterval=1,e._enabled=!0,e._updateOrder=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"transform",{get:function(){return this.entity.transform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onAddedToEntity=function(){},e.prototype.onRemovedFromEntity=function(){},e.prototype.onEntityTransformChanged=function(t){},e.prototype.debugRender=function(){},e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},e.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},e.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,t},e}(egret.HashObject);t.Component=e}(es||(es={})),function(t){var e=function(e){function i(){var n=e.call(this)||this;return n._globalManagers=[],i._instance=n,i.emitter=new t.Emitter,i.content=new t.ContentManager,n.addEventListener(egret.Event.ADDED_TO_STAGE,n.onAddToStage,n),n}return __extends(i,e),Object.defineProperty(i,"Instance",{get:function(){return this._instance},enumerable:!0,configurable:!0}),Object.defineProperty(i,"scene",{get:function(){return this._instance?this._instance._scene:null},set:function(t){t?null==this._instance._scene?(this._instance._scene=t,this._instance.addChild(t),this._instance._scene.begin(),i.Instance.onSceneChanged()):this._instance._nextScene=t:console.error("场景不能为空")},enumerable:!0,configurable:!0}),i.startSceneTransition=function(t){if(!this._instance._sceneTransition)return this._instance._sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},i.registerGlobalManager=function(t){this._instance._globalManagers.push(t),t.enabled=!0},i.unregisterGlobalManager=function(t){this._instance._globalManagers.remove(t),t.enabled=!1},i.getGlobalManager=function(t){for(var e=0;e<this._instance._globalManagers.length;e++)if(this._instance._globalManagers[e]instanceof t)return this._instance._globalManagers[e];return null},i.prototype.onOrientationChanged=function(){i.emitter.emit(t.CoreEvents.OrientationChanged)},i.prototype.draw=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this._sceneTransition?(this._sceneTransition.preRender(),!this._scene||this._sceneTransition.hasPreviousSceneRender?[3,2]:(this._scene.render(),this._scene.postRender(),[4,this._sceneTransition.onBeginTransition()])):[3,4];case 1:return e.sent(),[3,3];case 2:this._sceneTransition&&(this._scene&&this._sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this._sceneTransition.render()),e.label=3;case 3:return[3,5];case 4:this._scene&&(this._scene.render(),t.Debug.render(),this._scene.postRender()),e.label=5;case 5:return[2]}})})},i.prototype.startDebugUpdate=function(){t.TimeRuler.Instance.startFrame(),t.TimeRuler.Instance.beginMark("update",65280)},i.prototype.endDebugUpdate=function(){t.TimeRuler.Instance.endMark("update")},i.prototype.onSceneChanged=function(){i.emitter.emit(t.CoreEvents.SceneChanged),t.Time.sceneChanged()},i.prototype.onGraphicsDeviceReset=function(){i.emitter.emit(t.CoreEvents.GraphicsDeviceReset)},i.prototype.initialize=function(){},i.prototype.update=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:if(t.Time.update(egret.getTimer()),!this._scene)return[3,2];for(e=this._globalManagers.length-1;e>=0;e--)this._globalManagers[e].enabled&&this._globalManagers[e].update();return this._sceneTransition&&(!this._sceneTransition||this._sceneTransition.loadsNewScene&&!this._sceneTransition.isNewSceneLoaded)||this._scene.update(),this._nextScene?(this.removeChild(this._scene),this._scene.end(),this._scene=this._nextScene,this._nextScene=null,this.onSceneChanged(),this.addChild(this._scene),[4,this._scene.begin()]):[3,2];case 1:i.sent(),i.label=2;case 2:return[4,this.draw()];case 3:return i.sent(),[2]}})})},i.prototype.onAddToStage=function(){i.graphicsDevice=new t.GraphicsDevice,this.addEventListener(egret.Event.RESIZE,this.onGraphicsDeviceReset,this),this.addEventListener(egret.StageOrientationEvent.ORIENTATION_CHANGE,this.onOrientationChanged,this),this.addEventListener(egret.Event.ENTER_FRAME,this.update,this),t.Input.initialize(),this.initialize()},i.debugRenderEndabled=!1,i}(egret.DisplayObjectContainer);t.Core=e}(es||(es={})),function(t){!function(t){t[t.GraphicsDeviceReset=0]="GraphicsDeviceReset",t[t.SceneChanged=1]="SceneChanged",t[t.OrientationChanged=2]="OrientationChanged"}(t.CoreEvents||(t.CoreEvents={}))}(es||(es={})),function(t){var e=function(){function e(i){this.updateInterval=1,this._tag=0,this._enabled=!0,this._updateOrder=0,this.components=new t.ComponentList(this),this.transform=new t.Transform(this),this.name=i,this.id=e._idGenerator++,this.componentBits=new t.BitSet}return Object.defineProperty(e.prototype,"isDestroyed",{get:function(){return this._isDestroyed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parent",{get:function(){return this.transform.parent},set:function(t){this.transform.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"childCount",{get:function(){return this.transform.childCount},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this.transform.position},set:function(t){this.transform.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localPosition",{get:function(){return this.transform.localPosition},set:function(t){this.transform.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.transform.rotation},set:function(t){this.transform.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotationDegrees",{get:function(){return this.transform.rotationDegrees},set:function(t){this.transform.setRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotation",{get:function(){return this.transform.localRotation},set:function(t){this.transform.setLocalRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotationDegrees",{get:function(){return this.transform.localRotationDegrees},set:function(t){this.transform.setLocalRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return this.transform.scale},set:function(t){this.transform.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localScale",{get:function(){return this.transform.localScale},set:function(t){this.transform.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldInverseTransform",{get:function(){return this.transform.worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localToWorldTransform",{get:function(){return this.transform.localToWorldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldToLocalTransform",{get:function(){return this.transform.worldToLocalTransform},enumerable:!0,configurable:!0}),e.prototype.onTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.components.onEntityEnabled():this.components.onEntityDisabled()),this},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene&&(this.scene.entities.markEntityListUnsorted(),this.scene.entities.markTagUnsorted(this.tag)),this},e.prototype.destroy=function(){this._isDestroyed=!0,this.scene.entities.remove(this),this.transform.parent=null;for(var t=this.transform.childCount-1;t>=0;t--){this.transform.getChild(t).entity.destroy()}},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.transform.childCount;t++)this.transform.getChild(t).entity.detachFromScene()},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.transform.childCount;e++)this.transform.getChild(e).entity.attachToScene(t)},e.prototype.clone=function(i){void 0===i&&(i=new t.Vector2);var n=new e(this.name+"(clone)");return n.copyFrom(this),n.transform.position=i,n},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestroyed&&this.components.removeAllComponents()},e.prototype.update=function(){this.components.update()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),t.initialize(),t},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.compareTo=function(t){var e=this._updateOrder-t._updateOrder;return 0==e&&(e=this.id-t.id),e},e.prototype.toString=function(){return"[Entity: name: "+this.name+", tag: "+this.tag+", enabled: "+this.enabled+", depth: "+this.updateOrder+"]"},e.prototype.copyFrom=function(t){this.tag=t.tag,this.updateInterval=t.updateInterval,this.updateOrder=t.updateOrder,this.enabled=t.enabled,this.transform.scale=t.transform.scale,this.transform.rotation=t.transform.rotation;for(var e=0;e<t.components.count;e++)this.addComponent(t.components.buffer[e].clone());for(e=0;e<t.components._componentsToAdd.length;e++)this.addComponent(t.components._componentsToAdd[e].clone());for(e=0;e<t.transform.childCount;e++){var i=t.transform.getChild(e).entity,n=i.clone();n.transform.copyFrom(i.transform),n.transform.parent=this.transform}},e._idGenerator=0,e}();t.Entity=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.enablePostProcessing=!0,i._sceneComponents=[],i._renderers=[],i._postProcessors=[],i.entities=new t.EntityList(i),i.renderableComponents=new t.RenderableComponentList,i.content=new t.ContentManager,i.entityProcessors=new t.EntityProcessorList,i.initialize(),i}return __extends(i,e),i.createWithDefaultRenderer=function(){var e=new i;return e.addRenderer(new t.DefaultRenderer),e},i.prototype.initialize=function(){},i.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},i.prototype.unload=function(){},i.prototype.onActive=function(){},i.prototype.onDeactive=function(){},i.prototype.begin=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){return 0==this._renderers.length&&(this.addRenderer(new t.DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new t.Camera),t.Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.addEventListener(egret.Event.ACTIVATE,this.onActive,this),this.addEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart(),[2]})})},i.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren();for(t=0;t<this._sceneComponents.length;t++)this._sceneComponents[t].onRemovedFromScene();this._sceneComponents.length=0,this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.parent&&this.parent.removeChild(this),this.unload()},i.prototype.update=function(){this.entities.updateLists();for(var t=this._sceneComponents.length-1;t>=0;t--)this._sceneComponents[t].enabled&&this._sceneComponents[t].update();this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},i.prototype.render=function(){if(0!=this._renderers.length)for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this);else console.error("场景中没有渲染器!")},i.prototype.postRender=function(){if(this.enablePostProcessing)for(var e=0;e<this._postProcessors.length;e++)this._postProcessors[e].enabled&&this._postProcessors[e].process();if(this._screenshotRequestCallback){var i=new egret.RenderTexture;i.drawToTexture(this,new t.Rectangle(0,0,this.stage.stageWidth,this.stage.stageHeight)),this._screenshotRequestCallback(i),this._screenshotRequestCallback=null}},i.prototype.requestScreenshot=function(t){this._screenshotRequestCallback=t},i.prototype.addSceneComponent=function(t){return t.scene=this,t.onEnabled(),this._sceneComponents.push(t),this._sceneComponents.sort(t.compareTo),t},i.prototype.getSceneComponent=function(t){for(var e=0;e<this._sceneComponents.length;e++){var i=this._sceneComponents[e];if(i instanceof t)return i}return null},i.prototype.getOrCreateSceneComponent=function(t){var e=this.getSceneComponent(t);return null==e&&(e=this.addSceneComponent(new t)),e},i.prototype.removeSceneComponent=function(t){this._sceneComponents.contains(t)?(this._sceneComponents.remove(t),t.onRemovedFromScene()):console.warn("SceneComponent"+t+"不在SceneComponents列表中!")},i.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},i.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},i.prototype.removeRenderer=function(t){this._renderers.contains(t)&&(this._renderers.remove(t),t.unload())},i.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},i.prototype.getPostProcessor=function(t){for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e]instanceof t)return this._postProcessors[e];return null},i.prototype.removePostProcessor=function(t){this._postProcessors.contains(t)&&(this._postProcessors.remove(t),t.unload())},i.prototype.createEntity=function(e){var i=new t.Entity(e);return this.addEntity(i)},i.prototype.createEntityAsync=function(t){var e=this;return new Promise(function(i){i(e.createEntity(t))})},i.prototype.addEntity=function(t){this.entities.buffer.contains(t)&&console.warn("您试图将同一实体添加到场景两次: "+t),this.entities.add(t),t.scene=this;for(var e=0;e<t.transform.childCount;e++)this.addEntity(t.transform.getChild(e).entity);return t},i.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},i.prototype.findEntity=function(t){return this.entities.findEntity(t)},i.prototype.findEntitiesWithTag=function(t){return this.entities.entitiesWithTag(t)},i.prototype.entitiesOfType=function(t){return this.entities.entitiesOfType(t)},i.prototype.findComponentOfType=function(t){return this.entities.findComponentOfType(t)},i.prototype.findComponentsOfType=function(t){return this.entities.findComponentsOfType(t)},i.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},i.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},i.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},i}(egret.DisplayObjectContainer);t.Scene=e}(es||(es={})),function(t){!function(t){t[t.position=0]="position",t[t.scale=1]="scale",t[t.rotation=2]="rotation"}(t.Component||(t.Component={}))}(transform||(transform={})),function(t){var e,i=egret.HashObject;!function(t){t[t.clean=0]="clean",t[t.positionDirty=1]="positionDirty",t[t.scaleDirty=2]="scaleDirty",t[t.rotationDirty=3]="rotationDirty"}(e=t.DirtyType||(t.DirtyType={}));var n=function(i){function n(e){var n=i.call(this)||this;return n._localTransform=t.Matrix2D.create(),n._worldTransform=t.Matrix2D.create().identity(),n._rotationMatrix=t.Matrix2D.create(),n._translationMatrix=t.Matrix2D.create(),n._scaleMatrix=t.Matrix2D.create(),n._worldToLocalTransform=t.Matrix2D.create().identity(),n._worldInverseTransform=t.Matrix2D.create().identity(),n._position=t.Vector2.zero,n._scale=t.Vector2.one,n._rotation=0,n._localPosition=t.Vector2.zero,n._localScale=t.Vector2.one,n._localRotation=0,n.entity=e,n.scale=t.Vector2.one,n._children=[],n}return __extends(n,i),Object.defineProperty(n.prototype,"childCount",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._rotation)},set:function(e){this.setRotation(t.MathHelper.toRadians(e))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._localRotation)},set:function(e){this.localRotation=t.MathHelper.toRadians(e)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localToWorldTransform",{get:function(){return this.updateTransform(),this._worldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"parent",{get:function(){return this._parent},set:function(t){this.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldToLocalTransform",{get:function(){return this._worldToLocalDirty&&(this.parent?(this.parent.updateTransform(),this._worldToLocalTransform=this.parent._worldTransform.invert()):this._worldToLocalTransform=t.Matrix2D.create().identity(),this._worldToLocalDirty=!1),this._worldToLocalTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldInverseTransform",{get:function(){return this.updateTransform(),this._worldInverseDirty&&(this._worldInverseTransform=this._worldTransform.invert(),this._worldInverseDirty=!1),this._worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"position",{get:function(){return this.updateTransform(),this._positionDirty&&(this.parent?(this.parent.updateTransform(),this._position=t.Vector2Ext.transformR(this._localPosition,this.parent._worldTransform)):this._position=this._localPosition,this._positionDirty=!1),this._position},set:function(t){this.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"scale",{get:function(){return this.updateTransform(),this._scale},set:function(t){this.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotation",{get:function(){return this.updateTransform(),this._rotation},set:function(t){this.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localPosition",{get:function(){return this.updateTransform(),this._localPosition},set:function(t){this.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localScale",{get:function(){return this.updateTransform(),this._localScale},set:function(t){this.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotation",{get:function(){return this.updateTransform(),this._localRotation},set:function(t){this.setLocalRotation(t)},enumerable:!0,configurable:!0}),n.prototype.getChild=function(t){return this._children[t]},n.prototype.setParent=function(t){return this._parent.equals(t)?this:(this._parent||(this._parent._children.remove(this),this._parent._children.push(this)),this._parent=t,this.setDirty(e.positionDirty),this)},n.prototype.setPosition=function(e,i){var n=new t.Vector2(e,i);return n.equals(this._position)?this:(this._position=n,this.parent?this.localPosition=t.Vector2Ext.transformR(this._position,this._worldToLocalTransform):this.localPosition=n,this._positionDirty=!1,this)},n.prototype.setLocalPosition=function(t){return t.equals(this._localPosition)?this:(this._localPosition=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.positionDirty),this)},n.prototype.setRotation=function(t){return this._rotation=t,this.parent?this.localRotation=this.parent.rotation+t:this.localRotation=t,this},n.prototype.setRotationDegrees=function(e){return this.setRotation(t.MathHelper.toRadians(e))},n.prototype.lookAt=function(e){var i=this.position.x>e.x?-1:1,n=t.Vector2.normalize(t.Vector2.subtract(this.position,e));this.rotation=i*Math.acos(t.Vector2.dot(n,t.Vector2.unitY))},n.prototype.setLocalRotation=function(t){return this._localRotation=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.rotationDirty),this},n.prototype.setLocalRotationDegrees=function(e){return this.setLocalRotation(t.MathHelper.toRadians(e))},n.prototype.setScale=function(e){return this._scale=e,this.parent?this.localScale=t.Vector2.divide(e,this.parent._scale):this.localScale=e,this},n.prototype.setLocalScale=function(t){return this._localScale=t,this._localDirty=this._positionDirty=this._localScaleDirty=!0,this.setDirty(e.scaleDirty),this},n.prototype.roundPosition=function(){this.position=this._position.round()},n.prototype.updateTransform=function(){this.hierarchyDirty!=e.clean&&(this.parent&&this.parent.updateTransform(),this._localDirty&&(this._localPositionDirty&&(this._translationMatrix=t.Matrix2D.create().translate(this._localPosition.x,this._localPosition.y),this._localPositionDirty=!1),this._localRotationDirty&&(this._rotationMatrix=t.Matrix2D.create().rotate(this._localRotation),this._localRotationDirty=!1),this._localScaleDirty&&(this._scaleMatrix=t.Matrix2D.create().scale(this._localScale.x,this._localScale.y),this._localScaleDirty=!1),this._localTransform=this._scaleMatrix.multiply(this._rotationMatrix),this._localTransform=this._localTransform.multiply(this._translationMatrix),this.parent||(this._worldTransform=this._localTransform,this._rotation=this._localRotation,this._scale=this._localScale,this._worldInverseDirty=!0),this._localDirty=!1),this.parent&&(this._worldTransform=this._localTransform.multiply(this.parent._worldTransform),this._rotation=this._localRotation+this.parent._rotation,this._scale=t.Vector2.multiply(this.parent._scale,this._localScale),this._worldInverseDirty=!0),this._worldToLocalDirty=!0,this._positionDirty=!0,this.hierarchyDirty=e.clean)},n.prototype.setDirty=function(e){if(0==(this.hierarchyDirty&e)){switch(this.hierarchyDirty|=e,e){case t.DirtyType.positionDirty:this.entity.onTransformChanged(transform.Component.position);break;case t.DirtyType.rotationDirty:this.entity.onTransformChanged(transform.Component.rotation);break;case t.DirtyType.scaleDirty:this.entity.onTransformChanged(transform.Component.scale)}this._children||(this._children=[]);for(var i=0;i<this._children.length;i++)this._children[i].setDirty(e)}},n.prototype.copyFrom=function(t){this._position=t.position,this._localPosition=t._localPosition,this._rotation=t._rotation,this._localRotation=t._localRotation,this._scale=t._scale,this._localScale=t._localScale,this.setDirty(e.positionDirty),this.setDirty(e.rotationDirty),this.setDirty(e.scaleDirty)},n.prototype.toString=function(){return"[Transform: parent: "+this.parent+", position: "+this.position+", rotation: "+this.rotation+",\n                scale: "+this.scale+", localPosition: "+this._localPosition+", localRotation: "+this._localRotation+",\n                localScale: "+this._localScale+"]"},n.prototype.equals=function(t){return t.hashCode==this.hashCode},n}(i);t.Transform=n}(es||(es={})),function(t){var e;!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(e=t.CameraStyle||(t.CameraStyle={}));var i=function(){return function(){this.left=0,this.right=0,this.top=0,this.bottom=0}}();t.CameraInset=i;var n=function(n){function r(r,o){void 0===r&&(r=null),void 0===o&&(o=e.lockOn);var s=n.call(this)||this;return s._inset=new i,s._areMatrixedDirty=!0,s._areBoundsDirty=!0,s._isProjectionMatrixDirty=!0,s.followLerp=.1,s.deadzone=new t.Rectangle,s.focusOffset=t.Vector2.zero,s.mapLockEnabled=!1,s.mapSize=new t.Rectangle,s._desiredPositionDelta=new t.Vector2,s._worldSpaceDeadZone=new t.Rectangle,s._minimumZoom=.3,s._maximumZoom=3,s._bounds=new t.Rectangle,s._transformMatrix=(new t.Matrix2D).identity(),s._inverseTransformMatrix=(new t.Matrix2D).identity(),s._origin=t.Vector2.zero,s._targetEntity=r,s._cameraStyle=o,s.setZoom(0),s}return __extends(r,n),Object.defineProperty(r.prototype,"position",{get:function(){return this.entity.transform.position},set:function(t){this.entity.transform.position=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"rotation",{get:function(){return this.entity.transform.rotation},set:function(t){this.entity.transform.rotation=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?t.MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):t.MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"bounds",{get:function(){if(this._areMatrixedDirty&&this.updateMatrixes(),this._areBoundsDirty){var e=this.screenToWorldPoint(new t.Vector2(this._inset.left,this._inset.top)),i=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,t.Core.graphicsDevice.viewport.height-this._inset.bottom));if(0!=this.entity.transform.rotation){var n=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,this._inset.top)),r=this.screenToWorldPoint(new t.Vector2(this._inset.left,t.Core.graphicsDevice.viewport.height-this._inset.bottom)),o=Math.min(e.x,i.x,n.x,r.x),s=Math.max(e.x,i.x,n.x,r.x),a=Math.min(e.y,i.y,n.y,r.y),h=Math.max(e.y,i.y,n.y,r.y);this._bounds.location=new t.Vector2(o,a),this._bounds.width=s-o,this._bounds.height=h-a}else this._bounds.location=e,this._bounds.width=i.x-e.x,this._bounds.height=i.y-e.y;this._areBoundsDirty=!1}return this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"transformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._transformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"inverseTransformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._inverseTransformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t,this._areMatrixedDirty=!0)},enumerable:!0,configurable:!0}),r.prototype.onSceneSizeChanged=function(e,i){var n=this._origin;this.origin=new t.Vector2(e/2,i/2),this.entity.transform.position=t.Vector2.add(this.entity.transform.position,t.Vector2.subtract(this._origin,n))},r.prototype.setInset=function(t,e,n,r){return this._inset=new i,this._inset.left=t,this._inset.right=e,this._inset.top=n,this._inset.bottom=r,this._areBoundsDirty=!0,this},r.prototype.setPosition=function(t){return this.entity.transform.setPosition(t.x,t.y),this},r.prototype.setRotation=function(t){return this.entity.transform.setRotation(t),this},r.prototype.setZoom=function(e){var i=t.MathHelper.clamp(e,-1,1);return this._zoom=0==i?1:i<0?t.MathHelper.map(i,-1,0,this._minimumZoom,1):t.MathHelper.map(i,0,1,1,this._maximumZoom),this._areMatrixedDirty=!0,this},r.prototype.setMinimumZoom=function(t){if(!(t<=0))return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this;console.error("minimumZoom must be greater than zero")},r.prototype.setMaximumZoom=function(t){if(!(t<=0))return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this;console.error("maximumZoom must be greater than zero")},r.prototype.onEntityTransformChanged=function(t){this._areMatrixedDirty=!0},r.prototype.zoomIn=function(t){this.zoom+=t},r.prototype.zoomOut=function(t){this.zoom-=t},r.prototype.worldToScreenPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._transformMatrix)},r.prototype.screenToWorldPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._inverseTransformMatrix)},r.prototype.mouseToWorldPoint=function(){return this.screenToWorldPoint(t.Input.touchPosition)},r.prototype.onAddedToEntity=function(){this.follow(this._targetEntity,this._cameraStyle)},r.prototype.update=function(){var e=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*t.Core.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*t.Core.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this._targetEntity&&this.updateFollow(),this.position=t.Vector2.lerp(this.position,t.Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.transform.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.transform.roundPosition())},r.prototype.clampToMapSize=function(e){var i=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5)).add(new t.Vector2(this.mapSize.x,this.mapSize.y)),n=new t.Vector2(this.mapSize.width-i.x,this.mapSize.height-i.y);return t.Vector2.clamp(e,i,n)},r.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this._cameraStyle==e.lockOn){var i=this._targetEntity.transform.position.x,n=this._targetEntity.transform.position.y;this._worldSpaceDeadZone.x>i?this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<i&&(this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<n?this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>n&&(this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this._targetEntity.getComponent(t.Collider),!this._targetCollider))return;var r=this._targetEntity.getComponent(t.Collider).bounds;this._worldSpaceDeadZone.containsRect(r)||(this._worldSpaceDeadZone.left>r.left?this._desiredPositionDelta.x=r.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<r.right&&(this._desiredPositionDelta.x=r.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<r.bottom?this._desiredPositionDelta.y=r.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>r.top&&(this._desiredPositionDelta.y=r.top-this._worldSpaceDeadZone.top))}},r.prototype.follow=function(i,n){switch(void 0===n&&(n=e.cameraWindow),this._targetEntity=i,this._cameraStyle=n,this._cameraStyle){case e.cameraWindow:var r=this.bounds.width/6,o=this.bounds.height/3;this.deadzone=new t.Rectangle((this.bounds.width-r)/2,(this.bounds.height-o)/2,r,o);break;case e.lockOn:this.deadzone=new t.Rectangle(this.bounds.width/2,this.bounds.height/2,10,10)}},r.prototype.setCenteredDeadzone=function(e,i){this.deadzone=new t.Rectangle((this.bounds.width-e)/2,(this.bounds.height-i)/2,e,i)},r.prototype.updateMatrixes=function(){var e;this._areMatrixedDirty&&(this._transformMatrix=t.Matrix2D.create().translate(-this.entity.transform.position.x,-this.entity.transform.position.y),1!=this._zoom&&(e=t.Matrix2D.create().scale(this._zoom,this._zoom),this._transformMatrix=this._transformMatrix.multiply(e)),0!=this.entity.transform.rotation&&(e=t.Matrix2D.create().rotate(this.entity.transform.rotation),this._transformMatrix=this._transformMatrix.multiply(e)),e=t.Matrix2D.create().translate(this._origin.x,this._origin.y),this._transformMatrix=this._transformMatrix.multiply(e),this._inverseTransformMatrix=this._transformMatrix.invert(),this._areBoundsDirty=!0,this._areMatrixedDirty=!1)},r}(t.Component);t.Camera=n}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i._shakeDirection=t.Vector2.zero,i._shakeOffset=t.Vector2.zero,i._shakeIntensity=0,i._shakeDegredation=.95,i}return __extends(i,e),i.prototype.shake=function(e,i,n){void 0===e&&(e=15),void 0===i&&(i=.9),void 0===n&&(n=t.Vector2.zero),this.enabled=!0,this._shakeIntensity<e&&(this._shakeDirection=n,this._shakeIntensity=e,(i<0||i>=1)&&(i=.95),this._shakeDegredation=i)},i.prototype.update=function(){Math.abs(this._shakeIntensity)>0&&(this._shakeOffset=this._shakeDirection,0!=this._shakeOffset.x||0!=this._shakeOffset.y?this._shakeOffset.normalize():(this._shakeOffset.x=this._shakeOffset.x+Math.random()-.5,this._shakeOffset.y=this._shakeOffset.y+Math.random()-.5),this._shakeOffset.multiply(new t.Vector2(this._shakeIntensity)),this._shakeIntensity*=-this._shakeDegredation,Math.abs(this._shakeIntensity)<=.01&&(this._shakeIntensity=0,this.enabled=!1)),this.entity.scene.camera.position.add(this._shakeOffset)},i}(t.Component);t.CameraShake=e}(es||(es={})),function(t){var e=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}();t.ComponentPool=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return t.updateOrder-e.updateOrder},t}();t.IUpdatableComparer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Component);t.PooledComponent=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.displayObject=new egret.DisplayObject,i.color=0,i._areBoundsDirty=!0,i._localOffset=t.Vector2.zero,i._renderLayer=0,i._bounds=new t.Rectangle,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.bounds.width},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.bounds.height},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"renderLayer",{get:function(){return this._renderLayer},set:function(t){this.setRenderLayer(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return this._areBoundsDirty&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,t.Vector2.zero,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible!=t&&(this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible())},enumerable:!0,configurable:!0}),i.prototype.onEntityTransformChanged=function(t){this._areBoundsDirty=!0},i.prototype.isVisibleFromCamera=function(t){return this.isVisible=t.bounds.intersects(this.displayObject.getBounds().union(this.bounds)),this.isVisible},i.prototype.setRenderLayer=function(t){if(t!=this._renderLayer){var e=this._renderLayer;this._renderLayer=t,this.entity&&this.entity.scene&&this.entity.scene.renderableComponents.updateRenderableRenderLayer(this,e,this._renderLayer)}return this},i.prototype.setColor=function(t){return this.color=t,this},i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this._localOffset=t),this},i.prototype.sync=function(e){var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y),this.displayObject.scaleX!=this.entity.scale.x&&(this.displayObject.scaleX=this.entity.scale.x),this.displayObject.scaleY!=this.entity.scale.y&&(this.displayObject.scaleY=this.entity.scale.y),this.displayObject.rotation!=this.entity.rotation&&(this.displayObject.rotation=this.entity.rotation)},i.prototype.toString=function(){return"[RenderableComponent] renderLayer: "+this.renderLayer},i.prototype.onBecameVisible=function(){this.displayObject.visible=this.isVisible},i.prototype.onBecameInvisible=function(){this.displayObject.visible=this.isVisible},i}(t.Component);t.RenderableComponent=e}(es||(es={})),function(t){var e=function(){function e(){this.updateOrder=0,this._enabled=!0}return Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.onRemovedFromScene=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled),this},e.prototype.setUpdateOrder=function(e){return this.updateOrder!=e&&(this.updateOrder=e,t.Core.scene._sceneComponents.sort(this.compareTo)),this},e.prototype.compareTo=function(t){return this.updateOrder-t.updateOrder},e}();t.SceneComponent=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(i){function n(e){void 0===e&&(e=null);var n=i.call(this)||this;return e instanceof t.Sprite?n.setSprite(e):e instanceof egret.Texture&&n.setSprite(new t.Sprite(e)),n}return __extends(n,i),Object.defineProperty(n.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this._sprite.sourceRect.width,this._sprite.sourceRect.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"originNormalized",{get:function(){return new t.Vector2(this._origin.x/this.width*this.entity.transform.scale.x,this._origin.y/this.height*this.entity.transform.scale.y)},set:function(e){this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"origin",{get:function(){return this._origin},set:function(t){this.setOrigin(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),n.prototype.setSprite=function(t){return this._sprite=t,this._sprite&&(this._origin=this._sprite.origin,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y),this.displayObject=new e(t.texture2D),this},n.prototype.setOrigin=function(t){return this._origin!=t&&(this._origin=t,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y,this._areBoundsDirty=!0),this},n.prototype.setOriginNormalized=function(e){return this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y)),this},n.prototype.render=function(e){this.sync(e);var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y)},n}(t.RenderableComponent);t.SpriteRenderer=i}(es||(es={})),function(t){var e=egret.Bitmap,i=egret.RenderTexture,n=function(n){function r(e){var i=n.call(this,e)||this;return i._textureScale=t.Vector2.one,i._inverseTexScale=t.Vector2.one,i._gapX=0,i._gapY=0,i._sourceRect=e.sourceRect,i.displayObject.$fillMode=egret.BitmapFillMode.REPEAT,i}return __extends(r,n),Object.defineProperty(r.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollX",{get:function(){return this._sourceRect.x},set:function(t){this._sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollY",{get:function(){return this._sourceRect.y},set:function(t){this._sourceRect.y=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y),this._sourceRect.width=this._sprite.sourceRect.width*this._inverseTexScale.x,this._sourceRect.height=this._sprite.sourceRect.height*this._inverseTexScale.y},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"width",{get:function(){return this._sourceRect.width},set:function(t){this._areBoundsDirty=!0,this._sourceRect.width=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"height",{get:function(){return this._sourceRect.height},set:function(t){this._areBoundsDirty=!0,this._sourceRect.height=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"gapXY",{get:function(){return new t.Vector2(this._gapX,this._gapY)},set:function(t){this._gapX=t.x,this._gapY=t.y;var n=new i,r=this.sprite.sourceRect;r.x=0,r.y=0,r.width+=this._gapX,r.height+=this._gapY,n.drawToTexture(this.displayObject,r),this.displayObject?this.displayObject.texture=n:this.displayObject=new e(n)},enumerable:!0,configurable:!0}),r.prototype.setGapXY=function(t){return this.gapXY=t,this},r.prototype.render=function(t){n.prototype.render.call(this,t);var e=this.displayObject;e.width=this.width,e.height=this.height,e.scrollRect=this._sourceRect},r}(t.SpriteRenderer);t.TiledSpriteRenderer=n}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.scrollSpeedX=15,i.scroolSpeedY=0,i._scrollX=0,i._scrollY=0,i._scrollWidth=0,i._scrollHeight=0,i._scrollWidth=i.width,i._scrollHeight=i.height,i}return __extends(i,e),Object.defineProperty(i.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollWidth",{get:function(){return this._scrollWidth},set:function(t){this._scrollWidth=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollHeight",{get:function(){return this._scrollHeight},set:function(t){this._scrollHeight=t},enumerable:!0,configurable:!0}),i.prototype.update=function(){this.sprite&&(this._scrollX+=this.scrollSpeedX*t.Time.deltaTime,this._scrollY+=this.scroolSpeedY*t.Time.deltaTime,this._sourceRect.x=this._scrollX,this._sourceRect.y=this._scrollY,this._sourceRect.width=this._scrollWidth+Math.abs(this._scrollX),this._sourceRect.height=this._scrollHeight+Math.abs(this._scrollY))},i}(t.TiledSpriteRenderer);t.ScrollingSpriteRenderer=e}(es||(es={})),function(t){var e=function(){return function(e,i,n){void 0===i&&(i=new t.Rectangle(0,0,e.textureWidth,e.textureHeight)),void 0===n&&(n=i.getHalfSize()),this.uvs=new t.Rectangle,this.texture2D=e,this.sourceRect=i,this.center=new t.Vector2(.5*i.width,.5*i.height),this.origin=n;var r=1/e.textureWidth,o=1/e.textureHeight;this.uvs.x=i.x*r,this.uvs.y=i.y*o,this.uvs.width=i.width*r,this.uvs.height=i.height*o}}();t.Sprite=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.sprites=t,this.frameRate=e}}();t.SpriteAnimation=e}(es||(es={})),function(t){var e,i;!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(e=t.LoopMode||(t.LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(i=t.State||(t.State={}));var n=function(n){function r(t){var e=n.call(this,t)||this;return e.speed=1,e.animationState=i.none,e._elapsedTime=0,e._animations=new Map,e}return __extends(r,n),Object.defineProperty(r.prototype,"isRunning",{get:function(){return this.animationState==i.running},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),r.prototype.update=function(){if(this.animationState==i.running&&this.currentAnimation){var n=this.currentAnimation,r=1/(n.frameRate*this.speed),o=r*n.sprites.length;this._elapsedTime+=t.Time.deltaTime;var s=Math.abs(this._elapsedTime);if(this._loopMode==e.once&&s>o||this._loopMode==e.pingPongOnce&&s>2*o)return this.animationState=i.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=n.sprites[this.currentFrame]);var a=Math.floor(s/r),h=n.sprites.length;if(h>2&&(this._loopMode==e.pingPong||this._loopMode==e.pingPongOnce)){var c=h-1;this.currentFrame=c-Math.abs(c-a%(2*c))}else this.currentFrame=a%h;this.sprite=n.sprites[this.currentFrame]}},r.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},r.prototype.play=function(t,n){void 0===n&&(n=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=i.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=n||e.loop},r.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},r.prototype.pause=function(){this.animationState=i.paused},r.prototype.unPause=function(){this.animationState=i.running},r.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=i.none},r}(t.SpriteRenderer);t.SpriteAnimator=n}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"hasCollision",{get:function(){return this.below||this.right||this.left||this.above},enumerable:!0,configurable:!0}),t.prototype.reset=function(){this.becameGroundedThisFrame=this.isGroundedOnOnewayPlatform=this.right=this.left=this.above=this.below=!1,this.slopAngle=0},t.prototype.toString=function(){return"[CollisionState] r: "+this.right+", l: "+this.left+", a: "+this.above+", b: "+this.below+", angle: "+this.slopAngle+", wasGroundedLastFrame: "+this.wasGroundedLastFrame+", becameGroundedThisFrame: "+this.becameGroundedThisFrame},t}();t.CollisionState=e;var i=function(e){function i(){var t=e.call(this)||this;return t.colliderHorizontalInset=2,t.colliderVerticalInset=6,t}return __extends(i,e),i.prototype.testCollisions=function(e,i,n){this._boxColliderBounds=i,n.wasGroundedLastFrame=n.below,n.reset();var r=e.x;e.y;if(0!=r){var o=r>0?t.Edge.right:t.Edge.left,s=this.collisionRectForSide(o,r);this.testMapCollision(s,o,n,0)?(e.x=0-t.RectangleExt.getSide(i,o),n.left=o==t.Edge.left,n.right=o==t.Edge.right,n._movementRemainderX.reset()):(n.left=!1,n.right=!1)}},i.prototype.testMapCollision=function(e,i,n,r){var o=t.EdgeExt.oppositeEdge(i);t.EdgeExt.isVertical(o)?e.center.x:e.center.y,t.RectangleExt.getSide(e,i),t.EdgeExt.isVertical(o)},i.prototype.collisionRectForSide=function(e,i){var n;return n=t.EdgeExt.isHorizontal(e)?t.RectangleExt.getRectEdgePortion(this._boxColliderBounds,e):t.RectangleExt.getHalfRect(this._boxColliderBounds,e),t.EdgeExt.isVertical(e)?t.RectangleExt.contract(n,this.colliderHorizontalInset,0):t.RectangleExt.contract(n,0,this.colliderVerticalInset),t.RectangleExt.expandSide(n,e,i),n},i}(t.Component);t.TiledMapMover=i}(es||(es={})),function(t){var e=function(e){function i(t,i,n){void 0===i&&(i=null),void 0===n&&(n=!0);var r=e.call(this)||this;return r.physicsLayer=1,r.toContainer=!1,r.tiledMap=t,r._shouldCreateColliders=n,r.displayObject=new egret.DisplayObjectContainer,i&&(r.collisionLayer=t.tileLayers[i]),r}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.tiledMap.width*this.tiledMap.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.tiledMap.height*this.tiledMap.tileHeight},enumerable:!0,configurable:!0}),i.prototype.setLayerToRender=function(t){this.layerIndicesToRender=[],this.layerIndicesToRender[0]=this.getLayerIndex(t)},i.prototype.setLayersToRender=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];this.layerIndicesToRender=[];for(var i=0;i<t.length;i++)this.layerIndicesToRender[i]=this.getLayerIndex(t[i])},i.prototype.getLayerIndex=function(t){var e=this.tiledMap.getLayer(t);for(var i in this.tiledMap.layers)if(this.tiledMap.layers.hasOwnProperty(i)&&this.tiledMap.layers[i]==e)return 0;return-1},i.prototype.getRowAtWorldPosition=function(t){return t-=this.entity.transform.position.y+this._localOffset.y,this.tiledMap.worldToTilePositionY(t)},i.prototype.getColumnAtWorldPosition=function(t){return t-=this.entity.transform.position.x+this._localOffset.x,this.tiledMap.worldToTilePositionX(t)},i.prototype.onEntityTransformChanged=function(t){this._shouldCreateColliders&&t==transform.Component.position&&(this.removeColliders(),this.addColliders())},i.prototype.onAddedToEntity=function(){this.addColliders()},i.prototype.onRemovedFromEntity=function(){this.removeColliders()},i.prototype.update=function(){this.tiledMap.update()},i.prototype.render=function(e){if(this.sync(e),this.layerIndicesToRender)for(var i=0;i<this.tiledMap.layers.length;i++)this.tiledMap.layers[i].visible&&this.layerIndicesToRender.contains(i)&&t.TiledRendering.renderLayerRenderCamera(this.tiledMap.layers[i],this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer,e.bounds);else t.TiledRendering.renderMap(this.tiledMap,this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer);this.toContainer||(this.displayObject.cacheAsBitmap=!0,this.toContainer=!0)},i.prototype.addColliders=function(){if(this.collisionLayer&&this._shouldCreateColliders){var e=this.collisionLayer.getCollisionRectangles();this._colliders=[];for(var i=0;i<e.length;i++){var n=(new t.BoxCollider).createBoxRect(e[i].x+this._localOffset.x,e[i].y+this._localOffset.y,e[i].width,e[i].height);n.physicsLayer=this.physicsLayer,n.entity=this.entity,this._colliders[i]=n,t.Physics.addCollider(n)}}},i.prototype.removeColliders=function(){if(null!=this._colliders){for(var e=0,i=this._colliders;e<i.length;e++){var n=i[e];t.Physics.removeCollider(n)}this._colliders=null}},i}(t.RenderableComponent);t.TiledMapRenderer=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._triggerHelper=new t.ColliderTriggerHelper(this.entity)},i.prototype.calculateMovement=function(e,i){if(!this.entity.getComponent(t.Collider)||!this._triggerHelper)return!1;for(var n=this.entity.getComponents(t.Collider),r=0;r<n.length;r++){var o=n[r];if(!o.isTrigger){var s=o.bounds;s.x+=e.x,s.y+=e.y;for(var a=t.Physics.boxcastBroadphaseExcludingSelf(o,s,o.collidesWithLayers),h=0;h<a.length;h++){var c=a[h];if(!c.isTrigger){var u=new t.CollisionResult;o.collidesWith(c,e,u)&&(e=e.subtract(u.minimumTranslationVector),null!=u.collider&&(i=u))}}}}return t.ListPool.free(n),null!=i.collider},i.prototype.applyMovement=function(e){this.entity.position=t.Vector2.add(this.entity.position,e),this._triggerHelper&&this._triggerHelper.update()},i.prototype.move=function(t,e){return this.calculateMovement(t,e),this.applyMovement(t),null!=e.collider},i}(t.Component);t.Mover=e}(es||(es={})),function(t){var e=function(e){function i(){var t=null!==e&&e.apply(this,arguments)||this;return t._tempTriggerList=[],t}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(t.Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},i.prototype.move=function(e){if(!this._collider)return!1;var i=!1;this.entity.position=t.Vector2.add(this.entity.position,e);for(var n=t.Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),r=0;r<n.length;r++){var o=n[r];this._collider.overlaps(o)&&o.enabled&&(i=!0,this.notifyTriggerListeners(this._collider,o))}return i},i.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(e,t);this._tempTriggerList.length=0},i}(t.Component);t.ProjectileMover=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.physicsLayer=1,i.collidesWithLayers=t.Physics.allLayers,i.shouldColliderScaleAndRotateWithTransform=!0,i.registeredPhysicsBounds=new t.Rectangle,i._isPositionDirty=!0,i._isRotationDirty=!0,i._localOffset=t.Vector2.zero,i}return __extends(i,e),Object.defineProperty(i.prototype,"absolutePosition",{get:function(){return t.Vector2.add(this.entity.transform.position,this._localOffset)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"rotation",{get:function(){return this.shouldColliderScaleAndRotateWithTransform&&this.entity?this.entity.transform.rotation:0},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return(this._isPositionDirty||this._isRotationDirty)&&(this.shape.recalculateBounds(this),this._isPositionDirty=this._isRotationDirty=!1),this.shape.bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this.unregisterColliderWithPhysicsSystem(),this._localOffset=t,this._localOffsetLength=this._localOffset.length(),this._isPositionDirty=!0,this.registerColliderWithPhysicsSystem()),this},i.prototype.setShouldColliderScaleAndRotateWithTransform=function(t){return this.shouldColliderScaleAndRotateWithTransform=t,this._isPositionDirty=this._isRotationDirty=!0,this},i.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){if(!(this instanceof t.BoxCollider||this instanceof t.CircleCollider))return void console.error("Only box and circle colliders can be created automatically");var e=this.entity.getComponent(t.RenderableComponent);if(e){var i=e.bounds,n=i.width/this.entity.scale.x,r=i.height/this.entity.scale.y;this instanceof t.CircleCollider?this.radius=.5*Math.max(n,r):(this.width=n,this.height=r),this.localOffset=t.Vector2.subtract(i.center,this.entity.transform.position)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},i.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1},i.prototype.onEntityTransformChanged=function(e){switch(e){case transform.Component.position:case transform.Component.scale:this._isPositionDirty=!0;break;case transform.Component.rotation:this._isRotationDirty=!0}this._isColliderRegistered&&t.Physics.updateCollider(this)},i.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem(),this._isPositionDirty=this._isRotationDirty=!0},i.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},i.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(t.Physics.addCollider(this),this._isColliderRegistered=!0)},i.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&t.Physics.removeCollider(this),this._isColliderRegistered=!1},i.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},i.prototype.collidesWith=function(t,e,i){var n=this.entity.position;this.entity.position=this.entity.position.add(e);var r=this.shape.collidesWithShape(t.shape,i);return r&&(i.collider=t),this.entity.position=n,r},i.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,this.shape&&(t.shape=this.shape.clone()),t},i}(t.Component);t.Collider=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.shape=new t.Box(1,1),i._colliderRequiresAutoSizing=!0,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),i.prototype.createBoxRect=function(e,i,n,r){return this._localOffset=new t.Vector2(e+n/2,i+n/2),this.shape=new t.Box(n,r),this._colliderRequiresAutoSizing=!1,this},i.prototype.setSize=function(e,i){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e==n.width&&i==n.height||(n.updateBox(e,i),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setWidth=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.width&&(i.updateBox(e,i.height),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setHeight=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;e!=i.height&&(i.updateBox(i.width,e),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this))},i.prototype.toString=function(){return"[BoxCollider: bounds: "+this.bounds+"]"},i}(t.Collider);t.BoxCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;return i&&(n._colliderRequiresAutoSizing=!0),n.shape=new t.Circle(i||1),n}return __extends(i,e),Object.defineProperty(i.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),i.prototype.setRadius=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.radius&&(i.radius=e,i._originalRadius=e,this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.toString=function(){return"[CircleCollider: bounds: "+this.bounds+", radius: "+this.shape.radius+"]"},i}(t.Collider);t.CircleCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;i[0]==i[i.length-1]&&i.splice(i.length-1,1);var r=t.Polygon.findPolygonCenter(i);return n.setLocalOffset(r),t.Polygon.recenterPolygonVerts(i),n.shape=new t.Polygon(i),n}return __extends(i,e),i}(t.Collider);t.PolygonCollider=e}(es||(es={})),function(t){var e=function(){function e(e){this._entities=[],this._matcher=e||t.Matcher.empty()}return Object.defineProperty(e.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onChanged=function(t){var e=this._entities.contains(t),i=this._matcher.IsIntersted(t);i&&!e?this.add(t):!i&&e&&this.remove(t)},e.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},e.prototype.onAdded=function(t){},e.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},e.prototype.onRemoved=function(t){},e.prototype.update=function(){this.begin(),this.process(this._entities)},e.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},e.prototype.begin=function(){},e.prototype.process=function(t){},e.prototype.lateProcess=function(t){},e.prototype.end=function(){},e}();t.EntitySystem=e}(es||(es={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(t.EntitySystem);t.EntityProcessingSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(t.EntitySystem);t.PassiveSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(t.EntitySystem);t.ProcessingSystem=e}(es||(es={})),function(t){var e=function(){function t(e){void 0===e&&(e=64);var i=e>>6;0!=(e&t.LONG_MASK)&&i++,this._bits=new Array(i)}return t.prototype.and=function(t){for(var e,i=Math.min(this._bits.length,t._bits.length),n=0;n<i;++n)this._bits[n]&=t._bits[n];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var i=this._bits[e];if(0!=i)if(-1!=i){var n=((i=((i=(i>>1&0x5555555555555400)+(0x5555555555555400&i))>>2&0x3333333333333400)+(0x3333333333333400&i))>>32)+i;t+=((n=((n=(n>>4&252645135)+(252645135&n))>>8&16711935)+(16711935&n))>>16&65535)+(65535&n)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var i=0;i<this._bits.length;i++)this._bits[i]=0},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,i=1<<t;e<this._bits.length;){var n=this._bits[e];do{if(0!=(n&i))return t;i<<=1,t++}while(0!=i);i=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var i=t>>6;this.ensure(i),this._bits[i]|=1<<t}else this.clear(t)},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.LONG_MASK=63,t}();t.BitSet=e}(es||(es={})),function(t){var e=function(){function e(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isComponentListUnsorted=!0},e.prototype.add=function(t){this._componentsToAdd.push(t)},e.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},e.prototype.deregisterAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.removeChild(i.displayObject),this._entity.scene.renderableComponents.remove(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},e.prototype.registerAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.addChild(i.displayObject),this._entity.scene.renderableComponents.add(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},e.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var i=0;i<this._componentsToRemove.length;i++)this.handleRemove(this._componentsToRemove[i]),this._components.remove(this._componentsToRemove[i]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){i=0;for(var n=this._componentsToAdd.length;i<n;i++){(r=this._componentsToAdd[i])instanceof t.RenderableComponent&&(this._entity.scene.addChild(r.displayObject),this._entity.scene.renderableComponents.add(r)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(r)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(r),this._tempBufferList.push(r)}this._componentsToAdd.length=0,this._isComponentListUnsorted=!0;for(i=0;i<this._tempBufferList.length;i++){var r;(r=this._tempBufferList[i]).onAddedToEntity(),r.enabled&&r.onEnabled()}this._tempBufferList.length=0}this._isComponentListUnsorted&&(this._components.sort(e.compareUpdatableOrder.compare),this._isComponentListUnsorted=!1)},e.prototype.handleRemove=function(e){e instanceof t.RenderableComponent&&(this._entity.scene.removeChild(e.displayObject),this._entity.scene.renderableComponents.remove(e)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),e.onRemovedFromEntity(),e.entity=null},e.prototype.getComponent=function(t,e){for(var i=0;i<this._components.length;i++){if((n=this._components[i])instanceof t)return n}if(!e)for(i=0;i<this._componentsToAdd.length;i++){var n;if((n=this._componentsToAdd[i])instanceof t)return n}return null},e.prototype.getComponents=function(t,e){e||(e=[]);for(var i=0;i<this._components.length;i++){var n=this._components[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}for(i=0;i<this._componentsToAdd.length;i++){n=this._componentsToAdd[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}return e},e.prototype.update=function(){this.updateLists();for(var e=0;e<this._components.length;e++){var i=this._components[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},e.prototype.onEntityEnabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onEnabled()},e.prototype.onEntityDisabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onDisabled()},e.compareUpdatableOrder=new t.IUpdatableComparer,e}();t.ComponentList=e}(es||(es={})),function(t){var e=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}();t.ComponentTypeManager=e}(es||(es={})),function(t){var e=function(){function e(t){this._entities=[],this._entitiesToAdded=[],this._entitiesToRemove=[],this._entityDict=new Map,this._unsortedTags=[],this._tempEntityList=[],this.scene=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isEntityListUnsorted=!0},e.prototype.markTagUnsorted=function(t){this._unsortedTags.push(t)},e.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},e.prototype.remove=function(t){this._entitiesToRemove.contains(t)?this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t):console.warn("You are trying to remove an entity ("+t.name+") that you already removed")},e.prototype.removeAllEntities=function(){this._unsortedTags.length=0,this._entitiesToAdded.length=0,this._isEntityListUnsorted=!1,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestroyed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},e.prototype.contains=function(t){return this._entities.contains(t)||this._entitiesToAdded.contains(t)},e.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},e.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},e.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},e.prototype.update=function(){for(var e=0;e<this._entities.length;e++){var i=this._entities[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t.removeFromTagList(e),t._entities.remove(e),e.onRemovedFromScene(),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.addToTagList(e),t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0,this._isEntityListUnsorted=!0}this._isEntityListUnsorted&&(this._entities.sort(),this._isEntityListUnsorted=!1),this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},e.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},e.prototype.entitiesWithTag=function(e){for(var i=this.getTagList(e),n=t.ListPool.obtain(),r=0;r<i.length;r++)n.push(i[r]);return n},e.prototype.entitiesOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n]instanceof e&&i.push(this._entities[n]);return this._entitiesToAdded.forEach(function(t){t instanceof e&&i.push(t)}),i},e.prototype.findComponentOfType=function(t){for(var e=0;e<this._entities.length;e++){if(this._entities[e].enabled)if(i=this._entities[e].getComponent(t))return i}for(e=0;e<this._entitiesToAdded.length;e++){var i,n=this._entitiesToAdded[e];if(n.enabled)if(i=n.getComponent(t))return i}return null},e.prototype.findComponentsOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n].enabled&&this._entities[n].getComponents(e,i);for(n=0;n<this._entitiesToAdded.length;n++){var r=this._entitiesToAdded[n];r.enabled&&r.getComponents(e,i)}return i},e}();t.EntityList=e}(es||(es={})),function(t){var e=function(){function e(){this._processors=[]}return e.prototype.add=function(t){this._processors.push(t)},e.prototype.remove=function(t){this._processors.remove(t)},e.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},e.prototype.begin=function(){},e.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},e.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},e.prototype.end=function(){},e.prototype.getProcessor=function(){for(var e=0;e<this._processors.length;e++){var i=this._processors[e];if(i instanceof t.EntitySystem)return i}return null},e.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},e.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},e}();t.EntityProcessorList=e}(es||(es={})),function(t){var e=function(){function e(){this.allSet=new t.BitSet,this.exclusionSet=new t.BitSet,this.oneSet=new t.BitSet}return e.empty=function(){return new e},e.prototype.getAllSet=function(){return this.allSet},e.prototype.getExclusionSet=function(){return this.exclusionSet},e.prototype.getOneSet=function(){return this.oneSet},e.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},e.prototype.all=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.allSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.exclude=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.exclusionSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.one=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.oneSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e}();t.Matcher=e}(es||(es={}));var ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var i in t)"object"==typeof t[i]?(e[i]=t[i]instanceof Array?[]:{},this.clone(t[i],e[i])):e[i]=t[i];return e},t.elements=function(t){var e=[];for(var i in t)if(Array.isArray(t[i]))for(var n=0,r=t[i];n<r.length;n++){var o=r[n];e.push(o)}else e.push(t[i]);return e},t}();!function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return e.renderLayer-t.renderLayer},t}();t.RenderableComparer=e}(es||(es={})),function(t){var e=function(){function e(){this._components=[],this._componentsByRenderLayer=new Map,this._unsortedRenderLayers=[],this._componentsNeedSort=!0}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.add=function(t){this._components.push(t),this.addToRenderLayerList(t,t.renderLayer)},e.prototype.remove=function(t){this._components.remove(t),this._componentsByRenderLayer.get(t.renderLayer).remove(t)},e.prototype.updateRenderableRenderLayer=function(t,e,i){this._componentsByRenderLayer.has(e)&&this._componentsByRenderLayer.get(e).contains(t)&&(this._componentsByRenderLayer.get(e).remove(t),this.addToRenderLayerList(t,i))},e.prototype.setRenderLayerNeedsComponentSort=function(t){this._unsortedRenderLayers.contains(t)||this._unsortedRenderLayers.push(t),this._componentsNeedSort=!0},e.prototype.setNeedsComponentSort=function(){this._componentsNeedSort=!0},e.prototype.addToRenderLayerList=function(t,e){var i=this.componentsWithRenderLayer(e);i.contains(t)?console.warn("组件呈现层列表已经包含此组件"):(i.push(t),this._unsortedRenderLayers.contains(e)||this._unsortedRenderLayers.push(e),this._componentsNeedSort=!0)},e.prototype.componentsWithRenderLayer=function(t){return this._componentsByRenderLayer.get(t)||this._componentsByRenderLayer.set(t,[]),this._componentsByRenderLayer.get(t)},e.prototype.updateList=function(){if(this._componentsNeedSort&&(this._components.sort(e.compareUpdatableOrder.compare),this._componentsNeedSort=!1,this.updateEgretList()),this._unsortedRenderLayers.length>0){for(var t=0,i=this._unsortedRenderLayers.length;t<i;t++){var n=this._componentsByRenderLayer.get(this._unsortedRenderLayers[t]);n&&n.sort(e.compareUpdatableOrder.compare)}this._unsortedRenderLayers.length=0,this.updateEgretList()}},e.prototype.updateEgretList=function(){var e=t.Core._instance._scene;if(e)for(var i=function(t){var i=n._components[t],r=e.$children.find(function(t){return t.hashCode==i.displayObject.hashCode}),o=e.getChildIndex(r);o!=t&&e.swapChildrenAt(o,t)},n=this,r=0;r<this._components.length;r++)i(r)},e.compareUpdatableOrder=new t.RenderableComparer,e}();t.RenderableComponentList=e}(es||(es={}));var StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,i,n){void 0===n&&(n=!1);for(var r=t.length,o="",s=!1,a=1==n?e.toLowerCase():e,h=0;h<r;h++)s=!1,t.charAt(h)==a.charAt(0)&&t.substr(h,a.length)==a&&(s=!0),s?(o+=i,h=h+a.length-1):o+=t.charAt(h);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var i=this.specialSigns.length,n=0;n<i;n+=2){var r=void 0,o=void 0;if(r=this.specialSigns[n],o=this.specialSigns[n+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var i=t.length;if(i>=e)return t;var n=!1;"-"==t.substr(0,1)&&(n=!0,t=t.substr(1));for(var r=e-i,o=0;o<r;o++)t="0"+t;return n&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,i,n){void 0===n&&(n=!0),e=Math.floor(e),i=Math.floor(i);var r=t.length;e>r&&(e=r);var o,s=e,a=e+i;return n?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-i)+i,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var i=0,n=e.length;i<n;i++)null!=e[i]&&""!=e[i]||(e[i]="无"),t=t.replace("{"+i+"}",e[i]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}();!function(t){var e=function(){function e(){}return e.convertImageToCanvas=function(e,i){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var n=e.$getTextureWidth(),r=e.$getTextureHeight();i||((i=egret.$TempRectangle).x=0,i.y=0,i.width=n,i.height=r),i.x=Math.min(i.x,n-1),i.y=Math.min(i.y,r-1),i.width=Math.min(i.width,n-i.x),i.height=Math.min(i.height,r-i.y);var o=Math.floor(i.width),s=Math.floor(i.height),a=this.sharedCanvas;if(a.style.width=o+"px",a.style.height=s+"px",this.sharedCanvas.width=o,this.sharedCanvas.height=s,"webgl"==egret.Capabilities.renderMode){var h=void 0;e.$renderBuffer?h=e:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(h=new egret.RenderTexture).drawToTexture(new egret.Bitmap(e)));for(var c=h.$renderBuffer.getPixels(i.x,i.y,o,s),u=0,l=0,p=0;p<c.length;p+=4)this.sharedContext.fillStyle="rgba("+c[p]+","+c[p+1]+","+c[p+2]+","+c[p+3]/255+")",this.sharedContext.fillRect(u,l,1,1),++u==o&&(u=0,l++);return e.$renderBuffer||h.dispose(),a}var d=e,f=Math.round(d.$offsetX),g=Math.round(d.$offsetY),m=d.$bitmapWidth,y=d.$bitmapHeight,_=t.Core._instance.stage.textureScaleFactor;return this.sharedContext.drawImage(d.$bitmapData.source,d.$bitmapX+i.x/_,d.$bitmapY+i.y/_,m*i.width/n,y*i.height/r,f,g,i.width,i.height),a},e.toDataURL=function(t,e,i,n){try{return this.convertImageToCanvas(e,i).toDataURL(t,n)}catch(t){egret.$error(1033)}return null},e.eliFoTevas=function(t,e,i,n,r){var o=this.convertImageToCanvas(e,n).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+i,success:function(t){}}),o},e.getPixel32=function(t,e,i){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,i)},e.getPixels=function(t,e,i,n,r){if(void 0===n&&(n=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,i,n,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,i,n,r).data}catch(t){egret.$error(1039)}},e}();t.TextureUtils=e}(es||(es={})),function(t){var e=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}();t.Time=e}(es||(es={}));var TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),i=t.getMonth()+1;return parseInt(e+(i<10?"0":"")+i)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,i=e<10?"0":"",n=t.getDate(),r=n<10?"0":"";return parseInt(t.getFullYear()+i+e+r+n)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var i=new Date;i.setTime(t.getTime()),i.setDate(1),i.setMonth(0);var n=i.getFullYear(),r=i.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,i.setDate(i.getDate()-(r-1))):i.setDate(i.getDate()+7-r+1);var s=this.diffDay(t,i,!1);if(s<0)return i.setDate(1),i.setMonth(0),i.setDate(i.getDate()-1),this.weekId(i,!1);var a=s/7,h=Math.floor(a)+1;if(53==h){i.setTime(t.getTime()),i.setDate(i.getDate()-1);var c=i.getDay();if(0==c&&(c=7),e&&(!o||c<4))return i.setFullYear(i.getFullYear()+1),i.setDate(1),i.setMonth(0),this.weekId(i,!1)}return parseInt(n+"00"+(h>9?"":"0")+h)},t.diffDay=function(t,e,i){void 0===i&&(i=!1);var n=(t.getTime()-e.getTime())/864e5;return i?Math.ceil(n):Math.floor(n)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();return e+"-"+i+"-"+(n=n<10?"0"+n:n)},t.formatDateTime=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();n=n<10?"0"+n:n;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+i+"-"+n+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,i){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===i&&(i=!0);var n=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=n.toString(),a=r.toString(),h=o.toString();return n<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(h="0"+h),i?s+e+a+e+h:a+e+h},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var i=t.split(e),n=0,r=i.length,o=0;o<r;o++){n+=i[o]*Math.pow(60,r-1-o)}return(n*=1e3).toString()},t}();!function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){if(e.runtimeType==egret.RuntimeType.WXGAME){this.isMobile=!0;var i=wx.getSystemInfoSync(),n=i.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var r=i.language;r=r.indexOf("zh")>-1?"zh-CN":"en-US",this.language=r}},e}(egret.Capabilities);t.GraphicsCapabilities=e}(es||(es={})),function(t){var e=function(){function e(){this.setup(),this.graphicsCapabilities=new t.GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}return Object.defineProperty(e.prototype,"viewport",{get:function(){return this._viewport},enumerable:!0,configurable:!0}),e.prototype.setup=function(){this._viewport=new t.Viewport(0,0,t.Core._instance.stage.stageWidth,t.Core._instance.stage.stageHeight)},e}();t.GraphicsDevice=e}(es||(es={})),function(t){var e=function(){function e(t,e,i,n){this._x=t,this._y=e,this._width=i,this._height=n,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(e.prototype,"width",{get:function(){return this._width},set:function(t){this._width=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"height",{get:function(){return this._height},set:function(t){this._height=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new t.Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),e}();t.Viewport=e}(es||(es={})),function(t){var e=function(e){function i(){return e.call(this,t.PostProcessor.default_vert,i.blur_frag,{screenWidth:t.Core.graphicsDevice.viewport.width,screenHeight:t.Core.graphicsDevice.viewport.height})||this}return __extends(i,e),i.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",i}(egret.CustomFilter);t.GaussianBlurEffect=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter);t.PolygonLightEffect=e}(es||(es={})),function(t){var e=function(){function e(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return e.prototype.onAddedToScene=function(e){this.scene=e,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.shape.graphics.endFill(),e.addChild(this.shape)},e.prototype.process=function(){this.drawFullscreenQuad()},e.prototype.onSceneBackBufferSizeChanged=function(t,e){},e.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},e.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},e.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",e}();t.PostProcessor=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToScene=function(i){e.prototype.onAddedToScene.call(this,i),this.effect=new t.GaussianBlurEffect},i}(t.PostProcessor);t.GaussianBlurPostProcessor=e}(es||(es={})),function(t){var e=function(){function t(t,e){void 0===e&&(e=null),this.renderOrder=0,this.camera=e,this.renderOrder=t}return t.prototype.onAddedToScene=function(t){},t.prototype.unload=function(){},t.prototype.onSceneBackBufferSizeChanged=function(t,e){},t.prototype.compareTo=function(t){return this.renderOrder-t.renderOrder},t.prototype.beginRender=function(t){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t}();t.Renderer=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,0,null)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var i=0;i<t.renderableComponents.count;i++){var n=t.renderableComponents.buffer[i];n.enabled&&n.isVisibleFromCamera(e)&&this.renderAfterStateCheck(n,e)}},e}(t.Renderer);t.DefaultRenderer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){},e}(t.Renderer);t.ScreenSpaceRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e,i,n){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=n,r.color=i,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e}(t.RenderableComponent);t.PolyLight=e}(es||(es={})),function(t){var e=function(){function e(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(e.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),e.prototype.preRender=function(){},e.prototype.render=function(){},e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},e.prototype.tickEffectProgressProperty=function(t,e,i,n){return void 0===n&&(n=!1),new Promise(function(r){var o=n?1:0,s=n?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,i).call(function(){r()})})},e.prototype.transitionComplete=function(){t.Core._instance._sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},e.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),e=t.Core,[4,this.sceneLoadAction()];case 1:return e.scene=i.sent(),this.isNewSceneLoaded=!0,[2]}})})},e}();t.SceneTransition=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.fadeToColor=0,i.fadeOutDuration=.4,i.fadeEaseType=egret.Ease.quadInOut,i.delayBeforeFadeInDuration=.1,i._alpha=0,i._mask=new egret.Shape,i}return __extends(i,e),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var e=this;return __generator(this,function(i){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill(),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(e,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(e).to({_alpha:0},1e3*e.fadeOutDuration,e.fadeEaseType).call(function(){e.transitionComplete()})}),[2]})})},i.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill()},i}(t.SceneTransition);t.FadeTransition=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this,i)||this;n.duration=1,n.easeType=egret.Ease.quadOut;return n._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),n._mask=new egret.Shape,n._mask.graphics.beginFill(16777215,1),n._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),n._mask.graphics.endFill(),n._mask.filters=[n._windEffect],n}return __extends(i,e),Object.defineProperty(i.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return t.sent(),this.transitionComplete(),[2]}})})},i}(t.SceneTransition);t.WindTransition=e}(es||(es={})),function(t){var e=function(){function e(){}return e.getPoint=function(e,i,n,r){var o=1-(r=t.MathHelper.clamp01(r));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(o*o),e),t.Vector2.multiply(new t.Vector2(2*o*r),i)),t.Vector2.multiply(new t.Vector2(r*r),n))},e.getFirstDerivative=function(e,i,n,r){return t.Vector2.add(t.Vector2.multiply(new t.Vector2(2*(1-r)),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(2*r),t.Vector2.subtract(n,i)))},e.getFirstDerivativeThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(3*s*s),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(6*s*o),t.Vector2.subtract(n,i))),t.Vector2.multiply(new t.Vector2(3*o*o),t.Vector2.subtract(r,n)))},e.getPointThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(s*s*s),e),t.Vector2.multiply(new t.Vector2(3*s*s*o),i)),t.Vector2.multiply(new t.Vector2(3*s*o*o),n)),t.Vector2.multiply(new t.Vector2(o*o*o),r))},e.getOptimizedDrawingPoints=function(e,i,n,r,o){void 0===o&&(o=1);var s=t.ListPool.obtain();return s.push(e),this.recursiveGetOptimizedDrawingPoints(e,i,n,r,s,o),s.push(r),s},e.recursiveGetOptimizedDrawingPoints=function(e,i,n,r,o,s){var a=t.Vector2.divide(t.Vector2.add(e,i),new t.Vector2(2)),h=t.Vector2.divide(t.Vector2.add(i,n),new t.Vector2(2)),c=t.Vector2.divide(t.Vector2.add(n,r),new t.Vector2(2)),u=t.Vector2.divide(t.Vector2.add(a,h),new t.Vector2(2)),l=t.Vector2.divide(t.Vector2.add(h,c),new t.Vector2(2)),p=t.Vector2.divide(t.Vector2.add(u,l),new t.Vector2(2)),d=t.Vector2.subtract(r,e),f=Math.abs((i.x,r.x*d.y-(i.y-r.y)*d.x)),g=Math.abs((n.x-r.x)*d.y-(n.y-r.y)*d.x);(f+g)*(f+g)<s*(d.x*d.x+d.y*d.y)?o.push(p):(this.recursiveGetOptimizedDrawingPoints(e,a,u,p,o,s),this.recursiveGetOptimizedDrawingPoints(p,l,c,r,o,s))},e}();t.Bezier=e}(es||(es={})),function(t){var e=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}();t.Flags=e}(es||(es={})),function(t){var e=function(){function e(){}return e.toDegrees=function(t){return 57.29577951308232*t},e.toRadians=function(t){return.017453292519943295*t},e.map=function(t,e,i,n,r){return n+(t-e)*(r-n)/(i-e)},e.lerp=function(t,e,i){return t+(e-t)*i},e.clamp=function(t,e,i){return t<e?e:t>i?i:t},e.pointOnCirlce=function(i,n,r){var o=e.toRadians(r);return new t.Vector2(Math.cos(o)*o+i.x,Math.sin(o)*o+i.y)},e.isEven=function(t){return t%2==0},e.clamp01=function(t){return t<0?0:t>1?1:t},e.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},e.incrementWithWrap=function(t,e){return++t==e?0:t},e.Epsilon=1e-5,e.Rad2Deg=57.29578,e.Deg2Rad=.0174532924,e.PiOver2=Math.PI/2,e}();t.MathHelper=e}(es||(es={})),function(t){t.matrixPool=[];var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"m11",{get:function(){return this.a},set:function(t){this.a=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m12",{get:function(){return this.b},set:function(t){this.b=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m21",{get:function(){return this.c},set:function(t){this.c=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m22",{get:function(){return this.d},set:function(t){this.d=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m31",{get:function(){return this.tx},set:function(t){this.tx=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m32",{get:function(){return this.ty},set:function(t){this.ty=t},enumerable:!0,configurable:!0}),i.create=function(){var e=t.matrixPool.pop();return e||(e=new i),e},i.prototype.identity=function(){return this.a=this.d=1,this.b=this.c=this.tx=this.ty=0,this},i.prototype.translate=function(t,e){return this.tx+=t,this.ty+=e,this},i.prototype.scale=function(t,e){return 1!==t&&(this.a*=t,this.c*=t,this.tx*=t),1!==e&&(this.b*=e,this.d*=e,this.ty*=e),this},i.prototype.rotate=function(t){if(0!==(t=+t)){t/=DEG_TO_RAD;var e=Math.cos(t),i=Math.sin(t),n=this.a,r=this.b,o=this.c,s=this.d,a=this.tx,h=this.ty;this.a=n*e-r*i,this.b=n*i+r*e,this.c=o*e-s*i,this.d=o*i+s*e,this.tx=a*e-h*i,this.ty=a*i+h*e}return this},i.prototype.invert=function(){return this.$invertInto(this),this},i.prototype.add=function(t){return this.m11+=t.m11,this.m12+=t.m12,this.m21+=t.m21,this.m22+=t.m22,this.m31+=t.m31,this.m32+=t.m32,this},i.prototype.substract=function(t){return this.m11-=t.m11,this.m12-=t.m12,this.m21-=t.m21,this.m22-=t.m22,this.m31-=t.m31,this.m32-=t.m32,this},i.prototype.divide=function(t){return this.m11/=t.m11,this.m12/=t.m12,this.m21/=t.m21,this.m22/=t.m22,this.m31/=t.m31,this.m32/=t.m32,this},i.prototype.multiply=function(t){var e=this.m11*t.m11+this.m12*t.m21,i=this.m11*t.m12+this.m12*t.m22,n=this.m21*t.m11+this.m22*t.m21,r=this.m21*t.m12+this.m22*t.m22,o=this.m31*t.m11+this.m32*t.m21+t.m31,s=this.m31*t.m12+this.m32*t.m22+t.m32;return this.m11=e,this.m12=i,this.m21=n,this.m22=r,this.m31=o,this.m32=s,this},i.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},i.prototype.release=function(e){e&&t.matrixPool.push(e)},i}(egret.Matrix);t.Matrix2D=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"max",{get:function(){return new t.Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"center",{get:function(){return new t.Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"location",{get:function(){return new t.Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{get:function(){return new t.Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),i.fromMinMax=function(t,e,n,r){return new i(t,e,n-t,r-e)},i.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,i=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>n&&(n=s.x),s.y<i&&(i=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,i,n,r)},i.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},i.prototype.rayIntersects=function(t){var e=0,i=Number.MAX_VALUE;if(Math.abs(t.direction.x)<1e-6){if(t.start.x<this.x||t.start.x>this.x+this.width)return e}else{var n=1/t.direction.x,r=(this.x-t.start.x)*n,o=(this.x+this.width-t.start.x)*n;if(r>o){var s=r;r=o,o=s}if((e=Math.max(r,e))>(i=Math.min(o,i)))return e}if(Math.abs(t.direction.y)<1e-6){if(t.start.y<this.y||t.start.y>this.y+this.height)return e}else{var a=1/t.direction.y,h=(this.y-t.start.y)*a,c=(this.y+this.height-t.start.y)*a;if(h>c){var u=h;h=c,c=u}if((e=Math.max(h,e))>(i=Math.max(c,i)))return e}return e},i.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},i.prototype.contains=function(t,e){return this.x<=t&&t<this.x+this.width&&this.y<=e&&e<this.y+this.height},i.prototype.getHalfSize=function(){return new t.Vector2(.5*this.width,.5*this.height)},i.prototype.getClosestPointOnRectangleBorderToPoint=function(e,i){i=t.Vector2.zero;var n=new t.Vector2;if(n.x=t.MathHelper.clamp(e.x,this.left,this.right),n.y=t.MathHelper.clamp(e.y,this.top,this.bottom),this.contains(n.x,n.y)){var r=n.x-this.left,o=this.right-n.x,s=n.y-this.top,a=this.bottom-n.y,h=Math.min(r,o,s,a);h==s?(n.y=this.top,i.y=-1):h==a?(n.y=this.bottom,i.y=1):h==r?(n.x=this.left,i.x=-1):(n.x=this.right,i.x=1)}else n.x==this.left&&(i.x=-1),n.x==this.right&&(i.x=1),n.y==this.top&&(i.y=-1),n.y==this.bottom&&(i.y=1);return n},i.prototype.getClosestPointOnBoundsToOrigin=function(){var e=this.max,i=Math.abs(this.location.x),n=new t.Vector2(this.location.x,0);return Math.abs(e.x)<i&&(i=Math.abs(e.x),n.x=e.x,n.y=0),Math.abs(e.y)<i&&(i=Math.abs(e.y),n.x=0,n.y=e.y),Math.abs(this.location.y)<i&&(i=Math.abs(this.location.y),n.x=0,n.y=this.location.y),n},i.prototype.calculateBounds=function(e,i,n,r,o,s,a){if(0==o)this.x=e.x+i.x-n.x*r.x,this.y=e.y+i.y-n.y*r.y,this.width=s*r.x,this.height=a*r.y;else{var h=e.x+i.x,c=e.y+i.y;this._transformMat=t.Matrix2D.create().translate(-h-n.x,-c-n.y),this._tempMat=t.Matrix2D.create().scale(r.x,r.y),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().rotate(o),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().translate(h,c),this._transformMat=this._transformMat.multiply(this._tempMat);var u=new t.Vector2(h,c),l=new t.Vector2(h+s,c),p=new t.Vector2(h,c+a),d=new t.Vector2(h+s,c+a);u=t.Vector2Ext.transformR(u,this._transformMat),l=t.Vector2Ext.transformR(l,this._transformMat),p=t.Vector2Ext.transformR(p,this._transformMat),d=t.Vector2Ext.transformR(d,this._transformMat);var f=Math.min(u.x,d.x,l.x,p.x),g=Math.max(u.x,d.x,l.x,p.x),m=Math.min(u.y,d.y,l.y,p.y),y=Math.max(u.y,d.y,l.y,p.y);this.location=new t.Vector2(f,m),this.width=g-f,this.height=y-m}},i}(egret.Rectangle);t.Rectangle=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.x=t,this.y=e,this.z=i}}();t.Vector3=e}(es||(es={})),function(t){var e=function(){function e(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return e.prototype.update=function(){for(var e=this._entity.getComponents(t.Collider),i=0;i<e.length;i++)for(var n=e[i],r=t.Physics.boxcastBroadphase(n.bounds,n.collidesWithLayers),o=function(e){var i=r[e];if(!n.isTrigger&&!i.isTrigger)return"continue";if(n.overlaps(i)){var o=new t.Pair(n,i);-1==s._activeTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&-1==s._previousTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&s.notifyTriggerListeners(o,!0),s._activeTriggerIntersections.contains(o)||s._activeTriggerIntersections.push(o)}},s=this,a=0;a<r.length;a++)o(a);t.ListPool.free(e),this.checkForExitedColliders()},e.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var n=i._previousTriggerIntersections.findIndex(function(i){return i.first==t._activeTriggerIntersections[e].first&&i.second==t._activeTriggerIntersections[e].second});-1!=n&&i._previousTriggerIntersections.removeAt(n)},i=this,n=0;n<this._activeTriggerIntersections.length;n++)e(n);for(n=0;n<this._previousTriggerIntersections.length;n++)this.notifyTriggerListeners(this._previousTriggerIntersections[n],!1);this._previousTriggerIntersections.length=0;for(n=0;n<this._activeTriggerIntersections.length;n++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[n])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[n]);this._activeTriggerIntersections.length=0},e.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)if(e?this._tempTriggerList[i].onTriggerEnter(t.second,t.first):this._tempTriggerList[i].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)e?this._tempTriggerList[n].onTriggerEnter(t.first,t.second):this._tempTriggerList[n].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},e}();t.ColliderTriggerHelper=e}(es||(es={})),function(t){var e;!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(e=t.PointSectors||(t.PointSectors={}));var i=function(){function i(){}return i.isLineToLine=function(e,i,n,r){var o=t.Vector2.subtract(i,e),s=t.Vector2.subtract(r,n),a=o.x*s.y-o.y*s.x;if(0==a)return!1;var h=t.Vector2.subtract(n,e),c=(h.x*s.y-h.y*s.x)/a;if(c<0||c>1)return!1;var u=(h.x*o.y-h.y*o.x)/a;return!(u<0||u>1)},i.lineToLineIntersection=function(e,i,n,r){var o=new t.Vector2(0,0),s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return o;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return o;var l=(c.x*s.y-c.y*s.x)/h;return l<0||l>1?o:o=t.Vector2.add(e,new t.Vector2(u*s.x,u*s.y))},i.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,new t.Vector2(r.x*s,r.y*s))},i.isCircleToCircle=function(e,i,n,r){return t.Vector2.distanceSquared(e,n)<(i+r)*(i+r)},i.isCircleToLine=function(e,i,n,r){return t.Vector2.distanceSquared(e,this.closestPointOnLine(n,r,e))<i*i},i.isCircleToPoint=function(e,i,n){return t.Vector2.distanceSquared(e,n)<i*i},i.isRectToCircle=function(t,e,i){var n=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-n),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<i*i},i.isRectToLine=function(i,n,r){var o=this.getSector(i.x,i.y,i.width,i.height,n),s=this.getSector(i.x,i.y,i.width,i.height,r);if(o==e.center||s==e.center)return!0;if(0!=(o&s))return!1;var a=o|s,h=void 0,c=void 0;return!(0==(a&e.top)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x+i.width,i.y),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.bottom)||(h=new t.Vector2(i.x,i.y+i.height),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.left)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x,i.y+i.height),!this.isLineToLine(h,c,n,r)))||!(0==(a&e.right)||(h=new t.Vector2(i.x+i.width,i.y),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))))},i.isRectToPoint=function(t,e,i,n,r){return r.x>=t&&r.y>=e&&r.x<t+i&&r.y<e+n},i.getSector=function(t,i,n,r,o){var s=e.center;return o.x<t?s|=e.left:o.x>=t+n&&(s|=e.right),o.y<i?s|=e.top:o.y>=i+r&&(s|=e.bottom),s},i}();t.Collisions=i}(es||(es={})),function(t){var e=function(){function e(){}return e.reset=function(){this._spatialHash=new t.SpatialHash(this.spatialHashCellSize)},e.clear=function(){this._spatialHash.clear()},e.overlapCircleAll=function(t,e,i,n){if(void 0===n&&(n=-1),0!=i.length)return this._spatialHash.overlapCircle(t,e,i,n);console.error("An empty results array was passed in. No results will ever be returned.")},e.boxcastBroadphase=function(t,e){return void 0===e&&(e=this.allLayers),this._spatialHash.aabbBroadphase(t,null,e)},e.boxcastBroadphaseExcludingSelf=function(t,e,i){return void 0===i&&(i=this.allLayers),this._spatialHash.aabbBroadphase(e,t,i)},e.addCollider=function(t){e._spatialHash.register(t)},e.removeCollider=function(t){e._spatialHash.remove(t)},e.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},e.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},e.spatialHashCellSize=100,e.allLayers=-1,e.raycastsHitTriggers=!1,e.raycastsStartInColliders=!1,e}();t.Physics=e}(es||(es={})),function(t){var e=function(){return function(e,i){this.start=e,this.end=i,this.direction=t.Vector2.subtract(this.end,this.start)}}();t.Ray2D=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r,o){this.fraction=0,this.distance=0,this.point=t.Vector2.zero,this.normal=t.Vector2.zero,this.collider=e,this.fraction=i,this.distance=n,this.point=r,this.centroid=t.Vector2.zero}return e.prototype.setValues=function(t,e,i,n){this.collider=t,this.fraction=e,this.distance=i,this.point=n},e.prototype.setValuesNonCollider=function(t,e,i,n){this.fraction=t,this.distance=e,this.point=i,this.normal=n},e.prototype.reset=function(){this.collider=null,this.fraction=this.distance=0},e.prototype.toString=function(){return"[RaycastHit] fraction: "+this.fraction+", distance: "+this.distance+", normal: "+this.normal+", centroid: "+this.centroid+", point: "+this.point},e}();t.RaycastHit=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.clone=function(){return ObjectUtils.clone(this)},t}();t.Shape=e}(es||(es={})),function(t){var e=function(e){function i(t,i){var n=e.call(this)||this;return n._areEdgeNormalsDirty=!0,n.isUnrotated=!0,n.setPoints(t),n.isBox=i,n}return __extends(i,e),Object.defineProperty(i.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),i.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},i.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=i.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},i.prototype.buildEdgeNormals=function(){var e,i=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==i||(this._edgeNormals=new Array(i));for(var n=0;n<i;n++){var r=this.points[n];e=n+1>=this.points.length?this.points[0]:this.points[n+1];var o=t.Vector2Ext.perpendicular(r,e);o=t.Vector2.normalize(o),this._edgeNormals[n]=o}},i.buildSymmetricalPolygon=function(e,i){for(var n=new Array(e),r=0;r<e;r++){var o=2*Math.PI*(r/e);n[r]=t.Vector2.multiply(new t.Vector2(Math.cos(o),Math.sin(o)),new t.Vector2(i))}return n},i.recenterPolygonVerts=function(e){for(var i=this.findPolygonCenter(e),n=0;n<e.length;n++)e[n]=t.Vector2.subtract(e[n],i)},i.findPolygonCenter=function(e){for(var i=0,n=0,r=0;r<e.length;r++)i+=e[r].x,n+=e[r].y;return new t.Vector2(i/e.length,n/e.length)},i.getFarthestPointInDirection=function(e,i){for(var n=0,r=t.Vector2.dot(e[n],i),o=1;o<e.length;o++){var s=t.Vector2.dot(e[o],i);s>r&&(r=s,n=o)}return e[n]},i.getClosestPointOnPolygonToPoint=function(e,i,n,r){n=Number.MAX_VALUE,r=new t.Vector2(0,0);for(var o,s=new t.Vector2(0,0),a=0;a<e.length;a++){var h=a+1;h==e.length&&(h=0);var c=t.ShapeCollisions.closestPointOnLine(e[a],e[h],i);if((o=t.Vector2.distanceSquared(i,c))<n){n=o,s=c;var u=t.Vector2.subtract(e[h],e[a]);r=new t.Vector2(-u.y,u.x)}}return t.Vector2Ext.normalize(r),s},i.rotatePolygonVerts=function(e,i,n){for(var r=Math.cos(e),o=Math.sign(e),s=0;s<i.length;s++){var a=i[s];n[s]=new t.Vector2(a.x*r+a.y*-o,a.x*o+a.y*r)}},i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=!0,n=void 0,r=t.Matrix2D.create().translate(-this._polygonCenter.x,-this._polygonCenter.y);if(e.entity.transform.scale!=t.Vector2.zero&&(n=t.Matrix2D.create().scale(e.entity.transform.scale.x,e.entity.transform.scale.y),r=r.multiply(n),i=!1,this.center=t.Vector2.multiply(e.localOffset,e.entity.transform.scale)),0!=e.entity.transform.rotation){n=t.Matrix2D.create().rotate(e.entity.transform.rotation),r=r.multiply(n);var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=i?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}n=t.Matrix2D.create().translate(this._polygonCenter.x,this._polygonCenter.y),r=r.multiply(n),t.Vector2Ext.transform(this._originalPoints,r,this.points),this.isUnrotated=0==e.entity.transform.rotation,e._isRotationDirty&&(this._areEdgeNormalsDirty=!0)}this.position=t.Vector2.add(e.entity.transform.position,this.center),this.bounds=t.Rectangle.rectEncompassingPoints(this.points),this.bounds.location=this.bounds.location.add(this.position)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Pologon to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Polygon to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToPoly(e,i,this,n)},i.prototype.containsPoint=function(e){e=t.Vector2.subtract(e,this.position);for(var i=!1,n=0,r=this.points.length-1;n<this.points.length;r=n++)this.points[n].y>e.y!=this.points[r].y>e.y&&e.x<(this.points[r].x-this.points[n].x)*(e.y-this.points[n].y)/(this.points[r].y-this.points[n].y)+this.points[n].x&&(i=!i);return i},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToPoly(e,this,i)},i}(t.Shape);t.Polygon=e}(es||(es={})),function(t){var e=function(e){function i(t,n){var r=e.call(this,i.buildBox(t,n),!0)||this;return r.width=t,r.height=n,r}return __extends(i,e),i.buildBox=function(e,i){var n=e/2,r=i/2,o=new Array(4);return o[0]=new t.Vector2(-n,-r),o[1]=new t.Vector2(n,-r),o[2]=new t.Vector2(n,r),o[3]=new t.Vector2(-n,r),o},i.prototype.updateBox=function(e,i){this.width=e,this.height=i;var n=e/2,r=i/2;this.points[0]=new t.Vector2(-n,-r),this.points[1]=new t.Vector2(n,-r),this.points[2]=new t.Vector2(n,r),this.points[3]=new t.Vector2(-n,r);for(var o=0;o<this.points.length;o++)this._originalPoints[o]=this.points[o]},i.prototype.overlaps=function(n){if(this.isUnrotated){if(n instanceof i&&n.isUnrotated)return this.bounds.intersects(n.bounds);if(n instanceof t.Circle)return t.Collisions.isRectToCircle(this.bounds,n.position,n.radius)}return e.prototype.overlaps.call(this,n)},i.prototype.collidesWithShape=function(n,r){return n instanceof i&&n.isUnrotated?t.ShapeCollisions.boxToBox(this,n,r):e.prototype.collidesWithShape.call(this,n,r)},i.prototype.containsPoint=function(t){return this.isUnrotated?this.bounds.contains(t.x,t.y):e.prototype.containsPoint.call(this,t)},i.prototype.pointCollidesWithShape=function(i,n){return this.isUnrotated?t.ShapeCollisions.pointToBox(i,this,n):e.prototype.pointCollidesWithShape.call(this,i,n)},i}(t.Polygon);t.Box=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this)||this;return i.radius=t,i._originalRadius=t,i}return __extends(i,e),i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=e.entity.transform.scale,n=1==i.x&&1==i.y,r=Math.max(i.x,i.y);if(this.radius=this._originalRadius*r,0!=e.entity.transform.rotation){var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=n?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}}this.position=t.Vector2.add(e.transform.position,this.center),this.bounds=new t.Rectangle(this.position.x-this.radius,this.position.y-this.radius,2*this.radius,2*this.radius)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof t.Box&&e.isUnrotated)return t.Collisions.isRectToCircle(e.bounds,this.position,this.radius);if(e instanceof i)return t.Collisions.isCircleToCircle(this.position,this.radius,e.position,e.radius);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("overlaps of circle to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof t.Box&&e.isUnrotated)return t.ShapeCollisions.circleToBox(this,e,n);if(e instanceof i)return t.ShapeCollisions.circleToCircle(this,e,n);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("Collisions of Circle to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToCircle(e,i,this,n)},i.prototype.containsPoint=function(e){return t.Vector2.subtract(e,this.position).lengthSquared()<=this.radius*this.radius},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToCircle(e,this,i)},i}(t.Shape);t.Circle=e}(es||(es={})),function(t){var e=function(){function e(){this.normal=t.Vector2.zero,this.minimumTranslationVector=t.Vector2.zero,this.point=t.Vector2.zero}return e.prototype.removeHorizontal=function(e){if(Math.sign(this.normal.x)!=Math.sign(e.x)||0==e.x&&0!=this.normal.x){var i=this.minimumTranslationVector.length()/this.normal.y;1!=Math.abs(this.normal.x)&&Math.abs(i)<Math.abs(3*e.y)&&(this.minimumTranslationVector=new t.Vector2(0,-i))}},e.prototype.invertResult=function(){return this.minimumTranslationVector=t.Vector2.negate(this.minimumTranslationVector),this.normal=t.Vector2.negate(this.normal),this},e.prototype.toString=function(){return"[CollisionResult] normal: "+this.normal+", minimumTranslationVector: "+this.minimumTranslationVector},e}();t.CollisionResult=e}(es||(es={})),function(t){var e=function(){function e(){}return e.intersectMovingCircleToBox=function(e,i,n){var r=i.bounds;r.inflate(e.radius,e.radius);var o=new t.Ray2D(t.Vector2.subtract(e.position,n),e.position),s=r.rayIntersects(o);if(s>1)return s;var a,h=t.Vector2.add(o.start,t.Vector2.add(o.direction,new t.Vector2(s))),c=0;h.x<i.bounds.left&&(a|=1),h.x>i.bounds.right&&(c|=1),h.y<i.bounds.top&&(a|=2),h.y>i.bounds.bottom&&(c|=2);var u=a+c;return 3==u&&console.log("m == 3. corner "+t.Time.frameCount),s},e}();t.RealtimeCollisions=e}(es||(es={})),function(t){var e=function(){function e(){}return e.polygonToPolygon=function(e,i,n){for(var r,o=!0,s=e.edgeNormals,a=i.edgeNormals,h=Number.POSITIVE_INFINITY,c=new t.Vector2,u=t.Vector2.subtract(e.position,i.position),l=0;l<s.length+a.length;l++){r=l<s.length?s[l]:a[l-s.length];var p=0,d=0,f=0,g=0,m=0,y=this.getInterval(r,e,p,f);p=y.min,d=y.max;var _=this.getInterval(r,i,d,g);d=_.min,g=_.max;var v=t.Vector2.dot(u,r);if(p+=v,f+=v,(m=this.intervalDistance(p,f,d,g))>0&&(o=!1),!o)return!1;(m=Math.abs(m))<h&&(h=m,c=r,t.Vector2.dot(c,u)<0&&(c=new t.Vector2(-c)))}return n.normal=c,n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-c.x,-c.y),new t.Vector2(h)),!0},e.intervalDistance=function(t,e,i,n){return t<i?i-e:t-i},e.getInterval=function(e,i,n,r){var o=t.Vector2.dot(i.points[0],e);n=r=o;for(var s=1;s<i.points.length;s++)(o=t.Vector2.dot(i.points[s],e))<n?n=o:o>r&&(r=o);return{min:n,max:r}},e.circleToPolygon=function(e,i,n){var r,o=t.Vector2.subtract(e.position,i.position),s=t.Polygon.getClosestPointOnPolygonToPoint(i.points,o,0,n.normal),a=i.containsPoint(e.position);if(0>e.radius*e.radius&&!a)return!1;a?r=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0)-e.radius)):r=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));return n.minimumTranslationVector=r,n.point=t.Vector2.add(s,i.position),!0},e.circleToBox=function(e,i,n){var r=i.bounds.getClosestPointOnRectangleBorderToPoint(e.position,n.normal);if(i.containsPoint(e.position)){n.point=r;var o=t.Vector2.add(r,t.Vector2.multiply(n.normal,new t.Vector2(e.radius)));return n.minimumTranslationVector=t.Vector2.subtract(e.position,o),!0}var s=t.Vector2.distanceSquared(r,e.position);if(0==s)n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));else if(s<=e.radius*e.radius){n.normal=t.Vector2.subtract(e.position,r);var a=n.normal.length()-e.radius;return n.point=r,n.normal=t.Vector2Ext.normalize(n.normal),n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(a),n.normal),!0}return!1},e.pointToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e,i.position),o=1+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s,-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius,i.radius))),!0}return!1},e.pointToBox=function(e,i,n){return!!i.containsPoint(e)&&(n.point=i.bounds.getClosestPointOnRectangleBorderToPoint(e,n.normal),n.minimumTranslationVector=t.Vector2.subtract(e,n.point),!0)},e.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,t.Vector2.multiply(r,new t.Vector2(s,s)))},e.pointToPoly=function(e,i,n){if(i.containsPoint(e)){var r=t.Polygon.getClosestPointOnPolygonToPoint(i.points,t.Vector2.subtract(e,i.position),0,n.normal);return n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0),Math.sqrt(0))),n.point=t.Vector2.add(r,i.position),!0}return!1},e.circleToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e.position,i.position),o=e.radius+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e.position,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius))),!0}return!1},e.boxToBox=function(e,i,n){var r=this.minkowskiDifference(e,i);return!!r.contains(0,0)&&(n.minimumTranslationVector=r.getClosestPointOnBoundsToOrigin(),!n.minimumTranslationVector.equals(t.Vector2.zero)&&(n.normal=new t.Vector2(-n.minimumTranslationVector.x,-n.minimumTranslationVector.y),n.normal=n.normal.normalize(),!0))},e.minkowskiDifference=function(e,i){var n=t.Vector2.subtract(e.position,t.Vector2.add(e.bounds.location,t.Vector2.divide(e.bounds.size,new t.Vector2(2)))),r=t.Vector2.subtract(t.Vector2.add(e.bounds.location,n),i.bounds.max),o=t.Vector2.add(e.bounds.size,i.bounds.size);return new t.Rectangle(r.x,r.y,o.x,o.y)},e.lineToPoly=function(e,i,n,r){for(var o=t.Vector2.zero,s=t.Vector2.zero,a=Number.MAX_VALUE,h=!1,c=n.points.length-1,u=0;u<n.points.length;c=u,u++){var l=t.Vector2.add(n.position,n.points[c]),p=t.Vector2.add(n.position,n.points[u]),d=t.Vector2.zero;if(this.lineToLine(l,p,e,i,d)){h=!0;var f=(d.x-e.x)/(i.x-e.x);if((Number.isNaN(f)||Number.isFinite(f))&&(f=(d.y-e.y)/(i.y-e.y)),f<a){var g=t.Vector2.subtract(p,l);o=new t.Vector2(g.y,-g.x),a=f,s=d}}}if(h){o=o.normalize();var m=t.Vector2.distance(e,s);return r.setValuesNonCollider(a,m,s,o),!0}return!1},e.lineToLine=function(e,i,n,r,o){var s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return!1;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return!1;var l=(c.x*s.y-c.y*s.x)/h;return!(l<0||l>1)&&(o=o.add(e).add(t.Vector2.multiply(new t.Vector2(u),s)),!0)},e.lineToCircle=function(e,i,n,r){var o=t.Vector2.distance(e,i),s=t.Vector2.divide(t.Vector2.subtract(i,e),new t.Vector2(o)),a=t.Vector2.subtract(e,n.position),h=t.Vector2.dot(a,s),c=t.Vector2.dot(a,a)-n.radius*n.radius;if(c>0&&h>0)return!1;var u=h*h-c;return!(u<0)&&(r.fraction=-h-Math.sqrt(u),r.fraction<0&&(r.fraction=0),r.point=t.Vector2.add(e,t.Vector2.multiply(new t.Vector2(r.fraction),s)),r.distance=t.Vector2.distance(e,r.point),r.normal=t.Vector2.normalize(t.Vector2.subtract(r.point,n.position)),r.fraction=r.distance/o,!0)},e.boxToBoxCast=function(e,i,n,r){var o=this.minkowskiDifference(e,i);if(o.contains(0,0)){var s=o.getClosestPointOnBoundsToOrigin();return!s.equals(t.Vector2.zero)&&(r.normal=new t.Vector2(-s.x),r.normal=r.normal.normalize(),r.distance=0,r.fraction=0,!0)}var a=new t.Ray2D(t.Vector2.zero,new t.Vector2(-n.x)),h=o.rayIntersects(a);return h<=1&&(r.fraction=h,r.distance=n.length()*h,r.normal=new t.Vector2(-n.x),r.normal=r.normal.normalize(),r.centroid=t.Vector2.add(e.bounds.center,t.Vector2.multiply(n,new t.Vector2(h))),!0)},e}();t.ShapeCollisions=e}(es||(es={})),function(t){var e=function(){function e(e){void 0===e&&(e=100),this.gridBounds=new t.Rectangle,this._overlapTestCircle=new t.Circle(0),this._cellDict=new i,this._tempHashSet=[],this._cellSize=e,this._inverseCellSize=1/this._cellSize,this._raycastParser=new n}return e.prototype.register=function(e){var i=e.bounds;e.registeredPhysicsBounds=i;var n=this.cellCoords(i.x,i.y),r=this.cellCoords(i.right,i.bottom);this.gridBounds.contains(n.x,n.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,n)),this.gridBounds.contains(r.x,r.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,r));for(var o=n.x;o<=r.x;o++)for(var s=n.y;s<=r.y;s++){var a=this.cellAtPosition(o,s,!0);a.firstOrDefault(function(t){return t.hashCode==e.hashCode})||a.push(e)}},e.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,i=this.cellCoords(e.x,e.y),n=this.cellCoords(e.right,e.bottom),r=i.x;r<=n.x;r++)for(var o=i.y;o<=n.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.log("从不存在碰撞器的单元格中移除碰撞器: ["+t+"]")}},e.prototype.removeWithBruteForce=function(t){this._cellDict.remove(t)},e.prototype.clear=function(){this._cellDict.clear()},e.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var i=this.gridBounds.x;i<=this.gridBounds.right;i++)for(var n=this.gridBounds.y;n<=this.gridBounds.bottom;n++){var r=this.cellAtPosition(i,n);r&&r.length>0&&this.debugDrawCellDetails(i,n,r.length,t,e)}},e.prototype.aabbBroadphase=function(e,i,n){this._tempHashSet.length=0;for(var r=this.cellCoords(e.x,e.y),o=this.cellCoords(e.right,e.bottom),s=r.x;s<=o.x;s++)for(var a=r.y;a<=o.y;a++){var h=this.cellAtPosition(s,a);if(h)for(var c=function(r){var o=h[r];if(o==i||!t.Flags.isFlagSet(n,o.physicsLayer))return"continue";e.intersects(o.bounds)&&(u._tempHashSet.firstOrDefault(function(t){return t.hashCode==o.hashCode})||u._tempHashSet.push(o))},u=this,l=0;l<h.length;l++)c(l)}return this._tempHashSet},e.prototype.overlapCircle=function(e,i,n,r){var o=new t.Rectangle(e.x-i,e.y-i,2*i,2*i);this._overlapTestCircle.radius=i,this._overlapTestCircle.position=e;for(var s=0,a=this.aabbBroadphase(o,null,r),h=0;h<a.length;h++){var c=a[h];if(c instanceof t.BoxCollider)n[s]=c,s++;else if(c instanceof t.CircleCollider)c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++);else{if(!(c instanceof t.PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++)}if(s==n.length)return s}return s},e.prototype.cellCoords=function(e,i){return new t.Vector2(Math.floor(e*this._inverseCellSize),Math.floor(i*this._inverseCellSize))},e.prototype.cellAtPosition=function(t,e,i){void 0===i&&(i=!1);var n=this._cellDict.tryGetValue(t,e);return n||i&&(n=[],this._cellDict.add(t,e,n)),n},e.prototype.debugDrawCellDetails=function(t,e,i,n,r){void 0===n&&(n=.5),void 0===r&&(r=1)},e}();t.SpatialHash=e;var i=function(){function t(){this._store=new Map}return t.prototype.add=function(t,e,i){this._store.set(this.getKey(t,e),i)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!0)).toString()},t}();t.NumberDictionary=i;var n=function(){function e(){this._checkedColliders=[],this._cellHits=[]}return e.prototype.start=function(t,e,i){this._ray=t,this._hits=e,this._layerMask=i,this.hitCounter=0},e.prototype.checkRayIntersection=function(i,n,r){for(var o=0;o<r.length;o++){var s=r[o];if(!this._checkedColliders.contains(s))if(this._checkedColliders.push(s),!s.isTrigger||t.Physics.raycastsHitTriggers)if(t.Flags.isFlagSet(this._layerMask,s.physicsLayer))if(s.bounds.rayIntersects(this._ray)<=1&&s.shape.collidesWithLine(this._ray.start,this._ray.end,this._tempHit)){if(!t.Physics.raycastsStartInColliders&&s.shape.containsPoint(this._ray.start))continue;this._tempHit.collider=s,this._cellHits.push(this._tempHit)}}if(0==this._cellHits.length)return!1;this._cellHits.sort(e.compareRaycastHits);for(o=0;o<this._cellHits.length;o++)if(this._hits[this.hitCounter]=this._cellHits[o],this.hitCounter++,this.hitCounter==this._hits.length)return!0;return!1},e.prototype.reset=function(){this._hits=null,this._checkedColliders.length=0,this._cellHits.length=0},e.compareRaycastHits=function(t,e){return t.distance-e.distance},e}();t.RaycastResultParser=n}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxGroup=e}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxImageLayer=e}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"offset",{get:function(){return new t.Vector2(this.offsetX,this.offsetY)},enumerable:!0,configurable:!0}),e.prototype.getTileWithGid=function(t){for(var e=0;e<this.tiles.length;e++)if(this.tiles[e]&&this.tiles[e].gid==t)return this.tiles[e];return null},e.prototype.getTile=function(t,e){return this.tiles[t+e*this.width]},e.prototype.getCollisionRectangles=function(){for(var t=[],e=[],i=-1,n=-1,r=0;r<this.map.height;r++){for(var o=0;o<this.map.width;o++){n=r*this.map.width+o;var s=this.getTile(o,r);s&&!t[n]?(i<0&&(i=o),t[n]=!0):(s||t[n])&&i>=0&&(e.push(this.findBoundsRect(i,o,r,t)),i=-1)}i>=0&&(e.push(this.findBoundsRect(i,this.map.width,r,t)),i=-1)}return e},e.prototype.findBoundsRect=function(e,i,n,r){for(var o=-1,s=n+1;s<this.map.height;s++)for(var a=e;a<i;a++){if(o=s*this.map.width+a,this.getTile(a,s)||r[o]){for(var h=e;h<a;h++)r[o=s*this.map.width+h]=!1;return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(s-n)*this.map.tileHeight)}r[o]=!0}return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(this.map.height-n)*this.map.tileHeight)},e}();t.TmxLayer=e;var i=function(){function e(t,i,n,r){this.x=n,this.y=r;var o,s=i;o=0!=(s&e.FLIPPED_HORIZONTALLY_FLAG),this.horizontalFlip=o,o=0!=(s&e.FLIPPED_VERTICALLY_FLAG),this.verticalFlip=o,s&=~(e.FLIPPED_HORIZONTALLY_FLAG|e.FLIPPED_VERTICALLY_FLAG),this.gid=s,this.tileset=t.getTilesetForTileGid(this.gid)}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tilesetTile",{get:function(){null==this._tilesetTileIndex&&(this._tilesetTileIndex=-1,this.tileset.firstGid<=this.gid&&this.tileset.tiles.get(this.gid-this.tileset.firstGid)&&(this._tilesetTileIndex=this.gid-this.tileset.firstGid));return this._tilesetTileIndex<0?null:this.tileset.tiles.get(this._tilesetTileIndex)},enumerable:!0,configurable:!0}),e.FLIPPED_HORIZONTALLY_FLAG=2147483648,e.FLIPPED_VERTICALLY_FLAG=1073741824,e}();t.TmxLayerTile=i}(es||(es={})),function(t){var e=function(){return function(){this.tmxDirectory="resource/assets/"}}();t.TmxDocument=e;var i=function(){function t(){}return t.prototype.dispose=function(){this.bitmap&&(this.bitmap.dispose(),this.bitmap=null)},t}();t.TmxImage=i}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"worldWidth",{get:function(){return this.width*this.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"worldHeight",{get:function(){return this.height*this.tileHeight},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"requiresLargeTileCulling",{get:function(){return this.maxTileHeight>this.tileHeight||this.maxTileWidth>this.tileWidth},enumerable:!0,configurable:!0}),i.prototype.getTilesetForTileGid=function(t){if(0==t)return null;for(var e=this.tilesets.length-1;e>=0;e--)if(this.tilesets[e].firstGid<=t)return this.tilesets[e];console.error("tile gid"+t+"未在任何tileset中找到")},i.prototype.worldToTilePositionX=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileWidth);return i?t.MathHelper.clamp(n,0,this.width-1):n},i.prototype.worldToTilePositionY=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileHeight);return i?t.MathHelper.clamp(n,0,this.height-1):n},i.prototype.getLayer=function(t){return this.layers[t]},i.prototype.update=function(){this.tilesets.forEach(function(t){t.update()})},i.prototype.dispose=function(t){void 0===t&&(t=!0),this._isDisposed||(t&&(this.tilesets.forEach(function(t){t.image&&t.image.dispose()}),this.imageLayers.forEach(function(t){t.image&&t.image.dispose()})),this._isDisposed=!0)},i}(t.TmxDocument);t.TmxMap=e,function(t){t[t.unknown=0]="unknown",t[t.orthogonal=1]="orthogonal",t[t.isometric=2]="isometric",t[t.staggered=3]="staggered",t[t.hexagonal=4]="hexagonal"}(t.OrientationType||(t.OrientationType={})),function(t){t[t.x=0]="x",t[t.y=1]="y"}(t.StaggerAxisType||(t.StaggerAxisType={})),function(t){t[t.odd=0]="odd",t[t.even=1]="even"}(t.StaggerIndexType||(t.StaggerIndexType={})),function(t){t[t.rightDown=0]="rightDown",t[t.rightUp=1]="rightUp",t[t.leftDown=2]="leftDown",t[t.leftUp=3]="leftUp"}(t.RenderOrderType||(t.RenderOrderType={}))}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxObjectGroup=e;var i=function(){return function(){this.shape=new egret.Shape,this.textField=new egret.TextField}}();t.TmxObject=i;var n=function(){return function(){}}();t.TmxText=n;var r=function(){return function(){}}();t.TmxAlignment=r,function(t){t[t.basic=0]="basic",t[t.point=1]="point",t[t.tile=2]="tile",t[t.ellipse=3]="ellipse",t[t.polygon=4]="polygon",t[t.polyline=5]="polyline",t[t.text=6]="text"}(t.TmxObjectType||(t.TmxObjectType={})),function(t){t[t.unkownOrder=-1]="unkownOrder",t[t.TopDown=0]="TopDown",t[t.IndexOrder=1]="IndexOrder"}(t.DrawOrderType||(t.DrawOrderType={})),function(t){t[t.left=0]="left",t[t.center=1]="center",t[t.right=2]="right",t[t.justify=3]="justify"}(t.TmxHorizontalAlignment||(t.TmxHorizontalAlignment={})),function(t){t[t.top=0]="top",t[t.center=1]="center",t[t.bottom=2]="bottom"}(t.TmxVerticalAlignment||(t.TmxVerticalAlignment={}))}(es||(es={})),function(t){var e=function(){function e(){}return e.loadTmxMap=function(t,e){var i=RES.getRes(e);return this.loadTmxMapData(t,i)},e.loadTmxMapData=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:e.version=i.version,e.tiledVersion=i.tiledversion,e.width=i.width,e.height=i.height,e.tileWidth=i.tilewidth,e.tileHeight=i.tileheight,e.hexSideLength=i.hexsidelength,e.orientation=this.parseOrientationType(i.orientation),e.staggerAxis=this.parseStaggerAxisType(i.staggeraxis),e.staggerIndex=this.parseStaggerIndexType(i.staggerindex),e.renderOrder=this.parseRenderOrderType(i.renderorder),e.nextObjectID=i.nextobjectid,e.backgroundColor=t.TmxUtils.color16ToUnit(i.color),e.properties=this.parsePropertyDict(i.properties),e.maxTileWidth=e.tileWidth,e.maxTileHeight=e.tileHeight,e.tilesets=[],n=0,r=i.tilesets,a.label=1;case 1:return n<r.length?(o=r[n],[4,this.parseTmxTileset(e,o)]):[3,4];case 2:s=a.sent(),e.tilesets.push(s),this.updateMaxTileSizes(s),a.label=3;case 3:return n++,[3,1];case 4:return e.layers=[],e.tileLayers=[],e.objectGroups=[],e.imageLayers=[],e.groups=[],this.parseLayers(e,i,e,e.width,e.height,e.tmxDirectory),[2,e]}})})},e.parseLayers=function(e,i,n,r,o,s){return __awaiter(this,void 0,void 0,function(){var a,h,c,u,l,p,d,f;return __generator(this,function(g){switch(g.label){case 0:a=0,h=ObjectUtils.elements(i).where(function(t){return"tilelayer"==t.type||"objectgroup"==t.type||"imagelayer"==t.type||"group"==t.type}),g.label=1;case 1:if(!(a<h.length))return[3,11];switch(c=h[a],u=void 0,c.type){case"tilelayer":return[3,2];case"objectgroup":return[3,3];case"imagelayer":return[3,4];case"group":return[3,6]}return[3,8];case 2:return l=this.loadTmxLayer(new t.TmxLayer,n,c,r,o),u=l,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.tileLayers.push(l),[3,9];case 3:return p=this.loadTmxObjectGroup(new t.TmxObjectGroup,n,c),u=p,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.objectGroups.push(p),[3,9];case 4:return[4,this.loadTmxImageLayer(new t.TmxImageLayer,n,c,s)];case 5:return d=g.sent(),u=d,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.imageLayers.push(d),[3,9];case 6:return[4,this.loadTmxGroup(new t.TmxGroup,n,c,r,o,s)];case 7:return f=g.sent(),u=f,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.groups.push(f),[3,9];case 8:throw new Error("无效的操作");case 9:(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.layers.push(u),g.label=10;case 10:return a++,[3,1];case 11:return[2]}})})},e.loadTmxGroup=function(t,e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(s){switch(s.label){case 0:return t.map=e,t.name=null!=i.name?i.name:"",t.opacity=null!=i.opacity?i.opacity:1,t.visible=null==i.visible||i.visible,t.offsetX=null!=i.offsetx?i.offsetx:0,t.offsetY=null!=i.offsety?i.offsety:0,t.properties=this.parsePropertyDict(i.properties),t.layers=[],t.tileLayers=[],t.objectGroups=[],t.imageLayers=[],t.groups=[],[4,this.parseLayers(t,i,e,n,r,o)];case 1:return s.sent(),[2,t]}})})},e.loadTmxImageLayer=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s;return __generator(this,function(a){switch(a.label){case 0:return e.map=i,e.name=n.name,e.width=n.width,e.height=n.height,e.visible=null==n.visible||n.visible,e.opacity=null!=n.opacity?n.opacity:1,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0,(o=n.image)?(s=e,[4,this.loadTmxImage(new t.TmxImage,o,r)]):[3,2];case 1:s.image=a.sent(),a.label=2;case 2:return e.properties=this.parsePropertyDict(n.properties),[2,e]}})})},e.loadTmxLayer=function(i,n,r,o,s){i.map=n,i.name=r.name,i.opacity=null!=r.opacity?r.opacity:1,i.visible=null==r.visible||r.visible,i.offsetX=null!=r.offsetx?r.offsetx:0,i.offsetY=null!=r.offsety?r.offsety:0,i.width=r.width,i.height=r.height;var a=r.data,h=null!=a.encoding?a.encoding:"csv";if(i.tiles=new Array(o*s),"base64"==h)for(var c=t.TmxUtils.decode(a.toString(),h,a.compression),u=0,l=0;l<s;l++)for(var p=0;p<o;p++){var d=c[u];i.tiles[u++]=0!=d?new t.TmxLayerTile(n,d,p,l):null}else if("csv"==h)for(var f=0,g=0,m=a;g<m.length;g++){d=m[g];var y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}else{if(h)throw new Error("TmxLayer:未知编码");f=0;for(var v=0,b=a.tile;v<b.length;v++){var x=b[v];d=null!=x.gid?x.gid:0,y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}}return i.properties=e.parsePropertyDict(r.properties),i},e.updateMaxTileSizes=function(t){t.tiles.forEach(function(e){e.image&&(e.image.width>t.map.maxTileWidth&&(t.map.maxTileWidth=e.image.width),e.image.height>t.map.maxTileHeight&&(t.map.maxTileHeight=e.image.height))}),t.tileRegions.forEach(function(e){var i=e.width,n=e.height;i>t.map.maxTileWidth&&(t.map.maxTileWidth=i),i>t.map.maxTileHeight&&(t.map.maxTileHeight=n)})},e.parseOrientationType=function(e){return"unknown"==e?t.OrientationType.unknown:"orthogonal"==e?t.OrientationType.orthogonal:"isometric"==e?t.OrientationType.isometric:"staggered"==e?t.OrientationType.staggered:"hexagonal"==e?t.OrientationType.hexagonal:t.OrientationType.unknown},e.parseStaggerAxisType=function(e){return"y"==e?t.StaggerAxisType.y:t.StaggerAxisType.x},e.parseStaggerIndexType=function(e){return"even"==e?t.StaggerIndexType.even:t.StaggerIndexType.odd},e.parseRenderOrderType=function(e){return"right-up"==e?t.RenderOrderType.rightUp:"left-down"==e?t.RenderOrderType.leftDown:"left-up"==e?t.RenderOrderType.leftUp:t.RenderOrderType.rightDown},e.parsePropertyDict=function(e){if(!e)return null;for(var i=new Map,n=0,r=e;n<r.length;n++){var o=r[n],s=o.name,a=o.value;"color"==o.type?i.set(s,t.TmxUtils.color16ToUnit(a).toString()):i.set(s,a)}return i},e.parseTmxTileset=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:return n=i.firstgid,r=n,null==(o=i.image)?[3,2]:(o=e.tmxDirectory+o,[4,RES.getResByUrl(o,null,this,RES.ResourceItem.TYPE_IMAGE).catch(function(t){throw new Error(t)})]);case 1:return s=a.sent(),[2,this.loadTmxTileset(new t.TmxTileset,e,s.tileset,r)];case 2:return[2,this.loadTmxTileset(new t.TmxTileset,e,i,r)]}})})},e.loadTmxTileset=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s,a,h,c,u,l,p,d,f,g,m,y,_;return __generator(this,function(v){switch(v.label){case 0:return e.map=i,e.firstGid=r,e.name=n.name,e.tileWidth=n.tilewidth,e.tileHeight=n.tileheight,e.spacing=null!=n.spacing?n.spacing:0,e.margin=null!=n.margin?n.margin:0,e.columns=n.columns,e.tileCount=n.tilecount,e.tileOffset=this.parseTmxTileOffset(n.tileoffset),n.image?(o=e,[4,this.loadTmxImage(new t.TmxImage,n,i.tmxDirectory).catch(function(t){throw new Error(t)})]):[3,2];case 1:o.image=v.sent(),v.label=2;case 2:if(e.terrains=[],n.terrains)for(s=0,a=n.terrains;s<a.length;s++)h=a[s],e.terrains.push(this.parseTmxTerrain(h));for(u in e.tiles=new Map,c=[],n.tiles)c.push(u);l=0,v.label=3;case 3:return l<c.length?(p=c[l],n.tiles.hasOwnProperty(p)?(d=n.tiles[p],[4,this.loadTmxTilesetTile(new t.TmxTilesetTile,e,d,e.terrains,i.tmxDirectory)]):[3,5]):[3,6];case 4:f=v.sent(),e.tiles.set(null==f.id?Number(p)+1:f.id,f),v.label=5;case 5:return l++,[3,3];case 6:if(e.properties=this.parsePropertyDict(n.properties),e.tileRegions=new Map,e.image)for(g=r,m=e.margin;m<e.image.height-e.margin;m+=e.tileHeight+e.spacing)for(y=0,_=e.margin;_<e.image.width-e.margin&&(e.tileRegions.set(g++,new t.Rectangle(_,m,e.tileWidth,e.tileHeight)),!(++y>=e.columns));_+=e.tileWidth+e.spacing);else e.tiles.forEach(function(i,n){e.tileRegions.set(n,new t.Rectangle(0,0,i.image.width,i.image.height))});return[2,e]}})})},e.loadTmxTilesetTile=function(e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){var s,a,h,c,u,l,p,d,f,g,m,y,_;return __generator(this,function(v){switch(v.label){case 0:if(e.tileset=i,e.id=n.id,s=n.terrain)for(e.terrainEdges=new Array(4),a=0,h=0,c=s;h<c.length;h++)u=c[h],l=r[u],e.terrainEdges[a++]=l;return e.probability=null!=n.probability?n.probability:1,e.type=n.type,(p=n.image)?(d=e,[4,this.loadTmxImage(new t.TmxImage,p,o)]):[3,2];case 1:d.image=v.sent(),v.label=2;case 2:if(e.objectGroups=[],n.objectgroup)for(f=0,g=n.objectgroup;f<g.length;f++)_=g[f],e.objectGroups.push(this.loadTmxObjectGroup(new t.TmxObjectGroup,i.map,_));if(e.animationFrames=[],n.animation)for(m=0,y=n.animation.frame;m<y.length;m++)_=y[m],e.animationFrames.push(this.loadTmxAnimationFrame(new t.TmxAnimationFrame,_));return e.properties=this.parsePropertyDict(n.properties),e.properties&&e.processProperties(),[2,e]}})})},e.loadTmxAnimationFrame=function(t,e){return t.gid=e.tileid,t.duration=e.duration/1e3,t},e.loadTmxObjectGroup=function(e,i,n){e.map=i,e.name=null!=n.name?n.name:"",e.color=t.TmxUtils.color16ToUnit(n.color),e.opacity=null!=n.opacity?n.opacity:1,e.visible=null==n.visible||n.visible,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0;var r=new Map;r.set("unknown",t.DrawOrderType.unkownOrder),r.set("topdown",t.DrawOrderType.IndexOrder),r.set("index",t.DrawOrderType.TopDown);var o=n.draworder;o&&(e.drawOrder=r.get(o)),e.objects=[];for(var s=0,a=n.objects;s<a.length;s++){var h=a[s];e.objects.push(this.loadTmxObject(new t.TmxObject,i,h))}return e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxObject=function(e,i,n){e.id=null!=n.id?n.id:0,e.name=null!=n.name?n.name:"",e.x=n.x,e.y=n.y,e.width=null!=n.width?n.width:0,e.height=null!=n.height?n.height:0,e.type=null!=n.type?n.type:"",e.visible=null==n.visible||n.visible,e.rotation=null!=n.rotation?n.rotation:0;var r=n.gid,o=n.ellipse,s=n.polygon,a=n.polyline,h=n.text,c=n.point;return r?(e.tile=new t.TmxLayerTile(i,r,Math.round(e.x),Math.round(e.y)),e.objectType=t.TmxObjectType.tile):o?e.objectType=t.TmxObjectType.ellipse:s?(e.points=this.parsePoints(s),e.objectType=t.TmxObjectType.polygon):a?(e.points=this.parsePoints(a),e.objectType=t.TmxObjectType.polyline):h?(e.text=this.loadTmxText(new t.TmxText,h),e.objectType=t.TmxObjectType.text):e.objectType=c?t.TmxObjectType.point:t.TmxObjectType.basic,e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxText=function(e,i){return e.fontFamily=null!=i.fontfamily?i.fontfamily:"sans-serif",e.pixelSize=null!=i.pixelsize?i.pixelsize:16,e.wrap=null!=i.wrap&&i.wrap,e.color=t.TmxUtils.color16ToUnit(i.color),e.bold=!!i.bold&&i.bold,e.italic=!!i.italic&&i.italic,e.underline=!!i.underline&&i.underline,e.strikeout=!!i.strikeout&&i.strikeout,e.kerning=!i.kerning||i.kerning,e.alignment=this.loadTmxAlignment(new t.TmxAlignment,i),e.value=i,e},e.loadTmxAlignment=function(e,i){function n(t){return t&&""!=t?t[0].toString().toUpperCase()+t.substr(1):t}var r=null!=i.halign?i.halign:"left";e.horizontal=t.TmxHorizontalAlignment[n(r)];var o=null!=i.valign?i.valign:"top";return e.vertical=t.TmxVerticalAlignment[n(o)],e},e.parsePoints=function(t){for(var e=[],i=0,n=0,r=t;n<r.length;n++){var o=r[n];e[i++]=this.parsePoint(o)}return e},e.parsePoint=function(e){return new t.Vector2(e.x,e.y)},e.parseTmxTerrain=function(e){var i=new t.TmxTerrain;return i.name=e.name,i.tile=e.tile,i.properties=this.parsePropertyDict(e.properties),i},e.parseTmxTileOffset=function(e){var i=new t.TmxTileOffset;return e?(i.x=e.x,i.y=e.y,i):(i.x=0,i.y=0,i)},e.loadTmxImage=function(e,i,n){return __awaiter(this,void 0,void 0,function(){var r,o;return __generator(this,function(s){switch(s.label){case 0:return r=i.image,e.source=null!=r?n+r:n+i,[4,RES.getResByUrl(e.source,null,this,RES.ResourceItem.TYPE_IMAGE).catch(function(t){throw new Error(t)})];case 1:return o=s.sent(),e.bitmap=new egret.SpriteSheet(o),e.trans=t.TmxUtils.color16ToUnit(i.trans),e.width=null!=i.imagewidth?i.imagewidth:o.textureWidth,e.height=null!=i.imageheight?i.imageheight:o.textureHeight,[2,e]}})})},e}();t.TiledMapLoader=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){}return i.renderMap=function(e,i,n,r,o){var s=this;e.layers.forEach(function(e){e instanceof t.TmxLayer&&e.visible?s.renderLayer(e,i,n,r,o):e instanceof t.TmxImageLayer&&e.visible?s.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?s.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&s.renderObjectGroup(e,i,n,r,o)})},i.renderLayer=function(e,i,n,r,o){if(e.visible)for(var s=e.map.tileWidth*r.x,a=e.map.tileHeight*r.y,h=t.DrawUtils.getColorMatrix(16777215),c=0;c<e.tiles.length;c++){var u=e.tiles[c];u&&this.renderTile(u,i,n,r,s,a,h,o)}},i.renderLayerRenderCamera=function(e,i,n,r,o,s){e instanceof t.TmxLayer&&e.visible?this.renderLayerCamera(e,i,n,r,o,s):e instanceof t.TmxImageLayer&&e.visible?this.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?this.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&this.renderObjectGroup(e,i,n,r,o)},i.renderLayerCamera=function(e,i,n,r,o,s){if(e.visible){n=n.add(e.offset),s.location=s.location.subtract(n);var a,h,c,u=e.map.tileWidth*r.x,l=e.map.tileHeight*r.y,p=0;e.map.requiresLargeTileCulling?(a=e.map.worldToTilePositionX(s.left-(e.map.maxTileWidth*r.x-u)),h=e.map.worldToTilePositionY(s.top-(e.map.maxTileHeight*r.y-l)),c=e.map.worldToTilePositionX(s.right+(e.map.maxTileWidth*r.x-u)),p=e.map.worldToTilePositionY(s.bottom+(e.map.maxTileHeight*r.y-l))):(a=e.map.worldToTilePositionX(s.left),h=e.map.worldToTilePositionY(s.top),c=e.map.worldToTilePositionX(s.right),p=e.map.worldToTilePositionY(s.bottom));for(var d=t.DrawUtils.getColorMatrix(16777215),f=h;f<=p;f++)for(var g=a;g<=c;g++){var m=e.getTile(g,f);m&&this.renderTile(m,i,n,r,u,l,d,o)}}},i.renderImageLayer=function(e,i,n,r,o){if(e.visible){var s=t.DrawUtils.getColorMatrix(16777215),a=t.Vector2.add(n,new t.Vector2(e.offsetX,e.offsetY).multiply(r));e.image.texture.parent||i.addChild(e.image.texture),e.image.texture.x=a.x,e.image.texture.y=a.y,e.image.texture.scaleX=r.x,e.image.texture.scaleY=r.y,e.image.texture.filters=[s]}},i.renderObjectGroup=function(e,i,n,r,o){if(e.visible)for(var s in e.objects){var a=e.objects[s];if(a.visible&&(t.Core.debugRenderEndabled||a.objectType==t.TmxObjectType.tile||a.objectType==t.TmxObjectType.text)){var h=t.Vector2.add(n,new t.Vector2(a.x,a.y).multiply(r));switch(a.objectType){case t.TmxObjectType.basic:a.shape.parent||(a.shape.x=a.x,a.shape.y=a.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawRect(0,0,a.width*r.x,a.height*r.y),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.point:var c=.5*e.map.tileWidth;h.x-=.5*c,h.y-=.5*c,a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,1),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.tile:this.renderTilesetTile(e,a,i,h,r,p);break;case t.TmxObjectType.ellipse:h=new t.Vector2(a.x+.5*a.width,a.y+.5*a.height).multiply(r),a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,.5*a.width),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.polygon:case t.TmxObjectType.polyline:for(var u=[],l=0;l<a.points.length;l++)u[l]=t.Vector2.multiply(a.points[l],r);if(!a.shape.parent&&u.length>0){a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884);for(l=0;l<u.length;l++)a.shape.graphics.lineTo(u[l].x,u[l].y);a.shape.graphics.endFill(),p(a,h)}break;case t.TmxObjectType.text:a.textField.parent||(a.textField.x=h.x,a.textField.y=h.y,i.addChild(a.textField),a.textField.text=a.text.value,a.textField.textColor=a.text.color,a.textField.bold=null!=a.text.bold&&a.text.bold,a.textField.italic=null!=a.text.italic&&a.text.italic,a.textField.size=a.text.pixelSize,a.textField.fontFamily=a.text.fontFamily)}}}function p(e,n){i&&t.Core.debugRenderEndabled&&!e.textField.parent&&e.name&&(e.textField.text=e.name,e.textField.size=12,e.textField.fontFamily="sans-serif",e.shape?(e.textField.x=n.x+(e.shape.getBounds().width-e.textField.width)/2+e.shape.getBounds().x,e.textField.y=n.y-e.textField.height-5+e.shape.getBounds().y):(e.textField.x=n.x+(e.width-e.textField.width)/2,e.textField.y=n.y-e.textField.height-5),e.textField.background=!0,e.textField.backgroundColor=10526884,e.textField.textColor=16777215,i.addChild(e.textField))}},i.renderTilesetTile=function(t,i,n,r,o,s){var a=t.map.getTilesetForTileGid(i.tile.gid),h=a.tileRegions.get(i.tile.gid);if(n)if(a.image){i.tile.horizontalFlip&&i.tile.verticalFlip?(r.x+=a.tileHeight+(h.height*o.y-a.tileHeight),r.y-=h.width*o.x-a.tileWidth):i.tile.horizontalFlip?r.x+=a.tileWidth+(h.height*o.y-a.tileHeight):i.tile.verticalFlip?r.y+=a.tileWidth-h.width*o.x:r.y+=a.tileHeight-h.height*o.y,(c=a.image.bitmap.getTexture(""+i.tile.gid))||(c=a.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),a.image.texture=new e(c),n.addChild(a.image.texture),a.image.texture.x=r.x,a.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=-1):i.tile.verticalFlip?(a.image.texture.scaleX=o.x,a.image.texture.scaleY=-1):i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=o.y):(a.image.texture.scaleX=o.x,a.image.texture.scaleY=o.y),a.image.texture.anchorOffsetX=0,a.image.texture.anchorOffsetY=0,s(i,r)}else{var c,u=a.tiles.get(i.tile.gid);(c=u.image.bitmap.getTexture(""+i.tile.gid))||(c=u.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),r.y-=i.height,u.image.texture=new e(c),n.addChild(u.image.texture),u.image.texture.width=i.width,u.image.texture.height=i.height,u.image.texture.x=r.x,u.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=-1):i.tile.verticalFlip?(u.image.texture.scaleX=o.x,u.image.texture.scaleY=-1):i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=o.y):(u.image.texture.scaleX=o.x,u.image.texture.scaleY=o.y),u.image.texture.anchorOffsetX=0,u.image.texture.anchorOffsetY=0}},i.renderGroup=function(e,i,n,r,o){var s=this;e.visible&&e.layers.forEach(function(e){e instanceof t.TmxGroup&&s.renderGroup(e,i,n,r,o),e instanceof t.TmxObjectGroup&&s.renderObjectGroup(e,i,n,r,o),e instanceof t.TmxLayer&&s.renderLayer(e,i,n,r,o),e instanceof t.TmxImageLayer&&s.renderImageLayer(e,i,n,r,o)})},i.renderTile=function(i,n,r,o,s,a,h,c){var u=i.gid,l=i.tilesetTile;l&&l.animationFrames.length>0&&(u=l.currentAnimationFrameGid);var p=i.tileset.tileRegions.get(u),d=Math.floor(i.x)*s,f=Math.floor(i.y)*a;i.horizontalFlip&&i.verticalFlip?(d+=a+(p.height*o.y-a),f-=p.width*o.x-s):i.horizontalFlip?d+=s+(p.height*o.y-a):i.verticalFlip?f+=s-p.width*o.x:f+=a-p.height*o.y;var g=new t.Vector2(d,f).add(r);if(i.tileset.image){if(n){var m=i.tileset.image.bitmap.getTexture(""+u);m||(m=i.tileset.image.bitmap.createTexture(""+u,p.x,p.y,p.width,p.height)),i.tileset.image.texture=new e(m),n.addChild(i.tileset.image.texture),i.tileset.image.texture.x!=g.x&&(i.tileset.image.texture.x=g.x),i.tileset.image.texture.y!=g.y&&(i.tileset.image.texture.y=g.y),i.verticalFlip&&i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=-1):i.verticalFlip?(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=-1):i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=o.y):(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=o.y),0!=i.tileset.image.texture.rotation&&(i.tileset.image.texture.rotation=0),0!=i.tileset.image.texture.anchorOffsetX&&(i.tileset.image.texture.anchorOffsetX=0),0!=i.tileset.image.texture.anchorOffsetY&&(i.tileset.image.texture.anchorOffsetY=0)}}else l.image.texture&&(l.image.bitmap.getTexture(u.toString())||(l.image.texture=new e(l.image.bitmap.createTexture(u.toString(),p.x,p.y,p.width,p.height)),n.addChild(l.image.texture)),l.image.texture.x=g.x,l.image.texture.y=g.y,l.image.texture.scaleX=o.x,l.image.texture.scaleY=o.y,l.image.texture.rotation=0,l.image.texture.anchorOffsetX=0,l.image.texture.anchorOffsetY=0,l.image.texture.filters=[h])},i}();t.TiledRendering=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.update=function(){this.tiles.forEach(function(t){t.updateAnimatedTiles()})},e}(t.TmxDocument);t.TmxTileset=e;var i=function(){return function(){}}();t.TmxTileOffset=i;var n=function(){return function(){}}();t.TmxTerrain=n}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"currentAnimationFrameGid",{get:function(){return this.animationFrames[this._animationCurrentFrame].gid+this.tileset.firstGid},enumerable:!0,configurable:!0}),e.prototype.processProperties=function(){var t;(t=this.properties.get("engine.isDestructable"))&&(this.isDestructable=Boolean(t)),(t=this.properties.get("engine:isSlope"))&&(this.isSlope=Boolean(t)),(t=this.properties.get("engine:isOneWayPlatform"))&&(this.isOneWayPlatform=Boolean(t)),(t=this.properties.get("engine:slopeTopLeft"))&&(this.slopeTopLeft=Number(t)),(t=this.properties.get("engine:slopeTopRight"))&&(this.slopeTopRight=Number(t))},e.prototype.updateAnimatedTiles=function(){0!=this.animationFrames.length&&(this._animationElapsedTime+=t.Time.deltaTime,this._animationElapsedTime>this.animationFrames[this._animationCurrentFrame].duration&&(this._animationCurrentFrame=t.MathHelper.incrementWithWrap(this._animationCurrentFrame,this.animationFrames.length),this._animationElapsedTime=0))},e}();t.TmxTilesetTile=e;var i=function(){return function(){}}();t.TmxAnimationFrame=i}(es||(es={})),function(t){var e=function(){function e(){}return e.decode=function(e,i,n){switch(n=n||"none",i=i||"none"){case"base64":var r=t.Base64Utils.decodeBase64AsArray(e,4);return"none"===n?r:t.Base64Utils.decompress(e,r,n);case"csv":return t.Base64Utils.decodeCSV(e);case"none":for(var o=[],s=0;s<e.length;s++)o[s]=+e[s].gid;return o;default:throw new Error("未定义的编码:"+i)}},e.color16ToUnit=function(t){if(!t)return 16777215;var e="0x"+t.slice(1);return parseInt(e,16)},e}();t.TmxUtils=e}(es||(es={}));var ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,i=0;i<t.length;i++){e=!1;for(var n=t.length-1;n>i;n--)if(t[n]<t[n-1]){var r=t[n];t[n]=t[n-1],t[n-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,i=1;i<e;i++){for(var n=t[i],r=i;r>0&&t[r-1]>n;r--)t[r]=t[r-1];t[r]=n}},t.binarySearch=function(t,e){for(var i=0,n=t.length,r=i+n>>1;i<n;)e<=t[r]?n=r:e>=t[r]&&(i=r+1),r=i+n>>1;return t[i]==e?i:-1},t.findElementIndex=function(t,e){for(var i=t.length,n=0;n<i;++n)if(t[n]==e)return n;return null},t.getMaxElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]>t[e]&&(e=n);return e},t.getMinElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]<t[e]&&(e=n);return e},t.getUniqueAry=function(t){for(var e=[],i=[],n=t.length,r=0;r<n;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(n=e.length)-1;r>=0;--r)i.unshift(e[r]);return i},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var i=t.concat(e),n={},r=[],o=i.length,s=0;s<o;++s)n[i[s]]?n[i[s]]instanceof Object&&n[i[s]].count++:(n[i[s]]={},n[i[s]].count=0,n[i[s]].key=i[s],n[i[s]].count++);for(var a in n)2!=n[a].count&&r.unshift(n[a].key);return r},t.swap=function(t,e,i){var n=t[e];t[e]=t[i],t[i]=n},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var i=t.length;if(i!=e.length)return!1;for(;i--;)if(t[i]!=e[i])return!1;return!0},t.insert=function(t,e,i){if(!t)return null;var n=t.length;if(e>n&&(e=n),e<0&&(e=0),e==n)t.push(i);else if(0==e)t.unshift(i);else{for(var r=n-1;r>=e;r-=1)t[r+1]=t[r];t[e]=i}return i},t}();!function(t){var e=function(){function t(){}return Object.defineProperty(t,"nativeBase64",{get:function(){return"function"==typeof window.atob},enumerable:!0,configurable:!0}),t.decode=function(t){if(t=t.replace(/[^A-Za-z0-9\+\/\=]/g,""),this.nativeBase64)return window.atob(t);for(var e,i,n,r,o,s,a=[],h=0;h<t.length;)e=this._keyStr.indexOf(t.charAt(h++))<<2|(r=this._keyStr.indexOf(t.charAt(h++)))>>4,i=(15&r)<<4|(o=this._keyStr.indexOf(t.charAt(h++)))>>2,n=(3&o)<<6|(s=this._keyStr.indexOf(t.charAt(h++))),a.push(String.fromCharCode(e)),64!==o&&a.push(String.fromCharCode(i)),64!==s&&a.push(String.fromCharCode(n));return a=a.join("")},t.encode=function(t){if(t=t.replace(/\r\n/g,"\n"),!this.nativeBase64){for(var e,i,n,r,o,s,a,h=[],c=0;c<t.length;)r=(e=t.charCodeAt(c++))>>2,o=(3&e)<<4|(i=t.charCodeAt(c++))>>4,s=(15&i)<<2|(n=t.charCodeAt(c++))>>6,a=63&n,isNaN(i)?s=a=64:isNaN(n)&&(a=64),h.push(this._keyStr.charAt(r)),h.push(this._keyStr.charAt(o)),h.push(this._keyStr.charAt(s)),h.push(this._keyStr.charAt(a));return h=h.join("")}window.btoa(t)},t.decodeBase64AsArray=function(e,i){i=i||1;var n,r,o,s=t.decode(e),a=new Uint32Array(s.length/i);for(n=0,o=s.length/i;n<o;n++)for(a[n]=0,r=i-1;r>=0;--r)a[n]+=s.charCodeAt(n*i+r)<<(r<<3);return a},t.decompress=function(t,e,i){throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!")},t.decodeCSV=function(t){for(var e=t.replace("\n","").trim().split(","),i=[],n=0;n<e.length;n++)i.push(+e[n]);return i},t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",t}();t.Base64Utils=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r){if(0!=(4294967040&(e|i|n|r))){var o=t.MathHelper.clamp(e,0,255),s=t.MathHelper.clamp(i,0,255),a=t.MathHelper.clamp(n,0,255),h=t.MathHelper.clamp(r,0,255);this._packedValue=h<<24|a<<16|s<<8|o}else this._packedValue=r<<24|n<<16|i<<8|e}return Object.defineProperty(e.prototype,"b",{get:function(){return this._packedValue>>16},set:function(t){this._packedValue=4278255615&this._packedValue|t<<16},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"g",{get:function(){return this._packedValue>>8},set:function(t){this._packedValue=4294902015&this._packedValue|t<<8},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"r",{get:function(){return this._packedValue},set:function(t){this._packedValue=4294967040&this._packedValue|t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"a",{get:function(){return this._packedValue>>24},set:function(t){this._packedValue=16777215&this._packedValue|t<<24},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedValue",{get:function(){return this._packedValue},set:function(t){this._packedValue=t},enumerable:!0,configurable:!0}),e.prototype.equals=function(t){return this._packedValue==t._packedValue},e}();t.Color=e}(es||(es={})),function(t){var e=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var i=this;return void 0===e&&(e=!0),new Promise(function(n,r){var o=i.loadedAssets.get(t);o?n(o):e?RES.getResAsync(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}();t.ContentManager=e}(es||(es={})),function(t){var e=function(){function t(){}return t.getColorMatrix=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];return e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255,new egret.ColorMatrixFilter(e)},t}();t.DrawUtils=e}(es||(es={})),function(t){var e=function(){function e(){}return e.oppositeEdge=function(e){switch(e){case t.Edge.bottom:return t.Edge.top;case t.Edge.top:return t.Edge.bottom;case t.Edge.left:return t.Edge.right;case t.Edge.right:return t.Edge.left}},e.isHorizontal=function(e){return e==t.Edge.right||e==t.Edge.left},e.isVertical=function(e){return e==t.Edge.top||e==t.Edge.bottom},e}();t.EdgeExt=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.func=t,this.context=e}}();t.FuncPack=e;var i=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,i,n){var r=this._messageTable.get(t);r||(r=[],this._messageTable.set(t,r)),-1!=r.findIndex(function(t){return t.func==i})&&console.warn("您试图添加相同的观察者两次"),r.push(new e(i,n))},t.prototype.removeObserver=function(t,e){var i=this._messageTable.get(t),n=i.findIndex(function(t){return t.func==e});-1!=n&&i.removeAt(n)},t.prototype.emit=function(t,e){var i=this._messageTable.get(t);if(i)for(var n=i.length-1;n>=0;n--)i[n].func.call(i[n].context,e)},t}();t.Emitter=i}(es||(es={})),function(t){!function(t){t[t.top=0]="top",t[t.bottom=1]="bottom",t[t.left=2]="left",t[t.right=3]="right"}(t.Edge||(t.Edge={}))}(es||(es={})),function(t){var e=function(){function t(){}return t.repeat=function(t,e){for(var i=[];e--;)i.push(t);return i},t}();t.Enumerable=e}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t}();t.GlobalManager=e}(es||(es={})),function(t){var e=function(){function e(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),e.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},e}();t.TouchState=e;var i=function(){function i(){}return Object.defineProperty(i,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(i,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(i,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:t.Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(i,"maxSupportedTouch",{get:function(){return t.Core._instance.stage.maxTouches},set:function(e){t.Core._instance.stage.maxTouches=e,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPositionDelta",{get:function(){var e=t.Vector2.subtract(this.touchPosition,this._previousTouchState.position);return e.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),e},enumerable:!0,configurable:!0}),i.initialize=function(){this._init||(this._init=!0,t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},i.scaledPosition=function(e){var i=new t.Vector2(e.x-this._resolutionOffset.x,e.y-this._resolutionOffset.y);return t.Vector2.multiply(i,this.resolutionScale)},i.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new e)},i.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},i.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var i=this._gameTouchs[e];i.x=t.stageX,i.y=t.stageY}},i.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},i.setpreviousTouchState=function(t){this._previousTouchState=new e,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},i._init=!1,i._previousTouchState=new e,i._resolutionOffset=new t.Vector2,i._touchIndex=0,i._gameTouchs=[],i._resolutionScale=t.Vector2.one,i._totalTouchCount=0,i}();t.Input=i}(es||(es={}));var KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.registerKey=function(t,e,i,n){void 0===n&&(n=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(n?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:i}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),i=this.keyDownDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),i=this.keyUpDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}();!function(t){var e=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}();t.ListPool=e}(es||(es={}));var THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y",this.setItem=egret.localStorage.setItem.bind(localStorage),this.getItem=egret.localStorage.getItem.bind(localStorage),this.removeItem=egret.localStorage.removeItem.bind(localStorage)}return t.prototype.lock=function(){var t=this;return new Promise(function(e,i){var n=function(){t.setItem(t._keyX,THREAD_ID),null===!t.getItem(t._keyY)&&nextTick(n),t.setItem(t._keyY,THREAD_ID),t.getItem(t._keyX)!==THREAD_ID?setTimeout(function(){t.getItem(t._keyY)===THREAD_ID?(e(),t.removeItem(t._keyY)):nextTick(n)},10):(e(),t.removeItem(t._keyY))};n()})},t}();!function(t){var e=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}();t.Pair=e}(es||(es={}));var RandomUtils=function(){function t(){}return t.randrange=function(t,e,i){if(void 0===i&&(i=1),0==i)throw new Error("step 不能为 0");var n=e-t;if(0==n)throw new Error("没有可用的范围("+t+","+e+")");n<0&&(n=t-e);var r=Math.floor((n+i-1)/i);return Math.floor(this.random()*r)*i+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var i=t.length;if(e<=0||i<e)throw new Error("采样数量不够");for(var n=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*i);r.indexOf(s)>=0;)s=Math.floor(this.random()*i);n.push(t[s]),r.push(s)}return n},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t}();!function(t){var e=function(){function e(){}return e.getSide=function(e,i){switch(i){case t.Edge.top:return e.top;case t.Edge.bottom:return e.bottom;case t.Edge.left:return e.left;case t.Edge.right:return e.right}},e.union=function(e,i){var n=new t.Rectangle(i.x,i.y,0,0),r=new t.Rectangle;return r.x=Math.min(e.x,n.x),r.y=Math.min(e.y,n.y),r.width=Math.max(e.right,n.right)-r.x,r.height=Math.max(e.bottom,r.bottom)-r.y,r},e.getHalfRect=function(e,i){switch(i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,e.height/2);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height/2,e.width,e.height/2);case t.Edge.left:return new t.Rectangle(e.x,e.y,e.width/2,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width/2,e.y,e.width/2,e.height)}},e.getRectEdgePortion=function(e,i,n){switch(void 0===n&&(n=1),i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,n);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height-n,e.width,n);case t.Edge.left:return new t.Rectangle(e.x,e.y,n,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width-n,e.y,n,e.height)}},e.expandSide=function(e,i,n){switch(n=Math.abs(n),i){case t.Edge.top:e.y-=n,e.height+=n;break;case t.Edge.bottom:e.height+=n;break;case t.Edge.left:e.x-=n,e.width+=n;break;case t.Edge.right:e.width+=n}},e.contract=function(t,e,i){t.x+=e,t.y+=i,t.width-=2*e,t.height-=2*i},e}();t.RectangleExt=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.update=function(t){this.remainder+=t;var e=Math.trunc(this.remainder);return this.remainder-=e,e},t.prototype.reset=function(){this.remainder=0},t}();t.SubpixelNumber=e}(es||(es={})),function(t){var e=function(){function e(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return e.testPointTriangle=function(e,i,n,r){return!(t.Vector2Ext.cross(t.Vector2.subtract(e,i),t.Vector2.subtract(n,i))<0)&&(!(t.Vector2Ext.cross(t.Vector2.subtract(e,n),t.Vector2.subtract(r,n))<0)&&!(t.Vector2Ext.cross(t.Vector2.subtract(e,r),t.Vector2.subtract(i,r))<0))},e.prototype.triangulate=function(i,n){void 0===n&&(n=!0);var r=i.length;this.initialize(r);for(var o=0,s=0;r>3&&o<500;){o++;var a=!0,h=i[this._triPrev[s]],c=i[s],u=i[this._triNext[s]];if(t.Vector2Ext.isTriangleCCW(h,c,u)){var l=this._triNext[this._triNext[s]];do{if(e.testPointTriangle(i[l],h,c,u)){a=!1;break}l=this._triNext[l]}while(l!=this._triPrev[s])}else a=!1;a?(this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),this._triNext[this._triPrev[s]]=this._triNext[s],this._triPrev[this._triNext[s]]=this._triPrev[s],r--,s=this._triPrev[s]):s=this._triNext[s]}this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),n||this.triangleIndices.reverse()},e.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},e}();t.Triangulator=e}(es||(es={})),function(t){var e=function(){function e(){}return e.isTriangleCCW=function(e,i,n){return this.cross(t.Vector2.subtract(i,e),t.Vector2.subtract(n,i))<0},e.cross=function(t,e){return t.y*e.x-t.x*e.y},e.perpendicular=function(e,i){return new t.Vector2(-1*(i.y-e.y),i.x-e.x)},e.normalize=function(e){var i=Math.sqrt(e.x*e.x+e.y*e.y);return i>t.MathHelper.Epsilon?e=t.Vector2.divide(e,new t.Vector2(i)):e.x=e.y=0,e},e.transformA=function(t,e,i,n,r,o){for(var s=0;s<o;s++){var a=t[e+s],h=n[r+s];h.x=a.x*i.m11+a.y*i.m21+i.m31,h.y=a.x*i.m12+a.y*i.m22+i.m32,n[r+s]=h}},e.transformR=function(e,i){var n=e.x*i.m11+e.y*i.m21+i.m31,r=e.x*i.m12+e.y*i.m22+i.m32;return new t.Vector2(n,r)},e.transform=function(t,e,i){this.transformA(t,0,e,i,0,t.length)},e.round=function(e){return new t.Vector2(Math.round(e.x),Math.round(e.y))},e}();t.Vector2Ext=e}(es||(es={}));var stopwatch,WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}();!function(t){var e,i=function(){function i(){this.clientArea=new t.Rectangle(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.safeArea=this.clientArea}return i.prototype.place=function(i,n,r,o){var s=new t.Rectangle(0,0,i.x,i.y);return 0!=(o&e.left)?s.x=this.clientArea.x+this.clientArea.width*n:0!=(o&e.right)?s.x=this.clientArea.x+this.clientArea.width*(1-n)-s.width:0!=(o&e.horizontalCenter)&&(s.x=this.clientArea.x+(this.clientArea.width-s.width)/2+n*this.clientArea.width),0!=(o&e.top)?s.y=this.clientArea.y+this.clientArea.height*r:0!=(o&e.bottom)?s.y=this.clientArea.y+this.clientArea.height*(1-r)-s.height:0!=(o&e.verticalCenter)&&(s.y=this.clientArea.y+(this.clientArea.height-s.height)/2+r*this.clientArea.height),s.left<this.safeArea.left&&(s.x=this.safeArea.left),s.right>this.safeArea.right&&(s.x=this.safeArea.right-s.width),s.top<this.safeArea.top&&(s.y=this.safeArea.top),s.bottom>this.safeArea.bottom&&(s.y=this.safeArea.bottom-s.height),s},i}();t.Layout=i,function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(e=t.Alignment||(t.Alignment={}))}(es||(es={})),function(t){var e,i=function(){function t(t){void 0===t&&(t=n),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(i=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var i=this.getSystemTime();this._startSystemTime=i,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=i,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),n=t};var n=Date.now}(stopwatch||(stopwatch={})),function(t){var e=function(){function e(){this.showLog=!1,this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this._logs=new Array(2);for(var e=0;e<this._logs.length;++e)this._logs[e]=new i;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*t.Core.graphicsDevice.viewport.width,t.Core.emitter.addObserver(t.CoreEvents.GraphicsDeviceReset,this.onGraphicsDeviceReset,this),this.onGraphicsDeviceReset()}return Object.defineProperty(e,"Instance",{get:function(){return this._instance||(this._instance=new e),this._instance},enumerable:!0,configurable:!0}),e.prototype.startFrame=function(){var t=this;new LockUtils(this._frameKey).lock().then(function(){t._updateCount=parseInt(egret.localStorage.getItem(t._frameKey),10),isNaN(t._updateCount)&&(t._updateCount=0);var i=t._updateCount;if(i+=1,egret.localStorage.setItem(t._frameKey,i.toString()),!(t.enabled&&1<i&&i<e.maxSampleFrames)){t._prevLog=t._logs[1&t.frameCount++],t._curLog=t._logs[1&t.frameCount];for(var n=t.stopwacth.getTime(),r=0;r<t._prevLog.bars.length;++r){for(var o=t._prevLog.bars[r],s=t._curLog.bars[r],a=0;a<o.nestCount;++a){var h=o.markerNests[a];o.markers[h].endTime=n,s.markerNests[a]=a,s.markers[a].markerId=o.markers[h].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[h].color}for(h=0;h<o.markCount;++h){var c=o.markers[h].endTime-o.markers[h].beginTime,u=o.markers[h].markerId,l=t.markers[u];l.logs[r].color=o.markers[h].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,c),l.logs[r].max=Math.min(l.logs[r].max,c),l.logs[r].avg+=c,l.logs[r].avg*=.5,l.logs[r].samples++>=e.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=c,l.logs[r].max=c,l.logs[r].avg=c,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}t.stopwacth.reset(),t.stopwacth.start()}})},e.prototype.beginMark=function(t,i,n){var r=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=e.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[n];if(o.markCount>=e.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=e.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(t);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(t,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=i,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},e.prototype.endMark=function(t,i){var n=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=e.maxBars)throw new Error("barIndex argument out of range");var r=n._curLog.bars[i];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=n._markerNameToIdMap.get(t);if(isNaN(o))throw new Error("Marker "+t+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=n.stopwacth.getTime()})},e.prototype.getAverageTime=function(t,i){if(t<0||t>=e.maxBars)throw new Error("barIndex argument out of range");var n=0,r=this._markerNameToIdMap.get(i);return r&&(n=this.markers[r].logs[t].avg),n},e.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},e.prototype.render=function(t,i){if(void 0===t&&(t=this._position),void 0===i&&(i=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var n=0,r=0;this._prevLog.bars.forEach(function(t){t.markCount>0&&(n+=e.barHeight+2*e.barPadding,r=Math.max(r,t.markers[t.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>e.autoAdjustDelay&&(this.sampleFrames=Math.min(e.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);t.y,e.barHeight}},e.prototype.onGraphicsDeviceReset=function(){var i=new t.Layout;this._position=i.place(new t.Vector2(this.width,e.barHeight),0,.01,t.Alignment.bottomCenter).location},e.maxBars=8,e.maxSamples=256,e.maxNestCall=32,e.barHeight=8,e.maxSampleFrames=4,e.logSnapDuration=120,e.barPadding=2,e.autoAdjustDelay=30,e}();t.TimeRuler=e;var i=function(){return function(){this.bars=new Array(e.maxBars),this.bars.fill(new n,0,e.maxBars)}}();t.FrameLog=i;var n=function(){return function(){this.markers=new Array(e.maxSamples),this.markCount=0,this.markerNests=new Array(e.maxNestCall),this.nestCount=0,this.markers.fill(new r,0,e.maxSamples),this.markerNests.fill(0,0,e.maxNestCall)}}();t.MarkerCollection=n;var r=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}();t.Marker=r;var o=function(){return function(t){this.logs=new Array(e.maxBars),this.name=t,this.logs.fill(new s,0,e.maxBars)}}();t.MarkerInfo=o;var s=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();t.MarkerLog=s}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){this.itemsToRaster=[],this.useCache=!1,this.cacheName="",this._sprites=new Map,this.allow4096Textures=!1}return i.prototype.addTextureToPack=function(e,i){this.itemsToRaster.push(new t.TextureToPack(e,i))},i.prototype.process=function(t){return void 0===t&&(t=!1),__awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this.allow4096Textures=t,this.useCache?""==this.cacheName?(console.error("未指定缓存名称"),[2]):[4,RES.getResByUrl(this.cacheName)]:[3,2];case 1:return e.sent()?this.loadPack():this.createPack(),[3,3];case 2:this.createPack(),e.label=3;case 3:return[2]}})})},i.prototype.loadPack=function(){return __awaiter(this,void 0,void 0,function(){var t;return __generator(this,function(e){switch(e.label){case 0:return[4,RES.getResByUrl(this.cacheName)];case 1:return t=e.sent(),this.onProcessCompleted&&this.onProcessCompleted(),[2,t]}})})},i.prototype.createPack=function(){for(var i=[],n=[],r=0,o=this.itemsToRaster;r<o.length;r++){var s=o[r];i.push(new e(s.texture)),n.push(s.id)}for(var a=this.allow4096Textures?4096:2048,h=[],c=0;c<i.length;c++){if(i[c].width>a||i[c].height>a)throw new Error("一个纹理的大小比图集的大小大");h.push(new t.Rectangle(0,0,i[c].width,i[c].height))}for(;h.length>0;){var u=new egret.RenderTexture,l=new t.RectanglePacker(a,a,1);for(c=0;c<h.length;c++)l.insertRectangle(Math.floor(h[c].width),Math.floor(h[c].height),c);if(l.packRectangles(),l.rectangleCount>0){for(var p=new t.IntegerRectangle,d=[],f=[],g=[],m=[],y=0;y<l.rectangleCount;y++){p=l.getRectangle(y,p);var _=l.getRectangleId(y);u.drawToTexture(i[_],new t.Rectangle(p.x,p.y,p.width,p.height)),(R=new t.TextureAsset).x=p.x,R.y=p.y,R.width=p.width,R.height=p.height,R.name=n[_],d.push(R),f.push(h[_]),g.push(i[_].texture),m.push(n[_])}for(var v=0,b=f;v<b.length;v++){var x=b[v];h.remove(x)}for(var T=function(t){i.removeAll(function(e){return e.texture.hashCode==t.hashCode})},w=0,C=g;w<C.length;w++){T(x=C[w])}for(var S=0,P=m;S<P.length;S++){x=P[S];n.remove(x)}""!=this.cacheName&&(u.saveToFile("image/png",this.cacheName),0);for(var O=0,D=d;O<D.length;O++){var R=D[O];this._sprites.set(R.name,u)}}}this.onProcessCompleted&&this.onProcessCompleted()},i.prototype.dispose=function(){this._sprites.forEach(function(t,e){t.dispose(),RES.destroyRes(e)}),this._sprites.clear()},i.prototype.getTexture=function(t){return this._sprites.get(t)},i}();t.AssetPacker=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Rectangle);t.IntegerRectangle=e}(es||(es={})),function(t){var e=function(){function e(e,i,n){void 0===n&&(n=0),this._width=0,this._height=0,this._padding=8,this._packedWidth=0,this._packedHeight=0,this._insertList=[],this._insertedRectangles=[],this._freeAreas=[],this._newFreeAreas=[],this._sortableSizeStack=[],this._rectangleStack=[],this._outsideRectangle=new t.IntegerRectangle(e+1,i+1,0,0),this.reset(e,i,n)}return Object.defineProperty(e.prototype,"rectangleCount",{get:function(){return this._insertedRectangles.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedWidth",{get:function(){return this._packedWidth},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedHeight",{get:function(){return this._packedHeight},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"padding",{get:function(){return this._padding},enumerable:!0,configurable:!0}),e.prototype.reset=function(t,e,i){for(void 0===i&&(i=0);this._insertedRectangles.length>0;)this.freeRectangle(this._insertedRectangles.pop());for(;this._freeAreas.length>0;)this.freeRectangle(this._freeAreas.pop());for(this._width=t,this._height=e,this._packedWidth=0,this._packedHeight=0,this._freeAreas.push(this.allocateRectangle(0,0,this._width,this._height));this._insertedRectangles.length>0;)this.freeSize(this._insertList.pop());this._padding=i},e.prototype.insertRectangle=function(t,e,i){var n=this.allocateSize(t,e,i);this._insertList.push(n)},e.prototype.packRectangles=function(t){for(void 0===t&&(t=!0),t&&this._insertList.sort(function(t,e){return t.width-e.width});this._insertList.length>0;){var e=this._insertList.pop(),i=e.width,n=e.height,r=this.getFreeAreaIndex(i,n);if(r>=0){var o=this._freeAreas[r],s=this.allocateRectangle(o.x,o.y,i,n);for(s.id=e.id,this.generateNewFreeAreas(s,this._freeAreas,this._newFreeAreas);this._newFreeAreas.length>0;)this._freeAreas.push(this._newFreeAreas.pop());this._insertedRectangles.push(s),s.right>this._packedWidth&&(this._packedWidth=s.right),s.bottom>this._packedHeight&&(this._packedHeight=s.bottom)}this.freeSize(e)}return this.rectangleCount},e.prototype.getRectangle=function(t,e){var i=this._insertedRectangles[t];return e.x=i.x,e.y=i.y,e.width=i.width,e.height=i.height,e},e.prototype.getRectangleId=function(t){return this._insertedRectangles[t].id},e.prototype.generateNewFreeAreas=function(t,e,i){var n=t.x,r=t.y,o=t.right+1+this._padding,s=t.bottom+1+this._padding,a=null;0==this._padding&&(a=t);for(var h=e.length-1;h>=0;h--){var c=e[h];if(!(n>=c.right||o<=c.x||r>=c.bottom||s<=c.y)){null==a&&(a=this.allocateRectangle(t.x,t.y,t.width+this._padding,t.height+this._padding)),this.generateDividedAreas(a,c,i);var u=e.pop();h<e.length&&(e[h]=u)}}null!=a&&a!=t&&this.freeRectangle(a),this.filterSelfSubAreas(i)},e.prototype.filterSelfSubAreas=function(t){for(var e=t.length-1;e>=0;e--)for(var i=t[e],n=t.length-1;n>=0;n--)if(e!=n){var r=t[n];if(i.x>=r.x&&i.y>=r.y&&i.right<=r.right&&i.bottom<=r.bottom){this.freeRectangle(i);var o=t.pop();e<t.length&&(t[e]=o);break}}},e.prototype.generateDividedAreas=function(t,e,i){var n=0,r=e.right-t.right;r>0&&(i.push(this.allocateRectangle(t.right,e.y,r,e.height)),n++);var o=t.x-e.x;o>0&&(i.push(this.allocateRectangle(e.x,e.y,o,e.height)),n++);var s=e.bottom-t.bottom;s>0&&(i.push(this.allocateRectangle(e.x,t.bottom,e.width,s)),n++);var a=t.y-e.y;a>0&&(i.push(this.allocateRectangle(e.x,e.y,e.width,a)),n++),0==n&&(t.width<e.width||t.height<e.height)?i.push(e):this.freeRectangle(e)},e.prototype.getFreeAreaIndex=function(t,e){for(var i=this._outsideRectangle,n=-1,r=t+this._padding,o=e+this._padding,s=this._freeAreas.length-1;s>=0;s--){var a=this._freeAreas[s];if(a.x<this._packedWidth||a.y<this.packedHeight){if(a.x<i.x&&r<=a.width&&o<=a.height){if(n=s,r==a.width&&a.width<=a.height&&a.right<this._width||o==a.height&&a.height<=a.width)break;i=a}}else if(a.x<i.x&&t<=a.width&&e<=a.height){if(n=s,t==a.width&&a.width<=a.height&&a.right<this._width||e==a.height&&a.height<=a.width)break;i=a}}return n},e.prototype.allocateSize=function(e,i,n){if(this._sortableSizeStack.length>0){var r=this._sortableSizeStack.pop();return r.width=e,r.height=i,r.id=n,r}return new t.SortableSize(e,i,n)},e.prototype.freeSize=function(t){this._sortableSizeStack.push(t)},e.prototype.allocateRectangle=function(e,i,n,r){if(this._rectangleStack.length>0){var o=this._rectangleStack.pop();return o.x=e,o.y=i,o.width=n,o.height=r,o.right=e+n,o.bottom=i+r,o}return new t.IntegerRectangle(e,i,n,r)},e.prototype.freeRectangle=function(t){this._rectangleStack.push(t)},e}();t.RectanglePacker=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.width=t,this.height=e,this.id=i}}();t.SortableSize=e}(es||(es={})),function(t){var e=function(){return function(t){this.assets=t}}();t.TextureAssets=e;var i=function(){return function(){}}();t.TextureAsset=i}(es||(es={})),function(t){var e=function(){return function(t,e){this.texture=t,this.id=e}}();t.TextureToPack=e}(es||(es={}));
\ No newline at end of file
+window.es={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var i in e)e.hasOwnProperty(i)&&(t[i]=e[i])};return function(e,i){function n(){this.constructor=e}t(e,i),e.prototype=null===i?Object.create(i):(n.prototype=i.prototype,new n)}}();var transform,__awaiter=this&&this.__awaiter||function(t,e,i,n){return new(i||(i=Promise))(function(r,o){function s(t){try{h(n.next(t))}catch(t){o(t)}}function a(t){try{h(n.throw(t))}catch(t){o(t)}}function h(t){t.done?r(t.value):new i(function(e){e(t.value)}).then(s,a)}h((n=n.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var i,n,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(i)throw new TypeError("Generator is already executing.");for(;s;)try{if(i=1,n&&(r=2&o[0]?n.return:o[0]?n.throw||((r=n.return)&&r.call(n),0):n.next)&&!(r=r.call(n,o[1])).done)return r;switch(n=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,n=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],n=0}finally{i=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++)if(e.call(arguments[2],t[i],i,t))return i;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var i=t.findIndex(e);return-1==i?null:t[i]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return e.call(arguments[2],n,r,t)&&i.push(n),i},[]);for(var i=[],n=0,r=t.length;n<r;n++){var o=t[n];e.call(arguments[2],o,n,t)&&i.push(o)}return i}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++){if(t[i]instanceof egret.HashObject&&e instanceof egret.HashObject&&t[i].hashCode==e.hashCode)return!0;if(t[i]==e)return!0}return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var i;do{(i=t.findIndex(e))>=0&&t.splice(i,1)}while(i>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var i=t.findIndex(function(t){return t===e});return i>=0&&(t.splice(i,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,i){t.splice(e,i)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return i.push(e.call(arguments[2],n,r,t)),i},[]);for(var i=[],n=0,r=t.length;n<r;n++)i.push(e.call(arguments[2],t[n],n,t));return i}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?i(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?-i(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var i=[];return t.reduce(function(n,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=i.findIndex(function(t){return t===s});return a<0&&(a=i.push(s)-1),n[a]||(n[a]=[]),n[a].push(r),n},[])}for(var n=[],r=[],o=function(i,o){var a=JSON.stringify(e.call(s[1],t[i],i,t)),h=r.findIndex(function(t){return t===a});h<0&&(h=r.push(a)-1),n[h]||(n[h]=[]),n[h].push(t[i])},s=arguments,a=0,h=t.length;a<h;a++)o(a);return n}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var i,n=0,r=t.length;n<r;n++)0==n?i=e?e.call(arguments[2],t[n],n,t):t[n]:i+=e?e.call(arguments[2],t[n],n,t):t[n];return i}(this,t)},function(t){var e=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}();t.PriorityQueueNode=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new i(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";e.getNeighbors(t.data).forEach(function(n){var s=h.get(t.data)+e.cost(t.data,n);if(!o.hasKey(h,n)||s<h.get(n)){h.set(n,s);var u=s+e.heuristic(n,r);c.enqueue(new i(n),u),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},e.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},e}();t.AStarPathfinder=e;var i=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.AStarNode=i}(es||(es={})),function(t){var e=function(){function e(e,i){this.dirs=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=i}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.AStarPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this.dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},e}();t.AstarGridGraph=e}(es||(es={})),function(t){var e=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var i=e+1;if(i<this._nodes.length&&this._nodes[i]&&this.hasHigherPriority(this._nodes[i],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),i=this._nodes[e];e>0&&this.hasHigherPriority(t,i)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,i=t.queueIndex;;){e=t;var n=2*i;if(n>this._numNodes){t.queueIndex=i,this._nodes[i]=t;break}var r=this._nodes[n];this.hasHigherPriority(r,e)&&(e=r);var o=n+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=i,this._nodes[i]=t;break}this._nodes[i]=e;var a=e.queueIndex;e.queueIndex=i,i=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var i=this._nodes[e];if(this.hasHigherPriority(i,t))break;this.swap(t,i),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var i=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=i},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}();t.PriorityQueue=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,i,n){var r=this,o=!1,s=[];s.unshift(i);var a=new Map;a.set(i,i);for(var h=function(){var t=s.shift();if(JSON.stringify(t)==JSON.stringify(n))return o=!0,"break";e.getNeighbors(t).forEach(function(e){r.hasKey(a,e)||(s.unshift(e),a.set(e,t))})};s.length>0;){if("break"===h())break}return o?t.AStarPathfinder.recontructPath(a,i,n):null},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e}();t.BreadthFirstPathfinder=e}(es||(es={})),function(t){var e=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}();t.UnweightedGraph=e}(es||(es={})),function(t){var e=function(){function e(t,e){this.x=0,this.y=0,this.x=t||0,this.y=null!=e?e:this.x}return Object.defineProperty(e,"zero",{get:function(){return e.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"one",{get:function(){return e.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitX",{get:function(){return e.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitY",{get:function(){return e.unitYVector},enumerable:!0,configurable:!0}),e.add=function(t,i){var n=new e(0,0);return n.x=t.x+i.x,n.y=t.y+i.y,n},e.divide=function(t,i){var n=new e(0,0);return n.x=t.x/i.x,n.y=t.y/i.y,n},e.multiply=function(t,i){var n=new e(0,0);return n.x=t.x*i.x,n.y=t.y*i.y,n},e.subtract=function(t,i){var n=new e(0,0);return n.x=t.x-i.x,n.y=t.y-i.y,n},e.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},e.dot=function(t,e){return t.x*e.x+t.y*e.y},e.distanceSquared=function(t,e){var i=t.x-e.x,n=t.y-e.y;return i*i+n*n},e.clamp=function(i,n,r){return new e(t.MathHelper.clamp(i.x,n.x,r.x),t.MathHelper.clamp(i.y,n.y,r.y))},e.lerp=function(i,n,r){return new e(t.MathHelper.lerp(i.x,n.x,r),t.MathHelper.lerp(i.y,n.y,r))},e.transform=function(t,i){return new e(t.x*i.m11+t.y*i.m21+i.m31,t.x*i.m12+t.y*i.m22+i.m32)},e.distance=function(t,e){var i=t.x-e.x,n=t.y-e.y;return Math.sqrt(i*i+n*n)},e.angle=function(i,n){return i=e.normalize(i),n=e.normalize(n),Math.acos(t.MathHelper.clamp(e.dot(i,n),-1,1))*t.MathHelper.Rad2Deg},e.negate=function(t){var i=new e;return i.x=-t.x,i.y=-t.y,i},e.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this},e.prototype.divide=function(t){return this.x/=t.x,this.y/=t.y,this},e.prototype.multiply=function(t){return this.x*=t.x,this.y*=t.y,this},e.prototype.subtract=function(t){return this.x-=t.x,this.y-=t.y,this},e.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);return this.x*=t,this.y*=t,this},e.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},e.prototype.lengthSquared=function(){return this.x*this.x+this.y*this.y},e.prototype.round=function(){return new e(Math.round(this.x),Math.round(this.y))},e.prototype.equals=function(t){return t.x==this.x&&t.y==this.y},e.unitYVector=new e(0,1),e.unitXVector=new e(1,0),e.unitVector2=new e(1,1),e.zeroVector2=new e(0,0),e}();t.Vector2=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this._neighbors=new Array(4),this._width=t,this._hegiht=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.search=function(e,i){return t.BreadthFirstPathfinder.search(this,e,i)},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,-1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.UnweightedGridGraph=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.WeightedPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.WeightedGridGraph=e}(es||(es={})),function(t){var e=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.WeightedNode=e;var i=function(){function i(){}return i.search=function(i,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new e(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";i.getNeighbors(t.data).forEach(function(n){var r=h.get(t.data)+i.cost(t.data,n);if(!o.hasKey(h,n)||r<h.get(n)){h.set(n,r);var s=r;c.enqueue(new e(n),s),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},i.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},i.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},i.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},i}();t.WeightedPathfinder=i}(es||(es={})),function(t){var e=function(){function e(){}return e.drawHollowRect=function(e,i,n){void 0===n&&(n=0),this._debugDrawItems.push(new t.DebugDrawItem(e,i,n))},e.render=function(){if(this._debugDrawItems.length>0){var e=new egret.Shape;t.Core.scene&&t.Core.scene.addChild(e);for(var i=this._debugDrawItems.length-1;i>=0;i--){this._debugDrawItems[i].draw(e)&&this._debugDrawItems.removeAt(i)}}},e._debugDrawItems=[],e}();t.Debug=e}(es||(es={})),function(t){var e=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();t.DebugDefaults=e}(es||(es={})),function(t){var e;!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(e=t.DebugDrawType||(t.DebugDrawType={}));var i=function(){function i(t,i,n){this.rectangle=t,this.color=i,this.duration=n,this.drawType=e.hollowRectangle}return i.prototype.draw=function(i){switch(this.drawType){case e.line:case e.hollowRectangle:case e.pixel:case e.text:}return this.duration-=t.Time.deltaTime,this.duration<0},i}();t.DebugDrawItem=i}(es||(es={})),function(t){var e=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.updateInterval=1,e._enabled=!0,e._updateOrder=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"transform",{get:function(){return this.entity.transform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onAddedToEntity=function(){},e.prototype.onRemovedFromEntity=function(){},e.prototype.onEntityTransformChanged=function(t){},e.prototype.debugRender=function(){},e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},e.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},e.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,t},e}(egret.HashObject);t.Component=e}(es||(es={})),function(t){var e=function(e){function i(){var n=e.call(this)||this;return n._globalManagers=[],i._instance=n,i.emitter=new t.Emitter,i.content=new t.ContentManager,n.addEventListener(egret.Event.ADDED_TO_STAGE,n.onAddToStage,n),n}return __extends(i,e),Object.defineProperty(i,"Instance",{get:function(){return this._instance},enumerable:!0,configurable:!0}),Object.defineProperty(i,"scene",{get:function(){return this._instance?this._instance._scene:null},set:function(t){t?null==this._instance._scene?(this._instance._scene=t,this._instance.addChild(t),this._instance._scene.begin(),i.Instance.onSceneChanged()):this._instance._nextScene=t:console.error("场景不能为空")},enumerable:!0,configurable:!0}),i.startSceneTransition=function(t){if(!this._instance._sceneTransition)return this._instance._sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},i.registerGlobalManager=function(t){this._instance._globalManagers.push(t),t.enabled=!0},i.unregisterGlobalManager=function(t){this._instance._globalManagers.remove(t),t.enabled=!1},i.getGlobalManager=function(t){for(var e=0;e<this._instance._globalManagers.length;e++)if(this._instance._globalManagers[e]instanceof t)return this._instance._globalManagers[e];return null},i.prototype.onOrientationChanged=function(){i.emitter.emit(t.CoreEvents.OrientationChanged)},i.prototype.draw=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this._sceneTransition?(this._sceneTransition.preRender(),!this._scene||this._sceneTransition.hasPreviousSceneRender?[3,2]:(this._scene.render(),this._scene.postRender(),[4,this._sceneTransition.onBeginTransition()])):[3,4];case 1:return e.sent(),[3,3];case 2:this._sceneTransition&&(this._scene&&this._sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this._sceneTransition.render()),e.label=3;case 3:return[3,5];case 4:this._scene&&(this._scene.render(),t.Debug.render(),this._scene.postRender()),e.label=5;case 5:return[2]}})})},i.prototype.startDebugUpdate=function(){t.TimeRuler.Instance.startFrame(),t.TimeRuler.Instance.beginMark("update",65280)},i.prototype.endDebugUpdate=function(){t.TimeRuler.Instance.endMark("update")},i.prototype.onSceneChanged=function(){i.emitter.emit(t.CoreEvents.SceneChanged),t.Time.sceneChanged()},i.prototype.onGraphicsDeviceReset=function(){i.emitter.emit(t.CoreEvents.GraphicsDeviceReset)},i.prototype.initialize=function(){},i.prototype.update=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:if(t.Time.update(egret.getTimer()),!this._scene)return[3,2];for(e=this._globalManagers.length-1;e>=0;e--)this._globalManagers[e].enabled&&this._globalManagers[e].update();return this._sceneTransition&&(!this._sceneTransition||this._sceneTransition.loadsNewScene&&!this._sceneTransition.isNewSceneLoaded)||this._scene.update(),this._nextScene?(this.removeChild(this._scene),this._scene.end(),this._scene=this._nextScene,this._nextScene=null,this.onSceneChanged(),this.addChild(this._scene),[4,this._scene.begin()]):[3,2];case 1:i.sent(),i.label=2;case 2:return[4,this.draw()];case 3:return i.sent(),[2]}})})},i.prototype.onAddToStage=function(){i.graphicsDevice=new t.GraphicsDevice,this.addEventListener(egret.Event.RESIZE,this.onGraphicsDeviceReset,this),this.addEventListener(egret.StageOrientationEvent.ORIENTATION_CHANGE,this.onOrientationChanged,this),this.addEventListener(egret.Event.ENTER_FRAME,this.update,this),t.Input.initialize(),this.initialize()},i.debugRenderEndabled=!1,i}(egret.DisplayObjectContainer);t.Core=e}(es||(es={})),function(t){!function(t){t[t.GraphicsDeviceReset=0]="GraphicsDeviceReset",t[t.SceneChanged=1]="SceneChanged",t[t.OrientationChanged=2]="OrientationChanged"}(t.CoreEvents||(t.CoreEvents={}))}(es||(es={})),function(t){var e=function(){function e(i){this.updateInterval=1,this._tag=0,this._enabled=!0,this._updateOrder=0,this.components=new t.ComponentList(this),this.transform=new t.Transform(this),this.name=i,this.id=e._idGenerator++,this.componentBits=new t.BitSet}return Object.defineProperty(e.prototype,"isDestroyed",{get:function(){return this._isDestroyed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parent",{get:function(){return this.transform.parent},set:function(t){this.transform.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"childCount",{get:function(){return this.transform.childCount},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this.transform.position},set:function(t){this.transform.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localPosition",{get:function(){return this.transform.localPosition},set:function(t){this.transform.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.transform.rotation},set:function(t){this.transform.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotationDegrees",{get:function(){return this.transform.rotationDegrees},set:function(t){this.transform.setRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotation",{get:function(){return this.transform.localRotation},set:function(t){this.transform.setLocalRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotationDegrees",{get:function(){return this.transform.localRotationDegrees},set:function(t){this.transform.setLocalRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return this.transform.scale},set:function(t){this.transform.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localScale",{get:function(){return this.transform.localScale},set:function(t){this.transform.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldInverseTransform",{get:function(){return this.transform.worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localToWorldTransform",{get:function(){return this.transform.localToWorldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldToLocalTransform",{get:function(){return this.transform.worldToLocalTransform},enumerable:!0,configurable:!0}),e.prototype.onTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.components.onEntityEnabled():this.components.onEntityDisabled()),this},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene&&(this.scene.entities.markEntityListUnsorted(),this.scene.entities.markTagUnsorted(this.tag)),this},e.prototype.destroy=function(){this._isDestroyed=!0,this.scene.entities.remove(this),this.transform.parent=null;for(var t=this.transform.childCount-1;t>=0;t--){this.transform.getChild(t).entity.destroy()}},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.transform.childCount;t++)this.transform.getChild(t).entity.detachFromScene()},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.transform.childCount;e++)this.transform.getChild(e).entity.attachToScene(t)},e.prototype.clone=function(i){void 0===i&&(i=new t.Vector2);var n=new e(this.name+"(clone)");return n.copyFrom(this),n.transform.position=i,n},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestroyed&&this.components.removeAllComponents()},e.prototype.update=function(){this.components.update()},e.prototype.debugRender=function(){this.components.debugRender()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),t.initialize(),t},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.compareTo=function(t){var e=this._updateOrder-t._updateOrder;return 0==e&&(e=this.id-t.id),e},e.prototype.toString=function(){return"[Entity: name: "+this.name+", tag: "+this.tag+", enabled: "+this.enabled+", depth: "+this.updateOrder+"]"},e.prototype.copyFrom=function(t){this.tag=t.tag,this.updateInterval=t.updateInterval,this.updateOrder=t.updateOrder,this.enabled=t.enabled,this.transform.scale=t.transform.scale,this.transform.rotation=t.transform.rotation;for(var e=0;e<t.components.count;e++)this.addComponent(t.components.buffer[e].clone());for(e=0;e<t.components._componentsToAdd.length;e++)this.addComponent(t.components._componentsToAdd[e].clone());for(e=0;e<t.transform.childCount;e++){var i=t.transform.getChild(e).entity,n=i.clone();n.transform.copyFrom(i.transform),n.transform.parent=this.transform}},e._idGenerator=0,e}();t.Entity=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.enablePostProcessing=!0,i._sceneComponents=[],i._renderers=[],i._postProcessors=[],i.entities=new t.EntityList(i),i.renderableComponents=new t.RenderableComponentList,i.content=new t.ContentManager,i.entityProcessors=new t.EntityProcessorList,i.initialize(),i}return __extends(i,e),i.createWithDefaultRenderer=function(){var e=new i;return e.addRenderer(new t.DefaultRenderer),e},i.prototype.initialize=function(){},i.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},i.prototype.unload=function(){},i.prototype.onActive=function(){},i.prototype.onDeactive=function(){},i.prototype.begin=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){return 0==this._renderers.length&&(this.addRenderer(new t.DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new t.Camera),t.Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.addEventListener(egret.Event.ACTIVATE,this.onActive,this),this.addEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart(),[2]})})},i.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren();for(t=0;t<this._sceneComponents.length;t++)this._sceneComponents[t].onRemovedFromScene();this._sceneComponents.length=0,this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.parent&&this.parent.removeChild(this),this.unload()},i.prototype.update=function(){this.entities.updateLists();for(var t=this._sceneComponents.length-1;t>=0;t--)this._sceneComponents[t].enabled&&this._sceneComponents[t].update();this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},i.prototype.render=function(){if(0!=this._renderers.length)for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this);else console.error("场景中没有渲染器!")},i.prototype.postRender=function(){if(this.enablePostProcessing)for(var e=0;e<this._postProcessors.length;e++)this._postProcessors[e].enabled&&this._postProcessors[e].process();if(this._screenshotRequestCallback){var i=new egret.RenderTexture;i.drawToTexture(this,new t.Rectangle(0,0,this.stage.stageWidth,this.stage.stageHeight)),this._screenshotRequestCallback(i),this._screenshotRequestCallback=null}},i.prototype.requestScreenshot=function(t){this._screenshotRequestCallback=t},i.prototype.addSceneComponent=function(t){return t.scene=this,t.onEnabled(),this._sceneComponents.push(t),this._sceneComponents.sort(t.compareTo),t},i.prototype.getSceneComponent=function(t){for(var e=0;e<this._sceneComponents.length;e++){var i=this._sceneComponents[e];if(i instanceof t)return i}return null},i.prototype.getOrCreateSceneComponent=function(t){var e=this.getSceneComponent(t);return null==e&&(e=this.addSceneComponent(new t)),e},i.prototype.removeSceneComponent=function(t){this._sceneComponents.contains(t)?(this._sceneComponents.remove(t),t.onRemovedFromScene()):console.warn("SceneComponent"+t+"不在SceneComponents列表中!")},i.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},i.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},i.prototype.removeRenderer=function(t){this._renderers.contains(t)&&(this._renderers.remove(t),t.unload())},i.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},i.prototype.getPostProcessor=function(t){for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e]instanceof t)return this._postProcessors[e];return null},i.prototype.removePostProcessor=function(t){this._postProcessors.contains(t)&&(this._postProcessors.remove(t),t.unload())},i.prototype.createEntity=function(e){var i=new t.Entity(e);return this.addEntity(i)},i.prototype.createEntityAsync=function(t){var e=this;return new Promise(function(i){i(e.createEntity(t))})},i.prototype.addEntity=function(t){this.entities.buffer.contains(t)&&console.warn("您试图将同一实体添加到场景两次: "+t),this.entities.add(t),t.scene=this;for(var e=0;e<t.transform.childCount;e++)this.addEntity(t.transform.getChild(e).entity);return t},i.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},i.prototype.findEntity=function(t){return this.entities.findEntity(t)},i.prototype.findEntitiesWithTag=function(t){return this.entities.entitiesWithTag(t)},i.prototype.entitiesOfType=function(t){return this.entities.entitiesOfType(t)},i.prototype.findComponentOfType=function(t){return this.entities.findComponentOfType(t)},i.prototype.findComponentsOfType=function(t){return this.entities.findComponentsOfType(t)},i.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},i.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},i.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},i}(egret.DisplayObjectContainer);t.Scene=e}(es||(es={})),function(t){!function(t){t[t.position=0]="position",t[t.scale=1]="scale",t[t.rotation=2]="rotation"}(t.Component||(t.Component={}))}(transform||(transform={})),function(t){var e,i=egret.HashObject;!function(t){t[t.clean=0]="clean",t[t.positionDirty=1]="positionDirty",t[t.scaleDirty=2]="scaleDirty",t[t.rotationDirty=3]="rotationDirty"}(e=t.DirtyType||(t.DirtyType={}));var n=function(i){function n(e){var n=i.call(this)||this;return n._localTransform=t.Matrix2D.create(),n._worldTransform=t.Matrix2D.create().identity(),n._rotationMatrix=t.Matrix2D.create(),n._translationMatrix=t.Matrix2D.create(),n._scaleMatrix=t.Matrix2D.create(),n._worldToLocalTransform=t.Matrix2D.create().identity(),n._worldInverseTransform=t.Matrix2D.create().identity(),n._position=t.Vector2.zero,n._scale=t.Vector2.one,n._rotation=0,n._localPosition=t.Vector2.zero,n._localScale=t.Vector2.one,n._localRotation=0,n.entity=e,n.scale=t.Vector2.one,n._children=[],n}return __extends(n,i),Object.defineProperty(n.prototype,"childCount",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._rotation)},set:function(e){this.setRotation(t.MathHelper.toRadians(e))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._localRotation)},set:function(e){this.localRotation=t.MathHelper.toRadians(e)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localToWorldTransform",{get:function(){return this.updateTransform(),this._worldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"parent",{get:function(){return this._parent},set:function(t){this.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldToLocalTransform",{get:function(){return this._worldToLocalDirty&&(this.parent?(this.parent.updateTransform(),this._worldToLocalTransform=this.parent._worldTransform.invert()):this._worldToLocalTransform=t.Matrix2D.create().identity(),this._worldToLocalDirty=!1),this._worldToLocalTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldInverseTransform",{get:function(){return this.updateTransform(),this._worldInverseDirty&&(this._worldInverseTransform=this._worldTransform.invert(),this._worldInverseDirty=!1),this._worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"position",{get:function(){return this.updateTransform(),this._positionDirty&&(this.parent?(this.parent.updateTransform(),this._position=t.Vector2Ext.transformR(this._localPosition,this.parent._worldTransform)):this._position=this._localPosition,this._positionDirty=!1),this._position},set:function(t){this.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"scale",{get:function(){return this.updateTransform(),this._scale},set:function(t){this.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotation",{get:function(){return this.updateTransform(),this._rotation},set:function(t){this.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localPosition",{get:function(){return this.updateTransform(),this._localPosition},set:function(t){this.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localScale",{get:function(){return this.updateTransform(),this._localScale},set:function(t){this.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotation",{get:function(){return this.updateTransform(),this._localRotation},set:function(t){this.setLocalRotation(t)},enumerable:!0,configurable:!0}),n.prototype.getChild=function(t){return this._children[t]},n.prototype.setParent=function(t){return this._parent.equals(t)?this:(this._parent||(this._parent._children.remove(this),this._parent._children.push(this)),this._parent=t,this.setDirty(e.positionDirty),this)},n.prototype.setPosition=function(e,i){var n=new t.Vector2(e,i);return n.equals(this._position)?this:(this._position=n,this.parent?this.localPosition=t.Vector2Ext.transformR(this._position,this._worldToLocalTransform):this.localPosition=n,this._positionDirty=!1,this)},n.prototype.setLocalPosition=function(t){return t.equals(this._localPosition)?this:(this._localPosition=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.positionDirty),this)},n.prototype.setRotation=function(t){return this._rotation=t,this.parent?this.localRotation=this.parent.rotation+t:this.localRotation=t,this},n.prototype.setRotationDegrees=function(e){return this.setRotation(t.MathHelper.toRadians(e))},n.prototype.lookAt=function(e){var i=this.position.x>e.x?-1:1,n=t.Vector2.normalize(t.Vector2.subtract(this.position,e));this.rotation=i*Math.acos(t.Vector2.dot(n,t.Vector2.unitY))},n.prototype.setLocalRotation=function(t){return this._localRotation=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.rotationDirty),this},n.prototype.setLocalRotationDegrees=function(e){return this.setLocalRotation(t.MathHelper.toRadians(e))},n.prototype.setScale=function(e){return this._scale=e,this.parent?this.localScale=t.Vector2.divide(e,this.parent._scale):this.localScale=e,this},n.prototype.setLocalScale=function(t){return this._localScale=t,this._localDirty=this._positionDirty=this._localScaleDirty=!0,this.setDirty(e.scaleDirty),this},n.prototype.roundPosition=function(){this.position=this._position.round()},n.prototype.updateTransform=function(){this.hierarchyDirty!=e.clean&&(this.parent&&this.parent.updateTransform(),this._localDirty&&(this._localPositionDirty&&(this._translationMatrix=t.Matrix2D.create().translate(this._localPosition.x,this._localPosition.y),this._localPositionDirty=!1),this._localRotationDirty&&(this._rotationMatrix=t.Matrix2D.create().rotate(this._localRotation),this._localRotationDirty=!1),this._localScaleDirty&&(this._scaleMatrix=t.Matrix2D.create().scale(this._localScale.x,this._localScale.y),this._localScaleDirty=!1),this._localTransform=this._scaleMatrix.multiply(this._rotationMatrix),this._localTransform=this._localTransform.multiply(this._translationMatrix),this.parent||(this._worldTransform=this._localTransform,this._rotation=this._localRotation,this._scale=this._localScale,this._worldInverseDirty=!0),this._localDirty=!1),this.parent&&(this._worldTransform=this._localTransform.multiply(this.parent._worldTransform),this._rotation=this._localRotation+this.parent._rotation,this._scale=t.Vector2.multiply(this.parent._scale,this._localScale),this._worldInverseDirty=!0),this._worldToLocalDirty=!0,this._positionDirty=!0,this.hierarchyDirty=e.clean)},n.prototype.setDirty=function(e){if(0==(this.hierarchyDirty&e)){switch(this.hierarchyDirty|=e,e){case t.DirtyType.positionDirty:this.entity.onTransformChanged(transform.Component.position);break;case t.DirtyType.rotationDirty:this.entity.onTransformChanged(transform.Component.rotation);break;case t.DirtyType.scaleDirty:this.entity.onTransformChanged(transform.Component.scale)}this._children||(this._children=[]);for(var i=0;i<this._children.length;i++)this._children[i].setDirty(e)}},n.prototype.copyFrom=function(t){this._position=t.position,this._localPosition=t._localPosition,this._rotation=t._rotation,this._localRotation=t._localRotation,this._scale=t._scale,this._localScale=t._localScale,this.setDirty(e.positionDirty),this.setDirty(e.rotationDirty),this.setDirty(e.scaleDirty)},n.prototype.toString=function(){return"[Transform: parent: "+this.parent+", position: "+this.position+", rotation: "+this.rotation+",\n                scale: "+this.scale+", localPosition: "+this._localPosition+", localRotation: "+this._localRotation+",\n                localScale: "+this._localScale+"]"},n.prototype.equals=function(t){return t.hashCode==this.hashCode},n}(i);t.Transform=n}(es||(es={})),function(t){var e;!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(e=t.CameraStyle||(t.CameraStyle={}));var i=function(){return function(){this.left=0,this.right=0,this.top=0,this.bottom=0}}();t.CameraInset=i;var n=function(n){function r(r,o){void 0===r&&(r=null),void 0===o&&(o=e.lockOn);var s=n.call(this)||this;return s._inset=new i,s._areMatrixedDirty=!0,s._areBoundsDirty=!0,s._isProjectionMatrixDirty=!0,s.followLerp=.1,s.deadzone=new t.Rectangle,s.focusOffset=t.Vector2.zero,s.mapLockEnabled=!1,s.mapSize=new t.Rectangle,s._desiredPositionDelta=new t.Vector2,s._worldSpaceDeadZone=new t.Rectangle,s._minimumZoom=.3,s._maximumZoom=3,s._bounds=new t.Rectangle,s._transformMatrix=(new t.Matrix2D).identity(),s._inverseTransformMatrix=(new t.Matrix2D).identity(),s._origin=t.Vector2.zero,s._targetEntity=r,s._cameraStyle=o,s.setZoom(0),s}return __extends(r,n),Object.defineProperty(r.prototype,"position",{get:function(){return this.entity.transform.position},set:function(t){this.entity.transform.position=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"rotation",{get:function(){return this.entity.transform.rotation},set:function(t){this.entity.transform.rotation=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?t.MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):t.MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"bounds",{get:function(){if(this._areMatrixedDirty&&this.updateMatrixes(),this._areBoundsDirty){var e=this.screenToWorldPoint(new t.Vector2(this._inset.left,this._inset.top)),i=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,t.Core.graphicsDevice.viewport.height-this._inset.bottom));if(0!=this.entity.transform.rotation){var n=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,this._inset.top)),r=this.screenToWorldPoint(new t.Vector2(this._inset.left,t.Core.graphicsDevice.viewport.height-this._inset.bottom)),o=Math.min(e.x,i.x,n.x,r.x),s=Math.max(e.x,i.x,n.x,r.x),a=Math.min(e.y,i.y,n.y,r.y),h=Math.max(e.y,i.y,n.y,r.y);this._bounds.location=new t.Vector2(o,a),this._bounds.width=s-o,this._bounds.height=h-a}else this._bounds.location=e,this._bounds.width=i.x-e.x,this._bounds.height=i.y-e.y;this._areBoundsDirty=!1}return this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"transformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._transformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"inverseTransformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._inverseTransformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t,this._areMatrixedDirty=!0)},enumerable:!0,configurable:!0}),r.prototype.onSceneSizeChanged=function(e,i){var n=this._origin;this.origin=new t.Vector2(e/2,i/2),this.entity.transform.position=t.Vector2.add(this.entity.transform.position,t.Vector2.subtract(this._origin,n))},r.prototype.setInset=function(t,e,n,r){return this._inset=new i,this._inset.left=t,this._inset.right=e,this._inset.top=n,this._inset.bottom=r,this._areBoundsDirty=!0,this},r.prototype.setPosition=function(t){return this.entity.transform.setPosition(t.x,t.y),this},r.prototype.setRotation=function(t){return this.entity.transform.setRotation(t),this},r.prototype.setZoom=function(e){var i=t.MathHelper.clamp(e,-1,1);return this._zoom=0==i?1:i<0?t.MathHelper.map(i,-1,0,this._minimumZoom,1):t.MathHelper.map(i,0,1,1,this._maximumZoom),this._areMatrixedDirty=!0,this},r.prototype.setMinimumZoom=function(t){if(!(t<=0))return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this;console.error("minimumZoom must be greater than zero")},r.prototype.setMaximumZoom=function(t){if(!(t<=0))return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this;console.error("maximumZoom must be greater than zero")},r.prototype.onEntityTransformChanged=function(t){this._areMatrixedDirty=!0},r.prototype.zoomIn=function(t){this.zoom+=t},r.prototype.zoomOut=function(t){this.zoom-=t},r.prototype.worldToScreenPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._transformMatrix)},r.prototype.screenToWorldPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._inverseTransformMatrix)},r.prototype.mouseToWorldPoint=function(){return this.screenToWorldPoint(t.Input.touchPosition)},r.prototype.onAddedToEntity=function(){this.follow(this._targetEntity,this._cameraStyle)},r.prototype.update=function(){var e=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*t.Core.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*t.Core.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this._targetEntity&&this.updateFollow(),this.position=t.Vector2.lerp(this.position,t.Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.transform.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.transform.roundPosition())},r.prototype.clampToMapSize=function(e){var i=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5)).add(new t.Vector2(this.mapSize.x,this.mapSize.y)),n=new t.Vector2(this.mapSize.width-i.x,this.mapSize.height-i.y);return t.Vector2.clamp(e,i,n)},r.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this._cameraStyle==e.lockOn){var i=this._targetEntity.transform.position.x,n=this._targetEntity.transform.position.y;this._worldSpaceDeadZone.x>i?this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<i&&(this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<n?this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>n&&(this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this._targetEntity.getComponent(t.Collider),!this._targetCollider))return;var r=this._targetEntity.getComponent(t.Collider).bounds;this._worldSpaceDeadZone.containsRect(r)||(this._worldSpaceDeadZone.left>r.left?this._desiredPositionDelta.x=r.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<r.right&&(this._desiredPositionDelta.x=r.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<r.bottom?this._desiredPositionDelta.y=r.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>r.top&&(this._desiredPositionDelta.y=r.top-this._worldSpaceDeadZone.top))}},r.prototype.follow=function(i,n){switch(void 0===n&&(n=e.cameraWindow),this._targetEntity=i,this._cameraStyle=n,this._cameraStyle){case e.cameraWindow:var r=this.bounds.width/6,o=this.bounds.height/3;this.deadzone=new t.Rectangle((this.bounds.width-r)/2,(this.bounds.height-o)/2,r,o);break;case e.lockOn:this.deadzone=new t.Rectangle(this.bounds.width/2,this.bounds.height/2,10,10)}},r.prototype.setCenteredDeadzone=function(e,i){this.deadzone=new t.Rectangle((this.bounds.width-e)/2,(this.bounds.height-i)/2,e,i)},r.prototype.updateMatrixes=function(){var e;this._areMatrixedDirty&&(this._transformMatrix=t.Matrix2D.create().translate(-this.entity.transform.position.x,-this.entity.transform.position.y),1!=this._zoom&&(e=t.Matrix2D.create().scale(this._zoom,this._zoom),this._transformMatrix=this._transformMatrix.multiply(e)),0!=this.entity.transform.rotation&&(e=t.Matrix2D.create().rotate(this.entity.transform.rotation),this._transformMatrix=this._transformMatrix.multiply(e)),e=t.Matrix2D.create().translate(this._origin.x,this._origin.y),this._transformMatrix=this._transformMatrix.multiply(e),this._inverseTransformMatrix=this._transformMatrix.invert(),this._areBoundsDirty=!0,this._areMatrixedDirty=!1)},r}(t.Component);t.Camera=n}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i._shakeDirection=t.Vector2.zero,i._shakeOffset=t.Vector2.zero,i._shakeIntensity=0,i._shakeDegredation=.95,i}return __extends(i,e),i.prototype.shake=function(e,i,n){void 0===e&&(e=15),void 0===i&&(i=.9),void 0===n&&(n=t.Vector2.zero),this.enabled=!0,this._shakeIntensity<e&&(this._shakeDirection=n,this._shakeIntensity=e,(i<0||i>=1)&&(i=.95),this._shakeDegredation=i)},i.prototype.update=function(){Math.abs(this._shakeIntensity)>0&&(this._shakeOffset=this._shakeDirection,0!=this._shakeOffset.x||0!=this._shakeOffset.y?this._shakeOffset.normalize():(this._shakeOffset.x=this._shakeOffset.x+Math.random()-.5,this._shakeOffset.y=this._shakeOffset.y+Math.random()-.5),this._shakeOffset.multiply(new t.Vector2(this._shakeIntensity)),this._shakeIntensity*=-this._shakeDegredation,Math.abs(this._shakeIntensity)<=.01&&(this._shakeIntensity=0,this.enabled=!1)),this.entity.scene.camera.position.add(this._shakeOffset)},i}(t.Component);t.CameraShake=e}(es||(es={})),function(t){var e=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}();t.ComponentPool=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return t.updateOrder-e.updateOrder},t}();t.IUpdatableComparer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Component);t.PooledComponent=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.displayObject=new egret.DisplayObject,i.color=0,i._areBoundsDirty=!0,i._localOffset=t.Vector2.zero,i._renderLayer=0,i._bounds=new t.Rectangle,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.bounds.width},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.bounds.height},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"renderLayer",{get:function(){return this._renderLayer},set:function(t){this.setRenderLayer(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return this._areBoundsDirty&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,t.Vector2.zero,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible!=t&&(this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible())},enumerable:!0,configurable:!0}),i.prototype.onEntityTransformChanged=function(t){this._areBoundsDirty=!0},i.prototype.isVisibleFromCamera=function(t){return!!t&&(this.isVisible=t.bounds.intersects(this.displayObject.getBounds().union(this.bounds)),this.isVisible)},i.prototype.setRenderLayer=function(t){if(t!=this._renderLayer){var e=this._renderLayer;this._renderLayer=t,this.entity&&this.entity.scene&&this.entity.scene.renderableComponents.updateRenderableRenderLayer(this,e,this._renderLayer)}return this},i.prototype.setColor=function(t){return this.color=t,this},i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this._localOffset=t),this},i.prototype.sync=function(e){var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y),this.displayObject.scaleX!=this.entity.scale.x&&(this.displayObject.scaleX=this.entity.scale.x),this.displayObject.scaleY!=this.entity.scale.y&&(this.displayObject.scaleY=this.entity.scale.y),this.displayObject.rotation!=this.entity.rotation&&(this.displayObject.rotation=this.entity.rotation)},i.prototype.toString=function(){return"[RenderableComponent] renderLayer: "+this.renderLayer},i.prototype.onBecameVisible=function(){this.displayObject.visible=this.isVisible},i.prototype.onBecameInvisible=function(){this.displayObject.visible=this.isVisible},i}(t.Component);t.RenderableComponent=e}(es||(es={})),function(t){var e=function(){function e(){this.updateOrder=0,this._enabled=!0}return Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.onRemovedFromScene=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled),this},e.prototype.setUpdateOrder=function(e){return this.updateOrder!=e&&(this.updateOrder=e,t.Core.scene._sceneComponents.sort(this.compareTo)),this},e.prototype.compareTo=function(t){return this.updateOrder-t.updateOrder},e}();t.SceneComponent=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(i){function n(e){void 0===e&&(e=null);var n=i.call(this)||this;return e instanceof t.Sprite?n.setSprite(e):e instanceof egret.Texture&&n.setSprite(new t.Sprite(e)),n}return __extends(n,i),Object.defineProperty(n.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this._sprite.sourceRect.width,this._sprite.sourceRect.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"originNormalized",{get:function(){return new t.Vector2(this._origin.x/this.width*this.entity.transform.scale.x,this._origin.y/this.height*this.entity.transform.scale.y)},set:function(e){this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"origin",{get:function(){return this._origin},set:function(t){this.setOrigin(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),n.prototype.setSprite=function(t){return this._sprite=t,this._sprite&&(this._origin=this._sprite.origin,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y),this.displayObject=new e(t.texture2D),this},n.prototype.setOrigin=function(t){return this._origin!=t&&(this._origin=t,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y,this._areBoundsDirty=!0),this},n.prototype.setOriginNormalized=function(e){return this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y)),this},n.prototype.render=function(e){this.sync(e);var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y)},n}(t.RenderableComponent);t.SpriteRenderer=i}(es||(es={})),function(t){var e=egret.Bitmap,i=egret.RenderTexture,n=function(n){function r(e){var i=n.call(this,e)||this;return i._textureScale=t.Vector2.one,i._inverseTexScale=t.Vector2.one,i._gapX=0,i._gapY=0,i._sourceRect=e.sourceRect,i.displayObject.$fillMode=egret.BitmapFillMode.REPEAT,i}return __extends(r,n),Object.defineProperty(r.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollX",{get:function(){return this._sourceRect.x},set:function(t){this._sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollY",{get:function(){return this._sourceRect.y},set:function(t){this._sourceRect.y=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y),this._sourceRect.width=this._sprite.sourceRect.width*this._inverseTexScale.x,this._sourceRect.height=this._sprite.sourceRect.height*this._inverseTexScale.y},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"width",{get:function(){return this._sourceRect.width},set:function(t){this._areBoundsDirty=!0,this._sourceRect.width=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"height",{get:function(){return this._sourceRect.height},set:function(t){this._areBoundsDirty=!0,this._sourceRect.height=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"gapXY",{get:function(){return new t.Vector2(this._gapX,this._gapY)},set:function(t){this._gapX=t.x,this._gapY=t.y;var n=new i,r=this.sprite.sourceRect;r.x=0,r.y=0,r.width+=this._gapX,r.height+=this._gapY,n.drawToTexture(this.displayObject,r),this.displayObject?this.displayObject.texture=n:this.displayObject=new e(n)},enumerable:!0,configurable:!0}),r.prototype.setGapXY=function(t){return this.gapXY=t,this},r.prototype.render=function(t){n.prototype.render.call(this,t);var e=this.displayObject;e.width=this.width,e.height=this.height,e.scrollRect=this._sourceRect},r}(t.SpriteRenderer);t.TiledSpriteRenderer=n}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.scrollSpeedX=15,i.scroolSpeedY=0,i._scrollX=0,i._scrollY=0,i._scrollWidth=0,i._scrollHeight=0,i._scrollWidth=i.width,i._scrollHeight=i.height,i}return __extends(i,e),Object.defineProperty(i.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollWidth",{get:function(){return this._scrollWidth},set:function(t){this._scrollWidth=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollHeight",{get:function(){return this._scrollHeight},set:function(t){this._scrollHeight=t},enumerable:!0,configurable:!0}),i.prototype.update=function(){this.sprite&&(this._scrollX+=this.scrollSpeedX*t.Time.deltaTime,this._scrollY+=this.scroolSpeedY*t.Time.deltaTime,this._sourceRect.x=this._scrollX,this._sourceRect.y=this._scrollY,this._sourceRect.width=this._scrollWidth+Math.abs(this._scrollX),this._sourceRect.height=this._scrollHeight+Math.abs(this._scrollY))},i}(t.TiledSpriteRenderer);t.ScrollingSpriteRenderer=e}(es||(es={})),function(t){var e=function(){return function(e,i,n){void 0===i&&(i=new t.Rectangle(0,0,e.textureWidth,e.textureHeight)),void 0===n&&(n=i.getHalfSize()),this.uvs=new t.Rectangle,this.texture2D=e,this.sourceRect=i,this.center=new t.Vector2(.5*i.width,.5*i.height),this.origin=n;var r=1/e.textureWidth,o=1/e.textureHeight;this.uvs.x=i.x*r,this.uvs.y=i.y*o,this.uvs.width=i.width*r,this.uvs.height=i.height*o}}();t.Sprite=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.sprites=t,this.frameRate=e}}();t.SpriteAnimation=e}(es||(es={})),function(t){var e,i;!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(e=t.LoopMode||(t.LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(i=t.State||(t.State={}));var n=function(n){function r(t){var e=n.call(this,t)||this;return e.speed=1,e.animationState=i.none,e._elapsedTime=0,e._animations=new Map,e}return __extends(r,n),Object.defineProperty(r.prototype,"isRunning",{get:function(){return this.animationState==i.running},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),r.prototype.update=function(){if(this.animationState==i.running&&this.currentAnimation){var n=this.currentAnimation,r=1/(n.frameRate*this.speed),o=r*n.sprites.length;this._elapsedTime+=t.Time.deltaTime;var s=Math.abs(this._elapsedTime);if(this._loopMode==e.once&&s>o||this._loopMode==e.pingPongOnce&&s>2*o)return this.animationState=i.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=n.sprites[this.currentFrame]);var a=Math.floor(s/r),h=n.sprites.length;if(h>2&&(this._loopMode==e.pingPong||this._loopMode==e.pingPongOnce)){var c=h-1;this.currentFrame=c-Math.abs(c-a%(2*c))}else this.currentFrame=a%h;this.sprite=n.sprites[this.currentFrame]}},r.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},r.prototype.play=function(t,n){void 0===n&&(n=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=i.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=n||e.loop},r.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},r.prototype.pause=function(){this.animationState=i.paused},r.prototype.unPause=function(){this.animationState=i.running},r.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=i.none},r}(t.SpriteRenderer);t.SpriteAnimator=n}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"hasCollision",{get:function(){return this.below||this.right||this.left||this.above},enumerable:!0,configurable:!0}),t.prototype.reset=function(){this.becameGroundedThisFrame=this.isGroundedOnOnewayPlatform=this.right=this.left=this.above=this.below=!1,this.slopAngle=0},t.prototype.toString=function(){return"[CollisionState] r: "+this.right+", l: "+this.left+", a: "+this.above+", b: "+this.below+", angle: "+this.slopAngle+", wasGroundedLastFrame: "+this.wasGroundedLastFrame+", becameGroundedThisFrame: "+this.becameGroundedThisFrame},t}();t.CollisionState=e;var i=function(e){function i(){var t=e.call(this)||this;return t.colliderHorizontalInset=2,t.colliderVerticalInset=6,t}return __extends(i,e),i.prototype.testCollisions=function(e,i,n){this._boxColliderBounds=i,n.wasGroundedLastFrame=n.below,n.reset();var r=e.x;e.y;if(0!=r){var o=r>0?t.Edge.right:t.Edge.left,s=this.collisionRectForSide(o,r);this.testMapCollision(s,o,n,0)?(e.x=0-t.RectangleExt.getSide(i,o),n.left=o==t.Edge.left,n.right=o==t.Edge.right,n._movementRemainderX.reset()):(n.left=!1,n.right=!1)}},i.prototype.testMapCollision=function(e,i,n,r){var o=t.EdgeExt.oppositeEdge(i);t.EdgeExt.isVertical(o)?e.center.x:e.center.y,t.RectangleExt.getSide(e,i),t.EdgeExt.isVertical(o)},i.prototype.collisionRectForSide=function(e,i){var n;return n=t.EdgeExt.isHorizontal(e)?t.RectangleExt.getRectEdgePortion(this._boxColliderBounds,e):t.RectangleExt.getHalfRect(this._boxColliderBounds,e),t.EdgeExt.isVertical(e)?t.RectangleExt.contract(n,this.colliderHorizontalInset,0):t.RectangleExt.contract(n,0,this.colliderVerticalInset),t.RectangleExt.expandSide(n,e,i),n},i}(t.Component);t.TiledMapMover=i}(es||(es={})),function(t){var e=function(e){function i(t,i,n){void 0===i&&(i=null),void 0===n&&(n=!0);var r=e.call(this)||this;return r.physicsLayer=1,r.toContainer=!1,r.tiledMap=t,r._shouldCreateColliders=n,r.displayObject=new egret.DisplayObjectContainer,i&&(r.collisionLayer=t.tileLayers[i]),r}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.tiledMap.width*this.tiledMap.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.tiledMap.height*this.tiledMap.tileHeight},enumerable:!0,configurable:!0}),i.prototype.setLayerToRender=function(t){this.layerIndicesToRender=[],this.layerIndicesToRender[0]=this.getLayerIndex(t)},i.prototype.setLayersToRender=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];this.layerIndicesToRender=[];for(var i=0;i<t.length;i++)this.layerIndicesToRender[i]=this.getLayerIndex(t[i])},i.prototype.getLayerIndex=function(t){var e=this.tiledMap.getLayer(t);for(var i in this.tiledMap.layers)if(this.tiledMap.layers.hasOwnProperty(i)&&this.tiledMap.layers[i]==e)return 0;return-1},i.prototype.getRowAtWorldPosition=function(t){return t-=this.entity.transform.position.y+this._localOffset.y,this.tiledMap.worldToTilePositionY(t)},i.prototype.getColumnAtWorldPosition=function(t){return t-=this.entity.transform.position.x+this._localOffset.x,this.tiledMap.worldToTilePositionX(t)},i.prototype.onEntityTransformChanged=function(t){this._shouldCreateColliders&&t==transform.Component.position&&(this.removeColliders(),this.addColliders())},i.prototype.onAddedToEntity=function(){this.addColliders()},i.prototype.onRemovedFromEntity=function(){this.removeColliders()},i.prototype.update=function(){this.tiledMap.update()},i.prototype.render=function(e){if(this.sync(e),this.layerIndicesToRender)for(var i=0;i<this.tiledMap.layers.length;i++)this.tiledMap.layers[i].visible&&this.layerIndicesToRender.contains(i)&&t.TiledRendering.renderLayerRenderCamera(this.tiledMap.layers[i],this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer,e.bounds);else t.TiledRendering.renderMap(this.tiledMap,this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer);this.toContainer||(this.displayObject.cacheAsBitmap=!0,this.toContainer=!0)},i.prototype.addColliders=function(){if(this.collisionLayer&&this._shouldCreateColliders){var e=this.collisionLayer.getCollisionRectangles();this._colliders=[];for(var i=0;i<e.length;i++){var n=(new t.BoxCollider).createBoxRect(e[i].x+this._localOffset.x,e[i].y+this._localOffset.y,e[i].width,e[i].height);n.physicsLayer=this.physicsLayer,n.entity=this.entity,this._colliders[i]=n,t.Physics.addCollider(n)}}},i.prototype.removeColliders=function(){if(null!=this._colliders){for(var e=0,i=this._colliders;e<i.length;e++){var n=i[e];t.Physics.removeCollider(n)}this._colliders=null}},i}(t.RenderableComponent);t.TiledMapRenderer=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._triggerHelper=new t.ColliderTriggerHelper(this.entity)},i.prototype.calculateMovement=function(e,i){if(!this.entity.getComponent(t.Collider)||!this._triggerHelper)return!1;for(var n=this.entity.getComponents(t.Collider),r=0;r<n.length;r++){var o=n[r];if(!o.isTrigger){var s=o.bounds;s.x+=e.x,s.y+=e.y;for(var a=t.Physics.boxcastBroadphaseExcludingSelf(o,s,o.collidesWithLayers),h=0;h<a.length;h++){var c=a[h];if(!c.isTrigger){var u=new t.CollisionResult;o.collidesWith(c,e,u)&&(e=e.subtract(u.minimumTranslationVector),null!=u.collider&&(i=u))}}}}return t.ListPool.free(n),null!=i.collider},i.prototype.applyMovement=function(e){this.entity.position=t.Vector2.add(this.entity.position,e),this._triggerHelper&&this._triggerHelper.update()},i.prototype.move=function(t,e){return this.calculateMovement(t,e),this.applyMovement(t),null!=e.collider},i}(t.Component);t.Mover=e}(es||(es={})),function(t){var e=function(e){function i(){var t=null!==e&&e.apply(this,arguments)||this;return t._tempTriggerList=[],t}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(t.Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},i.prototype.move=function(e){if(!this._collider)return!1;var i=!1;this.entity.position=t.Vector2.add(this.entity.position,e);for(var n=t.Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),r=0;r<n.length;r++){var o=n[r];this._collider.overlaps(o)&&o.enabled&&(i=!0,this.notifyTriggerListeners(this._collider,o))}return i},i.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(e,t);this._tempTriggerList.length=0},i}(t.Component);t.ProjectileMover=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.physicsLayer=1,i.collidesWithLayers=t.Physics.allLayers,i.shouldColliderScaleAndRotateWithTransform=!0,i.registeredPhysicsBounds=new t.Rectangle,i._isPositionDirty=!0,i._isRotationDirty=!0,i._localOffset=t.Vector2.zero,i}return __extends(i,e),Object.defineProperty(i.prototype,"absolutePosition",{get:function(){return t.Vector2.add(this.entity.transform.position,this._localOffset)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"rotation",{get:function(){return this.shouldColliderScaleAndRotateWithTransform&&this.entity?this.entity.transform.rotation:0},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return(this._isPositionDirty||this._isRotationDirty)&&(this.shape.recalculateBounds(this),this._isPositionDirty=this._isRotationDirty=!1),this.shape.bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this.unregisterColliderWithPhysicsSystem(),this._localOffset=t,this._localOffsetLength=this._localOffset.length(),this._isPositionDirty=!0,this.registerColliderWithPhysicsSystem()),this},i.prototype.setShouldColliderScaleAndRotateWithTransform=function(t){return this.shouldColliderScaleAndRotateWithTransform=t,this._isPositionDirty=this._isRotationDirty=!0,this},i.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){if(!(this instanceof t.BoxCollider||this instanceof t.CircleCollider))return void console.error("Only box and circle colliders can be created automatically");var e=this.entity.getComponent(t.RenderableComponent);if(e){var i=e.bounds,n=i.width/this.entity.scale.x,r=i.height/this.entity.scale.y;this instanceof t.CircleCollider?this.radius=.5*Math.max(n,r):(this.width=n,this.height=r),this.localOffset=t.Vector2.subtract(i.center,this.entity.transform.position)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},i.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1},i.prototype.onEntityTransformChanged=function(e){switch(e){case transform.Component.position:case transform.Component.scale:this._isPositionDirty=!0;break;case transform.Component.rotation:this._isRotationDirty=!0}this._isColliderRegistered&&t.Physics.updateCollider(this)},i.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem(),this._isPositionDirty=this._isRotationDirty=!0},i.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},i.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(t.Physics.addCollider(this),this._isColliderRegistered=!0)},i.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&t.Physics.removeCollider(this),this._isColliderRegistered=!1},i.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},i.prototype.collidesWith=function(t,e,i){var n=this.entity.position;this.entity.position=this.entity.position.add(e);var r=this.shape.collidesWithShape(t.shape,i);return r&&(i.collider=t),this.entity.position=n,r},i.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,this.shape&&(t.shape=this.shape.clone()),t},i}(t.Component);t.Collider=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.shape=new t.Box(1,1),i._colliderRequiresAutoSizing=!0,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),i.prototype.createBoxRect=function(e,i,n,r){return this._localOffset=new t.Vector2(e+n/2,i+n/2),this.shape=new t.Box(n,r),this._colliderRequiresAutoSizing=!1,this},i.prototype.setSize=function(e,i){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e==n.width&&i==n.height||(n.updateBox(e,i),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setWidth=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.width&&(i.updateBox(e,i.height),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setHeight=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;e!=i.height&&(i.updateBox(i.width,e),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this))},i.prototype.toString=function(){return"[BoxCollider: bounds: "+this.bounds+"]"},i}(t.Collider);t.BoxCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;return i&&(n._colliderRequiresAutoSizing=!0),n.shape=new t.Circle(i||1),n}return __extends(i,e),Object.defineProperty(i.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),i.prototype.setRadius=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.radius&&(i.radius=e,i._originalRadius=e,this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.toString=function(){return"[CircleCollider: bounds: "+this.bounds+", radius: "+this.shape.radius+"]"},i}(t.Collider);t.CircleCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;i[0]==i[i.length-1]&&i.splice(i.length-1,1);var r=t.Polygon.findPolygonCenter(i);return n.setLocalOffset(r),t.Polygon.recenterPolygonVerts(i),n.shape=new t.Polygon(i),n}return __extends(i,e),i}(t.Collider);t.PolygonCollider=e}(es||(es={})),function(t){var e=function(){function e(e){this._entities=[],this._matcher=e||t.Matcher.empty()}return Object.defineProperty(e.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onChanged=function(t){var e=this._entities.contains(t),i=this._matcher.IsIntersted(t);i&&!e?this.add(t):!i&&e&&this.remove(t)},e.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},e.prototype.onAdded=function(t){},e.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},e.prototype.onRemoved=function(t){},e.prototype.update=function(){this.begin(),this.process(this._entities)},e.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},e.prototype.begin=function(){},e.prototype.process=function(t){},e.prototype.lateProcess=function(t){},e.prototype.end=function(){},e}();t.EntitySystem=e}(es||(es={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(t.EntitySystem);t.EntityProcessingSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(t.EntitySystem);t.PassiveSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(t.EntitySystem);t.ProcessingSystem=e}(es||(es={})),function(t){var e=function(){function t(e){void 0===e&&(e=64);var i=e>>6;0!=(e&t.LONG_MASK)&&i++,this._bits=new Array(i)}return t.prototype.and=function(t){for(var e,i=Math.min(this._bits.length,t._bits.length),n=0;n<i;++n)this._bits[n]&=t._bits[n];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var i=this._bits[e];if(0!=i)if(-1!=i){var n=((i=((i=(i>>1&0x5555555555555400)+(0x5555555555555400&i))>>2&0x3333333333333400)+(0x3333333333333400&i))>>32)+i;t+=((n=((n=(n>>4&252645135)+(252645135&n))>>8&16711935)+(16711935&n))>>16&65535)+(65535&n)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var i=0;i<this._bits.length;i++)this._bits[i]=0},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,i=1<<t;e<this._bits.length;){var n=this._bits[e];do{if(0!=(n&i))return t;i<<=1,t++}while(0!=i);i=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var i=t>>6;this.ensure(i),this._bits[i]|=1<<t}else this.clear(t)},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.LONG_MASK=63,t}();t.BitSet=e}(es||(es={})),function(t){var e=function(){function e(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isComponentListUnsorted=!0},e.prototype.add=function(t){this._componentsToAdd.push(t)},e.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},e.prototype.deregisterAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.removeChild(i.displayObject),this._entity.scene.renderableComponents.remove(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},e.prototype.registerAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.addChild(i.displayObject),this._entity.scene.renderableComponents.add(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},e.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var i=0;i<this._componentsToRemove.length;i++)this.handleRemove(this._componentsToRemove[i]),this._components.remove(this._componentsToRemove[i]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){i=0;for(var n=this._componentsToAdd.length;i<n;i++){(r=this._componentsToAdd[i])instanceof t.RenderableComponent&&(this._entity.scene.addChild(r.displayObject),this._entity.scene.renderableComponents.add(r)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(r)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(r),this._tempBufferList.push(r)}this._componentsToAdd.length=0,this._isComponentListUnsorted=!0;for(i=0;i<this._tempBufferList.length;i++){var r;(r=this._tempBufferList[i]).onAddedToEntity(),r.enabled&&r.onEnabled()}this._tempBufferList.length=0}this._isComponentListUnsorted&&(this._components.sort(e.compareUpdatableOrder.compare),this._isComponentListUnsorted=!1)},e.prototype.handleRemove=function(e){e instanceof t.RenderableComponent&&(this._entity.scene.removeChild(e.displayObject),this._entity.scene.renderableComponents.remove(e)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),e.onRemovedFromEntity(),e.entity=null},e.prototype.getComponent=function(t,e){for(var i=0;i<this._components.length;i++){if((n=this._components[i])instanceof t)return n}if(!e)for(i=0;i<this._componentsToAdd.length;i++){var n;if((n=this._componentsToAdd[i])instanceof t)return n}return null},e.prototype.getComponents=function(t,e){e||(e=[]);for(var i=0;i<this._components.length;i++){var n=this._components[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}for(i=0;i<this._componentsToAdd.length;i++){n=this._componentsToAdd[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}return e},e.prototype.update=function(){this.updateLists();for(var e=0;e<this._components.length;e++){var i=this._components[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},e.prototype.onEntityEnabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onEnabled()},e.prototype.onEntityDisabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onDisabled()},e.prototype.debugRender=function(){for(var t=0;t<this._components.length;t++)this._components[t].enabled&&this._components[t].debugRender()},e.compareUpdatableOrder=new t.IUpdatableComparer,e}();t.ComponentList=e}(es||(es={})),function(t){var e=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}();t.ComponentTypeManager=e}(es||(es={})),function(t){var e=function(){function e(t){this._entities=[],this._entitiesToAdded=[],this._entitiesToRemove=[],this._entityDict=new Map,this._unsortedTags=[],this._tempEntityList=[],this.scene=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isEntityListUnsorted=!0},e.prototype.markTagUnsorted=function(t){this._unsortedTags.push(t)},e.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},e.prototype.remove=function(t){this._entitiesToRemove.contains(t)?this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t):console.warn("You are trying to remove an entity ("+t.name+") that you already removed")},e.prototype.removeAllEntities=function(){this._unsortedTags.length=0,this._entitiesToAdded.length=0,this._isEntityListUnsorted=!1,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestroyed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},e.prototype.contains=function(t){return this._entities.contains(t)||this._entitiesToAdded.contains(t)},e.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},e.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},e.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},e.prototype.update=function(){for(var e=0;e<this._entities.length;e++){var i=this._entities[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t.removeFromTagList(e),t._entities.remove(e),e.onRemovedFromScene(),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.addToTagList(e),t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0,this._isEntityListUnsorted=!0}this._isEntityListUnsorted&&(this._entities.sort(),this._isEntityListUnsorted=!1),this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},e.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},e.prototype.entitiesWithTag=function(e){for(var i=this.getTagList(e),n=t.ListPool.obtain(),r=0;r<i.length;r++)n.push(i[r]);return n},e.prototype.entitiesOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n]instanceof e&&i.push(this._entities[n]);return this._entitiesToAdded.forEach(function(t){t instanceof e&&i.push(t)}),i},e.prototype.findComponentOfType=function(t){for(var e=0;e<this._entities.length;e++){if(this._entities[e].enabled)if(i=this._entities[e].getComponent(t))return i}for(e=0;e<this._entitiesToAdded.length;e++){var i,n=this._entitiesToAdded[e];if(n.enabled)if(i=n.getComponent(t))return i}return null},e.prototype.findComponentsOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n].enabled&&this._entities[n].getComponents(e,i);for(n=0;n<this._entitiesToAdded.length;n++){var r=this._entitiesToAdded[n];r.enabled&&r.getComponents(e,i)}return i},e}();t.EntityList=e}(es||(es={})),function(t){var e=function(){function e(){this._processors=[]}return e.prototype.add=function(t){this._processors.push(t)},e.prototype.remove=function(t){this._processors.remove(t)},e.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},e.prototype.begin=function(){},e.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},e.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},e.prototype.end=function(){},e.prototype.getProcessor=function(){for(var e=0;e<this._processors.length;e++){var i=this._processors[e];if(i instanceof t.EntitySystem)return i}return null},e.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},e.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},e}();t.EntityProcessorList=e}(es||(es={})),function(t){var e=function(){function e(){this.allSet=new t.BitSet,this.exclusionSet=new t.BitSet,this.oneSet=new t.BitSet}return e.empty=function(){return new e},e.prototype.getAllSet=function(){return this.allSet},e.prototype.getExclusionSet=function(){return this.exclusionSet},e.prototype.getOneSet=function(){return this.oneSet},e.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},e.prototype.all=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.allSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.exclude=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.exclusionSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.one=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.oneSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e}();t.Matcher=e}(es||(es={}));var ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var i in t)"object"==typeof t[i]?(e[i]=t[i]instanceof Array?[]:{},this.clone(t[i],e[i])):e[i]=t[i];return e},t.elements=function(t){var e=[];for(var i in t)if(Array.isArray(t[i]))for(var n=0,r=t[i];n<r.length;n++){var o=r[n];e.push(o)}else e.push(t[i]);return e},t}();!function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return e.renderLayer-t.renderLayer},t}();t.RenderableComparer=e}(es||(es={})),function(t){var e=function(){function e(){this._components=[],this._componentsByRenderLayer=new Map,this._unsortedRenderLayers=[],this._componentsNeedSort=!0}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.add=function(t){this._components.push(t),this.addToRenderLayerList(t,t.renderLayer)},e.prototype.remove=function(t){this._components.remove(t),this._componentsByRenderLayer.get(t.renderLayer).remove(t)},e.prototype.updateRenderableRenderLayer=function(t,e,i){this._componentsByRenderLayer.has(e)&&this._componentsByRenderLayer.get(e).contains(t)&&(this._componentsByRenderLayer.get(e).remove(t),this.addToRenderLayerList(t,i))},e.prototype.setRenderLayerNeedsComponentSort=function(t){this._unsortedRenderLayers.contains(t)||this._unsortedRenderLayers.push(t),this._componentsNeedSort=!0},e.prototype.setNeedsComponentSort=function(){this._componentsNeedSort=!0},e.prototype.addToRenderLayerList=function(t,e){var i=this.componentsWithRenderLayer(e);i.contains(t)?console.warn("组件呈现层列表已经包含此组件"):(i.push(t),this._unsortedRenderLayers.contains(e)||this._unsortedRenderLayers.push(e),this._componentsNeedSort=!0)},e.prototype.componentsWithRenderLayer=function(t){return this._componentsByRenderLayer.get(t)||this._componentsByRenderLayer.set(t,[]),this._componentsByRenderLayer.get(t)},e.prototype.updateList=function(){if(this._componentsNeedSort&&(this._components.sort(e.compareUpdatableOrder.compare),this._componentsNeedSort=!1,this.updateEgretList()),this._unsortedRenderLayers.length>0){for(var t=0,i=this._unsortedRenderLayers.length;t<i;t++){var n=this._componentsByRenderLayer.get(this._unsortedRenderLayers[t]);n&&n.sort(e.compareUpdatableOrder.compare)}this._unsortedRenderLayers.length=0,this.updateEgretList()}},e.prototype.updateEgretList=function(){var e=t.Core._instance._scene;if(e)for(var i=function(t){var i=n._components[t],r=e.$children.find(function(t){return t.hashCode==i.displayObject.hashCode}),o=e.getChildIndex(r);o!=t&&e.swapChildrenAt(o,t)},n=this,r=0;r<this._components.length;r++)i(r)},e.compareUpdatableOrder=new t.RenderableComparer,e}();t.RenderableComponentList=e}(es||(es={}));var StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,i,n){void 0===n&&(n=!1);for(var r=t.length,o="",s=!1,a=1==n?e.toLowerCase():e,h=0;h<r;h++)s=!1,t.charAt(h)==a.charAt(0)&&t.substr(h,a.length)==a&&(s=!0),s?(o+=i,h=h+a.length-1):o+=t.charAt(h);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var i=this.specialSigns.length,n=0;n<i;n+=2){var r=void 0,o=void 0;if(r=this.specialSigns[n],o=this.specialSigns[n+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var i=t.length;if(i>=e)return t;var n=!1;"-"==t.substr(0,1)&&(n=!0,t=t.substr(1));for(var r=e-i,o=0;o<r;o++)t="0"+t;return n&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,i,n){void 0===n&&(n=!0),e=Math.floor(e),i=Math.floor(i);var r=t.length;e>r&&(e=r);var o,s=e,a=e+i;return n?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-i)+i,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var i=0,n=e.length;i<n;i++)null!=e[i]&&""!=e[i]||(e[i]="无"),t=t.replace("{"+i+"}",e[i]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}();!function(t){var e=function(){function e(){}return e.convertImageToCanvas=function(e,i){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var n=e.$getTextureWidth(),r=e.$getTextureHeight();i||((i=egret.$TempRectangle).x=0,i.y=0,i.width=n,i.height=r),i.x=Math.min(i.x,n-1),i.y=Math.min(i.y,r-1),i.width=Math.min(i.width,n-i.x),i.height=Math.min(i.height,r-i.y);var o=Math.floor(i.width),s=Math.floor(i.height),a=this.sharedCanvas;if(a.style.width=o+"px",a.style.height=s+"px",this.sharedCanvas.width=o,this.sharedCanvas.height=s,"webgl"==egret.Capabilities.renderMode){var h=void 0;e.$renderBuffer?h=e:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(h=new egret.RenderTexture).drawToTexture(new egret.Bitmap(e)));for(var c=h.$renderBuffer.getPixels(i.x,i.y,o,s),u=0,l=0,p=0;p<c.length;p+=4)this.sharedContext.fillStyle="rgba("+c[p]+","+c[p+1]+","+c[p+2]+","+c[p+3]/255+")",this.sharedContext.fillRect(u,l,1,1),++u==o&&(u=0,l++);return e.$renderBuffer||h.dispose(),a}var d=e,f=Math.round(d.$offsetX),g=Math.round(d.$offsetY),m=d.$bitmapWidth,y=d.$bitmapHeight,_=t.Core._instance.stage.textureScaleFactor;return this.sharedContext.drawImage(d.$bitmapData.source,d.$bitmapX+i.x/_,d.$bitmapY+i.y/_,m*i.width/n,y*i.height/r,f,g,i.width,i.height),a},e.toDataURL=function(t,e,i,n){try{return this.convertImageToCanvas(e,i).toDataURL(t,n)}catch(t){egret.$error(1033)}return null},e.eliFoTevas=function(t,e,i,n,r){var o=this.convertImageToCanvas(e,n).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+i,success:function(t){}}),o},e.getPixel32=function(t,e,i){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,i)},e.getPixels=function(t,e,i,n,r){if(void 0===n&&(n=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,i,n,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,i,n,r).data}catch(t){egret.$error(1039)}},e}();t.TextureUtils=e}(es||(es={})),function(t){var e=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}();t.Time=e}(es||(es={}));var TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),i=t.getMonth()+1;return parseInt(e+(i<10?"0":"")+i)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,i=e<10?"0":"",n=t.getDate(),r=n<10?"0":"";return parseInt(t.getFullYear()+i+e+r+n)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var i=new Date;i.setTime(t.getTime()),i.setDate(1),i.setMonth(0);var n=i.getFullYear(),r=i.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,i.setDate(i.getDate()-(r-1))):i.setDate(i.getDate()+7-r+1);var s=this.diffDay(t,i,!1);if(s<0)return i.setDate(1),i.setMonth(0),i.setDate(i.getDate()-1),this.weekId(i,!1);var a=s/7,h=Math.floor(a)+1;if(53==h){i.setTime(t.getTime()),i.setDate(i.getDate()-1);var c=i.getDay();if(0==c&&(c=7),e&&(!o||c<4))return i.setFullYear(i.getFullYear()+1),i.setDate(1),i.setMonth(0),this.weekId(i,!1)}return parseInt(n+"00"+(h>9?"":"0")+h)},t.diffDay=function(t,e,i){void 0===i&&(i=!1);var n=(t.getTime()-e.getTime())/864e5;return i?Math.ceil(n):Math.floor(n)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();return e+"-"+i+"-"+(n=n<10?"0"+n:n)},t.formatDateTime=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();n=n<10?"0"+n:n;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+i+"-"+n+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,i){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===i&&(i=!0);var n=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=n.toString(),a=r.toString(),h=o.toString();return n<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(h="0"+h),i?s+e+a+e+h:a+e+h},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var i=t.split(e),n=0,r=i.length,o=0;o<r;o++){n+=i[o]*Math.pow(60,r-1-o)}return(n*=1e3).toString()},t}();!function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){if(e.runtimeType==egret.RuntimeType.WXGAME){this.isMobile=!0;var i=wx.getSystemInfoSync(),n=i.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var r=i.language;r=r.indexOf("zh")>-1?"zh-CN":"en-US",this.language=r}},e}(egret.Capabilities);t.GraphicsCapabilities=e}(es||(es={})),function(t){var e=function(){function e(){this.setup(),this.graphicsCapabilities=new t.GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}return Object.defineProperty(e.prototype,"viewport",{get:function(){return this._viewport},enumerable:!0,configurable:!0}),e.prototype.setup=function(){this._viewport=new t.Viewport(0,0,t.Core._instance.stage.stageWidth,t.Core._instance.stage.stageHeight)},e}();t.GraphicsDevice=e}(es||(es={})),function(t){var e=function(){function e(t,e,i,n){this._x=t,this._y=e,this._width=i,this._height=n,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(e.prototype,"width",{get:function(){return this._width},set:function(t){this._width=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"height",{get:function(){return this._height},set:function(t){this._height=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new t.Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),e}();t.Viewport=e}(es||(es={})),function(t){var e=function(e){function i(){return e.call(this,t.PostProcessor.default_vert,i.blur_frag,{screenWidth:t.Core.graphicsDevice.viewport.width,screenHeight:t.Core.graphicsDevice.viewport.height})||this}return __extends(i,e),i.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",i}(egret.CustomFilter);t.GaussianBlurEffect=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter);t.PolygonLightEffect=e}(es||(es={})),function(t){var e=function(){function e(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return e.prototype.onAddedToScene=function(e){this.scene=e,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.shape.graphics.endFill(),e.addChild(this.shape)},e.prototype.process=function(){this.drawFullscreenQuad()},e.prototype.onSceneBackBufferSizeChanged=function(t,e){},e.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},e.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},e.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",e}();t.PostProcessor=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToScene=function(i){e.prototype.onAddedToScene.call(this,i),this.effect=new t.GaussianBlurEffect},i}(t.PostProcessor);t.GaussianBlurPostProcessor=e}(es||(es={})),function(t){var e=function(){function t(t,e){void 0===e&&(e=null),this.renderOrder=0,this.shouldDebugRender=!0,this.camera=e,this.renderOrder=t}return Object.defineProperty(t.prototype,"wantsToRenderToSceneRenderTarget",{get:function(){return!!this.renderTexture},enumerable:!0,configurable:!0}),t.prototype.onAddedToScene=function(t){},t.prototype.unload=function(){},t.prototype.onSceneBackBufferSizeChanged=function(t,e){},t.prototype.compareTo=function(t){return this.renderOrder-t.renderOrder},t.prototype.beginRender=function(t){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t.prototype.debugRender=function(t,e){for(var i=0;i<t.entities.count;i++){var n=t.entities.buffer[i];n.enabled&&n.debugRender()}},t}();t.Renderer=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,0,null)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var i=0;i<t.renderableComponents.count;i++){var n=t.renderableComponents.buffer[i];n.enabled&&n.isVisibleFromCamera(e)&&this.renderAfterStateCheck(n,e)}},e}(t.Renderer);t.DefaultRenderer=e}(es||(es={})),function(t){var e=function(e){function i(t){for(var i=[],n=1;n<arguments.length;n++)i[n-1]=arguments[n];var r=e.call(this,t,null)||this;return r.excludedRenderLayers=i,r}return __extends(i,e),i.prototype.render=function(e){var i=this.camera?this.camera:e.camera;this.beginRender(i);for(var n=0;n<e.renderableComponents.count;n++){var r=e.renderableComponents.buffer[n];!this.excludedRenderLayers.contains(r.renderLayer)&&r.enabled&&r.isVisibleFromCamera(i)&&this.renderAfterStateCheck(r,i)}this.shouldDebugRender&&t.Core.debugRenderEndabled&&this.debugRender(e,i)},i.prototype.debugRender=function(t,i){for(var n=0;n<t.renderableComponents.count;n++){var r=t.renderableComponents.buffer[n];!this.excludedRenderLayers.contains(r.renderLayer)&&r.enabled&&r.isVisibleFromCamera(i)&&r.debugRender()}e.prototype.debugRender.call(this,t,i)},i}(t.Renderer);t.RenderLayerExcludeRenderer=e}(es||(es={})),function(t){var e=function(e){function i(t){for(var i=[],n=1;n<arguments.length;n++)i[n-1]=arguments[n];var r=e.call(this,t,null)||this;return i.sort(),i.reverse(),r.renderLayers=i,r}return __extends(i,e),i.prototype.render=function(e){this.beginRender(this.camera);for(var i=0;i<this.renderLayers.length;i++)for(var n=e.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]),r=0;r<n.length;r++){var o=n[r];o.enabled&&o.isVisibleFromCamera(this.camera)&&this.renderAfterStateCheck(o,this.camera)}this.shouldDebugRender&&t.Core.debugRenderEndabled&&this.debugRender(e,this.camera)},i.prototype.debugRender=function(t,e){for(var i=0;i<this.renderLayers.length;i++)for(var n=t.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]),r=0;r<n.length;r++){var o=n[r];o.enabled&&o.debugRender()}},i.prototype.onSceneBackBufferSizeChanged=function(i,n){e.prototype.onSceneBackBufferSizeChanged.call(this,i,n),this.camera||(this.camera=t.Core.scene.createEntity("screenspace camera").addComponent(new t.Camera))},i}(t.Renderer);t.ScreenSpaceRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e,i,n){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=n,r.color=i,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e}(t.RenderableComponent);t.PolyLight=e}(es||(es={})),function(t){var e=function(){function e(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(e.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),e.prototype.preRender=function(){},e.prototype.render=function(){},e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},e.prototype.tickEffectProgressProperty=function(t,e,i,n){return void 0===n&&(n=!1),new Promise(function(r){var o=n?1:0,s=n?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,i).call(function(){r()})})},e.prototype.transitionComplete=function(){t.Core._instance._sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},e.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),e=t.Core,[4,this.sceneLoadAction()];case 1:return e.scene=i.sent(),this.isNewSceneLoaded=!0,[2]}})})},e}();t.SceneTransition=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.fadeToColor=0,i.fadeOutDuration=.4,i.fadeEaseType=egret.Ease.quadInOut,i.delayBeforeFadeInDuration=.1,i._alpha=0,i._mask=new egret.Shape,i}return __extends(i,e),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var e=this;return __generator(this,function(i){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill(),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(e,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(e).to({_alpha:0},1e3*e.fadeOutDuration,e.fadeEaseType).call(function(){e.transitionComplete()})}),[2]})})},i.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill()},i}(t.SceneTransition);t.FadeTransition=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this,i)||this;n.duration=1,n.easeType=egret.Ease.quadOut;return n._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),n._mask=new egret.Shape,n._mask.graphics.beginFill(16777215,1),n._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),n._mask.graphics.endFill(),n._mask.filters=[n._windEffect],n}return __extends(i,e),Object.defineProperty(i.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return t.sent(),this.transitionComplete(),[2]}})})},i}(t.SceneTransition);t.WindTransition=e}(es||(es={})),function(t){var e=function(){function e(){}return e.getPoint=function(e,i,n,r){var o=1-(r=t.MathHelper.clamp01(r));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(o*o),e),t.Vector2.multiply(new t.Vector2(2*o*r),i)),t.Vector2.multiply(new t.Vector2(r*r),n))},e.getFirstDerivative=function(e,i,n,r){return t.Vector2.add(t.Vector2.multiply(new t.Vector2(2*(1-r)),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(2*r),t.Vector2.subtract(n,i)))},e.getFirstDerivativeThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(3*s*s),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(6*s*o),t.Vector2.subtract(n,i))),t.Vector2.multiply(new t.Vector2(3*o*o),t.Vector2.subtract(r,n)))},e.getPointThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(s*s*s),e),t.Vector2.multiply(new t.Vector2(3*s*s*o),i)),t.Vector2.multiply(new t.Vector2(3*s*o*o),n)),t.Vector2.multiply(new t.Vector2(o*o*o),r))},e.getOptimizedDrawingPoints=function(e,i,n,r,o){void 0===o&&(o=1);var s=t.ListPool.obtain();return s.push(e),this.recursiveGetOptimizedDrawingPoints(e,i,n,r,s,o),s.push(r),s},e.recursiveGetOptimizedDrawingPoints=function(e,i,n,r,o,s){var a=t.Vector2.divide(t.Vector2.add(e,i),new t.Vector2(2)),h=t.Vector2.divide(t.Vector2.add(i,n),new t.Vector2(2)),c=t.Vector2.divide(t.Vector2.add(n,r),new t.Vector2(2)),u=t.Vector2.divide(t.Vector2.add(a,h),new t.Vector2(2)),l=t.Vector2.divide(t.Vector2.add(h,c),new t.Vector2(2)),p=t.Vector2.divide(t.Vector2.add(u,l),new t.Vector2(2)),d=t.Vector2.subtract(r,e),f=Math.abs((i.x,r.x*d.y-(i.y-r.y)*d.x)),g=Math.abs((n.x-r.x)*d.y-(n.y-r.y)*d.x);(f+g)*(f+g)<s*(d.x*d.x+d.y*d.y)?o.push(p):(this.recursiveGetOptimizedDrawingPoints(e,a,u,p,o,s),this.recursiveGetOptimizedDrawingPoints(p,l,c,r,o,s))},e}();t.Bezier=e}(es||(es={})),function(t){var e=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}();t.Flags=e}(es||(es={})),function(t){var e=function(){function e(){}return e.toDegrees=function(t){return 57.29577951308232*t},e.toRadians=function(t){return.017453292519943295*t},e.map=function(t,e,i,n,r){return n+(t-e)*(r-n)/(i-e)},e.lerp=function(t,e,i){return t+(e-t)*i},e.clamp=function(t,e,i){return t<e?e:t>i?i:t},e.pointOnCirlce=function(i,n,r){var o=e.toRadians(r);return new t.Vector2(Math.cos(o)*o+i.x,Math.sin(o)*o+i.y)},e.isEven=function(t){return t%2==0},e.clamp01=function(t){return t<0?0:t>1?1:t},e.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},e.incrementWithWrap=function(t,e){return++t==e?0:t},e.Epsilon=1e-5,e.Rad2Deg=57.29578,e.Deg2Rad=.0174532924,e.PiOver2=Math.PI/2,e}();t.MathHelper=e}(es||(es={})),function(t){t.matrixPool=[];var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"m11",{get:function(){return this.a},set:function(t){this.a=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m12",{get:function(){return this.b},set:function(t){this.b=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m21",{get:function(){return this.c},set:function(t){this.c=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m22",{get:function(){return this.d},set:function(t){this.d=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m31",{get:function(){return this.tx},set:function(t){this.tx=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m32",{get:function(){return this.ty},set:function(t){this.ty=t},enumerable:!0,configurable:!0}),i.create=function(){var e=t.matrixPool.pop();return e||(e=new i),e},i.prototype.identity=function(){return this.a=this.d=1,this.b=this.c=this.tx=this.ty=0,this},i.prototype.translate=function(t,e){return this.tx+=t,this.ty+=e,this},i.prototype.scale=function(t,e){return 1!==t&&(this.a*=t,this.c*=t,this.tx*=t),1!==e&&(this.b*=e,this.d*=e,this.ty*=e),this},i.prototype.rotate=function(t){if(0!==(t=+t)){t/=DEG_TO_RAD;var e=Math.cos(t),i=Math.sin(t),n=this.a,r=this.b,o=this.c,s=this.d,a=this.tx,h=this.ty;this.a=n*e-r*i,this.b=n*i+r*e,this.c=o*e-s*i,this.d=o*i+s*e,this.tx=a*e-h*i,this.ty=a*i+h*e}return this},i.prototype.invert=function(){return this.$invertInto(this),this},i.prototype.add=function(t){return this.m11+=t.m11,this.m12+=t.m12,this.m21+=t.m21,this.m22+=t.m22,this.m31+=t.m31,this.m32+=t.m32,this},i.prototype.substract=function(t){return this.m11-=t.m11,this.m12-=t.m12,this.m21-=t.m21,this.m22-=t.m22,this.m31-=t.m31,this.m32-=t.m32,this},i.prototype.divide=function(t){return this.m11/=t.m11,this.m12/=t.m12,this.m21/=t.m21,this.m22/=t.m22,this.m31/=t.m31,this.m32/=t.m32,this},i.prototype.multiply=function(t){var e=this.m11*t.m11+this.m12*t.m21,i=this.m11*t.m12+this.m12*t.m22,n=this.m21*t.m11+this.m22*t.m21,r=this.m21*t.m12+this.m22*t.m22,o=this.m31*t.m11+this.m32*t.m21+t.m31,s=this.m31*t.m12+this.m32*t.m22+t.m32;return this.m11=e,this.m12=i,this.m21=n,this.m22=r,this.m31=o,this.m32=s,this},i.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},i.prototype.release=function(e){e&&t.matrixPool.push(e)},i}(egret.Matrix);t.Matrix2D=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"max",{get:function(){return new t.Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"center",{get:function(){return new t.Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"location",{get:function(){return new t.Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{get:function(){return new t.Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),i.fromMinMax=function(t,e,n,r){return new i(t,e,n-t,r-e)},i.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,i=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>n&&(n=s.x),s.y<i&&(i=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,i,n,r)},i.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},i.prototype.rayIntersects=function(t){var e=0,i=Number.MAX_VALUE;if(Math.abs(t.direction.x)<1e-6){if(t.start.x<this.x||t.start.x>this.x+this.width)return e}else{var n=1/t.direction.x,r=(this.x-t.start.x)*n,o=(this.x+this.width-t.start.x)*n;if(r>o){var s=r;r=o,o=s}if((e=Math.max(r,e))>(i=Math.min(o,i)))return e}if(Math.abs(t.direction.y)<1e-6){if(t.start.y<this.y||t.start.y>this.y+this.height)return e}else{var a=1/t.direction.y,h=(this.y-t.start.y)*a,c=(this.y+this.height-t.start.y)*a;if(h>c){var u=h;h=c,c=u}if((e=Math.max(h,e))>(i=Math.max(c,i)))return e}return e},i.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},i.prototype.contains=function(t,e){return this.x<=t&&t<this.x+this.width&&this.y<=e&&e<this.y+this.height},i.prototype.getHalfSize=function(){return new t.Vector2(.5*this.width,.5*this.height)},i.prototype.getClosestPointOnRectangleBorderToPoint=function(e,i){i=t.Vector2.zero;var n=new t.Vector2;if(n.x=t.MathHelper.clamp(e.x,this.left,this.right),n.y=t.MathHelper.clamp(e.y,this.top,this.bottom),this.contains(n.x,n.y)){var r=n.x-this.left,o=this.right-n.x,s=n.y-this.top,a=this.bottom-n.y,h=Math.min(r,o,s,a);h==s?(n.y=this.top,i.y=-1):h==a?(n.y=this.bottom,i.y=1):h==r?(n.x=this.left,i.x=-1):(n.x=this.right,i.x=1)}else n.x==this.left&&(i.x=-1),n.x==this.right&&(i.x=1),n.y==this.top&&(i.y=-1),n.y==this.bottom&&(i.y=1);return n},i.prototype.getClosestPointOnBoundsToOrigin=function(){var e=this.max,i=Math.abs(this.location.x),n=new t.Vector2(this.location.x,0);return Math.abs(e.x)<i&&(i=Math.abs(e.x),n.x=e.x,n.y=0),Math.abs(e.y)<i&&(i=Math.abs(e.y),n.x=0,n.y=e.y),Math.abs(this.location.y)<i&&(i=Math.abs(this.location.y),n.x=0,n.y=this.location.y),n},i.prototype.calculateBounds=function(e,i,n,r,o,s,a){if(0==o)this.x=e.x+i.x-n.x*r.x,this.y=e.y+i.y-n.y*r.y,this.width=s*r.x,this.height=a*r.y;else{var h=e.x+i.x,c=e.y+i.y;this._transformMat=t.Matrix2D.create().translate(-h-n.x,-c-n.y),this._tempMat=t.Matrix2D.create().scale(r.x,r.y),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().rotate(o),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().translate(h,c),this._transformMat=this._transformMat.multiply(this._tempMat);var u=new t.Vector2(h,c),l=new t.Vector2(h+s,c),p=new t.Vector2(h,c+a),d=new t.Vector2(h+s,c+a);u=t.Vector2Ext.transformR(u,this._transformMat),l=t.Vector2Ext.transformR(l,this._transformMat),p=t.Vector2Ext.transformR(p,this._transformMat),d=t.Vector2Ext.transformR(d,this._transformMat);var f=Math.min(u.x,d.x,l.x,p.x),g=Math.max(u.x,d.x,l.x,p.x),m=Math.min(u.y,d.y,l.y,p.y),y=Math.max(u.y,d.y,l.y,p.y);this.location=new t.Vector2(f,m),this.width=g-f,this.height=y-m}},i}(egret.Rectangle);t.Rectangle=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.x=t,this.y=e,this.z=i}}();t.Vector3=e}(es||(es={})),function(t){var e=function(){function e(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return e.prototype.update=function(){for(var e=this._entity.getComponents(t.Collider),i=0;i<e.length;i++)for(var n=e[i],r=t.Physics.boxcastBroadphase(n.bounds,n.collidesWithLayers),o=function(e){var i=r[e];if(!n.isTrigger&&!i.isTrigger)return"continue";if(n.overlaps(i)){var o=new t.Pair(n,i);-1==s._activeTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&-1==s._previousTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&s.notifyTriggerListeners(o,!0),s._activeTriggerIntersections.contains(o)||s._activeTriggerIntersections.push(o)}},s=this,a=0;a<r.length;a++)o(a);t.ListPool.free(e),this.checkForExitedColliders()},e.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var n=i._previousTriggerIntersections.findIndex(function(i){return i.first==t._activeTriggerIntersections[e].first&&i.second==t._activeTriggerIntersections[e].second});-1!=n&&i._previousTriggerIntersections.removeAt(n)},i=this,n=0;n<this._activeTriggerIntersections.length;n++)e(n);for(n=0;n<this._previousTriggerIntersections.length;n++)this.notifyTriggerListeners(this._previousTriggerIntersections[n],!1);this._previousTriggerIntersections.length=0;for(n=0;n<this._activeTriggerIntersections.length;n++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[n])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[n]);this._activeTriggerIntersections.length=0},e.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)if(e?this._tempTriggerList[i].onTriggerEnter(t.second,t.first):this._tempTriggerList[i].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)e?this._tempTriggerList[n].onTriggerEnter(t.first,t.second):this._tempTriggerList[n].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},e}();t.ColliderTriggerHelper=e}(es||(es={})),function(t){var e;!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(e=t.PointSectors||(t.PointSectors={}));var i=function(){function i(){}return i.isLineToLine=function(e,i,n,r){var o=t.Vector2.subtract(i,e),s=t.Vector2.subtract(r,n),a=o.x*s.y-o.y*s.x;if(0==a)return!1;var h=t.Vector2.subtract(n,e),c=(h.x*s.y-h.y*s.x)/a;if(c<0||c>1)return!1;var u=(h.x*o.y-h.y*o.x)/a;return!(u<0||u>1)},i.lineToLineIntersection=function(e,i,n,r){var o=new t.Vector2(0,0),s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return o;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return o;var l=(c.x*s.y-c.y*s.x)/h;return l<0||l>1?o:o=t.Vector2.add(e,new t.Vector2(u*s.x,u*s.y))},i.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,new t.Vector2(r.x*s,r.y*s))},i.isCircleToCircle=function(e,i,n,r){return t.Vector2.distanceSquared(e,n)<(i+r)*(i+r)},i.isCircleToLine=function(e,i,n,r){return t.Vector2.distanceSquared(e,this.closestPointOnLine(n,r,e))<i*i},i.isCircleToPoint=function(e,i,n){return t.Vector2.distanceSquared(e,n)<i*i},i.isRectToCircle=function(t,e,i){var n=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-n),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<i*i},i.isRectToLine=function(i,n,r){var o=this.getSector(i.x,i.y,i.width,i.height,n),s=this.getSector(i.x,i.y,i.width,i.height,r);if(o==e.center||s==e.center)return!0;if(0!=(o&s))return!1;var a=o|s,h=void 0,c=void 0;return!(0==(a&e.top)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x+i.width,i.y),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.bottom)||(h=new t.Vector2(i.x,i.y+i.height),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.left)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x,i.y+i.height),!this.isLineToLine(h,c,n,r)))||!(0==(a&e.right)||(h=new t.Vector2(i.x+i.width,i.y),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))))},i.isRectToPoint=function(t,e,i,n,r){return r.x>=t&&r.y>=e&&r.x<t+i&&r.y<e+n},i.getSector=function(t,i,n,r,o){var s=e.center;return o.x<t?s|=e.left:o.x>=t+n&&(s|=e.right),o.y<i?s|=e.top:o.y>=i+r&&(s|=e.bottom),s},i}();t.Collisions=i}(es||(es={})),function(t){var e=function(){function e(){}return e.reset=function(){this._spatialHash=new t.SpatialHash(this.spatialHashCellSize)},e.clear=function(){this._spatialHash.clear()},e.overlapCircleAll=function(t,e,i,n){if(void 0===n&&(n=-1),0!=i.length)return this._spatialHash.overlapCircle(t,e,i,n);console.error("An empty results array was passed in. No results will ever be returned.")},e.boxcastBroadphase=function(t,e){return void 0===e&&(e=this.allLayers),this._spatialHash.aabbBroadphase(t,null,e)},e.boxcastBroadphaseExcludingSelf=function(t,e,i){return void 0===i&&(i=this.allLayers),this._spatialHash.aabbBroadphase(e,t,i)},e.addCollider=function(t){e._spatialHash.register(t)},e.removeCollider=function(t){e._spatialHash.remove(t)},e.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},e.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},e.spatialHashCellSize=100,e.allLayers=-1,e.raycastsHitTriggers=!1,e.raycastsStartInColliders=!1,e}();t.Physics=e}(es||(es={})),function(t){var e=function(){return function(e,i){this.start=e,this.end=i,this.direction=t.Vector2.subtract(this.end,this.start)}}();t.Ray2D=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r,o){this.fraction=0,this.distance=0,this.point=t.Vector2.zero,this.normal=t.Vector2.zero,this.collider=e,this.fraction=i,this.distance=n,this.point=r,this.centroid=t.Vector2.zero}return e.prototype.setValues=function(t,e,i,n){this.collider=t,this.fraction=e,this.distance=i,this.point=n},e.prototype.setValuesNonCollider=function(t,e,i,n){this.fraction=t,this.distance=e,this.point=i,this.normal=n},e.prototype.reset=function(){this.collider=null,this.fraction=this.distance=0},e.prototype.toString=function(){return"[RaycastHit] fraction: "+this.fraction+", distance: "+this.distance+", normal: "+this.normal+", centroid: "+this.centroid+", point: "+this.point},e}();t.RaycastHit=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.clone=function(){return ObjectUtils.clone(this)},t}();t.Shape=e}(es||(es={})),function(t){var e=function(e){function i(t,i){var n=e.call(this)||this;return n._areEdgeNormalsDirty=!0,n.isUnrotated=!0,n.setPoints(t),n.isBox=i,n}return __extends(i,e),Object.defineProperty(i.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),i.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},i.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=i.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},i.prototype.buildEdgeNormals=function(){var e,i=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==i||(this._edgeNormals=new Array(i));for(var n=0;n<i;n++){var r=this.points[n];e=n+1>=this.points.length?this.points[0]:this.points[n+1];var o=t.Vector2Ext.perpendicular(r,e);o=t.Vector2.normalize(o),this._edgeNormals[n]=o}},i.buildSymmetricalPolygon=function(e,i){for(var n=new Array(e),r=0;r<e;r++){var o=2*Math.PI*(r/e);n[r]=t.Vector2.multiply(new t.Vector2(Math.cos(o),Math.sin(o)),new t.Vector2(i))}return n},i.recenterPolygonVerts=function(e){for(var i=this.findPolygonCenter(e),n=0;n<e.length;n++)e[n]=t.Vector2.subtract(e[n],i)},i.findPolygonCenter=function(e){for(var i=0,n=0,r=0;r<e.length;r++)i+=e[r].x,n+=e[r].y;return new t.Vector2(i/e.length,n/e.length)},i.getFarthestPointInDirection=function(e,i){for(var n=0,r=t.Vector2.dot(e[n],i),o=1;o<e.length;o++){var s=t.Vector2.dot(e[o],i);s>r&&(r=s,n=o)}return e[n]},i.getClosestPointOnPolygonToPoint=function(e,i,n,r){n=Number.MAX_VALUE,r=new t.Vector2(0,0);for(var o,s=new t.Vector2(0,0),a=0;a<e.length;a++){var h=a+1;h==e.length&&(h=0);var c=t.ShapeCollisions.closestPointOnLine(e[a],e[h],i);if((o=t.Vector2.distanceSquared(i,c))<n){n=o,s=c;var u=t.Vector2.subtract(e[h],e[a]);r=new t.Vector2(-u.y,u.x)}}return t.Vector2Ext.normalize(r),s},i.rotatePolygonVerts=function(e,i,n){for(var r=Math.cos(e),o=Math.sign(e),s=0;s<i.length;s++){var a=i[s];n[s]=new t.Vector2(a.x*r+a.y*-o,a.x*o+a.y*r)}},i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=!0,n=void 0,r=t.Matrix2D.create().translate(-this._polygonCenter.x,-this._polygonCenter.y);if(e.entity.transform.scale!=t.Vector2.zero&&(n=t.Matrix2D.create().scale(e.entity.transform.scale.x,e.entity.transform.scale.y),r=r.multiply(n),i=!1,this.center=t.Vector2.multiply(e.localOffset,e.entity.transform.scale)),0!=e.entity.transform.rotation){n=t.Matrix2D.create().rotate(e.entity.transform.rotation),r=r.multiply(n);var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=i?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}n=t.Matrix2D.create().translate(this._polygonCenter.x,this._polygonCenter.y),r=r.multiply(n),t.Vector2Ext.transform(this._originalPoints,r,this.points),this.isUnrotated=0==e.entity.transform.rotation,e._isRotationDirty&&(this._areEdgeNormalsDirty=!0)}this.position=t.Vector2.add(e.entity.transform.position,this.center),this.bounds=t.Rectangle.rectEncompassingPoints(this.points),this.bounds.location=this.bounds.location.add(this.position)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Pologon to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Polygon to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToPoly(e,i,this,n)},i.prototype.containsPoint=function(e){e=t.Vector2.subtract(e,this.position);for(var i=!1,n=0,r=this.points.length-1;n<this.points.length;r=n++)this.points[n].y>e.y!=this.points[r].y>e.y&&e.x<(this.points[r].x-this.points[n].x)*(e.y-this.points[n].y)/(this.points[r].y-this.points[n].y)+this.points[n].x&&(i=!i);return i},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToPoly(e,this,i)},i}(t.Shape);t.Polygon=e}(es||(es={})),function(t){var e=function(e){function i(t,n){var r=e.call(this,i.buildBox(t,n),!0)||this;return r.width=t,r.height=n,r}return __extends(i,e),i.buildBox=function(e,i){var n=e/2,r=i/2,o=new Array(4);return o[0]=new t.Vector2(-n,-r),o[1]=new t.Vector2(n,-r),o[2]=new t.Vector2(n,r),o[3]=new t.Vector2(-n,r),o},i.prototype.updateBox=function(e,i){this.width=e,this.height=i;var n=e/2,r=i/2;this.points[0]=new t.Vector2(-n,-r),this.points[1]=new t.Vector2(n,-r),this.points[2]=new t.Vector2(n,r),this.points[3]=new t.Vector2(-n,r);for(var o=0;o<this.points.length;o++)this._originalPoints[o]=this.points[o]},i.prototype.overlaps=function(n){if(this.isUnrotated){if(n instanceof i&&n.isUnrotated)return this.bounds.intersects(n.bounds);if(n instanceof t.Circle)return t.Collisions.isRectToCircle(this.bounds,n.position,n.radius)}return e.prototype.overlaps.call(this,n)},i.prototype.collidesWithShape=function(n,r){return n instanceof i&&n.isUnrotated?t.ShapeCollisions.boxToBox(this,n,r):e.prototype.collidesWithShape.call(this,n,r)},i.prototype.containsPoint=function(t){return this.isUnrotated?this.bounds.contains(t.x,t.y):e.prototype.containsPoint.call(this,t)},i.prototype.pointCollidesWithShape=function(i,n){return this.isUnrotated?t.ShapeCollisions.pointToBox(i,this,n):e.prototype.pointCollidesWithShape.call(this,i,n)},i}(t.Polygon);t.Box=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this)||this;return i.radius=t,i._originalRadius=t,i}return __extends(i,e),i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=e.entity.transform.scale,n=1==i.x&&1==i.y,r=Math.max(i.x,i.y);if(this.radius=this._originalRadius*r,0!=e.entity.transform.rotation){var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=n?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}}this.position=t.Vector2.add(e.transform.position,this.center),this.bounds=new t.Rectangle(this.position.x-this.radius,this.position.y-this.radius,2*this.radius,2*this.radius)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof t.Box&&e.isUnrotated)return t.Collisions.isRectToCircle(e.bounds,this.position,this.radius);if(e instanceof i)return t.Collisions.isCircleToCircle(this.position,this.radius,e.position,e.radius);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("overlaps of circle to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof t.Box&&e.isUnrotated)return t.ShapeCollisions.circleToBox(this,e,n);if(e instanceof i)return t.ShapeCollisions.circleToCircle(this,e,n);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("Collisions of Circle to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToCircle(e,i,this,n)},i.prototype.containsPoint=function(e){return t.Vector2.subtract(e,this.position).lengthSquared()<=this.radius*this.radius},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToCircle(e,this,i)},i}(t.Shape);t.Circle=e}(es||(es={})),function(t){var e=function(){function e(){this.normal=t.Vector2.zero,this.minimumTranslationVector=t.Vector2.zero,this.point=t.Vector2.zero}return e.prototype.removeHorizontal=function(e){if(Math.sign(this.normal.x)!=Math.sign(e.x)||0==e.x&&0!=this.normal.x){var i=this.minimumTranslationVector.length()/this.normal.y;1!=Math.abs(this.normal.x)&&Math.abs(i)<Math.abs(3*e.y)&&(this.minimumTranslationVector=new t.Vector2(0,-i))}},e.prototype.invertResult=function(){return this.minimumTranslationVector=t.Vector2.negate(this.minimumTranslationVector),this.normal=t.Vector2.negate(this.normal),this},e.prototype.toString=function(){return"[CollisionResult] normal: "+this.normal+", minimumTranslationVector: "+this.minimumTranslationVector},e}();t.CollisionResult=e}(es||(es={})),function(t){var e=function(){function e(){}return e.intersectMovingCircleToBox=function(e,i,n){var r=i.bounds;r.inflate(e.radius,e.radius);var o=new t.Ray2D(t.Vector2.subtract(e.position,n),e.position),s=r.rayIntersects(o);if(s>1)return s;var a,h=t.Vector2.add(o.start,t.Vector2.add(o.direction,new t.Vector2(s))),c=0;h.x<i.bounds.left&&(a|=1),h.x>i.bounds.right&&(c|=1),h.y<i.bounds.top&&(a|=2),h.y>i.bounds.bottom&&(c|=2);var u=a+c;return 3==u&&console.log("m == 3. corner "+t.Time.frameCount),s},e}();t.RealtimeCollisions=e}(es||(es={})),function(t){var e=function(){function e(){}return e.polygonToPolygon=function(e,i,n){for(var r,o=!0,s=e.edgeNormals,a=i.edgeNormals,h=Number.POSITIVE_INFINITY,c=new t.Vector2,u=t.Vector2.subtract(e.position,i.position),l=0;l<s.length+a.length;l++){r=l<s.length?s[l]:a[l-s.length];var p=0,d=0,f=0,g=0,m=0,y=this.getInterval(r,e,p,f);p=y.min,d=y.max;var _=this.getInterval(r,i,d,g);d=_.min,g=_.max;var v=t.Vector2.dot(u,r);if(p+=v,f+=v,(m=this.intervalDistance(p,f,d,g))>0&&(o=!1),!o)return!1;(m=Math.abs(m))<h&&(h=m,c=r,t.Vector2.dot(c,u)<0&&(c=new t.Vector2(-c)))}return n.normal=c,n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-c.x,-c.y),new t.Vector2(h)),!0},e.intervalDistance=function(t,e,i,n){return t<i?i-e:t-i},e.getInterval=function(e,i,n,r){var o=t.Vector2.dot(i.points[0],e);n=r=o;for(var s=1;s<i.points.length;s++)(o=t.Vector2.dot(i.points[s],e))<n?n=o:o>r&&(r=o);return{min:n,max:r}},e.circleToPolygon=function(e,i,n){var r,o=t.Vector2.subtract(e.position,i.position),s=t.Polygon.getClosestPointOnPolygonToPoint(i.points,o,0,n.normal),a=i.containsPoint(e.position);if(0>e.radius*e.radius&&!a)return!1;a?r=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0)-e.radius)):r=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));return n.minimumTranslationVector=r,n.point=t.Vector2.add(s,i.position),!0},e.circleToBox=function(e,i,n){var r=i.bounds.getClosestPointOnRectangleBorderToPoint(e.position,n.normal);if(i.containsPoint(e.position)){n.point=r;var o=t.Vector2.add(r,t.Vector2.multiply(n.normal,new t.Vector2(e.radius)));return n.minimumTranslationVector=t.Vector2.subtract(e.position,o),!0}var s=t.Vector2.distanceSquared(r,e.position);if(0==s)n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));else if(s<=e.radius*e.radius){n.normal=t.Vector2.subtract(e.position,r);var a=n.normal.length()-e.radius;return n.point=r,n.normal=t.Vector2Ext.normalize(n.normal),n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(a),n.normal),!0}return!1},e.pointToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e,i.position),o=1+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s,-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius,i.radius))),!0}return!1},e.pointToBox=function(e,i,n){return!!i.containsPoint(e)&&(n.point=i.bounds.getClosestPointOnRectangleBorderToPoint(e,n.normal),n.minimumTranslationVector=t.Vector2.subtract(e,n.point),!0)},e.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,t.Vector2.multiply(r,new t.Vector2(s,s)))},e.pointToPoly=function(e,i,n){if(i.containsPoint(e)){var r=t.Polygon.getClosestPointOnPolygonToPoint(i.points,t.Vector2.subtract(e,i.position),0,n.normal);return n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0),Math.sqrt(0))),n.point=t.Vector2.add(r,i.position),!0}return!1},e.circleToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e.position,i.position),o=e.radius+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e.position,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius))),!0}return!1},e.boxToBox=function(e,i,n){var r=this.minkowskiDifference(e,i);return!!r.contains(0,0)&&(n.minimumTranslationVector=r.getClosestPointOnBoundsToOrigin(),!n.minimumTranslationVector.equals(t.Vector2.zero)&&(n.normal=new t.Vector2(-n.minimumTranslationVector.x,-n.minimumTranslationVector.y),n.normal=n.normal.normalize(),!0))},e.minkowskiDifference=function(e,i){var n=t.Vector2.subtract(e.position,t.Vector2.add(e.bounds.location,t.Vector2.divide(e.bounds.size,new t.Vector2(2)))),r=t.Vector2.subtract(t.Vector2.add(e.bounds.location,n),i.bounds.max),o=t.Vector2.add(e.bounds.size,i.bounds.size);return new t.Rectangle(r.x,r.y,o.x,o.y)},e.lineToPoly=function(e,i,n,r){for(var o=t.Vector2.zero,s=t.Vector2.zero,a=Number.MAX_VALUE,h=!1,c=n.points.length-1,u=0;u<n.points.length;c=u,u++){var l=t.Vector2.add(n.position,n.points[c]),p=t.Vector2.add(n.position,n.points[u]),d=t.Vector2.zero;if(this.lineToLine(l,p,e,i,d)){h=!0;var f=(d.x-e.x)/(i.x-e.x);if((Number.isNaN(f)||Number.isFinite(f))&&(f=(d.y-e.y)/(i.y-e.y)),f<a){var g=t.Vector2.subtract(p,l);o=new t.Vector2(g.y,-g.x),a=f,s=d}}}if(h){o=o.normalize();var m=t.Vector2.distance(e,s);return r.setValuesNonCollider(a,m,s,o),!0}return!1},e.lineToLine=function(e,i,n,r,o){var s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return!1;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return!1;var l=(c.x*s.y-c.y*s.x)/h;return!(l<0||l>1)&&(o=o.add(e).add(t.Vector2.multiply(new t.Vector2(u),s)),!0)},e.lineToCircle=function(e,i,n,r){var o=t.Vector2.distance(e,i),s=t.Vector2.divide(t.Vector2.subtract(i,e),new t.Vector2(o)),a=t.Vector2.subtract(e,n.position),h=t.Vector2.dot(a,s),c=t.Vector2.dot(a,a)-n.radius*n.radius;if(c>0&&h>0)return!1;var u=h*h-c;return!(u<0)&&(r.fraction=-h-Math.sqrt(u),r.fraction<0&&(r.fraction=0),r.point=t.Vector2.add(e,t.Vector2.multiply(new t.Vector2(r.fraction),s)),r.distance=t.Vector2.distance(e,r.point),r.normal=t.Vector2.normalize(t.Vector2.subtract(r.point,n.position)),r.fraction=r.distance/o,!0)},e.boxToBoxCast=function(e,i,n,r){var o=this.minkowskiDifference(e,i);if(o.contains(0,0)){var s=o.getClosestPointOnBoundsToOrigin();return!s.equals(t.Vector2.zero)&&(r.normal=new t.Vector2(-s.x),r.normal=r.normal.normalize(),r.distance=0,r.fraction=0,!0)}var a=new t.Ray2D(t.Vector2.zero,new t.Vector2(-n.x)),h=o.rayIntersects(a);return h<=1&&(r.fraction=h,r.distance=n.length()*h,r.normal=new t.Vector2(-n.x),r.normal=r.normal.normalize(),r.centroid=t.Vector2.add(e.bounds.center,t.Vector2.multiply(n,new t.Vector2(h))),!0)},e}();t.ShapeCollisions=e}(es||(es={})),function(t){var e=function(){function e(e){void 0===e&&(e=100),this.gridBounds=new t.Rectangle,this._overlapTestCircle=new t.Circle(0),this._cellDict=new i,this._tempHashSet=[],this._cellSize=e,this._inverseCellSize=1/this._cellSize,this._raycastParser=new n}return e.prototype.register=function(e){var i=e.bounds;e.registeredPhysicsBounds=i;var n=this.cellCoords(i.x,i.y),r=this.cellCoords(i.right,i.bottom);this.gridBounds.contains(n.x,n.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,n)),this.gridBounds.contains(r.x,r.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,r));for(var o=n.x;o<=r.x;o++)for(var s=n.y;s<=r.y;s++){var a=this.cellAtPosition(o,s,!0);a.firstOrDefault(function(t){return t.hashCode==e.hashCode})||a.push(e)}},e.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,i=this.cellCoords(e.x,e.y),n=this.cellCoords(e.right,e.bottom),r=i.x;r<=n.x;r++)for(var o=i.y;o<=n.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.log("从不存在碰撞器的单元格中移除碰撞器: ["+t+"]")}},e.prototype.removeWithBruteForce=function(t){this._cellDict.remove(t)},e.prototype.clear=function(){this._cellDict.clear()},e.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var i=this.gridBounds.x;i<=this.gridBounds.right;i++)for(var n=this.gridBounds.y;n<=this.gridBounds.bottom;n++){var r=this.cellAtPosition(i,n);r&&r.length>0&&this.debugDrawCellDetails(i,n,r.length,t,e)}},e.prototype.aabbBroadphase=function(e,i,n){this._tempHashSet.length=0;for(var r=this.cellCoords(e.x,e.y),o=this.cellCoords(e.right,e.bottom),s=r.x;s<=o.x;s++)for(var a=r.y;a<=o.y;a++){var h=this.cellAtPosition(s,a);if(h)for(var c=function(r){var o=h[r];if(o==i||!t.Flags.isFlagSet(n,o.physicsLayer))return"continue";e.intersects(o.bounds)&&(u._tempHashSet.firstOrDefault(function(t){return t.hashCode==o.hashCode})||u._tempHashSet.push(o))},u=this,l=0;l<h.length;l++)c(l)}return this._tempHashSet},e.prototype.overlapCircle=function(e,i,n,r){var o=new t.Rectangle(e.x-i,e.y-i,2*i,2*i);this._overlapTestCircle.radius=i,this._overlapTestCircle.position=e;for(var s=0,a=this.aabbBroadphase(o,null,r),h=0;h<a.length;h++){var c=a[h];if(c instanceof t.BoxCollider)n[s]=c,s++;else if(c instanceof t.CircleCollider)c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++);else{if(!(c instanceof t.PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++)}if(s==n.length)return s}return s},e.prototype.cellCoords=function(e,i){return new t.Vector2(Math.floor(e*this._inverseCellSize),Math.floor(i*this._inverseCellSize))},e.prototype.cellAtPosition=function(t,e,i){void 0===i&&(i=!1);var n=this._cellDict.tryGetValue(t,e);return n||i&&(n=[],this._cellDict.add(t,e,n)),n},e.prototype.debugDrawCellDetails=function(t,e,i,n,r){void 0===n&&(n=.5),void 0===r&&(r=1)},e}();t.SpatialHash=e;var i=function(){function t(){this._store=new Map}return t.prototype.add=function(t,e,i){this._store.set(this.getKey(t,e),i)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!0)).toString()},t}();t.NumberDictionary=i;var n=function(){function e(){this._checkedColliders=[],this._cellHits=[]}return e.prototype.start=function(t,e,i){this._ray=t,this._hits=e,this._layerMask=i,this.hitCounter=0},e.prototype.checkRayIntersection=function(i,n,r){for(var o=0;o<r.length;o++){var s=r[o];if(!this._checkedColliders.contains(s))if(this._checkedColliders.push(s),!s.isTrigger||t.Physics.raycastsHitTriggers)if(t.Flags.isFlagSet(this._layerMask,s.physicsLayer))if(s.bounds.rayIntersects(this._ray)<=1&&s.shape.collidesWithLine(this._ray.start,this._ray.end,this._tempHit)){if(!t.Physics.raycastsStartInColliders&&s.shape.containsPoint(this._ray.start))continue;this._tempHit.collider=s,this._cellHits.push(this._tempHit)}}if(0==this._cellHits.length)return!1;this._cellHits.sort(e.compareRaycastHits);for(o=0;o<this._cellHits.length;o++)if(this._hits[this.hitCounter]=this._cellHits[o],this.hitCounter++,this.hitCounter==this._hits.length)return!0;return!1},e.prototype.reset=function(){this._hits=null,this._checkedColliders.length=0,this._cellHits.length=0},e.compareRaycastHits=function(t,e){return t.distance-e.distance},e}();t.RaycastResultParser=n}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxGroup=e}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxImageLayer=e}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"offset",{get:function(){return new t.Vector2(this.offsetX,this.offsetY)},enumerable:!0,configurable:!0}),e.prototype.getTileWithGid=function(t){for(var e=0;e<this.tiles.length;e++)if(this.tiles[e]&&this.tiles[e].gid==t)return this.tiles[e];return null},e.prototype.getTile=function(t,e){return this.tiles[t+e*this.width]},e.prototype.getCollisionRectangles=function(){for(var t=[],e=[],i=-1,n=-1,r=0;r<this.map.height;r++){for(var o=0;o<this.map.width;o++){n=r*this.map.width+o;var s=this.getTile(o,r);s&&!t[n]?(i<0&&(i=o),t[n]=!0):(s||t[n])&&i>=0&&(e.push(this.findBoundsRect(i,o,r,t)),i=-1)}i>=0&&(e.push(this.findBoundsRect(i,this.map.width,r,t)),i=-1)}return e},e.prototype.findBoundsRect=function(e,i,n,r){for(var o=-1,s=n+1;s<this.map.height;s++)for(var a=e;a<i;a++){if(o=s*this.map.width+a,this.getTile(a,s)||r[o]){for(var h=e;h<a;h++)r[o=s*this.map.width+h]=!1;return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(s-n)*this.map.tileHeight)}r[o]=!0}return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(this.map.height-n)*this.map.tileHeight)},e}();t.TmxLayer=e;var i=function(){function e(t,i,n,r){this.x=n,this.y=r;var o,s=i;o=0!=(s&e.FLIPPED_HORIZONTALLY_FLAG),this.horizontalFlip=o,o=0!=(s&e.FLIPPED_VERTICALLY_FLAG),this.verticalFlip=o,s&=~(e.FLIPPED_HORIZONTALLY_FLAG|e.FLIPPED_VERTICALLY_FLAG),this.gid=s,this.tileset=t.getTilesetForTileGid(this.gid)}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tilesetTile",{get:function(){null==this._tilesetTileIndex&&(this._tilesetTileIndex=-1,this.tileset.firstGid<=this.gid&&this.tileset.tiles.get(this.gid-this.tileset.firstGid)&&(this._tilesetTileIndex=this.gid-this.tileset.firstGid));return this._tilesetTileIndex<0?null:this.tileset.tiles.get(this._tilesetTileIndex)},enumerable:!0,configurable:!0}),e.FLIPPED_HORIZONTALLY_FLAG=2147483648,e.FLIPPED_VERTICALLY_FLAG=1073741824,e}();t.TmxLayerTile=i}(es||(es={})),function(t){var e=function(){return function(){this.tmxDirectory="resource/assets/"}}();t.TmxDocument=e;var i=function(){function t(){}return t.prototype.dispose=function(){this.bitmap&&(this.bitmap.dispose(),this.bitmap=null)},t}();t.TmxImage=i}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"worldWidth",{get:function(){return this.width*this.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"worldHeight",{get:function(){return this.height*this.tileHeight},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"requiresLargeTileCulling",{get:function(){return this.maxTileHeight>this.tileHeight||this.maxTileWidth>this.tileWidth},enumerable:!0,configurable:!0}),i.prototype.getTilesetForTileGid=function(t){if(0==t)return null;for(var e=this.tilesets.length-1;e>=0;e--)if(this.tilesets[e].firstGid<=t)return this.tilesets[e];console.error("tile gid"+t+"未在任何tileset中找到")},i.prototype.worldToTilePositionX=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileWidth);return i?t.MathHelper.clamp(n,0,this.width-1):n},i.prototype.worldToTilePositionY=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileHeight);return i?t.MathHelper.clamp(n,0,this.height-1):n},i.prototype.getLayer=function(t){return this.layers[t]},i.prototype.update=function(){this.tilesets.forEach(function(t){t.update()})},i.prototype.dispose=function(t){void 0===t&&(t=!0),this._isDisposed||(t&&(this.tilesets.forEach(function(t){t.image&&t.image.dispose()}),this.imageLayers.forEach(function(t){t.image&&t.image.dispose()})),this._isDisposed=!0)},i}(t.TmxDocument);t.TmxMap=e,function(t){t[t.unknown=0]="unknown",t[t.orthogonal=1]="orthogonal",t[t.isometric=2]="isometric",t[t.staggered=3]="staggered",t[t.hexagonal=4]="hexagonal"}(t.OrientationType||(t.OrientationType={})),function(t){t[t.x=0]="x",t[t.y=1]="y"}(t.StaggerAxisType||(t.StaggerAxisType={})),function(t){t[t.odd=0]="odd",t[t.even=1]="even"}(t.StaggerIndexType||(t.StaggerIndexType={})),function(t){t[t.rightDown=0]="rightDown",t[t.rightUp=1]="rightUp",t[t.leftDown=2]="leftDown",t[t.leftUp=3]="leftUp"}(t.RenderOrderType||(t.RenderOrderType={}))}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxObjectGroup=e;var i=function(){return function(){this.shape=new egret.Shape,this.textField=new egret.TextField}}();t.TmxObject=i;var n=function(){return function(){}}();t.TmxText=n;var r=function(){return function(){}}();t.TmxAlignment=r,function(t){t[t.basic=0]="basic",t[t.point=1]="point",t[t.tile=2]="tile",t[t.ellipse=3]="ellipse",t[t.polygon=4]="polygon",t[t.polyline=5]="polyline",t[t.text=6]="text"}(t.TmxObjectType||(t.TmxObjectType={})),function(t){t[t.unkownOrder=-1]="unkownOrder",t[t.TopDown=0]="TopDown",t[t.IndexOrder=1]="IndexOrder"}(t.DrawOrderType||(t.DrawOrderType={})),function(t){t[t.left=0]="left",t[t.center=1]="center",t[t.right=2]="right",t[t.justify=3]="justify"}(t.TmxHorizontalAlignment||(t.TmxHorizontalAlignment={})),function(t){t[t.top=0]="top",t[t.center=1]="center",t[t.bottom=2]="bottom"}(t.TmxVerticalAlignment||(t.TmxVerticalAlignment={}))}(es||(es={})),function(t){var e=function(){function e(){}return e.loadTmxMap=function(t,e){var i=RES.getRes(e);return this.loadTmxMapData(t,i)},e.loadTmxMapData=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:e.version=i.version,e.tiledVersion=i.tiledversion,e.width=i.width,e.height=i.height,e.tileWidth=i.tilewidth,e.tileHeight=i.tileheight,e.hexSideLength=i.hexsidelength,e.orientation=this.parseOrientationType(i.orientation),e.staggerAxis=this.parseStaggerAxisType(i.staggeraxis),e.staggerIndex=this.parseStaggerIndexType(i.staggerindex),e.renderOrder=this.parseRenderOrderType(i.renderorder),e.nextObjectID=i.nextobjectid,e.backgroundColor=t.TmxUtils.color16ToUnit(i.color),e.properties=this.parsePropertyDict(i.properties),e.maxTileWidth=e.tileWidth,e.maxTileHeight=e.tileHeight,e.tilesets=[],n=0,r=i.tilesets,a.label=1;case 1:return n<r.length?(o=r[n],[4,this.parseTmxTileset(e,o)]):[3,4];case 2:s=a.sent(),e.tilesets.push(s),this.updateMaxTileSizes(s),a.label=3;case 3:return n++,[3,1];case 4:return e.layers=[],e.tileLayers=[],e.objectGroups=[],e.imageLayers=[],e.groups=[],this.parseLayers(e,i,e,e.width,e.height,e.tmxDirectory),[2,e]}})})},e.parseLayers=function(e,i,n,r,o,s){return __awaiter(this,void 0,void 0,function(){var a,h,c,u,l,p,d,f;return __generator(this,function(g){switch(g.label){case 0:a=0,h=ObjectUtils.elements(i).where(function(t){return"tilelayer"==t.type||"objectgroup"==t.type||"imagelayer"==t.type||"group"==t.type}),g.label=1;case 1:if(!(a<h.length))return[3,11];switch(c=h[a],u=void 0,c.type){case"tilelayer":return[3,2];case"objectgroup":return[3,3];case"imagelayer":return[3,4];case"group":return[3,6]}return[3,8];case 2:return l=this.loadTmxLayer(new t.TmxLayer,n,c,r,o),u=l,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.tileLayers.push(l),[3,9];case 3:return p=this.loadTmxObjectGroup(new t.TmxObjectGroup,n,c),u=p,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.objectGroups.push(p),[3,9];case 4:return[4,this.loadTmxImageLayer(new t.TmxImageLayer,n,c,s)];case 5:return d=g.sent(),u=d,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.imageLayers.push(d),[3,9];case 6:return[4,this.loadTmxGroup(new t.TmxGroup,n,c,r,o,s)];case 7:return f=g.sent(),u=f,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.groups.push(f),[3,9];case 8:throw new Error("无效的操作");case 9:(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.layers.push(u),g.label=10;case 10:return a++,[3,1];case 11:return[2]}})})},e.loadTmxGroup=function(t,e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(s){switch(s.label){case 0:return t.map=e,t.name=null!=i.name?i.name:"",t.opacity=null!=i.opacity?i.opacity:1,t.visible=null==i.visible||i.visible,t.offsetX=null!=i.offsetx?i.offsetx:0,t.offsetY=null!=i.offsety?i.offsety:0,t.properties=this.parsePropertyDict(i.properties),t.layers=[],t.tileLayers=[],t.objectGroups=[],t.imageLayers=[],t.groups=[],[4,this.parseLayers(t,i,e,n,r,o)];case 1:return s.sent(),[2,t]}})})},e.loadTmxImageLayer=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s;return __generator(this,function(a){switch(a.label){case 0:return e.map=i,e.name=n.name,e.width=n.width,e.height=n.height,e.visible=null==n.visible||n.visible,e.opacity=null!=n.opacity?n.opacity:1,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0,(o=n.image)?(s=e,[4,this.loadTmxImage(new t.TmxImage,o,r)]):[3,2];case 1:s.image=a.sent(),a.label=2;case 2:return e.properties=this.parsePropertyDict(n.properties),[2,e]}})})},e.loadTmxLayer=function(i,n,r,o,s){i.map=n,i.name=r.name,i.opacity=null!=r.opacity?r.opacity:1,i.visible=null==r.visible||r.visible,i.offsetX=null!=r.offsetx?r.offsetx:0,i.offsetY=null!=r.offsety?r.offsety:0,i.width=r.width,i.height=r.height;var a=r.data,h=null!=a.encoding?a.encoding:"csv";if(i.tiles=new Array(o*s),"base64"==h)for(var c=t.TmxUtils.decode(a.toString(),h,a.compression),u=0,l=0;l<s;l++)for(var p=0;p<o;p++){var d=c[u];i.tiles[u++]=0!=d?new t.TmxLayerTile(n,d,p,l):null}else if("csv"==h)for(var f=0,g=0,m=a;g<m.length;g++){d=m[g];var y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}else{if(h)throw new Error("TmxLayer:未知编码");f=0;for(var v=0,b=a.tile;v<b.length;v++){var x=b[v];d=null!=x.gid?x.gid:0,y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}}return i.properties=e.parsePropertyDict(r.properties),i},e.updateMaxTileSizes=function(t){t.tiles.forEach(function(e){e.image&&(e.image.width>t.map.maxTileWidth&&(t.map.maxTileWidth=e.image.width),e.image.height>t.map.maxTileHeight&&(t.map.maxTileHeight=e.image.height))}),t.tileRegions.forEach(function(e){var i=e.width,n=e.height;i>t.map.maxTileWidth&&(t.map.maxTileWidth=i),i>t.map.maxTileHeight&&(t.map.maxTileHeight=n)})},e.parseOrientationType=function(e){return"unknown"==e?t.OrientationType.unknown:"orthogonal"==e?t.OrientationType.orthogonal:"isometric"==e?t.OrientationType.isometric:"staggered"==e?t.OrientationType.staggered:"hexagonal"==e?t.OrientationType.hexagonal:t.OrientationType.unknown},e.parseStaggerAxisType=function(e){return"y"==e?t.StaggerAxisType.y:t.StaggerAxisType.x},e.parseStaggerIndexType=function(e){return"even"==e?t.StaggerIndexType.even:t.StaggerIndexType.odd},e.parseRenderOrderType=function(e){return"right-up"==e?t.RenderOrderType.rightUp:"left-down"==e?t.RenderOrderType.leftDown:"left-up"==e?t.RenderOrderType.leftUp:t.RenderOrderType.rightDown},e.parsePropertyDict=function(e){if(!e)return null;for(var i=new Map,n=0,r=e;n<r.length;n++){var o=r[n],s=o.name,a=o.value;"color"==o.type?i.set(s,t.TmxUtils.color16ToUnit(a).toString()):i.set(s,a)}return i},e.parseTmxTileset=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:return n=i.firstgid,r=n,null==(o=i.source)?[3,2]:(o=e.tmxDirectory+o,[4,RES.getResByUrl(o).catch(function(t){throw new Error(t)})]);case 1:return s=a.sent(),[2,this.loadTmxTileset(new t.TmxTileset,e,s.tileset,r)];case 2:return[2,this.loadTmxTileset(new t.TmxTileset,e,i,r)]}})})},e.loadTmxTileset=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s,a,h,c,u,l,p,d,f,g,m,y;return __generator(this,function(_){switch(_.label){case 0:return e.map=i,e.firstGid=r,e.name=n.name,e.tileWidth=n.tilewidth,e.tileHeight=n.tileheight,e.spacing=null!=n.spacing?n.spacing:0,e.margin=null!=n.margin?n.margin:0,e.columns=n.columns,e.tileCount=n.tilecount,e.tileOffset=this.parseTmxTileOffset(n.tileoffset),n.image?[4,this.loadTmxImage(new t.TmxImage,n,i.tmxDirectory).then(function(t){e.image=t}).catch(function(t){throw new Error(t)})]:[3,2];case 1:_.sent(),_.label=2;case 2:if(e.terrains=[],n.terrains)for(o=0,s=n.terrains;o<s.length;o++)a=s[o],e.terrains.push(this.parseTmxTerrain(a));for(c in e.tiles=new Map,h=[],n.tiles)h.push(c);u=0,_.label=3;case 3:return u<h.length?(l=h[u],n.tiles.hasOwnProperty(l)?(p=n.tiles[l],[4,this.loadTmxTilesetTile(new t.TmxTilesetTile,e,p,e.terrains,i.tmxDirectory)]):[3,5]):[3,6];case 4:d=_.sent(),e.tiles.set(null==d.id?Number(l)+1:d.id,d),_.label=5;case 5:return u++,[3,3];case 6:if(e.properties=this.parsePropertyDict(n.properties),e.tileRegions=new Map,e.image)for(f=r,g=e.margin;g<e.image.height-e.margin;g+=e.tileHeight+e.spacing)for(m=0,y=e.margin;y<e.image.width-e.margin&&(e.tileRegions.set(f++,new t.Rectangle(y,g,e.tileWidth,e.tileHeight)),!(++m>=e.columns));y+=e.tileWidth+e.spacing);else e.tiles.forEach(function(i,n){e.tileRegions.set(n,new t.Rectangle(0,0,i.image.width,i.image.height))});return[2,e]}})})},e.loadTmxTilesetTile=function(e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){var s,a,h,c,u,l,p,d,f,g,m,y,_;return __generator(this,function(v){switch(v.label){case 0:if(e.tileset=i,e.id=n.id,s=n.terrain)for(e.terrainEdges=new Array(4),a=0,h=0,c=s;h<c.length;h++)u=c[h],l=r[u],e.terrainEdges[a++]=l;return e.probability=null!=n.probability?n.probability:1,e.type=n.type,(p=n.image)?(d=e,[4,this.loadTmxImage(new t.TmxImage,p,o)]):[3,2];case 1:d.image=v.sent(),v.label=2;case 2:if(e.objectGroups=[],n.objectgroup)for(f=0,g=n.objectgroup;f<g.length;f++)_=g[f],e.objectGroups.push(this.loadTmxObjectGroup(new t.TmxObjectGroup,i.map,_));if(e.animationFrames=[],n.animation)for(m=0,y=n.animation.frame;m<y.length;m++)_=y[m],e.animationFrames.push(this.loadTmxAnimationFrame(new t.TmxAnimationFrame,_));return e.properties=this.parsePropertyDict(n.properties),e.properties&&e.processProperties(),[2,e]}})})},e.loadTmxAnimationFrame=function(t,e){return t.gid=e.tileid,t.duration=e.duration/1e3,t},e.loadTmxObjectGroup=function(e,i,n){e.map=i,e.name=null!=n.name?n.name:"",e.color=t.TmxUtils.color16ToUnit(n.color),e.opacity=null!=n.opacity?n.opacity:1,e.visible=null==n.visible||n.visible,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0;var r=new Map;r.set("unknown",t.DrawOrderType.unkownOrder),r.set("topdown",t.DrawOrderType.IndexOrder),r.set("index",t.DrawOrderType.TopDown);var o=n.draworder;o&&(e.drawOrder=r.get(o)),e.objects=[];for(var s=0,a=n.objects;s<a.length;s++){var h=a[s];e.objects.push(this.loadTmxObject(new t.TmxObject,i,h))}return e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxObject=function(e,i,n){e.id=null!=n.id?n.id:0,e.name=null!=n.name?n.name:"",e.x=n.x,e.y=n.y,e.width=null!=n.width?n.width:0,e.height=null!=n.height?n.height:0,e.type=null!=n.type?n.type:"",e.visible=null==n.visible||n.visible,e.rotation=null!=n.rotation?n.rotation:0;var r=n.gid,o=n.ellipse,s=n.polygon,a=n.polyline,h=n.text,c=n.point;return r?(e.tile=new t.TmxLayerTile(i,r,Math.round(e.x),Math.round(e.y)),e.objectType=t.TmxObjectType.tile):o?e.objectType=t.TmxObjectType.ellipse:s?(e.points=this.parsePoints(s),e.objectType=t.TmxObjectType.polygon):a?(e.points=this.parsePoints(a),e.objectType=t.TmxObjectType.polyline):h?(e.text=this.loadTmxText(new t.TmxText,h),e.objectType=t.TmxObjectType.text):e.objectType=c?t.TmxObjectType.point:t.TmxObjectType.basic,e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxText=function(e,i){return e.fontFamily=null!=i.fontfamily?i.fontfamily:"sans-serif",e.pixelSize=null!=i.pixelsize?i.pixelsize:16,e.wrap=null!=i.wrap&&i.wrap,e.color=t.TmxUtils.color16ToUnit(i.color),e.bold=!!i.bold&&i.bold,e.italic=!!i.italic&&i.italic,e.underline=!!i.underline&&i.underline,e.strikeout=!!i.strikeout&&i.strikeout,e.kerning=!i.kerning||i.kerning,e.alignment=this.loadTmxAlignment(new t.TmxAlignment,i),e.value=i,e},e.loadTmxAlignment=function(e,i){function n(t){return t&&""!=t?t[0].toString().toUpperCase()+t.substr(1):t}var r=null!=i.halign?i.halign:"left";e.horizontal=t.TmxHorizontalAlignment[n(r)];var o=null!=i.valign?i.valign:"top";return e.vertical=t.TmxVerticalAlignment[n(o)],e},e.parsePoints=function(t){for(var e=[],i=0,n=0,r=t;n<r.length;n++){var o=r[n];e[i++]=this.parsePoint(o)}return e},e.parsePoint=function(e){return new t.Vector2(e.x,e.y)},e.parseTmxTerrain=function(e){var i=new t.TmxTerrain;return i.name=e.name,i.tile=e.tile,i.properties=this.parsePropertyDict(e.properties),i},e.parseTmxTileOffset=function(e){var i=new t.TmxTileOffset;return e?(i.x=e.x,i.y=e.y,i):(i.x=0,i.y=0,i)},e.loadTmxImage=function(e,i,n){return __awaiter(this,void 0,void 0,function(){var r,o;return __generator(this,function(s){switch(s.label){case 0:return r=i.image,e.source=null!=r?n+r:n+i,[4,RES.getResByUrl(e.source,null,this,RES.ResourceItem.TYPE_IMAGE).catch(function(t){throw new Error(t)})];case 1:return o=s.sent(),e.bitmap=new egret.SpriteSheet(o),e.trans=t.TmxUtils.color16ToUnit(i.trans),e.width=null!=i.imagewidth?i.imagewidth:o.textureWidth,e.height=null!=i.imageheight?i.imageheight:o.textureHeight,[2,e]}})})},e}();t.TiledMapLoader=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){}return i.renderMap=function(e,i,n,r,o){var s=this;e.layers.forEach(function(e){e instanceof t.TmxLayer&&e.visible?s.renderLayer(e,i,n,r,o):e instanceof t.TmxImageLayer&&e.visible?s.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?s.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&s.renderObjectGroup(e,i,n,r,o)})},i.renderLayer=function(e,i,n,r,o){if(e.visible)for(var s=e.map.tileWidth*r.x,a=e.map.tileHeight*r.y,h=t.DrawUtils.getColorMatrix(16777215),c=0;c<e.tiles.length;c++){var u=e.tiles[c];u&&this.renderTile(u,i,n,r,s,a,h,o)}},i.renderLayerRenderCamera=function(e,i,n,r,o,s){e instanceof t.TmxLayer&&e.visible?this.renderLayerCamera(e,i,n,r,o,s):e instanceof t.TmxImageLayer&&e.visible?this.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?this.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&this.renderObjectGroup(e,i,n,r,o)},i.renderLayerCamera=function(e,i,n,r,o,s){if(e.visible){n=n.add(e.offset),s.location=s.location.subtract(n);var a,h,c,u=e.map.tileWidth*r.x,l=e.map.tileHeight*r.y,p=0;e.map.requiresLargeTileCulling?(a=e.map.worldToTilePositionX(s.left-(e.map.maxTileWidth*r.x-u)),h=e.map.worldToTilePositionY(s.top-(e.map.maxTileHeight*r.y-l)),c=e.map.worldToTilePositionX(s.right+(e.map.maxTileWidth*r.x-u)),p=e.map.worldToTilePositionY(s.bottom+(e.map.maxTileHeight*r.y-l))):(a=e.map.worldToTilePositionX(s.left),h=e.map.worldToTilePositionY(s.top),c=e.map.worldToTilePositionX(s.right),p=e.map.worldToTilePositionY(s.bottom));for(var d=t.DrawUtils.getColorMatrix(16777215),f=h;f<=p;f++)for(var g=a;g<=c;g++){var m=e.getTile(g,f);m&&this.renderTile(m,i,n,r,u,l,d,o)}}},i.renderImageLayer=function(e,i,n,r,o){if(e.visible){var s=t.DrawUtils.getColorMatrix(16777215),a=t.Vector2.add(n,new t.Vector2(e.offsetX,e.offsetY).multiply(r));e.image.texture.parent||i.addChild(e.image.texture),e.image.texture.x=a.x,e.image.texture.y=a.y,e.image.texture.scaleX=r.x,e.image.texture.scaleY=r.y,e.image.texture.filters=[s]}},i.renderObjectGroup=function(e,i,n,r,o){if(e.visible)for(var s in e.objects){var a=e.objects[s];if(a.visible&&(t.Core.debugRenderEndabled||a.objectType==t.TmxObjectType.tile||a.objectType==t.TmxObjectType.text)){var h=t.Vector2.add(n,new t.Vector2(a.x,a.y).multiply(r));switch(a.objectType){case t.TmxObjectType.basic:a.shape.parent||(a.shape.x=a.x,a.shape.y=a.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawRect(0,0,a.width*r.x,a.height*r.y),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.point:var c=.5*e.map.tileWidth;h.x-=.5*c,h.y-=.5*c,a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,1),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.tile:this.renderTilesetTile(e,a,i,h,r,p);break;case t.TmxObjectType.ellipse:h=new t.Vector2(a.x+.5*a.width,a.y+.5*a.height).multiply(r),a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,.5*a.width),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.polygon:case t.TmxObjectType.polyline:for(var u=[],l=0;l<a.points.length;l++)u[l]=t.Vector2.multiply(a.points[l],r);if(!a.shape.parent&&u.length>0){a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884);for(l=0;l<u.length;l++)a.shape.graphics.lineTo(u[l].x,u[l].y);a.shape.graphics.endFill(),p(a,h)}break;case t.TmxObjectType.text:a.textField.parent||(a.textField.x=h.x,a.textField.y=h.y,i.addChild(a.textField),a.textField.text=a.text.value,a.textField.textColor=a.text.color,a.textField.bold=null!=a.text.bold&&a.text.bold,a.textField.italic=null!=a.text.italic&&a.text.italic,a.textField.size=a.text.pixelSize,a.textField.fontFamily=a.text.fontFamily)}}}function p(e,n){i&&t.Core.debugRenderEndabled&&!e.textField.parent&&e.name&&(e.textField.text=e.name,e.textField.size=12,e.textField.fontFamily="sans-serif",e.shape?(e.textField.x=n.x+(e.shape.getBounds().width-e.textField.width)/2+e.shape.getBounds().x,e.textField.y=n.y-e.textField.height-5+e.shape.getBounds().y):(e.textField.x=n.x+(e.width-e.textField.width)/2,e.textField.y=n.y-e.textField.height-5),e.textField.background=!0,e.textField.backgroundColor=10526884,e.textField.textColor=16777215,i.addChild(e.textField))}},i.renderTilesetTile=function(t,i,n,r,o,s){var a=t.map.getTilesetForTileGid(i.tile.gid),h=a.tileRegions.get(i.tile.gid);if(n)if(a.image){i.tile.horizontalFlip&&i.tile.verticalFlip?(r.x+=a.tileHeight+(h.height*o.y-a.tileHeight),r.y-=h.width*o.x-a.tileWidth):i.tile.horizontalFlip?r.x+=a.tileWidth+(h.height*o.y-a.tileHeight):i.tile.verticalFlip?r.y+=a.tileWidth-h.width*o.x:r.y+=a.tileHeight-h.height*o.y,(c=a.image.bitmap.getTexture(""+i.tile.gid))||(c=a.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),a.image.texture=new e(c),n.addChild(a.image.texture),a.image.texture.x=r.x,a.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=-1):i.tile.verticalFlip?(a.image.texture.scaleX=o.x,a.image.texture.scaleY=-1):i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=o.y):(a.image.texture.scaleX=o.x,a.image.texture.scaleY=o.y),a.image.texture.anchorOffsetX=0,a.image.texture.anchorOffsetY=0,s(i,r)}else{var c,u=a.tiles.get(i.tile.gid);(c=u.image.bitmap.getTexture(""+i.tile.gid))||(c=u.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),r.y-=i.height,u.image.texture=new e(c),n.addChild(u.image.texture),u.image.texture.width=i.width,u.image.texture.height=i.height,u.image.texture.x=r.x,u.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=-1):i.tile.verticalFlip?(u.image.texture.scaleX=o.x,u.image.texture.scaleY=-1):i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=o.y):(u.image.texture.scaleX=o.x,u.image.texture.scaleY=o.y),u.image.texture.anchorOffsetX=0,u.image.texture.anchorOffsetY=0}},i.renderGroup=function(e,i,n,r,o){var s=this;e.visible&&e.layers.forEach(function(e){e instanceof t.TmxGroup&&s.renderGroup(e,i,n,r,o),e instanceof t.TmxObjectGroup&&s.renderObjectGroup(e,i,n,r,o),e instanceof t.TmxLayer&&s.renderLayer(e,i,n,r,o),e instanceof t.TmxImageLayer&&s.renderImageLayer(e,i,n,r,o)})},i.renderTile=function(i,n,r,o,s,a,h,c){var u=i.gid,l=i.tilesetTile;l&&l.animationFrames.length>0&&(u=l.currentAnimationFrameGid);var p=i.tileset.tileRegions.get(u),d=Math.floor(i.x)*s,f=Math.floor(i.y)*a;i.horizontalFlip&&i.verticalFlip?(d+=a+(p.height*o.y-a),f-=p.width*o.x-s):i.horizontalFlip?d+=s+(p.height*o.y-a):i.verticalFlip?f+=s-p.width*o.x:f+=a-p.height*o.y;var g=new t.Vector2(d,f).add(r);if(i.tileset.image){if(n){var m=i.tileset.image.bitmap.getTexture(""+u);m||(m=i.tileset.image.bitmap.createTexture(""+u,p.x,p.y,p.width,p.height)),i.tileset.image.texture=new e(m),n.addChild(i.tileset.image.texture),i.tileset.image.texture.x!=g.x&&(i.tileset.image.texture.x=g.x),i.tileset.image.texture.y!=g.y&&(i.tileset.image.texture.y=g.y),i.verticalFlip&&i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=-1):i.verticalFlip?(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=-1):i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=o.y):(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=o.y),0!=i.tileset.image.texture.rotation&&(i.tileset.image.texture.rotation=0),0!=i.tileset.image.texture.anchorOffsetX&&(i.tileset.image.texture.anchorOffsetX=0),0!=i.tileset.image.texture.anchorOffsetY&&(i.tileset.image.texture.anchorOffsetY=0)}}else l.image.texture&&(l.image.bitmap.getTexture(u.toString())||(l.image.texture=new e(l.image.bitmap.createTexture(u.toString(),p.x,p.y,p.width,p.height)),n.addChild(l.image.texture)),l.image.texture.x=g.x,l.image.texture.y=g.y,l.image.texture.scaleX=o.x,l.image.texture.scaleY=o.y,l.image.texture.rotation=0,l.image.texture.anchorOffsetX=0,l.image.texture.anchorOffsetY=0,l.image.texture.filters=[h])},i}();t.TiledRendering=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.update=function(){this.tiles.forEach(function(t){t.updateAnimatedTiles()})},e}(t.TmxDocument);t.TmxTileset=e;var i=function(){return function(){}}();t.TmxTileOffset=i;var n=function(){return function(){}}();t.TmxTerrain=n}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"currentAnimationFrameGid",{get:function(){return this.animationFrames[this._animationCurrentFrame].gid+this.tileset.firstGid},enumerable:!0,configurable:!0}),e.prototype.processProperties=function(){var t;(t=this.properties.get("engine.isDestructable"))&&(this.isDestructable=Boolean(t)),(t=this.properties.get("engine:isSlope"))&&(this.isSlope=Boolean(t)),(t=this.properties.get("engine:isOneWayPlatform"))&&(this.isOneWayPlatform=Boolean(t)),(t=this.properties.get("engine:slopeTopLeft"))&&(this.slopeTopLeft=Number(t)),(t=this.properties.get("engine:slopeTopRight"))&&(this.slopeTopRight=Number(t))},e.prototype.updateAnimatedTiles=function(){0!=this.animationFrames.length&&(this._animationElapsedTime+=t.Time.deltaTime,this._animationElapsedTime>this.animationFrames[this._animationCurrentFrame].duration&&(this._animationCurrentFrame=t.MathHelper.incrementWithWrap(this._animationCurrentFrame,this.animationFrames.length),this._animationElapsedTime=0))},e}();t.TmxTilesetTile=e;var i=function(){return function(){}}();t.TmxAnimationFrame=i}(es||(es={})),function(t){var e=function(){function e(){}return e.decode=function(e,i,n){switch(n=n||"none",i=i||"none"){case"base64":var r=t.Base64Utils.decodeBase64AsArray(e,4);return"none"===n?r:t.Base64Utils.decompress(e,r,n);case"csv":return t.Base64Utils.decodeCSV(e);case"none":for(var o=[],s=0;s<e.length;s++)o[s]=+e[s].gid;return o;default:throw new Error("未定义的编码:"+i)}},e.color16ToUnit=function(t){if(!t)return 16777215;var e="0x"+t.slice(1);return parseInt(e,16)},e}();t.TmxUtils=e}(es||(es={}));var ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,i=0;i<t.length;i++){e=!1;for(var n=t.length-1;n>i;n--)if(t[n]<t[n-1]){var r=t[n];t[n]=t[n-1],t[n-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,i=1;i<e;i++){for(var n=t[i],r=i;r>0&&t[r-1]>n;r--)t[r]=t[r-1];t[r]=n}},t.binarySearch=function(t,e){for(var i=0,n=t.length,r=i+n>>1;i<n;)e<=t[r]?n=r:e>=t[r]&&(i=r+1),r=i+n>>1;return t[i]==e?i:-1},t.findElementIndex=function(t,e){for(var i=t.length,n=0;n<i;++n)if(t[n]==e)return n;return null},t.getMaxElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]>t[e]&&(e=n);return e},t.getMinElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]<t[e]&&(e=n);return e},t.getUniqueAry=function(t){for(var e=[],i=[],n=t.length,r=0;r<n;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(n=e.length)-1;r>=0;--r)i.unshift(e[r]);return i},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var i=t.concat(e),n={},r=[],o=i.length,s=0;s<o;++s)n[i[s]]?n[i[s]]instanceof Object&&n[i[s]].count++:(n[i[s]]={},n[i[s]].count=0,n[i[s]].key=i[s],n[i[s]].count++);for(var a in n)2!=n[a].count&&r.unshift(n[a].key);return r},t.swap=function(t,e,i){var n=t[e];t[e]=t[i],t[i]=n},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var i=t.length;if(i!=e.length)return!1;for(;i--;)if(t[i]!=e[i])return!1;return!0},t.insert=function(t,e,i){if(!t)return null;var n=t.length;if(e>n&&(e=n),e<0&&(e=0),e==n)t.push(i);else if(0==e)t.unshift(i);else{for(var r=n-1;r>=e;r-=1)t[r+1]=t[r];t[e]=i}return i},t}();!function(t){var e=function(){function t(){}return Object.defineProperty(t,"nativeBase64",{get:function(){return"function"==typeof window.atob},enumerable:!0,configurable:!0}),t.decode=function(t){if(t=t.replace(/[^A-Za-z0-9\+\/\=]/g,""),this.nativeBase64)return window.atob(t);for(var e,i,n,r,o,s,a=[],h=0;h<t.length;)e=this._keyStr.indexOf(t.charAt(h++))<<2|(r=this._keyStr.indexOf(t.charAt(h++)))>>4,i=(15&r)<<4|(o=this._keyStr.indexOf(t.charAt(h++)))>>2,n=(3&o)<<6|(s=this._keyStr.indexOf(t.charAt(h++))),a.push(String.fromCharCode(e)),64!==o&&a.push(String.fromCharCode(i)),64!==s&&a.push(String.fromCharCode(n));return a=a.join("")},t.encode=function(t){if(t=t.replace(/\r\n/g,"\n"),!this.nativeBase64){for(var e,i,n,r,o,s,a,h=[],c=0;c<t.length;)r=(e=t.charCodeAt(c++))>>2,o=(3&e)<<4|(i=t.charCodeAt(c++))>>4,s=(15&i)<<2|(n=t.charCodeAt(c++))>>6,a=63&n,isNaN(i)?s=a=64:isNaN(n)&&(a=64),h.push(this._keyStr.charAt(r)),h.push(this._keyStr.charAt(o)),h.push(this._keyStr.charAt(s)),h.push(this._keyStr.charAt(a));return h=h.join("")}window.btoa(t)},t.decodeBase64AsArray=function(e,i){i=i||1;var n,r,o,s=t.decode(e),a=new Uint32Array(s.length/i);for(n=0,o=s.length/i;n<o;n++)for(a[n]=0,r=i-1;r>=0;--r)a[n]+=s.charCodeAt(n*i+r)<<(r<<3);return a},t.decompress=function(t,e,i){throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!")},t.decodeCSV=function(t){for(var e=t.replace("\n","").trim().split(","),i=[],n=0;n<e.length;n++)i.push(+e[n]);return i},t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",t}();t.Base64Utils=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r){if(0!=(4294967040&(e|i|n|r))){var o=t.MathHelper.clamp(e,0,255),s=t.MathHelper.clamp(i,0,255),a=t.MathHelper.clamp(n,0,255),h=t.MathHelper.clamp(r,0,255);this._packedValue=h<<24|a<<16|s<<8|o}else this._packedValue=r<<24|n<<16|i<<8|e}return Object.defineProperty(e.prototype,"b",{get:function(){return this._packedValue>>16},set:function(t){this._packedValue=4278255615&this._packedValue|t<<16},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"g",{get:function(){return this._packedValue>>8},set:function(t){this._packedValue=4294902015&this._packedValue|t<<8},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"r",{get:function(){return this._packedValue},set:function(t){this._packedValue=4294967040&this._packedValue|t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"a",{get:function(){return this._packedValue>>24},set:function(t){this._packedValue=16777215&this._packedValue|t<<24},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedValue",{get:function(){return this._packedValue},set:function(t){this._packedValue=t},enumerable:!0,configurable:!0}),e.prototype.equals=function(t){return this._packedValue==t._packedValue},e}();t.Color=e}(es||(es={})),function(t){var e=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var i=this;return void 0===e&&(e=!0),new Promise(function(n,r){var o=i.loadedAssets.get(t);o?n(o):e?RES.getResAsync(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}();t.ContentManager=e}(es||(es={})),function(t){var e=function(){function t(){}return t.getColorMatrix=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];return e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255,new egret.ColorMatrixFilter(e)},t}();t.DrawUtils=e}(es||(es={})),function(t){var e=function(){function e(){}return e.oppositeEdge=function(e){switch(e){case t.Edge.bottom:return t.Edge.top;case t.Edge.top:return t.Edge.bottom;case t.Edge.left:return t.Edge.right;case t.Edge.right:return t.Edge.left}},e.isHorizontal=function(e){return e==t.Edge.right||e==t.Edge.left},e.isVertical=function(e){return e==t.Edge.top||e==t.Edge.bottom},e}();t.EdgeExt=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.func=t,this.context=e}}();t.FuncPack=e;var i=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,i,n){var r=this._messageTable.get(t);r||(r=[],this._messageTable.set(t,r)),-1!=r.findIndex(function(t){return t.func==i})&&console.warn("您试图添加相同的观察者两次"),r.push(new e(i,n))},t.prototype.removeObserver=function(t,e){var i=this._messageTable.get(t),n=i.findIndex(function(t){return t.func==e});-1!=n&&i.removeAt(n)},t.prototype.emit=function(t,e){var i=this._messageTable.get(t);if(i)for(var n=i.length-1;n>=0;n--)i[n].func.call(i[n].context,e)},t}();t.Emitter=i}(es||(es={})),function(t){!function(t){t[t.top=0]="top",t[t.bottom=1]="bottom",t[t.left=2]="left",t[t.right=3]="right"}(t.Edge||(t.Edge={}))}(es||(es={})),function(t){var e=function(){function t(){}return t.repeat=function(t,e){for(var i=[];e--;)i.push(t);return i},t}();t.Enumerable=e}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t}();t.GlobalManager=e}(es||(es={})),function(t){var e=function(){function e(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),e.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},e}();t.TouchState=e;var i=function(){function i(){}return Object.defineProperty(i,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(i,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(i,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:t.Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(i,"maxSupportedTouch",{get:function(){return t.Core._instance.stage.maxTouches},set:function(e){t.Core._instance.stage.maxTouches=e,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPositionDelta",{get:function(){var e=t.Vector2.subtract(this.touchPosition,this._previousTouchState.position);return e.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),e},enumerable:!0,configurable:!0}),i.initialize=function(){this._init||(this._init=!0,t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},i.scaledPosition=function(e){var i=new t.Vector2(e.x-this._resolutionOffset.x,e.y-this._resolutionOffset.y);return t.Vector2.multiply(i,this.resolutionScale)},i.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new e)},i.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},i.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var i=this._gameTouchs[e];i.x=t.stageX,i.y=t.stageY}},i.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},i.setpreviousTouchState=function(t){this._previousTouchState=new e,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},i._init=!1,i._previousTouchState=new e,i._resolutionOffset=new t.Vector2,i._touchIndex=0,i._gameTouchs=[],i._resolutionScale=t.Vector2.one,i._totalTouchCount=0,i}();t.Input=i}(es||(es={}));var KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.registerKey=function(t,e,i,n){void 0===n&&(n=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(n?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:i}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),i=this.keyDownDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),i=this.keyUpDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}();!function(t){var e=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}();t.ListPool=e}(es||(es={}));var THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y",this.setItem=egret.localStorage.setItem.bind(localStorage),this.getItem=egret.localStorage.getItem.bind(localStorage),this.removeItem=egret.localStorage.removeItem.bind(localStorage)}return t.prototype.lock=function(){var t=this;return new Promise(function(e,i){var n=function(){t.setItem(t._keyX,THREAD_ID),null===!t.getItem(t._keyY)&&nextTick(n),t.setItem(t._keyY,THREAD_ID),t.getItem(t._keyX)!==THREAD_ID?setTimeout(function(){t.getItem(t._keyY)===THREAD_ID?(e(),t.removeItem(t._keyY)):nextTick(n)},10):(e(),t.removeItem(t._keyY))};n()})},t}();!function(t){var e=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}();t.Pair=e}(es||(es={}));var RandomUtils=function(){function t(){}return t.randrange=function(t,e,i){if(void 0===i&&(i=1),0==i)throw new Error("step 不能为 0");var n=e-t;if(0==n)throw new Error("没有可用的范围("+t+","+e+")");n<0&&(n=t-e);var r=Math.floor((n+i-1)/i);return Math.floor(this.random()*r)*i+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var i=t.length;if(e<=0||i<e)throw new Error("采样数量不够");for(var n=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*i);r.indexOf(s)>=0;)s=Math.floor(this.random()*i);n.push(t[s]),r.push(s)}return n},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t}();!function(t){var e=function(){function e(){}return e.getSide=function(e,i){switch(i){case t.Edge.top:return e.top;case t.Edge.bottom:return e.bottom;case t.Edge.left:return e.left;case t.Edge.right:return e.right}},e.union=function(e,i){var n=new t.Rectangle(i.x,i.y,0,0),r=new t.Rectangle;return r.x=Math.min(e.x,n.x),r.y=Math.min(e.y,n.y),r.width=Math.max(e.right,n.right)-r.x,r.height=Math.max(e.bottom,r.bottom)-r.y,r},e.getHalfRect=function(e,i){switch(i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,e.height/2);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height/2,e.width,e.height/2);case t.Edge.left:return new t.Rectangle(e.x,e.y,e.width/2,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width/2,e.y,e.width/2,e.height)}},e.getRectEdgePortion=function(e,i,n){switch(void 0===n&&(n=1),i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,n);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height-n,e.width,n);case t.Edge.left:return new t.Rectangle(e.x,e.y,n,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width-n,e.y,n,e.height)}},e.expandSide=function(e,i,n){switch(n=Math.abs(n),i){case t.Edge.top:e.y-=n,e.height+=n;break;case t.Edge.bottom:e.height+=n;break;case t.Edge.left:e.x-=n,e.width+=n;break;case t.Edge.right:e.width+=n}},e.contract=function(t,e,i){t.x+=e,t.y+=i,t.width-=2*e,t.height-=2*i},e}();t.RectangleExt=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.update=function(t){this.remainder+=t;var e=Math.trunc(this.remainder);return this.remainder-=e,e},t.prototype.reset=function(){this.remainder=0},t}();t.SubpixelNumber=e}(es||(es={})),function(t){var e=function(){function e(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return e.testPointTriangle=function(e,i,n,r){return!(t.Vector2Ext.cross(t.Vector2.subtract(e,i),t.Vector2.subtract(n,i))<0)&&(!(t.Vector2Ext.cross(t.Vector2.subtract(e,n),t.Vector2.subtract(r,n))<0)&&!(t.Vector2Ext.cross(t.Vector2.subtract(e,r),t.Vector2.subtract(i,r))<0))},e.prototype.triangulate=function(i,n){void 0===n&&(n=!0);var r=i.length;this.initialize(r);for(var o=0,s=0;r>3&&o<500;){o++;var a=!0,h=i[this._triPrev[s]],c=i[s],u=i[this._triNext[s]];if(t.Vector2Ext.isTriangleCCW(h,c,u)){var l=this._triNext[this._triNext[s]];do{if(e.testPointTriangle(i[l],h,c,u)){a=!1;break}l=this._triNext[l]}while(l!=this._triPrev[s])}else a=!1;a?(this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),this._triNext[this._triPrev[s]]=this._triNext[s],this._triPrev[this._triNext[s]]=this._triPrev[s],r--,s=this._triPrev[s]):s=this._triNext[s]}this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),n||this.triangleIndices.reverse()},e.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},e}();t.Triangulator=e}(es||(es={})),function(t){var e=function(){function e(){}return e.isTriangleCCW=function(e,i,n){return this.cross(t.Vector2.subtract(i,e),t.Vector2.subtract(n,i))<0},e.cross=function(t,e){return t.y*e.x-t.x*e.y},e.perpendicular=function(e,i){return new t.Vector2(-1*(i.y-e.y),i.x-e.x)},e.normalize=function(e){var i=Math.sqrt(e.x*e.x+e.y*e.y);return i>t.MathHelper.Epsilon?e=t.Vector2.divide(e,new t.Vector2(i)):e.x=e.y=0,e},e.transformA=function(t,e,i,n,r,o){for(var s=0;s<o;s++){var a=t[e+s],h=n[r+s];h.x=a.x*i.m11+a.y*i.m21+i.m31,h.y=a.x*i.m12+a.y*i.m22+i.m32,n[r+s]=h}},e.transformR=function(e,i){var n=e.x*i.m11+e.y*i.m21+i.m31,r=e.x*i.m12+e.y*i.m22+i.m32;return new t.Vector2(n,r)},e.transform=function(t,e,i){this.transformA(t,0,e,i,0,t.length)},e.round=function(e){return new t.Vector2(Math.round(e.x),Math.round(e.y))},e}();t.Vector2Ext=e}(es||(es={}));var stopwatch,WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}();!function(t){var e,i=function(){function i(){this.clientArea=new t.Rectangle(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.safeArea=this.clientArea}return i.prototype.place=function(i,n,r,o){var s=new t.Rectangle(0,0,i.x,i.y);return 0!=(o&e.left)?s.x=this.clientArea.x+this.clientArea.width*n:0!=(o&e.right)?s.x=this.clientArea.x+this.clientArea.width*(1-n)-s.width:0!=(o&e.horizontalCenter)&&(s.x=this.clientArea.x+(this.clientArea.width-s.width)/2+n*this.clientArea.width),0!=(o&e.top)?s.y=this.clientArea.y+this.clientArea.height*r:0!=(o&e.bottom)?s.y=this.clientArea.y+this.clientArea.height*(1-r)-s.height:0!=(o&e.verticalCenter)&&(s.y=this.clientArea.y+(this.clientArea.height-s.height)/2+r*this.clientArea.height),s.left<this.safeArea.left&&(s.x=this.safeArea.left),s.right>this.safeArea.right&&(s.x=this.safeArea.right-s.width),s.top<this.safeArea.top&&(s.y=this.safeArea.top),s.bottom>this.safeArea.bottom&&(s.y=this.safeArea.bottom-s.height),s},i}();t.Layout=i,function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(e=t.Alignment||(t.Alignment={}))}(es||(es={})),function(t){var e,i=function(){function t(t){void 0===t&&(t=n),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(i=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var i=this.getSystemTime();this._startSystemTime=i,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=i,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),n=t};var n=Date.now}(stopwatch||(stopwatch={})),function(t){var e=function(){function e(){this.showLog=!1,this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this._logs=new Array(2);for(var e=0;e<this._logs.length;++e)this._logs[e]=new i;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*t.Core.graphicsDevice.viewport.width,t.Core.emitter.addObserver(t.CoreEvents.GraphicsDeviceReset,this.onGraphicsDeviceReset,this),this.onGraphicsDeviceReset()}return Object.defineProperty(e,"Instance",{get:function(){return this._instance||(this._instance=new e),this._instance},enumerable:!0,configurable:!0}),e.prototype.startFrame=function(){var t=this;new LockUtils(this._frameKey).lock().then(function(){t._updateCount=parseInt(egret.localStorage.getItem(t._frameKey),10),isNaN(t._updateCount)&&(t._updateCount=0);var i=t._updateCount;if(i+=1,egret.localStorage.setItem(t._frameKey,i.toString()),!(t.enabled&&1<i&&i<e.maxSampleFrames)){t._prevLog=t._logs[1&t.frameCount++],t._curLog=t._logs[1&t.frameCount];for(var n=t.stopwacth.getTime(),r=0;r<t._prevLog.bars.length;++r){for(var o=t._prevLog.bars[r],s=t._curLog.bars[r],a=0;a<o.nestCount;++a){var h=o.markerNests[a];o.markers[h].endTime=n,s.markerNests[a]=a,s.markers[a].markerId=o.markers[h].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[h].color}for(h=0;h<o.markCount;++h){var c=o.markers[h].endTime-o.markers[h].beginTime,u=o.markers[h].markerId,l=t.markers[u];l.logs[r].color=o.markers[h].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,c),l.logs[r].max=Math.min(l.logs[r].max,c),l.logs[r].avg+=c,l.logs[r].avg*=.5,l.logs[r].samples++>=e.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=c,l.logs[r].max=c,l.logs[r].avg=c,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}t.stopwacth.reset(),t.stopwacth.start()}})},e.prototype.beginMark=function(t,i,n){var r=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=e.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[n];if(o.markCount>=e.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=e.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(t);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(t,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=i,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},e.prototype.endMark=function(t,i){var n=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=e.maxBars)throw new Error("barIndex argument out of range");var r=n._curLog.bars[i];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=n._markerNameToIdMap.get(t);if(isNaN(o))throw new Error("Marker "+t+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=n.stopwacth.getTime()})},e.prototype.getAverageTime=function(t,i){if(t<0||t>=e.maxBars)throw new Error("barIndex argument out of range");var n=0,r=this._markerNameToIdMap.get(i);return r&&(n=this.markers[r].logs[t].avg),n},e.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},e.prototype.render=function(t,i){if(void 0===t&&(t=this._position),void 0===i&&(i=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var n=0,r=0;this._prevLog.bars.forEach(function(t){t.markCount>0&&(n+=e.barHeight+2*e.barPadding,r=Math.max(r,t.markers[t.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>e.autoAdjustDelay&&(this.sampleFrames=Math.min(e.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);t.y,e.barHeight}},e.prototype.onGraphicsDeviceReset=function(){var i=new t.Layout;this._position=i.place(new t.Vector2(this.width,e.barHeight),0,.01,t.Alignment.bottomCenter).location},e.maxBars=8,e.maxSamples=256,e.maxNestCall=32,e.barHeight=8,e.maxSampleFrames=4,e.logSnapDuration=120,e.barPadding=2,e.autoAdjustDelay=30,e}();t.TimeRuler=e;var i=function(){return function(){this.bars=new Array(e.maxBars),this.bars.fill(new n,0,e.maxBars)}}();t.FrameLog=i;var n=function(){return function(){this.markers=new Array(e.maxSamples),this.markCount=0,this.markerNests=new Array(e.maxNestCall),this.nestCount=0,this.markers.fill(new r,0,e.maxSamples),this.markerNests.fill(0,0,e.maxNestCall)}}();t.MarkerCollection=n;var r=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}();t.Marker=r;var o=function(){return function(t){this.logs=new Array(e.maxBars),this.name=t,this.logs.fill(new s,0,e.maxBars)}}();t.MarkerInfo=o;var s=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();t.MarkerLog=s}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){this.itemsToRaster=[],this.useCache=!1,this.cacheName="",this._sprites=new Map,this.allow4096Textures=!1}return i.prototype.addTextureToPack=function(e,i){this.itemsToRaster.push(new t.TextureToPack(e,i))},i.prototype.process=function(t){return void 0===t&&(t=!1),__awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this.allow4096Textures=t,this.useCache?""==this.cacheName?(console.error("未指定缓存名称"),[2]):[4,RES.getResByUrl(this.cacheName)]:[3,2];case 1:return e.sent()?this.loadPack():this.createPack(),[3,3];case 2:this.createPack(),e.label=3;case 3:return[2]}})})},i.prototype.loadPack=function(){return __awaiter(this,void 0,void 0,function(){var t;return __generator(this,function(e){switch(e.label){case 0:return[4,RES.getResByUrl(this.cacheName)];case 1:return t=e.sent(),this.onProcessCompleted&&this.onProcessCompleted(),[2,t]}})})},i.prototype.createPack=function(){for(var i=[],n=[],r=0,o=this.itemsToRaster;r<o.length;r++){var s=o[r];i.push(new e(s.texture)),n.push(s.id)}for(var a=this.allow4096Textures?4096:2048,h=[],c=0;c<i.length;c++){if(i[c].width>a||i[c].height>a)throw new Error("一个纹理的大小比图集的大小大");h.push(new t.Rectangle(0,0,i[c].width,i[c].height))}for(;h.length>0;){var u=new egret.RenderTexture,l=new t.RectanglePacker(a,a,1);for(c=0;c<h.length;c++)l.insertRectangle(Math.floor(h[c].width),Math.floor(h[c].height),c);if(l.packRectangles(),l.rectangleCount>0){for(var p=new t.IntegerRectangle,d=[],f=[],g=[],m=[],y=0;y<l.rectangleCount;y++){p=l.getRectangle(y,p);var _=l.getRectangleId(y);u.drawToTexture(i[_],new t.Rectangle(p.x,p.y,p.width,p.height)),(D=new t.TextureAsset).x=p.x,D.y=p.y,D.width=p.width,D.height=p.height,D.name=n[_],d.push(D),f.push(h[_]),g.push(i[_].texture),m.push(n[_])}for(var v=0,b=f;v<b.length;v++){var x=b[v];h.remove(x)}for(var T=function(t){i.removeAll(function(e){return e.texture.hashCode==t.hashCode})},w=0,C=g;w<C.length;w++){T(x=C[w])}for(var S=0,P=m;S<P.length;S++){x=P[S];n.remove(x)}""!=this.cacheName&&(u.saveToFile("image/png",this.cacheName),0);for(var O=0,R=d;O<R.length;O++){var D=R[O];this._sprites.set(D.name,u)}}}this.onProcessCompleted&&this.onProcessCompleted()},i.prototype.dispose=function(){this._sprites.forEach(function(t,e){t.dispose(),RES.destroyRes(e)}),this._sprites.clear()},i.prototype.getTexture=function(t){return this._sprites.get(t)},i}();t.AssetPacker=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Rectangle);t.IntegerRectangle=e}(es||(es={})),function(t){var e=function(){function e(e,i,n){void 0===n&&(n=0),this._width=0,this._height=0,this._padding=8,this._packedWidth=0,this._packedHeight=0,this._insertList=[],this._insertedRectangles=[],this._freeAreas=[],this._newFreeAreas=[],this._sortableSizeStack=[],this._rectangleStack=[],this._outsideRectangle=new t.IntegerRectangle(e+1,i+1,0,0),this.reset(e,i,n)}return Object.defineProperty(e.prototype,"rectangleCount",{get:function(){return this._insertedRectangles.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedWidth",{get:function(){return this._packedWidth},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedHeight",{get:function(){return this._packedHeight},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"padding",{get:function(){return this._padding},enumerable:!0,configurable:!0}),e.prototype.reset=function(t,e,i){for(void 0===i&&(i=0);this._insertedRectangles.length>0;)this.freeRectangle(this._insertedRectangles.pop());for(;this._freeAreas.length>0;)this.freeRectangle(this._freeAreas.pop());for(this._width=t,this._height=e,this._packedWidth=0,this._packedHeight=0,this._freeAreas.push(this.allocateRectangle(0,0,this._width,this._height));this._insertedRectangles.length>0;)this.freeSize(this._insertList.pop());this._padding=i},e.prototype.insertRectangle=function(t,e,i){var n=this.allocateSize(t,e,i);this._insertList.push(n)},e.prototype.packRectangles=function(t){for(void 0===t&&(t=!0),t&&this._insertList.sort(function(t,e){return t.width-e.width});this._insertList.length>0;){var e=this._insertList.pop(),i=e.width,n=e.height,r=this.getFreeAreaIndex(i,n);if(r>=0){var o=this._freeAreas[r],s=this.allocateRectangle(o.x,o.y,i,n);for(s.id=e.id,this.generateNewFreeAreas(s,this._freeAreas,this._newFreeAreas);this._newFreeAreas.length>0;)this._freeAreas.push(this._newFreeAreas.pop());this._insertedRectangles.push(s),s.right>this._packedWidth&&(this._packedWidth=s.right),s.bottom>this._packedHeight&&(this._packedHeight=s.bottom)}this.freeSize(e)}return this.rectangleCount},e.prototype.getRectangle=function(t,e){var i=this._insertedRectangles[t];return e.x=i.x,e.y=i.y,e.width=i.width,e.height=i.height,e},e.prototype.getRectangleId=function(t){return this._insertedRectangles[t].id},e.prototype.generateNewFreeAreas=function(t,e,i){var n=t.x,r=t.y,o=t.right+1+this._padding,s=t.bottom+1+this._padding,a=null;0==this._padding&&(a=t);for(var h=e.length-1;h>=0;h--){var c=e[h];if(!(n>=c.right||o<=c.x||r>=c.bottom||s<=c.y)){null==a&&(a=this.allocateRectangle(t.x,t.y,t.width+this._padding,t.height+this._padding)),this.generateDividedAreas(a,c,i);var u=e.pop();h<e.length&&(e[h]=u)}}null!=a&&a!=t&&this.freeRectangle(a),this.filterSelfSubAreas(i)},e.prototype.filterSelfSubAreas=function(t){for(var e=t.length-1;e>=0;e--)for(var i=t[e],n=t.length-1;n>=0;n--)if(e!=n){var r=t[n];if(i.x>=r.x&&i.y>=r.y&&i.right<=r.right&&i.bottom<=r.bottom){this.freeRectangle(i);var o=t.pop();e<t.length&&(t[e]=o);break}}},e.prototype.generateDividedAreas=function(t,e,i){var n=0,r=e.right-t.right;r>0&&(i.push(this.allocateRectangle(t.right,e.y,r,e.height)),n++);var o=t.x-e.x;o>0&&(i.push(this.allocateRectangle(e.x,e.y,o,e.height)),n++);var s=e.bottom-t.bottom;s>0&&(i.push(this.allocateRectangle(e.x,t.bottom,e.width,s)),n++);var a=t.y-e.y;a>0&&(i.push(this.allocateRectangle(e.x,e.y,e.width,a)),n++),0==n&&(t.width<e.width||t.height<e.height)?i.push(e):this.freeRectangle(e)},e.prototype.getFreeAreaIndex=function(t,e){for(var i=this._outsideRectangle,n=-1,r=t+this._padding,o=e+this._padding,s=this._freeAreas.length-1;s>=0;s--){var a=this._freeAreas[s];if(a.x<this._packedWidth||a.y<this.packedHeight){if(a.x<i.x&&r<=a.width&&o<=a.height){if(n=s,r==a.width&&a.width<=a.height&&a.right<this._width||o==a.height&&a.height<=a.width)break;i=a}}else if(a.x<i.x&&t<=a.width&&e<=a.height){if(n=s,t==a.width&&a.width<=a.height&&a.right<this._width||e==a.height&&a.height<=a.width)break;i=a}}return n},e.prototype.allocateSize=function(e,i,n){if(this._sortableSizeStack.length>0){var r=this._sortableSizeStack.pop();return r.width=e,r.height=i,r.id=n,r}return new t.SortableSize(e,i,n)},e.prototype.freeSize=function(t){this._sortableSizeStack.push(t)},e.prototype.allocateRectangle=function(e,i,n,r){if(this._rectangleStack.length>0){var o=this._rectangleStack.pop();return o.x=e,o.y=i,o.width=n,o.height=r,o.right=e+n,o.bottom=i+r,o}return new t.IntegerRectangle(e,i,n,r)},e.prototype.freeRectangle=function(t){this._rectangleStack.push(t)},e}();t.RectanglePacker=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.width=t,this.height=e,this.id=i}}();t.SortableSize=e}(es||(es={})),function(t){var e=function(){return function(t){this.assets=t}}();t.TextureAssets=e;var i=function(){return function(){}}();t.TextureAsset=i}(es||(es={})),function(t){var e=function(){return function(t,e){this.texture=t,this.id=e}}();t.TextureToPack=e}(es||(es={}));
\ No newline at end of file
diff --git a/demo/libs/modules/dragonBones/dragonBones.d.ts b/demo/libs/modules/dragonBones/dragonBones.d.ts
new file mode 100644
index 00000000..a2cb345f
--- /dev/null
+++ b/demo/libs/modules/dragonBones/dragonBones.d.ts
@@ -0,0 +1,8471 @@
+declare namespace dragonBones {
+    /**
+     * @internal
+     * @private
+     */
+    const webAssemblyModule: {
+        HEAP16: Int16Array;
+        _malloc(byteSize: number): number;
+        _free(pointer: number): void;
+        setDataBinary(data: DragonBonesData, binaryPointer: number, intBytesLength: number, floatBytesLength: number, frameIntBytesLength: number, frameFloatBytesLength: number, frameBytesLength: number, timelineBytesLength: number): void;
+    };
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    const enum BinaryOffset {
+        WeigthBoneCount = 0,
+        WeigthFloatOffset = 1,
+        WeigthBoneIndices = 2,
+        MeshVertexCount = 0,
+        MeshTriangleCount = 1,
+        MeshFloatOffset = 2,
+        MeshWeightOffset = 3,
+        MeshVertexIndices = 4,
+        TimelineScale = 0,
+        TimelineOffset = 1,
+        TimelineKeyFrameCount = 2,
+        TimelineFrameValueCount = 3,
+        TimelineFrameValueOffset = 4,
+        TimelineFrameOffset = 5,
+        FramePosition = 0,
+        FrameTweenType = 1,
+        FrameTweenEasingOrCurveSampleCount = 2,
+        FrameCurveSamples = 3,
+        DeformVertexOffset = 0,
+        DeformCount = 1,
+        DeformValueCount = 2,
+        DeformValueOffset = 3,
+        DeformFloatOffset = 4,
+        PathVertexCount = 0,
+        PathFloatOffset = 2,
+        PathWeightOffset = 3,
+    }
+    /**
+     * @internal
+     */
+    const enum ArmatureType {
+        Armature = 0,
+        MovieClip = 1,
+        Stage = 2,
+    }
+    /**
+     * @internal
+     */
+    const enum BoneType {
+        Bone = 0,
+        Surface = 1,
+    }
+    /**
+     * @private
+     */
+    const enum DisplayType {
+        Image = 0,
+        Armature = 1,
+        Mesh = 2,
+        BoundingBox = 3,
+        Path = 4,
+    }
+    /**
+     * - Bounding box type.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 边界框类型。
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    const enum BoundingBoxType {
+        Rectangle = 0,
+        Ellipse = 1,
+        Polygon = 2,
+    }
+    /**
+     * @internal
+     */
+    const enum ActionType {
+        Play = 0,
+        Frame = 10,
+        Sound = 11,
+    }
+    /**
+     * @internal
+     */
+    const enum BlendMode {
+        Normal = 0,
+        Add = 1,
+        Alpha = 2,
+        Darken = 3,
+        Difference = 4,
+        Erase = 5,
+        HardLight = 6,
+        Invert = 7,
+        Layer = 8,
+        Lighten = 9,
+        Multiply = 10,
+        Overlay = 11,
+        Screen = 12,
+        Subtract = 13,
+    }
+    /**
+     * @internal
+     */
+    const enum TweenType {
+        None = 0,
+        Line = 1,
+        Curve = 2,
+        QuadIn = 3,
+        QuadOut = 4,
+        QuadInOut = 5,
+    }
+    /**
+     * @internal
+     */
+    const enum TimelineType {
+        Action = 0,
+        ZOrder = 1,
+        BoneAll = 10,
+        BoneTranslate = 11,
+        BoneRotate = 12,
+        BoneScale = 13,
+        Surface = 50,
+        SlotDisplay = 20,
+        SlotColor = 21,
+        SlotDeform = 22,
+        IKConstraint = 30,
+        AnimationTime = 40,
+        AnimationWeight = 41,
+    }
+    /**
+     * - Offset mode.
+     * @version DragonBones 5.5
+     * @language en_US
+     */
+    /**
+     * - 偏移模式。
+     * @version DragonBones 5.5
+     * @language zh_CN
+     */
+    const enum OffsetMode {
+        None = 0,
+        Additive = 1,
+        Override = 2,
+    }
+    /**
+     * - Animation fade out mode.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 动画淡出模式。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    const enum AnimationFadeOutMode {
+        /**
+         * - Do not fade out of any animation states.
+         * @language en_US
+         */
+        /**
+         * - 不淡出任何的动画状态。
+         * @language zh_CN
+         */
+        None = 0,
+        /**
+         * - Fade out the animation states of the same layer.
+         * @language en_US
+         */
+        /**
+         * - 淡出同层的动画状态。
+         * @language zh_CN
+         */
+        SameLayer = 1,
+        /**
+         * - Fade out the animation states of the same group.
+         * @language en_US
+         */
+        /**
+         * - 淡出同组的动画状态。
+         * @language zh_CN
+         */
+        SameGroup = 2,
+        /**
+         * - Fade out the animation states of the same layer and group.
+         * @language en_US
+         */
+        /**
+         * - 淡出同层并且同组的动画状态。
+         * @language zh_CN
+         */
+        SameLayerAndGroup = 3,
+        /**
+         * - Fade out of all animation states.
+         * @language en_US
+         */
+        /**
+         * - 淡出所有的动画状态。
+         * @language zh_CN
+         */
+        All = 4,
+        /**
+         * - Does not replace the animation state with the same name.
+         * @language en_US
+         */
+        /**
+         * - 不替换同名的动画状态。
+         * @language zh_CN
+         */
+        Single = 5,
+    }
+    const enum ConstraintType {
+        IK = 0,
+        Path = 1,
+    }
+    const enum PositionMode {
+        Fixed = 0,
+        Percent = 1,
+    }
+    const enum SpacingMode {
+        Length = 0,
+        Fixed = 1,
+        Percent = 2,
+    }
+    const enum RotateMode {
+        Tangent = 0,
+        Chain = 1,
+        ChainScale = 2,
+    }
+    /**
+     * @private
+     */
+    interface Map<T> {
+        [key: string]: T;
+    }
+    /**
+     * @private
+     */
+    class DragonBones {
+        static readonly VERSION: string;
+        static yDown: boolean;
+        static debug: boolean;
+        static debugDraw: boolean;
+        static webAssembly: boolean;
+        private readonly _clock;
+        private readonly _events;
+        private readonly _objects;
+        private _eventManager;
+        constructor(eventManager: IEventDispatcher);
+        advanceTime(passedTime: number): void;
+        bufferEvent(value: EventObject): void;
+        bufferObject(object: BaseObject): void;
+        readonly clock: WorldClock;
+        readonly eventManager: IEventDispatcher;
+    }
+}
+
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The BaseObject is the base class for all objects in the DragonBones framework.
+     * All BaseObject instances are cached to the object pool to reduce the performance consumption of frequent requests for memory or memory recovery.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 基础对象，通常 DragonBones 的对象都继承自该类。
+     * 所有基础对象的实例都会缓存到对象池，以减少频繁申请内存或内存回收的性能消耗。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    abstract class BaseObject {
+        private static _hashCode;
+        private static _defaultMaxCount;
+        private static readonly _maxCountMap;
+        private static readonly _poolsMap;
+        private static _returnObject(object);
+        static toString(): string;
+        /**
+         * - Set the maximum cache count of the specify object pool.
+         * @param objectConstructor - The specify class. (Set all object pools max cache count if not set)
+         * @param maxCount - Max count.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 设置特定对象池的最大缓存数量。
+         * @param objectConstructor - 特定的类。 (不设置则设置所有对象池的最大缓存数量)
+         * @param maxCount - 最大缓存数量。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static setMaxCount(objectConstructor: (typeof BaseObject) | null, maxCount: number): void;
+        /**
+         * - Clear the cached instances of a specify object pool.
+         * @param objectConstructor - Specify class. (Clear all cached instances if not set)
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除特定对象池的缓存实例。
+         * @param objectConstructor - 特定的类。 (不设置则清除所有缓存的实例)
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static clearPool(objectConstructor?: (typeof BaseObject) | null): void;
+        /**
+         * - Get an instance of the specify class from object pool.
+         * @param objectConstructor - The specify class.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从对象池中获取特定类的实例。
+         * @param objectConstructor - 特定的类。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static borrowObject<T extends BaseObject>(objectConstructor: {
+            new (): T;
+        }): T;
+        /**
+         * - A unique identification number assigned to the object.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 分配给此实例的唯一标识号。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly hashCode: number;
+        private _isInPool;
+        protected abstract _onClear(): void;
+        /**
+         * - Clear the object and return it back to object pool。
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除该实例的所有数据并将其返还对象池。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        returnToPool(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - 2D Transform matrix.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 2D 转换矩阵。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class Matrix {
+        /**
+         * - The value that affects the positioning of pixels along the x axis when scaling or rotating an image.
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 缩放或旋转图像时影响像素沿 x 轴定位的值。
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        a: number;
+        /**
+         * - The value that affects the positioning of pixels along the y axis when rotating or skewing an image.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 旋转或倾斜图像时影响像素沿 y 轴定位的值。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        b: number;
+        /**
+         * - The value that affects the positioning of pixels along the x axis when rotating or skewing an image.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 旋转或倾斜图像时影响像素沿 x 轴定位的值。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        c: number;
+        /**
+         * - The value that affects the positioning of pixels along the y axis when scaling or rotating an image.
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 缩放或旋转图像时影响像素沿 y 轴定位的值。
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        d: number;
+        /**
+         * - The distance by which to translate each point along the x axis.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 沿 x 轴平移每个点的距离。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        tx: number;
+        /**
+         * - The distance by which to translate each point along the y axis.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 沿 y 轴平移每个点的距离。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        ty: number;
+        /**
+         * @private
+         */
+        constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+        toString(): string;
+        /**
+         * @private
+         */
+        copyFrom(value: Matrix): Matrix;
+        /**
+         * @private
+         */
+        copyFromArray(value: Array<number>, offset?: number): Matrix;
+        /**
+         * - Convert to unit matrix.
+         * The resulting matrix has the following properties: a=1, b=0, c=0, d=1, tx=0, ty=0.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 转换为单位矩阵。
+         * 该矩阵具有以下属性：a=1、b=0、c=0、d=1、tx=0、ty=0。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        identity(): Matrix;
+        /**
+         * - Multiplies the current matrix with another matrix.
+         * @param value - The matrix that needs to be multiplied.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将当前矩阵与另一个矩阵相乘。
+         * @param value - 需要相乘的矩阵。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        concat(value: Matrix): Matrix;
+        /**
+         * - Convert to inverse matrix.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 转换为逆矩阵。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        invert(): Matrix;
+        /**
+         * - Apply a matrix transformation to a specific point.
+         * @param x - X coordinate.
+         * @param y - Y coordinate.
+         * @param result - The point after the transformation is applied.
+         * @param delta - Whether to ignore tx, ty's conversion to point.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将矩阵转换应用于特定点。
+         * @param x - 横坐标。
+         * @param y - 纵坐标。
+         * @param result - 应用转换之后的点。
+         * @param delta - 是否忽略 tx，ty 对点的转换。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        transformPoint(x: number, y: number, result: {
+            x: number;
+            y: number;
+        }, delta?: boolean): void;
+        /**
+         * @private
+         */
+        transformRectangle(rectangle: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }, delta?: boolean): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - 2D Transform.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 2D 变换。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class Transform {
+        /**
+         * @private
+         */
+        static readonly PI: number;
+        /**
+         * @private
+         */
+        static readonly PI_D: number;
+        /**
+         * @private
+         */
+        static readonly PI_H: number;
+        /**
+         * @private
+         */
+        static readonly PI_Q: number;
+        /**
+         * @private
+         */
+        static readonly RAD_DEG: number;
+        /**
+         * @private
+         */
+        static readonly DEG_RAD: number;
+        /**
+         * @private
+         */
+        static normalizeRadian(value: number): number;
+        /**
+         * - Horizontal translate.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 水平位移。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        x: number;
+        /**
+         * - Vertical translate.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 垂直位移。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        y: number;
+        /**
+         * - Skew. (In radians)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 倾斜。 （以弧度为单位）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        skew: number;
+        /**
+         * - rotation. (In radians)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 旋转。 （以弧度为单位）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        rotation: number;
+        /**
+         * - Horizontal Scaling.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 水平缩放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        scaleX: number;
+        /**
+         * - Vertical scaling.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 垂直缩放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        scaleY: number;
+        /**
+         * @private
+         */
+        constructor(x?: number, y?: number, skew?: number, rotation?: number, scaleX?: number, scaleY?: number);
+        toString(): string;
+        /**
+         * @private
+         */
+        copyFrom(value: Transform): Transform;
+        /**
+         * @private
+         */
+        identity(): Transform;
+        /**
+         * @private
+         */
+        add(value: Transform): Transform;
+        /**
+         * @private
+         */
+        minus(value: Transform): Transform;
+        /**
+         * @private
+         */
+        fromMatrix(matrix: Matrix): Transform;
+        /**
+         * @private
+         */
+        toMatrix(matrix: Matrix): Transform;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class ColorTransform {
+        alphaMultiplier: number;
+        redMultiplier: number;
+        greenMultiplier: number;
+        blueMultiplier: number;
+        alphaOffset: number;
+        redOffset: number;
+        greenOffset: number;
+        blueOffset: number;
+        constructor(alphaMultiplier?: number, redMultiplier?: number, greenMultiplier?: number, blueMultiplier?: number, alphaOffset?: number, redOffset?: number, greenOffset?: number, blueOffset?: number);
+        copyFrom(value: ColorTransform): void;
+        identity(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The Point object represents a location in a two-dimensional coordinate system.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Point 对象表示二维坐标系统中的某个位置。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class Point {
+        /**
+         * - The horizontal coordinate.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 该点的水平坐标。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        x: number;
+        /**
+         * - The vertical coordinate.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 该点的垂直坐标。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        y: number;
+        /**
+         * - Creates a new point. If you pass no parameters to this method, a point is created at (0,0).
+         * @param x - The horizontal coordinate.
+         * @param y - The vertical coordinate.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建一个 egret.Point 对象.若不传入任何参数，将会创建一个位于（0，0）位置的点。
+         * @param x - 该对象的x属性值，默认为 0.0。
+         * @param y - 该对象的y属性值，默认为 0.0。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        constructor(x?: number, y?: number);
+        /**
+         * @private
+         */
+        copyFrom(value: Point): void;
+        /**
+         * @private
+         */
+        clear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - A Rectangle object is an area defined by its position, as indicated by its top-left corner point (x, y) and by its
+     * width and its height.<br/>
+     * The x, y, width, and height properties of the Rectangle class are independent of each other; changing the value of
+     * one property has no effect on the others. However, the right and bottom properties are integrally related to those
+     * four properties. For example, if you change the value of the right property, the value of the width property changes;
+     * if you change the bottom property, the value of the height property changes.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Rectangle 对象是按其位置（由它左上角的点 (x, y) 确定）以及宽度和高度定义的区域。<br/>
+     * Rectangle 类的 x、y、width 和 height 属性相互独立；更改一个属性的值不会影响其他属性。
+     * 但是，right 和 bottom 属性与这四个属性是整体相关的。例如，如果更改 right 属性的值，则 width
+     * 属性的值将发生变化；如果更改 bottom 属性，则 height 属性的值将发生变化。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class Rectangle {
+        /**
+         * - The x coordinate of the top-left corner of the rectangle.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 矩形左上角的 x 坐标。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        x: number;
+        /**
+         * - The y coordinate of the top-left corner of the rectangle.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 矩形左上角的 y 坐标。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        y: number;
+        /**
+         * - The width of the rectangle, in pixels.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 矩形的宽度（以像素为单位）。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        width: number;
+        /**
+         * - 矩形的高度（以像素为单位）。
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - The height of the rectangle, in pixels.
+         * @default 0.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        height: number;
+        /**
+         * @private
+         */
+        constructor(x?: number, y?: number, width?: number, height?: number);
+        /**
+         * @private
+         */
+        copyFrom(value: Rectangle): void;
+        /**
+         * @private
+         */
+        clear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The user custom data.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 用户自定义数据。
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    class UserData extends BaseObject {
+        static toString(): string;
+        /**
+         * - The custom int numbers.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 自定义整数。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        readonly ints: Array<number>;
+        /**
+         * - The custom float numbers.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 自定义浮点数。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        readonly floats: Array<number>;
+        /**
+         * - The custom strings.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 自定义字符串。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        readonly strings: Array<string>;
+        protected _onClear(): void;
+        /**
+         * @internal
+         */
+        addInt(value: number): void;
+        /**
+         * @internal
+         */
+        addFloat(value: number): void;
+        /**
+         * @internal
+         */
+        addString(value: string): void;
+        /**
+         * - Get the custom int number.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 获取自定义整数。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        getInt(index?: number): number;
+        /**
+         * - Get the custom float number.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 获取自定义浮点数。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        getFloat(index?: number): number;
+        /**
+         * - Get the custom string.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 获取自定义字符串。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        getString(index?: number): string;
+    }
+    /**
+     * @internal
+     */
+    class ActionData extends BaseObject {
+        static toString(): string;
+        type: ActionType;
+        name: string;
+        bone: BoneData | null;
+        slot: SlotData | null;
+        data: UserData | null;
+        protected _onClear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The DragonBones data.
+     * A DragonBones data contains multiple armature data.
+     * @see dragonBones.ArmatureData
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 龙骨数据。
+     * 一个龙骨数据包含多个骨架数据。
+     * @see dragonBones.ArmatureData
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class DragonBonesData extends BaseObject {
+        static toString(): string;
+        /**
+         * @private
+         */
+        autoSearch: boolean;
+        /**
+         * - The animation frame rate.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画帧频。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        frameRate: number;
+        /**
+         * - The data version.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 数据版本。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        version: string;
+        /**
+         * - The DragonBones data name.
+         * The name is consistent with the DragonBones project name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 龙骨数据名称。
+         * 该名称与龙骨项目名保持一致。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * @private
+         */
+        stage: ArmatureData | null;
+        /**
+         * @internal
+         */
+        readonly frameIndices: Array<number>;
+        /**
+         * @internal
+         */
+        readonly cachedFrames: Array<number>;
+        /**
+         * - All armature data names.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 所有的骨架数据名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly armatureNames: Array<string>;
+        /**
+         * @private
+         */
+        readonly armatures: Map<ArmatureData>;
+        /**
+         * @internal
+         */
+        binary: ArrayBuffer;
+        /**
+         * @internal
+         */
+        intArray: Int16Array;
+        /**
+         * @internal
+         */
+        floatArray: Float32Array;
+        /**
+         * @internal
+         */
+        frameIntArray: Int16Array;
+        /**
+         * @internal
+         */
+        frameFloatArray: Float32Array;
+        /**
+         * @internal
+         */
+        frameArray: Int16Array;
+        /**
+         * @internal
+         */
+        timelineArray: Uint16Array;
+        /**
+         * @private
+         */
+        userData: UserData | null;
+        protected _onClear(): void;
+        /**
+         * @internal
+         */
+        addArmature(value: ArmatureData): void;
+        /**
+         * - Get a specific armature data.
+         * @param armatureName - The armature data name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨架数据。
+         * @param armatureName - 骨架数据名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getArmature(armatureName: string): ArmatureData | null;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.BaseFactory#removeDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.BaseFactory#removeDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        dispose(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The armature data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨架数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class ArmatureData extends BaseObject {
+        static toString(): string;
+        /**
+         * @private
+         */
+        type: ArmatureType;
+        /**
+         * - The animation frame rate.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画帧率。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        frameRate: number;
+        /**
+         * @private
+         */
+        cacheFrameRate: number;
+        /**
+         * @private
+         */
+        scale: number;
+        /**
+         * - The armature name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 骨架名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * @private
+         */
+        readonly aabb: Rectangle;
+        /**
+         * - The names of all the animation data.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 所有的动画数据名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly animationNames: Array<string>;
+        /**
+         * @private
+         */
+        readonly sortedBones: Array<BoneData>;
+        /**
+         * @private
+         */
+        readonly sortedSlots: Array<SlotData>;
+        /**
+         * @private
+         */
+        readonly defaultActions: Array<ActionData>;
+        /**
+         * @private
+         */
+        readonly actions: Array<ActionData>;
+        /**
+         * @private
+         */
+        readonly bones: Map<BoneData>;
+        /**
+         * @private
+         */
+        readonly slots: Map<SlotData>;
+        /**
+         * @private
+         */
+        readonly constraints: Map<ConstraintData>;
+        /**
+         * @private
+         */
+        readonly skins: Map<SkinData>;
+        /**
+         * @private
+         */
+        readonly animations: Map<AnimationData>;
+        /**
+         * - The default skin data.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 默认插槽数据。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        defaultSkin: SkinData | null;
+        /**
+         * - The default animation data.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 默认动画数据。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        defaultAnimation: AnimationData | null;
+        /**
+         * @private
+         */
+        canvas: CanvasData | null;
+        /**
+         * @private
+         */
+        userData: UserData | null;
+        /**
+         * @private
+         */
+        parent: DragonBonesData;
+        protected _onClear(): void;
+        /**
+         * @internal
+         */
+        sortBones(): void;
+        /**
+         * @internal
+         */
+        cacheFrames(frameRate: number): void;
+        /**
+         * @internal
+         */
+        setCacheFrame(globalTransformMatrix: Matrix, transform: Transform): number;
+        /**
+         * @internal
+         */
+        getCacheFrame(globalTransformMatrix: Matrix, transform: Transform, arrayOffset: number): void;
+        /**
+         * @internal
+         */
+        addBone(value: BoneData): void;
+        /**
+         * @internal
+         */
+        addSlot(value: SlotData): void;
+        /**
+         * @internal
+         */
+        addConstraint(value: ConstraintData): void;
+        /**
+         * @internal
+         */
+        addSkin(value: SkinData): void;
+        /**
+         * @internal
+         */
+        addAnimation(value: AnimationData): void;
+        /**
+         * @internal
+         */
+        addAction(value: ActionData, isDefault: boolean): void;
+        /**
+         * - Get a specific done data.
+         * @param boneName - The bone name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨骼数据。
+         * @param boneName - 骨骼名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getBone(boneName: string): BoneData | null;
+        /**
+         * - Get a specific slot data.
+         * @param slotName - The slot name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的插槽数据。
+         * @param slotName - 插槽名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getSlot(slotName: string): SlotData | null;
+        /**
+         * @private
+         */
+        getConstraint(constraintName: string): ConstraintData | null;
+        /**
+         * - Get a specific skin data.
+         * @param skinName - The skin name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定皮肤数据。
+         * @param skinName - 皮肤名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getSkin(skinName: string): SkinData | null;
+        /**
+         * @private
+         */
+        getMesh(skinName: string, slotName: string, meshName: string): MeshDisplayData | null;
+        /**
+         * - Get a specific animation data.
+         * @param animationName - The animation animationName.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的动画数据。
+         * @param animationName - 动画名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getAnimation(animationName: string): AnimationData | null;
+    }
+    /**
+     * - The bone data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨骼数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class BoneData extends BaseObject {
+        static toString(): string;
+        /**
+         * @private
+         */
+        inheritTranslation: boolean;
+        /**
+         * @private
+         */
+        inheritRotation: boolean;
+        /**
+         * @private
+         */
+        inheritScale: boolean;
+        /**
+         * @private
+         */
+        inheritReflection: boolean;
+        /**
+         * @private
+         */
+        type: BoneType;
+        /**
+         * - The bone length.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 骨骼长度。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        length: number;
+        /**
+         * - The bone name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 骨骼名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * @private
+         */
+        readonly transform: Transform;
+        /**
+         * @private
+         */
+        userData: UserData | null;
+        /**
+         * - The parent bone data.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 父骨骼数据。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        parent: BoneData | null;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class SurfaceData extends BoneData {
+        static toString(): string;
+        segmentX: number;
+        segmentY: number;
+        readonly vertices: Array<number>;
+        protected _onClear(): void;
+    }
+    /**
+     * - The slot data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 插槽数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class SlotData extends BaseObject {
+        /**
+         * @internal
+         */
+        static readonly DEFAULT_COLOR: ColorTransform;
+        /**
+         * @internal
+         */
+        static createColor(): ColorTransform;
+        static toString(): string;
+        /**
+         * @private
+         */
+        blendMode: BlendMode;
+        /**
+         * @private
+         */
+        displayIndex: number;
+        /**
+         * @private
+         */
+        zOrder: number;
+        /**
+         * - The slot name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 插槽名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * @private
+         */
+        color: ColorTransform;
+        /**
+         * @private
+         */
+        userData: UserData | null;
+        /**
+         * - The parent bone data.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 父骨骼数据。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        parent: BoneData;
+        protected _onClear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class CanvasData extends BaseObject {
+        static toString(): string;
+        hasBackground: boolean;
+        color: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        protected _onClear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The skin data, typically a armature data instance contains at least one skinData.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 皮肤数据，通常一个骨架数据至少包含一个皮肤数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class SkinData extends BaseObject {
+        static toString(): string;
+        /**
+         * - The skin name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 皮肤名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * @private
+         */
+        readonly displays: Map<Array<DisplayData | null>>;
+        /**
+         * @private
+         */
+        parent: ArmatureData;
+        protected _onClear(): void;
+        /**
+         * @internal
+         */
+        addDisplay(slotName: string, value: DisplayData | null): void;
+        /**
+         * @private
+         */
+        getDisplay(slotName: string, displayName: string): DisplayData | null;
+        /**
+         * @private
+         */
+        getDisplays(slotName: string): Array<DisplayData | null> | null;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    abstract class ConstraintData extends BaseObject {
+        order: number;
+        name: string;
+        type: ConstraintType;
+        target: BoneData;
+        root: BoneData;
+        bone: BoneData | null;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class IKConstraintData extends ConstraintData {
+        static toString(): string;
+        scaleEnabled: boolean;
+        bendPositive: boolean;
+        weight: number;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class PathConstraintData extends ConstraintData {
+        static toString(): string;
+        pathSlot: SlotData;
+        pathDisplayData: PathDisplayData;
+        bones: Array<BoneData>;
+        positionMode: PositionMode;
+        spacingMode: SpacingMode;
+        rotateMode: RotateMode;
+        position: number;
+        spacing: number;
+        rotateOffset: number;
+        rotateMix: number;
+        translateMix: number;
+        protected _onClear(): void;
+        AddBone(value: BoneData): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class VerticesData {
+        isShared: boolean;
+        inheritDeform: boolean;
+        offset: number;
+        data: DragonBonesData;
+        weight: WeightData | null;
+        clear(): void;
+        shareFrom(value: VerticesData): void;
+    }
+    /**
+     * @internal
+     */
+    abstract class DisplayData extends BaseObject {
+        type: DisplayType;
+        name: string;
+        path: string;
+        readonly transform: Transform;
+        parent: SkinData;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class ImageDisplayData extends DisplayData {
+        static toString(): string;
+        readonly pivot: Point;
+        texture: TextureData | null;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class ArmatureDisplayData extends DisplayData {
+        static toString(): string;
+        inheritAnimation: boolean;
+        readonly actions: Array<ActionData>;
+        armature: ArmatureData | null;
+        protected _onClear(): void;
+        /**
+         * @private
+         */
+        addAction(value: ActionData): void;
+    }
+    /**
+     * @internal
+     */
+    class MeshDisplayData extends DisplayData {
+        static toString(): string;
+        readonly vertices: VerticesData;
+        texture: TextureData | null;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class BoundingBoxDisplayData extends DisplayData {
+        static toString(): string;
+        boundingBox: BoundingBoxData | null;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class PathDisplayData extends DisplayData {
+        static toString(): string;
+        closed: boolean;
+        constantSpeed: boolean;
+        readonly vertices: VerticesData;
+        readonly curveLengths: Array<number>;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class WeightData extends BaseObject {
+        static toString(): string;
+        count: number;
+        offset: number;
+        readonly bones: Array<BoneData>;
+        protected _onClear(): void;
+        addBone(value: BoneData): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The base class of bounding box data.
+     * @see dragonBones.RectangleData
+     * @see dragonBones.EllipseData
+     * @see dragonBones.PolygonData
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 边界框数据基类。
+     * @see dragonBones.RectangleData
+     * @see dragonBones.EllipseData
+     * @see dragonBones.PolygonData
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    abstract class BoundingBoxData extends BaseObject {
+        /**
+         * - The bounding box type.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 边界框类型。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        type: BoundingBoxType;
+        /**
+         * @private
+         */
+        color: number;
+        /**
+         * @private
+         */
+        width: number;
+        /**
+         * @private
+         */
+        height: number;
+        protected _onClear(): void;
+        /**
+         * - Check whether the bounding box contains a specific point. (Local coordinate system)
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查边界框是否包含特定点。（本地坐标系）
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        abstract containsPoint(pX: number, pY: number): boolean;
+        /**
+         * - Check whether the bounding box intersects a specific segment. (Local coordinate system)
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查边界框是否与特定线段相交。（本地坐标系）
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        abstract intersectsSegment(xA: number, yA: number, xB: number, yB: number, intersectionPointA: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB: {
+            x: number;
+            y: number;
+        } | null, normalRadians: {
+            x: number;
+            y: number;
+        } | null): number;
+    }
+    /**
+     * - The rectangle bounding box data.
+     * @version DragonBones 5.1
+     * @language en_US
+     */
+    /**
+     * - 矩形边界框数据。
+     * @version DragonBones 5.1
+     * @language zh_CN
+     */
+    class RectangleBoundingBoxData extends BoundingBoxData {
+        static toString(): string;
+        /**
+         * - Compute the bit code for a point (x, y) using the clip rectangle
+         */
+        private static _computeOutCode(x, y, xMin, yMin, xMax, yMax);
+        /**
+         * @private
+         */
+        static rectangleIntersectsSegment(xA: number, yA: number, xB: number, yB: number, xMin: number, yMin: number, xMax: number, yMax: number, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): number;
+        protected _onClear(): void;
+        /**
+         * @inheritDoc
+         */
+        containsPoint(pX: number, pY: number): boolean;
+        /**
+         * @inheritDoc
+         */
+        intersectsSegment(xA: number, yA: number, xB: number, yB: number, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): number;
+    }
+    /**
+     * - The ellipse bounding box data.
+     * @version DragonBones 5.1
+     * @language en_US
+     */
+    /**
+     * - 椭圆边界框数据。
+     * @version DragonBones 5.1
+     * @language zh_CN
+     */
+    class EllipseBoundingBoxData extends BoundingBoxData {
+        static toString(): string;
+        /**
+         * @private
+         */
+        static ellipseIntersectsSegment(xA: number, yA: number, xB: number, yB: number, xC: number, yC: number, widthH: number, heightH: number, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): number;
+        protected _onClear(): void;
+        /**
+         * @inheritDoc
+         */
+        containsPoint(pX: number, pY: number): boolean;
+        /**
+         * @inheritDoc
+         */
+        intersectsSegment(xA: number, yA: number, xB: number, yB: number, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): number;
+    }
+    /**
+     * - The polygon bounding box data.
+     * @version DragonBones 5.1
+     * @language en_US
+     */
+    /**
+     * - 多边形边界框数据。
+     * @version DragonBones 5.1
+     * @language zh_CN
+     */
+    class PolygonBoundingBoxData extends BoundingBoxData {
+        static toString(): string;
+        /**
+         * @private
+         */
+        static polygonIntersectsSegment(xA: number, yA: number, xB: number, yB: number, vertices: Array<number>, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): number;
+        /**
+         * @private
+         */
+        x: number;
+        /**
+         * @private
+         */
+        y: number;
+        /**
+         * - The polygon vertices.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 多边形顶点。
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        readonly vertices: Array<number>;
+        protected _onClear(): void;
+        /**
+         * @inheritDoc
+         */
+        containsPoint(pX: number, pY: number): boolean;
+        /**
+         * @inheritDoc
+         */
+        intersectsSegment(xA: number, yA: number, xB: number, yB: number, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): number;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The animation data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 动画数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class AnimationData extends BaseObject {
+        static toString(): string;
+        /**
+         * - FrameIntArray.
+         * @internal
+         */
+        frameIntOffset: number;
+        /**
+         * - FrameFloatArray.
+         * @internal
+         */
+        frameFloatOffset: number;
+        /**
+         * - FrameArray.
+         * @internal
+         */
+        frameOffset: number;
+        /**
+         * - The frame count of the animation.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画的帧数。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        frameCount: number;
+        /**
+         * - The play times of the animation. [0: Loop play, [1~N]: Play N times]
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画的播放次数。 [0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        playTimes: number;
+        /**
+         * - The duration of the animation. (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画的持续时间。 （以秒为单位）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        duration: number;
+        /**
+         * @private
+         */
+        scale: number;
+        /**
+         * - The fade in time of the animation. (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画的淡入时间。 （以秒为单位）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        fadeInTime: number;
+        /**
+         * @private
+         */
+        cacheFrameRate: number;
+        /**
+         * - The animation name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * @private
+         */
+        readonly cachedFrames: Array<boolean>;
+        /**
+         * @private
+         */
+        readonly boneTimelines: Map<Array<TimelineData>>;
+        /**
+         * @private
+         */
+        readonly surfaceTimelines: Map<Array<TimelineData>>;
+        /**
+         * @private
+         */
+        readonly slotTimelines: Map<Array<TimelineData>>;
+        /**
+         * @private
+         */
+        readonly constraintTimelines: Map<Array<TimelineData>>;
+        /**
+         * @private
+         */
+        readonly animationTimelines: Map<Array<TimelineData>>;
+        /**
+         * @private
+         */
+        readonly boneCachedFrameIndices: Map<Array<number>>;
+        /**
+         * @private
+         */
+        readonly slotCachedFrameIndices: Map<Array<number>>;
+        /**
+         * @private
+         */
+        actionTimeline: TimelineData | null;
+        /**
+         * @private
+         */
+        zOrderTimeline: TimelineData | null;
+        /**
+         * @private
+         */
+        parent: ArmatureData;
+        protected _onClear(): void;
+        /**
+         * @internal
+         */
+        cacheFrames(frameRate: number): void;
+        /**
+         * @private
+         */
+        addBoneTimeline(bone: BoneData, timeline: TimelineData): void;
+        /**
+         * @private
+         */
+        addSurfaceTimeline(surface: SurfaceData, timeline: TimelineData): void;
+        /**
+         * @private
+         */
+        addSlotTimeline(slot: SlotData, timeline: TimelineData): void;
+        /**
+         * @private
+         */
+        addConstraintTimeline(constraint: ConstraintData, timeline: TimelineData): void;
+        /**
+         * @private
+         */
+        addAnimationTimeline(timelineName: string, timeline: TimelineData): void;
+        /**
+         * @private
+         */
+        getBoneTimelines(timelineName: string): Array<TimelineData> | null;
+        /**
+         * @private
+         */
+        getSurfaceTimelines(timelineName: string): Array<TimelineData> | null;
+        /**
+         * @private
+         */
+        getSlotTimelines(timelineName: string): Array<TimelineData> | null;
+        /**
+         * @private
+         */
+        getConstraintTimelines(timelineName: string): Array<TimelineData> | null;
+        /**
+         * @private
+         */
+        getAnimationTimelines(timelineName: string): Array<TimelineData> | null;
+        /**
+         * @private
+         */
+        getBoneCachedFrameIndices(boneName: string): Array<number> | null;
+        /**
+         * @private
+         */
+        getSlotCachedFrameIndices(slotName: string): Array<number> | null;
+    }
+    /**
+     * @internal
+     */
+    class TimelineData extends BaseObject {
+        static toString(): string;
+        type: TimelineType;
+        offset: number;
+        frameIndicesOffset: number;
+        protected _onClear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The animation config is used to describe all the information needed to play an animation state.
+     * The API is still in the experimental phase and may encounter bugs or stability or compatibility issues when used.
+     * @see dragonBones.AnimationState
+     * @beta
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 动画配置用来描述播放一个动画状态所需要的全部信息。
+     * 该 API 仍在实验阶段，使用时可能遭遇 bug 或稳定性或兼容性问题。
+     * @see dragonBones.AnimationState
+     * @beta
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    class AnimationConfig extends BaseObject {
+        static toString(): string;
+        /**
+         * @private
+         */
+        pauseFadeOut: boolean;
+        /**
+         * - Fade out the pattern of other animation states when the animation state is fade in.
+         * This property is typically used to specify the substitution of multiple animation states blend.
+         * @default dragonBones.AnimationFadeOutMode.All
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 淡入动画状态时淡出其他动画状态的模式。
+         * 该属性通常用来指定多个动画状态混合时的相互替换关系。
+         * @default dragonBones.AnimationFadeOutMode.All
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        fadeOutMode: AnimationFadeOutMode;
+        /**
+         * @private
+         */
+        fadeOutTweenType: TweenType;
+        /**
+         * @private
+         */
+        fadeOutTime: number;
+        /**
+         * @private
+         */
+        pauseFadeIn: boolean;
+        /**
+         * @private
+         */
+        actionEnabled: boolean;
+        /**
+         * @private
+         */
+        additiveBlending: boolean;
+        /**
+         * - Whether the animation state has control over the display property of the slots.
+         * Sometimes blend a animation state does not want it to control the display properties of the slots,
+         * especially if other animation state are controlling the display properties of the slots.
+         * @default true
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 动画状态是否对插槽的显示对象属性有控制权。
+         * 有时混合一个动画状态并不希望其控制插槽的显示对象属性，
+         * 尤其是其他动画状态正在控制这些插槽的显示对象属性时。
+         * @default true
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        displayControl: boolean;
+        /**
+         * - Whether to reset the objects without animation to the armature pose when the animation state is start to play.
+         * This property should usually be set to false when blend multiple animation states.
+         * @default true
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 开始播放动画状态时是否将没有动画的对象重置为骨架初始值。
+         * 通常在混合多个动画状态时应该将该属性设置为 false。
+         * @default true
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        resetToPose: boolean;
+        /**
+         * @private
+         */
+        fadeInTweenType: TweenType;
+        /**
+         * - The play times. [0: Loop play, [1~N]: Play N times]
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 播放次数。 [0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        playTimes: number;
+        /**
+         * - The blend layer.
+         * High layer animation state will get the blend weight first.
+         * When the blend weight is assigned more than 1, the remaining animation states will no longer get the weight assigned.
+         * @readonly
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 混合图层。
+         * 图层高的动画状态会优先获取混合权重。
+         * 当混合权重分配超过 1 时，剩余的动画状态将不再获得权重分配。
+         * @readonly
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        layer: number;
+        /**
+         * - The start time of play. (In seconds)
+         * @default 0.0
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 播放的开始时间。 （以秒为单位）
+         * @default 0.0
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        position: number;
+        /**
+         * - The duration of play.
+         * [-1: Use the default value of the animation data, 0: Stop play, (0~N]: The duration] (In seconds)
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 播放的持续时间。
+         * [-1: 使用动画数据默认值, 0: 动画停止, (0~N]: 持续时间] （以秒为单位）
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        duration: number;
+        /**
+         * - The play speed.
+         * The value is an overlay relationship with {@link dragonBones.Animation#timeScale}.
+         * [(-N~0): Reverse play, 0: Stop play, (0~1): Slow play, 1: Normal play, (1~N): Fast play]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 播放速度。
+         * 该值与 {@link dragonBones.Animation#timeScale} 是叠加关系。
+         * [(-N~0): 倒转播放, 0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        timeScale: number;
+        /**
+         * - The blend weight.
+         * @default 1.0
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 混合权重。
+         * @default 1.0
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        weight: number;
+        /**
+         * - The fade in time.
+         * [-1: Use the default value of the animation data, [0~N]: The fade in time] (In seconds)
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 淡入时间。
+         * [-1: 使用动画数据默认值, [0~N]: 淡入时间] （以秒为单位）
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        fadeInTime: number;
+        /**
+         * - The auto fade out time when the animation state play completed.
+         * [-1: Do not fade out automatically, [0~N]: The fade out time] (In seconds)
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 动画状态播放完成后的自动淡出时间。
+         * [-1: 不自动淡出, [0~N]: 淡出时间] （以秒为单位）
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        autoFadeOutTime: number;
+        /**
+         * - The name of the animation state. (Can be different from the name of the animation data)
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 动画状态名称。 （可以不同于动画数据）
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * - The animation data name.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 动画数据名称。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        animation: string;
+        /**
+         * - The blend group name of the animation state.
+         * This property is typically used to specify the substitution of multiple animation states blend.
+         * @readonly
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 混合组名称。
+         * 该属性通常用来指定多个动画状态混合时的相互替换关系。
+         * @readonly
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        group: string;
+        /**
+         * @private
+         */
+        readonly boneMask: Array<string>;
+        protected _onClear(): void;
+        /**
+         * @private
+         */
+        clear(): void;
+        /**
+         * @private
+         */
+        copyFrom(value: AnimationConfig): void;
+        /**
+         * @private
+         */
+        containsBoneMask(boneName: string): boolean;
+        /**
+         * @private
+         */
+        addBoneMask(armature: Armature, boneName: string, recursive?: boolean): void;
+        /**
+         * @private
+         */
+        removeBoneMask(armature: Armature, boneName: string, recursive?: boolean): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The texture atlas data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 贴图集数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    abstract class TextureAtlasData extends BaseObject {
+        /**
+         * @private
+         */
+        autoSearch: boolean;
+        /**
+         * @private
+         */
+        width: number;
+        /**
+         * @private
+         */
+        height: number;
+        /**
+         * @private
+         */
+        scale: number;
+        /**
+         * - The texture atlas name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 贴图集名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * - The image path of the texture atlas.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 贴图集图片路径。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        imagePath: string;
+        /**
+         * @private
+         */
+        readonly textures: Map<TextureData>;
+        protected _onClear(): void;
+        /**
+         * @private
+         */
+        copyFrom(value: TextureAtlasData): void;
+        /**
+         * @internal
+         */
+        abstract createTexture(): TextureData;
+        /**
+         * @internal
+         */
+        addTexture(value: TextureData): void;
+        /**
+         * @private
+         */
+        getTexture(textureName: string): TextureData | null;
+    }
+    /**
+     * @internal
+     */
+    abstract class TextureData extends BaseObject {
+        static createRectangle(): Rectangle;
+        rotated: boolean;
+        name: string;
+        readonly region: Rectangle;
+        parent: TextureAtlasData;
+        frame: Rectangle | null;
+        protected _onClear(): void;
+        copyFrom(value: TextureData): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class DeformVertices extends BaseObject {
+        static toString(): string;
+        verticesDirty: boolean;
+        readonly vertices: Array<number>;
+        readonly bones: Array<Bone | null>;
+        verticesData: VerticesData | null;
+        protected _onClear(): void;
+        init(verticesDataValue: VerticesData | null, armature: Armature): void;
+        isBonesUpdate(): boolean;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The armature proxy interface, the docking engine needs to implement it concretely.
+     * @see dragonBones.Armature
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 骨架代理接口，对接的引擎需要对其进行具体实现。
+     * @see dragonBones.Armature
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    interface IArmatureProxy extends IEventDispatcher {
+        /**
+         * @internal
+         */
+        dbInit(armature: Armature): void;
+        /**
+         * @internal
+         */
+        dbClear(): void;
+        /**
+         * @internal
+         */
+        dbUpdate(): void;
+        /**
+         * - Dispose the instance and the Armature instance. (The Armature instance will return to the object pool)
+         * @example
+         * <pre>
+         *     removeChild(armatureDisplay);
+         *     armatureDisplay.dispose();
+         * </pre>
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 释放该实例和骨架。 （骨架会回收到对象池）
+         * @example
+         * <pre>
+         *     removeChild(armatureDisplay);
+         *     armatureDisplay.dispose();
+         * </pre>
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        dispose(disposeProxy: boolean): void;
+        /**
+         * - The armature.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 骨架。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly armature: Armature;
+        /**
+         * - The animation player.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画播放器。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly animation: Animation;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - Armature is the core of the skeleton animation system.
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Bone
+     * @see dragonBones.Slot
+     * @see dragonBones.Animation
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨架是骨骼动画系统的核心。
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Bone
+     * @see dragonBones.Slot
+     * @see dragonBones.Animation
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class Armature extends BaseObject implements IAnimatable {
+        static toString(): string;
+        private static _onSortSlots(a, b);
+        /**
+         * - Whether to inherit the animation control of the parent armature.
+         * True to try to have the child armature play an animation with the same name when the parent armature play the animation.
+         * @default true
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 是否继承父骨架的动画控制。
+         * 如果该值为 true，当父骨架播放动画时，会尝试让子骨架播放同名动画。
+         * @default true
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        inheritAnimation: boolean;
+        /**
+         * @private
+         */
+        userData: any;
+        private _lockUpdate;
+        private _slotsDirty;
+        private _zOrderDirty;
+        private _flipX;
+        private _flipY;
+        /**
+         * @internal
+         */
+        _cacheFrameIndex: number;
+        private readonly _bones;
+        private readonly _slots;
+        /**
+         * @internal
+         */
+        readonly _constraints: Array<Constraint>;
+        private readonly _actions;
+        /**
+         * @internal
+         */
+        _armatureData: ArmatureData;
+        private _animation;
+        private _proxy;
+        private _display;
+        /**
+         * @internal
+         */
+        _replaceTextureAtlasData: TextureAtlasData | null;
+        private _replacedTexture;
+        /**
+         * @internal
+         */
+        _dragonBones: DragonBones;
+        private _clock;
+        /**
+         * @internal
+         */
+        _parent: Slot | null;
+        protected _onClear(): void;
+        /**
+         * @internal
+         */
+        _sortZOrder(slotIndices: Array<number> | Int16Array | null, offset: number): void;
+        /**
+         * @internal
+         */
+        _addBone(value: Bone): void;
+        /**
+         * @internal
+         */
+        _addSlot(value: Slot): void;
+        /**
+         * @internal
+         */
+        _addConstraint(value: Constraint): void;
+        /**
+         * @internal
+         */
+        _bufferAction(action: EventObject, append: boolean): void;
+        /**
+         * - Dispose the armature. (Return to the object pool)
+         * @example
+         * <pre>
+         *     removeChild(armature.display);
+         *     armature.dispose();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 释放骨架。 （回收到对象池）
+         * @example
+         * <pre>
+         *     removeChild(armature.display);
+         *     armature.dispose();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        dispose(): void;
+        /**
+         * @internal
+         */
+        init(armatureData: ArmatureData, proxy: IArmatureProxy, display: any, dragonBones: DragonBones): void;
+        /**
+         * @inheritDoc
+         */
+        advanceTime(passedTime: number): void;
+        /**
+         * - Forces a specific bone or its owning slot to update the transform or display property in the next frame.
+         * @param boneName - The bone name. (If not set, all bones will be update)
+         * @param updateSlot - Whether to update the bone's slots. (Default: false)
+         * @see dragonBones.Bone#invalidUpdate()
+         * @see dragonBones.Slot#invalidUpdate()
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 强制特定骨骼或其拥有的插槽在下一帧更新变换或显示属性。
+         * @param boneName - 骨骼名称。 （如果未设置，将更新所有骨骼）
+         * @param updateSlot - 是否更新骨骼的插槽。 （默认: false）
+         * @see dragonBones.Bone#invalidUpdate()
+         * @see dragonBones.Slot#invalidUpdate()
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        invalidUpdate(boneName?: string | null, updateSlot?: boolean): void;
+        /**
+         * - Check whether a specific point is inside a custom bounding box in a slot.
+         * The coordinate system of the point is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param x - The horizontal coordinate of the point.
+         * @param y - The vertical coordinate of the point.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定点是否在某个插槽的自定义边界框内。
+         * 点的坐标系为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param x - 点的水平坐标。
+         * @param y - 点的垂直坐标。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        containsPoint(x: number, y: number): Slot | null;
+        /**
+         * - Check whether a specific segment intersects a custom bounding box for a slot in the armature.
+         * The coordinate system of the segment and intersection is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param xA - The horizontal coordinate of the beginning of the segment.
+         * @param yA - The vertical coordinate of the beginning of the segment.
+         * @param xB - The horizontal coordinate of the end point of the segment.
+         * @param yB - The vertical coordinate of the end point of the segment.
+         * @param intersectionPointA - The first intersection at which a line segment intersects the bounding box from the beginning to the end. (If not set, the intersection point will not calculated)
+         * @param intersectionPointB - The first intersection at which a line segment intersects the bounding box from the end to the beginning. (If not set, the intersection point will not calculated)
+         * @param normalRadians - The normal radians of the tangent of the intersection boundary box. [x: Normal radian of the first intersection tangent, y: Normal radian of the second intersection tangent] (If not set, the normal will not calculated)
+         * @returns The slot of the first custom bounding box where the segment intersects from the start point to the end point.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定线段是否与骨架的某个插槽的自定义边界框相交。
+         * 线段和交点的坐标系均为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param xA - 线段起点的水平坐标。
+         * @param yA - 线段起点的垂直坐标。
+         * @param xB - 线段终点的水平坐标。
+         * @param yB - 线段终点的垂直坐标。
+         * @param intersectionPointA - 线段从起点到终点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param intersectionPointB - 线段从终点到起点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param normalRadians - 交点边界框切线的法线弧度。 [x: 第一个交点切线的法线弧度, y: 第二个交点切线的法线弧度] （如果未设置，则不计算法线）
+         * @returns 线段从起点到终点相交的第一个自定义边界框的插槽。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        intersectsSegment(xA: number, yA: number, xB: number, yB: number, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): Slot | null;
+        /**
+         * - Get a specific bone.
+         * @param name - The bone name.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨骼。
+         * @param name - 骨骼名称。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getBone(name: string): Bone | null;
+        /**
+         * - Get a specific bone by the display.
+         * @param display - The display object.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 通过显示对象获取特定的骨骼。
+         * @param display - 显示对象。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getBoneByDisplay(display: any): Bone | null;
+        /**
+         * - Get a specific slot.
+         * @param name - The slot name.
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的插槽。
+         * @param name - 插槽名称。
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getSlot(name: string): Slot | null;
+        /**
+         * - Get a specific slot by the display.
+         * @param display - The display object.
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 通过显示对象获取特定的插槽。
+         * @param display - 显示对象。
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getSlotByDisplay(display: any): Slot | null;
+        /**
+         * - Get all bones.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取所有的骨骼。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getBones(): Array<Bone>;
+        /**
+         * - Get all slots.
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取所有的插槽。
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getSlots(): Array<Slot>;
+        /**
+         * - Whether to flip the armature horizontally.
+         * @version DragonBones 5.5
+         * @language en_US
+         */
+        /**
+         * - 是否将骨架水平翻转。
+         * @version DragonBones 5.5
+         * @language zh_CN
+         */
+        flipX: boolean;
+        /**
+         * - Whether to flip the armature vertically.
+         * @version DragonBones 5.5
+         * @language en_US
+         */
+        /**
+         * - 是否将骨架垂直翻转。
+         * @version DragonBones 5.5
+         * @language zh_CN
+         */
+        flipY: boolean;
+        /**
+         * - The animation cache frame rate, which turns on the animation cache when the set value is greater than 0.
+         * There is a certain amount of memory overhead to improve performance by caching animation data in memory.
+         * The frame rate should not be set too high, usually with the frame rate of the animation is similar and lower than the program running frame rate.
+         * When the animation cache is turned on, some features will fail, such as the offset property of bone.
+         * @example
+         * <pre>
+         *     armature.cacheFrameRate = 24;
+         * </pre>
+         * @see dragonBones.DragonBonesData#frameRate
+         * @see dragonBones.ArmatureData#frameRate
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画缓存帧率，当设置的值大于 0 的时，将会开启动画缓存。
+         * 通过将动画数据缓存在内存中来提高运行性能，会有一定的内存开销。
+         * 帧率不宜设置的过高，通常跟动画的帧率相当且低于程序运行的帧率。
+         * 开启动画缓存后，某些功能将会失效，比如骨骼的 offset 属性等。
+         * @example
+         * <pre>
+         *     armature.cacheFrameRate = 24;
+         * </pre>
+         * @see dragonBones.DragonBonesData#frameRate
+         * @see dragonBones.ArmatureData#frameRate
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        cacheFrameRate: number;
+        /**
+         * - The armature name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 骨架名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly name: string;
+        /**
+         * - The armature data.
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 骨架数据。
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly armatureData: ArmatureData;
+        /**
+         * - The animation player.
+         * @see dragonBones.Animation
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画播放器。
+         * @see dragonBones.Animation
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly animation: Animation;
+        /**
+         * @pivate
+         */
+        readonly proxy: IArmatureProxy;
+        /**
+         * - The EventDispatcher instance of the armature.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 该骨架的 EventDispatcher 实例。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly eventDispatcher: IEventDispatcher;
+        /**
+         * - The display container.
+         * The display of the slot is displayed as the parent.
+         * Depending on the rendering engine, the type will be different, usually the DisplayObjectContainer type.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 显示容器实例。
+         * 插槽的显示对象都会以此显示容器为父级。
+         * 根据渲染引擎的不同，类型会不同，通常是 DisplayObjectContainer 类型。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly display: any;
+        /**
+         * @private
+         */
+        replacedTexture: any;
+        /**
+         * @inheritDoc
+         */
+        clock: WorldClock | null;
+        /**
+         * - Get the parent slot which the armature belongs to.
+         * @see dragonBones.Slot
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 该骨架所属的父插槽。
+         * @see dragonBones.Slot
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly parent: Slot | null;
+        /**
+         * @deprecated
+         * @private
+         */
+        replaceTexture(texture: any): void;
+        /**
+         * - Deprecated, please refer to {@link #eventDispatcher}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventDispatcher}。
+         * @deprecated
+         * @language zh_CN
+         */
+        hasEventListener(type: EventStringType): boolean;
+        /**
+         * - Deprecated, please refer to {@link #eventDispatcher}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventDispatcher}。
+         * @deprecated
+         * @language zh_CN
+         */
+        addEventListener(type: EventStringType, listener: Function, target: any): void;
+        /**
+         * - Deprecated, please refer to {@link #eventDispatcher}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventDispatcher}。
+         * @deprecated
+         * @language zh_CN
+         */
+        removeEventListener(type: EventStringType, listener: Function, target: any): void;
+        /**
+         * - Deprecated, please refer to {@link #cacheFrameRate}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #cacheFrameRate}。
+         * @deprecated
+         * @language zh_CN
+         */
+        enableAnimationCache(frameRate: number): void;
+        /**
+         * - Deprecated, please refer to {@link #display}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #display}。
+         * @deprecated
+         * @language zh_CN
+         */
+        getDisplay(): any;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The base class of the transform object.
+     * @see dragonBones.Transform
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 变换对象的基类。
+     * @see dragonBones.Transform
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    abstract class TransformObject extends BaseObject {
+        protected static readonly _helpMatrix: Matrix;
+        protected static readonly _helpTransform: Transform;
+        protected static readonly _helpPoint: Point;
+        /**
+         * - A matrix relative to the armature coordinate system.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 相对于骨架坐标系的矩阵。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly globalTransformMatrix: Matrix;
+        /**
+         * - A transform relative to the armature coordinate system.
+         * @see #updateGlobalTransform()
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 相对于骨架坐标系的变换。
+         * @see #updateGlobalTransform()
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly global: Transform;
+        /**
+         * - The offset transform relative to the armature or the parent bone coordinate system.
+         * @see #dragonBones.Bone#invalidUpdate()
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 相对于骨架或父骨骼坐标系的偏移变换。
+         * @see #dragonBones.Bone#invalidUpdate()
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly offset: Transform;
+        /**
+         * @private
+         */
+        origin: Transform | null;
+        /**
+         * @private
+         */
+        userData: any;
+        protected _globalDirty: boolean;
+        /**
+         * @internal
+         */
+        _armature: Armature;
+        /**
+         */
+        protected _onClear(): void;
+        /**
+         * - For performance considerations, rotation or scale in the {@link #global} attribute of the bone or slot is not always properly accessible,
+         * some engines do not rely on these attributes to update rendering, such as Egret.
+         * The use of this method ensures that the access to the {@link #global} property is correctly rotation or scale.
+         * @example
+         * <pre>
+         *     bone.updateGlobalTransform();
+         *     let rotation = bone.global.rotation;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 出于性能的考虑，骨骼或插槽的 {@link #global} 属性中的旋转或缩放并不总是正确可访问的，有些引擎并不依赖这些属性更新渲染，比如 Egret。
+         * 使用此方法可以保证访问到 {@link #global} 属性中正确的旋转或缩放。
+         * @example
+         * <pre>
+         *     bone.updateGlobalTransform();
+         *     let rotation = bone.global.rotation;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        updateGlobalTransform(): void;
+        /**
+         * - The armature to which it belongs.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 所属的骨架。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly armature: Armature;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - Bone is one of the most important logical units in the armature animation system,
+     * and is responsible for the realization of translate, rotation, scaling in the animations.
+     * A armature can contain multiple bones.
+     * @see dragonBones.BoneData
+     * @see dragonBones.Armature
+     * @see dragonBones.Slot
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨骼在骨骼动画体系中是最重要的逻辑单元之一，负责动画中的平移、旋转、缩放的实现。
+     * 一个骨架中可以包含多个骨骼。
+     * @see dragonBones.BoneData
+     * @see dragonBones.Armature
+     * @see dragonBones.Slot
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class Bone extends TransformObject {
+        static toString(): string;
+        /**
+         * - The offset mode.
+         * @see #offset
+         * @version DragonBones 5.5
+         * @language en_US
+         */
+        /**
+         * - 偏移模式。
+         * @see #offset
+         * @version DragonBones 5.5
+         * @language zh_CN
+         */
+        offsetMode: OffsetMode;
+        /**
+         * @internal
+         */
+        readonly animationPose: Transform;
+        /**
+         * @internal
+         */
+        _transformDirty: boolean;
+        /**
+         * @internal
+         */
+        _childrenTransformDirty: boolean;
+        protected _localDirty: boolean;
+        /**
+         * @internal
+         */
+        _hasConstraint: boolean;
+        protected _visible: boolean;
+        protected _cachedFrameIndex: number;
+        /**
+         * @internal
+         */
+        readonly _blendState: BlendState;
+        /**
+         * @internal
+         */
+        _boneData: BoneData;
+        /**
+         * @private
+         */
+        protected _parent: Bone | null;
+        /**
+         * @internal
+         */
+        _cachedFrameIndices: Array<number> | null;
+        protected _onClear(): void;
+        protected _updateGlobalTransformMatrix(isCache: boolean): void;
+        /**
+         * @internal
+         */
+        init(boneData: BoneData, armatureValue: Armature): void;
+        /**
+         * @internal
+         */
+        update(cacheFrameIndex: number): void;
+        /**
+         * @internal
+         */
+        updateByConstraint(): void;
+        /**
+         * - Forces the bone to update the transform in the next frame.
+         * When the bone is not animated or its animation state is finished, the bone will not continue to update,
+         * and when the skeleton must be updated for some reason, the method needs to be called explicitly.
+         * @example
+         * <pre>
+         *     let bone = armature.getBone("arm");
+         *     bone.offset.scaleX = 2.0;
+         *     bone.invalidUpdate();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 强制骨骼在下一帧更新变换。
+         * 当该骨骼没有动画状态或其动画状态播放完成时，骨骼将不在继续更新，而此时由于某些原因必须更新骨骼时，则需要显式调用该方法。
+         * @example
+         * <pre>
+         *     let bone = armature.getBone("arm");
+         *     bone.offset.scaleX = 2.0;
+         *     bone.invalidUpdate();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        invalidUpdate(): void;
+        /**
+         * - Check whether the bone contains a specific bone.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查该骨骼是否包含特定的骨骼。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        contains(value: Bone): boolean;
+        /**
+         * - The bone data.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 骨骼数据。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly boneData: BoneData;
+        /**
+         * - The visible of all slots in the bone.
+         * @default true
+         * @see dragonBones.Slot#visible
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 此骨骼所有插槽的可见。
+         * @default true
+         * @see dragonBones.Slot#visible
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        visible: boolean;
+        /**
+         * - The bone name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 骨骼名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly name: string;
+        /**
+         * - The parent bone to which it belongs.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 所属的父骨骼。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly parent: Bone | null;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.Armature#getBones()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.Armature#getBones()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        getBones(): Array<Bone>;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.Armature#getSlots()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.Armature#getSlots()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        getSlots(): Array<Slot>;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.Armature#getSlot()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.Armature#getSlot()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly slot: Slot | null;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class Surface extends Bone {
+        static toString(): string;
+        private _dX;
+        private _dY;
+        private _k;
+        private _kX;
+        private _kY;
+        readonly _vertices: Array<number>;
+        readonly _deformVertices: Array<number>;
+        /**
+         * - x1, y1, x2, y2, x3, y3, x4, y4, d1X, d1Y, d2X, d2Y
+         */
+        private readonly _hullCache;
+        /**
+         * - Inside [flag, a, b, c, d, tx, ty], Outside [flag, a, b, c, d, tx, ty]
+         */
+        private readonly _matrixCahce;
+        protected _onClear(): void;
+        private _getAffineTransform(x, y, lX, lY, aX, aY, bX, bY, cX, cY, transform, matrix, isDown);
+        private _updateVertices();
+        protected _updateGlobalTransformMatrix(isCache: boolean): void;
+        _getGlobalTransformMatrix(x: number, y: number): Matrix;
+        /**
+         * @internal
+         * @private
+         */
+        init(surfaceData: SurfaceData, armatureValue: Armature): void;
+        /**
+         * @internal
+         */
+        update(cacheFrameIndex: number): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The slot attached to the armature, controls the display status and properties of the display object.
+     * A bone can contain multiple slots.
+     * A slot can contain multiple display objects, displaying only one of the display objects at a time,
+     * but you can toggle the display object into frame animation while the animation is playing.
+     * The display object can be a normal texture, or it can be a display of a child armature, a grid display object,
+     * and a custom other display object.
+     * @see dragonBones.Armature
+     * @see dragonBones.Bone
+     * @see dragonBones.SlotData
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 插槽附着在骨骼上，控制显示对象的显示状态和属性。
+     * 一个骨骼上可以包含多个插槽。
+     * 一个插槽中可以包含多个显示对象，同一时间只能显示其中的一个显示对象，但可以在动画播放的过程中切换显示对象实现帧动画。
+     * 显示对象可以是普通的图片纹理，也可以是子骨架的显示容器，网格显示对象，还可以是自定义的其他显示对象。
+     * @see dragonBones.Armature
+     * @see dragonBones.Bone
+     * @see dragonBones.SlotData
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    abstract class Slot extends TransformObject {
+        /**
+         * - Displays the animated state or mixed group name controlled by the object, set to null to be controlled by all animation states.
+         * @default null
+         * @see dragonBones.AnimationState#displayControl
+         * @see dragonBones.AnimationState#name
+         * @see dragonBones.AnimationState#group
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 显示对象受到控制的动画状态或混合组名称，设置为 null 则表示受所有的动画状态控制。
+         * @default null
+         * @see dragonBones.AnimationState#displayControl
+         * @see dragonBones.AnimationState#name
+         * @see dragonBones.AnimationState#group
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        displayController: string | null;
+        protected _displayDirty: boolean;
+        protected _zOrderDirty: boolean;
+        protected _visibleDirty: boolean;
+        protected _blendModeDirty: boolean;
+        /**
+         * @internal
+         */
+        _colorDirty: boolean;
+        protected _transformDirty: boolean;
+        protected _visible: boolean;
+        protected _blendMode: BlendMode;
+        protected _displayIndex: number;
+        protected _animationDisplayIndex: number;
+        /**
+         * @internal
+         */
+        _zOrder: number;
+        protected _cachedFrameIndex: number;
+        /**
+         * @internal
+         */
+        _pivotX: number;
+        /**
+         * @internal
+         */
+        _pivotY: number;
+        protected readonly _localMatrix: Matrix;
+        /**
+         * @internal
+         */
+        readonly _colorTransform: ColorTransform;
+        protected readonly _displayDatas: Array<DisplayData | null>;
+        protected readonly _displayList: Array<any | Armature>;
+        /**
+         * @internal
+         */
+        _slotData: SlotData;
+        protected _rawDisplayDatas: Array<DisplayData | null> | null;
+        /**
+         * @internal
+         */
+        _displayData: DisplayData | null;
+        protected _boundingBoxData: BoundingBoxData | null;
+        protected _textureData: TextureData | null;
+        /**
+         * @internal
+         */
+        _deformVertices: DeformVertices | null;
+        protected _rawDisplay: any;
+        protected _meshDisplay: any;
+        protected _display: any;
+        protected _childArmature: Armature | null;
+        /**
+         * @private
+         */
+        protected _parent: Bone;
+        /**
+         * @internal
+         */
+        _cachedFrameIndices: Array<number> | null;
+        protected _onClear(): void;
+        protected abstract _initDisplay(value: any, isRetain: boolean): void;
+        protected abstract _disposeDisplay(value: any, isRelease: boolean): void;
+        protected abstract _onUpdateDisplay(): void;
+        protected abstract _addDisplay(): void;
+        protected abstract _replaceDisplay(value: any): void;
+        protected abstract _removeDisplay(): void;
+        protected abstract _updateZOrder(): void;
+        /**
+         * @internal
+         */
+        abstract _updateVisible(): void;
+        protected abstract _updateBlendMode(): void;
+        protected abstract _updateColor(): void;
+        protected abstract _updateFrame(): void;
+        protected abstract _updateMesh(): void;
+        /**
+         * @internal
+         */
+        abstract _updateGlueMesh(): void;
+        protected abstract _updateTransform(): void;
+        protected abstract _identityTransform(): void;
+        /**
+         * - Support default skin data.
+         */
+        protected _getDefaultRawDisplayData(displayIndex: number): DisplayData | null;
+        protected _updateDisplayData(): void;
+        protected _updateDisplay(): void;
+        protected _updateGlobalTransformMatrix(isCache: boolean): void;
+        /**
+         * @internal
+         */
+        _setDisplayIndex(value: number, isAnimation?: boolean): boolean;
+        /**
+         * @internal
+         */
+        _setZorder(value: number): boolean;
+        /**
+         * @internal
+         */
+        _setColor(value: ColorTransform): boolean;
+        /**
+         * @internal
+         */
+        _setDisplayList(value: Array<any> | null): boolean;
+        /**
+         * @internal
+         */
+        init(slotData: SlotData, armatureValue: Armature, rawDisplay: any, meshDisplay: any): void;
+        /**
+         * @internal
+         */
+        update(cacheFrameIndex: number): void;
+        /**
+         * @private
+         */
+        updateTransformAndMatrix(): void;
+        /**
+         * @private
+         */
+        replaceDisplayData(value: DisplayData | null, displayIndex?: number): void;
+        /**
+         * - Check whether a specific point is inside a custom bounding box in the slot.
+         * The coordinate system of the point is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param x - The horizontal coordinate of the point.
+         * @param y - The vertical coordinate of the point.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定点是否在插槽的自定义边界框内。
+         * 点的坐标系为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param x - 点的水平坐标。
+         * @param y - 点的垂直坐标。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        containsPoint(x: number, y: number): boolean;
+        /**
+         * - Check whether a specific segment intersects a custom bounding box for the slot.
+         * The coordinate system of the segment and intersection is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param xA - The horizontal coordinate of the beginning of the segment.
+         * @param yA - The vertical coordinate of the beginning of the segment.
+         * @param xB - The horizontal coordinate of the end point of the segment.
+         * @param yB - The vertical coordinate of the end point of the segment.
+         * @param intersectionPointA - The first intersection at which a line segment intersects the bounding box from the beginning to the end. (If not set, the intersection point will not calculated)
+         * @param intersectionPointB - The first intersection at which a line segment intersects the bounding box from the end to the beginning. (If not set, the intersection point will not calculated)
+         * @param normalRadians - The normal radians of the tangent of the intersection boundary box. [x: Normal radian of the first intersection tangent, y: Normal radian of the second intersection tangent] (If not set, the normal will not calculated)
+         * @returns Intersection situation. [1: Disjoint and segments within the bounding box, 0: Disjoint, 1: Intersecting and having a nodal point and ending in the bounding box, 2: Intersecting and having a nodal point and starting at the bounding box, 3: Intersecting and having two intersections, N: Intersecting and having N intersections]
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定线段是否与插槽的自定义边界框相交。
+         * 线段和交点的坐标系均为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param xA - 线段起点的水平坐标。
+         * @param yA - 线段起点的垂直坐标。
+         * @param xB - 线段终点的水平坐标。
+         * @param yB - 线段终点的垂直坐标。
+         * @param intersectionPointA - 线段从起点到终点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param intersectionPointB - 线段从终点到起点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param normalRadians - 交点边界框切线的法线弧度。 [x: 第一个交点切线的法线弧度, y: 第二个交点切线的法线弧度] （如果未设置，则不计算法线）
+         * @returns 相交的情况。 [-1: 不相交且线段在包围盒内, 0: 不相交, 1: 相交且有一个交点且终点在包围盒内, 2: 相交且有一个交点且起点在包围盒内, 3: 相交且有两个交点, N: 相交且有 N 个交点]
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        intersectsSegment(xA: number, yA: number, xB: number, yB: number, intersectionPointA?: {
+            x: number;
+            y: number;
+        } | null, intersectionPointB?: {
+            x: number;
+            y: number;
+        } | null, normalRadians?: {
+            x: number;
+            y: number;
+        } | null): number;
+        /**
+         * - Forces the slot to update the state of the display object in the next frame.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 强制插槽在下一帧更新显示对象的状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        invalidUpdate(): void;
+        /**
+         * - The visible of slot's display object.
+         * @default true
+         * @version DragonBones 5.6
+         * @language en_US
+         */
+        /**
+         * - 插槽的显示对象的可见。
+         * @default true
+         * @version DragonBones 5.6
+         * @language zh_CN
+         */
+        visible: boolean;
+        /**
+         * - The index of the display object displayed in the display list.
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         *     slot.displayIndex = 3;
+         *     slot.displayController = "none";
+         * </pre>
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 此时显示的显示对象在显示列表中的索引。
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         *     slot.displayIndex = 3;
+         *     slot.displayController = "none";
+         * </pre>
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        displayIndex: number;
+        /**
+         * - The slot name.
+         * @see dragonBones.SlotData#name
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 插槽名称。
+         * @see dragonBones.SlotData#name
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly name: string;
+        /**
+         * - Contains a display list of display objects or child armatures.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 包含显示对象或子骨架的显示列表。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        displayList: Array<any>;
+        /**
+         * - The slot data.
+         * @see dragonBones.SlotData
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 插槽数据。
+         * @see dragonBones.SlotData
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly slotData: SlotData;
+        /**
+         * @private
+         */
+        rawDisplayDatas: Array<DisplayData | null> | null;
+        /**
+         * @private
+         */
+        readonly displayData: DisplayData | null;
+        /**
+         * - The custom bounding box data for the slot at current time.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 插槽此时的自定义包围盒数据。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        readonly boundingBoxData: BoundingBoxData | null;
+        /**
+         * @private
+         */
+        readonly rawDisplay: any;
+        /**
+         * @private
+         */
+        readonly meshDisplay: any;
+        /**
+         * - The display object that the slot displays at this time.
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("text");
+         *     slot.display = new yourEngine.TextField();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 插槽此时显示的显示对象。
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("text");
+         *     slot.display = new yourEngine.TextField();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        display: any;
+        /**
+         * - The child armature that the slot displayed at current time.
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         * let prevChildArmature = slot.childArmature;
+         * if (prevChildArmature) {
+         * prevChildArmature.dispose();
+         *     }
+         *     slot.childArmature = factory.buildArmature("weapon_blabla", "weapon_blabla_project");
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 插槽此时显示的子骨架。
+         * 注意，被替换的对象或子骨架并不会被回收，根据语言和引擎的不同，需要额外处理。
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         * let prevChildArmature = slot.childArmature;
+         * if (prevChildArmature) {
+         * prevChildArmature.dispose();
+         *     }
+         *     slot.childArmature = factory.buildArmature("weapon_blabla", "weapon_blabla_project");
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        childArmature: Armature | null;
+        /**
+         * - The parent bone to which it belongs.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 所属的父骨骼。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly parent: Bone;
+        /**
+         * - Deprecated, please refer to {@link #display}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #display}。
+         * @deprecated
+         * @language zh_CN
+         */
+        getDisplay(): any;
+        /**
+         * - Deprecated, please refer to {@link #display}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #display}。
+         * @deprecated
+         * @language zh_CN
+         */
+        setDisplay(value: any): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    abstract class Constraint extends BaseObject {
+        protected static readonly _helpMatrix: Matrix;
+        protected static readonly _helpTransform: Transform;
+        protected static readonly _helpPoint: Point;
+        /**
+         * - For timeline state.
+         * @internal
+         */
+        _constraintData: ConstraintData;
+        protected _armature: Armature;
+        /**
+         * - For sort bones.
+         * @internal
+         */
+        _target: Bone;
+        /**
+         * - For sort bones.
+         * @internal
+         */
+        _root: Bone;
+        protected _bone: Bone | null;
+        protected _onClear(): void;
+        abstract init(constraintData: ConstraintData, armature: Armature): void;
+        abstract update(): void;
+        abstract invalidUpdate(): void;
+        readonly name: string;
+    }
+    /**
+     * @internal
+     */
+    class IKConstraint extends Constraint {
+        static toString(): string;
+        private _scaleEnabled;
+        /**
+         * - For timeline state.
+         * @internal
+         */
+        _bendPositive: boolean;
+        /**
+         * - For timeline state.
+         * @internal
+         */
+        _weight: number;
+        protected _onClear(): void;
+        private _computeA();
+        private _computeB();
+        init(constraintData: ConstraintData, armature: Armature): void;
+        update(): void;
+        invalidUpdate(): void;
+    }
+    /**
+     * @internal
+     */
+    class PathConstraint extends Constraint {
+        dirty: boolean;
+        pathOffset: number;
+        position: number;
+        spacing: number;
+        rotateOffset: number;
+        rotateMix: number;
+        translateMix: number;
+        private _pathSlot;
+        private _bones;
+        private _spaces;
+        private _positions;
+        private _curves;
+        private _boneLengths;
+        private _pathGlobalVertices;
+        private _segments;
+        static toString(): string;
+        protected _onClear(): void;
+        protected _updatePathVertices(verticesData: VerticesData): void;
+        protected _computeVertices(start: number, count: number, offset: number, out: Array<number>): void;
+        protected _computeBezierCurve(pathDisplayDta: PathDisplayData, spaceCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): void;
+        private addCurvePosition(t, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, offset, tangents);
+        init(constraintData: ConstraintData, armature: Armature): void;
+        update(): void;
+        invalidUpdate(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - Play animation interface. (Both Armature and Wordclock implement the interface)
+     * Any instance that implements the interface can be added to the Worldclock instance and advance time by Worldclock instance uniformly.
+     * @see dragonBones.WorldClock
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 播放动画接口。 (Armature 和 WordClock 都实现了该接口)
+     * 任何实现了此接口的实例都可以添加到 WorldClock 实例中，由 WorldClock 实例统一更新时间。
+     * @see dragonBones.WorldClock
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    interface IAnimatable {
+        /**
+         * - Advance time.
+         * @param passedTime - Passed time. (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 更新时间。
+         * @param passedTime - 前进的时间。 （以秒为单位）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        advanceTime(passedTime: number): void;
+        /**
+         * - The Wordclock instance to which the current belongs.
+         * @example
+         * <pre>
+         *     armature.clock = factory.clock; // Add armature to clock.
+         *     armature.clock = null; // Remove armature from clock.
+         * </pre>
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 当前所属的 WordClock 实例。
+         * @example
+         * <pre>
+         *     armature.clock = factory.clock; // 将骨架添加到时钟。
+         *     armature.clock = null; // 将骨架从时钟移除。
+         * </pre>
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        clock: WorldClock | null;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - Worldclock provides clock support for animations, advance time for each IAnimatable object added to the instance.
+     * @see dragonBones.IAnimateble
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - WorldClock 对动画提供时钟支持，为每个加入到该实例的 IAnimatable 对象更新时间。
+     * @see dragonBones.IAnimateble
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class WorldClock implements IAnimatable {
+        /**
+         * - Current time. (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 当前的时间。 (以秒为单位)
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        time: number;
+        /**
+         * - The play speed, used to control animation speed-shift play.
+         * [0: Stop play, (0~1): Slow play, 1: Normal play, (1~N): Fast play]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 播放速度，用于控制动画变速播放。
+         * [0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        timeScale: number;
+        private _systemTime;
+        private readonly _animatebles;
+        private _clock;
+        /**
+         * - Creating a Worldclock instance. Typically, you do not need to create Worldclock instance.
+         * When multiple Worldclock instances are running at different speeds, can achieving some specific animation effects, such as bullet time.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建一个 WorldClock 实例。通常并不需要创建 WorldClock 实例。
+         * 当多个 WorldClock 实例使用不同的速度运行时，可以实现一些特殊的动画效果，比如子弹时间等。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        constructor(time?: number);
+        /**
+         * - Advance time for all IAnimatable instances.
+         * @param passedTime - Passed time. [-1: Automatically calculates the time difference between the current frame and the previous frame, [0~N): Passed time] (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 为所有的 IAnimatable 实例更新时间。
+         * @param passedTime - 前进的时间。 [-1: 自动计算当前帧与上一帧的时间差, [0~N): 前进的时间] (以秒为单位)
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        advanceTime(passedTime: number): void;
+        /**
+         * - Check whether contains a specific instance of IAnimatable.
+         * @param value - The IAnimatable instance.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否包含特定的 IAnimatable 实例。
+         * @param value - IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        contains(value: IAnimatable): boolean;
+        /**
+         * - Add IAnimatable instance.
+         * @param value - The IAnimatable instance.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 添加 IAnimatable 实例。
+         * @param value - IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        add(value: IAnimatable): void;
+        /**
+         * - Removes a specified IAnimatable instance.
+         * @param value - The IAnimatable instance.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 移除特定的 IAnimatable 实例。
+         * @param value - IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        remove(value: IAnimatable): void;
+        /**
+         * - Clear all IAnimatable instances.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 清除所有的 IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        clear(): void;
+        /**
+         * @inheritDoc
+         */
+        clock: WorldClock | null;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#clock}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#clock}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static readonly clock: WorldClock;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The animation player is used to play the animation data and manage the animation states.
+     * @see dragonBones.AnimationData
+     * @see dragonBones.AnimationState
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 动画播放器用来播放动画数据和管理动画状态。
+     * @see dragonBones.AnimationData
+     * @see dragonBones.AnimationState
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class Animation extends BaseObject {
+        static toString(): string;
+        /**
+         * - The play speed of all animations. [0: Stop, (0~1): Slow, 1: Normal, (1~N): Fast]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 所有动画的播放速度。 [0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        timeScale: number;
+        private _lockUpdate;
+        private _animationDirty;
+        private _inheritTimeScale;
+        private readonly _animationNames;
+        private readonly _animationStates;
+        private readonly _animations;
+        private _armature;
+        private _animationConfig;
+        private _lastAnimationState;
+        protected _onClear(): void;
+        private _fadeOut(animationConfig);
+        /**
+         * @internal
+         */
+        init(armature: Armature): void;
+        /**
+         * @internal
+         */
+        advanceTime(passedTime: number): void;
+        /**
+         * - Clear all animations states.
+         * @see dragonBones.AnimationState
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除所有的动画状态。
+         * @see dragonBones.AnimationState
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        reset(): void;
+        /**
+         * - Pause a specific animation state.
+         * @param animationName - The name of animation state. (If not set, it will pause all animations)
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 暂停指定动画状态的播放。
+         * @param animationName - 动画状态名称。 （如果未设置，则暂停所有动画）
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        stop(animationName?: string | null): void;
+        /**
+         * - Play animation with a specific animation config.
+         * The API is still in the experimental phase and may encounter bugs or stability or compatibility issues when used.
+         * @param animationConfig - The animation config.
+         * @returns The playing animation state.
+         * @see dragonBones.AnimationConfig
+         * @beta
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 通过指定的动画配置来播放动画。
+         * 该 API 仍在实验阶段，使用时可能遭遇 bug 或稳定性或兼容性问题。
+         * @param animationConfig - 动画配置。
+         * @returns 播放的动画状态。
+         * @see dragonBones.AnimationConfig
+         * @beta
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        playConfig(animationConfig: AnimationConfig): AnimationState | null;
+        /**
+         * - Play a specific animation.
+         * @param animationName - The name of animation data. (If not set, The default animation will be played, or resume the animation playing from pause status, or replay the last playing animation)
+         * @param playTimes - Playing repeat times. [-1: Use default value of the animation data, 0: No end loop playing, [1~N]: Repeat N times] (default: -1)
+         * @returns The playing animation state.
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 播放指定动画。
+         * @param animationName - 动画数据名称。 （如果未设置，则播放默认动画，或将暂停状态切换为播放状态，或重新播放之前播放的动画）
+         * @param playTimes - 循环播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        play(animationName?: string | null, playTimes?: number): AnimationState | null;
+        /**
+         * - Fade in a specific animation.
+         * @param animationName - The name of animation data.
+         * @param fadeInTime - The fade in time. [-1: Use the default value of animation data, [0~N]: The fade in time (In seconds)] (Default: -1)
+         * @param playTimes - playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @param layer - The blending layer, the animation states in high level layer will get the blending weights with high priority, when the total blending weights are more than 1.0, there will be no more weights can be allocated to the other animation states. (Default: 0)
+         * @param group - The blending group name, it is typically used to specify the substitution of multiple animation states blending. (Default: null)
+         * @param fadeOutMode - The fade out mode, which is typically used to specify alternate mode of multiple animation states blending. (Default: AnimationFadeOutMode.SameLayerAndGroup)
+         * @returns The playing animation state.
+         * @example
+         * <pre>
+         *     armature.animation.fadeIn("walk", 0.3, 0, 0, "normalGroup").resetToPose = false;
+         *     armature.animation.fadeIn("attack", 0.3, 1, 0, "attackGroup").resetToPose = false;
+         * </pre>
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 淡入播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param fadeInTime - 淡入时间。 [-1: 使用动画数据默认值, [0~N]: 淡入时间 (以秒为单位)] （默认: -1）
+         * @param playTimes - 播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @param layer - 混合图层，图层高的动画状态会优先获取混合权重，当混合权重分配总和超过 1.0 时，剩余的动画状态将不能再获得权重分配。 （默认: 0）
+         * @param group - 混合组名称，该属性通常用来指定多个动画状态混合时的相互替换关系。 （默认: null）
+         * @param fadeOutMode - 淡出模式，该属性通常用来指定多个动画状态混合时的相互替换模式。 （默认: AnimationFadeOutMode.SameLayerAndGroup）
+         * @returns 播放的动画状态。
+         * @example
+         * <pre>
+         *     armature.animation.fadeIn("walk", 0.3, 0, 0, "normalGroup").resetToPose = false;
+         *     armature.animation.fadeIn("attack", 0.3, 1, 0, "attackGroup").resetToPose = false;
+         * </pre>
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        fadeIn(animationName: string, fadeInTime?: number, playTimes?: number, layer?: number, group?: string | null, fadeOutMode?: AnimationFadeOutMode): AnimationState | null;
+        /**
+         * - Play a specific animation from the specific time.
+         * @param animationName - The name of animation data.
+         * @param time - The start time point of playing. (In seconds)
+         * @param playTimes - Playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从指定时间开始播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param time - 播放开始的时间。 (以秒为单位)
+         * @param playTimes - 循环播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        gotoAndPlayByTime(animationName: string, time?: number, playTimes?: number): AnimationState | null;
+        /**
+         * - Play a specific animation from the specific frame.
+         * @param animationName - The name of animation data.
+         * @param frame - The start frame of playing.
+         * @param playTimes - Playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从指定帧开始播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param frame - 播放开始的帧数。
+         * @param playTimes - 播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        gotoAndPlayByFrame(animationName: string, frame?: number, playTimes?: number): AnimationState | null;
+        /**
+         * - Play a specific animation from the specific progress.
+         * @param animationName - The name of animation data.
+         * @param progress - The start progress value of playing.
+         * @param playTimes - Playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从指定进度开始播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param progress - 开始播放的进度。
+         * @param playTimes - 播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        gotoAndPlayByProgress(animationName: string, progress?: number, playTimes?: number): AnimationState | null;
+        /**
+         * - Stop a specific animation at the specific time.
+         * @param animationName - The name of animation data.
+         * @param time - The stop time. (In seconds)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 在指定时间停止指定动画播放
+         * @param animationName - 动画数据名称。
+         * @param time - 停止的时间。 (以秒为单位)
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        gotoAndStopByTime(animationName: string, time?: number): AnimationState | null;
+        /**
+         * - Stop a specific animation at the specific frame.
+         * @param animationName - The name of animation data.
+         * @param frame - The stop frame.
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 在指定帧停止指定动画的播放
+         * @param animationName - 动画数据名称。
+         * @param frame - 停止的帧数。
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        gotoAndStopByFrame(animationName: string, frame?: number): AnimationState | null;
+        /**
+         * - Stop a specific animation at the specific progress.
+         * @param animationName - The name of animation data.
+         * @param progress - The stop progress value.
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 在指定的进度停止指定的动画播放。
+         * @param animationName - 动画数据名称。
+         * @param progress - 停止进度。
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        gotoAndStopByProgress(animationName: string, progress?: number): AnimationState | null;
+        /**
+         * - Get a specific animation state.
+         * @param animationName - The name of animation state.
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         *     let walkState = armature.animation.getState("walk");
+         *     walkState.timeScale = 0.5;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取指定的动画状态
+         * @param animationName - 动画状态名称。
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         *     let walkState = armature.animation.getState("walk");
+         *     walkState.timeScale = 0.5;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getState(animationName: string): AnimationState | null;
+        /**
+         * - Check whether a specific animation data is included.
+         * @param animationName - The name of animation data.
+         * @see dragonBones.AnimationData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否包含指定的动画数据
+         * @param animationName - 动画数据名称。
+         * @see dragonBones.AnimationData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        hasAnimation(animationName: string): boolean;
+        /**
+         * - Get all the animation states.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 获取所有的动画状态
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        getStates(): Array<AnimationState>;
+        /**
+         * - Check whether there is an animation state is playing
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否有动画状态正在播放
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly isPlaying: boolean;
+        /**
+         * - Check whether all the animation states' playing were finished.
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否所有的动画状态均已播放完毕。
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly isCompleted: boolean;
+        /**
+         * - The name of the last playing animation state.
+         * @see #lastAnimationState
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 上一个播放的动画状态名称
+         * @see #lastAnimationState
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly lastAnimationName: string;
+        /**
+         * - The name of all animation data
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 所有动画数据的名称
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly animationNames: Array<string>;
+        /**
+         * - All animation data.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 所有的动画数据。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        animations: Map<AnimationData>;
+        /**
+         * - An AnimationConfig instance that can be used quickly.
+         * @see dragonBones.AnimationConfig
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 一个可以快速使用的动画配置实例。
+         * @see dragonBones.AnimationConfig
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        readonly animationConfig: AnimationConfig;
+        /**
+         * - The last playing animation state
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 上一个播放的动画状态
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly lastAnimationState: AnimationState | null;
+        /**
+         * - Deprecated, please refer to {@link #play()} {@link #fadeIn()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #play()} {@link #fadeIn()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        gotoAndPlay(animationName: string, fadeInTime?: number, duration?: number, playTimes?: number, layer?: number, group?: string | null, fadeOutMode?: AnimationFadeOutMode, pauseFadeOut?: boolean, pauseFadeIn?: boolean): AnimationState | null;
+        /**
+         * - Deprecated, please refer to {@link #gotoAndStopByTime()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #gotoAndStopByTime()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        gotoAndStop(animationName: string, time?: number): AnimationState | null;
+        /**
+         * - Deprecated, please refer to {@link #animationNames}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #animationNames}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly animationList: Array<string>;
+        /**
+         * - Deprecated, please refer to {@link #animationNames}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #animationNames}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly animationDataList: Array<AnimationData>;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The animation state is generated when the animation data is played.
+     * @see dragonBones.Animation
+     * @see dragonBones.AnimationData
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 动画状态由播放动画数据时产生。
+     * @see dragonBones.Animation
+     * @see dragonBones.AnimationData
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class AnimationState extends BaseObject {
+        static toString(): string;
+        /**
+         * @private
+         */
+        actionEnabled: boolean;
+        /**
+         * @private
+         */
+        additiveBlending: boolean;
+        /**
+         * - Whether the animation state has control over the display object properties of the slots.
+         * Sometimes blend a animation state does not want it to control the display object properties of the slots,
+         * especially if other animation state are controlling the display object properties of the slots.
+         * @default true
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 动画状态是否对插槽的显示对象属性有控制权。
+         * 有时混合一个动画状态并不希望其控制插槽的显示对象属性，
+         * 尤其是其他动画状态正在控制这些插槽的显示对象属性时。
+         * @default true
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        displayControl: boolean;
+        /**
+         * - Whether to reset the objects without animation to the armature pose when the animation state is start to play.
+         * This property should usually be set to false when blend multiple animation states.
+         * @default true
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 开始播放动画状态时是否将没有动画的对象重置为骨架初始值。
+         * 通常在混合多个动画状态时应该将该属性设置为 false。
+         * @default true
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        resetToPose: boolean;
+        /**
+         * - The play times. [0: Loop play, [1~N]: Play N times]
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 播放次数。 [0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        playTimes: number;
+        /**
+         * - The blend layer.
+         * High layer animation state will get the blend weight first.
+         * When the blend weight is assigned more than 1, the remaining animation states will no longer get the weight assigned.
+         * @readonly
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 混合图层。
+         * 图层高的动画状态会优先获取混合权重。
+         * 当混合权重分配超过 1 时，剩余的动画状态将不再获得权重分配。
+         * @readonly
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        layer: number;
+        /**
+         * - The play speed.
+         * The value is an overlay relationship with {@link dragonBones.Animation#timeScale}.
+         * [(-N~0): Reverse play, 0: Stop play, (0~1): Slow play, 1: Normal play, (1~N): Fast play]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 播放速度。
+         * 该值与 {@link dragonBones.Animation#timeScale} 是叠加关系。
+         * [(-N~0): 倒转播放, 0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+         * @default 1.0
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        timeScale: number;
+        /**
+         * - The blend weight.
+         * @default 1.0
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 混合权重。
+         * @default 1.0
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        weight: number;
+        /**
+         * - The auto fade out time when the animation state play completed.
+         * [-1: Do not fade out automatically, [0~N]: The fade out time] (In seconds)
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 动画状态播放完成后的自动淡出时间。
+         * [-1: 不自动淡出, [0~N]: 淡出时间] （以秒为单位）
+         * @default -1.0
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        autoFadeOutTime: number;
+        /**
+         * @private
+         */
+        fadeTotalTime: number;
+        /**
+         * - The name of the animation state. (Can be different from the name of the animation data)
+         * @readonly
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 动画状态名称。 （可以不同于动画数据）
+         * @readonly
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * - The blend group name of the animation state.
+         * This property is typically used to specify the substitution of multiple animation states blend.
+         * @readonly
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 混合组名称。
+         * 该属性通常用来指定多个动画状态混合时的相互替换关系。
+         * @readonly
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        group: string;
+        private _timelineDirty;
+        /**
+         * - xx: Play Enabled, Fade Play Enabled
+         * @internal
+         */
+        _playheadState: number;
+        /**
+         * -1: Fade in, 0: Fade complete, 1: Fade out;
+         * @internal
+         */
+        _fadeState: number;
+        /**
+         * -1: Fade start, 0: Fading, 1: Fade complete;
+         * @internal
+         */
+        _subFadeState: number;
+        /**
+         * @internal
+         */
+        _position: number;
+        /**
+         * @internal
+         */
+        _duration: number;
+        private _fadeTime;
+        private _time;
+        /**
+         * @internal
+         */
+        _fadeProgress: number;
+        /**
+         * @internal
+         */
+        _weightResult: number;
+        /**
+         * @internal
+         */
+        readonly _blendState: BlendState;
+        private readonly _boneMask;
+        private readonly _boneTimelines;
+        private readonly _surfaceTimelines;
+        private readonly _slotTimelines;
+        private readonly _constraintTimelines;
+        private readonly _animationTimelines;
+        private readonly _poseTimelines;
+        private readonly _bonePoses;
+        /**
+         * @internal
+         */
+        _animationData: AnimationData;
+        private _armature;
+        /**
+         * @internal
+         */
+        _actionTimeline: ActionTimelineState;
+        private _zOrderTimeline;
+        /**
+         * @internal
+         */
+        _parent: AnimationState;
+        protected _onClear(): void;
+        private _updateTimelines();
+        private _updateBoneAndSlotTimelines();
+        private _advanceFadeTime(passedTime);
+        /**
+         * @internal
+         */
+        init(armature: Armature, animationData: AnimationData, animationConfig: AnimationConfig): void;
+        /**
+         * @internal
+         */
+        advanceTime(passedTime: number, cacheFrameRate: number): void;
+        /**
+         * - Continue play.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 继续播放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        play(): void;
+        /**
+         * - Stop play.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 暂停播放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        stop(): void;
+        /**
+         * - Fade out the animation state.
+         * @param fadeOutTime - The fade out time. (In seconds)
+         * @param pausePlayhead - Whether to pause the animation playing when fade out.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 淡出动画状态。
+         * @param fadeOutTime - 淡出时间。 （以秒为单位）
+         * @param pausePlayhead - 淡出时是否暂停播放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        fadeOut(fadeOutTime: number, pausePlayhead?: boolean): void;
+        /**
+         * - Check if a specific bone mask is included.
+         * @param boneName - The bone name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否包含特定骨骼遮罩。
+         * @param boneName - 骨骼名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        containsBoneMask(boneName: string): boolean;
+        /**
+         * - Add a specific bone mask.
+         * @param boneName - The bone name.
+         * @param recursive - Whether or not to add a mask to the bone's sub-bone.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 添加特定的骨骼遮罩。
+         * @param boneName - 骨骼名称。
+         * @param recursive - 是否为该骨骼的子骨骼添加遮罩。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        addBoneMask(boneName: string, recursive?: boolean): void;
+        /**
+         * - Remove the mask of a specific bone.
+         * @param boneName - The bone name.
+         * @param recursive - Whether to remove the bone's sub-bone mask.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 删除特定骨骼的遮罩。
+         * @param boneName - 骨骼名称。
+         * @param recursive - 是否删除该骨骼的子骨骼遮罩。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        removeBoneMask(boneName: string, recursive?: boolean): void;
+        /**
+         * - Remove all bone masks.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 删除所有骨骼遮罩。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        removeAllBoneMask(): void;
+        /**
+         * - Whether the animation state is fading in.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 是否正在淡入。
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        readonly isFadeIn: boolean;
+        /**
+         * - Whether the animation state is fading out.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 是否正在淡出。
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        readonly isFadeOut: boolean;
+        /**
+         * - Whether the animation state is fade completed.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 是否淡入或淡出完毕。
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        readonly isFadeComplete: boolean;
+        /**
+         * - Whether the animation state is playing.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 是否正在播放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly isPlaying: boolean;
+        /**
+         * - Whether the animation state is play completed.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 是否播放完毕。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly isCompleted: boolean;
+        /**
+         * - The times has been played.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 已经循环播放的次数。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly currentPlayTimes: number;
+        /**
+         * - The total time. (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 总播放时间。 （以秒为单位）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly totalTime: number;
+        /**
+         * - The time is currently playing. (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 当前播放的时间。 （以秒为单位）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        currentTime: number;
+        /**
+         * - The animation data.
+         * @see dragonBones.AnimationData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 动画数据。
+         * @see dragonBones.AnimationData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        readonly animationData: AnimationData;
+    }
+    /**
+     * @internal
+     */
+    class BonePose extends BaseObject {
+        static toString(): string;
+        readonly current: Transform;
+        readonly delta: Transform;
+        readonly result: Transform;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    class BlendState {
+        dirty: boolean;
+        layer: number;
+        leftWeight: number;
+        layerWeight: number;
+        blendWeight: number;
+        /**
+         * -1: First blending, 0: No blending, 1: Blending.
+         */
+        update(weight: number, p_layer: number): number;
+        clear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    const enum TweenState {
+        None = 0,
+        Once = 1,
+        Always = 2,
+    }
+    /**
+     * @internal
+     */
+    abstract class TimelineState extends BaseObject {
+        /**
+         * -1: start, 0: play, 1: complete;
+         */
+        playState: number;
+        currentPlayTimes: number;
+        currentTime: number;
+        protected _tweenState: TweenState;
+        protected _frameRate: number;
+        protected _frameValueOffset: number;
+        protected _frameCount: number;
+        protected _frameOffset: number;
+        protected _frameIndex: number;
+        protected _frameRateR: number;
+        protected _position: number;
+        protected _duration: number;
+        protected _timeScale: number;
+        protected _timeOffset: number;
+        protected _dragonBonesData: DragonBonesData;
+        protected _animationData: AnimationData;
+        protected _timelineData: TimelineData | null;
+        protected _armature: Armature;
+        protected _animationState: AnimationState;
+        protected _actionTimeline: TimelineState;
+        protected _frameArray: Array<number> | Int16Array;
+        protected _frameIntArray: Array<number> | Int16Array;
+        protected _frameFloatArray: Array<number> | Int16Array;
+        protected _timelineArray: Array<number> | Uint16Array;
+        protected _frameIndices: Array<number>;
+        protected _onClear(): void;
+        protected abstract _onArriveAtFrame(): void;
+        protected abstract _onUpdateFrame(): void;
+        protected _setCurrentTime(passedTime: number): boolean;
+        init(armature: Armature, animationState: AnimationState, timelineData: TimelineData | null): void;
+        fadeOut(): void;
+        update(passedTime: number): void;
+    }
+    /**
+     * @internal
+     */
+    abstract class TweenTimelineState extends TimelineState {
+        private static _getEasingValue(tweenType, progress, easing);
+        private static _getEasingCurveValue(progress, samples, count, offset);
+        protected _tweenType: TweenType;
+        protected _curveCount: number;
+        protected _framePosition: number;
+        protected _frameDurationR: number;
+        protected _tweenProgress: number;
+        protected _tweenEasing: number;
+        protected _onClear(): void;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+    }
+    /**
+     * @internal
+     */
+    abstract class BoneTimelineState extends TweenTimelineState {
+        bone: Bone;
+        bonePose: BonePose;
+        protected _onClear(): void;
+        blend(state: number): void;
+    }
+    /**
+     * @internal
+     */
+    abstract class SlotTimelineState extends TweenTimelineState {
+        slot: Slot;
+        protected _onClear(): void;
+    }
+    /**
+     * @internal
+     */
+    abstract class ConstraintTimelineState extends TweenTimelineState {
+        constraint: Constraint;
+        protected _onClear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class ActionTimelineState extends TimelineState {
+        static toString(): string;
+        private _onCrossFrame(frameIndex);
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+        update(passedTime: number): void;
+        setCurrentTime(value: number): void;
+    }
+    /**
+     * @internal
+     */
+    class ZOrderTimelineState extends TimelineState {
+        static toString(): string;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+    }
+    /**
+     * @internal
+     */
+    class BoneAllTimelineState extends BoneTimelineState {
+        static toString(): string;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+        fadeOut(): void;
+    }
+    /**
+     * @internal
+     */
+    class BoneTranslateTimelineState extends BoneTimelineState {
+        static toString(): string;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+    }
+    /**
+     * @internal
+     */
+    class BoneRotateTimelineState extends BoneTimelineState {
+        static toString(): string;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+        fadeOut(): void;
+    }
+    /**
+     * @internal
+     */
+    class BoneScaleTimelineState extends BoneTimelineState {
+        static toString(): string;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+    }
+    /**
+     * @internal
+     */
+    class SurfaceTimelineState extends TweenTimelineState {
+        static toString(): string;
+        surface: Surface;
+        private _frameFloatOffset;
+        private _valueCount;
+        private _deformCount;
+        private _valueOffset;
+        private readonly _current;
+        private readonly _delta;
+        private readonly _result;
+        protected _onClear(): void;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+        init(armature: Armature, animationState: AnimationState, timelineData: TimelineData | null): void;
+        blend(state: number): void;
+    }
+    /**
+     * @internal
+     */
+    class SlotDislayTimelineState extends SlotTimelineState {
+        static toString(): string;
+        protected _onArriveAtFrame(): void;
+    }
+    /**
+     * @internal
+     */
+    class SlotColorTimelineState extends SlotTimelineState {
+        static toString(): string;
+        private _dirty;
+        private readonly _current;
+        private readonly _delta;
+        private readonly _result;
+        protected _onClear(): void;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+        fadeOut(): void;
+        update(passedTime: number): void;
+    }
+    /**
+     * @internal
+     */
+    class DeformTimelineState extends SlotTimelineState {
+        static toString(): string;
+        vertexOffset: number;
+        private _dirty;
+        private _frameFloatOffset;
+        private _valueCount;
+        private _deformCount;
+        private _valueOffset;
+        private readonly _current;
+        private readonly _delta;
+        private readonly _result;
+        protected _onClear(): void;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+        init(armature: Armature, animationState: AnimationState, timelineData: TimelineData | null): void;
+        fadeOut(): void;
+        update(passedTime: number): void;
+    }
+    /**
+     * @internal
+     */
+    class IKConstraintTimelineState extends ConstraintTimelineState {
+        static toString(): string;
+        private _current;
+        private _delta;
+        protected _onClear(): void;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+    }
+    /**
+     * @internal
+     */
+    class AnimationTimelineState extends TweenTimelineState {
+        static toString(): string;
+        animationState: AnimationState;
+        private readonly _floats;
+        protected _onClear(): void;
+        protected _onArriveAtFrame(): void;
+        protected _onUpdateFrame(): void;
+        blend(state: number): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The properties of the object carry basic information about an event,
+     * which are passed as parameter or parameter's parameter to event listeners when an event occurs.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 事件对象，包含有关事件的基本信息，当发生事件时，该实例将作为参数或参数的参数传递给事件侦听器。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    class EventObject extends BaseObject {
+        /**
+         * - Animation start play.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画开始播放。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly START: string;
+        /**
+         * - Animation loop play complete once.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画循环播放完成一次。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly LOOP_COMPLETE: string;
+        /**
+         * - Animation play complete.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画播放完成。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly COMPLETE: string;
+        /**
+         * - Animation fade in start.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡入开始。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly FADE_IN: string;
+        /**
+         * - Animation fade in complete.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡入完成。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly FADE_IN_COMPLETE: string;
+        /**
+         * - Animation fade out start.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡出开始。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly FADE_OUT: string;
+        /**
+         * - Animation fade out complete.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡出完成。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly FADE_OUT_COMPLETE: string;
+        /**
+         * - Animation frame event.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画帧事件。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly FRAME_EVENT: string;
+        /**
+         * - Animation frame sound event.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画帧声音事件。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        static readonly SOUND_EVENT: string;
+        /**
+         * @internal
+         * @private
+         */
+        static actionDataToInstance(data: ActionData, instance: EventObject, armature: Armature): void;
+        static toString(): string;
+        /**
+         * - If is a frame event, the value is used to describe the time that the event was in the animation timeline. (In seconds)
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 如果是帧事件，此值用来描述该事件在动画时间轴中所处的时间。（以秒为单位）
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        time: number;
+        /**
+         * - The event type。
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 事件类型。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        type: EventStringType;
+        /**
+         * - The event name. (The frame event name or the frame sound name)
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 事件名称。 (帧事件的名称或帧声音的名称)
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * - The armature that dispatch the event.
+         * @see dragonBones.Armature
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 发出该事件的骨架。
+         * @see dragonBones.Armature
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        armature: Armature;
+        /**
+         * - The bone that dispatch the event.
+         * @see dragonBones.Bone
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 发出该事件的骨骼。
+         * @see dragonBones.Bone
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        bone: Bone | null;
+        /**
+         * - The slot that dispatch the event.
+         * @see dragonBones.Slot
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 发出该事件的插槽。
+         * @see dragonBones.Slot
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        slot: Slot | null;
+        /**
+         * - The animation state that dispatch the event.
+         * @see dragonBones.AnimationState
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 发出该事件的动画状态。
+         * @see dragonBones.AnimationState
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        animationState: AnimationState;
+        /**
+         * @private
+         */
+        actionData: ActionData | null;
+        /**
+         * @private
+         */
+        /**
+         * - The custom data.
+         * @see dragonBones.CustomData
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 自定义数据。
+         * @see dragonBones.CustomData
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        data: UserData | null;
+        protected _onClear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @private
+     */
+    type EventStringType = string | "start" | "loopComplete" | "complete" | "fadeIn" | "fadeInComplete" | "fadeOut" | "fadeOutComplete" | "frameEvent" | "soundEvent";
+    /**
+     * - The event dispatcher interface.
+     * Dragonbones event dispatch usually relies on docking engine to implement, which defines the event method to be implemented when docking the engine.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 事件派发接口。
+     * DragonBones 的事件派发通常依赖于对接的引擎来实现，该接口定义了对接引擎时需要实现的事件方法。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    interface IEventDispatcher {
+        /**
+         * - Checks whether the object has any listeners registered for a specific type of event。
+         * @param type - Event type.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 检查是否为特定的事件类型注册了任何侦听器。
+         * @param type - 事件类型。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        hasDBEventListener(type: EventStringType): boolean;
+        /**
+         * - Dispatches an event into the event flow.
+         * @param type - Event type.
+         * @param eventObject - Event object.
+         * @see dragonBones.EventObject
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 分派特定的事件到事件流中。
+         * @param type - 事件类型。
+         * @param eventObject - 事件数据。
+         * @see dragonBones.EventObject
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        dispatchDBEvent(type: EventStringType, eventObject: EventObject): void;
+        /**
+         * - Add an event listener object so that the listener receives notification of an event.
+         * @param type - Event type.
+         * @param listener - Event listener.
+         * @param thisObject - The listener function's "this".
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 添加特定事件类型的事件侦听器，以使侦听器能够接收事件通知。
+         * @param type - 事件类型。
+         * @param listener - 事件侦听器。
+         * @param thisObject - 侦听函数绑定的 this 对象。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        addDBEventListener(type: EventStringType, listener: Function, thisObject: any): void;
+        /**
+         * - Removes a listener from the object.
+         * @param type - Event type.
+         * @param listener - Event listener.
+         * @param thisObject - The listener function's "this".
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 删除特定事件类型的侦听器。
+         * @param type - 事件类型。
+         * @param listener - 事件侦听器。
+         * @param thisObject - 侦听函数绑定的 this 对象。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        removeDBEventListener(type: EventStringType, listener: Function, thisObject: any): void;
+        /**
+         * - Deprecated, please refer to {@link #hasDBEventListener()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #hasDBEventListener()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        hasEvent(type: EventStringType): boolean;
+        /**
+         * - Deprecated, please refer to {@link #addDBEventListener()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #addDBEventListener()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        addEvent(type: EventStringType, listener: Function, thisObject: any): void;
+        /**
+         * - Deprecated, please refer to {@link #removeDBEventListener()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #removeDBEventListener()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        removeEvent(type: EventStringType, listener: Function, thisObject: any): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    abstract class DataParser {
+        protected static readonly DATA_VERSION_2_3: string;
+        protected static readonly DATA_VERSION_3_0: string;
+        protected static readonly DATA_VERSION_4_0: string;
+        protected static readonly DATA_VERSION_4_5: string;
+        protected static readonly DATA_VERSION_5_0: string;
+        protected static readonly DATA_VERSION_5_5: string;
+        protected static readonly DATA_VERSION: string;
+        protected static readonly DATA_VERSIONS: Array<string>;
+        protected static readonly TEXTURE_ATLAS: string;
+        protected static readonly SUB_TEXTURE: string;
+        protected static readonly FORMAT: string;
+        protected static readonly IMAGE_PATH: string;
+        protected static readonly WIDTH: string;
+        protected static readonly HEIGHT: string;
+        protected static readonly ROTATED: string;
+        protected static readonly FRAME_X: string;
+        protected static readonly FRAME_Y: string;
+        protected static readonly FRAME_WIDTH: string;
+        protected static readonly FRAME_HEIGHT: string;
+        protected static readonly DRADON_BONES: string;
+        protected static readonly USER_DATA: string;
+        protected static readonly ARMATURE: string;
+        protected static readonly BONE: string;
+        protected static readonly SURFACE: string;
+        protected static readonly SLOT: string;
+        protected static readonly CONSTRAINT: string;
+        protected static readonly IK: string;
+        protected static readonly PATH_CONSTRAINT: string;
+        protected static readonly SKIN: string;
+        protected static readonly DISPLAY: string;
+        protected static readonly ANIMATION: string;
+        protected static readonly Z_ORDER: string;
+        protected static readonly FFD: string;
+        protected static readonly FRAME: string;
+        protected static readonly TRANSLATE_FRAME: string;
+        protected static readonly ROTATE_FRAME: string;
+        protected static readonly SCALE_FRAME: string;
+        protected static readonly DISPLAY_FRAME: string;
+        protected static readonly COLOR_FRAME: string;
+        protected static readonly DEFAULT_ACTIONS: string;
+        protected static readonly ACTIONS: string;
+        protected static readonly EVENTS: string;
+        protected static readonly INTS: string;
+        protected static readonly FLOATS: string;
+        protected static readonly STRINGS: string;
+        protected static readonly CANVAS: string;
+        protected static readonly TRANSFORM: string;
+        protected static readonly PIVOT: string;
+        protected static readonly AABB: string;
+        protected static readonly COLOR: string;
+        protected static readonly VERSION: string;
+        protected static readonly COMPATIBLE_VERSION: string;
+        protected static readonly FRAME_RATE: string;
+        protected static readonly TYPE: string;
+        protected static readonly SUB_TYPE: string;
+        protected static readonly NAME: string;
+        protected static readonly PARENT: string;
+        protected static readonly TARGET: string;
+        protected static readonly STAGE: string;
+        protected static readonly SHARE: string;
+        protected static readonly PATH: string;
+        protected static readonly LENGTH: string;
+        protected static readonly DISPLAY_INDEX: string;
+        protected static readonly BLEND_MODE: string;
+        protected static readonly INHERIT_TRANSLATION: string;
+        protected static readonly INHERIT_ROTATION: string;
+        protected static readonly INHERIT_SCALE: string;
+        protected static readonly INHERIT_REFLECTION: string;
+        protected static readonly INHERIT_ANIMATION: string;
+        protected static readonly INHERIT_DEFORM: string;
+        protected static readonly SEGMENT_X: string;
+        protected static readonly SEGMENT_Y: string;
+        protected static readonly BEND_POSITIVE: string;
+        protected static readonly CHAIN: string;
+        protected static readonly WEIGHT: string;
+        protected static readonly FADE_IN_TIME: string;
+        protected static readonly PLAY_TIMES: string;
+        protected static readonly SCALE: string;
+        protected static readonly OFFSET: string;
+        protected static readonly POSITION: string;
+        protected static readonly DURATION: string;
+        protected static readonly TWEEN_EASING: string;
+        protected static readonly TWEEN_ROTATE: string;
+        protected static readonly TWEEN_SCALE: string;
+        protected static readonly CLOCK_WISE: string;
+        protected static readonly CURVE: string;
+        protected static readonly SOUND: string;
+        protected static readonly EVENT: string;
+        protected static readonly ACTION: string;
+        protected static readonly X: string;
+        protected static readonly Y: string;
+        protected static readonly SKEW_X: string;
+        protected static readonly SKEW_Y: string;
+        protected static readonly SCALE_X: string;
+        protected static readonly SCALE_Y: string;
+        protected static readonly VALUE: string;
+        protected static readonly ROTATE: string;
+        protected static readonly SKEW: string;
+        protected static readonly ALPHA_OFFSET: string;
+        protected static readonly RED_OFFSET: string;
+        protected static readonly GREEN_OFFSET: string;
+        protected static readonly BLUE_OFFSET: string;
+        protected static readonly ALPHA_MULTIPLIER: string;
+        protected static readonly RED_MULTIPLIER: string;
+        protected static readonly GREEN_MULTIPLIER: string;
+        protected static readonly BLUE_MULTIPLIER: string;
+        protected static readonly UVS: string;
+        protected static readonly VERTICES: string;
+        protected static readonly TRIANGLES: string;
+        protected static readonly WEIGHTS: string;
+        protected static readonly SLOT_POSE: string;
+        protected static readonly BONE_POSE: string;
+        protected static readonly GLUE_WEIGHTS: string;
+        protected static readonly GLUE_MESHES: string;
+        protected static readonly BONES: string;
+        protected static readonly POSITION_MODE: string;
+        protected static readonly SPACING_MODE: string;
+        protected static readonly ROTATE_MODE: string;
+        protected static readonly SPACING: string;
+        protected static readonly ROTATE_OFFSET: string;
+        protected static readonly ROTATE_MIX: string;
+        protected static readonly TRANSLATE_MIX: string;
+        protected static readonly TARGET_DISPLAY: string;
+        protected static readonly CLOSED: string;
+        protected static readonly CONSTANT_SPEED: string;
+        protected static readonly VERTEX_COUNT: string;
+        protected static readonly LENGTHS: string;
+        protected static readonly GOTO_AND_PLAY: string;
+        protected static readonly DEFAULT_NAME: string;
+        protected static _getArmatureType(value: string): ArmatureType;
+        protected static _getBoneType(value: string): BoneType;
+        protected static _getDisplayType(value: string): DisplayType;
+        protected static _getBoundingBoxType(value: string): BoundingBoxType;
+        protected static _getActionType(value: string): ActionType;
+        protected static _getBlendMode(value: string): BlendMode;
+        protected static _getPositionMode(value: string): PositionMode;
+        protected static _getSpacingMode(value: string): SpacingMode;
+        protected static _getRotateMode(value: string): RotateMode;
+        abstract parseDragonBonesData(rawData: any, scale: number): DragonBonesData | null;
+        abstract parseTextureAtlasData(rawData: any, textureAtlasData: TextureAtlasData, scale: number): boolean;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parsetTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parsetTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static parseDragonBonesData(rawData: any): DragonBonesData | null;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parsetTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parsetTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static parseTextureAtlasData(rawData: any, scale?: number): any;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class ObjectDataParser extends DataParser {
+        protected static _getBoolean(rawData: any, key: string, defaultValue: boolean): boolean;
+        protected static _getNumber(rawData: any, key: string, defaultValue: number): number;
+        protected static _getString(rawData: any, key: string, defaultValue: string): string;
+        protected _rawTextureAtlasIndex: number;
+        protected readonly _rawBones: Array<BoneData>;
+        protected _data: DragonBonesData;
+        protected _armature: ArmatureData;
+        protected _bone: BoneData;
+        protected _surface: SurfaceData;
+        protected _slot: SlotData;
+        protected _skin: SkinData;
+        protected _mesh: MeshDisplayData;
+        protected _animation: AnimationData;
+        protected _timeline: TimelineData;
+        protected _rawTextureAtlases: Array<any> | null;
+        private _defaultColorOffset;
+        private _prevClockwise;
+        private _prevRotation;
+        private readonly _helpMatrixA;
+        private readonly _helpMatrixB;
+        private readonly _helpTransform;
+        private readonly _helpColorTransform;
+        private readonly _helpPoint;
+        private readonly _helpArray;
+        private readonly _intArray;
+        private readonly _floatArray;
+        private readonly _frameIntArray;
+        private readonly _frameFloatArray;
+        private readonly _frameArray;
+        private readonly _timelineArray;
+        private readonly _cacheRawMeshes;
+        private readonly _cacheMeshes;
+        private readonly _actionFrames;
+        private readonly _weightSlotPose;
+        private readonly _weightBonePoses;
+        private readonly _cacheBones;
+        private readonly _slotChildActions;
+        private _getCurvePoint(x1, y1, x2, y2, x3, y3, x4, y4, t, result);
+        private _samplingEasingCurve(curve, samples);
+        private _parseActionDataInFrame(rawData, frameStart, bone, slot);
+        private _mergeActionFrame(rawData, frameStart, type, bone, slot);
+        protected _parseArmature(rawData: any, scale: number): ArmatureData;
+        protected _parseBone(rawData: any): BoneData;
+        protected _parseIKConstraint(rawData: any): ConstraintData | null;
+        protected _parsePathConstraint(rawData: any): ConstraintData | null;
+        protected _parseSlot(rawData: any, zOrder: number): SlotData;
+        protected _parseSkin(rawData: any): SkinData;
+        protected _parseDisplay(rawData: any): DisplayData | null;
+        protected _parsePath(rawData: any, display: PathDisplayData): void;
+        protected _parsePivot(rawData: any, display: ImageDisplayData): void;
+        protected _parseMesh(rawData: any, mesh: MeshDisplayData): void;
+        protected _parseMeshGlue(rawData: any, mesh: MeshDisplayData): void;
+        protected _parseBoundingBox(rawData: any): BoundingBoxData | null;
+        protected _parsePolygonBoundingBox(rawData: any): PolygonBoundingBoxData;
+        protected _parseAnimation(rawData: any): AnimationData;
+        protected _parseTimeline(rawData: any, rawFrames: Array<any> | null, framesKey: string, type: TimelineType, addIntOffset: boolean, addFloatOffset: boolean, frameValueCount: number, frameParser: (rawData: any, frameStart: number, frameCount: number) => number): TimelineData | null;
+        protected _parseBoneTimeline(rawData: any): void;
+        protected _parseSlotTimeline(rawData: any): void;
+        protected _parseFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseTweenFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseActionFrame(frame: ActionFrame, frameStart: number, frameCount: number): number;
+        protected _parseZOrderFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseBoneAllFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseBoneTranslateFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseBoneRotateFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseBoneScaleFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseSurfaceFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseSlotDisplayFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseSlotColorFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseSlotFFDFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseIKConstraintFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseAnimationFrame(rawData: any, frameStart: number, frameCount: number): number;
+        protected _parseActionData(rawData: any, type: ActionType, bone: BoneData | null, slot: SlotData | null): Array<ActionData>;
+        protected _parseTransform(rawData: any, transform: Transform, scale: number): void;
+        protected _parseColorTransform(rawData: any, color: ColorTransform): void;
+        protected _parseArray(rawData: any): void;
+        protected _modifyArray(): void;
+        parseDragonBonesData(rawData: any, scale?: number): DragonBonesData | null;
+        parseTextureAtlasData(rawData: any, textureAtlasData: TextureAtlasData, scale?: number): boolean;
+        private static _objectDataParserInstance;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parseDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parseDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static getInstance(): ObjectDataParser;
+    }
+    /**
+     * @internal
+     */
+    class ActionFrame {
+        frameStart: number;
+        readonly actions: Array<number>;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    class BinaryDataParser extends ObjectDataParser {
+        private _binaryOffset;
+        private _binary;
+        private _intArrayBuffer;
+        private _floatArrayBuffer;
+        private _frameIntArrayBuffer;
+        private _frameFloatArrayBuffer;
+        private _frameArrayBuffer;
+        private _timelineArrayBuffer;
+        private _inRange(a, min, max);
+        private _decodeUTF8(data);
+        private _getUTF16Key(value);
+        private _parseBinaryTimeline(type, offset, timelineData?);
+        private _parseVertices(rawData, vertices);
+        protected _parseMesh(rawData: any, mesh: MeshDisplayData): void;
+        protected _parsePath(rawData: any, path: PathDisplayData): void;
+        protected _parseAnimation(rawData: any): AnimationData;
+        protected _parseArray(rawData: any): void;
+        parseDragonBonesData(rawData: any, scale?: number): DragonBonesData | null;
+        private static _binaryDataParserInstance;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parseDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parseDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static getInstance(): BinaryDataParser;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - Base class for the factory that create the armatures. (Typically only one global factory instance is required)
+     * The factory instance create armatures by parsed and added DragonBonesData instances and TextureAtlasData instances.
+     * Once the data has been parsed, it has been cached in the factory instance and does not need to be parsed again until it is cleared by the factory instance.
+     * @see dragonBones.DragonBonesData
+     * @see dragonBones.TextureAtlasData
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 创建骨架的工厂基类。 （通常只需要一个全局工厂实例）
+     * 工厂通过解析并添加的 DragonBonesData 实例和 TextureAtlasData 实例来创建骨架。
+     * 当数据被解析过之后，已经添加到工厂中，在没有被工厂清理之前，不需要再次解析。
+     * @see dragonBones.DragonBonesData
+     * @see dragonBones.TextureAtlasData
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    abstract class BaseFactory {
+        protected static _objectParser: ObjectDataParser;
+        protected static _binaryParser: BinaryDataParser;
+        /**
+         * @private
+         */
+        autoSearch: boolean;
+        protected readonly _dragonBonesDataMap: Map<DragonBonesData>;
+        protected readonly _textureAtlasDataMap: Map<Array<TextureAtlasData>>;
+        protected _dragonBones: DragonBones;
+        protected _dataParser: DataParser;
+        /**
+         * - Create a factory instance. (typically only one global factory instance is required)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建一个工厂实例。 （通常只需要一个全局工厂实例）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        constructor(dataParser?: DataParser | null);
+        protected _isSupportMesh(): boolean;
+        protected _getTextureData(textureAtlasName: string, textureName: string): TextureData | null;
+        protected _fillBuildArmaturePackage(dataPackage: BuildArmaturePackage, dragonBonesName: string, armatureName: string, skinName: string, textureAtlasName: string): boolean;
+        protected _buildBones(dataPackage: BuildArmaturePackage, armature: Armature): void;
+        /**
+         * @private
+         */
+        protected _buildSlots(dataPackage: BuildArmaturePackage, armature: Armature): void;
+        protected _buildConstraints(dataPackage: BuildArmaturePackage, armature: Armature): void;
+        protected _buildChildArmature(dataPackage: BuildArmaturePackage | null, slot: Slot, displayData: DisplayData): Armature | null;
+        protected _getSlotDisplay(dataPackage: BuildArmaturePackage | null, displayData: DisplayData, rawDisplayData: DisplayData | null, slot: Slot): any;
+        protected abstract _buildTextureAtlasData(textureAtlasData: TextureAtlasData | null, textureAtlas: any): TextureAtlasData;
+        protected abstract _buildArmature(dataPackage: BuildArmaturePackage): Armature;
+        protected abstract _buildSlot(dataPackage: BuildArmaturePackage, slotData: SlotData, armature: Armature): Slot;
+        /**
+         * - Parse the raw data to a DragonBonesData instance and cache it to the factory.
+         * @param rawData - The raw data.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (If not set, use the instance name instead)
+         * @param scale - Specify a scaling value for all armatures. (Default: 1.0)
+         * @returns DragonBonesData instance
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 将原始数据解析为 DragonBonesData 实例，并缓存到工厂中。
+         * @param rawData - 原始数据。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @param scale - 为所有的骨架指定一个缩放值。 （默认: 1.0）
+         * @returns DragonBonesData 实例
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        parseDragonBonesData(rawData: any, name?: string | null, scale?: number): DragonBonesData | null;
+        /**
+         * - Parse the raw texture atlas data and the texture atlas object to a TextureAtlasData instance and cache it to the factory.
+         * @param rawData - The raw texture atlas data.
+         * @param textureAtlas - The texture atlas object.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (If not set, use the instance name instead)
+         * @param scale - Specify a scaling value for the map set. (Default: 1.0)
+         * @returns TextureAtlasData instance
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 将原始贴图集数据和贴图集对象解析为 TextureAtlasData 实例，并缓存到工厂中。
+         * @param rawData - 原始贴图集数据。
+         * @param textureAtlas - 贴图集对象。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @param scale - 为贴图集指定一个缩放值。 （默认: 1.0）
+         * @returns TextureAtlasData 实例
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        parseTextureAtlasData(rawData: any, textureAtlas: any, name?: string | null, scale?: number): TextureAtlasData;
+        /**
+         * @private
+         */
+        updateTextureAtlasData(name: string, textureAtlases: Array<any>): void;
+        /**
+         * - Get a specific DragonBonesData instance.
+         * @param name - The DragonBonesData instance cache name.
+         * @returns DragonBonesData instance
+         * @see #parseDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的 DragonBonesData 实例。
+         * @param name - DragonBonesData 实例的缓存名称。
+         * @returns DragonBonesData 实例
+         * @see #parseDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getDragonBonesData(name: string): DragonBonesData | null;
+        /**
+         * - Cache a DragonBonesData instance to the factory.
+         * @param data - The DragonBonesData instance.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (if not set, use the instance name instead)
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将 DragonBonesData 实例缓存到工厂中。
+         * @param data - DragonBonesData 实例。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        addDragonBonesData(data: DragonBonesData, name?: string | null): void;
+        /**
+         * - Remove a DragonBonesData instance.
+         * @param name - The DragonBonesData instance cache name.
+         * @param disposeData - Whether to dispose data. (Default: true)
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 移除 DragonBonesData 实例。
+         * @param name - DragonBonesData 实例缓存名称。
+         * @param disposeData - 是否释放数据。 （默认: true）
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        removeDragonBonesData(name: string, disposeData?: boolean): void;
+        /**
+         * - Get a list of specific TextureAtlasData instances.
+         * @param name - The TextureAtlasData cahce name.
+         * @see #parseTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的 TextureAtlasData 实例列表。
+         * @param name - TextureAtlasData 实例缓存名称。
+         * @see #parseTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getTextureAtlasData(name: string): Array<TextureAtlasData> | null;
+        /**
+         * - Cache a TextureAtlasData instance to the factory.
+         * @param data - The TextureAtlasData instance.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (if not set, use the instance name instead)
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将 TextureAtlasData 实例缓存到工厂中。
+         * @param data - TextureAtlasData 实例。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        addTextureAtlasData(data: TextureAtlasData, name?: string | null): void;
+        /**
+         * - Remove a TextureAtlasData instance.
+         * @param name - The TextureAtlasData instance cache name.
+         * @param disposeData - Whether to dispose data.
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 移除 TextureAtlasData 实例。
+         * @param name - TextureAtlasData 实例的缓存名称。
+         * @param disposeData - 是否释放数据。
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        removeTextureAtlasData(name: string, disposeData?: boolean): void;
+        /**
+         * - Get a specific armature data.
+         * @param name - The armature data name.
+         * @param dragonBonesName - The cached name for DragonbonesData instance.
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨架数据。
+         * @param name - 骨架数据名称。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        getArmatureData(name: string, dragonBonesName?: string): ArmatureData | null;
+        /**
+         * - Clear all cached DragonBonesData instances and TextureAtlasData instances.
+         * @param disposeData - Whether to dispose data.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除缓存的所有 DragonBonesData 实例和 TextureAtlasData 实例。
+         * @param disposeData - 是否释放数据。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        clear(disposeData?: boolean): void;
+        /**
+         * - Create a armature from cached DragonBonesData instances and TextureAtlasData instances.
+         * Note that when the created armature that is no longer in use, you need to explicitly dispose {@link #dragonBones.Armature#dispose()}.
+         * @param armatureName - The armature data name.
+         * @param dragonBonesName - The cached name of the DragonBonesData instance. (If not set, all DragonBonesData instances are retrieved, and when multiple DragonBonesData instances contain a the same name armature data, it may not be possible to accurately create a specific armature)
+         * @param skinName - The skin name, you can set a different ArmatureData name to share it's skin data. (If not set, use the default skin data)
+         * @returns The armature.
+         * @example
+         * <pre>
+         *     let armature = factory.buildArmature("armatureName", "dragonBonesName");
+         *     armature.clock = factory.clock;
+         * </pre>
+         * @see dragonBones.DragonBonesData
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 通过缓存的 DragonBonesData 实例和 TextureAtlasData 实例创建一个骨架。
+         * 注意，创建的骨架不再使用时，需要显式释放 {@link #dragonBones.Armature#dispose()}。
+         * @param armatureName - 骨架数据名称。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。 （如果未设置，将检索所有的 DragonBonesData 实例，当多个 DragonBonesData 实例中包含同名的骨架数据时，可能无法准确的创建出特定的骨架）
+         * @param skinName - 皮肤名称，可以设置一个其他骨架数据名称来共享其皮肤数据。（如果未设置，则使用默认的皮肤数据）
+         * @returns 骨架。
+         * @example
+         * <pre>
+         *     let armature = factory.buildArmature("armatureName", "dragonBonesName");
+         *     armature.clock = factory.clock;
+         * </pre>
+         * @see dragonBones.DragonBonesData
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        buildArmature(armatureName: string, dragonBonesName?: string, skinName?: string, textureAtlasName?: string): Armature | null;
+        /**
+         * @private
+         */
+        replaceDisplay(slot: Slot, displayData: DisplayData, displayIndex?: number): void;
+        /**
+         * - Replaces the current display data for a particular slot with a specific display data.
+         * Specify display data with "dragonBonesName/armatureName/slotName/displayName".
+         * @param dragonBonesName - The DragonBonesData instance cache name.
+         * @param armatureName - The armature data name.
+         * @param slotName - The slot data name.
+         * @param displayName - The display data name.
+         * @param slot - The slot.
+         * @param displayIndex - The index of the display data that is replaced. (If it is not set, replaces the current display data)
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         *     factory.replaceSlotDisplay("dragonBonesName", "armatureName", "slotName", "displayName", slot);
+         * </pre>
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 用特定的显示对象数据替换特定插槽当前的显示对象数据。
+         * 用 "dragonBonesName/armatureName/slotName/displayName" 指定显示对象数据。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。
+         * @param armatureName - 骨架数据名称。
+         * @param slotName - 插槽数据名称。
+         * @param displayName - 显示对象数据名称。
+         * @param slot - 插槽。
+         * @param displayIndex - 被替换的显示对象数据的索引。 （如果未设置，则替换当前的显示对象数据）
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         *     factory.replaceSlotDisplay("dragonBonesName", "armatureName", "slotName", "displayName", slot);
+         * </pre>
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        replaceSlotDisplay(dragonBonesName: string, armatureName: string, slotName: string, displayName: string, slot: Slot, displayIndex?: number): boolean;
+        /**
+         * @private
+         */
+        replaceSlotDisplayList(dragonBonesName: string | null, armatureName: string, slotName: string, slot: Slot): boolean;
+        /**
+         * - Share specific skin data with specific armature.
+         * @param armature - The armature.
+         * @param skin - The skin data.
+         * @param isOverride - Whether it completely override the original skin. (Default: false)
+         * @param exclude - A list of slot names that do not need to be replace.
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB && armatureDataB.defaultSkin) {
+         *     factory.replaceSkin(armatureA, armatureDataB.defaultSkin, false, ["arm_l", "weapon_l"]);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.SkinData
+         * @version DragonBones 5.6
+         * @language en_US
+         */
+        /**
+         * - 将特定的皮肤数据共享给特定的骨架使用。
+         * @param armature - 骨架。
+         * @param skin - 皮肤数据。
+         * @param isOverride - 是否完全覆盖原来的皮肤。 （默认: false）
+         * @param exclude - 不需要被替换的插槽名称列表。
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB && armatureDataB.defaultSkin) {
+         *     factory.replaceSkin(armatureA, armatureDataB.defaultSkin, false, ["arm_l", "weapon_l"]);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.SkinData
+         * @version DragonBones 5.6
+         * @language zh_CN
+         */
+        replaceSkin(armature: Armature, skin: SkinData, isOverride?: boolean, exclude?: Array<string> | null): boolean;
+        /**
+         * - Replaces the existing animation data for a specific armature with the animation data for the specific armature data.
+         * This enables you to make a armature template so that other armature without animations can share it's animations.
+         * @param armature - The armtaure.
+         * @param armatureData - The armature data.
+         * @param isOverride - Whether to completely overwrite the original animation. (Default: false)
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB) {
+         *     factory.replaceAnimation(armatureA, armatureDataB);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.6
+         * @language en_US
+         */
+        /**
+         * - 用特定骨架数据的动画数据替换特定骨架现有的动画数据。
+         * 这样就能实现制作一个骨架动画模板，让其他没有制作动画的骨架共享该动画。
+         * @param armature - 骨架。
+         * @param armatureData - 骨架数据。
+         * @param isOverride - 是否完全覆盖原来的动画。（默认: false）
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB) {
+         *     factory.replaceAnimation(armatureA, armatureDataB);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.6
+         * @language zh_CN
+         */
+        replaceAnimation(armature: Armature, armatureData: ArmatureData, isOverride?: boolean): boolean;
+        /**
+         * @private
+         */
+        getAllDragonBonesData(): Map<DragonBonesData>;
+        /**
+         * @private
+         */
+        getAllTextureAtlasData(): Map<Array<TextureAtlasData>>;
+        /**
+         * - An Worldclock instance updated by engine.
+         * @version DragonBones 5.7
+         * @language en_US
+         */
+        /**
+         * - 由引擎驱动的 WorldClock 实例。
+         * @version DragonBones 5.7
+         * @language zh_CN
+         */
+        readonly clock: WorldClock;
+        /**
+         * @private
+         */
+        readonly dragonBones: DragonBones;
+        /**
+         * - Deprecated, please refer to {@link #replaceSkin}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #replaceSkin}。
+         * @deprecated
+         * @language zh_CN
+         */
+        changeSkin(armature: Armature, skin: SkinData, exclude?: Array<string> | null): boolean;
+        /**
+         * - Deprecated, please refer to {@link #replaceAnimation}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #replaceAnimation}。
+         * @deprecated
+         * @language zh_CN
+         */
+        copyAnimationsToArmature(toArmature: Armature, fromArmatreName: string, fromSkinName?: string, fromDragonBonesDataName?: string, replaceOriginalAnimation?: boolean): boolean;
+    }
+    /**
+     * @internal
+     */
+    class BuildArmaturePackage {
+        dataName: string;
+        textureAtlasName: string;
+        data: DragonBonesData;
+        armature: ArmatureData;
+        skin: SkinData | null;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The egret texture atlas data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Egret 贴图集数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class EgretTextureAtlasData extends TextureAtlasData {
+        static toString(): string;
+        /**
+         * @internal
+         */
+        disposeEnabled: boolean;
+        private _renderTexture;
+        protected _onClear(): void;
+        /**
+         * @inheritDoc
+         */
+        createTexture(): TextureData;
+        /**
+         * - The Egret texture.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - Egret 贴图。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        renderTexture: egret.Texture | null;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#removeTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#removeTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        dispose(): void;
+        /**
+         * - Deprecated, please refer to {@link #renderTexture}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #renderTexture}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly texture: egret.Texture | null;
+    }
+    /**
+     * @internal
+     */
+    class EgretTextureData extends TextureData {
+        static toString(): string;
+        renderTexture: egret.Texture | null;
+        protected _onClear(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The egret event.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - Egret 事件。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    class EgretEvent extends egret.Event {
+        /**
+         * - The event object.
+         * @see dragonBones.EventObject
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 事件对象。
+         * @see dragonBones.EventObject
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly eventObject: EventObject;
+        /**
+         * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#animationState}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#animationState}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly animationName: string;
+        /**
+         * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#armature}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#armature}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly armature: Armature;
+        /**
+         * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#bone}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#bone}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly bone: Bone | null;
+        /**
+         * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#slot}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#slot}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly slot: Slot | null;
+        /**
+         * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#animationState}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#animationState}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly animationState: AnimationState | null;
+        /**
+         * Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#name}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#name}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly frameLabel: string;
+        /**
+         * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#name}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#name}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly sound: string;
+        /**
+         * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#animationState}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#animationState}。
+         * @deprecated
+         * @language zh_CN
+         */
+        readonly movementID: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.START}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.START}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static START: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.LOOP_COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.LOOP_COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static LOOP_COMPLETE: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static COMPLETE: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_IN}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_IN}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static FADE_IN: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_IN_COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_IN_COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static FADE_IN_COMPLETE: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_OUT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_OUT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static FADE_OUT: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_OUT_COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_OUT_COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static FADE_OUT_COMPLETE: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static FRAME_EVENT: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.SOUND_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.SOUND_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static SOUND_EVENT: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static ANIMATION_FRAME_EVENT: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static BONE_FRAME_EVENT: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static MOVEMENT_FRAME_EVENT: string;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.SOUND_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.SOUND_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static SOUND: string;
+    }
+    /**
+     * @inheritDoc
+     */
+    class EgretArmatureDisplay extends egret.DisplayObjectContainer implements IArmatureProxy {
+        private static _cleanBeforeRender();
+        /**
+         * @private
+         */
+        debugDraw: boolean;
+        /**
+         * @internal
+         */
+        _batchEnabled: boolean;
+        /**
+         * @internal
+         */
+        _childDirty: boolean;
+        private _debugDraw;
+        private _armature;
+        private _bounds;
+        private _debugDrawer;
+        /**
+         * @inheritDoc
+         */
+        dbInit(armature: Armature): void;
+        /**
+         * @inheritDoc
+         */
+        dbClear(): void;
+        /**
+         * @inheritDoc
+         */
+        dbUpdate(): void;
+        /**
+         * @inheritDoc
+         */
+        dispose(disposeProxy?: boolean): void;
+        /**
+         * @inheritDoc
+         */
+        dispatchDBEvent(type: EventStringType, eventObject: EventObject): void;
+        /**
+         * @inheritDoc
+         */
+        hasDBEventListener(type: EventStringType): boolean;
+        /**
+         * @inheritDoc
+         */
+        addDBEventListener(type: EventStringType, listener: (event: EgretEvent) => void, target: any): void;
+        /**
+         * @inheritDoc
+         */
+        removeDBEventListener(type: EventStringType, listener: (event: EgretEvent) => void, target: any): void;
+        /**
+         * - Disable the batch.
+         * Batch rendering for performance reasons, the boundary properties of the render object are not updated.
+         * This will not correctly obtain the wide-height properties of the rendered object and the transformation properties of its internal display objects,
+         * which can turn off batch rendering if you need to use these properties.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 关闭批次渲染。
+         * 批次渲染出于性能考虑，不会更新渲染对象的边界属性。
+         * 这样将无法正确获得渲染对象的宽高属性以及其内部显示对象的变换属性，如果需要使用这些属性，可以关闭批次渲染。
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        disableBatch(): void;
+        /**
+         * @inheritDoc
+         */
+        readonly armature: Armature;
+        /**
+         * @inheritDoc
+         */
+        readonly animation: Animation;
+        /**
+         * @inheritDoc
+         */
+        $measureContentBounds(bounds: egret.Rectangle): void;
+        /**
+         * @inheritDoc
+         */
+        hasEvent(type: EventStringType): boolean;
+        /**
+         * @inheritDoc
+         */
+        addEvent(type: EventStringType, listener: (event: EgretEvent) => void, target: any): void;
+        /**
+         * @inheritDoc
+         */
+        removeEvent(type: EventStringType, listener: (event: EgretEvent) => void, target: any): void;
+        /**
+         * - Deprecated, please refer to {@link dragonBones.Armature#clock} {@link dragonBones.BaseFactory#clock}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.Armature#clock} {@link dragonBones.BaseFactory#clock}。
+         * @deprecated
+         * @language zh_CN
+         */
+        advanceTimeBySelf(on: boolean): void;
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.Armature}。
+     * @deprecated
+     * @language zh_CN
+     */
+    type FastArmature = Armature;
+    /**
+     * 已废弃，请参考 {@link dragonBones.Bone}。
+     * @deprecated
+     * @language zh_CN
+     */
+    type FastBone = Bone;
+    /**
+     * 已废弃，请参考 {@link dragonBones.Slot}。
+     * @deprecated
+     * @language zh_CN
+     */
+    type FastSlot = Slot;
+    /**
+     * 已废弃，请参考 {@link dragonBones.Animation}。
+     * @deprecated
+     * @language zh_CN
+     */
+    type FastAnimation = Animation;
+    /**
+     * 已废弃，请参考 {@link dragonBones.AnimationState}。
+     * @deprecated
+     * @language zh_CN
+     */
+    type FastAnimationState = AnimationState;
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class Event extends EgretEvent {
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class ArmatureEvent extends EgretEvent {
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class AnimationEvent extends EgretEvent {
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class FrameEvent extends EgretEvent {
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class SoundEvent extends EgretEvent {
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.BaseFacory#parseTextureAtlasData()}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class EgretTextureAtlas extends EgretTextureAtlasData {
+        static toString(): string;
+        /**
+         * 已废弃，请参考 {@link dragonBones.BaseFacory#parseTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        constructor(texture: egret.Texture, rawData: any, scale?: number);
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.BaseFacory#parseTextureAtlasData()}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class EgretSheetAtlas extends EgretTextureAtlas {
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretFactory#soundEventManager}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class SoundEventManager {
+        /**
+         * 已废弃，请参考 {@link dragonBones.EgretFactory#soundEventManager}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static getInstance(): EgretArmatureDisplay;
+    }
+    /**
+     * 已废弃，请参考 {@link dragonBones.Armature#cacheFrameRate}。
+     * @deprecated
+     * @language zh_CN
+     */
+    class AnimationCacheManager {
+        /**
+         * 已废弃，请参考 {@link dragonBones.Armature#cacheFrameRate}。
+         * @deprecated
+         * @language zh_CN
+         */
+        constructor();
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * - The egret slot.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Egret 插槽。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class EgretSlot extends Slot {
+        static toString(): string;
+        /**
+         * - Whether to update the transform properties of the display object.
+         * For better performance, the transform properties of display object (x, y, rotation, ScaleX, ScaleX) are not updated and need to be set to true if these properties need to be accessed correctly.
+         * @default false
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        /**
+         * - 是否更新显示对象的变换属性。
+         * 为了更好的性能, 默认并不会更新显示对象的变换属性 (x, y, rotation, scaleX, scaleX), 如果需要正确访问这些属性, 则需要设置为 true 。
+         * @default false
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        transformUpdateEnabled: boolean;
+        private _armatureDisplay;
+        private _renderDisplay;
+        private _colorFilter;
+        /**
+         * @inheritDoc
+         */
+        init(slotData: SlotData, armatureValue: Armature, rawDisplay: any, meshDisplay: any): void;
+        protected _onClear(): void;
+        protected _initDisplay(value: any, isRetain: boolean): void;
+        protected _disposeDisplay(value: any, isRelease: boolean): void;
+        protected _onUpdateDisplay(): void;
+        protected _addDisplay(): void;
+        protected _replaceDisplay(value: any): void;
+        protected _removeDisplay(): void;
+        protected _updateZOrder(): void;
+        /**
+         * @internal
+         */
+        _updateVisible(): void;
+        protected _updateBlendMode(): void;
+        protected _updateColor(): void;
+        protected _updateFrame(): void;
+        protected _updateMesh(): void;
+        /**
+         * @internal
+         */
+        _updateGlueMesh(): void;
+        protected _updateTransform(): void;
+        protected _identityTransform(): void;
+        private _updateTransformV4();
+        private _updateTransformV5();
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare namespace dragonBones {
+    /**
+     * @internal
+     */
+    const isV5: boolean;
+    /**
+     * - The Egret factory.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Egret 工厂。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    class EgretFactory extends BaseFactory {
+        private static _time;
+        private static _dragonBonesInstance;
+        private static _factory;
+        private static _clockHandler(time);
+        /**
+         * - A global factory instance that can be used directly.
+         * @version DragonBones 4.7
+         * @language en_US
+         */
+        /**
+         * - 一个可以直接使用的全局工厂实例。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        static readonly factory: EgretFactory;
+        /**
+         * @inheritDoc
+         */
+        constructor(dataParser?: DataParser | null);
+        protected _isSupportMesh(): boolean;
+        protected _buildTextureAtlasData(textureAtlasData: EgretTextureAtlasData | null, textureAtlas: egret.Texture | HTMLImageElement | null): EgretTextureAtlasData;
+        protected _buildArmature(dataPackage: BuildArmaturePackage): Armature;
+        protected _buildSlot(dataPackage: BuildArmaturePackage, slotData: SlotData, armature: Armature): Slot;
+        /**
+         * - Create a armature from cached DragonBonesData instances and TextureAtlasData instances, then use the {@link #clock} to update it.
+         * Note that when the created armature proxy that is no longer in use, you need to explicitly dispose {@link #dragonBones.IArmatureProxy#dispose()}.
+         * The difference is that the armature created by {@link #buildArmature} is not WorldClock instance update.
+         * @param armatureName - The armature data name.
+         * @param dragonBonesName - The cached name of the DragonBonesData instance. (If not set, all DragonBonesData instances are retrieved, and when multiple DragonBonesData instances contain a the same name armature data, it may not be possible to accurately create a specific armature)
+         * @param skinName - The skin name, you can set a different ArmatureData name to share it's skin data. (If not set, use the default skin data)
+         * @returns The armature display container.
+         * @see dragonBones.IArmatureProxy
+         * @see dragonBones.BaseFactory#buildArmature
+         * @version DragonBones 4.5
+         * @example
+         * <pre>
+         *     let armatureDisplay = factory.buildArmatureDisplay("armatureName", "dragonBonesName");
+         * </pre>
+         * @language en_US
+         */
+        /**
+         * - 通过缓存的 DragonBonesData 实例和 TextureAtlasData 实例创建一个骨架，并用 {@link #clock} 更新该骨架。
+         * 区别在于由 {@link #buildArmature} 创建的骨架没有 WorldClock 实例驱动。
+         * 注意，创建的骨架代理不再使用时，需要显式释放 {@link #dragonBones.IArmatureProxy#dispose()}。
+         * @param armatureName - 骨架数据名称。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。 （如果未设置，将检索所有的 DragonBonesData 实例，当多个 DragonBonesData 实例中包含同名的骨架数据时，可能无法准确的创建出特定的骨架）
+         * @param skinName - 皮肤名称，可以设置一个其他骨架数据名称来共享其皮肤数据。（如果未设置，则使用默认的皮肤数据）
+         * @returns 骨架的显示容器。
+         * @see dragonBones.IArmatureProxy
+         * @see dragonBones.BaseFactory#buildArmature
+         * @version DragonBones 4.5
+         * @example
+         * <pre>
+         *     let armatureDisplay = factory.buildArmatureDisplay("armatureName", "dragonBonesName");
+         * </pre>
+         * @language zh_CN
+         */
+        buildArmatureDisplay(armatureName: string, dragonBonesName?: string, skinName?: string, textureAtlasName?: string): EgretArmatureDisplay | null;
+        /**
+         * - Create the display object with the specified texture.
+         * @param textureName - The texture data name.
+         * @param textureAtlasName - The texture atlas data name. (Of not set, all texture atlas data will be searched)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建带有指定贴图的显示对象。
+         * @param textureName - 贴图数据名称。
+         * @param textureAtlasName - 贴图集数据名称。 （如果未设置，将检索所有的贴图集数据）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        getTextureDisplay(textureName: string, textureAtlasName?: string | null): egret.Bitmap | null;
+        /**
+         * - A global sound event manager.
+         * Sound events can be listened to uniformly from the manager.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 全局声音事件管理器。
+         * 声音事件可以从该管理器统一侦听。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        readonly soundEventManager: EgretArmatureDisplay;
+        /**
+         * - Deprecated, please refer to {@link #clock}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #clock}。
+         * @deprecated
+         * @language zh_CN
+         */
+        static readonly clock: WorldClock;
+        /**
+         * - Deprecated, please refer to {@link #addDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #addDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        addSkeletonData(dragonBonesData: DragonBonesData, dragonBonesName?: string | null): void;
+        /**
+         * - Deprecated, please refer to {@link #getDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #getDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        getSkeletonData(dragonBonesName: string): DragonBonesData | null;
+        /**
+         * - Deprecated, please refer to {@link #removeDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #removeDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        removeSkeletonData(dragonBonesName: string): void;
+        /**
+         * - Deprecated, please refer to {@link #addTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #addTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        addTextureAtlas(textureAtlasData: TextureAtlasData, dragonBonesName?: string | null): void;
+        /**
+         * - Deprecated, please refer to {@link #getTextureAtlas()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #getTextureAtlas()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        getTextureAtlas(dragonBonesName: string): TextureAtlasData[] | null;
+        /**
+         * - Deprecated, please refer to {@link #removeTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #removeTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        removeTextureAtlas(dragonBonesName: string): void;
+        /**
+         * - Deprecated, please refer to {@link #buildArmature()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #buildArmature()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        buildFastArmature(armatureName: string, dragonBonesName?: string, skinName?: string): FastArmature | null;
+        /**
+         * - Deprecated, please refer to {@link #clear()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #clear()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        dispose(): void;
+    }
+}
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+declare const _super: any;
+declare namespace dragonBones {
+    /**
+     * 是否包含指定名称的动画组。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function hasMovieGroup(groupName: string): boolean;
+    /**
+     * 添加动画组。
+     * @param groupData 动画二进制数据。
+     * @param textureAtlas 贴图集或贴图集列表。
+     * @param groupName 为动画组指定一个名称，如果未设置，则使用数据中的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function addMovieGroup(groupData: ArrayBuffer, textureAtlas: egret.Texture | egret.Texture[], groupName?: string | null): void;
+    /**
+     * 移除动画组。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function removeMovieGroup(groupName: string): void;
+    /**
+     * 移除所有的动画组。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function removeAllMovieGroup(): void;
+    /**
+     * 创建一个动画。
+     * @param movieName 动画的名称。
+     * @param groupName 动画组的名称，如果未设置，将检索所有的动画组，当多个动画组中包含同名的动画时，可能无法创建出准确的动画。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function buildMovie(movieName: string, groupName?: string | null): Movie | null;
+    /**
+     * 获取指定动画组内包含的所有动画名称。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function getMovieNames(groupName: string): string[] | null;
+    /**
+     * 动画事件。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    class MovieEvent extends egret.Event {
+        /**
+         * 动画剪辑开始播放。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        static START: string;
+        /**
+         * 动画剪辑循环播放一次完成。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        static LOOP_COMPLETE: string;
+        /**
+         * 动画剪辑播放完成。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        static COMPLETE: string;
+        /**
+         * 动画剪辑帧事件。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        static FRAME_EVENT: string;
+        /**
+         * 动画剪辑声音事件。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        static SOUND_EVENT: string;
+        /**
+         * 事件名称。 (帧标签的名称或声音的名称)
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        name: string;
+        /**
+         * 发出事件的插槽名称。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        slotName: string;
+        /**
+         * 发出事件的动画剪辑名称。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        clipName: string;
+        /**
+         * 发出事件的动画。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        movie: Movie;
+        /**
+         * @private
+         */
+        constructor(type: string);
+        /**
+         * @private
+         */
+        readonly armature: any;
+        /**
+         * @private
+         */
+        readonly bone: any;
+        /**
+         * @private
+         */
+        readonly animationState: any;
+        /**
+         * @private
+         */
+        readonly frameLabel: any;
+        /**
+         * @private
+         */
+        readonly movementID: any;
+    }
+    /**
+     * 通过读取缓存的二进制动画数据来更新动画，具有良好的运行性能，同时对内存的占用也非常低。
+     * @see dragonBones.buildMovie
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    class Movie extends egret.DisplayObjectContainer implements IAnimatable {
+        private static _cleanBeforeRender();
+        /**
+         * 动画的播放速度。 [(-N~0): 倒转播放, 0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+         * @default 1
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        timeScale: number;
+        /**
+         * 动画剪辑的播放速度。 [(-N~0): 倒转播放, 0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+         * （当再次播放其他动画剪辑时，此值将被重置为 1）
+         * @default 1
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        clipTimeScale: number;
+        private _batchEnabled;
+        private _isLockDispose;
+        private _isDelayDispose;
+        private _isStarted;
+        private _isPlaying;
+        private _isReversing;
+        private _isCompleted;
+        private _playTimes;
+        private _time;
+        private _currentTime;
+        private _currentPlayTimes;
+        private _cacheFrameIndex;
+        private _frameSize;
+        private _cacheRectangle;
+        private _clock;
+        private _groupConfig;
+        private _config;
+        private _clipConfig;
+        private _currentFrameConfig;
+        private _clipArray;
+        private _clipNames;
+        private _slots;
+        private _childMovies;
+        constructor(createMovieHelper: any);
+        private _configToEvent(config, event);
+        private _onCrossFrame(frameConfig);
+        private _updateSlotBlendMode(slot);
+        private _updateSlotColor(slot, aM, rM, gM, bM, aO, rO, gO, bO);
+        private _updateSlotDisplay(slot);
+        private _getSlot(name);
+        /**
+         * @inheritDoc
+         */
+        $render(): void;
+        /**
+         * @inheritDoc
+         */
+        $updateRenderNode(): void;
+        /**
+         * @inheritDoc
+         */
+        $measureContentBounds(bounds: egret.Rectangle): void;
+        /**
+         * @inheritDoc
+         */
+        $doAddChild(child: egret.DisplayObject, index: number, notifyListeners?: boolean): egret.DisplayObject;
+        /**
+         * @inheritDoc
+         */
+        $doRemoveChild(index: number, notifyListeners?: boolean): egret.DisplayObject;
+        /**
+         * 释放动画。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        dispose(): void;
+        /**
+         * @inheritDoc
+         */
+        advanceTime(passedTime: number): void;
+        /**
+         * 播放动画剪辑。
+         * @param clipName 动画剪辑的名称，如果未设置，则播放默认动画剪辑，或将暂停状态切换为播放状态，或重新播放上一个正在播放的动画剪辑。
+         * @param playTimes 动画剪辑需要播放的次数。 [-1: 使用动画剪辑默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        play(clipName?: string | null, playTimes?: number): void;
+        /**
+         * 暂停播放动画。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        stop(): void;
+        /**
+         * 从指定时间播放动画。
+         * @param clipName 动画剪辑的名称。
+         * @param time 指定时间。（以秒为单位）
+         * @param playTimes 动画剪辑需要播放的次数。 [-1: 使用动画剪辑默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        gotoAndPlay(clipName: string | null | undefined, time: number, playTimes?: number): void;
+        /**
+         * 将动画停止到指定时间。
+         * @param clipName 动画剪辑的名称。
+         * @param time 指定时间。（以秒为单位）
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        gotoAndStop(clipName: string | null | undefined, time: number): void;
+        /**
+         * 是否包含指定动画剪辑。
+         * @param clipName 动画剪辑的名称。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        hasClip(clipName: string): boolean;
+        /**
+         * 动画剪辑是否处正在播放。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly isPlaying: boolean;
+        /**
+         * 动画剪辑是否均播放完毕。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly isComplete: boolean;
+        /**
+         * 当前动画剪辑的播放时间。 (以秒为单位)
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly currentTime: number;
+        /**
+         * 当前动画剪辑的总时间。 (以秒为单位)
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly totalTime: number;
+        /**
+         * 当前动画剪辑的播放次数。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly currentPlayTimes: number;
+        /**
+         * 当前动画剪辑需要播放的次数。 [0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly playTimes: number;
+        readonly groupName: string;
+        /**
+         * 正在播放的动画剪辑名称。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly clipName: string;
+        /**
+         * 所有动画剪辑的名称。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        readonly clipNames: string[];
+        /**
+         * @inheritDoc
+         */
+        clock: WorldClock | null;
+        /**
+         * 已废弃，请参考 {@link dragonBones.Movie#clock} {@link dragonBones.Movie#clock} {@link dragonBones.EgretFactory#clock}。
+         * @deprecated
+         * @language zh_CN
+         */
+        advanceTimeBySelf(on: boolean): void;
+        /**
+         * @private
+         */
+        readonly display: any;
+        /**
+         * @private
+         */
+        readonly animation: any;
+        /**
+         * @private
+         */
+        readonly armature: any;
+        /**
+         * @private
+         */
+        getAnimation(): any;
+        /**
+         * @private
+         */
+        getArmature(): any;
+        /**
+         * @private
+         */
+        getDisplay(): any;
+        /**
+         * @private
+         */
+        hasAnimation(name: string): boolean;
+        /**
+         * @private
+         */
+        invalidUpdate(...args: any[]): void;
+        /**
+         * @private
+         */
+        readonly lastAnimationName: string;
+        /**
+         * @private
+         */
+        readonly animationNames: string[];
+        /**
+         * @private
+         */
+        readonly animationList: string[];
+    }
+}
diff --git a/demo/libs/modules/dragonBones/dragonBones.js b/demo/libs/modules/dragonBones/dragonBones.js
new file mode 100644
index 00000000..59091a98
--- /dev/null
+++ b/demo/libs/modules/dragonBones/dragonBones.js
@@ -0,0 +1,18213 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var dragonBones;
+(function (dragonBones) {
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @private
+     */
+    var DragonBones = /** @class */ (function () {
+        function DragonBones(eventManager) {
+            this._clock = new dragonBones.WorldClock();
+            this._events = [];
+            this._objects = [];
+            this._eventManager = null;
+            this._eventManager = eventManager;
+            console.info("DragonBones: " + DragonBones.VERSION + "\nWebsite: http://dragonbones.com/\nSource and Demo: https://github.com/DragonBones/");
+        }
+        DragonBones.prototype.advanceTime = function (passedTime) {
+            if (this._objects.length > 0) {
+                for (var _i = 0, _a = this._objects; _i < _a.length; _i++) {
+                    var object = _a[_i];
+                    object.returnToPool();
+                }
+                this._objects.length = 0;
+            }
+            this._clock.advanceTime(passedTime);
+            if (this._events.length > 0) {
+                for (var i = 0; i < this._events.length; ++i) {
+                    var eventObject = this._events[i];
+                    var armature = eventObject.armature;
+                    if (armature._armatureData !== null) {
+                        armature.eventDispatcher.dispatchDBEvent(eventObject.type, eventObject);
+                        if (eventObject.type === dragonBones.EventObject.SOUND_EVENT) {
+                            this._eventManager.dispatchDBEvent(eventObject.type, eventObject);
+                        }
+                    }
+                    this.bufferObject(eventObject);
+                }
+                this._events.length = 0;
+            }
+        };
+        DragonBones.prototype.bufferEvent = function (value) {
+            if (this._events.indexOf(value) < 0) {
+                this._events.push(value);
+            }
+        };
+        DragonBones.prototype.bufferObject = function (object) {
+            if (this._objects.indexOf(object) < 0) {
+                this._objects.push(object);
+            }
+        };
+        Object.defineProperty(DragonBones.prototype, "clock", {
+            get: function () {
+                return this._clock;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(DragonBones.prototype, "eventManager", {
+            get: function () {
+                return this._eventManager;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        DragonBones.VERSION = "5.6.300";
+        DragonBones.yDown = true;
+        DragonBones.debug = false;
+        DragonBones.debugDraw = false;
+        DragonBones.webAssembly = false;
+        return DragonBones;
+    }());
+    dragonBones.DragonBones = DragonBones;
+})(dragonBones || (dragonBones = {}));
+//
+if (typeof global === "undefined") {
+    var global = window;
+}
+//
+if (!console.warn) {
+    console.warn = function () { };
+}
+if (!console.assert) {
+    console.assert = function () { };
+}
+//
+if (!Date.now) {
+    Date.now = function now() {
+        return new Date().getTime();
+    };
+}
+// Weixin can not support typescript extends.
+var __extends = function (t, e) {
+    function r() {
+        this.constructor = t;
+    }
+    for (var i in e) {
+        if (e.hasOwnProperty(i)) {
+            t[i] = e[i];
+        }
+    }
+    r.prototype = e.prototype, t.prototype = new r();
+};
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The BaseObject is the base class for all objects in the DragonBones framework.
+     * All BaseObject instances are cached to the object pool to reduce the performance consumption of frequent requests for memory or memory recovery.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 基础对象，通常 DragonBones 的对象都继承自该类。
+     * 所有基础对象的实例都会缓存到对象池，以减少频繁申请内存或内存回收的性能消耗。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    var BaseObject = /** @class */ (function () {
+        function BaseObject() {
+            /**
+             * - A unique identification number assigned to the object.
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 分配给此实例的唯一标识号。
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            this.hashCode = BaseObject._hashCode++;
+            this._isInPool = false;
+        }
+        BaseObject._returnObject = function (object) {
+            var classType = String(object.constructor);
+            var maxCount = classType in BaseObject._maxCountMap ? BaseObject._maxCountMap[classType] : BaseObject._defaultMaxCount;
+            var pool = BaseObject._poolsMap[classType] = BaseObject._poolsMap[classType] || [];
+            if (pool.length < maxCount) {
+                if (!object._isInPool) {
+                    object._isInPool = true;
+                    pool.push(object);
+                }
+                else {
+                    console.warn("The object is already in the pool.");
+                }
+            }
+            else {
+            }
+        };
+        BaseObject.toString = function () {
+            throw new Error();
+        };
+        /**
+         * - Set the maximum cache count of the specify object pool.
+         * @param objectConstructor - The specify class. (Set all object pools max cache count if not set)
+         * @param maxCount - Max count.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 设置特定对象池的最大缓存数量。
+         * @param objectConstructor - 特定的类。 (不设置则设置所有对象池的最大缓存数量)
+         * @param maxCount - 最大缓存数量。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseObject.setMaxCount = function (objectConstructor, maxCount) {
+            if (maxCount < 0 || maxCount !== maxCount) {
+                maxCount = 0;
+            }
+            if (objectConstructor !== null) {
+                var classType = String(objectConstructor);
+                var pool = classType in BaseObject._poolsMap ? BaseObject._poolsMap[classType] : null;
+                if (pool !== null && pool.length > maxCount) {
+                    pool.length = maxCount;
+                }
+                BaseObject._maxCountMap[classType] = maxCount;
+            }
+            else {
+                BaseObject._defaultMaxCount = maxCount;
+                for (var classType in BaseObject._poolsMap) {
+                    var pool = BaseObject._poolsMap[classType];
+                    if (pool.length > maxCount) {
+                        pool.length = maxCount;
+                    }
+                    if (classType in BaseObject._maxCountMap) {
+                        BaseObject._maxCountMap[classType] = maxCount;
+                    }
+                }
+            }
+        };
+        /**
+         * - Clear the cached instances of a specify object pool.
+         * @param objectConstructor - Specify class. (Clear all cached instances if not set)
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除特定对象池的缓存实例。
+         * @param objectConstructor - 特定的类。 (不设置则清除所有缓存的实例)
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseObject.clearPool = function (objectConstructor) {
+            if (objectConstructor === void 0) { objectConstructor = null; }
+            if (objectConstructor !== null) {
+                var classType = String(objectConstructor);
+                var pool = classType in BaseObject._poolsMap ? BaseObject._poolsMap[classType] : null;
+                if (pool !== null && pool.length > 0) {
+                    pool.length = 0;
+                }
+            }
+            else {
+                for (var k in BaseObject._poolsMap) {
+                    var pool = BaseObject._poolsMap[k];
+                    pool.length = 0;
+                }
+            }
+        };
+        /**
+         * - Get an instance of the specify class from object pool.
+         * @param objectConstructor - The specify class.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从对象池中获取特定类的实例。
+         * @param objectConstructor - 特定的类。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseObject.borrowObject = function (objectConstructor) {
+            var classType = String(objectConstructor);
+            var pool = classType in BaseObject._poolsMap ? BaseObject._poolsMap[classType] : null;
+            if (pool !== null && pool.length > 0) {
+                var object_1 = pool.pop();
+                object_1._isInPool = false;
+                return object_1;
+            }
+            var object = new objectConstructor();
+            object._onClear();
+            return object;
+        };
+        /**
+         * - Clear the object and return it back to object pool。
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除该实例的所有数据并将其返还对象池。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseObject.prototype.returnToPool = function () {
+            this._onClear();
+            BaseObject._returnObject(this);
+        };
+        BaseObject._hashCode = 0;
+        BaseObject._defaultMaxCount = 3000;
+        BaseObject._maxCountMap = {};
+        BaseObject._poolsMap = {};
+        return BaseObject;
+    }());
+    dragonBones.BaseObject = BaseObject;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - 2D Transform matrix.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 2D 转换矩阵。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Matrix = /** @class */ (function () {
+        /**
+         * @private
+         */
+        function Matrix(a, b, c, d, tx, ty) {
+            if (a === void 0) { a = 1.0; }
+            if (b === void 0) { b = 0.0; }
+            if (c === void 0) { c = 0.0; }
+            if (d === void 0) { d = 1.0; }
+            if (tx === void 0) { tx = 0.0; }
+            if (ty === void 0) { ty = 0.0; }
+            this.a = a;
+            this.b = b;
+            this.c = c;
+            this.d = d;
+            this.tx = tx;
+            this.ty = ty;
+        }
+        Matrix.prototype.toString = function () {
+            return "[object dragonBones.Matrix] a:" + this.a + " b:" + this.b + " c:" + this.c + " d:" + this.d + " tx:" + this.tx + " ty:" + this.ty;
+        };
+        /**
+         * @private
+         */
+        Matrix.prototype.copyFrom = function (value) {
+            this.a = value.a;
+            this.b = value.b;
+            this.c = value.c;
+            this.d = value.d;
+            this.tx = value.tx;
+            this.ty = value.ty;
+            return this;
+        };
+        /**
+         * @private
+         */
+        Matrix.prototype.copyFromArray = function (value, offset) {
+            if (offset === void 0) { offset = 0; }
+            this.a = value[offset];
+            this.b = value[offset + 1];
+            this.c = value[offset + 2];
+            this.d = value[offset + 3];
+            this.tx = value[offset + 4];
+            this.ty = value[offset + 5];
+            return this;
+        };
+        /**
+         * - Convert to unit matrix.
+         * The resulting matrix has the following properties: a=1, b=0, c=0, d=1, tx=0, ty=0.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 转换为单位矩阵。
+         * 该矩阵具有以下属性：a=1、b=0、c=0、d=1、tx=0、ty=0。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Matrix.prototype.identity = function () {
+            this.a = this.d = 1.0;
+            this.b = this.c = 0.0;
+            this.tx = this.ty = 0.0;
+            return this;
+        };
+        /**
+         * - Multiplies the current matrix with another matrix.
+         * @param value - The matrix that needs to be multiplied.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将当前矩阵与另一个矩阵相乘。
+         * @param value - 需要相乘的矩阵。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Matrix.prototype.concat = function (value) {
+            var aA = this.a * value.a;
+            var bA = 0.0;
+            var cA = 0.0;
+            var dA = this.d * value.d;
+            var txA = this.tx * value.a + value.tx;
+            var tyA = this.ty * value.d + value.ty;
+            if (this.b !== 0.0 || this.c !== 0.0) {
+                aA += this.b * value.c;
+                bA += this.b * value.d;
+                cA += this.c * value.a;
+                dA += this.c * value.b;
+            }
+            if (value.b !== 0.0 || value.c !== 0.0) {
+                bA += this.a * value.b;
+                cA += this.d * value.c;
+                txA += this.ty * value.c;
+                tyA += this.tx * value.b;
+            }
+            this.a = aA;
+            this.b = bA;
+            this.c = cA;
+            this.d = dA;
+            this.tx = txA;
+            this.ty = tyA;
+            return this;
+        };
+        /**
+         * - Convert to inverse matrix.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 转换为逆矩阵。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Matrix.prototype.invert = function () {
+            var aA = this.a;
+            var bA = this.b;
+            var cA = this.c;
+            var dA = this.d;
+            var txA = this.tx;
+            var tyA = this.ty;
+            if (bA === 0.0 && cA === 0.0) {
+                this.b = this.c = 0.0;
+                if (aA === 0.0 || dA === 0.0) {
+                    this.a = this.b = this.tx = this.ty = 0.0;
+                }
+                else {
+                    aA = this.a = 1.0 / aA;
+                    dA = this.d = 1.0 / dA;
+                    this.tx = -aA * txA;
+                    this.ty = -dA * tyA;
+                }
+                return this;
+            }
+            var determinant = aA * dA - bA * cA;
+            if (determinant === 0.0) {
+                this.a = this.d = 1.0;
+                this.b = this.c = 0.0;
+                this.tx = this.ty = 0.0;
+                return this;
+            }
+            determinant = 1.0 / determinant;
+            var k = this.a = dA * determinant;
+            bA = this.b = -bA * determinant;
+            cA = this.c = -cA * determinant;
+            dA = this.d = aA * determinant;
+            this.tx = -(k * txA + cA * tyA);
+            this.ty = -(bA * txA + dA * tyA);
+            return this;
+        };
+        /**
+         * - Apply a matrix transformation to a specific point.
+         * @param x - X coordinate.
+         * @param y - Y coordinate.
+         * @param result - The point after the transformation is applied.
+         * @param delta - Whether to ignore tx, ty's conversion to point.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将矩阵转换应用于特定点。
+         * @param x - 横坐标。
+         * @param y - 纵坐标。
+         * @param result - 应用转换之后的点。
+         * @param delta - 是否忽略 tx，ty 对点的转换。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Matrix.prototype.transformPoint = function (x, y, result, delta) {
+            if (delta === void 0) { delta = false; }
+            result.x = this.a * x + this.c * y;
+            result.y = this.b * x + this.d * y;
+            if (!delta) {
+                result.x += this.tx;
+                result.y += this.ty;
+            }
+        };
+        /**
+         * @private
+         */
+        Matrix.prototype.transformRectangle = function (rectangle, delta) {
+            if (delta === void 0) { delta = false; }
+            var a = this.a;
+            var b = this.b;
+            var c = this.c;
+            var d = this.d;
+            var tx = delta ? 0.0 : this.tx;
+            var ty = delta ? 0.0 : this.ty;
+            var x = rectangle.x;
+            var y = rectangle.y;
+            var xMax = x + rectangle.width;
+            var yMax = y + rectangle.height;
+            var x0 = a * x + c * y + tx;
+            var y0 = b * x + d * y + ty;
+            var x1 = a * xMax + c * y + tx;
+            var y1 = b * xMax + d * y + ty;
+            var x2 = a * xMax + c * yMax + tx;
+            var y2 = b * xMax + d * yMax + ty;
+            var x3 = a * x + c * yMax + tx;
+            var y3 = b * x + d * yMax + ty;
+            var tmp = 0.0;
+            if (x0 > x1) {
+                tmp = x0;
+                x0 = x1;
+                x1 = tmp;
+            }
+            if (x2 > x3) {
+                tmp = x2;
+                x2 = x3;
+                x3 = tmp;
+            }
+            rectangle.x = Math.floor(x0 < x2 ? x0 : x2);
+            rectangle.width = Math.ceil((x1 > x3 ? x1 : x3) - rectangle.x);
+            if (y0 > y1) {
+                tmp = y0;
+                y0 = y1;
+                y1 = tmp;
+            }
+            if (y2 > y3) {
+                tmp = y2;
+                y2 = y3;
+                y3 = tmp;
+            }
+            rectangle.y = Math.floor(y0 < y2 ? y0 : y2);
+            rectangle.height = Math.ceil((y1 > y3 ? y1 : y3) - rectangle.y);
+        };
+        return Matrix;
+    }());
+    dragonBones.Matrix = Matrix;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - 2D Transform.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 2D 变换。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Transform = /** @class */ (function () {
+        /**
+         * @private
+         */
+        function Transform(x, y, skew, rotation, scaleX, scaleY) {
+            if (x === void 0) { x = 0.0; }
+            if (y === void 0) { y = 0.0; }
+            if (skew === void 0) { skew = 0.0; }
+            if (rotation === void 0) { rotation = 0.0; }
+            if (scaleX === void 0) { scaleX = 1.0; }
+            if (scaleY === void 0) { scaleY = 1.0; }
+            this.x = x;
+            this.y = y;
+            this.skew = skew;
+            this.rotation = rotation;
+            this.scaleX = scaleX;
+            this.scaleY = scaleY;
+        }
+        /**
+         * @private
+         */
+        Transform.normalizeRadian = function (value) {
+            value = (value + Math.PI) % (Math.PI * 2.0);
+            value += value > 0.0 ? -Math.PI : Math.PI;
+            return value;
+        };
+        Transform.prototype.toString = function () {
+            return "[object dragonBones.Transform] x:" + this.x + " y:" + this.y + " skewX:" + this.skew * 180.0 / Math.PI + " skewY:" + this.rotation * 180.0 / Math.PI + " scaleX:" + this.scaleX + " scaleY:" + this.scaleY;
+        };
+        /**
+         * @private
+         */
+        Transform.prototype.copyFrom = function (value) {
+            this.x = value.x;
+            this.y = value.y;
+            this.skew = value.skew;
+            this.rotation = value.rotation;
+            this.scaleX = value.scaleX;
+            this.scaleY = value.scaleY;
+            return this;
+        };
+        /**
+         * @private
+         */
+        Transform.prototype.identity = function () {
+            this.x = this.y = 0.0;
+            this.skew = this.rotation = 0.0;
+            this.scaleX = this.scaleY = 1.0;
+            return this;
+        };
+        /**
+         * @private
+         */
+        Transform.prototype.add = function (value) {
+            this.x += value.x;
+            this.y += value.y;
+            this.skew += value.skew;
+            this.rotation += value.rotation;
+            this.scaleX *= value.scaleX;
+            this.scaleY *= value.scaleY;
+            return this;
+        };
+        /**
+         * @private
+         */
+        Transform.prototype.minus = function (value) {
+            this.x -= value.x;
+            this.y -= value.y;
+            this.skew -= value.skew;
+            this.rotation -= value.rotation;
+            this.scaleX /= value.scaleX;
+            this.scaleY /= value.scaleY;
+            return this;
+        };
+        /**
+         * @private
+         */
+        Transform.prototype.fromMatrix = function (matrix) {
+            var backupScaleX = this.scaleX, backupScaleY = this.scaleY;
+            var PI_Q = Transform.PI_Q;
+            this.x = matrix.tx;
+            this.y = matrix.ty;
+            this.rotation = Math.atan(matrix.b / matrix.a);
+            var skewX = Math.atan(-matrix.c / matrix.d);
+            this.scaleX = (this.rotation > -PI_Q && this.rotation < PI_Q) ? matrix.a / Math.cos(this.rotation) : matrix.b / Math.sin(this.rotation);
+            this.scaleY = (skewX > -PI_Q && skewX < PI_Q) ? matrix.d / Math.cos(skewX) : -matrix.c / Math.sin(skewX);
+            if (backupScaleX >= 0.0 && this.scaleX < 0.0) {
+                this.scaleX = -this.scaleX;
+                this.rotation = this.rotation - Math.PI;
+            }
+            if (backupScaleY >= 0.0 && this.scaleY < 0.0) {
+                this.scaleY = -this.scaleY;
+                skewX = skewX - Math.PI;
+            }
+            this.skew = skewX - this.rotation;
+            return this;
+        };
+        /**
+         * @private
+         */
+        Transform.prototype.toMatrix = function (matrix) {
+            if (this.rotation === 0.0) {
+                matrix.a = 1.0;
+                matrix.b = 0.0;
+            }
+            else {
+                matrix.a = Math.cos(this.rotation);
+                matrix.b = Math.sin(this.rotation);
+            }
+            if (this.skew === 0.0) {
+                matrix.c = -matrix.b;
+                matrix.d = matrix.a;
+            }
+            else {
+                matrix.c = -Math.sin(this.skew + this.rotation);
+                matrix.d = Math.cos(this.skew + this.rotation);
+            }
+            if (this.scaleX !== 1.0) {
+                matrix.a *= this.scaleX;
+                matrix.b *= this.scaleX;
+            }
+            if (this.scaleY !== 1.0) {
+                matrix.c *= this.scaleY;
+                matrix.d *= this.scaleY;
+            }
+            matrix.tx = this.x;
+            matrix.ty = this.y;
+            return this;
+        };
+        /**
+         * @private
+         */
+        Transform.PI = Math.PI;
+        /**
+         * @private
+         */
+        Transform.PI_D = Math.PI * 2.0;
+        /**
+         * @private
+         */
+        Transform.PI_H = Math.PI / 2.0;
+        /**
+         * @private
+         */
+        Transform.PI_Q = Math.PI / 4.0;
+        /**
+         * @private
+         */
+        Transform.RAD_DEG = 180.0 / Math.PI;
+        /**
+         * @private
+         */
+        Transform.DEG_RAD = Math.PI / 180.0;
+        return Transform;
+    }());
+    dragonBones.Transform = Transform;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var ColorTransform = /** @class */ (function () {
+        function ColorTransform(alphaMultiplier, redMultiplier, greenMultiplier, blueMultiplier, alphaOffset, redOffset, greenOffset, blueOffset) {
+            if (alphaMultiplier === void 0) { alphaMultiplier = 1.0; }
+            if (redMultiplier === void 0) { redMultiplier = 1.0; }
+            if (greenMultiplier === void 0) { greenMultiplier = 1.0; }
+            if (blueMultiplier === void 0) { blueMultiplier = 1.0; }
+            if (alphaOffset === void 0) { alphaOffset = 0; }
+            if (redOffset === void 0) { redOffset = 0; }
+            if (greenOffset === void 0) { greenOffset = 0; }
+            if (blueOffset === void 0) { blueOffset = 0; }
+            this.alphaMultiplier = alphaMultiplier;
+            this.redMultiplier = redMultiplier;
+            this.greenMultiplier = greenMultiplier;
+            this.blueMultiplier = blueMultiplier;
+            this.alphaOffset = alphaOffset;
+            this.redOffset = redOffset;
+            this.greenOffset = greenOffset;
+            this.blueOffset = blueOffset;
+        }
+        ColorTransform.prototype.copyFrom = function (value) {
+            this.alphaMultiplier = value.alphaMultiplier;
+            this.redMultiplier = value.redMultiplier;
+            this.greenMultiplier = value.greenMultiplier;
+            this.blueMultiplier = value.blueMultiplier;
+            this.alphaOffset = value.alphaOffset;
+            this.redOffset = value.redOffset;
+            this.greenOffset = value.greenOffset;
+            this.blueOffset = value.blueOffset;
+        };
+        ColorTransform.prototype.identity = function () {
+            this.alphaMultiplier = this.redMultiplier = this.greenMultiplier = this.blueMultiplier = 1.0;
+            this.alphaOffset = this.redOffset = this.greenOffset = this.blueOffset = 0;
+        };
+        return ColorTransform;
+    }());
+    dragonBones.ColorTransform = ColorTransform;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The Point object represents a location in a two-dimensional coordinate system.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Point 对象表示二维坐标系统中的某个位置。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Point = /** @class */ (function () {
+        /**
+         * - Creates a new point. If you pass no parameters to this method, a point is created at (0,0).
+         * @param x - The horizontal coordinate.
+         * @param y - The vertical coordinate.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建一个 egret.Point 对象.若不传入任何参数，将会创建一个位于（0，0）位置的点。
+         * @param x - 该对象的x属性值，默认为 0.0。
+         * @param y - 该对象的y属性值，默认为 0.0。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        function Point(x, y) {
+            if (x === void 0) { x = 0.0; }
+            if (y === void 0) { y = 0.0; }
+            this.x = x;
+            this.y = y;
+        }
+        /**
+         * @private
+         */
+        Point.prototype.copyFrom = function (value) {
+            this.x = value.x;
+            this.y = value.y;
+        };
+        /**
+         * @private
+         */
+        Point.prototype.clear = function () {
+            this.x = this.y = 0.0;
+        };
+        return Point;
+    }());
+    dragonBones.Point = Point;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - A Rectangle object is an area defined by its position, as indicated by its top-left corner point (x, y) and by its
+     * width and its height.<br/>
+     * The x, y, width, and height properties of the Rectangle class are independent of each other; changing the value of
+     * one property has no effect on the others. However, the right and bottom properties are integrally related to those
+     * four properties. For example, if you change the value of the right property, the value of the width property changes;
+     * if you change the bottom property, the value of the height property changes.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Rectangle 对象是按其位置（由它左上角的点 (x, y) 确定）以及宽度和高度定义的区域。<br/>
+     * Rectangle 类的 x、y、width 和 height 属性相互独立；更改一个属性的值不会影响其他属性。
+     * 但是，right 和 bottom 属性与这四个属性是整体相关的。例如，如果更改 right 属性的值，则 width
+     * 属性的值将发生变化；如果更改 bottom 属性，则 height 属性的值将发生变化。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Rectangle = /** @class */ (function () {
+        /**
+         * @private
+         */
+        function Rectangle(x, y, width, height) {
+            if (x === void 0) { x = 0.0; }
+            if (y === void 0) { y = 0.0; }
+            if (width === void 0) { width = 0.0; }
+            if (height === void 0) { height = 0.0; }
+            this.x = x;
+            this.y = y;
+            this.width = width;
+            this.height = height;
+        }
+        /**
+         * @private
+         */
+        Rectangle.prototype.copyFrom = function (value) {
+            this.x = value.x;
+            this.y = value.y;
+            this.width = value.width;
+            this.height = value.height;
+        };
+        /**
+         * @private
+         */
+        Rectangle.prototype.clear = function () {
+            this.x = this.y = 0.0;
+            this.width = this.height = 0.0;
+        };
+        return Rectangle;
+    }());
+    dragonBones.Rectangle = Rectangle;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The user custom data.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 用户自定义数据。
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    var UserData = /** @class */ (function (_super) {
+        __extends(UserData, _super);
+        function UserData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * - The custom int numbers.
+             * @version DragonBones 5.0
+             * @language en_US
+             */
+            /**
+             * - 自定义整数。
+             * @version DragonBones 5.0
+             * @language zh_CN
+             */
+            _this.ints = [];
+            /**
+             * - The custom float numbers.
+             * @version DragonBones 5.0
+             * @language en_US
+             */
+            /**
+             * - 自定义浮点数。
+             * @version DragonBones 5.0
+             * @language zh_CN
+             */
+            _this.floats = [];
+            /**
+             * - The custom strings.
+             * @version DragonBones 5.0
+             * @language en_US
+             */
+            /**
+             * - 自定义字符串。
+             * @version DragonBones 5.0
+             * @language zh_CN
+             */
+            _this.strings = [];
+            return _this;
+        }
+        UserData.toString = function () {
+            return "[class dragonBones.UserData]";
+        };
+        UserData.prototype._onClear = function () {
+            this.ints.length = 0;
+            this.floats.length = 0;
+            this.strings.length = 0;
+        };
+        /**
+         * @internal
+         */
+        UserData.prototype.addInt = function (value) {
+            this.ints.push(value);
+        };
+        /**
+         * @internal
+         */
+        UserData.prototype.addFloat = function (value) {
+            this.floats.push(value);
+        };
+        /**
+         * @internal
+         */
+        UserData.prototype.addString = function (value) {
+            this.strings.push(value);
+        };
+        /**
+         * - Get the custom int number.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 获取自定义整数。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        UserData.prototype.getInt = function (index) {
+            if (index === void 0) { index = 0; }
+            return index >= 0 && index < this.ints.length ? this.ints[index] : 0;
+        };
+        /**
+         * - Get the custom float number.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 获取自定义浮点数。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        UserData.prototype.getFloat = function (index) {
+            if (index === void 0) { index = 0; }
+            return index >= 0 && index < this.floats.length ? this.floats[index] : 0.0;
+        };
+        /**
+         * - Get the custom string.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 获取自定义字符串。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        UserData.prototype.getString = function (index) {
+            if (index === void 0) { index = 0; }
+            return index >= 0 && index < this.strings.length ? this.strings[index] : "";
+        };
+        return UserData;
+    }(dragonBones.BaseObject));
+    dragonBones.UserData = UserData;
+    /**
+     * @internal
+     */
+    var ActionData = /** @class */ (function (_super) {
+        __extends(ActionData, _super);
+        function ActionData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.data = null; //
+            return _this;
+        }
+        ActionData.toString = function () {
+            return "[class dragonBones.ActionData]";
+        };
+        ActionData.prototype._onClear = function () {
+            if (this.data !== null) {
+                this.data.returnToPool();
+            }
+            this.type = 0 /* Play */;
+            this.name = "";
+            this.bone = null;
+            this.slot = null;
+            this.data = null;
+        };
+        return ActionData;
+    }(dragonBones.BaseObject));
+    dragonBones.ActionData = ActionData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The DragonBones data.
+     * A DragonBones data contains multiple armature data.
+     * @see dragonBones.ArmatureData
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 龙骨数据。
+     * 一个龙骨数据包含多个骨架数据。
+     * @see dragonBones.ArmatureData
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var DragonBonesData = /** @class */ (function (_super) {
+        __extends(DragonBonesData, _super);
+        function DragonBonesData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @internal
+             */
+            _this.frameIndices = [];
+            /**
+             * @internal
+             */
+            _this.cachedFrames = [];
+            /**
+             * - All armature data names.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 所有的骨架数据名称。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            _this.armatureNames = [];
+            /**
+             * @private
+             */
+            _this.armatures = {};
+            /**
+             * @private
+             */
+            _this.userData = null; // Initial value.
+            return _this;
+        }
+        DragonBonesData.toString = function () {
+            return "[class dragonBones.DragonBonesData]";
+        };
+        DragonBonesData.prototype._onClear = function () {
+            for (var k in this.armatures) {
+                this.armatures[k].returnToPool();
+                delete this.armatures[k];
+            }
+            if (this.userData !== null) {
+                this.userData.returnToPool();
+            }
+            this.autoSearch = false;
+            this.frameRate = 0;
+            this.version = "";
+            this.name = "";
+            this.stage = null;
+            this.frameIndices.length = 0;
+            this.cachedFrames.length = 0;
+            this.armatureNames.length = 0;
+            //this.armatures.clear();
+            this.binary = null; //
+            this.intArray = null; //
+            this.floatArray = null; //
+            this.frameIntArray = null; //
+            this.frameFloatArray = null; //
+            this.frameArray = null; //
+            this.timelineArray = null; //
+            this.userData = null;
+        };
+        /**
+         * @internal
+         */
+        DragonBonesData.prototype.addArmature = function (value) {
+            if (value.name in this.armatures) {
+                console.warn("Same armature: " + value.name);
+                return;
+            }
+            value.parent = this;
+            this.armatures[value.name] = value;
+            this.armatureNames.push(value.name);
+        };
+        /**
+         * - Get a specific armature data.
+         * @param armatureName - The armature data name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨架数据。
+         * @param armatureName - 骨架数据名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        DragonBonesData.prototype.getArmature = function (armatureName) {
+            return armatureName in this.armatures ? this.armatures[armatureName] : null;
+        };
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.BaseFactory#removeDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.BaseFactory#removeDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        DragonBonesData.prototype.dispose = function () {
+            console.warn("已废弃");
+            this.returnToPool();
+        };
+        return DragonBonesData;
+    }(dragonBones.BaseObject));
+    dragonBones.DragonBonesData = DragonBonesData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The armature data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨架数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var ArmatureData = /** @class */ (function (_super) {
+        __extends(ArmatureData, _super);
+        function ArmatureData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.aabb = new dragonBones.Rectangle();
+            /**
+             * - The names of all the animation data.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 所有的动画数据名称。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            _this.animationNames = [];
+            /**
+             * @private
+             */
+            _this.sortedBones = [];
+            /**
+             * @private
+             */
+            _this.sortedSlots = [];
+            /**
+             * @private
+             */
+            _this.defaultActions = [];
+            /**
+             * @private
+             */
+            _this.actions = [];
+            /**
+             * @private
+             */
+            _this.bones = {};
+            /**
+             * @private
+             */
+            _this.slots = {};
+            /**
+             * @private
+             */
+            _this.constraints = {};
+            /**
+             * @private
+             */
+            _this.skins = {};
+            /**
+             * @private
+             */
+            _this.animations = {};
+            /**
+             * @private
+             */
+            _this.canvas = null; // Initial value.
+            /**
+             * @private
+             */
+            _this.userData = null; // Initial value.
+            return _this;
+        }
+        ArmatureData.toString = function () {
+            return "[class dragonBones.ArmatureData]";
+        };
+        ArmatureData.prototype._onClear = function () {
+            for (var _i = 0, _a = this.defaultActions; _i < _a.length; _i++) {
+                var action = _a[_i];
+                action.returnToPool();
+            }
+            for (var _b = 0, _c = this.actions; _b < _c.length; _b++) {
+                var action = _c[_b];
+                action.returnToPool();
+            }
+            for (var k in this.bones) {
+                this.bones[k].returnToPool();
+                delete this.bones[k];
+            }
+            for (var k in this.slots) {
+                this.slots[k].returnToPool();
+                delete this.slots[k];
+            }
+            for (var k in this.constraints) {
+                this.constraints[k].returnToPool();
+                delete this.constraints[k];
+            }
+            for (var k in this.skins) {
+                this.skins[k].returnToPool();
+                delete this.skins[k];
+            }
+            for (var k in this.animations) {
+                this.animations[k].returnToPool();
+                delete this.animations[k];
+            }
+            if (this.canvas !== null) {
+                this.canvas.returnToPool();
+            }
+            if (this.userData !== null) {
+                this.userData.returnToPool();
+            }
+            this.type = 0 /* Armature */;
+            this.frameRate = 0;
+            this.cacheFrameRate = 0;
+            this.scale = 1.0;
+            this.name = "";
+            this.aabb.clear();
+            this.animationNames.length = 0;
+            this.sortedBones.length = 0;
+            this.sortedSlots.length = 0;
+            this.defaultActions.length = 0;
+            this.actions.length = 0;
+            // this.bones.clear();
+            // this.slots.clear();
+            // this.constraints.clear();
+            // this.skins.clear();
+            // this.animations.clear();
+            this.defaultSkin = null;
+            this.defaultAnimation = null;
+            this.canvas = null;
+            this.userData = null;
+            this.parent = null; //
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.sortBones = function () {
+            var total = this.sortedBones.length;
+            if (total <= 0) {
+                return;
+            }
+            var sortHelper = this.sortedBones.concat();
+            var index = 0;
+            var count = 0;
+            this.sortedBones.length = 0;
+            while (count < total) {
+                var bone = sortHelper[index++];
+                if (index >= total) {
+                    index = 0;
+                }
+                if (this.sortedBones.indexOf(bone) >= 0) {
+                    continue;
+                }
+                var flag = false;
+                for (var k in this.constraints) {
+                    var constraint = this.constraints[k];
+                    if (constraint.root === bone && this.sortedBones.indexOf(constraint.target) < 0) {
+                        flag = true;
+                        break;
+                    }
+                }
+                if (flag) {
+                    continue;
+                }
+                if (bone.parent !== null && this.sortedBones.indexOf(bone.parent) < 0) {
+                    continue;
+                }
+                this.sortedBones.push(bone);
+                count++;
+            }
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.cacheFrames = function (frameRate) {
+            if (this.cacheFrameRate > 0) {
+                return;
+            }
+            this.cacheFrameRate = frameRate;
+            for (var k in this.animations) {
+                this.animations[k].cacheFrames(this.cacheFrameRate);
+            }
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.setCacheFrame = function (globalTransformMatrix, transform) {
+            var dataArray = this.parent.cachedFrames;
+            var arrayOffset = dataArray.length;
+            dataArray.length += 10;
+            dataArray[arrayOffset] = globalTransformMatrix.a;
+            dataArray[arrayOffset + 1] = globalTransformMatrix.b;
+            dataArray[arrayOffset + 2] = globalTransformMatrix.c;
+            dataArray[arrayOffset + 3] = globalTransformMatrix.d;
+            dataArray[arrayOffset + 4] = globalTransformMatrix.tx;
+            dataArray[arrayOffset + 5] = globalTransformMatrix.ty;
+            dataArray[arrayOffset + 6] = transform.rotation;
+            dataArray[arrayOffset + 7] = transform.skew;
+            dataArray[arrayOffset + 8] = transform.scaleX;
+            dataArray[arrayOffset + 9] = transform.scaleY;
+            return arrayOffset;
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.getCacheFrame = function (globalTransformMatrix, transform, arrayOffset) {
+            var dataArray = this.parent.cachedFrames;
+            globalTransformMatrix.a = dataArray[arrayOffset];
+            globalTransformMatrix.b = dataArray[arrayOffset + 1];
+            globalTransformMatrix.c = dataArray[arrayOffset + 2];
+            globalTransformMatrix.d = dataArray[arrayOffset + 3];
+            globalTransformMatrix.tx = dataArray[arrayOffset + 4];
+            globalTransformMatrix.ty = dataArray[arrayOffset + 5];
+            transform.rotation = dataArray[arrayOffset + 6];
+            transform.skew = dataArray[arrayOffset + 7];
+            transform.scaleX = dataArray[arrayOffset + 8];
+            transform.scaleY = dataArray[arrayOffset + 9];
+            transform.x = globalTransformMatrix.tx;
+            transform.y = globalTransformMatrix.ty;
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.addBone = function (value) {
+            if (value.name in this.bones) {
+                console.warn("Same bone: " + value.name);
+                return;
+            }
+            this.bones[value.name] = value;
+            this.sortedBones.push(value);
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.addSlot = function (value) {
+            if (value.name in this.slots) {
+                console.warn("Same slot: " + value.name);
+                return;
+            }
+            this.slots[value.name] = value;
+            this.sortedSlots.push(value);
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.addConstraint = function (value) {
+            if (value.name in this.constraints) {
+                console.warn("Same constraint: " + value.name);
+                return;
+            }
+            this.constraints[value.name] = value;
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.addSkin = function (value) {
+            if (value.name in this.skins) {
+                console.warn("Same skin: " + value.name);
+                return;
+            }
+            value.parent = this;
+            this.skins[value.name] = value;
+            if (this.defaultSkin === null) {
+                this.defaultSkin = value;
+            }
+            if (value.name === "default") {
+                this.defaultSkin = value;
+            }
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.addAnimation = function (value) {
+            if (value.name in this.animations) {
+                console.warn("Same animation: " + value.name);
+                return;
+            }
+            value.parent = this;
+            this.animations[value.name] = value;
+            this.animationNames.push(value.name);
+            if (this.defaultAnimation === null) {
+                this.defaultAnimation = value;
+            }
+        };
+        /**
+         * @internal
+         */
+        ArmatureData.prototype.addAction = function (value, isDefault) {
+            if (isDefault) {
+                this.defaultActions.push(value);
+            }
+            else {
+                this.actions.push(value);
+            }
+        };
+        /**
+         * - Get a specific done data.
+         * @param boneName - The bone name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨骼数据。
+         * @param boneName - 骨骼名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        ArmatureData.prototype.getBone = function (boneName) {
+            return boneName in this.bones ? this.bones[boneName] : null;
+        };
+        /**
+         * - Get a specific slot data.
+         * @param slotName - The slot name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的插槽数据。
+         * @param slotName - 插槽名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        ArmatureData.prototype.getSlot = function (slotName) {
+            return slotName in this.slots ? this.slots[slotName] : null;
+        };
+        /**
+         * @private
+         */
+        ArmatureData.prototype.getConstraint = function (constraintName) {
+            return constraintName in this.constraints ? this.constraints[constraintName] : null;
+        };
+        /**
+         * - Get a specific skin data.
+         * @param skinName - The skin name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定皮肤数据。
+         * @param skinName - 皮肤名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        ArmatureData.prototype.getSkin = function (skinName) {
+            return skinName in this.skins ? this.skins[skinName] : null;
+        };
+        /**
+         * @private
+         */
+        ArmatureData.prototype.getMesh = function (skinName, slotName, meshName) {
+            var skin = this.getSkin(skinName);
+            if (skin === null) {
+                return null;
+            }
+            return skin.getDisplay(slotName, meshName);
+        };
+        /**
+         * - Get a specific animation data.
+         * @param animationName - The animation animationName.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的动画数据。
+         * @param animationName - 动画名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        ArmatureData.prototype.getAnimation = function (animationName) {
+            return animationName in this.animations ? this.animations[animationName] : null;
+        };
+        return ArmatureData;
+    }(dragonBones.BaseObject));
+    dragonBones.ArmatureData = ArmatureData;
+    /**
+     * - The bone data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨骼数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var BoneData = /** @class */ (function (_super) {
+        __extends(BoneData, _super);
+        function BoneData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.transform = new dragonBones.Transform();
+            /**
+             * @private
+             */
+            _this.userData = null; // Initial value.
+            return _this;
+        }
+        BoneData.toString = function () {
+            return "[class dragonBones.BoneData]";
+        };
+        BoneData.prototype._onClear = function () {
+            if (this.userData !== null) {
+                this.userData.returnToPool();
+            }
+            this.inheritTranslation = false;
+            this.inheritRotation = false;
+            this.inheritScale = false;
+            this.inheritReflection = false;
+            this.type = 0 /* Bone */;
+            this.length = 0.0;
+            this.name = "";
+            this.transform.identity();
+            this.userData = null;
+            this.parent = null;
+        };
+        return BoneData;
+    }(dragonBones.BaseObject));
+    dragonBones.BoneData = BoneData;
+    /**
+     * @internal
+     */
+    var SurfaceData = /** @class */ (function (_super) {
+        __extends(SurfaceData, _super);
+        function SurfaceData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.vertices = [];
+            return _this;
+        }
+        SurfaceData.toString = function () {
+            return "[class dragonBones.SurfaceData]";
+        };
+        SurfaceData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.type = 1 /* Surface */;
+            this.segmentX = 0;
+            this.segmentY = 0;
+            this.vertices.length = 0;
+        };
+        return SurfaceData;
+    }(BoneData));
+    dragonBones.SurfaceData = SurfaceData;
+    /**
+     * - The slot data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 插槽数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var SlotData = /** @class */ (function (_super) {
+        __extends(SlotData, _super);
+        function SlotData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.color = null; // Initial value.
+            /**
+             * @private
+             */
+            _this.userData = null; // Initial value.
+            return _this;
+        }
+        /**
+         * @internal
+         */
+        SlotData.createColor = function () {
+            return new dragonBones.ColorTransform();
+        };
+        SlotData.toString = function () {
+            return "[class dragonBones.SlotData]";
+        };
+        SlotData.prototype._onClear = function () {
+            if (this.userData !== null) {
+                this.userData.returnToPool();
+            }
+            this.blendMode = 0 /* Normal */;
+            this.displayIndex = 0;
+            this.zOrder = 0;
+            this.name = "";
+            this.color = null; //
+            this.userData = null;
+            this.parent = null; //
+        };
+        /**
+         * @internal
+         */
+        SlotData.DEFAULT_COLOR = new dragonBones.ColorTransform();
+        return SlotData;
+    }(dragonBones.BaseObject));
+    dragonBones.SlotData = SlotData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var CanvasData = /** @class */ (function (_super) {
+        __extends(CanvasData, _super);
+        function CanvasData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        CanvasData.toString = function () {
+            return "[class dragonBones.CanvasData]";
+        };
+        CanvasData.prototype._onClear = function () {
+            this.hasBackground = false;
+            this.color = 0x000000;
+            this.x = 0;
+            this.y = 0;
+            this.width = 0;
+            this.height = 0;
+        };
+        return CanvasData;
+    }(dragonBones.BaseObject));
+    dragonBones.CanvasData = CanvasData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The skin data, typically a armature data instance contains at least one skinData.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 皮肤数据，通常一个骨架数据至少包含一个皮肤数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var SkinData = /** @class */ (function (_super) {
+        __extends(SkinData, _super);
+        function SkinData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.displays = {};
+            return _this;
+        }
+        SkinData.toString = function () {
+            return "[class dragonBones.SkinData]";
+        };
+        SkinData.prototype._onClear = function () {
+            for (var k in this.displays) {
+                var slotDisplays = this.displays[k];
+                for (var _i = 0, slotDisplays_1 = slotDisplays; _i < slotDisplays_1.length; _i++) {
+                    var display = slotDisplays_1[_i];
+                    if (display !== null) {
+                        display.returnToPool();
+                    }
+                }
+                delete this.displays[k];
+            }
+            this.name = "";
+            // this.displays.clear();
+            this.parent = null; //
+        };
+        /**
+         * @internal
+         */
+        SkinData.prototype.addDisplay = function (slotName, value) {
+            if (!(slotName in this.displays)) {
+                this.displays[slotName] = [];
+            }
+            if (value !== null) {
+                value.parent = this;
+            }
+            var slotDisplays = this.displays[slotName]; // TODO clear prev
+            slotDisplays.push(value);
+        };
+        /**
+         * @private
+         */
+        SkinData.prototype.getDisplay = function (slotName, displayName) {
+            var slotDisplays = this.getDisplays(slotName);
+            if (slotDisplays !== null) {
+                for (var _i = 0, slotDisplays_2 = slotDisplays; _i < slotDisplays_2.length; _i++) {
+                    var display = slotDisplays_2[_i];
+                    if (display !== null && display.name === displayName) {
+                        return display;
+                    }
+                }
+            }
+            return null;
+        };
+        /**
+         * @private
+         */
+        SkinData.prototype.getDisplays = function (slotName) {
+            if (!(slotName in this.displays)) {
+                return null;
+            }
+            return this.displays[slotName];
+        };
+        return SkinData;
+    }(dragonBones.BaseObject));
+    dragonBones.SkinData = SkinData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var ConstraintData = /** @class */ (function (_super) {
+        __extends(ConstraintData, _super);
+        function ConstraintData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ConstraintData.prototype._onClear = function () {
+            this.order = 0;
+            this.name = "";
+            this.type = 0 /* IK */;
+            this.target = null; //
+            this.root = null; //
+            this.bone = null;
+        };
+        return ConstraintData;
+    }(dragonBones.BaseObject));
+    dragonBones.ConstraintData = ConstraintData;
+    /**
+     * @internal
+     */
+    var IKConstraintData = /** @class */ (function (_super) {
+        __extends(IKConstraintData, _super);
+        function IKConstraintData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        IKConstraintData.toString = function () {
+            return "[class dragonBones.IKConstraintData]";
+        };
+        IKConstraintData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.scaleEnabled = false;
+            this.bendPositive = false;
+            this.weight = 1.0;
+        };
+        return IKConstraintData;
+    }(ConstraintData));
+    dragonBones.IKConstraintData = IKConstraintData;
+    /**
+     * @internal
+     */
+    var PathConstraintData = /** @class */ (function (_super) {
+        __extends(PathConstraintData, _super);
+        function PathConstraintData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.bones = [];
+            return _this;
+        }
+        PathConstraintData.toString = function () {
+            return "[class dragonBones.PathConstraintData]";
+        };
+        PathConstraintData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.pathSlot = null;
+            this.pathDisplayData = null;
+            this.bones.length = 0;
+            this.positionMode = 0 /* Fixed */;
+            this.spacingMode = 1 /* Fixed */;
+            this.rotateMode = 1 /* Chain */;
+            this.position = 0.0;
+            this.spacing = 0.0;
+            this.rotateOffset = 0.0;
+            this.rotateMix = 0.0;
+            this.translateMix = 0.0;
+        };
+        PathConstraintData.prototype.AddBone = function (value) {
+            this.bones.push(value);
+        };
+        return PathConstraintData;
+    }(ConstraintData));
+    dragonBones.PathConstraintData = PathConstraintData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var VerticesData = /** @class */ (function () {
+        function VerticesData() {
+            this.weight = null; // Initial value.
+        }
+        VerticesData.prototype.clear = function () {
+            if (!this.isShared && this.weight !== null) {
+                this.weight.returnToPool();
+            }
+            this.isShared = false;
+            this.inheritDeform = false;
+            this.offset = 0;
+            this.data = null;
+            this.weight = null;
+        };
+        VerticesData.prototype.shareFrom = function (value) {
+            this.isShared = true;
+            this.offset = value.offset;
+            this.weight = value.weight;
+        };
+        return VerticesData;
+    }());
+    dragonBones.VerticesData = VerticesData;
+    /**
+     * @internal
+     */
+    var DisplayData = /** @class */ (function (_super) {
+        __extends(DisplayData, _super);
+        function DisplayData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.transform = new dragonBones.Transform();
+            return _this;
+        }
+        DisplayData.prototype._onClear = function () {
+            this.name = "";
+            this.path = "";
+            this.transform.identity();
+            this.parent = null; //
+        };
+        return DisplayData;
+    }(dragonBones.BaseObject));
+    dragonBones.DisplayData = DisplayData;
+    /**
+     * @internal
+     */
+    var ImageDisplayData = /** @class */ (function (_super) {
+        __extends(ImageDisplayData, _super);
+        function ImageDisplayData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.pivot = new dragonBones.Point();
+            return _this;
+        }
+        ImageDisplayData.toString = function () {
+            return "[class dragonBones.ImageDisplayData]";
+        };
+        ImageDisplayData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.type = 0 /* Image */;
+            this.pivot.clear();
+            this.texture = null;
+        };
+        return ImageDisplayData;
+    }(DisplayData));
+    dragonBones.ImageDisplayData = ImageDisplayData;
+    /**
+     * @internal
+     */
+    var ArmatureDisplayData = /** @class */ (function (_super) {
+        __extends(ArmatureDisplayData, _super);
+        function ArmatureDisplayData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.actions = [];
+            return _this;
+        }
+        ArmatureDisplayData.toString = function () {
+            return "[class dragonBones.ArmatureDisplayData]";
+        };
+        ArmatureDisplayData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            for (var _i = 0, _a = this.actions; _i < _a.length; _i++) {
+                var action = _a[_i];
+                action.returnToPool();
+            }
+            this.type = 1 /* Armature */;
+            this.inheritAnimation = false;
+            this.actions.length = 0;
+            this.armature = null;
+        };
+        /**
+         * @private
+         */
+        ArmatureDisplayData.prototype.addAction = function (value) {
+            this.actions.push(value);
+        };
+        return ArmatureDisplayData;
+    }(DisplayData));
+    dragonBones.ArmatureDisplayData = ArmatureDisplayData;
+    /**
+     * @internal
+     */
+    var MeshDisplayData = /** @class */ (function (_super) {
+        __extends(MeshDisplayData, _super);
+        function MeshDisplayData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.vertices = new VerticesData();
+            return _this;
+        }
+        MeshDisplayData.toString = function () {
+            return "[class dragonBones.MeshDisplayData]";
+        };
+        MeshDisplayData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.type = 2 /* Mesh */;
+            this.vertices.clear();
+            this.texture = null;
+        };
+        return MeshDisplayData;
+    }(DisplayData));
+    dragonBones.MeshDisplayData = MeshDisplayData;
+    /**
+     * @internal
+     */
+    var BoundingBoxDisplayData = /** @class */ (function (_super) {
+        __extends(BoundingBoxDisplayData, _super);
+        function BoundingBoxDisplayData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.boundingBox = null; // Initial value.
+            return _this;
+        }
+        BoundingBoxDisplayData.toString = function () {
+            return "[class dragonBones.BoundingBoxDisplayData]";
+        };
+        BoundingBoxDisplayData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            if (this.boundingBox !== null) {
+                this.boundingBox.returnToPool();
+            }
+            this.type = 3 /* BoundingBox */;
+            this.boundingBox = null;
+        };
+        return BoundingBoxDisplayData;
+    }(DisplayData));
+    dragonBones.BoundingBoxDisplayData = BoundingBoxDisplayData;
+    /**
+     * @internal
+     */
+    var PathDisplayData = /** @class */ (function (_super) {
+        __extends(PathDisplayData, _super);
+        function PathDisplayData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.vertices = new VerticesData();
+            _this.curveLengths = [];
+            return _this;
+        }
+        PathDisplayData.toString = function () {
+            return "[class dragonBones.PathDisplayData]";
+        };
+        PathDisplayData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.type = 4 /* Path */;
+            this.closed = false;
+            this.constantSpeed = false;
+            this.vertices.clear();
+            this.curveLengths.length = 0;
+        };
+        return PathDisplayData;
+    }(DisplayData));
+    dragonBones.PathDisplayData = PathDisplayData;
+    /**
+     * @internal
+     */
+    var WeightData = /** @class */ (function (_super) {
+        __extends(WeightData, _super);
+        function WeightData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.bones = [];
+            return _this;
+        }
+        WeightData.toString = function () {
+            return "[class dragonBones.WeightData]";
+        };
+        WeightData.prototype._onClear = function () {
+            this.count = 0;
+            this.offset = 0;
+            this.bones.length = 0;
+        };
+        WeightData.prototype.addBone = function (value) {
+            this.bones.push(value);
+        };
+        return WeightData;
+    }(dragonBones.BaseObject));
+    dragonBones.WeightData = WeightData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The base class of bounding box data.
+     * @see dragonBones.RectangleData
+     * @see dragonBones.EllipseData
+     * @see dragonBones.PolygonData
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 边界框数据基类。
+     * @see dragonBones.RectangleData
+     * @see dragonBones.EllipseData
+     * @see dragonBones.PolygonData
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    var BoundingBoxData = /** @class */ (function (_super) {
+        __extends(BoundingBoxData, _super);
+        function BoundingBoxData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BoundingBoxData.prototype._onClear = function () {
+            this.color = 0x000000;
+            this.width = 0.0;
+            this.height = 0.0;
+        };
+        return BoundingBoxData;
+    }(dragonBones.BaseObject));
+    dragonBones.BoundingBoxData = BoundingBoxData;
+    /**
+     * - The rectangle bounding box data.
+     * @version DragonBones 5.1
+     * @language en_US
+     */
+    /**
+     * - 矩形边界框数据。
+     * @version DragonBones 5.1
+     * @language zh_CN
+     */
+    var RectangleBoundingBoxData = /** @class */ (function (_super) {
+        __extends(RectangleBoundingBoxData, _super);
+        function RectangleBoundingBoxData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        RectangleBoundingBoxData.toString = function () {
+            return "[class dragonBones.RectangleBoundingBoxData]";
+        };
+        /**
+         * - Compute the bit code for a point (x, y) using the clip rectangle
+         */
+        RectangleBoundingBoxData._computeOutCode = function (x, y, xMin, yMin, xMax, yMax) {
+            var code = 0 /* InSide */; // initialised as being inside of [[clip window]]
+            if (x < xMin) {
+                code |= 1 /* Left */;
+            }
+            else if (x > xMax) {
+                code |= 2 /* Right */;
+            }
+            if (y < yMin) {
+                code |= 4 /* Top */;
+            }
+            else if (y > yMax) {
+                code |= 8 /* Bottom */;
+            }
+            return code;
+        };
+        /**
+         * @private
+         */
+        RectangleBoundingBoxData.rectangleIntersectsSegment = function (xA, yA, xB, yB, xMin, yMin, xMax, yMax, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            var inSideA = xA > xMin && xA < xMax && yA > yMin && yA < yMax;
+            var inSideB = xB > xMin && xB < xMax && yB > yMin && yB < yMax;
+            if (inSideA && inSideB) {
+                return -1;
+            }
+            var intersectionCount = 0;
+            var outcode0 = RectangleBoundingBoxData._computeOutCode(xA, yA, xMin, yMin, xMax, yMax);
+            var outcode1 = RectangleBoundingBoxData._computeOutCode(xB, yB, xMin, yMin, xMax, yMax);
+            while (true) {
+                if ((outcode0 | outcode1) === 0) {
+                    intersectionCount = 2;
+                    break;
+                }
+                else if ((outcode0 & outcode1) !== 0) {
+                    break;
+                }
+                // failed both tests, so calculate the line segment to clip
+                // from an outside point to an intersection with clip edge
+                var x = 0.0;
+                var y = 0.0;
+                var normalRadian = 0.0;
+                // At least one endpoint is outside the clip rectangle; pick it.
+                var outcodeOut = outcode0 !== 0 ? outcode0 : outcode1;
+                // Now find the intersection point;
+                if ((outcodeOut & 4 /* Top */) !== 0) {
+                    x = xA + (xB - xA) * (yMin - yA) / (yB - yA);
+                    y = yMin;
+                    if (normalRadians !== null) {
+                        normalRadian = -Math.PI * 0.5;
+                    }
+                }
+                else if ((outcodeOut & 8 /* Bottom */) !== 0) {
+                    x = xA + (xB - xA) * (yMax - yA) / (yB - yA);
+                    y = yMax;
+                    if (normalRadians !== null) {
+                        normalRadian = Math.PI * 0.5;
+                    }
+                }
+                else if ((outcodeOut & 2 /* Right */) !== 0) {
+                    y = yA + (yB - yA) * (xMax - xA) / (xB - xA);
+                    x = xMax;
+                    if (normalRadians !== null) {
+                        normalRadian = 0;
+                    }
+                }
+                else if ((outcodeOut & 1 /* Left */) !== 0) {
+                    y = yA + (yB - yA) * (xMin - xA) / (xB - xA);
+                    x = xMin;
+                    if (normalRadians !== null) {
+                        normalRadian = Math.PI;
+                    }
+                }
+                // Now we move outside point to intersection point to clip
+                // and get ready for next pass.
+                if (outcodeOut === outcode0) {
+                    xA = x;
+                    yA = y;
+                    outcode0 = RectangleBoundingBoxData._computeOutCode(xA, yA, xMin, yMin, xMax, yMax);
+                    if (normalRadians !== null) {
+                        normalRadians.x = normalRadian;
+                    }
+                }
+                else {
+                    xB = x;
+                    yB = y;
+                    outcode1 = RectangleBoundingBoxData._computeOutCode(xB, yB, xMin, yMin, xMax, yMax);
+                    if (normalRadians !== null) {
+                        normalRadians.y = normalRadian;
+                    }
+                }
+            }
+            if (intersectionCount) {
+                if (inSideA) {
+                    intersectionCount = 2; // 10
+                    if (intersectionPointA !== null) {
+                        intersectionPointA.x = xB;
+                        intersectionPointA.y = yB;
+                    }
+                    if (intersectionPointB !== null) {
+                        intersectionPointB.x = xB;
+                        intersectionPointB.y = xB;
+                    }
+                    if (normalRadians !== null) {
+                        normalRadians.x = normalRadians.y + Math.PI;
+                    }
+                }
+                else if (inSideB) {
+                    intersectionCount = 1; // 01
+                    if (intersectionPointA !== null) {
+                        intersectionPointA.x = xA;
+                        intersectionPointA.y = yA;
+                    }
+                    if (intersectionPointB !== null) {
+                        intersectionPointB.x = xA;
+                        intersectionPointB.y = yA;
+                    }
+                    if (normalRadians !== null) {
+                        normalRadians.y = normalRadians.x + Math.PI;
+                    }
+                }
+                else {
+                    intersectionCount = 3; // 11
+                    if (intersectionPointA !== null) {
+                        intersectionPointA.x = xA;
+                        intersectionPointA.y = yA;
+                    }
+                    if (intersectionPointB !== null) {
+                        intersectionPointB.x = xB;
+                        intersectionPointB.y = yB;
+                    }
+                }
+            }
+            return intersectionCount;
+        };
+        RectangleBoundingBoxData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.type = 0 /* Rectangle */;
+        };
+        /**
+         * @inheritDoc
+         */
+        RectangleBoundingBoxData.prototype.containsPoint = function (pX, pY) {
+            var widthH = this.width * 0.5;
+            if (pX >= -widthH && pX <= widthH) {
+                var heightH = this.height * 0.5;
+                if (pY >= -heightH && pY <= heightH) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        /**
+         * @inheritDoc
+         */
+        RectangleBoundingBoxData.prototype.intersectsSegment = function (xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            var widthH = this.width * 0.5;
+            var heightH = this.height * 0.5;
+            var intersectionCount = RectangleBoundingBoxData.rectangleIntersectsSegment(xA, yA, xB, yB, -widthH, -heightH, widthH, heightH, intersectionPointA, intersectionPointB, normalRadians);
+            return intersectionCount;
+        };
+        return RectangleBoundingBoxData;
+    }(BoundingBoxData));
+    dragonBones.RectangleBoundingBoxData = RectangleBoundingBoxData;
+    /**
+     * - The ellipse bounding box data.
+     * @version DragonBones 5.1
+     * @language en_US
+     */
+    /**
+     * - 椭圆边界框数据。
+     * @version DragonBones 5.1
+     * @language zh_CN
+     */
+    var EllipseBoundingBoxData = /** @class */ (function (_super) {
+        __extends(EllipseBoundingBoxData, _super);
+        function EllipseBoundingBoxData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        EllipseBoundingBoxData.toString = function () {
+            return "[class dragonBones.EllipseData]";
+        };
+        /**
+         * @private
+         */
+        EllipseBoundingBoxData.ellipseIntersectsSegment = function (xA, yA, xB, yB, xC, yC, widthH, heightH, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            var d = widthH / heightH;
+            var dd = d * d;
+            yA *= d;
+            yB *= d;
+            var dX = xB - xA;
+            var dY = yB - yA;
+            var lAB = Math.sqrt(dX * dX + dY * dY);
+            var xD = dX / lAB;
+            var yD = dY / lAB;
+            var a = (xC - xA) * xD + (yC - yA) * yD;
+            var aa = a * a;
+            var ee = xA * xA + yA * yA;
+            var rr = widthH * widthH;
+            var dR = rr - ee + aa;
+            var intersectionCount = 0;
+            if (dR >= 0.0) {
+                var dT = Math.sqrt(dR);
+                var sA = a - dT;
+                var sB = a + dT;
+                var inSideA = sA < 0.0 ? -1 : (sA <= lAB ? 0 : 1);
+                var inSideB = sB < 0.0 ? -1 : (sB <= lAB ? 0 : 1);
+                var sideAB = inSideA * inSideB;
+                if (sideAB < 0) {
+                    return -1;
+                }
+                else if (sideAB === 0) {
+                    if (inSideA === -1) {
+                        intersectionCount = 2; // 10
+                        xB = xA + sB * xD;
+                        yB = (yA + sB * yD) / d;
+                        if (intersectionPointA !== null) {
+                            intersectionPointA.x = xB;
+                            intersectionPointA.y = yB;
+                        }
+                        if (intersectionPointB !== null) {
+                            intersectionPointB.x = xB;
+                            intersectionPointB.y = yB;
+                        }
+                        if (normalRadians !== null) {
+                            normalRadians.x = Math.atan2(yB / rr * dd, xB / rr);
+                            normalRadians.y = normalRadians.x + Math.PI;
+                        }
+                    }
+                    else if (inSideB === 1) {
+                        intersectionCount = 1; // 01
+                        xA = xA + sA * xD;
+                        yA = (yA + sA * yD) / d;
+                        if (intersectionPointA !== null) {
+                            intersectionPointA.x = xA;
+                            intersectionPointA.y = yA;
+                        }
+                        if (intersectionPointB !== null) {
+                            intersectionPointB.x = xA;
+                            intersectionPointB.y = yA;
+                        }
+                        if (normalRadians !== null) {
+                            normalRadians.x = Math.atan2(yA / rr * dd, xA / rr);
+                            normalRadians.y = normalRadians.x + Math.PI;
+                        }
+                    }
+                    else {
+                        intersectionCount = 3; // 11
+                        if (intersectionPointA !== null) {
+                            intersectionPointA.x = xA + sA * xD;
+                            intersectionPointA.y = (yA + sA * yD) / d;
+                            if (normalRadians !== null) {
+                                normalRadians.x = Math.atan2(intersectionPointA.y / rr * dd, intersectionPointA.x / rr);
+                            }
+                        }
+                        if (intersectionPointB !== null) {
+                            intersectionPointB.x = xA + sB * xD;
+                            intersectionPointB.y = (yA + sB * yD) / d;
+                            if (normalRadians !== null) {
+                                normalRadians.y = Math.atan2(intersectionPointB.y / rr * dd, intersectionPointB.x / rr);
+                            }
+                        }
+                    }
+                }
+            }
+            return intersectionCount;
+        };
+        EllipseBoundingBoxData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.type = 1 /* Ellipse */;
+        };
+        /**
+         * @inheritDoc
+         */
+        EllipseBoundingBoxData.prototype.containsPoint = function (pX, pY) {
+            var widthH = this.width * 0.5;
+            if (pX >= -widthH && pX <= widthH) {
+                var heightH = this.height * 0.5;
+                if (pY >= -heightH && pY <= heightH) {
+                    pY *= widthH / heightH;
+                    return Math.sqrt(pX * pX + pY * pY) <= widthH;
+                }
+            }
+            return false;
+        };
+        /**
+         * @inheritDoc
+         */
+        EllipseBoundingBoxData.prototype.intersectsSegment = function (xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            var intersectionCount = EllipseBoundingBoxData.ellipseIntersectsSegment(xA, yA, xB, yB, 0.0, 0.0, this.width * 0.5, this.height * 0.5, intersectionPointA, intersectionPointB, normalRadians);
+            return intersectionCount;
+        };
+        return EllipseBoundingBoxData;
+    }(BoundingBoxData));
+    dragonBones.EllipseBoundingBoxData = EllipseBoundingBoxData;
+    /**
+     * - The polygon bounding box data.
+     * @version DragonBones 5.1
+     * @language en_US
+     */
+    /**
+     * - 多边形边界框数据。
+     * @version DragonBones 5.1
+     * @language zh_CN
+     */
+    var PolygonBoundingBoxData = /** @class */ (function (_super) {
+        __extends(PolygonBoundingBoxData, _super);
+        function PolygonBoundingBoxData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * - The polygon vertices.
+             * @version DragonBones 5.1
+             * @language en_US
+             */
+            /**
+             * - 多边形顶点。
+             * @version DragonBones 5.1
+             * @language zh_CN
+             */
+            _this.vertices = [];
+            return _this;
+        }
+        PolygonBoundingBoxData.toString = function () {
+            return "[class dragonBones.PolygonBoundingBoxData]";
+        };
+        /**
+         * @private
+         */
+        PolygonBoundingBoxData.polygonIntersectsSegment = function (xA, yA, xB, yB, vertices, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            if (xA === xB) {
+                xA = xB + 0.000001;
+            }
+            if (yA === yB) {
+                yA = yB + 0.000001;
+            }
+            var count = vertices.length;
+            var dXAB = xA - xB;
+            var dYAB = yA - yB;
+            var llAB = xA * yB - yA * xB;
+            var intersectionCount = 0;
+            var xC = vertices[count - 2];
+            var yC = vertices[count - 1];
+            var dMin = 0.0;
+            var dMax = 0.0;
+            var xMin = 0.0;
+            var yMin = 0.0;
+            var xMax = 0.0;
+            var yMax = 0.0;
+            for (var i = 0; i < count; i += 2) {
+                var xD = vertices[i];
+                var yD = vertices[i + 1];
+                if (xC === xD) {
+                    xC = xD + 0.0001;
+                }
+                if (yC === yD) {
+                    yC = yD + 0.0001;
+                }
+                var dXCD = xC - xD;
+                var dYCD = yC - yD;
+                var llCD = xC * yD - yC * xD;
+                var ll = dXAB * dYCD - dYAB * dXCD;
+                var x = (llAB * dXCD - dXAB * llCD) / ll;
+                if (((x >= xC && x <= xD) || (x >= xD && x <= xC)) && (dXAB === 0.0 || (x >= xA && x <= xB) || (x >= xB && x <= xA))) {
+                    var y = (llAB * dYCD - dYAB * llCD) / ll;
+                    if (((y >= yC && y <= yD) || (y >= yD && y <= yC)) && (dYAB === 0.0 || (y >= yA && y <= yB) || (y >= yB && y <= yA))) {
+                        if (intersectionPointB !== null) {
+                            var d = x - xA;
+                            if (d < 0.0) {
+                                d = -d;
+                            }
+                            if (intersectionCount === 0) {
+                                dMin = d;
+                                dMax = d;
+                                xMin = x;
+                                yMin = y;
+                                xMax = x;
+                                yMax = y;
+                                if (normalRadians !== null) {
+                                    normalRadians.x = Math.atan2(yD - yC, xD - xC) - Math.PI * 0.5;
+                                    normalRadians.y = normalRadians.x;
+                                }
+                            }
+                            else {
+                                if (d < dMin) {
+                                    dMin = d;
+                                    xMin = x;
+                                    yMin = y;
+                                    if (normalRadians !== null) {
+                                        normalRadians.x = Math.atan2(yD - yC, xD - xC) - Math.PI * 0.5;
+                                    }
+                                }
+                                if (d > dMax) {
+                                    dMax = d;
+                                    xMax = x;
+                                    yMax = y;
+                                    if (normalRadians !== null) {
+                                        normalRadians.y = Math.atan2(yD - yC, xD - xC) - Math.PI * 0.5;
+                                    }
+                                }
+                            }
+                            intersectionCount++;
+                        }
+                        else {
+                            xMin = x;
+                            yMin = y;
+                            xMax = x;
+                            yMax = y;
+                            intersectionCount++;
+                            if (normalRadians !== null) {
+                                normalRadians.x = Math.atan2(yD - yC, xD - xC) - Math.PI * 0.5;
+                                normalRadians.y = normalRadians.x;
+                            }
+                            break;
+                        }
+                    }
+                }
+                xC = xD;
+                yC = yD;
+            }
+            if (intersectionCount === 1) {
+                if (intersectionPointA !== null) {
+                    intersectionPointA.x = xMin;
+                    intersectionPointA.y = yMin;
+                }
+                if (intersectionPointB !== null) {
+                    intersectionPointB.x = xMin;
+                    intersectionPointB.y = yMin;
+                }
+                if (normalRadians !== null) {
+                    normalRadians.y = normalRadians.x + Math.PI;
+                }
+            }
+            else if (intersectionCount > 1) {
+                intersectionCount++;
+                if (intersectionPointA !== null) {
+                    intersectionPointA.x = xMin;
+                    intersectionPointA.y = yMin;
+                }
+                if (intersectionPointB !== null) {
+                    intersectionPointB.x = xMax;
+                    intersectionPointB.y = yMax;
+                }
+            }
+            return intersectionCount;
+        };
+        PolygonBoundingBoxData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.type = 2 /* Polygon */;
+            this.x = 0.0;
+            this.y = 0.0;
+            this.vertices.length = 0;
+        };
+        /**
+         * @inheritDoc
+         */
+        PolygonBoundingBoxData.prototype.containsPoint = function (pX, pY) {
+            var isInSide = false;
+            if (pX >= this.x && pX <= this.width && pY >= this.y && pY <= this.height) {
+                for (var i = 0, l = this.vertices.length, iP = l - 2; i < l; i += 2) {
+                    var yA = this.vertices[iP + 1];
+                    var yB = this.vertices[i + 1];
+                    if ((yB < pY && yA >= pY) || (yA < pY && yB >= pY)) {
+                        var xA = this.vertices[iP];
+                        var xB = this.vertices[i];
+                        if ((pY - yB) * (xA - xB) / (yA - yB) + xB < pX) {
+                            isInSide = !isInSide;
+                        }
+                    }
+                    iP = i;
+                }
+            }
+            return isInSide;
+        };
+        /**
+         * @inheritDoc
+         */
+        PolygonBoundingBoxData.prototype.intersectsSegment = function (xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            var intersectionCount = 0;
+            if (RectangleBoundingBoxData.rectangleIntersectsSegment(xA, yA, xB, yB, this.x, this.y, this.x + this.width, this.y + this.height, null, null, null) !== 0) {
+                intersectionCount = PolygonBoundingBoxData.polygonIntersectsSegment(xA, yA, xB, yB, this.vertices, intersectionPointA, intersectionPointB, normalRadians);
+            }
+            return intersectionCount;
+        };
+        return PolygonBoundingBoxData;
+    }(BoundingBoxData));
+    dragonBones.PolygonBoundingBoxData = PolygonBoundingBoxData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The animation data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 动画数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var AnimationData = /** @class */ (function (_super) {
+        __extends(AnimationData, _super);
+        function AnimationData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.cachedFrames = [];
+            /**
+             * @private
+             */
+            _this.boneTimelines = {};
+            /**
+             * @private
+             */
+            _this.surfaceTimelines = {};
+            /**
+             * @private
+             */
+            _this.slotTimelines = {};
+            /**
+             * @private
+             */
+            _this.constraintTimelines = {};
+            /**
+             * @private
+             */
+            _this.animationTimelines = {};
+            /**
+             * @private
+             */
+            _this.boneCachedFrameIndices = {};
+            /**
+             * @private
+             */
+            _this.slotCachedFrameIndices = {};
+            /**
+             * @private
+             */
+            _this.actionTimeline = null; // Initial value.
+            /**
+             * @private
+             */
+            _this.zOrderTimeline = null; // Initial value.
+            return _this;
+        }
+        AnimationData.toString = function () {
+            return "[class dragonBones.AnimationData]";
+        };
+        AnimationData.prototype._onClear = function () {
+            for (var k in this.boneTimelines) {
+                for (var _i = 0, _a = this.boneTimelines[k]; _i < _a.length; _i++) {
+                    var timeline = _a[_i];
+                    timeline.returnToPool();
+                }
+                delete this.boneTimelines[k];
+            }
+            for (var k in this.surfaceTimelines) {
+                for (var _b = 0, _c = this.surfaceTimelines[k]; _b < _c.length; _b++) {
+                    var timeline = _c[_b];
+                    timeline.returnToPool();
+                }
+                delete this.surfaceTimelines[k];
+            }
+            for (var k in this.slotTimelines) {
+                for (var _d = 0, _e = this.slotTimelines[k]; _d < _e.length; _d++) {
+                    var timeline = _e[_d];
+                    timeline.returnToPool();
+                }
+                delete this.slotTimelines[k];
+            }
+            for (var k in this.constraintTimelines) {
+                for (var _f = 0, _g = this.constraintTimelines[k]; _f < _g.length; _f++) {
+                    var timeline = _g[_f];
+                    timeline.returnToPool();
+                }
+                delete this.constraintTimelines[k];
+            }
+            for (var k in this.animationTimelines) {
+                for (var _h = 0, _j = this.animationTimelines[k]; _h < _j.length; _h++) {
+                    var timeline = _j[_h];
+                    timeline.returnToPool();
+                }
+                delete this.animationTimelines[k];
+            }
+            for (var k in this.boneCachedFrameIndices) {
+                delete this.boneCachedFrameIndices[k];
+            }
+            for (var k in this.slotCachedFrameIndices) {
+                delete this.slotCachedFrameIndices[k];
+            }
+            if (this.actionTimeline !== null) {
+                this.actionTimeline.returnToPool();
+            }
+            if (this.zOrderTimeline !== null) {
+                this.zOrderTimeline.returnToPool();
+            }
+            this.frameIntOffset = 0;
+            this.frameFloatOffset = 0;
+            this.frameOffset = 0;
+            this.frameCount = 0;
+            this.playTimes = 0;
+            this.duration = 0.0;
+            this.scale = 1.0;
+            this.fadeInTime = 0.0;
+            this.cacheFrameRate = 0.0;
+            this.name = "";
+            this.cachedFrames.length = 0;
+            // this.boneTimelines.clear();
+            // this.surfaceTimelines.clear();
+            // this.slotTimelines.clear();
+            // this.constraintTimelines.clear();
+            // this.animationTimelines.clear();
+            // this.boneCachedFrameIndices.clear();
+            // this.slotCachedFrameIndices.clear();
+            this.actionTimeline = null;
+            this.zOrderTimeline = null;
+            this.parent = null; //
+        };
+        /**
+         * @internal
+         */
+        AnimationData.prototype.cacheFrames = function (frameRate) {
+            if (this.cacheFrameRate > 0.0) {
+                return;
+            }
+            this.cacheFrameRate = Math.max(Math.ceil(frameRate * this.scale), 1.0);
+            var cacheFrameCount = Math.ceil(this.cacheFrameRate * this.duration) + 1; // Cache one more frame.
+            this.cachedFrames.length = cacheFrameCount;
+            for (var i = 0, l = this.cacheFrames.length; i < l; ++i) {
+                this.cachedFrames[i] = false;
+            }
+            for (var _i = 0, _a = this.parent.sortedBones; _i < _a.length; _i++) {
+                var bone = _a[_i];
+                var indices = new Array(cacheFrameCount);
+                for (var i = 0, l = indices.length; i < l; ++i) {
+                    indices[i] = -1;
+                }
+                this.boneCachedFrameIndices[bone.name] = indices;
+            }
+            for (var _b = 0, _c = this.parent.sortedSlots; _b < _c.length; _b++) {
+                var slot = _c[_b];
+                var indices = new Array(cacheFrameCount);
+                for (var i = 0, l = indices.length; i < l; ++i) {
+                    indices[i] = -1;
+                }
+                this.slotCachedFrameIndices[slot.name] = indices;
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.addBoneTimeline = function (bone, timeline) {
+            var timelines = bone.name in this.boneTimelines ? this.boneTimelines[bone.name] : (this.boneTimelines[bone.name] = []);
+            if (timelines.indexOf(timeline) < 0) {
+                timelines.push(timeline);
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.addSurfaceTimeline = function (surface, timeline) {
+            var timelines = surface.name in this.surfaceTimelines ? this.surfaceTimelines[surface.name] : (this.surfaceTimelines[surface.name] = []);
+            if (timelines.indexOf(timeline) < 0) {
+                timelines.push(timeline);
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.addSlotTimeline = function (slot, timeline) {
+            var timelines = slot.name in this.slotTimelines ? this.slotTimelines[slot.name] : (this.slotTimelines[slot.name] = []);
+            if (timelines.indexOf(timeline) < 0) {
+                timelines.push(timeline);
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.addConstraintTimeline = function (constraint, timeline) {
+            var timelines = constraint.name in this.constraintTimelines ? this.constraintTimelines[constraint.name] : (this.constraintTimelines[constraint.name] = []);
+            if (timelines.indexOf(timeline) < 0) {
+                timelines.push(timeline);
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.addAnimationTimeline = function (timelineName, timeline) {
+            var timelines = timelineName in this.animationTimelines ? this.animationTimelines[timelineName] : (this.animationTimelines[timelineName] = []);
+            if (timelines.indexOf(timeline) < 0) {
+                timelines.push(timeline);
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.getBoneTimelines = function (timelineName) {
+            return timelineName in this.boneTimelines ? this.boneTimelines[timelineName] : null;
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.getSurfaceTimelines = function (timelineName) {
+            return timelineName in this.surfaceTimelines ? this.surfaceTimelines[timelineName] : null;
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.getSlotTimelines = function (timelineName) {
+            return timelineName in this.slotTimelines ? this.slotTimelines[timelineName] : null;
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.getConstraintTimelines = function (timelineName) {
+            return timelineName in this.constraintTimelines ? this.constraintTimelines[timelineName] : null;
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.getAnimationTimelines = function (timelineName) {
+            return timelineName in this.animationTimelines ? this.animationTimelines[timelineName] : null;
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.getBoneCachedFrameIndices = function (boneName) {
+            return boneName in this.boneCachedFrameIndices ? this.boneCachedFrameIndices[boneName] : null;
+        };
+        /**
+         * @private
+         */
+        AnimationData.prototype.getSlotCachedFrameIndices = function (slotName) {
+            return slotName in this.slotCachedFrameIndices ? this.slotCachedFrameIndices[slotName] : null;
+        };
+        return AnimationData;
+    }(dragonBones.BaseObject));
+    dragonBones.AnimationData = AnimationData;
+    /**
+     * @internal
+     */
+    var TimelineData = /** @class */ (function (_super) {
+        __extends(TimelineData, _super);
+        function TimelineData() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TimelineData.toString = function () {
+            return "[class dragonBones.TimelineData]";
+        };
+        TimelineData.prototype._onClear = function () {
+            this.type = 10 /* BoneAll */;
+            this.offset = 0;
+            this.frameIndicesOffset = -1;
+        };
+        return TimelineData;
+    }(dragonBones.BaseObject));
+    dragonBones.TimelineData = TimelineData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The animation config is used to describe all the information needed to play an animation state.
+     * The API is still in the experimental phase and may encounter bugs or stability or compatibility issues when used.
+     * @see dragonBones.AnimationState
+     * @beta
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    /**
+     * - 动画配置用来描述播放一个动画状态所需要的全部信息。
+     * 该 API 仍在实验阶段，使用时可能遭遇 bug 或稳定性或兼容性问题。
+     * @see dragonBones.AnimationState
+     * @beta
+     * @version DragonBones 5.0
+     * @language zh_CN
+     */
+    var AnimationConfig = /** @class */ (function (_super) {
+        __extends(AnimationConfig, _super);
+        function AnimationConfig() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.boneMask = [];
+            return _this;
+        }
+        AnimationConfig.toString = function () {
+            return "[class dragonBones.AnimationConfig]";
+        };
+        AnimationConfig.prototype._onClear = function () {
+            this.pauseFadeOut = true;
+            this.fadeOutMode = 4 /* All */;
+            this.fadeOutTweenType = 1 /* Line */;
+            this.fadeOutTime = -1.0;
+            this.actionEnabled = true;
+            this.additiveBlending = false;
+            this.displayControl = true;
+            this.pauseFadeIn = true;
+            this.resetToPose = true;
+            this.fadeInTweenType = 1 /* Line */;
+            this.playTimes = -1;
+            this.layer = 0;
+            this.position = 0.0;
+            this.duration = -1.0;
+            this.timeScale = -100.0;
+            this.weight = 1.0;
+            this.fadeInTime = -1.0;
+            this.autoFadeOutTime = -1.0;
+            this.name = "";
+            this.animation = "";
+            this.group = "";
+            this.boneMask.length = 0;
+        };
+        /**
+         * @private
+         */
+        AnimationConfig.prototype.clear = function () {
+            this._onClear();
+        };
+        /**
+         * @private
+         */
+        AnimationConfig.prototype.copyFrom = function (value) {
+            this.pauseFadeOut = value.pauseFadeOut;
+            this.fadeOutMode = value.fadeOutMode;
+            this.autoFadeOutTime = value.autoFadeOutTime;
+            this.fadeOutTweenType = value.fadeOutTweenType;
+            this.actionEnabled = value.actionEnabled;
+            this.additiveBlending = value.additiveBlending;
+            this.displayControl = value.displayControl;
+            this.pauseFadeIn = value.pauseFadeIn;
+            this.resetToPose = value.resetToPose;
+            this.playTimes = value.playTimes;
+            this.layer = value.layer;
+            this.position = value.position;
+            this.duration = value.duration;
+            this.timeScale = value.timeScale;
+            this.fadeInTime = value.fadeInTime;
+            this.fadeOutTime = value.fadeOutTime;
+            this.fadeInTweenType = value.fadeInTweenType;
+            this.weight = value.weight;
+            this.name = value.name;
+            this.animation = value.animation;
+            this.group = value.group;
+            this.boneMask.length = value.boneMask.length;
+            for (var i = 0, l = this.boneMask.length; i < l; ++i) {
+                this.boneMask[i] = value.boneMask[i];
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationConfig.prototype.containsBoneMask = function (boneName) {
+            return this.boneMask.length === 0 || this.boneMask.indexOf(boneName) >= 0;
+        };
+        /**
+         * @private
+         */
+        AnimationConfig.prototype.addBoneMask = function (armature, boneName, recursive) {
+            if (recursive === void 0) { recursive = true; }
+            var currentBone = armature.getBone(boneName);
+            if (currentBone === null) {
+                return;
+            }
+            if (this.boneMask.indexOf(boneName) < 0) {
+                this.boneMask.push(boneName);
+            }
+            if (recursive) {
+                for (var _i = 0, _a = armature.getBones(); _i < _a.length; _i++) {
+                    var bone = _a[_i];
+                    if (this.boneMask.indexOf(bone.name) < 0 && currentBone.contains(bone)) {
+                        this.boneMask.push(bone.name);
+                    }
+                }
+            }
+        };
+        /**
+         * @private
+         */
+        AnimationConfig.prototype.removeBoneMask = function (armature, boneName, recursive) {
+            if (recursive === void 0) { recursive = true; }
+            var index = this.boneMask.indexOf(boneName);
+            if (index >= 0) {
+                this.boneMask.splice(index, 1);
+            }
+            if (recursive) {
+                var currentBone = armature.getBone(boneName);
+                if (currentBone !== null) {
+                    if (this.boneMask.length > 0) {
+                        for (var _i = 0, _a = armature.getBones(); _i < _a.length; _i++) {
+                            var bone = _a[_i];
+                            var index_1 = this.boneMask.indexOf(bone.name);
+                            if (index_1 >= 0 && currentBone.contains(bone)) {
+                                this.boneMask.splice(index_1, 1);
+                            }
+                        }
+                    }
+                    else {
+                        for (var _b = 0, _c = armature.getBones(); _b < _c.length; _b++) {
+                            var bone = _c[_b];
+                            if (bone === currentBone) {
+                                continue;
+                            }
+                            if (!currentBone.contains(bone)) {
+                                this.boneMask.push(bone.name);
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        return AnimationConfig;
+    }(dragonBones.BaseObject));
+    dragonBones.AnimationConfig = AnimationConfig;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The texture atlas data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 贴图集数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var TextureAtlasData = /** @class */ (function (_super) {
+        __extends(TextureAtlasData, _super);
+        function TextureAtlasData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.textures = {};
+            return _this;
+        }
+        TextureAtlasData.prototype._onClear = function () {
+            for (var k in this.textures) {
+                this.textures[k].returnToPool();
+                delete this.textures[k];
+            }
+            this.autoSearch = false;
+            this.width = 0;
+            this.height = 0;
+            this.scale = 1.0;
+            // this.textures.clear();
+            this.name = "";
+            this.imagePath = "";
+        };
+        /**
+         * @private
+         */
+        TextureAtlasData.prototype.copyFrom = function (value) {
+            this.autoSearch = value.autoSearch;
+            this.scale = value.scale;
+            this.width = value.width;
+            this.height = value.height;
+            this.name = value.name;
+            this.imagePath = value.imagePath;
+            for (var k in this.textures) {
+                this.textures[k].returnToPool();
+                delete this.textures[k];
+            }
+            // this.textures.clear();
+            for (var k in value.textures) {
+                var texture = this.createTexture();
+                texture.copyFrom(value.textures[k]);
+                this.textures[k] = texture;
+            }
+        };
+        /**
+         * @internal
+         */
+        TextureAtlasData.prototype.addTexture = function (value) {
+            if (value.name in this.textures) {
+                console.warn("Same texture: " + value.name);
+                return;
+            }
+            value.parent = this;
+            this.textures[value.name] = value;
+        };
+        /**
+         * @private
+         */
+        TextureAtlasData.prototype.getTexture = function (textureName) {
+            return textureName in this.textures ? this.textures[textureName] : null;
+        };
+        return TextureAtlasData;
+    }(dragonBones.BaseObject));
+    dragonBones.TextureAtlasData = TextureAtlasData;
+    /**
+     * @internal
+     */
+    var TextureData = /** @class */ (function (_super) {
+        __extends(TextureData, _super);
+        function TextureData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.region = new dragonBones.Rectangle();
+            _this.frame = null; // Initial value.
+            return _this;
+        }
+        TextureData.createRectangle = function () {
+            return new dragonBones.Rectangle();
+        };
+        TextureData.prototype._onClear = function () {
+            this.rotated = false;
+            this.name = "";
+            this.region.clear();
+            this.parent = null; //
+            this.frame = null;
+        };
+        TextureData.prototype.copyFrom = function (value) {
+            this.rotated = value.rotated;
+            this.name = value.name;
+            this.region.copyFrom(value.region);
+            this.parent = value.parent;
+            if (this.frame === null && value.frame !== null) {
+                this.frame = TextureData.createRectangle();
+            }
+            else if (this.frame !== null && value.frame === null) {
+                this.frame = null;
+            }
+            if (this.frame !== null && value.frame !== null) {
+                this.frame.copyFrom(value.frame);
+            }
+        };
+        return TextureData;
+    }(dragonBones.BaseObject));
+    dragonBones.TextureData = TextureData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var DeformVertices = /** @class */ (function (_super) {
+        __extends(DeformVertices, _super);
+        function DeformVertices() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.vertices = [];
+            _this.bones = [];
+            return _this;
+        }
+        DeformVertices.toString = function () {
+            return "[class dragonBones.DeformVertices]";
+        };
+        DeformVertices.prototype._onClear = function () {
+            this.verticesDirty = false;
+            this.vertices.length = 0;
+            this.bones.length = 0;
+            this.verticesData = null;
+        };
+        DeformVertices.prototype.init = function (verticesDataValue, armature) {
+            this.verticesData = verticesDataValue;
+            if (this.verticesData !== null) {
+                var vertexCount = 0;
+                if (this.verticesData.weight !== null) {
+                    vertexCount = this.verticesData.weight.count * 2;
+                }
+                else {
+                    vertexCount = this.verticesData.data.intArray[this.verticesData.offset + 0 /* MeshVertexCount */] * 2;
+                }
+                this.verticesDirty = true;
+                this.vertices.length = vertexCount;
+                this.bones.length = 0;
+                //
+                for (var i = 0, l = this.vertices.length; i < l; ++i) {
+                    this.vertices[i] = 0.0;
+                }
+                if (this.verticesData.weight !== null) {
+                    for (var i = 0, l = this.verticesData.weight.bones.length; i < l; ++i) {
+                        var bone = armature.getBone(this.verticesData.weight.bones[i].name);
+                        this.bones.push(bone);
+                    }
+                }
+            }
+            else {
+                this.verticesDirty = false;
+                this.vertices.length = 0;
+                this.bones.length = 0;
+                this.verticesData = null;
+            }
+        };
+        DeformVertices.prototype.isBonesUpdate = function () {
+            for (var _i = 0, _a = this.bones; _i < _a.length; _i++) {
+                var bone = _a[_i];
+                if (bone !== null && bone._childrenTransformDirty) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        return DeformVertices;
+    }(dragonBones.BaseObject));
+    dragonBones.DeformVertices = DeformVertices;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones_1) {
+    /**
+     * - Armature is the core of the skeleton animation system.
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Bone
+     * @see dragonBones.Slot
+     * @see dragonBones.Animation
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨架是骨骼动画系统的核心。
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Bone
+     * @see dragonBones.Slot
+     * @see dragonBones.Animation
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Armature = /** @class */ (function (_super) {
+        __extends(Armature, _super);
+        function Armature() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._bones = [];
+            _this._slots = [];
+            /**
+             * @internal
+             */
+            _this._constraints = [];
+            _this._actions = [];
+            _this._animation = null; // Initial value.
+            _this._proxy = null; // Initial value.
+            /**
+             * @internal
+             */
+            _this._replaceTextureAtlasData = null; // Initial value.
+            _this._clock = null; // Initial value.
+            return _this;
+        }
+        Armature.toString = function () {
+            return "[class dragonBones.Armature]";
+        };
+        Armature._onSortSlots = function (a, b) {
+            return a._zOrder > b._zOrder ? 1 : -1;
+        };
+        Armature.prototype._onClear = function () {
+            if (this._clock !== null) {
+                this._clock.remove(this);
+            }
+            for (var _i = 0, _a = this._bones; _i < _a.length; _i++) {
+                var bone = _a[_i];
+                bone.returnToPool();
+            }
+            for (var _b = 0, _c = this._slots; _b < _c.length; _b++) {
+                var slot = _c[_b];
+                slot.returnToPool();
+            }
+            for (var _d = 0, _e = this._constraints; _d < _e.length; _d++) {
+                var constraint = _e[_d];
+                constraint.returnToPool();
+            }
+            for (var _f = 0, _g = this._actions; _f < _g.length; _f++) {
+                var action = _g[_f];
+                action.returnToPool();
+            }
+            if (this._animation !== null) {
+                this._animation.returnToPool();
+            }
+            if (this._proxy !== null) {
+                this._proxy.dbClear();
+            }
+            if (this._replaceTextureAtlasData !== null) {
+                this._replaceTextureAtlasData.returnToPool();
+            }
+            this.inheritAnimation = true;
+            this.userData = null;
+            this._lockUpdate = false;
+            this._slotsDirty = true;
+            this._zOrderDirty = false;
+            this._flipX = false;
+            this._flipY = false;
+            this._cacheFrameIndex = -1;
+            this._bones.length = 0;
+            this._slots.length = 0;
+            this._constraints.length = 0;
+            this._actions.length = 0;
+            this._armatureData = null; //
+            this._animation = null; //
+            this._proxy = null; //
+            this._display = null;
+            this._replaceTextureAtlasData = null;
+            this._replacedTexture = null;
+            this._dragonBones = null; //
+            this._clock = null;
+            this._parent = null;
+        };
+        /**
+         * @internal
+         */
+        Armature.prototype._sortZOrder = function (slotIndices, offset) {
+            var slotDatas = this._armatureData.sortedSlots;
+            var isOriginal = slotIndices === null;
+            if (this._zOrderDirty || !isOriginal) {
+                for (var i = 0, l = slotDatas.length; i < l; ++i) {
+                    var slotIndex = isOriginal ? i : slotIndices[offset + i];
+                    if (slotIndex < 0 || slotIndex >= l) {
+                        continue;
+                    }
+                    var slotData = slotDatas[slotIndex];
+                    var slot = this.getSlot(slotData.name);
+                    if (slot !== null) {
+                        slot._setZorder(i);
+                    }
+                }
+                this._slotsDirty = true;
+                this._zOrderDirty = !isOriginal;
+            }
+        };
+        /**
+         * @internal
+         */
+        Armature.prototype._addBone = function (value) {
+            if (this._bones.indexOf(value) < 0) {
+                this._bones.push(value);
+            }
+        };
+        /**
+         * @internal
+         */
+        Armature.prototype._addSlot = function (value) {
+            if (this._slots.indexOf(value) < 0) {
+                this._slots.push(value);
+            }
+        };
+        /**
+         * @internal
+         */
+        Armature.prototype._addConstraint = function (value) {
+            if (this._constraints.indexOf(value) < 0) {
+                this._constraints.push(value);
+            }
+        };
+        /**
+         * @internal
+         */
+        Armature.prototype._bufferAction = function (action, append) {
+            if (this._actions.indexOf(action) < 0) {
+                if (append) {
+                    this._actions.push(action);
+                }
+                else {
+                    this._actions.unshift(action);
+                }
+            }
+        };
+        /**
+         * - Dispose the armature. (Return to the object pool)
+         * @example
+         * <pre>
+         *     removeChild(armature.display);
+         *     armature.dispose();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 释放骨架。 （回收到对象池）
+         * @example
+         * <pre>
+         *     removeChild(armature.display);
+         *     armature.dispose();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.dispose = function () {
+            if (this._armatureData !== null) {
+                this._lockUpdate = true;
+                this._dragonBones.bufferObject(this);
+            }
+        };
+        /**
+         * @internal
+         */
+        Armature.prototype.init = function (armatureData, proxy, display, dragonBones) {
+            if (this._armatureData !== null) {
+                return;
+            }
+            this._armatureData = armatureData;
+            this._animation = dragonBones_1.BaseObject.borrowObject(dragonBones_1.Animation);
+            this._proxy = proxy;
+            this._display = display;
+            this._dragonBones = dragonBones;
+            this._proxy.dbInit(this);
+            this._animation.init(this);
+            this._animation.animations = this._armatureData.animations;
+        };
+        /**
+         * @inheritDoc
+         */
+        Armature.prototype.advanceTime = function (passedTime) {
+            if (this._lockUpdate) {
+                return;
+            }
+            if (this._armatureData === null) {
+                console.warn("The armature has been disposed.");
+                return;
+            }
+            else if (this._armatureData.parent === null) {
+                console.warn("The armature data has been disposed.\nPlease make sure dispose armature before call factory.clear().");
+                return;
+            }
+            var prevCacheFrameIndex = this._cacheFrameIndex;
+            // Update animation.
+            this._animation.advanceTime(passedTime);
+            // Sort slots.
+            if (this._slotsDirty) {
+                this._slotsDirty = false;
+                this._slots.sort(Armature._onSortSlots);
+            }
+            // Update bones and slots.
+            if (this._cacheFrameIndex < 0 || this._cacheFrameIndex !== prevCacheFrameIndex) {
+                var i = 0, l = 0;
+                for (i = 0, l = this._bones.length; i < l; ++i) {
+                    this._bones[i].update(this._cacheFrameIndex);
+                }
+                for (i = 0, l = this._slots.length; i < l; ++i) {
+                    this._slots[i].update(this._cacheFrameIndex);
+                }
+            }
+            // Do actions.
+            if (this._actions.length > 0) {
+                this._lockUpdate = true;
+                for (var _i = 0, _a = this._actions; _i < _a.length; _i++) {
+                    var action = _a[_i];
+                    var actionData = action.actionData;
+                    if (actionData !== null) {
+                        if (actionData.type === 0 /* Play */) {
+                            if (action.slot !== null) {
+                                var childArmature = action.slot.childArmature;
+                                if (childArmature !== null) {
+                                    childArmature.animation.fadeIn(actionData.name);
+                                }
+                            }
+                            else if (action.bone !== null) {
+                                for (var _b = 0, _c = this.getSlots(); _b < _c.length; _b++) {
+                                    var slot = _c[_b];
+                                    if (slot.parent === action.bone) {
+                                        var childArmature = slot.childArmature;
+                                        if (childArmature !== null) {
+                                            childArmature.animation.fadeIn(actionData.name);
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                this._animation.fadeIn(actionData.name);
+                            }
+                        }
+                    }
+                    action.returnToPool();
+                }
+                this._actions.length = 0;
+                this._lockUpdate = false;
+            }
+            this._proxy.dbUpdate();
+        };
+        /**
+         * - Forces a specific bone or its owning slot to update the transform or display property in the next frame.
+         * @param boneName - The bone name. (If not set, all bones will be update)
+         * @param updateSlot - Whether to update the bone's slots. (Default: false)
+         * @see dragonBones.Bone#invalidUpdate()
+         * @see dragonBones.Slot#invalidUpdate()
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 强制特定骨骼或其拥有的插槽在下一帧更新变换或显示属性。
+         * @param boneName - 骨骼名称。 （如果未设置，将更新所有骨骼）
+         * @param updateSlot - 是否更新骨骼的插槽。 （默认: false）
+         * @see dragonBones.Bone#invalidUpdate()
+         * @see dragonBones.Slot#invalidUpdate()
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.invalidUpdate = function (boneName, updateSlot) {
+            if (boneName === void 0) { boneName = null; }
+            if (updateSlot === void 0) { updateSlot = false; }
+            if (boneName !== null && boneName.length > 0) {
+                var bone = this.getBone(boneName);
+                if (bone !== null) {
+                    bone.invalidUpdate();
+                    if (updateSlot) {
+                        for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                            var slot = _a[_i];
+                            if (slot.parent === bone) {
+                                slot.invalidUpdate();
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                for (var _b = 0, _c = this._bones; _b < _c.length; _b++) {
+                    var bone = _c[_b];
+                    bone.invalidUpdate();
+                }
+                if (updateSlot) {
+                    for (var _d = 0, _e = this._slots; _d < _e.length; _d++) {
+                        var slot = _e[_d];
+                        slot.invalidUpdate();
+                    }
+                }
+            }
+        };
+        /**
+         * - Check whether a specific point is inside a custom bounding box in a slot.
+         * The coordinate system of the point is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param x - The horizontal coordinate of the point.
+         * @param y - The vertical coordinate of the point.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定点是否在某个插槽的自定义边界框内。
+         * 点的坐标系为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param x - 点的水平坐标。
+         * @param y - 点的垂直坐标。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        Armature.prototype.containsPoint = function (x, y) {
+            for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                var slot = _a[_i];
+                if (slot.containsPoint(x, y)) {
+                    return slot;
+                }
+            }
+            return null;
+        };
+        /**
+         * - Check whether a specific segment intersects a custom bounding box for a slot in the armature.
+         * The coordinate system of the segment and intersection is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param xA - The horizontal coordinate of the beginning of the segment.
+         * @param yA - The vertical coordinate of the beginning of the segment.
+         * @param xB - The horizontal coordinate of the end point of the segment.
+         * @param yB - The vertical coordinate of the end point of the segment.
+         * @param intersectionPointA - The first intersection at which a line segment intersects the bounding box from the beginning to the end. (If not set, the intersection point will not calculated)
+         * @param intersectionPointB - The first intersection at which a line segment intersects the bounding box from the end to the beginning. (If not set, the intersection point will not calculated)
+         * @param normalRadians - The normal radians of the tangent of the intersection boundary box. [x: Normal radian of the first intersection tangent, y: Normal radian of the second intersection tangent] (If not set, the normal will not calculated)
+         * @returns The slot of the first custom bounding box where the segment intersects from the start point to the end point.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定线段是否与骨架的某个插槽的自定义边界框相交。
+         * 线段和交点的坐标系均为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param xA - 线段起点的水平坐标。
+         * @param yA - 线段起点的垂直坐标。
+         * @param xB - 线段终点的水平坐标。
+         * @param yB - 线段终点的垂直坐标。
+         * @param intersectionPointA - 线段从起点到终点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param intersectionPointB - 线段从终点到起点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param normalRadians - 交点边界框切线的法线弧度。 [x: 第一个交点切线的法线弧度, y: 第二个交点切线的法线弧度] （如果未设置，则不计算法线）
+         * @returns 线段从起点到终点相交的第一个自定义边界框的插槽。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        Armature.prototype.intersectsSegment = function (xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            var isV = xA === xB;
+            var dMin = 0.0;
+            var dMax = 0.0;
+            var intXA = 0.0;
+            var intYA = 0.0;
+            var intXB = 0.0;
+            var intYB = 0.0;
+            var intAN = 0.0;
+            var intBN = 0.0;
+            var intSlotA = null;
+            var intSlotB = null;
+            for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                var slot = _a[_i];
+                var intersectionCount = slot.intersectsSegment(xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians);
+                if (intersectionCount > 0) {
+                    if (intersectionPointA !== null || intersectionPointB !== null) {
+                        if (intersectionPointA !== null) {
+                            var d = isV ? intersectionPointA.y - yA : intersectionPointA.x - xA;
+                            if (d < 0.0) {
+                                d = -d;
+                            }
+                            if (intSlotA === null || d < dMin) {
+                                dMin = d;
+                                intXA = intersectionPointA.x;
+                                intYA = intersectionPointA.y;
+                                intSlotA = slot;
+                                if (normalRadians) {
+                                    intAN = normalRadians.x;
+                                }
+                            }
+                        }
+                        if (intersectionPointB !== null) {
+                            var d = intersectionPointB.x - xA;
+                            if (d < 0.0) {
+                                d = -d;
+                            }
+                            if (intSlotB === null || d > dMax) {
+                                dMax = d;
+                                intXB = intersectionPointB.x;
+                                intYB = intersectionPointB.y;
+                                intSlotB = slot;
+                                if (normalRadians !== null) {
+                                    intBN = normalRadians.y;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        intSlotA = slot;
+                        break;
+                    }
+                }
+            }
+            if (intSlotA !== null && intersectionPointA !== null) {
+                intersectionPointA.x = intXA;
+                intersectionPointA.y = intYA;
+                if (normalRadians !== null) {
+                    normalRadians.x = intAN;
+                }
+            }
+            if (intSlotB !== null && intersectionPointB !== null) {
+                intersectionPointB.x = intXB;
+                intersectionPointB.y = intYB;
+                if (normalRadians !== null) {
+                    normalRadians.y = intBN;
+                }
+            }
+            return intSlotA;
+        };
+        /**
+         * - Get a specific bone.
+         * @param name - The bone name.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨骼。
+         * @param name - 骨骼名称。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.getBone = function (name) {
+            for (var _i = 0, _a = this._bones; _i < _a.length; _i++) {
+                var bone = _a[_i];
+                if (bone.name === name) {
+                    return bone;
+                }
+            }
+            return null;
+        };
+        /**
+         * - Get a specific bone by the display.
+         * @param display - The display object.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 通过显示对象获取特定的骨骼。
+         * @param display - 显示对象。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.getBoneByDisplay = function (display) {
+            var slot = this.getSlotByDisplay(display);
+            return slot !== null ? slot.parent : null;
+        };
+        /**
+         * - Get a specific slot.
+         * @param name - The slot name.
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的插槽。
+         * @param name - 插槽名称。
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.getSlot = function (name) {
+            for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                var slot = _a[_i];
+                if (slot.name === name) {
+                    return slot;
+                }
+            }
+            return null;
+        };
+        /**
+         * - Get a specific slot by the display.
+         * @param display - The display object.
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 通过显示对象获取特定的插槽。
+         * @param display - 显示对象。
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.getSlotByDisplay = function (display) {
+            if (display !== null) {
+                for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                    var slot = _a[_i];
+                    if (slot.display === display) {
+                        return slot;
+                    }
+                }
+            }
+            return null;
+        };
+        /**
+         * - Get all bones.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取所有的骨骼。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.getBones = function () {
+            return this._bones;
+        };
+        /**
+         * - Get all slots.
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取所有的插槽。
+         * @see dragonBones.Slot
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Armature.prototype.getSlots = function () {
+            return this._slots;
+        };
+        Object.defineProperty(Armature.prototype, "flipX", {
+            /**
+             * - Whether to flip the armature horizontally.
+             * @version DragonBones 5.5
+             * @language en_US
+             */
+            /**
+             * - 是否将骨架水平翻转。
+             * @version DragonBones 5.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._flipX;
+            },
+            set: function (value) {
+                if (this._flipX === value) {
+                    return;
+                }
+                this._flipX = value;
+                this.invalidUpdate();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "flipY", {
+            /**
+             * - Whether to flip the armature vertically.
+             * @version DragonBones 5.5
+             * @language en_US
+             */
+            /**
+             * - 是否将骨架垂直翻转。
+             * @version DragonBones 5.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._flipY;
+            },
+            set: function (value) {
+                if (this._flipY === value) {
+                    return;
+                }
+                this._flipY = value;
+                this.invalidUpdate();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "cacheFrameRate", {
+            /**
+             * - The animation cache frame rate, which turns on the animation cache when the set value is greater than 0.
+             * There is a certain amount of memory overhead to improve performance by caching animation data in memory.
+             * The frame rate should not be set too high, usually with the frame rate of the animation is similar and lower than the program running frame rate.
+             * When the animation cache is turned on, some features will fail, such as the offset property of bone.
+             * @example
+             * <pre>
+             *     armature.cacheFrameRate = 24;
+             * </pre>
+             * @see dragonBones.DragonBonesData#frameRate
+             * @see dragonBones.ArmatureData#frameRate
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 动画缓存帧率，当设置的值大于 0 的时，将会开启动画缓存。
+             * 通过将动画数据缓存在内存中来提高运行性能，会有一定的内存开销。
+             * 帧率不宜设置的过高，通常跟动画的帧率相当且低于程序运行的帧率。
+             * 开启动画缓存后，某些功能将会失效，比如骨骼的 offset 属性等。
+             * @example
+             * <pre>
+             *     armature.cacheFrameRate = 24;
+             * </pre>
+             * @see dragonBones.DragonBonesData#frameRate
+             * @see dragonBones.ArmatureData#frameRate
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._armatureData.cacheFrameRate;
+            },
+            set: function (value) {
+                if (this._armatureData.cacheFrameRate !== value) {
+                    this._armatureData.cacheFrames(value);
+                    // Set child armature frameRate.
+                    for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                        var slot = _a[_i];
+                        var childArmature = slot.childArmature;
+                        if (childArmature !== null) {
+                            childArmature.cacheFrameRate = value;
+                        }
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "name", {
+            /**
+             * - The armature name.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 骨架名称。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._armatureData.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "armatureData", {
+            /**
+             * - The armature data.
+             * @see dragonBones.ArmatureData
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 骨架数据。
+             * @see dragonBones.ArmatureData
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._armatureData;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "animation", {
+            /**
+             * - The animation player.
+             * @see dragonBones.Animation
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 动画播放器。
+             * @see dragonBones.Animation
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._animation;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "proxy", {
+            /**
+             * @pivate
+             */
+            get: function () {
+                return this._proxy;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "eventDispatcher", {
+            /**
+             * - The EventDispatcher instance of the armature.
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 该骨架的 EventDispatcher 实例。
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._proxy;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "display", {
+            /**
+             * - The display container.
+             * The display of the slot is displayed as the parent.
+             * Depending on the rendering engine, the type will be different, usually the DisplayObjectContainer type.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 显示容器实例。
+             * 插槽的显示对象都会以此显示容器为父级。
+             * 根据渲染引擎的不同，类型会不同，通常是 DisplayObjectContainer 类型。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._display;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "replacedTexture", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this._replacedTexture;
+            },
+            set: function (value) {
+                if (this._replacedTexture === value) {
+                    return;
+                }
+                if (this._replaceTextureAtlasData !== null) {
+                    this._replaceTextureAtlasData.returnToPool();
+                    this._replaceTextureAtlasData = null;
+                }
+                this._replacedTexture = value;
+                for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                    var slot = _a[_i];
+                    slot.invalidUpdate();
+                    slot.update(-1);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "clock", {
+            /**
+             * @inheritDoc
+             */
+            get: function () {
+                return this._clock;
+            },
+            set: function (value) {
+                if (this._clock === value) {
+                    return;
+                }
+                if (this._clock !== null) {
+                    this._clock.remove(this);
+                }
+                this._clock = value;
+                if (this._clock) {
+                    this._clock.add(this);
+                }
+                // Update childArmature clock.
+                for (var _i = 0, _a = this._slots; _i < _a.length; _i++) {
+                    var slot = _a[_i];
+                    var childArmature = slot.childArmature;
+                    if (childArmature !== null) {
+                        childArmature.clock = this._clock;
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Armature.prototype, "parent", {
+            /**
+             * - Get the parent slot which the armature belongs to.
+             * @see dragonBones.Slot
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 该骨架所属的父插槽。
+             * @see dragonBones.Slot
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._parent;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @deprecated
+         * @private
+         */
+        Armature.prototype.replaceTexture = function (texture) {
+            this.replacedTexture = texture;
+        };
+        /**
+         * - Deprecated, please refer to {@link #eventDispatcher}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventDispatcher}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Armature.prototype.hasEventListener = function (type) {
+            console.warn("Deprecated.");
+            return this._proxy.hasDBEventListener(type);
+        };
+        /**
+         * - Deprecated, please refer to {@link #eventDispatcher}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventDispatcher}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Armature.prototype.addEventListener = function (type, listener, target) {
+            console.warn("Deprecated.");
+            this._proxy.addDBEventListener(type, listener, target);
+        };
+        /**
+         * - Deprecated, please refer to {@link #eventDispatcher}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #eventDispatcher}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Armature.prototype.removeEventListener = function (type, listener, target) {
+            console.warn("Deprecated.");
+            this._proxy.removeDBEventListener(type, listener, target);
+        };
+        /**
+         * - Deprecated, please refer to {@link #cacheFrameRate}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #cacheFrameRate}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Armature.prototype.enableAnimationCache = function (frameRate) {
+            console.warn("Deprecated.");
+            this.cacheFrameRate = frameRate;
+        };
+        /**
+         * - Deprecated, please refer to {@link #display}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #display}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Armature.prototype.getDisplay = function () {
+            return this._display;
+        };
+        return Armature;
+    }(dragonBones_1.BaseObject));
+    dragonBones_1.Armature = Armature;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The base class of the transform object.
+     * @see dragonBones.Transform
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 变换对象的基类。
+     * @see dragonBones.Transform
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    var TransformObject = /** @class */ (function (_super) {
+        __extends(TransformObject, _super);
+        function TransformObject() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * - A matrix relative to the armature coordinate system.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 相对于骨架坐标系的矩阵。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            _this.globalTransformMatrix = new dragonBones.Matrix();
+            /**
+             * - A transform relative to the armature coordinate system.
+             * @see #updateGlobalTransform()
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 相对于骨架坐标系的变换。
+             * @see #updateGlobalTransform()
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            _this.global = new dragonBones.Transform();
+            /**
+             * - The offset transform relative to the armature or the parent bone coordinate system.
+             * @see #dragonBones.Bone#invalidUpdate()
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 相对于骨架或父骨骼坐标系的偏移变换。
+             * @see #dragonBones.Bone#invalidUpdate()
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            _this.offset = new dragonBones.Transform();
+            return _this;
+        }
+        /**
+         */
+        TransformObject.prototype._onClear = function () {
+            this.globalTransformMatrix.identity();
+            this.global.identity();
+            this.offset.identity();
+            this.origin = null;
+            this.userData = null;
+            this._globalDirty = false;
+            this._armature = null; //
+        };
+        /**
+         * - For performance considerations, rotation or scale in the {@link #global} attribute of the bone or slot is not always properly accessible,
+         * some engines do not rely on these attributes to update rendering, such as Egret.
+         * The use of this method ensures that the access to the {@link #global} property is correctly rotation or scale.
+         * @example
+         * <pre>
+         *     bone.updateGlobalTransform();
+         *     let rotation = bone.global.rotation;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 出于性能的考虑，骨骼或插槽的 {@link #global} 属性中的旋转或缩放并不总是正确可访问的，有些引擎并不依赖这些属性更新渲染，比如 Egret。
+         * 使用此方法可以保证访问到 {@link #global} 属性中正确的旋转或缩放。
+         * @example
+         * <pre>
+         *     bone.updateGlobalTransform();
+         *     let rotation = bone.global.rotation;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        TransformObject.prototype.updateGlobalTransform = function () {
+            if (this._globalDirty) {
+                this._globalDirty = false;
+                this.global.fromMatrix(this.globalTransformMatrix);
+            }
+        };
+        Object.defineProperty(TransformObject.prototype, "armature", {
+            /**
+             * - The armature to which it belongs.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 所属的骨架。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._armature;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TransformObject._helpMatrix = new dragonBones.Matrix();
+        TransformObject._helpTransform = new dragonBones.Transform();
+        TransformObject._helpPoint = new dragonBones.Point();
+        return TransformObject;
+    }(dragonBones.BaseObject));
+    dragonBones.TransformObject = TransformObject;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - Bone is one of the most important logical units in the armature animation system,
+     * and is responsible for the realization of translate, rotation, scaling in the animations.
+     * A armature can contain multiple bones.
+     * @see dragonBones.BoneData
+     * @see dragonBones.Armature
+     * @see dragonBones.Slot
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 骨骼在骨骼动画体系中是最重要的逻辑单元之一，负责动画中的平移、旋转、缩放的实现。
+     * 一个骨架中可以包含多个骨骼。
+     * @see dragonBones.BoneData
+     * @see dragonBones.Armature
+     * @see dragonBones.Slot
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Bone = /** @class */ (function (_super) {
+        __extends(Bone, _super);
+        function Bone() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @internal
+             */
+            _this.animationPose = new dragonBones.Transform();
+            /**
+             * @internal
+             */
+            _this._blendState = new dragonBones.BlendState();
+            return _this;
+        }
+        Bone.toString = function () {
+            return "[class dragonBones.Bone]";
+        };
+        Bone.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.offsetMode = 1 /* Additive */;
+            this.animationPose.identity();
+            this._transformDirty = false;
+            this._childrenTransformDirty = false;
+            this._localDirty = true;
+            this._hasConstraint = false;
+            this._visible = true;
+            this._cachedFrameIndex = -1;
+            this._blendState.clear();
+            this._boneData = null; //
+            this._parent = null; //
+            this._cachedFrameIndices = null;
+        };
+        Bone.prototype._updateGlobalTransformMatrix = function (isCache) {
+            // For typescript.
+            var boneData = this._boneData;
+            var global = this.global;
+            var globalTransformMatrix = this.globalTransformMatrix;
+            var origin = this.origin;
+            var offset = this.offset;
+            var animationPose = this.animationPose;
+            var parent = this._parent; //
+            var flipX = this._armature.flipX;
+            var flipY = this._armature.flipY === dragonBones.DragonBones.yDown;
+            var inherit = parent !== null;
+            var rotation = 0.0;
+            if (this.offsetMode === 1 /* Additive */) {
+                if (origin !== null) {
+                    // global.copyFrom(this.origin).add(this.offset).add(this.animationPose);
+                    global.x = origin.x + offset.x + animationPose.x;
+                    global.y = origin.y + offset.y + animationPose.y;
+                    global.skew = origin.skew + offset.skew + animationPose.skew;
+                    global.rotation = origin.rotation + offset.rotation + animationPose.rotation;
+                    global.scaleX = origin.scaleX * offset.scaleX * animationPose.scaleX;
+                    global.scaleY = origin.scaleY * offset.scaleY * animationPose.scaleY;
+                }
+                else {
+                    global.copyFrom(offset).add(animationPose);
+                }
+            }
+            else if (this.offsetMode === 0 /* None */) {
+                if (origin !== null) {
+                    global.copyFrom(origin).add(animationPose);
+                }
+                else {
+                    global.copyFrom(animationPose);
+                }
+            }
+            else {
+                inherit = false;
+                global.copyFrom(offset);
+            }
+            if (inherit) {
+                var parentMatrix = parent._boneData.type === 0 /* Bone */ ? parent.globalTransformMatrix : parent._getGlobalTransformMatrix(global.x, global.y);
+                if (boneData.inheritScale) {
+                    if (!boneData.inheritRotation) {
+                        parent.updateGlobalTransform();
+                        if (flipX && flipY) {
+                            rotation = global.rotation - (parent.global.rotation + Math.PI);
+                        }
+                        else if (flipX) {
+                            rotation = global.rotation + parent.global.rotation + Math.PI;
+                        }
+                        else if (flipY) {
+                            rotation = global.rotation + parent.global.rotation;
+                        }
+                        else {
+                            rotation = global.rotation - parent.global.rotation;
+                        }
+                        global.rotation = rotation;
+                    }
+                    global.toMatrix(globalTransformMatrix);
+                    globalTransformMatrix.concat(parentMatrix);
+                    if (boneData.inheritTranslation) {
+                        global.x = globalTransformMatrix.tx;
+                        global.y = globalTransformMatrix.ty;
+                    }
+                    else {
+                        globalTransformMatrix.tx = global.x;
+                        globalTransformMatrix.ty = global.y;
+                    }
+                    if (isCache) {
+                        global.fromMatrix(globalTransformMatrix);
+                    }
+                    else {
+                        this._globalDirty = true;
+                    }
+                }
+                else {
+                    if (boneData.inheritTranslation) {
+                        var x = global.x;
+                        var y = global.y;
+                        global.x = parentMatrix.a * x + parentMatrix.c * y + parentMatrix.tx;
+                        global.y = parentMatrix.b * x + parentMatrix.d * y + parentMatrix.ty;
+                    }
+                    else {
+                        if (flipX) {
+                            global.x = -global.x;
+                        }
+                        if (flipY) {
+                            global.y = -global.y;
+                        }
+                    }
+                    if (boneData.inheritRotation) {
+                        parent.updateGlobalTransform();
+                        if (parent.global.scaleX < 0.0) {
+                            rotation = global.rotation + parent.global.rotation + Math.PI;
+                        }
+                        else {
+                            rotation = global.rotation + parent.global.rotation;
+                        }
+                        if (parentMatrix.a * parentMatrix.d - parentMatrix.b * parentMatrix.c < 0.0) {
+                            rotation -= global.rotation * 2.0;
+                            if (flipX !== flipY || boneData.inheritReflection) {
+                                global.skew += Math.PI;
+                            }
+                        }
+                        global.rotation = rotation;
+                    }
+                    else if (flipX || flipY) {
+                        if (flipX && flipY) {
+                            rotation = global.rotation + Math.PI;
+                        }
+                        else {
+                            if (flipX) {
+                                rotation = Math.PI - global.rotation;
+                            }
+                            else {
+                                rotation = -global.rotation;
+                            }
+                            global.skew += Math.PI;
+                        }
+                        global.rotation = rotation;
+                    }
+                    global.toMatrix(globalTransformMatrix);
+                }
+            }
+            else {
+                if (flipX || flipY) {
+                    if (flipX) {
+                        global.x = -global.x;
+                    }
+                    if (flipY) {
+                        global.y = -global.y;
+                    }
+                    if (flipX && flipY) {
+                        rotation = global.rotation + Math.PI;
+                    }
+                    else {
+                        if (flipX) {
+                            rotation = Math.PI - global.rotation;
+                        }
+                        else {
+                            rotation = -global.rotation;
+                        }
+                        global.skew += Math.PI;
+                    }
+                    global.rotation = rotation;
+                }
+                global.toMatrix(globalTransformMatrix);
+            }
+        };
+        /**
+         * @internal
+         */
+        Bone.prototype.init = function (boneData, armatureValue) {
+            if (this._boneData !== null) {
+                return;
+            }
+            this._boneData = boneData;
+            this._armature = armatureValue;
+            if (this._boneData.parent !== null) {
+                this._parent = this._armature.getBone(this._boneData.parent.name);
+            }
+            this._armature._addBone(this);
+            //
+            this.origin = this._boneData.transform;
+        };
+        /**
+         * @internal
+         */
+        Bone.prototype.update = function (cacheFrameIndex) {
+            this._blendState.dirty = false;
+            if (cacheFrameIndex >= 0 && this._cachedFrameIndices !== null) {
+                var cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex];
+                if (cachedFrameIndex >= 0 && this._cachedFrameIndex === cachedFrameIndex) {
+                    this._transformDirty = false;
+                }
+                else if (cachedFrameIndex >= 0) {
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = cachedFrameIndex;
+                }
+                else {
+                    if (this._hasConstraint) {
+                        for (var _i = 0, _a = this._armature._constraints; _i < _a.length; _i++) {
+                            var constraint = _a[_i];
+                            if (constraint._root === this) {
+                                constraint.update();
+                            }
+                        }
+                    }
+                    if (this._transformDirty ||
+                        (this._parent !== null && this._parent._childrenTransformDirty)) {
+                        this._transformDirty = true;
+                        this._cachedFrameIndex = -1;
+                    }
+                    else if (this._cachedFrameIndex >= 0) {
+                        this._transformDirty = false;
+                        this._cachedFrameIndices[cacheFrameIndex] = this._cachedFrameIndex;
+                    }
+                    else {
+                        this._transformDirty = true;
+                        this._cachedFrameIndex = -1;
+                    }
+                }
+            }
+            else {
+                if (this._hasConstraint) {
+                    for (var _b = 0, _c = this._armature._constraints; _b < _c.length; _b++) {
+                        var constraint = _c[_b];
+                        if (constraint._root === this) {
+                            constraint.update();
+                        }
+                    }
+                }
+                if (this._transformDirty || (this._parent !== null && this._parent._childrenTransformDirty)) {
+                    cacheFrameIndex = -1;
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = -1;
+                }
+            }
+            if (this._transformDirty) {
+                this._transformDirty = false;
+                this._childrenTransformDirty = true;
+                //
+                if (this._cachedFrameIndex < 0) {
+                    var isCache = cacheFrameIndex >= 0;
+                    if (this._localDirty) {
+                        this._updateGlobalTransformMatrix(isCache);
+                    }
+                    if (isCache && this._cachedFrameIndices !== null) {
+                        this._cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex] = this._armature._armatureData.setCacheFrame(this.globalTransformMatrix, this.global);
+                    }
+                }
+                else {
+                    this._armature._armatureData.getCacheFrame(this.globalTransformMatrix, this.global, this._cachedFrameIndex);
+                }
+                //
+            }
+            else if (this._childrenTransformDirty) {
+                this._childrenTransformDirty = false;
+            }
+            this._localDirty = true;
+        };
+        /**
+         * @internal
+         */
+        Bone.prototype.updateByConstraint = function () {
+            if (this._localDirty) {
+                this._localDirty = false;
+                if (this._transformDirty || (this._parent !== null && this._parent._childrenTransformDirty)) {
+                    this._updateGlobalTransformMatrix(true);
+                }
+                this._transformDirty = true;
+            }
+        };
+        /**
+         * - Forces the bone to update the transform in the next frame.
+         * When the bone is not animated or its animation state is finished, the bone will not continue to update,
+         * and when the skeleton must be updated for some reason, the method needs to be called explicitly.
+         * @example
+         * <pre>
+         *     let bone = armature.getBone("arm");
+         *     bone.offset.scaleX = 2.0;
+         *     bone.invalidUpdate();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 强制骨骼在下一帧更新变换。
+         * 当该骨骼没有动画状态或其动画状态播放完成时，骨骼将不在继续更新，而此时由于某些原因必须更新骨骼时，则需要显式调用该方法。
+         * @example
+         * <pre>
+         *     let bone = armature.getBone("arm");
+         *     bone.offset.scaleX = 2.0;
+         *     bone.invalidUpdate();
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Bone.prototype.invalidUpdate = function () {
+            this._transformDirty = true;
+        };
+        /**
+         * - Check whether the bone contains a specific bone.
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查该骨骼是否包含特定的骨骼。
+         * @see dragonBones.Bone
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Bone.prototype.contains = function (value) {
+            if (value === this) {
+                return false;
+            }
+            var ancestor = value;
+            while (ancestor !== this && ancestor !== null) {
+                ancestor = ancestor.parent;
+            }
+            return ancestor === this;
+        };
+        Object.defineProperty(Bone.prototype, "boneData", {
+            /**
+             * - The bone data.
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 骨骼数据。
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._boneData;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Bone.prototype, "visible", {
+            /**
+             * - The visible of all slots in the bone.
+             * @default true
+             * @see dragonBones.Slot#visible
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 此骨骼所有插槽的可见。
+             * @default true
+             * @see dragonBones.Slot#visible
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._visible;
+            },
+            set: function (value) {
+                if (this._visible === value) {
+                    return;
+                }
+                this._visible = value;
+                for (var _i = 0, _a = this._armature.getSlots(); _i < _a.length; _i++) {
+                    var slot = _a[_i];
+                    if (slot.parent === this) {
+                        slot._updateVisible();
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Bone.prototype, "name", {
+            /**
+             * - The bone name.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 骨骼名称。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._boneData.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Bone.prototype, "parent", {
+            /**
+             * - The parent bone to which it belongs.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 所属的父骨骼。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._parent;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link dragonBones.Armature#getBones()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.Armature#getBones()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Bone.prototype.getBones = function () {
+            console.warn("Deprecated.");
+            var bones = new Array();
+            for (var _i = 0, _a = this._armature.getBones(); _i < _a.length; _i++) {
+                var bone = _a[_i];
+                if (bone.parent === this) {
+                    bones.push(bone);
+                }
+            }
+            return bones;
+        };
+        /**
+         * - Deprecated, please refer to {@link dragonBones.Armature#getSlots()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.Armature#getSlots()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Bone.prototype.getSlots = function () {
+            console.warn("Deprecated.");
+            var slots = new Array();
+            for (var _i = 0, _a = this._armature.getSlots(); _i < _a.length; _i++) {
+                var slot = _a[_i];
+                if (slot.parent === this) {
+                    slots.push(slot);
+                }
+            }
+            return slots;
+        };
+        Object.defineProperty(Bone.prototype, "slot", {
+            /**
+             * - Deprecated, please refer to {@link dragonBones.Armature#getSlot()}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link dragonBones.Armature#getSlot()}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                console.warn("Deprecated.");
+                for (var _i = 0, _a = this._armature.getSlots(); _i < _a.length; _i++) {
+                    var slot = _a[_i];
+                    if (slot.parent === this) {
+                        return slot;
+                    }
+                }
+                return null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return Bone;
+    }(dragonBones.TransformObject));
+    dragonBones.Bone = Bone;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var Surface = /** @class */ (function (_super) {
+        __extends(Surface, _super);
+        function Surface() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._vertices = [];
+            _this._deformVertices = [];
+            /**
+             * - x1, y1, x2, y2, x3, y3, x4, y4, d1X, d1Y, d2X, d2Y
+             */
+            _this._hullCache = [];
+            /**
+             * - Inside [flag, a, b, c, d, tx, ty], Outside [flag, a, b, c, d, tx, ty]
+             */
+            _this._matrixCahce = [];
+            return _this;
+        }
+        Surface.toString = function () {
+            return "[class dragonBones.Surface]";
+        };
+        Surface.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this._dX = 0.0;
+            this._dY = 0.0;
+            this._k = 0.0;
+            this._kX = 0.0;
+            this._kY = 0.0;
+            this._vertices.length = 0;
+            this._deformVertices.length = 0;
+            this._matrixCahce.length = 0;
+            this._hullCache.length = 0;
+        };
+        Surface.prototype._getAffineTransform = function (x, y, lX, lY, aX, aY, bX, bY, cX, cY, transform, matrix, isDown) {
+            var dabX = bX - aX;
+            var dabY = bY - aY;
+            var dacX = cX - aX;
+            var dacY = cY - aY;
+            transform.rotation = Math.atan2(dabY, dabX);
+            transform.skew = Math.atan2(dacY, dacX) - Math.PI * 0.5 - transform.rotation;
+            if (isDown) {
+                transform.rotation += Math.PI;
+            }
+            transform.scaleX = Math.sqrt(dabX * dabX + dabY * dabY) / lX;
+            transform.scaleY = Math.sqrt(dacX * dacX + dacY * dacY) / lY;
+            transform.toMatrix(matrix);
+            transform.x = matrix.tx = aX - (matrix.a * x + matrix.c * y);
+            transform.y = matrix.ty = aY - (matrix.b * x + matrix.d * y);
+        };
+        Surface.prototype._updateVertices = function () {
+            var originalVertices = this._boneData.vertices;
+            var vertices = this._vertices;
+            var animationVertices = this._deformVertices;
+            if (this._parent !== null) {
+                if (this._parent._boneData.type === 1 /* Surface */) {
+                    for (var i = 0, l = originalVertices.length; i < l; i += 2) {
+                        var x = originalVertices[i] + animationVertices[i];
+                        var y = originalVertices[i + 1] + animationVertices[i];
+                        var matrix = this._parent._getGlobalTransformMatrix(x, y);
+                        //
+                        vertices[i] = matrix.a * x + matrix.c * y + matrix.tx;
+                        vertices[i + 1] = matrix.b * x + matrix.d * y + matrix.ty;
+                    }
+                }
+                else {
+                    var parentMatrix = this._parent.globalTransformMatrix;
+                    for (var i = 0, l = originalVertices.length; i < l; i += 2) {
+                        var x = originalVertices[i] + animationVertices[i];
+                        var y = originalVertices[i + 1] + animationVertices[i + 1];
+                        //
+                        vertices[i] = parentMatrix.a * x + parentMatrix.c * y + parentMatrix.tx;
+                        vertices[i + 1] = parentMatrix.b * x + parentMatrix.d * y + parentMatrix.ty;
+                    }
+                }
+            }
+            else {
+                for (var i = 0, l = originalVertices.length; i < l; i += 2) {
+                    vertices[i] = originalVertices[i] + animationVertices[i];
+                    vertices[i + 1] = originalVertices[i + 1] + animationVertices[i + 1];
+                }
+            }
+        };
+        Surface.prototype._updateGlobalTransformMatrix = function (isCache) {
+            // tslint:disable-next-line:no-unused-expression
+            isCache;
+            var segmentXD = this._boneData.segmentX * 2;
+            var lastIndex = this._vertices.length - 2;
+            var lA = 200.0;
+            //
+            var raX = this._vertices[0];
+            var raY = this._vertices[1];
+            var rbX = this._vertices[segmentXD];
+            var rbY = this._vertices[segmentXD + 1];
+            var rcX = this._vertices[lastIndex];
+            var rcY = this._vertices[lastIndex + 1];
+            var rdX = this._vertices[lastIndex - segmentXD];
+            var rdY = this._vertices[lastIndex - segmentXD + 1];
+            //
+            var dacX = raX + (rcX - raX) * 0.5;
+            var dacY = raY + (rcY - raY) * 0.5;
+            var dbdX = rbX + (rdX - rbX) * 0.5;
+            var dbdY = rbY + (rdY - rbY) * 0.5;
+            var aX = dacX + (dbdX - dacX) * 0.5;
+            var aY = dacY + (dbdY - dacY) * 0.5;
+            var bX = rbX + (rcX - rbX) * 0.5;
+            var bY = rbY + (rcY - rbY) * 0.5;
+            var cX = rdX + (rcX - rdX) * 0.5;
+            var cY = rdY + (rcY - rdY) * 0.5;
+            //
+            this._globalDirty = false;
+            this._getAffineTransform(0.0, 0.0, lA, lA, aX, aY, bX, bY, cX, cY, this.global, this.globalTransformMatrix, false);
+        };
+        Surface.prototype._getGlobalTransformMatrix = function (x, y) {
+            var lB = 1000.0;
+            if (x < -lB || lB < x || y < -lB || lB < y) {
+                return this.globalTransformMatrix;
+            }
+            var isDown = false;
+            var lA = 200.0;
+            var surfaceData = this._boneData;
+            var segmentX = surfaceData.segmentX;
+            var segmentY = surfaceData.segmentY;
+            var segmentXD = surfaceData.segmentX * 2;
+            var dX = this._dX;
+            var dY = this._dY;
+            var indexX = Math.floor((x + lA) / dX); // -1 ~ segmentX - 1
+            var indexY = Math.floor((y + lA) / dY); // -1 ~ segmentY - 1
+            var matrixIndex = 0;
+            var pX = indexX * dX - lA;
+            var pY = indexY * dY - lA;
+            var matrices = this._matrixCahce;
+            var helpMatrix = Surface._helpMatrix;
+            if (x < -lA) {
+                if (y < -lA || y >= lA) {
+                    return this.globalTransformMatrix;
+                }
+                // Left.
+                isDown = y > this._kX * (x + lA) + pY;
+                matrixIndex = ((segmentX * (segmentY + 1) + segmentX * 2 + segmentY + indexY) * 2 + (isDown ? 1 : 0)) * 7;
+                if (this._matrixCahce[matrixIndex] > 0.0) {
+                    helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+                }
+                else {
+                    var vertexIndex = indexY * (segmentXD + 2);
+                    var ddX = this._hullCache[4];
+                    var ddY = this._hullCache[5];
+                    var sX = this._hullCache[2] - (segmentY - indexY) * ddX;
+                    var sY = this._hullCache[3] - (segmentY - indexY) * ddY;
+                    var vertices = this._vertices;
+                    if (isDown) {
+                        this._getAffineTransform(-lA, pY + dY, lB - lA, dY, vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], sX + ddX, sY + ddY, vertices[vertexIndex], vertices[vertexIndex + 1], Surface._helpTransform, helpMatrix, true);
+                    }
+                    else {
+                        this._getAffineTransform(-lB, pY, lB - lA, dY, sX, sY, vertices[vertexIndex], vertices[vertexIndex + 1], sX + ddX, sY + ddY, Surface._helpTransform, helpMatrix, false);
+                    }
+                    matrices[matrixIndex] = 1.0;
+                    matrices[matrixIndex + 1] = helpMatrix.a;
+                    matrices[matrixIndex + 2] = helpMatrix.b;
+                    matrices[matrixIndex + 3] = helpMatrix.c;
+                    matrices[matrixIndex + 4] = helpMatrix.d;
+                    matrices[matrixIndex + 5] = helpMatrix.tx;
+                    matrices[matrixIndex + 6] = helpMatrix.ty;
+                }
+            }
+            else if (x >= lA) {
+                if (y < -lA || y >= lA) {
+                    return this.globalTransformMatrix;
+                }
+                // Right.
+                isDown = y > this._kX * (x - lB) + pY;
+                matrixIndex = ((segmentX * (segmentY + 1) + segmentX + indexY) * 2 + (isDown ? 1 : 0)) * 7;
+                if (this._matrixCahce[matrixIndex] > 0.0) {
+                    helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+                }
+                else {
+                    var vertexIndex = (indexY + 1) * (segmentXD + 2) - 2;
+                    var ddX = this._hullCache[4];
+                    var ddY = this._hullCache[5];
+                    var sX = this._hullCache[0] + indexY * ddX;
+                    var sY = this._hullCache[1] + indexY * ddY;
+                    var vertices = this._vertices;
+                    if (isDown) {
+                        this._getAffineTransform(lB, pY + dY, lB - lA, dY, sX + ddX, sY + ddY, vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], sX, sY, Surface._helpTransform, helpMatrix, true);
+                    }
+                    else {
+                        this._getAffineTransform(lA, pY, lB - lA, dY, vertices[vertexIndex], vertices[vertexIndex + 1], sX, sY, vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], Surface._helpTransform, helpMatrix, false);
+                    }
+                    matrices[matrixIndex] = 1.0;
+                    matrices[matrixIndex + 1] = helpMatrix.a;
+                    matrices[matrixIndex + 2] = helpMatrix.b;
+                    matrices[matrixIndex + 3] = helpMatrix.c;
+                    matrices[matrixIndex + 4] = helpMatrix.d;
+                    matrices[matrixIndex + 5] = helpMatrix.tx;
+                    matrices[matrixIndex + 6] = helpMatrix.ty;
+                }
+            }
+            else if (y < -lA) {
+                if (x < -lA || x >= lA) {
+                    return this.globalTransformMatrix;
+                }
+                // Up.
+                isDown = y > this._kY * (x - pX - dX) - lB;
+                matrixIndex = (segmentX * (segmentY + 1) + indexX * 2 + (isDown ? 1 : 0)) * 7;
+                if (this._matrixCahce[matrixIndex] > 0.0) {
+                    helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+                }
+                else {
+                    var vertexIndex = indexX * 2;
+                    var ddX = this._hullCache[10];
+                    var ddY = this._hullCache[11];
+                    var sX = this._hullCache[8] + indexX * ddX;
+                    var sY = this._hullCache[9] + indexX * ddY;
+                    var vertices = this._vertices;
+                    if (isDown) {
+                        this._getAffineTransform(pX + dX, -lA, dX, lB - lA, vertices[vertexIndex + 2], vertices[vertexIndex + 3], vertices[vertexIndex], vertices[vertexIndex + 1], sX + ddX, sY + ddY, Surface._helpTransform, helpMatrix, true);
+                    }
+                    else {
+                        this._getAffineTransform(pX, -lB, dX, lB - lA, sX, sY, sX + ddX, sY + ddY, vertices[vertexIndex], vertices[vertexIndex + 1], Surface._helpTransform, helpMatrix, false);
+                    }
+                    matrices[matrixIndex] = 1.0;
+                    matrices[matrixIndex + 1] = helpMatrix.a;
+                    matrices[matrixIndex + 2] = helpMatrix.b;
+                    matrices[matrixIndex + 3] = helpMatrix.c;
+                    matrices[matrixIndex + 4] = helpMatrix.d;
+                    matrices[matrixIndex + 5] = helpMatrix.tx;
+                    matrices[matrixIndex + 6] = helpMatrix.ty;
+                }
+            }
+            else if (y >= lA) {
+                if (x < -lA || x >= lA) {
+                    return this.globalTransformMatrix;
+                }
+                // Down
+                isDown = y > this._kY * (x - pX - dX) + lA;
+                matrixIndex = ((segmentX * (segmentY + 1) + segmentX + segmentY + indexY) * 2 + (isDown ? 1 : 0)) * 7;
+                if (this._matrixCahce[matrixIndex] > 0.0) {
+                    helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+                }
+                else {
+                    var vertexIndex = segmentY * (segmentXD + 2) + indexX * 2;
+                    var ddX = this._hullCache[10];
+                    var ddY = this._hullCache[11];
+                    var sX = this._hullCache[6] - (segmentX - indexX) * ddX;
+                    var sY = this._hullCache[7] - (segmentX - indexX) * ddY;
+                    var vertices = this._vertices;
+                    if (isDown) {
+                        this._getAffineTransform(pX + dX, lB, dX, lB - lA, sX + ddX, sY + ddY, sX, sY, vertices[vertexIndex + 2], vertices[vertexIndex + 3], Surface._helpTransform, helpMatrix, true);
+                    }
+                    else {
+                        this._getAffineTransform(pX, lA, dX, lB - lA, vertices[vertexIndex], vertices[vertexIndex + 1], vertices[vertexIndex + 2], vertices[vertexIndex + 3], sX, sY, Surface._helpTransform, helpMatrix, false);
+                    }
+                    matrices[matrixIndex] = 1.0;
+                    matrices[matrixIndex + 1] = helpMatrix.a;
+                    matrices[matrixIndex + 2] = helpMatrix.b;
+                    matrices[matrixIndex + 3] = helpMatrix.c;
+                    matrices[matrixIndex + 4] = helpMatrix.d;
+                    matrices[matrixIndex + 5] = helpMatrix.tx;
+                    matrices[matrixIndex + 6] = helpMatrix.ty;
+                }
+            }
+            else {
+                isDown = y > this._k * (x - pX - dX) + pY;
+                matrixIndex = ((segmentX * indexY + indexX) * 2 + (isDown ? 1 : 0)) * 7;
+                if (this._matrixCahce[matrixIndex] > 0.0) {
+                    helpMatrix.copyFromArray(matrices, matrixIndex + 1);
+                }
+                else {
+                    var vertexIndex = indexX * 2 + indexY * (segmentXD + 2);
+                    var vertices = this._vertices;
+                    if (isDown) {
+                        this._getAffineTransform(pX + dX, pY + dY, dX, dY, vertices[vertexIndex + segmentXD + 4], vertices[vertexIndex + segmentXD + 5], vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], vertices[vertexIndex + 2], vertices[vertexIndex + 3], Surface._helpTransform, helpMatrix, true);
+                    }
+                    else {
+                        this._getAffineTransform(pX, pY, dX, dY, vertices[vertexIndex], vertices[vertexIndex + 1], vertices[vertexIndex + 2], vertices[vertexIndex + 3], vertices[vertexIndex + segmentXD + 2], vertices[vertexIndex + segmentXD + 3], Surface._helpTransform, helpMatrix, false);
+                    }
+                    matrices[matrixIndex] = 1.0;
+                    matrices[matrixIndex + 1] = helpMatrix.a;
+                    matrices[matrixIndex + 2] = helpMatrix.b;
+                    matrices[matrixIndex + 3] = helpMatrix.c;
+                    matrices[matrixIndex + 4] = helpMatrix.d;
+                    matrices[matrixIndex + 5] = helpMatrix.tx;
+                    matrices[matrixIndex + 6] = helpMatrix.ty;
+                }
+            }
+            return helpMatrix;
+        };
+        /**
+         * @internal
+         * @private
+         */
+        Surface.prototype.init = function (surfaceData, armatureValue) {
+            if (this._boneData !== null) {
+                return;
+            }
+            _super.prototype.init.call(this, surfaceData, armatureValue);
+            var segmentX = surfaceData.segmentX;
+            var segmentY = surfaceData.segmentY;
+            var vertexCount = surfaceData.vertices.length;
+            var lB = 1000.0;
+            var lA = 200.0;
+            //
+            this._dX = lA * 2.0 / segmentX;
+            this._dY = lA * 2.0 / segmentY;
+            this._k = -this._dY / this._dX;
+            this._kX = -this._dY / (lB - lA);
+            this._kY = -(lB - lA) / this._dX;
+            this._vertices.length = vertexCount;
+            this._deformVertices.length = vertexCount;
+            this._matrixCahce.length = (segmentX * segmentY + segmentX * 2 + segmentY * 2) * 2 * 7;
+            this._hullCache.length = 10;
+            for (var i = 0; i < vertexCount; ++i) {
+                this._deformVertices[i] = 0.0;
+            }
+        };
+        /**
+         * @internal
+         */
+        Surface.prototype.update = function (cacheFrameIndex) {
+            this._blendState.dirty = false;
+            if (cacheFrameIndex >= 0 && this._cachedFrameIndices !== null) {
+                var cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex];
+                if (cachedFrameIndex >= 0 && this._cachedFrameIndex === cachedFrameIndex) {
+                    this._transformDirty = false;
+                }
+                else if (cachedFrameIndex >= 0) {
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = cachedFrameIndex;
+                }
+                else {
+                    if (this._hasConstraint) {
+                        for (var _i = 0, _a = this._armature._constraints; _i < _a.length; _i++) {
+                            var constraint = _a[_i];
+                            if (constraint._root === this) {
+                                constraint.update();
+                            }
+                        }
+                    }
+                    if (this._transformDirty ||
+                        (this._parent !== null && this._parent._childrenTransformDirty)) {
+                        this._transformDirty = true;
+                        this._cachedFrameIndex = -1;
+                    }
+                    else if (this._cachedFrameIndex >= 0) {
+                        this._transformDirty = false;
+                        this._cachedFrameIndices[cacheFrameIndex] = this._cachedFrameIndex;
+                    }
+                    else {
+                        this._transformDirty = true;
+                        this._cachedFrameIndex = -1;
+                    }
+                }
+            }
+            else {
+                if (this._hasConstraint) {
+                    for (var _b = 0, _c = this._armature._constraints; _b < _c.length; _b++) {
+                        var constraint = _c[_b];
+                        if (constraint._root === this) {
+                            constraint.update();
+                        }
+                    }
+                }
+                if (this._transformDirty || (this._parent !== null && this._parent._childrenTransformDirty)) {
+                    cacheFrameIndex = -1;
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = -1;
+                }
+            }
+            if (this._transformDirty) {
+                this._transformDirty = false;
+                this._childrenTransformDirty = true;
+                //
+                for (var i = 0, l = this._matrixCahce.length; i < l; i += 7) {
+                    this._matrixCahce[i] = -1.0;
+                }
+                //
+                this._updateVertices();
+                //
+                if (this._cachedFrameIndex < 0) {
+                    var isCache = cacheFrameIndex >= 0;
+                    if (this._localDirty) {
+                        this._updateGlobalTransformMatrix(isCache);
+                    }
+                    if (isCache && this._cachedFrameIndices !== null) {
+                        this._cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex] = this._armature._armatureData.setCacheFrame(this.globalTransformMatrix, this.global);
+                    }
+                }
+                else {
+                    this._armature._armatureData.getCacheFrame(this.globalTransformMatrix, this.global, this._cachedFrameIndex);
+                }
+                // Update hull vertices.
+                var lB = 1000.0;
+                var lA = 200.0;
+                var ddX = 2 * this.global.x;
+                var ddY = 2 * this.global.y;
+                //
+                var helpPoint = Surface._helpPoint;
+                this.globalTransformMatrix.transformPoint(lB, -lA, helpPoint);
+                this._hullCache[0] = helpPoint.x;
+                this._hullCache[1] = helpPoint.y;
+                this._hullCache[2] = ddX - helpPoint.x;
+                this._hullCache[3] = ddY - helpPoint.y;
+                this.globalTransformMatrix.transformPoint(0.0, this._dY, helpPoint, true);
+                this._hullCache[4] = helpPoint.x;
+                this._hullCache[5] = helpPoint.y;
+                //
+                this.globalTransformMatrix.transformPoint(lA, lB, helpPoint);
+                this._hullCache[6] = helpPoint.x;
+                this._hullCache[7] = helpPoint.y;
+                this._hullCache[8] = ddX - helpPoint.x;
+                this._hullCache[9] = ddY - helpPoint.y;
+                this.globalTransformMatrix.transformPoint(this._dX, 0.0, helpPoint, true);
+                this._hullCache[10] = helpPoint.x;
+                this._hullCache[11] = helpPoint.y;
+            }
+            else if (this._childrenTransformDirty) {
+                this._childrenTransformDirty = false;
+            }
+            this._localDirty = true;
+        };
+        return Surface;
+    }(dragonBones.Bone));
+    dragonBones.Surface = Surface;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The slot attached to the armature, controls the display status and properties of the display object.
+     * A bone can contain multiple slots.
+     * A slot can contain multiple display objects, displaying only one of the display objects at a time,
+     * but you can toggle the display object into frame animation while the animation is playing.
+     * The display object can be a normal texture, or it can be a display of a child armature, a grid display object,
+     * and a custom other display object.
+     * @see dragonBones.Armature
+     * @see dragonBones.Bone
+     * @see dragonBones.SlotData
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 插槽附着在骨骼上，控制显示对象的显示状态和属性。
+     * 一个骨骼上可以包含多个插槽。
+     * 一个插槽中可以包含多个显示对象，同一时间只能显示其中的一个显示对象，但可以在动画播放的过程中切换显示对象实现帧动画。
+     * 显示对象可以是普通的图片纹理，也可以是子骨架的显示容器，网格显示对象，还可以是自定义的其他显示对象。
+     * @see dragonBones.Armature
+     * @see dragonBones.Bone
+     * @see dragonBones.SlotData
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Slot = /** @class */ (function (_super) {
+        __extends(Slot, _super);
+        function Slot() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._localMatrix = new dragonBones.Matrix();
+            /**
+             * @internal
+             */
+            _this._colorTransform = new dragonBones.ColorTransform();
+            _this._displayDatas = [];
+            _this._displayList = [];
+            /**
+             * @internal
+             */
+            _this._deformVertices = null;
+            _this._rawDisplay = null; // Initial value.
+            _this._meshDisplay = null; // Initial value.
+            return _this;
+        }
+        Slot.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            var disposeDisplayList = [];
+            for (var _i = 0, _a = this._displayList; _i < _a.length; _i++) {
+                var eachDisplay = _a[_i];
+                if (eachDisplay !== null && eachDisplay !== this._rawDisplay && eachDisplay !== this._meshDisplay &&
+                    disposeDisplayList.indexOf(eachDisplay) < 0) {
+                    disposeDisplayList.push(eachDisplay);
+                }
+            }
+            for (var _b = 0, disposeDisplayList_1 = disposeDisplayList; _b < disposeDisplayList_1.length; _b++) {
+                var eachDisplay = disposeDisplayList_1[_b];
+                if (eachDisplay instanceof dragonBones.Armature) {
+                    eachDisplay.dispose();
+                }
+                else {
+                    this._disposeDisplay(eachDisplay, true);
+                }
+            }
+            if (this._deformVertices !== null) {
+                this._deformVertices.returnToPool();
+            }
+            if (this._meshDisplay !== null && this._meshDisplay !== this._rawDisplay) {
+                this._disposeDisplay(this._meshDisplay, false);
+            }
+            if (this._rawDisplay !== null) {
+                this._disposeDisplay(this._rawDisplay, false);
+            }
+            this.displayController = null;
+            this._displayDirty = false;
+            this._zOrderDirty = false;
+            this._blendModeDirty = false;
+            this._colorDirty = false;
+            this._transformDirty = false;
+            this._visible = true;
+            this._blendMode = 0 /* Normal */;
+            this._displayIndex = -1;
+            this._animationDisplayIndex = -1;
+            this._zOrder = 0;
+            this._cachedFrameIndex = -1;
+            this._pivotX = 0.0;
+            this._pivotY = 0.0;
+            this._localMatrix.identity();
+            this._colorTransform.identity();
+            this._displayList.length = 0;
+            this._displayDatas.length = 0;
+            this._slotData = null; //
+            this._rawDisplayDatas = null;
+            this._displayData = null;
+            this._boundingBoxData = null;
+            this._textureData = null;
+            this._deformVertices = null;
+            this._rawDisplay = null;
+            this._meshDisplay = null;
+            this._display = null;
+            this._childArmature = null;
+            this._parent = null; //
+            this._cachedFrameIndices = null;
+        };
+        /**
+         * - Support default skin data.
+         */
+        Slot.prototype._getDefaultRawDisplayData = function (displayIndex) {
+            var defaultSkin = this._armature._armatureData.defaultSkin;
+            if (defaultSkin !== null) {
+                var defaultRawDisplayDatas = defaultSkin.getDisplays(this._slotData.name);
+                if (defaultRawDisplayDatas !== null) {
+                    return displayIndex < defaultRawDisplayDatas.length ? defaultRawDisplayDatas[displayIndex] : null;
+                }
+            }
+            return null;
+        };
+        Slot.prototype._updateDisplayData = function () {
+            var prevDisplayData = this._displayData;
+            var prevVerticesData = this._deformVertices !== null ? this._deformVertices.verticesData : null;
+            var prevTextureData = this._textureData;
+            var rawDisplayData = null;
+            var currentVerticesData = null;
+            this._displayData = null;
+            this._boundingBoxData = null;
+            this._textureData = null;
+            if (this._displayIndex >= 0) {
+                if (this._rawDisplayDatas !== null) {
+                    rawDisplayData = this._displayIndex < this._rawDisplayDatas.length ? this._rawDisplayDatas[this._displayIndex] : null;
+                }
+                if (rawDisplayData === null) {
+                    rawDisplayData = this._getDefaultRawDisplayData(this._displayIndex);
+                }
+                if (this._displayIndex < this._displayDatas.length) {
+                    this._displayData = this._displayDatas[this._displayIndex];
+                }
+            }
+            if (this._displayData !== null) {
+                if (this._displayData.type === 2 /* Mesh */) {
+                    currentVerticesData = this._displayData.vertices;
+                }
+                else if (this._displayData.type === 4 /* Path */) {
+                    currentVerticesData = this._displayData.vertices;
+                }
+                else if (rawDisplayData !== null) {
+                    if (rawDisplayData.type === 2 /* Mesh */) {
+                        currentVerticesData = rawDisplayData.vertices;
+                    }
+                    else if (rawDisplayData.type === 4 /* Path */) {
+                        currentVerticesData = rawDisplayData.vertices;
+                    }
+                }
+                if (this._displayData.type === 3 /* BoundingBox */) {
+                    this._boundingBoxData = this._displayData.boundingBox;
+                }
+                else if (rawDisplayData !== null) {
+                    if (rawDisplayData.type === 3 /* BoundingBox */) {
+                        this._boundingBoxData = rawDisplayData.boundingBox;
+                    }
+                }
+                if (this._displayData.type === 0 /* Image */) {
+                    this._textureData = this._displayData.texture;
+                }
+                else if (this._displayData.type === 2 /* Mesh */) {
+                    this._textureData = this._displayData.texture;
+                }
+            }
+            if (this._displayData !== prevDisplayData || currentVerticesData !== prevVerticesData || this._textureData !== prevTextureData) {
+                // Update pivot offset.
+                if (currentVerticesData === null && this._textureData !== null) {
+                    var imageDisplayData = this._displayData;
+                    var scale = this._textureData.parent.scale * this._armature._armatureData.scale;
+                    var frame = this._textureData.frame;
+                    this._pivotX = imageDisplayData.pivot.x;
+                    this._pivotY = imageDisplayData.pivot.y;
+                    var rect = frame !== null ? frame : this._textureData.region;
+                    var width = rect.width;
+                    var height = rect.height;
+                    if (this._textureData.rotated && frame === null) {
+                        width = rect.height;
+                        height = rect.width;
+                    }
+                    this._pivotX *= width * scale;
+                    this._pivotY *= height * scale;
+                    if (frame !== null) {
+                        this._pivotX += frame.x * scale;
+                        this._pivotY += frame.y * scale;
+                    }
+                    // Update replace pivot. TODO
+                    if (this._displayData !== null && rawDisplayData !== null && this._displayData !== rawDisplayData) {
+                        rawDisplayData.transform.toMatrix(Slot._helpMatrix);
+                        Slot._helpMatrix.invert();
+                        Slot._helpMatrix.transformPoint(0.0, 0.0, Slot._helpPoint);
+                        this._pivotX -= Slot._helpPoint.x;
+                        this._pivotY -= Slot._helpPoint.y;
+                        this._displayData.transform.toMatrix(Slot._helpMatrix);
+                        Slot._helpMatrix.invert();
+                        Slot._helpMatrix.transformPoint(0.0, 0.0, Slot._helpPoint);
+                        this._pivotX += Slot._helpPoint.x;
+                        this._pivotY += Slot._helpPoint.y;
+                    }
+                    if (!dragonBones.DragonBones.yDown) {
+                        this._pivotY = (this._textureData.rotated ? this._textureData.region.width : this._textureData.region.height) * scale - this._pivotY;
+                    }
+                }
+                else {
+                    this._pivotX = 0.0;
+                    this._pivotY = 0.0;
+                }
+                // Update original transform.
+                if (rawDisplayData !== null) {
+                    this.origin = rawDisplayData.transform;
+                }
+                else if (this._displayData !== null) {
+                    this.origin = this._displayData.transform;
+                }
+                else {
+                    this.origin = null;
+                }
+                // Update vertices.
+                if (currentVerticesData !== prevVerticesData) {
+                    if (this._deformVertices === null) {
+                        this._deformVertices = dragonBones.BaseObject.borrowObject(dragonBones.DeformVertices);
+                    }
+                    this._deformVertices.init(currentVerticesData, this._armature);
+                }
+                else if (this._deformVertices !== null && this._textureData !== prevTextureData) {
+                    this._deformVertices.verticesDirty = true;
+                }
+                this._displayDirty = true;
+                this._transformDirty = true;
+            }
+        };
+        Slot.prototype._updateDisplay = function () {
+            var prevDisplay = this._display !== null ? this._display : this._rawDisplay;
+            var prevChildArmature = this._childArmature;
+            // Update display and child armature.
+            if (this._displayIndex >= 0 && this._displayIndex < this._displayList.length) {
+                this._display = this._displayList[this._displayIndex];
+                if (this._display !== null && this._display instanceof dragonBones.Armature) {
+                    this._childArmature = this._display;
+                    this._display = this._childArmature.display;
+                }
+                else {
+                    this._childArmature = null;
+                }
+            }
+            else {
+                this._display = null;
+                this._childArmature = null;
+            }
+            // Update display.
+            var currentDisplay = this._display !== null ? this._display : this._rawDisplay;
+            if (currentDisplay !== prevDisplay) {
+                this._onUpdateDisplay();
+                this._replaceDisplay(prevDisplay);
+                this._transformDirty = true;
+                this._visibleDirty = true;
+                this._blendModeDirty = true;
+                this._colorDirty = true;
+            }
+            // Update frame.
+            if (currentDisplay === this._rawDisplay || currentDisplay === this._meshDisplay) {
+                this._updateFrame();
+            }
+            // Update child armature.
+            if (this._childArmature !== prevChildArmature) {
+                if (prevChildArmature !== null) {
+                    prevChildArmature._parent = null; // Update child armature parent.
+                    prevChildArmature.clock = null;
+                    if (prevChildArmature.inheritAnimation) {
+                        prevChildArmature.animation.reset();
+                    }
+                }
+                if (this._childArmature !== null) {
+                    this._childArmature._parent = this; // Update child armature parent.
+                    this._childArmature.clock = this._armature.clock;
+                    if (this._childArmature.inheritAnimation) {
+                        if (this._childArmature.cacheFrameRate === 0) {
+                            var cacheFrameRate = this._armature.cacheFrameRate;
+                            if (cacheFrameRate !== 0) {
+                                this._childArmature.cacheFrameRate = cacheFrameRate;
+                            }
+                        }
+                        // Child armature action.
+                        var actions = null;
+                        if (this._displayData !== null && this._displayData.type === 1 /* Armature */) {
+                            actions = this._displayData.actions;
+                        }
+                        else if (this._displayIndex >= 0 && this._rawDisplayDatas !== null) {
+                            var rawDisplayData = this._displayIndex < this._rawDisplayDatas.length ? this._rawDisplayDatas[this._displayIndex] : null;
+                            if (rawDisplayData === null) {
+                                rawDisplayData = this._getDefaultRawDisplayData(this._displayIndex);
+                            }
+                            if (rawDisplayData !== null && rawDisplayData.type === 1 /* Armature */) {
+                                actions = rawDisplayData.actions;
+                            }
+                        }
+                        if (actions !== null && actions.length > 0) {
+                            for (var _i = 0, actions_1 = actions; _i < actions_1.length; _i++) {
+                                var action = actions_1[_i];
+                                var eventObject = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                                dragonBones.EventObject.actionDataToInstance(action, eventObject, this._armature);
+                                eventObject.slot = this;
+                                this._armature._bufferAction(eventObject, false);
+                            }
+                        }
+                        else {
+                            this._childArmature.animation.play();
+                        }
+                    }
+                }
+            }
+        };
+        Slot.prototype._updateGlobalTransformMatrix = function (isCache) {
+            var parentMatrix = this._parent._boneData.type === 0 /* Bone */ ? this._parent.globalTransformMatrix : this._parent._getGlobalTransformMatrix(this.global.x, this.global.y);
+            this.globalTransformMatrix.copyFrom(this._localMatrix);
+            this.globalTransformMatrix.concat(parentMatrix);
+            if (isCache) {
+                this.global.fromMatrix(this.globalTransformMatrix);
+            }
+            else {
+                this._globalDirty = true;
+            }
+        };
+        /**
+         * @internal
+         */
+        Slot.prototype._setDisplayIndex = function (value, isAnimation) {
+            if (isAnimation === void 0) { isAnimation = false; }
+            if (isAnimation) {
+                if (this._animationDisplayIndex === value) {
+                    return false;
+                }
+                this._animationDisplayIndex = value;
+            }
+            if (this._displayIndex === value) {
+                return false;
+            }
+            this._displayIndex = value;
+            this._displayDirty = true;
+            this._updateDisplayData();
+            return this._displayDirty;
+        };
+        /**
+         * @internal
+         */
+        Slot.prototype._setZorder = function (value) {
+            if (this._zOrder === value) {
+                //return false;
+            }
+            this._zOrder = value;
+            this._zOrderDirty = true;
+            return this._zOrderDirty;
+        };
+        /**
+         * @internal
+         */
+        Slot.prototype._setColor = function (value) {
+            this._colorTransform.copyFrom(value);
+            this._colorDirty = true;
+            return this._colorDirty;
+        };
+        /**
+         * @internal
+         */
+        Slot.prototype._setDisplayList = function (value) {
+            if (value !== null && value.length > 0) {
+                if (this._displayList.length !== value.length) {
+                    this._displayList.length = value.length;
+                }
+                for (var i = 0, l = value.length; i < l; ++i) {
+                    var eachDisplay = value[i];
+                    if (eachDisplay !== null && eachDisplay !== this._rawDisplay && eachDisplay !== this._meshDisplay &&
+                        !(eachDisplay instanceof dragonBones.Armature) && this._displayList.indexOf(eachDisplay) < 0) {
+                        this._initDisplay(eachDisplay, true);
+                    }
+                    this._displayList[i] = eachDisplay;
+                }
+            }
+            else if (this._displayList.length > 0) {
+                this._displayList.length = 0;
+            }
+            if (this._displayIndex >= 0 && this._displayIndex < this._displayList.length) {
+                this._displayDirty = this._display !== this._displayList[this._displayIndex];
+            }
+            else {
+                this._displayDirty = this._display !== null;
+            }
+            this._updateDisplayData();
+            return this._displayDirty;
+        };
+        /**
+         * @internal
+         */
+        Slot.prototype.init = function (slotData, armatureValue, rawDisplay, meshDisplay) {
+            if (this._slotData !== null) {
+                return;
+            }
+            this._slotData = slotData;
+            //
+            this._visibleDirty = true;
+            this._blendModeDirty = true;
+            this._colorDirty = true;
+            this._blendMode = this._slotData.blendMode;
+            this._zOrder = this._slotData.zOrder;
+            this._colorTransform.copyFrom(this._slotData.color);
+            this._rawDisplay = rawDisplay;
+            this._meshDisplay = meshDisplay;
+            //
+            this._armature = armatureValue;
+            //
+            var slotParent = this._armature.getBone(this._slotData.parent.name);
+            if (slotParent !== null) {
+                this._parent = slotParent;
+            }
+            else {
+                // Never;
+            }
+            this._armature._addSlot(this);
+            //
+            this._initDisplay(this._rawDisplay, false);
+            if (this._rawDisplay !== this._meshDisplay) {
+                this._initDisplay(this._meshDisplay, false);
+            }
+            this._onUpdateDisplay();
+            this._addDisplay();
+        };
+        /**
+         * @internal
+         */
+        Slot.prototype.update = function (cacheFrameIndex) {
+            if (this._displayDirty) {
+                this._displayDirty = false;
+                this._updateDisplay();
+                // TODO remove slot offset.
+                if (this._transformDirty) {
+                    if (this.origin !== null) {
+                        this.global.copyFrom(this.origin).add(this.offset).toMatrix(this._localMatrix);
+                    }
+                    else {
+                        this.global.copyFrom(this.offset).toMatrix(this._localMatrix);
+                    }
+                }
+            }
+            if (this._zOrderDirty) {
+                this._zOrderDirty = false;
+                this._updateZOrder();
+            }
+            if (cacheFrameIndex >= 0 && this._cachedFrameIndices !== null) {
+                var cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex];
+                if (cachedFrameIndex >= 0 && this._cachedFrameIndex === cachedFrameIndex) {
+                    this._transformDirty = false;
+                }
+                else if (cachedFrameIndex >= 0) {
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = cachedFrameIndex;
+                }
+                else if (this._transformDirty || this._parent._childrenTransformDirty) {
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = -1;
+                }
+                else if (this._cachedFrameIndex >= 0) {
+                    this._transformDirty = false;
+                    this._cachedFrameIndices[cacheFrameIndex] = this._cachedFrameIndex;
+                }
+                else {
+                    this._transformDirty = true;
+                    this._cachedFrameIndex = -1;
+                }
+            }
+            else if (this._transformDirty || this._parent._childrenTransformDirty) {
+                cacheFrameIndex = -1;
+                this._transformDirty = true;
+                this._cachedFrameIndex = -1;
+            }
+            if (this._display === null) {
+                return;
+            }
+            if (this._visibleDirty) {
+                this._visibleDirty = false;
+                this._updateVisible();
+            }
+            if (this._blendModeDirty) {
+                this._blendModeDirty = false;
+                this._updateBlendMode();
+            }
+            if (this._colorDirty) {
+                this._colorDirty = false;
+                this._updateColor();
+            }
+            if (this._deformVertices !== null && this._deformVertices.verticesData !== null && this._display === this._meshDisplay) {
+                var isSkinned = this._deformVertices.verticesData.weight !== null;
+                var isSurface = this._parent._boneData.type !== 0 /* Bone */;
+                if (this._deformVertices.verticesDirty ||
+                    (isSkinned && this._deformVertices.isBonesUpdate()) ||
+                    (isSurface && this._parent._childrenTransformDirty)) {
+                    this._deformVertices.verticesDirty = false;
+                    this._updateMesh();
+                }
+                if (isSkinned || isSurface) {
+                    return;
+                }
+            }
+            if (this._transformDirty) {
+                this._transformDirty = false;
+                if (this._cachedFrameIndex < 0) {
+                    var isCache = cacheFrameIndex >= 0;
+                    this._updateGlobalTransformMatrix(isCache);
+                    if (isCache && this._cachedFrameIndices !== null) {
+                        this._cachedFrameIndex = this._cachedFrameIndices[cacheFrameIndex] = this._armature._armatureData.setCacheFrame(this.globalTransformMatrix, this.global);
+                    }
+                }
+                else {
+                    this._armature._armatureData.getCacheFrame(this.globalTransformMatrix, this.global, this._cachedFrameIndex);
+                }
+                this._updateTransform();
+            }
+        };
+        /**
+         * @private
+         */
+        Slot.prototype.updateTransformAndMatrix = function () {
+            if (this._transformDirty) {
+                this._transformDirty = false;
+                this._updateGlobalTransformMatrix(false);
+            }
+        };
+        /**
+         * @private
+         */
+        Slot.prototype.replaceDisplayData = function (value, displayIndex) {
+            if (displayIndex === void 0) { displayIndex = -1; }
+            if (displayIndex < 0) {
+                if (this._displayIndex < 0) {
+                    displayIndex = 0;
+                }
+                else {
+                    displayIndex = this._displayIndex;
+                }
+            }
+            if (this._displayDatas.length <= displayIndex) {
+                this._displayDatas.length = displayIndex + 1;
+                for (var i = 0, l = this._displayDatas.length; i < l; ++i) {
+                    if (!this._displayDatas[i]) {
+                        this._displayDatas[i] = null;
+                    }
+                }
+            }
+            this._displayDatas[displayIndex] = value;
+        };
+        /**
+         * - Check whether a specific point is inside a custom bounding box in the slot.
+         * The coordinate system of the point is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param x - The horizontal coordinate of the point.
+         * @param y - The vertical coordinate of the point.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定点是否在插槽的自定义边界框内。
+         * 点的坐标系为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param x - 点的水平坐标。
+         * @param y - 点的垂直坐标。
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        Slot.prototype.containsPoint = function (x, y) {
+            if (this._boundingBoxData === null) {
+                return false;
+            }
+            this.updateTransformAndMatrix();
+            Slot._helpMatrix.copyFrom(this.globalTransformMatrix);
+            Slot._helpMatrix.invert();
+            Slot._helpMatrix.transformPoint(x, y, Slot._helpPoint);
+            return this._boundingBoxData.containsPoint(Slot._helpPoint.x, Slot._helpPoint.y);
+        };
+        /**
+         * - Check whether a specific segment intersects a custom bounding box for the slot.
+         * The coordinate system of the segment and intersection is the inner coordinate system of the armature.
+         * Custom bounding boxes need to be customized in Dragonbones Pro.
+         * @param xA - The horizontal coordinate of the beginning of the segment.
+         * @param yA - The vertical coordinate of the beginning of the segment.
+         * @param xB - The horizontal coordinate of the end point of the segment.
+         * @param yB - The vertical coordinate of the end point of the segment.
+         * @param intersectionPointA - The first intersection at which a line segment intersects the bounding box from the beginning to the end. (If not set, the intersection point will not calculated)
+         * @param intersectionPointB - The first intersection at which a line segment intersects the bounding box from the end to the beginning. (If not set, the intersection point will not calculated)
+         * @param normalRadians - The normal radians of the tangent of the intersection boundary box. [x: Normal radian of the first intersection tangent, y: Normal radian of the second intersection tangent] (If not set, the normal will not calculated)
+         * @returns Intersection situation. [1: Disjoint and segments within the bounding box, 0: Disjoint, 1: Intersecting and having a nodal point and ending in the bounding box, 2: Intersecting and having a nodal point and starting at the bounding box, 3: Intersecting and having two intersections, N: Intersecting and having N intersections]
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 检查特定线段是否与插槽的自定义边界框相交。
+         * 线段和交点的坐标系均为骨架内坐标系。
+         * 自定义边界框需要在 DragonBones Pro 中自定义。
+         * @param xA - 线段起点的水平坐标。
+         * @param yA - 线段起点的垂直坐标。
+         * @param xB - 线段终点的水平坐标。
+         * @param yB - 线段终点的垂直坐标。
+         * @param intersectionPointA - 线段从起点到终点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param intersectionPointB - 线段从终点到起点与边界框相交的第一个交点。 （如果未设置，则不计算交点）
+         * @param normalRadians - 交点边界框切线的法线弧度。 [x: 第一个交点切线的法线弧度, y: 第二个交点切线的法线弧度] （如果未设置，则不计算法线）
+         * @returns 相交的情况。 [-1: 不相交且线段在包围盒内, 0: 不相交, 1: 相交且有一个交点且终点在包围盒内, 2: 相交且有一个交点且起点在包围盒内, 3: 相交且有两个交点, N: 相交且有 N 个交点]
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        Slot.prototype.intersectsSegment = function (xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians) {
+            if (intersectionPointA === void 0) { intersectionPointA = null; }
+            if (intersectionPointB === void 0) { intersectionPointB = null; }
+            if (normalRadians === void 0) { normalRadians = null; }
+            if (this._boundingBoxData === null) {
+                return 0;
+            }
+            this.updateTransformAndMatrix();
+            Slot._helpMatrix.copyFrom(this.globalTransformMatrix);
+            Slot._helpMatrix.invert();
+            Slot._helpMatrix.transformPoint(xA, yA, Slot._helpPoint);
+            xA = Slot._helpPoint.x;
+            yA = Slot._helpPoint.y;
+            Slot._helpMatrix.transformPoint(xB, yB, Slot._helpPoint);
+            xB = Slot._helpPoint.x;
+            yB = Slot._helpPoint.y;
+            var intersectionCount = this._boundingBoxData.intersectsSegment(xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians);
+            if (intersectionCount > 0) {
+                if (intersectionCount === 1 || intersectionCount === 2) {
+                    if (intersectionPointA !== null) {
+                        this.globalTransformMatrix.transformPoint(intersectionPointA.x, intersectionPointA.y, intersectionPointA);
+                        if (intersectionPointB !== null) {
+                            intersectionPointB.x = intersectionPointA.x;
+                            intersectionPointB.y = intersectionPointA.y;
+                        }
+                    }
+                    else if (intersectionPointB !== null) {
+                        this.globalTransformMatrix.transformPoint(intersectionPointB.x, intersectionPointB.y, intersectionPointB);
+                    }
+                }
+                else {
+                    if (intersectionPointA !== null) {
+                        this.globalTransformMatrix.transformPoint(intersectionPointA.x, intersectionPointA.y, intersectionPointA);
+                    }
+                    if (intersectionPointB !== null) {
+                        this.globalTransformMatrix.transformPoint(intersectionPointB.x, intersectionPointB.y, intersectionPointB);
+                    }
+                }
+                if (normalRadians !== null) {
+                    this.globalTransformMatrix.transformPoint(Math.cos(normalRadians.x), Math.sin(normalRadians.x), Slot._helpPoint, true);
+                    normalRadians.x = Math.atan2(Slot._helpPoint.y, Slot._helpPoint.x);
+                    this.globalTransformMatrix.transformPoint(Math.cos(normalRadians.y), Math.sin(normalRadians.y), Slot._helpPoint, true);
+                    normalRadians.y = Math.atan2(Slot._helpPoint.y, Slot._helpPoint.x);
+                }
+            }
+            return intersectionCount;
+        };
+        /**
+         * - Forces the slot to update the state of the display object in the next frame.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 强制插槽在下一帧更新显示对象的状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Slot.prototype.invalidUpdate = function () {
+            this._displayDirty = true;
+            this._transformDirty = true;
+        };
+        Object.defineProperty(Slot.prototype, "visible", {
+            /**
+             * - The visible of slot's display object.
+             * @default true
+             * @version DragonBones 5.6
+             * @language en_US
+             */
+            /**
+             * - 插槽的显示对象的可见。
+             * @default true
+             * @version DragonBones 5.6
+             * @language zh_CN
+             */
+            get: function () {
+                return this._visible;
+            },
+            set: function (value) {
+                if (this._visible === value) {
+                    return;
+                }
+                this._visible = value;
+                this._updateVisible();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "displayIndex", {
+            /**
+             * - The index of the display object displayed in the display list.
+             * @example
+             * <pre>
+             *     let slot = armature.getSlot("weapon");
+             *     slot.displayIndex = 3;
+             *     slot.displayController = "none";
+             * </pre>
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 此时显示的显示对象在显示列表中的索引。
+             * @example
+             * <pre>
+             *     let slot = armature.getSlot("weapon");
+             *     slot.displayIndex = 3;
+             *     slot.displayController = "none";
+             * </pre>
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._displayIndex;
+            },
+            set: function (value) {
+                if (this._setDisplayIndex(value)) {
+                    this.update(-1);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "name", {
+            /**
+             * - The slot name.
+             * @see dragonBones.SlotData#name
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 插槽名称。
+             * @see dragonBones.SlotData#name
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._slotData.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "displayList", {
+            /**
+             * - Contains a display list of display objects or child armatures.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 包含显示对象或子骨架的显示列表。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._displayList.concat();
+            },
+            set: function (value) {
+                var backupDisplayList = this._displayList.concat(); // Copy.
+                var disposeDisplayList = new Array();
+                if (this._setDisplayList(value)) {
+                    this.update(-1);
+                }
+                // Release replaced displays.
+                for (var _i = 0, backupDisplayList_1 = backupDisplayList; _i < backupDisplayList_1.length; _i++) {
+                    var eachDisplay = backupDisplayList_1[_i];
+                    if (eachDisplay !== null && eachDisplay !== this._rawDisplay && eachDisplay !== this._meshDisplay &&
+                        this._displayList.indexOf(eachDisplay) < 0 &&
+                        disposeDisplayList.indexOf(eachDisplay) < 0) {
+                        disposeDisplayList.push(eachDisplay);
+                    }
+                }
+                for (var _a = 0, disposeDisplayList_2 = disposeDisplayList; _a < disposeDisplayList_2.length; _a++) {
+                    var eachDisplay = disposeDisplayList_2[_a];
+                    if (eachDisplay instanceof dragonBones.Armature) {
+                        // (eachDisplay as Armature).dispose();
+                    }
+                    else {
+                        this._disposeDisplay(eachDisplay, true);
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "slotData", {
+            /**
+             * - The slot data.
+             * @see dragonBones.SlotData
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 插槽数据。
+             * @see dragonBones.SlotData
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._slotData;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "rawDisplayDatas", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this._rawDisplayDatas;
+            },
+            set: function (value) {
+                if (this._rawDisplayDatas === value) {
+                    return;
+                }
+                this._displayDirty = true;
+                this._rawDisplayDatas = value;
+                if (this._rawDisplayDatas !== null) {
+                    this._displayDatas.length = this._rawDisplayDatas.length;
+                    for (var i = 0, l = this._displayDatas.length; i < l; ++i) {
+                        var rawDisplayData = this._rawDisplayDatas[i];
+                        if (rawDisplayData === null) {
+                            rawDisplayData = this._getDefaultRawDisplayData(i);
+                        }
+                        this._displayDatas[i] = rawDisplayData;
+                    }
+                }
+                else {
+                    this._displayDatas.length = 0;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "displayData", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this._displayData;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "boundingBoxData", {
+            /**
+             * - The custom bounding box data for the slot at current time.
+             * @version DragonBones 5.0
+             * @language en_US
+             */
+            /**
+             * - 插槽此时的自定义包围盒数据。
+             * @version DragonBones 5.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._boundingBoxData;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "rawDisplay", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this._rawDisplay;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "meshDisplay", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this._meshDisplay;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "display", {
+            /**
+             * - The display object that the slot displays at this time.
+             * @example
+             * <pre>
+             *     let slot = armature.getSlot("text");
+             *     slot.display = new yourEngine.TextField();
+             * </pre>
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 插槽此时显示的显示对象。
+             * @example
+             * <pre>
+             *     let slot = armature.getSlot("text");
+             *     slot.display = new yourEngine.TextField();
+             * </pre>
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._display;
+            },
+            set: function (value) {
+                if (this._display === value) {
+                    return;
+                }
+                var displayListLength = this._displayList.length;
+                if (this._displayIndex < 0 && displayListLength === 0) {
+                    this._displayIndex = 0;
+                }
+                if (this._displayIndex < 0) {
+                    return;
+                }
+                else {
+                    var replaceDisplayList = this.displayList; // Copy.
+                    if (displayListLength <= this._displayIndex) {
+                        replaceDisplayList.length = this._displayIndex + 1;
+                    }
+                    replaceDisplayList[this._displayIndex] = value;
+                    this.displayList = replaceDisplayList;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "childArmature", {
+            /**
+             * - The child armature that the slot displayed at current time.
+             * @example
+             * <pre>
+             *     let slot = armature.getSlot("weapon");
+             * let prevChildArmature = slot.childArmature;
+             * if (prevChildArmature) {
+             * prevChildArmature.dispose();
+             *     }
+             *     slot.childArmature = factory.buildArmature("weapon_blabla", "weapon_blabla_project");
+             * </pre>
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 插槽此时显示的子骨架。
+             * 注意，被替换的对象或子骨架并不会被回收，根据语言和引擎的不同，需要额外处理。
+             * @example
+             * <pre>
+             *     let slot = armature.getSlot("weapon");
+             * let prevChildArmature = slot.childArmature;
+             * if (prevChildArmature) {
+             * prevChildArmature.dispose();
+             *     }
+             *     slot.childArmature = factory.buildArmature("weapon_blabla", "weapon_blabla_project");
+             * </pre>
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._childArmature;
+            },
+            set: function (value) {
+                if (this._childArmature === value) {
+                    return;
+                }
+                this.display = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Slot.prototype, "parent", {
+            /**
+             * - The parent bone to which it belongs.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 所属的父骨骼。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._parent;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link #display}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #display}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Slot.prototype.getDisplay = function () {
+            return this._display;
+        };
+        /**
+         * - Deprecated, please refer to {@link #display}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #display}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Slot.prototype.setDisplay = function (value) {
+            this.display = value;
+        };
+        return Slot;
+    }(dragonBones.TransformObject));
+    dragonBones.Slot = Slot;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var Constraint = /** @class */ (function (_super) {
+        __extends(Constraint, _super);
+        function Constraint() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Constraint.prototype._onClear = function () {
+            this._armature = null; //
+            this._target = null; //
+            this._root = null; //
+            this._bone = null;
+        };
+        Object.defineProperty(Constraint.prototype, "name", {
+            get: function () {
+                return this._constraintData.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Constraint._helpMatrix = new dragonBones.Matrix();
+        Constraint._helpTransform = new dragonBones.Transform();
+        Constraint._helpPoint = new dragonBones.Point();
+        return Constraint;
+    }(dragonBones.BaseObject));
+    dragonBones.Constraint = Constraint;
+    /**
+     * @internal
+     */
+    var IKConstraint = /** @class */ (function (_super) {
+        __extends(IKConstraint, _super);
+        function IKConstraint() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        IKConstraint.toString = function () {
+            return "[class dragonBones.IKConstraint]";
+        };
+        IKConstraint.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this._scaleEnabled = false;
+            this._bendPositive = false;
+            this._weight = 1.0;
+            this._constraintData = null;
+        };
+        IKConstraint.prototype._computeA = function () {
+            var ikGlobal = this._target.global;
+            var global = this._root.global;
+            var globalTransformMatrix = this._root.globalTransformMatrix;
+            var radian = Math.atan2(ikGlobal.y - global.y, ikGlobal.x - global.x);
+            if (global.scaleX < 0.0) {
+                radian += Math.PI;
+            }
+            global.rotation += dragonBones.Transform.normalizeRadian(radian - global.rotation) * this._weight;
+            global.toMatrix(globalTransformMatrix);
+        };
+        IKConstraint.prototype._computeB = function () {
+            var boneLength = this._bone._boneData.length;
+            var parent = this._root;
+            var ikGlobal = this._target.global;
+            var parentGlobal = parent.global;
+            var global = this._bone.global;
+            var globalTransformMatrix = this._bone.globalTransformMatrix;
+            var x = globalTransformMatrix.a * boneLength;
+            var y = globalTransformMatrix.b * boneLength;
+            var lLL = x * x + y * y;
+            var lL = Math.sqrt(lLL);
+            var dX = global.x - parentGlobal.x;
+            var dY = global.y - parentGlobal.y;
+            var lPP = dX * dX + dY * dY;
+            var lP = Math.sqrt(lPP);
+            var rawRadian = global.rotation;
+            var rawParentRadian = parentGlobal.rotation;
+            var rawRadianA = Math.atan2(dY, dX);
+            dX = ikGlobal.x - parentGlobal.x;
+            dY = ikGlobal.y - parentGlobal.y;
+            var lTT = dX * dX + dY * dY;
+            var lT = Math.sqrt(lTT);
+            var radianA = 0.0;
+            if (lL + lP <= lT || lT + lL <= lP || lT + lP <= lL) {
+                radianA = Math.atan2(ikGlobal.y - parentGlobal.y, ikGlobal.x - parentGlobal.x);
+                if (lL + lP <= lT) {
+                }
+                else if (lP < lL) {
+                    radianA += Math.PI;
+                }
+            }
+            else {
+                var h = (lPP - lLL + lTT) / (2.0 * lTT);
+                var r = Math.sqrt(lPP - h * h * lTT) / lT;
+                var hX = parentGlobal.x + (dX * h);
+                var hY = parentGlobal.y + (dY * h);
+                var rX = -dY * r;
+                var rY = dX * r;
+                var isPPR = false;
+                var parentParent = parent.parent;
+                if (parentParent !== null) {
+                    var parentParentMatrix = parentParent.globalTransformMatrix;
+                    isPPR = parentParentMatrix.a * parentParentMatrix.d - parentParentMatrix.b * parentParentMatrix.c < 0.0;
+                }
+                if (isPPR !== this._bendPositive) {
+                    global.x = hX - rX;
+                    global.y = hY - rY;
+                }
+                else {
+                    global.x = hX + rX;
+                    global.y = hY + rY;
+                }
+                radianA = Math.atan2(global.y - parentGlobal.y, global.x - parentGlobal.x);
+            }
+            var dR = dragonBones.Transform.normalizeRadian(radianA - rawRadianA);
+            parentGlobal.rotation = rawParentRadian + dR * this._weight;
+            parentGlobal.toMatrix(parent.globalTransformMatrix);
+            //
+            var currentRadianA = rawRadianA + dR * this._weight;
+            global.x = parentGlobal.x + Math.cos(currentRadianA) * lP;
+            global.y = parentGlobal.y + Math.sin(currentRadianA) * lP;
+            //
+            var radianB = Math.atan2(ikGlobal.y - global.y, ikGlobal.x - global.x);
+            if (global.scaleX < 0.0) {
+                radianB += Math.PI;
+            }
+            global.rotation = parentGlobal.rotation + rawRadian - rawParentRadian + dragonBones.Transform.normalizeRadian(radianB - dR - rawRadian) * this._weight;
+            global.toMatrix(globalTransformMatrix);
+        };
+        IKConstraint.prototype.init = function (constraintData, armature) {
+            if (this._constraintData !== null) {
+                return;
+            }
+            this._constraintData = constraintData;
+            this._armature = armature;
+            this._target = this._armature.getBone(this._constraintData.target.name);
+            this._root = this._armature.getBone(this._constraintData.root.name);
+            this._bone = this._constraintData.bone !== null ? this._armature.getBone(this._constraintData.bone.name) : null;
+            {
+                var ikConstraintData = this._constraintData;
+                this._scaleEnabled = ikConstraintData.scaleEnabled;
+                this._bendPositive = ikConstraintData.bendPositive;
+                this._weight = ikConstraintData.weight;
+            }
+            this._root._hasConstraint = true;
+        };
+        IKConstraint.prototype.update = function () {
+            this._root.updateByConstraint();
+            if (this._bone !== null) {
+                this._bone.updateByConstraint();
+                this._computeB();
+            }
+            else {
+                this._computeA();
+            }
+        };
+        IKConstraint.prototype.invalidUpdate = function () {
+            this._root.invalidUpdate();
+            if (this._bone !== null) {
+                this._bone.invalidUpdate();
+            }
+        };
+        return IKConstraint;
+    }(Constraint));
+    dragonBones.IKConstraint = IKConstraint;
+    /**
+     * @internal
+     */
+    var PathConstraint = /** @class */ (function (_super) {
+        __extends(PathConstraint, _super);
+        function PathConstraint() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._bones = [];
+            _this._spaces = [];
+            _this._positions = [];
+            _this._curves = [];
+            _this._boneLengths = [];
+            _this._pathGlobalVertices = [];
+            _this._segments = [10];
+            return _this;
+        }
+        PathConstraint.toString = function () {
+            return "[class dragonBones.PathConstraint]";
+        };
+        PathConstraint.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.dirty = false;
+            this.pathOffset = 0;
+            this.position = 0.0;
+            this.spacing = 0.0;
+            this.rotateOffset = 0.0;
+            this.rotateMix = 1.0;
+            this.translateMix = 1.0;
+            this._pathSlot = null;
+            this._bones.length = 0;
+            this._spaces.length = 0;
+            this._positions.length = 0;
+            this._curves.length = 0;
+            this._boneLengths.length = 0;
+            this._pathGlobalVertices.length = 0;
+        };
+        PathConstraint.prototype._updatePathVertices = function (verticesData) {
+            //计算曲线的节点数据
+            var armature = this._armature;
+            var dragonBonesData = armature.armatureData.parent;
+            var scale = armature.armatureData.scale;
+            var intArray = dragonBonesData.intArray;
+            var floatArray = dragonBonesData.floatArray;
+            var pathOffset = verticesData.offset;
+            var pathVertexCount = intArray[pathOffset + 0 /* PathVertexCount */];
+            var pathVertexOffset = intArray[pathOffset + 2 /* PathFloatOffset */];
+            this._pathGlobalVertices.length = pathVertexCount * 2;
+            var weightData = verticesData.weight;
+            //没有骨骼约束我,那节点只受自己的Bone控制
+            if (weightData === null) {
+                var parentBone = this._pathSlot.parent;
+                parentBone.updateByConstraint();
+                var matrix = parentBone.globalTransformMatrix;
+                for (var i = 0, iV_1 = pathVertexOffset; i < pathVertexCount; i += 2) {
+                    var vx = floatArray[iV_1++] * scale;
+                    var vy = floatArray[iV_1++] * scale;
+                    var x = matrix.a * vx + matrix.c * vy + matrix.tx;
+                    var y = matrix.b * vx + matrix.d * vy + matrix.ty;
+                    //
+                    this._pathGlobalVertices[i] = x;
+                    this._pathGlobalVertices[i + 1] = y;
+                }
+                return;
+            }
+            //有骨骼约束我,那我的节点受骨骼权重控制
+            var bones = this._pathSlot._deformVertices.bones;
+            var weightBoneCount = weightData.bones.length;
+            var weightOffset = weightData.offset;
+            var floatOffset = intArray[weightOffset + 1 /* WeigthFloatOffset */];
+            var iV = floatOffset;
+            var iB = weightOffset + 2 /* WeigthBoneIndices */ + weightBoneCount;
+            for (var i = 0, iW = 0; i < pathVertexCount; i++) {
+                var vertexBoneCount = intArray[iB++]; //
+                var xG = 0.0, yG = 0.0;
+                for (var ii = 0, ll = vertexBoneCount; ii < ll; ii++) {
+                    var boneIndex = intArray[iB++];
+                    var bone = bones[boneIndex];
+                    if (bone === null) {
+                        continue;
+                    }
+                    bone.updateByConstraint();
+                    var matrix = bone.globalTransformMatrix;
+                    var weight = floatArray[iV++];
+                    var vx = floatArray[iV++] * scale;
+                    var vy = floatArray[iV++] * scale;
+                    xG += (matrix.a * vx + matrix.c * vy + matrix.tx) * weight;
+                    yG += (matrix.b * vx + matrix.d * vy + matrix.ty) * weight;
+                }
+                this._pathGlobalVertices[iW++] = xG;
+                this._pathGlobalVertices[iW++] = yG;
+            }
+        };
+        PathConstraint.prototype._computeVertices = function (start, count, offset, out) {
+            //TODO优化
+            for (var i = offset, iW = start; i < count; i += 2) {
+                out[i] = this._pathGlobalVertices[iW++];
+                out[i + 1] = this._pathGlobalVertices[iW++];
+            }
+        };
+        PathConstraint.prototype._computeBezierCurve = function (pathDisplayDta, spaceCount, tangents, percentPosition, percentSpacing) {
+            //计算当前的骨骼在曲线上的位置
+            var armature = this._armature;
+            var intArray = armature.armatureData.parent.intArray;
+            var vertexCount = intArray[pathDisplayDta.vertices.offset + 0 /* PathVertexCount */];
+            var positions = this._positions;
+            var spaces = this._spaces;
+            var isClosed = pathDisplayDta.closed;
+            var curveVertices = Array();
+            var verticesLength = vertexCount * 2;
+            var curveCount = verticesLength / 6;
+            var preCurve = -1;
+            var position = this.position;
+            positions.length = spaceCount * 3 + 2;
+            var pathLength = 0.0;
+            //不需要匀速运动，效率高些
+            if (!pathDisplayDta.constantSpeed) {
+                var lenghts = pathDisplayDta.curveLengths;
+                curveCount -= isClosed ? 1 : 2;
+                pathLength = lenghts[curveCount];
+                if (percentPosition) {
+                    position *= pathLength;
+                }
+                if (percentSpacing) {
+                    for (var i = 0; i < spaceCount; i++) {
+                        spaces[i] *= pathLength;
+                    }
+                }
+                curveVertices.length = 8;
+                for (var i = 0, o = 0, curve = 0; i < spaceCount; i++, o += 3) {
+                    var space = spaces[i];
+                    position += space;
+                    if (isClosed) {
+                        position %= pathLength;
+                        if (position < 0) {
+                            position += pathLength;
+                        }
+                        curve = 0;
+                    }
+                    else if (position < 0) {
+                        //TODO
+                        continue;
+                    }
+                    else if (position > pathLength) {
+                        //TODO
+                        continue;
+                    }
+                    var percent = 0.0;
+                    for (;; curve++) {
+                        var len = lenghts[curve];
+                        if (position > len) {
+                            continue;
+                        }
+                        if (curve === 0) {
+                            percent = position / len;
+                        }
+                        else {
+                            var preLen = lenghts[curve - 1];
+                            percent = (position - preLen) / (len - preLen);
+                        }
+                        break;
+                    }
+                    if (curve !== preCurve) {
+                        preCurve = curve;
+                        if (isClosed && curve === curveCount) {
+                            //计算曲线
+                            this._computeVertices(verticesLength - 4, 4, 0, curveVertices);
+                            this._computeVertices(0, 4, 4, curveVertices);
+                        }
+                        else {
+                            this._computeVertices(curve * 6 + 2, 8, 0, curveVertices);
+                        }
+                    }
+                    //
+                    this.addCurvePosition(percent, curveVertices[0], curveVertices[1], curveVertices[2], curveVertices[3], curveVertices[4], curveVertices[5], curveVertices[6], curveVertices[7], positions, o, tangents);
+                }
+                return;
+            }
+            //匀速的
+            if (isClosed) {
+                verticesLength += 2;
+                curveVertices.length = vertexCount;
+                this._computeVertices(2, verticesLength - 4, 0, curveVertices);
+                this._computeVertices(0, 2, verticesLength - 4, curveVertices);
+                curveVertices[verticesLength - 2] = curveVertices[0];
+                curveVertices[verticesLength - 1] = curveVertices[1];
+            }
+            else {
+                curveCount--;
+                verticesLength -= 4;
+                curveVertices.length = verticesLength;
+                this._computeVertices(2, verticesLength, 0, curveVertices);
+            }
+            //
+            var curves = new Array(curveCount);
+            pathLength = 0;
+            var x1 = curveVertices[0], y1 = curveVertices[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
+            var tmpx, tmpy, dddfx, dddfy, ddfx, ddfy, dfx, dfy;
+            for (var i = 0, w = 2; i < curveCount; i++, w += 6) {
+                cx1 = curveVertices[w];
+                cy1 = curveVertices[w + 1];
+                cx2 = curveVertices[w + 2];
+                cy2 = curveVertices[w + 3];
+                x2 = curveVertices[w + 4];
+                y2 = curveVertices[w + 5];
+                tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
+                tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
+                dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
+                dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
+                ddfx = tmpx * 2 + dddfx;
+                ddfy = tmpy * 2 + dddfy;
+                dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
+                dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
+                pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                dfx += ddfx;
+                dfy += ddfy;
+                ddfx += dddfx;
+                ddfy += dddfy;
+                pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                dfx += ddfx;
+                dfy += ddfy;
+                pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                dfx += ddfx + dddfx;
+                dfy += ddfy + dddfy;
+                pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                curves[i] = pathLength;
+                x1 = x2;
+                y1 = y2;
+            }
+            if (percentPosition) {
+                position *= pathLength;
+            }
+            if (percentSpacing) {
+                for (var i = 0; i < spaceCount; i++) {
+                    spaces[i] *= pathLength;
+                }
+            }
+            var segments = this._segments;
+            var curveLength = 0;
+            for (var i = 0, o = 0, curve = 0, segment = 0; i < spaceCount; i++, o += 3) {
+                var space = spaces[i];
+                position += space;
+                var p = position;
+                if (isClosed) {
+                    p %= pathLength;
+                    if (p < 0)
+                        p += pathLength;
+                    curve = 0;
+                }
+                else if (p < 0) {
+                    continue;
+                }
+                else if (p > pathLength) {
+                    continue;
+                }
+                // Determine curve containing position.
+                for (;; curve++) {
+                    var length_1 = curves[curve];
+                    if (p > length_1)
+                        continue;
+                    if (curve === 0)
+                        p /= length_1;
+                    else {
+                        var prev = curves[curve - 1];
+                        p = (p - prev) / (length_1 - prev);
+                    }
+                    break;
+                }
+                if (curve !== preCurve) {
+                    preCurve = curve;
+                    var ii = curve * 6;
+                    x1 = curveVertices[ii];
+                    y1 = curveVertices[ii + 1];
+                    cx1 = curveVertices[ii + 2];
+                    cy1 = curveVertices[ii + 3];
+                    cx2 = curveVertices[ii + 4];
+                    cy2 = curveVertices[ii + 5];
+                    x2 = curveVertices[ii + 6];
+                    y2 = curveVertices[ii + 7];
+                    tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
+                    tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
+                    dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
+                    dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
+                    ddfx = tmpx * 2 + dddfx;
+                    ddfy = tmpy * 2 + dddfy;
+                    dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
+                    dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
+                    curveLength = Math.sqrt(dfx * dfx + dfy * dfy);
+                    segments[0] = curveLength;
+                    for (ii = 1; ii < 8; ii++) {
+                        dfx += ddfx;
+                        dfy += ddfy;
+                        ddfx += dddfx;
+                        ddfy += dddfy;
+                        curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                        segments[ii] = curveLength;
+                    }
+                    dfx += ddfx;
+                    dfy += ddfy;
+                    curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                    segments[8] = curveLength;
+                    dfx += ddfx + dddfx;
+                    dfy += ddfy + dddfy;
+                    curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
+                    segments[9] = curveLength;
+                    segment = 0;
+                }
+                // Weight by segment length.
+                p *= curveLength;
+                for (;; segment++) {
+                    var length_2 = segments[segment];
+                    if (p > length_2)
+                        continue;
+                    if (segment === 0)
+                        p /= length_2;
+                    else {
+                        var prev = segments[segment - 1];
+                        p = segment + (p - prev) / (length_2 - prev);
+                    }
+                    break;
+                }
+                this.addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, positions, o, tangents);
+            }
+        };
+        //Calculates a point on the curve, for a given t value between 0 and 1.
+        PathConstraint.prototype.addCurvePosition = function (t, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, offset, tangents) {
+            if (t === 0) {
+                out[offset] = x1;
+                out[offset + 1] = y1;
+                out[offset + 2] = 0;
+                return;
+            }
+            if (t === 1) {
+                out[offset] = x2;
+                out[offset + 1] = y2;
+                out[offset + 2] = 0;
+                return;
+            }
+            var mt = 1 - t;
+            var mt2 = mt * mt;
+            var t2 = t * t;
+            var a = mt2 * mt;
+            var b = mt2 * t * 3;
+            var c = mt * t2 * 3;
+            var d = t * t2;
+            var x = a * x1 + b * cx1 + c * cx2 + d * x2;
+            var y = a * y1 + b * cy1 + c * cy2 + d * y2;
+            out[offset] = x;
+            out[offset + 1] = y;
+            if (tangents) {
+                //Calculates the curve tangent at the specified t value
+                out[offset + 2] = Math.atan2(y - (a * y1 + b * cy1 + c * cy2), x - (a * x1 + b * cx1 + c * cx2));
+            }
+            else {
+                out[offset + 2] = 0;
+            }
+        };
+        PathConstraint.prototype.init = function (constraintData, armature) {
+            this._constraintData = constraintData;
+            this._armature = armature;
+            var data = constraintData;
+            this.pathOffset = data.pathDisplayData.vertices.offset;
+            //
+            this.position = data.position;
+            this.spacing = data.spacing;
+            this.rotateOffset = data.rotateOffset;
+            this.rotateMix = data.rotateMix;
+            this.translateMix = data.translateMix;
+            //
+            this._root = this._armature.getBone(data.root.name);
+            this._target = this._armature.getBone(data.target.name);
+            this._pathSlot = this._armature.getSlot(data.pathSlot.name);
+            for (var i = 0, l = data.bones.length; i < l; i++) {
+                var bone = this._armature.getBone(data.bones[i].name);
+                if (bone !== null) {
+                    this._bones.push(bone);
+                }
+            }
+            if (data.rotateMode === 2 /* ChainScale */) {
+                this._boneLengths.length = this._bones.length;
+            }
+            this._root._hasConstraint = true;
+        };
+        PathConstraint.prototype.update = function () {
+            var pathSlot = this._pathSlot;
+            if (pathSlot._deformVertices === null ||
+                pathSlot._deformVertices.verticesData === null ||
+                pathSlot._deformVertices.verticesData.offset !== this.pathOffset) {
+                return;
+            }
+            var constraintData = this._constraintData;
+            var pathDisplayData = pathSlot._displayData; // TODO
+            //
+            //曲线节点数据改变:父亲bone改变，权重bones改变，变形顶点改变
+            var isPathVerticeDirty = false;
+            var deformVertices = pathSlot._deformVertices;
+            if (this._root._childrenTransformDirty) {
+                this._updatePathVertices(pathDisplayData.vertices);
+                isPathVerticeDirty = true;
+            }
+            else if (deformVertices !== null && (deformVertices.verticesDirty || deformVertices.isBonesUpdate())) {
+                this._updatePathVertices(pathDisplayData.vertices);
+                deformVertices.verticesDirty = false;
+                isPathVerticeDirty = true;
+            }
+            if (!isPathVerticeDirty && !this.dirty) {
+                return;
+            }
+            //
+            var positionMode = constraintData.positionMode;
+            var spacingMode = constraintData.spacingMode;
+            var rotateMode = constraintData.rotateMode;
+            var bones = this._bones;
+            var isLengthMode = spacingMode === 0 /* Length */;
+            var isChainScaleMode = rotateMode === 2 /* ChainScale */;
+            var isTangentMode = rotateMode === 0 /* Tangent */;
+            var boneCount = bones.length;
+            var spacesCount = isTangentMode ? boneCount : boneCount + 1;
+            var spacing = this.spacing;
+            var spaces = this._spaces;
+            spaces.length = spacesCount;
+            //计曲线间隔和长度
+            if (isChainScaleMode || isLengthMode) {
+                //Bone改变和spacing改变触发
+                spaces[0] = 0;
+                for (var i = 0, l = spacesCount - 1; i < l; i++) {
+                    var bone = bones[i];
+                    bone.updateByConstraint();
+                    var boneLength = bone._boneData.length;
+                    var matrix = bone.globalTransformMatrix;
+                    var x = boneLength * matrix.a;
+                    var y = boneLength * matrix.b;
+                    var len = Math.sqrt(x * x + y * y);
+                    if (isChainScaleMode) {
+                        this._boneLengths[i] = len;
+                    }
+                    spaces[i + 1] = (boneLength + spacing) * len / boneLength;
+                }
+            }
+            else {
+                for (var i = 0; i < spacesCount; i++) {
+                    spaces[i] = spacing;
+                }
+            }
+            //
+            this._computeBezierCurve(pathDisplayData, spacesCount, isTangentMode, positionMode === 1 /* Percent */, spacingMode === 2 /* Percent */);
+            //根据新的节点数据重新采样
+            var positions = this._positions;
+            var rotateOffset = this.rotateOffset;
+            var boneX = positions[0], boneY = positions[1];
+            var tip;
+            if (rotateOffset === 0) {
+                tip = rotateMode === 1 /* Chain */;
+            }
+            else {
+                tip = false;
+                var bone = pathSlot.parent;
+                if (bone !== null) {
+                    var matrix = bone.globalTransformMatrix;
+                    rotateOffset *= matrix.a * matrix.d - matrix.b * matrix.c > 0 ? dragonBones.Transform.DEG_RAD : -dragonBones.Transform.DEG_RAD;
+                }
+            }
+            //
+            var rotateMix = this.rotateMix;
+            var translateMix = this.translateMix;
+            for (var i = 0, p = 3; i < boneCount; i++, p += 3) {
+                var bone = bones[i];
+                bone.updateByConstraint();
+                var matrix = bone.globalTransformMatrix;
+                matrix.tx += (boneX - matrix.tx) * translateMix;
+                matrix.ty += (boneY - matrix.ty) * translateMix;
+                var x = positions[p], y = positions[p + 1];
+                var dx = x - boneX, dy = y - boneY;
+                if (isChainScaleMode) {
+                    var lenght = this._boneLengths[i];
+                    var s = (Math.sqrt(dx * dx + dy * dy) / lenght - 1) * rotateMix + 1;
+                    matrix.a *= s;
+                    matrix.b *= s;
+                }
+                boneX = x;
+                boneY = y;
+                if (rotateMix > 0) {
+                    var a = matrix.a, b = matrix.b, c = matrix.c, d = matrix.d, r = void 0, cos = void 0, sin = void 0;
+                    if (isTangentMode) {
+                        r = positions[p - 1];
+                    }
+                    else {
+                        r = Math.atan2(dy, dx);
+                    }
+                    r -= Math.atan2(b, a);
+                    if (tip) {
+                        cos = Math.cos(r);
+                        sin = Math.sin(r);
+                        var length_3 = bone._boneData.length;
+                        boneX += (length_3 * (cos * a - sin * b) - dx) * rotateMix;
+                        boneY += (length_3 * (sin * a + cos * b) - dy) * rotateMix;
+                    }
+                    else {
+                        r += rotateOffset;
+                    }
+                    if (r > dragonBones.Transform.PI) {
+                        r -= dragonBones.Transform.PI_D;
+                    }
+                    else if (r < -dragonBones.Transform.PI) {
+                        r += dragonBones.Transform.PI_D;
+                    }
+                    r *= rotateMix;
+                    cos = Math.cos(r);
+                    sin = Math.sin(r);
+                    matrix.a = cos * a - sin * b;
+                    matrix.b = sin * a + cos * b;
+                    matrix.c = cos * c - sin * d;
+                    matrix.d = sin * c + cos * d;
+                }
+                bone.global.fromMatrix(matrix);
+            }
+            this.dirty = false;
+        };
+        PathConstraint.prototype.invalidUpdate = function () {
+        };
+        return PathConstraint;
+    }(Constraint));
+    dragonBones.PathConstraint = PathConstraint;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - Worldclock provides clock support for animations, advance time for each IAnimatable object added to the instance.
+     * @see dragonBones.IAnimateble
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - WorldClock 对动画提供时钟支持，为每个加入到该实例的 IAnimatable 对象更新时间。
+     * @see dragonBones.IAnimateble
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var WorldClock = /** @class */ (function () {
+        /**
+         * - Creating a Worldclock instance. Typically, you do not need to create Worldclock instance.
+         * When multiple Worldclock instances are running at different speeds, can achieving some specific animation effects, such as bullet time.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建一个 WorldClock 实例。通常并不需要创建 WorldClock 实例。
+         * 当多个 WorldClock 实例使用不同的速度运行时，可以实现一些特殊的动画效果，比如子弹时间等。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        function WorldClock(time) {
+            if (time === void 0) { time = 0.0; }
+            /**
+             * - Current time. (In seconds)
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 当前的时间。 (以秒为单位)
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            this.time = 0.0;
+            /**
+             * - The play speed, used to control animation speed-shift play.
+             * [0: Stop play, (0~1): Slow play, 1: Normal play, (1~N): Fast play]
+             * @default 1.0
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 播放速度，用于控制动画变速播放。
+             * [0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+             * @default 1.0
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            this.timeScale = 1.0;
+            this._systemTime = 0.0;
+            this._animatebles = [];
+            this._clock = null;
+            this.time = time;
+            this._systemTime = new Date().getTime() * 0.001;
+        }
+        /**
+         * - Advance time for all IAnimatable instances.
+         * @param passedTime - Passed time. [-1: Automatically calculates the time difference between the current frame and the previous frame, [0~N): Passed time] (In seconds)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 为所有的 IAnimatable 实例更新时间。
+         * @param passedTime - 前进的时间。 [-1: 自动计算当前帧与上一帧的时间差, [0~N): 前进的时间] (以秒为单位)
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        WorldClock.prototype.advanceTime = function (passedTime) {
+            if (passedTime !== passedTime) {
+                passedTime = 0.0;
+            }
+            var currentTime = Date.now() * 0.001;
+            if (passedTime < 0.0) {
+                passedTime = currentTime - this._systemTime;
+            }
+            this._systemTime = currentTime;
+            if (this.timeScale !== 1.0) {
+                passedTime *= this.timeScale;
+            }
+            if (passedTime === 0.0) {
+                return;
+            }
+            if (passedTime < 0.0) {
+                this.time -= passedTime;
+            }
+            else {
+                this.time += passedTime;
+            }
+            var i = 0, r = 0, l = this._animatebles.length;
+            for (; i < l; ++i) {
+                var animatable = this._animatebles[i];
+                if (animatable !== null) {
+                    if (r > 0) {
+                        this._animatebles[i - r] = animatable;
+                        this._animatebles[i] = null;
+                    }
+                    animatable.advanceTime(passedTime);
+                }
+                else {
+                    r++;
+                }
+            }
+            if (r > 0) {
+                l = this._animatebles.length;
+                for (; i < l; ++i) {
+                    var animateble = this._animatebles[i];
+                    if (animateble !== null) {
+                        this._animatebles[i - r] = animateble;
+                    }
+                    else {
+                        r++;
+                    }
+                }
+                this._animatebles.length -= r;
+            }
+        };
+        /**
+         * - Check whether contains a specific instance of IAnimatable.
+         * @param value - The IAnimatable instance.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否包含特定的 IAnimatable 实例。
+         * @param value - IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        WorldClock.prototype.contains = function (value) {
+            if (value === this) {
+                return false;
+            }
+            var ancestor = value;
+            while (ancestor !== this && ancestor !== null) {
+                ancestor = ancestor.clock;
+            }
+            return ancestor === this;
+        };
+        /**
+         * - Add IAnimatable instance.
+         * @param value - The IAnimatable instance.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 添加 IAnimatable 实例。
+         * @param value - IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        WorldClock.prototype.add = function (value) {
+            if (this._animatebles.indexOf(value) < 0) {
+                this._animatebles.push(value);
+                value.clock = this;
+            }
+        };
+        /**
+         * - Removes a specified IAnimatable instance.
+         * @param value - The IAnimatable instance.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 移除特定的 IAnimatable 实例。
+         * @param value - IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        WorldClock.prototype.remove = function (value) {
+            var index = this._animatebles.indexOf(value);
+            if (index >= 0) {
+                this._animatebles[index] = null;
+                value.clock = null;
+            }
+        };
+        /**
+         * - Clear all IAnimatable instances.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 清除所有的 IAnimatable 实例。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        WorldClock.prototype.clear = function () {
+            for (var _i = 0, _a = this._animatebles; _i < _a.length; _i++) {
+                var animatable = _a[_i];
+                if (animatable !== null) {
+                    animatable.clock = null;
+                }
+            }
+        };
+        Object.defineProperty(WorldClock.prototype, "clock", {
+            /**
+             * @inheritDoc
+             */
+            get: function () {
+                return this._clock;
+            },
+            set: function (value) {
+                if (this._clock === value) {
+                    return;
+                }
+                if (this._clock !== null) {
+                    this._clock.remove(this);
+                }
+                this._clock = value;
+                if (this._clock !== null) {
+                    this._clock.add(this);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#clock}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#clock}。
+         * @deprecated
+         * @language zh_CN
+         */
+        WorldClock.clock = new WorldClock();
+        return WorldClock;
+    }());
+    dragonBones.WorldClock = WorldClock;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The animation player is used to play the animation data and manage the animation states.
+     * @see dragonBones.AnimationData
+     * @see dragonBones.AnimationState
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 动画播放器用来播放动画数据和管理动画状态。
+     * @see dragonBones.AnimationData
+     * @see dragonBones.AnimationState
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var Animation = /** @class */ (function (_super) {
+        __extends(Animation, _super);
+        function Animation() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._animationNames = [];
+            _this._animationStates = [];
+            _this._animations = {};
+            _this._animationConfig = null; // Initial value.
+            return _this;
+        }
+        Animation.toString = function () {
+            return "[class dragonBones.Animation]";
+        };
+        Animation.prototype._onClear = function () {
+            for (var _i = 0, _a = this._animationStates; _i < _a.length; _i++) {
+                var animationState = _a[_i];
+                animationState.returnToPool();
+            }
+            for (var k in this._animations) {
+                delete this._animations[k];
+            }
+            if (this._animationConfig !== null) {
+                this._animationConfig.returnToPool();
+            }
+            this.timeScale = 1.0;
+            this._lockUpdate = false;
+            this._animationDirty = false;
+            this._inheritTimeScale = 1.0;
+            this._animationNames.length = 0;
+            this._animationStates.length = 0;
+            //this._animations.clear();
+            this._armature = null; //
+            this._animationConfig = null; //
+            this._lastAnimationState = null;
+        };
+        Animation.prototype._fadeOut = function (animationConfig) {
+            switch (animationConfig.fadeOutMode) {
+                case 1 /* SameLayer */:
+                    for (var _i = 0, _a = this._animationStates; _i < _a.length; _i++) {
+                        var animationState = _a[_i];
+                        if (animationState._parent !== null) {
+                            continue;
+                        }
+                        if (animationState.layer === animationConfig.layer) {
+                            animationState.fadeOut(animationConfig.fadeOutTime, animationConfig.pauseFadeOut);
+                        }
+                    }
+                    break;
+                case 2 /* SameGroup */:
+                    for (var _b = 0, _c = this._animationStates; _b < _c.length; _b++) {
+                        var animationState = _c[_b];
+                        if (animationState._parent !== null) {
+                            continue;
+                        }
+                        if (animationState.group === animationConfig.group) {
+                            animationState.fadeOut(animationConfig.fadeOutTime, animationConfig.pauseFadeOut);
+                        }
+                    }
+                    break;
+                case 3 /* SameLayerAndGroup */:
+                    for (var _d = 0, _e = this._animationStates; _d < _e.length; _d++) {
+                        var animationState = _e[_d];
+                        if (animationState._parent !== null) {
+                            continue;
+                        }
+                        if (animationState.layer === animationConfig.layer &&
+                            animationState.group === animationConfig.group) {
+                            animationState.fadeOut(animationConfig.fadeOutTime, animationConfig.pauseFadeOut);
+                        }
+                    }
+                    break;
+                case 4 /* All */:
+                    for (var _f = 0, _g = this._animationStates; _f < _g.length; _f++) {
+                        var animationState = _g[_f];
+                        if (animationState._parent !== null) {
+                            continue;
+                        }
+                        animationState.fadeOut(animationConfig.fadeOutTime, animationConfig.pauseFadeOut);
+                    }
+                    break;
+                case 0 /* None */:
+                case 5 /* Single */:
+                default:
+                    break;
+            }
+        };
+        /**
+         * @internal
+         */
+        Animation.prototype.init = function (armature) {
+            if (this._armature !== null) {
+                return;
+            }
+            this._armature = armature;
+            this._animationConfig = dragonBones.BaseObject.borrowObject(dragonBones.AnimationConfig);
+        };
+        /**
+         * @internal
+         */
+        Animation.prototype.advanceTime = function (passedTime) {
+            if (passedTime < 0.0) {
+                passedTime = -passedTime;
+            }
+            if (this._armature.inheritAnimation && this._armature._parent !== null) {
+                this._inheritTimeScale = this._armature._parent._armature.animation._inheritTimeScale * this.timeScale;
+            }
+            else {
+                this._inheritTimeScale = this.timeScale;
+            }
+            if (this._inheritTimeScale !== 1.0) {
+                passedTime *= this._inheritTimeScale;
+            }
+            var animationStateCount = this._animationStates.length;
+            if (animationStateCount === 1) {
+                var animationState = this._animationStates[0];
+                if (animationState._fadeState > 0 && animationState._subFadeState > 0) {
+                    this._armature._dragonBones.bufferObject(animationState);
+                    this._animationStates.length = 0;
+                    this._lastAnimationState = null;
+                }
+                else {
+                    var animationData = animationState._animationData;
+                    var cacheFrameRate = animationData.cacheFrameRate;
+                    if (this._animationDirty && cacheFrameRate > 0.0) {
+                        this._animationDirty = false;
+                        for (var _i = 0, _a = this._armature.getBones(); _i < _a.length; _i++) {
+                            var bone = _a[_i];
+                            bone._cachedFrameIndices = animationData.getBoneCachedFrameIndices(bone.name);
+                        }
+                        for (var _b = 0, _c = this._armature.getSlots(); _b < _c.length; _b++) {
+                            var slot = _c[_b];
+                            var rawDisplayDatas = slot.rawDisplayDatas;
+                            if (rawDisplayDatas !== null && rawDisplayDatas.length > 0) {
+                                var rawDsplayData = rawDisplayDatas[0];
+                                if (rawDsplayData !== null) {
+                                    if (rawDsplayData.parent === this._armature.armatureData.defaultSkin) {
+                                        slot._cachedFrameIndices = animationData.getSlotCachedFrameIndices(slot.name);
+                                        continue;
+                                    }
+                                }
+                            }
+                            slot._cachedFrameIndices = null;
+                        }
+                    }
+                    animationState.advanceTime(passedTime, cacheFrameRate);
+                }
+            }
+            else if (animationStateCount > 1) {
+                for (var i = 0, r = 0; i < animationStateCount; ++i) {
+                    var animationState = this._animationStates[i];
+                    if (animationState._fadeState > 0 && animationState._subFadeState > 0) {
+                        r++;
+                        this._armature._dragonBones.bufferObject(animationState);
+                        this._animationDirty = true;
+                        if (this._lastAnimationState === animationState) {
+                            this._lastAnimationState = null;
+                        }
+                    }
+                    else {
+                        if (r > 0) {
+                            this._animationStates[i - r] = animationState;
+                        }
+                        animationState.advanceTime(passedTime, 0.0);
+                    }
+                    if (i === animationStateCount - 1 && r > 0) {
+                        this._animationStates.length -= r;
+                        if (this._lastAnimationState === null && this._animationStates.length > 0) {
+                            this._lastAnimationState = this._animationStates[this._animationStates.length - 1];
+                        }
+                    }
+                }
+                this._armature._cacheFrameIndex = -1;
+            }
+            else {
+                this._armature._cacheFrameIndex = -1;
+            }
+        };
+        /**
+         * - Clear all animations states.
+         * @see dragonBones.AnimationState
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除所有的动画状态。
+         * @see dragonBones.AnimationState
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.reset = function () {
+            for (var _i = 0, _a = this._animationStates; _i < _a.length; _i++) {
+                var animationState = _a[_i];
+                animationState.returnToPool();
+            }
+            this._animationDirty = false;
+            this._animationConfig.clear();
+            this._animationStates.length = 0;
+            this._lastAnimationState = null;
+        };
+        /**
+         * - Pause a specific animation state.
+         * @param animationName - The name of animation state. (If not set, it will pause all animations)
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 暂停指定动画状态的播放。
+         * @param animationName - 动画状态名称。 （如果未设置，则暂停所有动画）
+         * @see dragonBones.AnimationState
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Animation.prototype.stop = function (animationName) {
+            if (animationName === void 0) { animationName = null; }
+            if (animationName !== null) {
+                var animationState = this.getState(animationName);
+                if (animationState !== null) {
+                    animationState.stop();
+                }
+            }
+            else {
+                for (var _i = 0, _a = this._animationStates; _i < _a.length; _i++) {
+                    var animationState = _a[_i];
+                    animationState.stop();
+                }
+            }
+        };
+        /**
+         * - Play animation with a specific animation config.
+         * The API is still in the experimental phase and may encounter bugs or stability or compatibility issues when used.
+         * @param animationConfig - The animation config.
+         * @returns The playing animation state.
+         * @see dragonBones.AnimationConfig
+         * @beta
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        /**
+         * - 通过指定的动画配置来播放动画。
+         * 该 API 仍在实验阶段，使用时可能遭遇 bug 或稳定性或兼容性问题。
+         * @param animationConfig - 动画配置。
+         * @returns 播放的动画状态。
+         * @see dragonBones.AnimationConfig
+         * @beta
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        Animation.prototype.playConfig = function (animationConfig) {
+            var animationName = animationConfig.animation;
+            if (!(animationName in this._animations)) {
+                console.warn("Non-existent animation.\n", "DragonBones name: " + this._armature.armatureData.parent.name, "Armature name: " + this._armature.name, "Animation name: " + animationName);
+                return null;
+            }
+            var animationData = this._animations[animationName];
+            if (animationConfig.fadeOutMode === 5 /* Single */) {
+                for (var _i = 0, _a = this._animationStates; _i < _a.length; _i++) {
+                    var animationState_1 = _a[_i];
+                    if (animationState_1._animationData === animationData) {
+                        return animationState_1;
+                    }
+                }
+            }
+            if (this._animationStates.length === 0) {
+                animationConfig.fadeInTime = 0.0;
+            }
+            else if (animationConfig.fadeInTime < 0.0) {
+                animationConfig.fadeInTime = animationData.fadeInTime;
+            }
+            if (animationConfig.fadeOutTime < 0.0) {
+                animationConfig.fadeOutTime = animationConfig.fadeInTime;
+            }
+            if (animationConfig.timeScale <= -100.0) {
+                animationConfig.timeScale = 1.0 / animationData.scale;
+            }
+            if (animationData.frameCount > 1) {
+                if (animationConfig.position < 0.0) {
+                    animationConfig.position %= animationData.duration;
+                    animationConfig.position = animationData.duration - animationConfig.position;
+                }
+                else if (animationConfig.position === animationData.duration) {
+                    animationConfig.position -= 0.000001; // Play a little time before end.
+                }
+                else if (animationConfig.position > animationData.duration) {
+                    animationConfig.position %= animationData.duration;
+                }
+                if (animationConfig.duration > 0.0 && animationConfig.position + animationConfig.duration > animationData.duration) {
+                    animationConfig.duration = animationData.duration - animationConfig.position;
+                }
+                if (animationConfig.playTimes < 0) {
+                    animationConfig.playTimes = animationData.playTimes;
+                }
+            }
+            else {
+                animationConfig.playTimes = 1;
+                animationConfig.position = 0.0;
+                if (animationConfig.duration > 0.0) {
+                    animationConfig.duration = 0.0;
+                }
+            }
+            if (animationConfig.duration === 0.0) {
+                animationConfig.duration = -1.0;
+            }
+            this._fadeOut(animationConfig);
+            var animationState = dragonBones.BaseObject.borrowObject(dragonBones.AnimationState);
+            animationState.init(this._armature, animationData, animationConfig);
+            this._animationDirty = true;
+            this._armature._cacheFrameIndex = -1;
+            if (this._animationStates.length > 0) {
+                var added = false;
+                for (var i = 0, l = this._animationStates.length; i < l; ++i) {
+                    if (animationState.layer > this._animationStates[i].layer) {
+                        added = true;
+                        this._animationStates.splice(i, 0, animationState);
+                        break;
+                    }
+                    else if (i !== l - 1 && animationState.layer > this._animationStates[i + 1].layer) {
+                        added = true;
+                        this._animationStates.splice(i + 1, 0, animationState);
+                        break;
+                    }
+                }
+                if (!added) {
+                    this._animationStates.push(animationState);
+                }
+            }
+            else {
+                this._animationStates.push(animationState);
+            }
+            // Child armature play same name animation.
+            for (var _b = 0, _c = this._armature.getSlots(); _b < _c.length; _b++) {
+                var slot = _c[_b];
+                var childArmature = slot.childArmature;
+                if (childArmature !== null && childArmature.inheritAnimation &&
+                    childArmature.animation.hasAnimation(animationName) &&
+                    childArmature.animation.getState(animationName) === null) {
+                    childArmature.animation.fadeIn(animationName); //
+                }
+            }
+            var isLocked = false;
+            for (var k in animationData.animationTimelines) {
+                if (!this._lockUpdate) {
+                    isLocked = true;
+                    this._lockUpdate = true;
+                }
+                var childAnimatiionState = this.fadeIn(k, animationConfig.fadeInTime, 1, animationState.layer, null, 0 /* None */);
+                if (childAnimatiionState !== null) {
+                    childAnimatiionState.resetToPose = false;
+                    childAnimatiionState._parent = animationState;
+                    childAnimatiionState.stop();
+                }
+            }
+            if (isLocked) {
+                this._lockUpdate = false;
+            }
+            if (!this._lockUpdate) {
+                if (animationConfig.fadeInTime <= 0.0) {
+                    this._armature.advanceTime(0.0);
+                }
+                this._lastAnimationState = animationState;
+            }
+            return animationState;
+        };
+        /**
+         * - Play a specific animation.
+         * @param animationName - The name of animation data. (If not set, The default animation will be played, or resume the animation playing from pause status, or replay the last playing animation)
+         * @param playTimes - Playing repeat times. [-1: Use default value of the animation data, 0: No end loop playing, [1~N]: Repeat N times] (default: -1)
+         * @returns The playing animation state.
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 播放指定动画。
+         * @param animationName - 动画数据名称。 （如果未设置，则播放默认动画，或将暂停状态切换为播放状态，或重新播放之前播放的动画）
+         * @param playTimes - 循环播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Animation.prototype.play = function (animationName, playTimes) {
+            if (animationName === void 0) { animationName = null; }
+            if (playTimes === void 0) { playTimes = -1; }
+            this._animationConfig.clear();
+            this._animationConfig.resetToPose = true;
+            this._animationConfig.playTimes = playTimes;
+            this._animationConfig.fadeInTime = 0.0;
+            this._animationConfig.animation = animationName !== null ? animationName : "";
+            if (animationName !== null && animationName.length > 0) {
+                this.playConfig(this._animationConfig);
+            }
+            else if (this._lastAnimationState === null) {
+                var defaultAnimation = this._armature.armatureData.defaultAnimation;
+                if (defaultAnimation !== null) {
+                    this._animationConfig.animation = defaultAnimation.name;
+                    this.playConfig(this._animationConfig);
+                }
+            }
+            else if (!this._lastAnimationState.isPlaying && !this._lastAnimationState.isCompleted) {
+                this._lastAnimationState.play();
+            }
+            else {
+                this._animationConfig.animation = this._lastAnimationState.name;
+                this.playConfig(this._animationConfig);
+            }
+            return this._lastAnimationState;
+        };
+        /**
+         * - Fade in a specific animation.
+         * @param animationName - The name of animation data.
+         * @param fadeInTime - The fade in time. [-1: Use the default value of animation data, [0~N]: The fade in time (In seconds)] (Default: -1)
+         * @param playTimes - playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @param layer - The blending layer, the animation states in high level layer will get the blending weights with high priority, when the total blending weights are more than 1.0, there will be no more weights can be allocated to the other animation states. (Default: 0)
+         * @param group - The blending group name, it is typically used to specify the substitution of multiple animation states blending. (Default: null)
+         * @param fadeOutMode - The fade out mode, which is typically used to specify alternate mode of multiple animation states blending. (Default: AnimationFadeOutMode.SameLayerAndGroup)
+         * @returns The playing animation state.
+         * @example
+         * <pre>
+         *     armature.animation.fadeIn("walk", 0.3, 0, 0, "normalGroup").resetToPose = false;
+         *     armature.animation.fadeIn("attack", 0.3, 1, 0, "attackGroup").resetToPose = false;
+         * </pre>
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 淡入播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param fadeInTime - 淡入时间。 [-1: 使用动画数据默认值, [0~N]: 淡入时间 (以秒为单位)] （默认: -1）
+         * @param playTimes - 播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @param layer - 混合图层，图层高的动画状态会优先获取混合权重，当混合权重分配总和超过 1.0 时，剩余的动画状态将不能再获得权重分配。 （默认: 0）
+         * @param group - 混合组名称，该属性通常用来指定多个动画状态混合时的相互替换关系。 （默认: null）
+         * @param fadeOutMode - 淡出模式，该属性通常用来指定多个动画状态混合时的相互替换模式。 （默认: AnimationFadeOutMode.SameLayerAndGroup）
+         * @returns 播放的动画状态。
+         * @example
+         * <pre>
+         *     armature.animation.fadeIn("walk", 0.3, 0, 0, "normalGroup").resetToPose = false;
+         *     armature.animation.fadeIn("attack", 0.3, 1, 0, "attackGroup").resetToPose = false;
+         * </pre>
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.fadeIn = function (animationName, fadeInTime, playTimes, layer, group, fadeOutMode) {
+            if (fadeInTime === void 0) { fadeInTime = -1.0; }
+            if (playTimes === void 0) { playTimes = -1; }
+            if (layer === void 0) { layer = 0; }
+            if (group === void 0) { group = null; }
+            if (fadeOutMode === void 0) { fadeOutMode = 3 /* SameLayerAndGroup */; }
+            this._animationConfig.clear();
+            this._animationConfig.fadeOutMode = fadeOutMode;
+            this._animationConfig.playTimes = playTimes;
+            this._animationConfig.layer = layer;
+            this._animationConfig.fadeInTime = fadeInTime;
+            this._animationConfig.animation = animationName;
+            this._animationConfig.group = group !== null ? group : "";
+            return this.playConfig(this._animationConfig);
+        };
+        /**
+         * - Play a specific animation from the specific time.
+         * @param animationName - The name of animation data.
+         * @param time - The start time point of playing. (In seconds)
+         * @param playTimes - Playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从指定时间开始播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param time - 播放开始的时间。 (以秒为单位)
+         * @param playTimes - 循环播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndPlayByTime = function (animationName, time, playTimes) {
+            if (time === void 0) { time = 0.0; }
+            if (playTimes === void 0) { playTimes = -1; }
+            this._animationConfig.clear();
+            this._animationConfig.resetToPose = true;
+            this._animationConfig.playTimes = playTimes;
+            this._animationConfig.position = time;
+            this._animationConfig.fadeInTime = 0.0;
+            this._animationConfig.animation = animationName;
+            return this.playConfig(this._animationConfig);
+        };
+        /**
+         * - Play a specific animation from the specific frame.
+         * @param animationName - The name of animation data.
+         * @param frame - The start frame of playing.
+         * @param playTimes - Playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从指定帧开始播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param frame - 播放开始的帧数。
+         * @param playTimes - 播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndPlayByFrame = function (animationName, frame, playTimes) {
+            if (frame === void 0) { frame = 0; }
+            if (playTimes === void 0) { playTimes = -1; }
+            this._animationConfig.clear();
+            this._animationConfig.resetToPose = true;
+            this._animationConfig.playTimes = playTimes;
+            this._animationConfig.fadeInTime = 0.0;
+            this._animationConfig.animation = animationName;
+            var animationData = animationName in this._animations ? this._animations[animationName] : null;
+            if (animationData !== null) {
+                this._animationConfig.position = animationData.duration * frame / animationData.frameCount;
+            }
+            return this.playConfig(this._animationConfig);
+        };
+        /**
+         * - Play a specific animation from the specific progress.
+         * @param animationName - The name of animation data.
+         * @param progress - The start progress value of playing.
+         * @param playTimes - Playing repeat times. [-1: Use the default value of animation data, 0: No end loop playing, [1~N]: Repeat N times] (Default: -1)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 从指定进度开始播放指定的动画。
+         * @param animationName - 动画数据名称。
+         * @param progress - 开始播放的进度。
+         * @param playTimes - 播放次数。 [-1: 使用动画数据默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次] （默认: -1）
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndPlayByProgress = function (animationName, progress, playTimes) {
+            if (progress === void 0) { progress = 0.0; }
+            if (playTimes === void 0) { playTimes = -1; }
+            this._animationConfig.clear();
+            this._animationConfig.resetToPose = true;
+            this._animationConfig.playTimes = playTimes;
+            this._animationConfig.fadeInTime = 0.0;
+            this._animationConfig.animation = animationName;
+            var animationData = animationName in this._animations ? this._animations[animationName] : null;
+            if (animationData !== null) {
+                this._animationConfig.position = animationData.duration * (progress > 0.0 ? progress : 0.0);
+            }
+            return this.playConfig(this._animationConfig);
+        };
+        /**
+         * - Stop a specific animation at the specific time.
+         * @param animationName - The name of animation data.
+         * @param time - The stop time. (In seconds)
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 在指定时间停止指定动画播放
+         * @param animationName - 动画数据名称。
+         * @param time - 停止的时间。 (以秒为单位)
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndStopByTime = function (animationName, time) {
+            if (time === void 0) { time = 0.0; }
+            var animationState = this.gotoAndPlayByTime(animationName, time, 1);
+            if (animationState !== null) {
+                animationState.stop();
+            }
+            return animationState;
+        };
+        /**
+         * - Stop a specific animation at the specific frame.
+         * @param animationName - The name of animation data.
+         * @param frame - The stop frame.
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 在指定帧停止指定动画的播放
+         * @param animationName - 动画数据名称。
+         * @param frame - 停止的帧数。
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndStopByFrame = function (animationName, frame) {
+            if (frame === void 0) { frame = 0; }
+            var animationState = this.gotoAndPlayByFrame(animationName, frame, 1);
+            if (animationState !== null) {
+                animationState.stop();
+            }
+            return animationState;
+        };
+        /**
+         * - Stop a specific animation at the specific progress.
+         * @param animationName - The name of animation data.
+         * @param progress - The stop progress value.
+         * @returns The played animation state.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 在指定的进度停止指定的动画播放。
+         * @param animationName - 动画数据名称。
+         * @param progress - 停止进度。
+         * @returns 播放的动画状态。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndStopByProgress = function (animationName, progress) {
+            if (progress === void 0) { progress = 0.0; }
+            var animationState = this.gotoAndPlayByProgress(animationName, progress, 1);
+            if (animationState !== null) {
+                animationState.stop();
+            }
+            return animationState;
+        };
+        /**
+         * - Get a specific animation state.
+         * @param animationName - The name of animation state.
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         *     let walkState = armature.animation.getState("walk");
+         *     walkState.timeScale = 0.5;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取指定的动画状态
+         * @param animationName - 动画状态名称。
+         * @example
+         * <pre>
+         *     armature.animation.play("walk");
+         *     let walkState = armature.animation.getState("walk");
+         *     walkState.timeScale = 0.5;
+         * </pre>
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Animation.prototype.getState = function (animationName) {
+            var i = this._animationStates.length;
+            while (i--) {
+                var animationState = this._animationStates[i];
+                if (animationState.name === animationName) {
+                    return animationState;
+                }
+            }
+            return null;
+        };
+        /**
+         * - Check whether a specific animation data is included.
+         * @param animationName - The name of animation data.
+         * @see dragonBones.AnimationData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否包含指定的动画数据
+         * @param animationName - 动画数据名称。
+         * @see dragonBones.AnimationData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Animation.prototype.hasAnimation = function (animationName) {
+            return animationName in this._animations;
+        };
+        /**
+         * - Get all the animation states.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 获取所有的动画状态
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        Animation.prototype.getStates = function () {
+            return this._animationStates;
+        };
+        Object.defineProperty(Animation.prototype, "isPlaying", {
+            /**
+             * - Check whether there is an animation state is playing
+             * @see dragonBones.AnimationState
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 检查是否有动画状态正在播放
+             * @see dragonBones.AnimationState
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                for (var _i = 0, _a = this._animationStates; _i < _a.length; _i++) {
+                    var animationState = _a[_i];
+                    if (animationState.isPlaying) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Animation.prototype, "isCompleted", {
+            /**
+             * - Check whether all the animation states' playing were finished.
+             * @see dragonBones.AnimationState
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 检查是否所有的动画状态均已播放完毕。
+             * @see dragonBones.AnimationState
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                for (var _i = 0, _a = this._animationStates; _i < _a.length; _i++) {
+                    var animationState = _a[_i];
+                    if (!animationState.isCompleted) {
+                        return false;
+                    }
+                }
+                return this._animationStates.length > 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Animation.prototype, "lastAnimationName", {
+            /**
+             * - The name of the last playing animation state.
+             * @see #lastAnimationState
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 上一个播放的动画状态名称
+             * @see #lastAnimationState
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._lastAnimationState !== null ? this._lastAnimationState.name : "";
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Animation.prototype, "animationNames", {
+            /**
+             * - The name of all animation data
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 所有动画数据的名称
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._animationNames;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Animation.prototype, "animations", {
+            /**
+             * - All animation data.
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 所有的动画数据。
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._animations;
+            },
+            set: function (value) {
+                if (this._animations === value) {
+                    return;
+                }
+                this._animationNames.length = 0;
+                for (var k in this._animations) {
+                    delete this._animations[k];
+                }
+                for (var k in value) {
+                    this._animationNames.push(k);
+                    this._animations[k] = value[k];
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Animation.prototype, "animationConfig", {
+            /**
+             * - An AnimationConfig instance that can be used quickly.
+             * @see dragonBones.AnimationConfig
+             * @version DragonBones 5.0
+             * @language en_US
+             */
+            /**
+             * - 一个可以快速使用的动画配置实例。
+             * @see dragonBones.AnimationConfig
+             * @version DragonBones 5.0
+             * @language zh_CN
+             */
+            get: function () {
+                this._animationConfig.clear();
+                return this._animationConfig;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Animation.prototype, "lastAnimationState", {
+            /**
+             * - The last playing animation state
+             * @see dragonBones.AnimationState
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 上一个播放的动画状态
+             * @see dragonBones.AnimationState
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._lastAnimationState;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link #play()} {@link #fadeIn()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #play()} {@link #fadeIn()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndPlay = function (animationName, fadeInTime, duration, playTimes, layer, group, fadeOutMode, pauseFadeOut, pauseFadeIn) {
+            if (fadeInTime === void 0) { fadeInTime = -1; }
+            if (duration === void 0) { duration = -1; }
+            if (playTimes === void 0) { playTimes = -1; }
+            if (layer === void 0) { layer = 0; }
+            if (group === void 0) { group = null; }
+            if (fadeOutMode === void 0) { fadeOutMode = 3 /* SameLayerAndGroup */; }
+            if (pauseFadeOut === void 0) { pauseFadeOut = true; }
+            if (pauseFadeIn === void 0) { pauseFadeIn = true; }
+            console.warn("Deprecated.");
+            // tslint:disable-next-line:no-unused-expression
+            pauseFadeOut;
+            // tslint:disable-next-line:no-unused-expression
+            pauseFadeIn;
+            this._animationConfig.clear();
+            this._animationConfig.resetToPose = true;
+            this._animationConfig.fadeOutMode = fadeOutMode;
+            this._animationConfig.playTimes = playTimes;
+            this._animationConfig.layer = layer;
+            this._animationConfig.fadeInTime = fadeInTime;
+            this._animationConfig.animation = animationName;
+            this._animationConfig.group = group !== null ? group : "";
+            var animationData = this._animations[animationName];
+            if (animationData && duration > 0.0) {
+                this._animationConfig.timeScale = animationData.duration / duration;
+            }
+            return this.playConfig(this._animationConfig);
+        };
+        /**
+         * - Deprecated, please refer to {@link #gotoAndStopByTime()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #gotoAndStopByTime()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Animation.prototype.gotoAndStop = function (animationName, time) {
+            if (time === void 0) { time = 0; }
+            console.warn("Deprecated.");
+            return this.gotoAndStopByTime(animationName, time);
+        };
+        Object.defineProperty(Animation.prototype, "animationList", {
+            /**
+             * - Deprecated, please refer to {@link #animationNames}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #animationNames}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                console.warn("Deprecated.");
+                return this._animationNames;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Animation.prototype, "animationDataList", {
+            /**
+             * - Deprecated, please refer to {@link #animationNames}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #animationNames}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                console.warn("Deprecated.");
+                var list = [];
+                for (var i = 0, l = this._animationNames.length; i < l; ++i) {
+                    list.push(this._animations[this._animationNames[i]]);
+                }
+                return list;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return Animation;
+    }(dragonBones.BaseObject));
+    dragonBones.Animation = Animation;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The animation state is generated when the animation data is played.
+     * @see dragonBones.Animation
+     * @see dragonBones.AnimationData
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 动画状态由播放动画数据时产生。
+     * @see dragonBones.Animation
+     * @see dragonBones.AnimationData
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var AnimationState = /** @class */ (function (_super) {
+        __extends(AnimationState, _super);
+        function AnimationState() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @internal
+             */
+            _this._blendState = new BlendState();
+            _this._boneMask = [];
+            _this._boneTimelines = [];
+            _this._surfaceTimelines = [];
+            _this._slotTimelines = [];
+            _this._constraintTimelines = [];
+            _this._animationTimelines = [];
+            _this._poseTimelines = [];
+            _this._bonePoses = {};
+            /**
+             * @internal
+             */
+            _this._actionTimeline = null; // Initial value.
+            _this._zOrderTimeline = null; // Initial value.
+            /**
+             * @internal
+             */
+            _this._parent = null; // Initial value.
+            return _this;
+        }
+        AnimationState.toString = function () {
+            return "[class dragonBones.AnimationState]";
+        };
+        AnimationState.prototype._onClear = function () {
+            for (var _i = 0, _a = this._boneTimelines; _i < _a.length; _i++) {
+                var timeline = _a[_i];
+                timeline.returnToPool();
+            }
+            for (var _b = 0, _c = this._surfaceTimelines; _b < _c.length; _b++) {
+                var timeline = _c[_b];
+                timeline.returnToPool();
+            }
+            for (var _d = 0, _e = this._slotTimelines; _d < _e.length; _d++) {
+                var timeline = _e[_d];
+                timeline.returnToPool();
+            }
+            for (var _f = 0, _g = this._constraintTimelines; _f < _g.length; _f++) {
+                var timeline = _g[_f];
+                timeline.returnToPool();
+            }
+            for (var _h = 0, _j = this._animationTimelines; _h < _j.length; _h++) {
+                var timeline = _j[_h];
+                timeline.returnToPool();
+            }
+            for (var k in this._bonePoses) {
+                this._bonePoses[k].returnToPool();
+                delete this._bonePoses[k];
+            }
+            if (this._actionTimeline !== null) {
+                this._actionTimeline.returnToPool();
+            }
+            if (this._zOrderTimeline !== null) {
+                this._zOrderTimeline.returnToPool();
+            }
+            this.actionEnabled = false;
+            this.additiveBlending = false;
+            this.displayControl = false;
+            this.resetToPose = false;
+            this.playTimes = 1;
+            this.layer = 0;
+            this.timeScale = 1.0;
+            this.weight = 1.0;
+            this.autoFadeOutTime = 0.0;
+            this.fadeTotalTime = 0.0;
+            this.name = "";
+            this.group = "";
+            this._timelineDirty = 2;
+            this._playheadState = 0;
+            this._fadeState = -1;
+            this._subFadeState = -1;
+            this._position = 0.0;
+            this._duration = 0.0;
+            this._fadeTime = 0.0;
+            this._time = 0.0;
+            this._fadeProgress = 0.0;
+            this._weightResult = 0.0;
+            this._blendState.clear();
+            this._boneMask.length = 0;
+            this._boneTimelines.length = 0;
+            this._surfaceTimelines.length = 0;
+            this._slotTimelines.length = 0;
+            this._constraintTimelines.length = 0;
+            this._animationTimelines.length = 0;
+            this._poseTimelines.length = 0;
+            // this._bonePoses.clear();
+            this._animationData = null; //
+            this._armature = null; //
+            this._actionTimeline = null; //
+            this._zOrderTimeline = null;
+            this._parent = null; //
+        };
+        AnimationState.prototype._updateTimelines = function () {
+            {
+                for (var _i = 0, _a = this._armature._constraints; _i < _a.length; _i++) {
+                    var constraint = _a[_i];
+                    var timelineDatas = this._animationData.getConstraintTimelines(constraint.name);
+                    if (timelineDatas !== null) {
+                        for (var _b = 0, timelineDatas_1 = timelineDatas; _b < timelineDatas_1.length; _b++) {
+                            var timelineData = timelineDatas_1[_b];
+                            switch (timelineData.type) {
+                                case 30 /* IKConstraint */: {
+                                    var timeline = dragonBones.BaseObject.borrowObject(dragonBones.IKConstraintTimelineState);
+                                    timeline.constraint = constraint;
+                                    timeline.init(this._armature, this, timelineData);
+                                    this._constraintTimelines.push(timeline);
+                                    break;
+                                }
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                    else if (this.resetToPose) {
+                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.IKConstraintTimelineState);
+                        timeline.constraint = constraint;
+                        timeline.init(this._armature, this, null);
+                        this._constraintTimelines.push(timeline);
+                        this._poseTimelines.push(timeline);
+                    }
+                }
+            }
+            {
+                for (var _c = 0, _d = this._armature.animation.getStates(); _c < _d.length; _c++) {
+                    var animationState = _d[_c];
+                    if (animationState._parent !== this) {
+                        continue;
+                    }
+                    var timelineDatas = this._animationData.getAnimationTimelines(animationState.name);
+                    if (timelineDatas === null) {
+                        continue;
+                    }
+                    for (var _e = 0, timelineDatas_2 = timelineDatas; _e < timelineDatas_2.length; _e++) {
+                        var timelineData = timelineDatas_2[_e];
+                        switch (timelineData.type) {
+                            case 40 /* AnimationTime */: {
+                                var timeline = dragonBones.BaseObject.borrowObject(dragonBones.AnimationTimelineState);
+                                timeline.animationState = animationState;
+                                timeline.init(this._armature, this, timelineData);
+                                this._animationTimelines.push(timeline);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                    }
+                }
+            }
+        };
+        AnimationState.prototype._updateBoneAndSlotTimelines = function () {
+            {
+                var boneTimelines = {};
+                for (var _i = 0, _a = this._boneTimelines; _i < _a.length; _i++) {
+                    var timeline = _a[_i];
+                    var timelineName = timeline.bone.name;
+                    if (!(timelineName in boneTimelines)) {
+                        boneTimelines[timelineName] = [];
+                    }
+                    boneTimelines[timelineName].push(timeline);
+                }
+                for (var _b = 0, _c = this._armature.getBones(); _b < _c.length; _b++) {
+                    var bone = _c[_b];
+                    var timelineName = bone.name;
+                    if (!this.containsBoneMask(timelineName)) {
+                        continue;
+                    }
+                    if (timelineName in boneTimelines) {
+                        delete boneTimelines[timelineName];
+                    }
+                    else if (bone._boneData.type === 0 /* Bone */) {
+                        var timelineDatas = this._animationData.getBoneTimelines(timelineName);
+                        var bonePose = timelineName in this._bonePoses ? this._bonePoses[timelineName] : (this._bonePoses[timelineName] = dragonBones.BaseObject.borrowObject(BonePose));
+                        if (timelineDatas !== null) {
+                            for (var _d = 0, timelineDatas_3 = timelineDatas; _d < timelineDatas_3.length; _d++) {
+                                var timelineData = timelineDatas_3[_d];
+                                switch (timelineData.type) {
+                                    case 10 /* BoneAll */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.BoneAllTimelineState);
+                                        timeline.bone = bone;
+                                        timeline.bonePose = bonePose;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._boneTimelines.push(timeline);
+                                        break;
+                                    }
+                                    case 11 /* BoneTranslate */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.BoneTranslateTimelineState);
+                                        timeline.bone = bone;
+                                        timeline.bonePose = bonePose;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._boneTimelines.push(timeline);
+                                        break;
+                                    }
+                                    case 12 /* BoneRotate */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.BoneRotateTimelineState);
+                                        timeline.bone = bone;
+                                        timeline.bonePose = bonePose;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._boneTimelines.push(timeline);
+                                        break;
+                                    }
+                                    case 13 /* BoneScale */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.BoneScaleTimelineState);
+                                        timeline.bone = bone;
+                                        timeline.bonePose = bonePose;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._boneTimelines.push(timeline);
+                                        break;
+                                    }
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                        else if (this.resetToPose) {
+                            var timeline = dragonBones.BaseObject.borrowObject(dragonBones.BoneAllTimelineState);
+                            timeline.bone = bone;
+                            timeline.bonePose = bonePose;
+                            timeline.init(this._armature, this, null);
+                            this._boneTimelines.push(timeline);
+                            this._poseTimelines.push(timeline);
+                        }
+                    }
+                    else if (bone._boneData.type === 1 /* Surface */) {
+                        var timelineDatas = this._animationData.getSurfaceTimelines(timelineName);
+                        if (timelineDatas !== null) {
+                            for (var _e = 0, timelineDatas_4 = timelineDatas; _e < timelineDatas_4.length; _e++) {
+                                var timelineData = timelineDatas_4[_e];
+                                switch (timelineData.type) {
+                                    case 50 /* Surface */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.SurfaceTimelineState);
+                                        timeline.surface = bone;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._surfaceTimelines.push(timeline);
+                                        break;
+                                    }
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                        else if (this.resetToPose) {
+                            var timeline = dragonBones.BaseObject.borrowObject(dragonBones.SurfaceTimelineState);
+                            timeline.surface = bone;
+                            timeline.init(this._armature, this, null);
+                            this._surfaceTimelines.push(timeline);
+                            this._poseTimelines.push(timeline);
+                        }
+                    }
+                }
+                for (var k in boneTimelines) {
+                    for (var _f = 0, _g = boneTimelines[k]; _f < _g.length; _f++) {
+                        var timeline = _g[_f];
+                        this._boneTimelines.splice(this._boneTimelines.indexOf(timeline), 1);
+                        timeline.returnToPool();
+                    }
+                }
+            }
+            {
+                var slotTimelines = {};
+                var ffdFlags = [];
+                for (var _h = 0, _j = this._slotTimelines; _h < _j.length; _h++) {
+                    var timeline = _j[_h];
+                    var timelineName = timeline.slot.name;
+                    if (!(timelineName in slotTimelines)) {
+                        slotTimelines[timelineName] = [];
+                    }
+                    slotTimelines[timelineName].push(timeline);
+                }
+                for (var _k = 0, _l = this._armature.getSlots(); _k < _l.length; _k++) {
+                    var slot = _l[_k];
+                    var boneName = slot.parent.name;
+                    if (!this.containsBoneMask(boneName)) {
+                        continue;
+                    }
+                    var timelineName = slot.name;
+                    var timelineDatas = this._animationData.getSlotTimelines(timelineName);
+                    if (timelineName in slotTimelines) {
+                        delete slotTimelines[timelineName];
+                    }
+                    else {
+                        var displayIndexFlag = false;
+                        var colorFlag = false;
+                        ffdFlags.length = 0;
+                        if (timelineDatas !== null) {
+                            for (var _m = 0, timelineDatas_5 = timelineDatas; _m < timelineDatas_5.length; _m++) {
+                                var timelineData = timelineDatas_5[_m];
+                                switch (timelineData.type) {
+                                    case 20 /* SlotDisplay */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.SlotDislayTimelineState);
+                                        timeline.slot = slot;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._slotTimelines.push(timeline);
+                                        displayIndexFlag = true;
+                                        break;
+                                    }
+                                    case 21 /* SlotColor */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.SlotColorTimelineState);
+                                        timeline.slot = slot;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._slotTimelines.push(timeline);
+                                        colorFlag = true;
+                                        break;
+                                    }
+                                    case 22 /* SlotDeform */: {
+                                        var timeline = dragonBones.BaseObject.borrowObject(dragonBones.DeformTimelineState);
+                                        timeline.slot = slot;
+                                        timeline.init(this._armature, this, timelineData);
+                                        this._slotTimelines.push(timeline);
+                                        ffdFlags.push(timeline.vertexOffset);
+                                        break;
+                                    }
+                                    default:
+                                        break;
+                                }
+                            }
+                        }
+                        if (this.resetToPose) {
+                            if (!displayIndexFlag) {
+                                var timeline = dragonBones.BaseObject.borrowObject(dragonBones.SlotDislayTimelineState);
+                                timeline.slot = slot;
+                                timeline.init(this._armature, this, null);
+                                this._slotTimelines.push(timeline);
+                                this._poseTimelines.push(timeline);
+                            }
+                            if (!colorFlag) {
+                                var timeline = dragonBones.BaseObject.borrowObject(dragonBones.SlotColorTimelineState);
+                                timeline.slot = slot;
+                                timeline.init(this._armature, this, null);
+                                this._slotTimelines.push(timeline);
+                                this._poseTimelines.push(timeline);
+                            }
+                            if (slot.rawDisplayDatas !== null) {
+                                for (var _o = 0, _p = slot.rawDisplayDatas; _o < _p.length; _o++) {
+                                    var displayData = _p[_o];
+                                    if (displayData !== null && displayData.type === 2 /* Mesh */) {
+                                        var meshOffset = displayData.vertices.offset;
+                                        if (ffdFlags.indexOf(meshOffset) < 0) {
+                                            var timeline = dragonBones.BaseObject.borrowObject(dragonBones.DeformTimelineState);
+                                            timeline.vertexOffset = meshOffset; //
+                                            timeline.slot = slot;
+                                            timeline.init(this._armature, this, null);
+                                            this._slotTimelines.push(timeline);
+                                            this._poseTimelines.push(timeline);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                for (var k in slotTimelines) {
+                    for (var _q = 0, _r = slotTimelines[k]; _q < _r.length; _q++) {
+                        var timeline = _r[_q];
+                        this._slotTimelines.splice(this._slotTimelines.indexOf(timeline), 1);
+                        timeline.returnToPool();
+                    }
+                }
+            }
+        };
+        AnimationState.prototype._advanceFadeTime = function (passedTime) {
+            var isFadeOut = this._fadeState > 0;
+            if (this._subFadeState < 0) {
+                this._subFadeState = 0;
+                var eventType = isFadeOut ? dragonBones.EventObject.FADE_OUT : dragonBones.EventObject.FADE_IN;
+                if (this._armature.eventDispatcher.hasDBEventListener(eventType)) {
+                    var eventObject = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                    eventObject.type = eventType;
+                    eventObject.armature = this._armature;
+                    eventObject.animationState = this;
+                    this._armature._dragonBones.bufferEvent(eventObject);
+                }
+            }
+            if (passedTime < 0.0) {
+                passedTime = -passedTime;
+            }
+            this._fadeTime += passedTime;
+            if (this._fadeTime >= this.fadeTotalTime) {
+                this._subFadeState = 1;
+                this._fadeProgress = isFadeOut ? 0.0 : 1.0;
+            }
+            else if (this._fadeTime > 0.0) {
+                this._fadeProgress = isFadeOut ? (1.0 - this._fadeTime / this.fadeTotalTime) : (this._fadeTime / this.fadeTotalTime);
+            }
+            else {
+                this._fadeProgress = isFadeOut ? 1.0 : 0.0;
+            }
+            if (this._subFadeState > 0) {
+                if (!isFadeOut) {
+                    this._playheadState |= 1; // x1
+                    this._fadeState = 0;
+                }
+                var eventType = isFadeOut ? dragonBones.EventObject.FADE_OUT_COMPLETE : dragonBones.EventObject.FADE_IN_COMPLETE;
+                if (this._armature.eventDispatcher.hasDBEventListener(eventType)) {
+                    var eventObject = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                    eventObject.type = eventType;
+                    eventObject.armature = this._armature;
+                    eventObject.animationState = this;
+                    this._armature._dragonBones.bufferEvent(eventObject);
+                }
+            }
+        };
+        /**
+         * @internal
+         */
+        AnimationState.prototype.init = function (armature, animationData, animationConfig) {
+            if (this._armature !== null) {
+                return;
+            }
+            this._armature = armature;
+            this._animationData = animationData;
+            //
+            this.resetToPose = animationConfig.resetToPose;
+            this.additiveBlending = animationConfig.additiveBlending;
+            this.displayControl = animationConfig.displayControl;
+            this.actionEnabled = animationConfig.actionEnabled;
+            this.layer = animationConfig.layer;
+            this.playTimes = animationConfig.playTimes;
+            this.timeScale = animationConfig.timeScale;
+            this.fadeTotalTime = animationConfig.fadeInTime;
+            this.autoFadeOutTime = animationConfig.autoFadeOutTime;
+            this.weight = animationConfig.weight;
+            this.name = animationConfig.name.length > 0 ? animationConfig.name : animationConfig.animation;
+            this.group = animationConfig.group;
+            if (animationConfig.pauseFadeIn) {
+                this._playheadState = 2; // 10
+            }
+            else {
+                this._playheadState = 3; // 11
+            }
+            if (animationConfig.duration < 0.0) {
+                this._position = 0.0;
+                this._duration = this._animationData.duration;
+                if (animationConfig.position !== 0.0) {
+                    if (this.timeScale >= 0.0) {
+                        this._time = animationConfig.position;
+                    }
+                    else {
+                        this._time = animationConfig.position - this._duration;
+                    }
+                }
+                else {
+                    this._time = 0.0;
+                }
+            }
+            else {
+                this._position = animationConfig.position;
+                this._duration = animationConfig.duration;
+                this._time = 0.0;
+            }
+            if (this.timeScale < 0.0 && this._time === 0.0) {
+                this._time = -0.000001; // Turn to end.
+            }
+            if (this.fadeTotalTime <= 0.0) {
+                this._fadeProgress = 0.999999; // Make different.
+            }
+            if (animationConfig.boneMask.length > 0) {
+                this._boneMask.length = animationConfig.boneMask.length;
+                for (var i = 0, l = this._boneMask.length; i < l; ++i) {
+                    this._boneMask[i] = animationConfig.boneMask[i];
+                }
+            }
+            this._actionTimeline = dragonBones.BaseObject.borrowObject(dragonBones.ActionTimelineState);
+            this._actionTimeline.init(this._armature, this, this._animationData.actionTimeline);
+            this._actionTimeline.currentTime = this._time;
+            if (this._actionTimeline.currentTime < 0.0) {
+                this._actionTimeline.currentTime = this._duration - this._actionTimeline.currentTime;
+            }
+            if (this._animationData.zOrderTimeline !== null) {
+                this._zOrderTimeline = dragonBones.BaseObject.borrowObject(dragonBones.ZOrderTimelineState);
+                this._zOrderTimeline.init(this._armature, this, this._animationData.zOrderTimeline);
+            }
+        };
+        /**
+         * @internal
+         */
+        AnimationState.prototype.advanceTime = function (passedTime, cacheFrameRate) {
+            this._blendState.dirty = false;
+            // Update fade time.
+            if (this._fadeState !== 0 || this._subFadeState !== 0) {
+                this._advanceFadeTime(passedTime);
+            }
+            // Update time.
+            if (this._playheadState === 3) {
+                if (this.timeScale !== 1.0) {
+                    passedTime *= this.timeScale;
+                }
+                this._time += passedTime;
+            }
+            // Update timeline.
+            if (this._timelineDirty !== 0) {
+                if (this._timelineDirty === 2) {
+                    this._updateTimelines();
+                }
+                this._timelineDirty = 0;
+                this._updateBoneAndSlotTimelines();
+            }
+            if (this.weight === 0.0) {
+                return;
+            }
+            var isCacheEnabled = this._fadeState === 0 && cacheFrameRate > 0.0;
+            var isUpdateTimeline = true;
+            var isUpdateBoneTimeline = true;
+            var time = this._time;
+            this._weightResult = this.weight * this._fadeProgress;
+            if (this._parent !== null) {
+                this._weightResult *= this._parent._weightResult / this._parent._fadeProgress;
+            }
+            if (this._actionTimeline.playState <= 0) {
+                this._actionTimeline.update(time); // Update main timeline.
+            }
+            if (isCacheEnabled) {
+                var internval = cacheFrameRate * 2.0;
+                this._actionTimeline.currentTime = Math.floor(this._actionTimeline.currentTime * internval) / internval;
+            }
+            if (this._zOrderTimeline !== null && this._zOrderTimeline.playState <= 0) {
+                this._zOrderTimeline.update(time);
+            }
+            if (isCacheEnabled) {
+                var cacheFrameIndex = Math.floor(this._actionTimeline.currentTime * cacheFrameRate); // uint
+                if (this._armature._cacheFrameIndex === cacheFrameIndex) {
+                    isUpdateTimeline = false;
+                    isUpdateBoneTimeline = false;
+                }
+                else {
+                    this._armature._cacheFrameIndex = cacheFrameIndex;
+                    if (this._animationData.cachedFrames[cacheFrameIndex]) {
+                        isUpdateBoneTimeline = false;
+                    }
+                    else {
+                        this._animationData.cachedFrames[cacheFrameIndex] = true;
+                    }
+                }
+            }
+            if (isUpdateTimeline) {
+                if (isUpdateBoneTimeline) {
+                    for (var i = 0, l = this._boneTimelines.length; i < l; ++i) {
+                        var timeline = this._boneTimelines[i];
+                        if (timeline.playState <= 0) {
+                            timeline.update(time);
+                        }
+                        if (i === l - 1 || timeline.bone !== this._boneTimelines[i + 1].bone) {
+                            var state = timeline.bone._blendState.update(this._weightResult, this.layer);
+                            if (state !== 0) {
+                                timeline.blend(state);
+                            }
+                        }
+                    }
+                }
+                for (var i = 0, l = this._surfaceTimelines.length; i < l; ++i) {
+                    var timeline = this._surfaceTimelines[i];
+                    var state = timeline.surface._blendState.update(this._weightResult, this.layer);
+                    if (timeline.playState <= 0) {
+                        timeline.update(time);
+                    }
+                    if (state !== 0) {
+                        timeline.blend(state);
+                    }
+                }
+                if (this.displayControl) {
+                    for (var i = 0, l = this._slotTimelines.length; i < l; ++i) {
+                        var timeline = this._slotTimelines[i];
+                        var displayController = timeline.slot.displayController;
+                        if (displayController === null ||
+                            displayController === this.name ||
+                            displayController === this.group) {
+                            if (timeline.playState <= 0) {
+                                timeline.update(time);
+                            }
+                        }
+                    }
+                }
+                for (var i = 0, l = this._constraintTimelines.length; i < l; ++i) {
+                    var timeline = this._constraintTimelines[i];
+                    if (timeline.playState <= 0) {
+                        timeline.update(time);
+                    }
+                }
+                for (var i = 0, l = this._animationTimelines.length; i < l; ++i) {
+                    var timeline = this._animationTimelines[i];
+                    var state = timeline.animationState._blendState.update(this._weightResult, this.layer);
+                    if (timeline.playState <= 0) {
+                        timeline.update(time);
+                    }
+                    if (state !== 0) {
+                        timeline.blend(state);
+                    }
+                }
+            }
+            if (this._fadeState === 0) {
+                if (this._subFadeState > 0) {
+                    this._subFadeState = 0;
+                    if (this._poseTimelines.length > 0) {
+                        for (var _i = 0, _a = this._poseTimelines; _i < _a.length; _i++) {
+                            var timeline = _a[_i];
+                            if (timeline instanceof dragonBones.BoneTimelineState) {
+                                this._boneTimelines.splice(this._boneTimelines.indexOf(timeline), 1);
+                            }
+                            else if (timeline instanceof dragonBones.SurfaceTimelineState) {
+                                this._surfaceTimelines.splice(this._surfaceTimelines.indexOf(timeline), 1);
+                            }
+                            else if (timeline instanceof dragonBones.SlotTimelineState) {
+                                this._slotTimelines.splice(this._slotTimelines.indexOf(timeline), 1);
+                            }
+                            else if (timeline instanceof dragonBones.ConstraintTimelineState) {
+                                this._constraintTimelines.splice(this._constraintTimelines.indexOf(timeline), 1);
+                            }
+                            timeline.returnToPool();
+                        }
+                        this._poseTimelines.length = 0;
+                    }
+                }
+                if (this._actionTimeline.playState > 0) {
+                    if (this.autoFadeOutTime >= 0.0) {
+                        this.fadeOut(this.autoFadeOutTime);
+                    }
+                }
+            }
+        };
+        /**
+         * - Continue play.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 继续播放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        AnimationState.prototype.play = function () {
+            this._playheadState = 3; // 11
+        };
+        /**
+         * - Stop play.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 暂停播放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        AnimationState.prototype.stop = function () {
+            this._playheadState &= 1; // 0x
+        };
+        /**
+         * - Fade out the animation state.
+         * @param fadeOutTime - The fade out time. (In seconds)
+         * @param pausePlayhead - Whether to pause the animation playing when fade out.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 淡出动画状态。
+         * @param fadeOutTime - 淡出时间。 （以秒为单位）
+         * @param pausePlayhead - 淡出时是否暂停播放。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        AnimationState.prototype.fadeOut = function (fadeOutTime, pausePlayhead) {
+            if (pausePlayhead === void 0) { pausePlayhead = true; }
+            if (fadeOutTime < 0.0) {
+                fadeOutTime = 0.0;
+            }
+            if (pausePlayhead) {
+                this._playheadState &= 2; // x0
+            }
+            if (this._fadeState > 0) {
+                if (fadeOutTime > this.fadeTotalTime - this._fadeTime) {
+                    return;
+                }
+            }
+            else {
+                this._fadeState = 1;
+                this._subFadeState = -1;
+                if (fadeOutTime <= 0.0 || this._fadeProgress <= 0.0) {
+                    this._fadeProgress = 0.000001; // Modify fade progress to different value.
+                }
+                for (var _i = 0, _a = this._boneTimelines; _i < _a.length; _i++) {
+                    var timeline = _a[_i];
+                    timeline.fadeOut();
+                }
+                for (var _b = 0, _c = this._surfaceTimelines; _b < _c.length; _b++) {
+                    var timeline = _c[_b];
+                    timeline.fadeOut();
+                }
+                for (var _d = 0, _e = this._slotTimelines; _d < _e.length; _d++) {
+                    var timeline = _e[_d];
+                    timeline.fadeOut();
+                }
+                for (var _f = 0, _g = this._constraintTimelines; _f < _g.length; _f++) {
+                    var timeline = _g[_f];
+                    timeline.fadeOut();
+                }
+                for (var _h = 0, _j = this._animationTimelines; _h < _j.length; _h++) {
+                    var timeline = _j[_h];
+                    timeline.animationState.fadeOut(fadeOutTime, pausePlayhead);
+                    timeline.fadeOut();
+                }
+            }
+            this.displayControl = false; //
+            this.fadeTotalTime = this._fadeProgress > 0.000001 ? fadeOutTime / this._fadeProgress : 0.0;
+            this._fadeTime = this.fadeTotalTime * (1.0 - this._fadeProgress);
+        };
+        /**
+         * - Check if a specific bone mask is included.
+         * @param boneName - The bone name.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 检查是否包含特定骨骼遮罩。
+         * @param boneName - 骨骼名称。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        AnimationState.prototype.containsBoneMask = function (boneName) {
+            return this._boneMask.length === 0 || this._boneMask.indexOf(boneName) >= 0;
+        };
+        /**
+         * - Add a specific bone mask.
+         * @param boneName - The bone name.
+         * @param recursive - Whether or not to add a mask to the bone's sub-bone.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 添加特定的骨骼遮罩。
+         * @param boneName - 骨骼名称。
+         * @param recursive - 是否为该骨骼的子骨骼添加遮罩。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        AnimationState.prototype.addBoneMask = function (boneName, recursive) {
+            if (recursive === void 0) { recursive = true; }
+            var currentBone = this._armature.getBone(boneName);
+            if (currentBone === null) {
+                return;
+            }
+            if (this._boneMask.indexOf(boneName) < 0) {
+                this._boneMask.push(boneName);
+            }
+            if (recursive) {
+                for (var _i = 0, _a = this._armature.getBones(); _i < _a.length; _i++) {
+                    var bone = _a[_i];
+                    if (this._boneMask.indexOf(bone.name) < 0 && currentBone.contains(bone)) {
+                        this._boneMask.push(bone.name);
+                    }
+                }
+            }
+            this._timelineDirty = 1;
+        };
+        /**
+         * - Remove the mask of a specific bone.
+         * @param boneName - The bone name.
+         * @param recursive - Whether to remove the bone's sub-bone mask.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 删除特定骨骼的遮罩。
+         * @param boneName - 骨骼名称。
+         * @param recursive - 是否删除该骨骼的子骨骼遮罩。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        AnimationState.prototype.removeBoneMask = function (boneName, recursive) {
+            if (recursive === void 0) { recursive = true; }
+            var index = this._boneMask.indexOf(boneName);
+            if (index >= 0) {
+                this._boneMask.splice(index, 1);
+            }
+            if (recursive) {
+                var currentBone = this._armature.getBone(boneName);
+                if (currentBone !== null) {
+                    var bones = this._armature.getBones();
+                    if (this._boneMask.length > 0) {
+                        for (var _i = 0, bones_1 = bones; _i < bones_1.length; _i++) {
+                            var bone = bones_1[_i];
+                            var index_2 = this._boneMask.indexOf(bone.name);
+                            if (index_2 >= 0 && currentBone.contains(bone)) {
+                                this._boneMask.splice(index_2, 1);
+                            }
+                        }
+                    }
+                    else {
+                        for (var _a = 0, bones_2 = bones; _a < bones_2.length; _a++) {
+                            var bone = bones_2[_a];
+                            if (bone === currentBone) {
+                                continue;
+                            }
+                            if (!currentBone.contains(bone)) {
+                                this._boneMask.push(bone.name);
+                            }
+                        }
+                    }
+                }
+            }
+            this._timelineDirty = 1;
+        };
+        /**
+         * - Remove all bone masks.
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 删除所有骨骼遮罩。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        AnimationState.prototype.removeAllBoneMask = function () {
+            this._boneMask.length = 0;
+            this._timelineDirty = 1;
+        };
+        Object.defineProperty(AnimationState.prototype, "isFadeIn", {
+            /**
+             * - Whether the animation state is fading in.
+             * @version DragonBones 5.1
+             * @language en_US
+             */
+            /**
+             * - 是否正在淡入。
+             * @version DragonBones 5.1
+             * @language zh_CN
+             */
+            get: function () {
+                return this._fadeState < 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "isFadeOut", {
+            /**
+             * - Whether the animation state is fading out.
+             * @version DragonBones 5.1
+             * @language en_US
+             */
+            /**
+             * - 是否正在淡出。
+             * @version DragonBones 5.1
+             * @language zh_CN
+             */
+            get: function () {
+                return this._fadeState > 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "isFadeComplete", {
+            /**
+             * - Whether the animation state is fade completed.
+             * @version DragonBones 5.1
+             * @language en_US
+             */
+            /**
+             * - 是否淡入或淡出完毕。
+             * @version DragonBones 5.1
+             * @language zh_CN
+             */
+            get: function () {
+                return this._fadeState === 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "isPlaying", {
+            /**
+             * - Whether the animation state is playing.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 是否正在播放。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return (this._playheadState & 2) !== 0 && this._actionTimeline.playState <= 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "isCompleted", {
+            /**
+             * - Whether the animation state is play completed.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 是否播放完毕。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._actionTimeline.playState > 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "currentPlayTimes", {
+            /**
+             * - The times has been played.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 已经循环播放的次数。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._actionTimeline.currentPlayTimes;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "totalTime", {
+            /**
+             * - The total time. (In seconds)
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 总播放时间。 （以秒为单位）
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._duration;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "currentTime", {
+            /**
+             * - The time is currently playing. (In seconds)
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 当前播放的时间。 （以秒为单位）
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._actionTimeline.currentTime;
+            },
+            set: function (value) {
+                var currentPlayTimes = this._actionTimeline.currentPlayTimes - (this._actionTimeline.playState > 0 ? 1 : 0);
+                if (value < 0 || this._duration < value) {
+                    value = (value % this._duration) + currentPlayTimes * this._duration;
+                    if (value < 0) {
+                        value += this._duration;
+                    }
+                }
+                if (this.playTimes > 0 && currentPlayTimes === this.playTimes - 1 && value === this._duration) {
+                    value = this._duration - 0.000001;
+                }
+                if (this._time === value) {
+                    return;
+                }
+                this._time = value;
+                this._actionTimeline.setCurrentTime(this._time);
+                if (this._zOrderTimeline !== null) {
+                    this._zOrderTimeline.playState = -1;
+                }
+                for (var _i = 0, _a = this._boneTimelines; _i < _a.length; _i++) {
+                    var timeline = _a[_i];
+                    timeline.playState = -1;
+                }
+                for (var _b = 0, _c = this._slotTimelines; _b < _c.length; _b++) {
+                    var timeline = _c[_b];
+                    timeline.playState = -1;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(AnimationState.prototype, "animationData", {
+            /**
+             * - The animation data.
+             * @see dragonBones.AnimationData
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - 动画数据。
+             * @see dragonBones.AnimationData
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._animationData;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return AnimationState;
+    }(dragonBones.BaseObject));
+    dragonBones.AnimationState = AnimationState;
+    /**
+     * @internal
+     */
+    var BonePose = /** @class */ (function (_super) {
+        __extends(BonePose, _super);
+        function BonePose() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.current = new dragonBones.Transform();
+            _this.delta = new dragonBones.Transform();
+            _this.result = new dragonBones.Transform();
+            return _this;
+        }
+        BonePose.toString = function () {
+            return "[class dragonBones.BonePose]";
+        };
+        BonePose.prototype._onClear = function () {
+            this.current.identity();
+            this.delta.identity();
+            this.result.identity();
+        };
+        return BonePose;
+    }(dragonBones.BaseObject));
+    dragonBones.BonePose = BonePose;
+    /**
+     * @internal
+     */
+    var BlendState = /** @class */ (function () {
+        function BlendState() {
+        }
+        /**
+         * -1: First blending, 0: No blending, 1: Blending.
+         */
+        BlendState.prototype.update = function (weight, p_layer) {
+            if (this.dirty) {
+                if (this.leftWeight > 0.0) {
+                    if (this.layer !== p_layer) {
+                        if (this.layerWeight >= this.leftWeight) {
+                            this.leftWeight = 0.0;
+                            return 0;
+                        }
+                        else {
+                            this.layer = p_layer;
+                            this.leftWeight -= this.layerWeight;
+                            this.layerWeight = 0.0;
+                        }
+                    }
+                }
+                else {
+                    return 0;
+                }
+                weight *= this.leftWeight;
+                this.layerWeight += weight;
+                this.blendWeight = weight;
+                return 2;
+            }
+            this.dirty = true;
+            this.layer = p_layer;
+            this.layerWeight = weight;
+            this.leftWeight = 1.0;
+            this.blendWeight = weight;
+            return 1;
+        };
+        BlendState.prototype.clear = function () {
+            this.dirty = false;
+            this.layer = 0;
+            this.leftWeight = 0.0;
+            this.layerWeight = 0.0;
+            this.blendWeight = 0.0;
+        };
+        return BlendState;
+    }());
+    dragonBones.BlendState = BlendState;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var TimelineState = /** @class */ (function (_super) {
+        __extends(TimelineState, _super);
+        function TimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TimelineState.prototype._onClear = function () {
+            this.playState = -1;
+            this.currentPlayTimes = -1;
+            this.currentTime = -1.0;
+            this._tweenState = 0 /* None */;
+            this._frameRate = 0;
+            this._frameValueOffset = 0;
+            this._frameCount = 0;
+            this._frameOffset = 0;
+            this._frameIndex = -1;
+            this._frameRateR = 0.0;
+            this._position = 0.0;
+            this._duration = 0.0;
+            this._timeScale = 1.0;
+            this._timeOffset = 0.0;
+            this._dragonBonesData = null; //
+            this._animationData = null; //
+            this._timelineData = null; //
+            this._armature = null; //
+            this._animationState = null; //
+            this._actionTimeline = null; //
+            this._frameArray = null; //
+            this._frameIntArray = null; //
+            this._frameFloatArray = null; //
+            this._timelineArray = null; //
+            this._frameIndices = null; //
+        };
+        TimelineState.prototype._setCurrentTime = function (passedTime) {
+            var prevState = this.playState;
+            var prevPlayTimes = this.currentPlayTimes;
+            var prevTime = this.currentTime;
+            if (this._actionTimeline !== null && this._frameCount <= 1) {
+                this.playState = this._actionTimeline.playState >= 0 ? 1 : -1;
+                this.currentPlayTimes = 1;
+                this.currentTime = this._actionTimeline.currentTime;
+            }
+            else if (this._actionTimeline === null || this._timeScale !== 1.0 || this._timeOffset !== 0.0) {
+                var playTimes = this._animationState.playTimes;
+                var totalTime = playTimes * this._duration;
+                passedTime *= this._timeScale;
+                if (this._timeOffset !== 0.0) {
+                    passedTime += this._timeOffset * this._animationData.duration;
+                }
+                if (playTimes > 0 && (passedTime >= totalTime || passedTime <= -totalTime)) {
+                    if (this.playState <= 0 && this._animationState._playheadState === 3) {
+                        this.playState = 1;
+                    }
+                    this.currentPlayTimes = playTimes;
+                    if (passedTime < 0.0) {
+                        this.currentTime = 0.0;
+                    }
+                    else {
+                        this.currentTime = this._duration + 0.000001; // Precision problem
+                    }
+                }
+                else {
+                    if (this.playState !== 0 && this._animationState._playheadState === 3) {
+                        this.playState = 0;
+                    }
+                    if (passedTime < 0.0) {
+                        passedTime = -passedTime;
+                        this.currentPlayTimes = Math.floor(passedTime / this._duration);
+                        this.currentTime = this._duration - (passedTime % this._duration);
+                    }
+                    else {
+                        this.currentPlayTimes = Math.floor(passedTime / this._duration);
+                        this.currentTime = passedTime % this._duration;
+                    }
+                }
+                this.currentTime += this._position;
+            }
+            else {
+                this.playState = this._actionTimeline.playState;
+                this.currentPlayTimes = this._actionTimeline.currentPlayTimes;
+                this.currentTime = this._actionTimeline.currentTime;
+            }
+            if (this.currentPlayTimes === prevPlayTimes && this.currentTime === prevTime) {
+                return false;
+            }
+            // Clear frame flag when timeline start or loopComplete.
+            if ((prevState < 0 && this.playState !== prevState) ||
+                (this.playState <= 0 && this.currentPlayTimes !== prevPlayTimes)) {
+                this._frameIndex = -1;
+            }
+            return true;
+        };
+        TimelineState.prototype.init = function (armature, animationState, timelineData) {
+            this._armature = armature;
+            this._animationState = animationState;
+            this._timelineData = timelineData;
+            this._actionTimeline = this._animationState._actionTimeline;
+            if (this === this._actionTimeline) {
+                this._actionTimeline = null; //
+            }
+            this._animationData = this._animationState._animationData;
+            this._frameRate = this._animationData.parent.frameRate;
+            this._frameRateR = 1.0 / this._frameRate;
+            this._position = this._animationState._position;
+            this._duration = this._animationState._duration;
+            this._dragonBonesData = this._animationData.parent.parent; // May by the animation data is not belone to this armature data.
+            if (this._timelineData !== null) {
+                this._frameIntArray = this._dragonBonesData.frameIntArray;
+                this._frameFloatArray = this._dragonBonesData.frameFloatArray;
+                this._frameArray = this._dragonBonesData.frameArray;
+                this._timelineArray = this._dragonBonesData.timelineArray;
+                this._frameIndices = this._dragonBonesData.frameIndices;
+                this._frameCount = this._timelineArray[this._timelineData.offset + 2 /* TimelineKeyFrameCount */];
+                this._frameValueOffset = this._timelineArray[this._timelineData.offset + 4 /* TimelineFrameValueOffset */];
+                this._timeScale = 100.0 / this._timelineArray[this._timelineData.offset + 0 /* TimelineScale */];
+                this._timeOffset = this._timelineArray[this._timelineData.offset + 1 /* TimelineOffset */] * 0.01;
+            }
+        };
+        TimelineState.prototype.fadeOut = function () { };
+        TimelineState.prototype.update = function (passedTime) {
+            if (this._setCurrentTime(passedTime)) {
+                if (this._frameCount > 1) {
+                    var timelineFrameIndex = Math.floor(this.currentTime * this._frameRate); // uint
+                    var frameIndex = this._frameIndices[this._timelineData.frameIndicesOffset + timelineFrameIndex];
+                    if (this._frameIndex !== frameIndex) {
+                        this._frameIndex = frameIndex;
+                        this._frameOffset = this._animationData.frameOffset + this._timelineArray[this._timelineData.offset + 5 /* TimelineFrameOffset */ + this._frameIndex];
+                        this._onArriveAtFrame();
+                    }
+                }
+                else if (this._frameIndex < 0) {
+                    this._frameIndex = 0;
+                    if (this._timelineData !== null) {
+                        this._frameOffset = this._animationData.frameOffset + this._timelineArray[this._timelineData.offset + 5 /* TimelineFrameOffset */];
+                    }
+                    this._onArriveAtFrame();
+                }
+                if (this._tweenState !== 0 /* None */) {
+                    this._onUpdateFrame();
+                }
+            }
+        };
+        return TimelineState;
+    }(dragonBones.BaseObject));
+    dragonBones.TimelineState = TimelineState;
+    /**
+     * @internal
+     */
+    var TweenTimelineState = /** @class */ (function (_super) {
+        __extends(TweenTimelineState, _super);
+        function TweenTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        TweenTimelineState._getEasingValue = function (tweenType, progress, easing) {
+            var value = progress;
+            switch (tweenType) {
+                case 3 /* QuadIn */:
+                    value = Math.pow(progress, 2.0);
+                    break;
+                case 4 /* QuadOut */:
+                    value = 1.0 - Math.pow(1.0 - progress, 2.0);
+                    break;
+                case 5 /* QuadInOut */:
+                    value = 0.5 * (1.0 - Math.cos(progress * Math.PI));
+                    break;
+            }
+            return (value - progress) * easing + progress;
+        };
+        TweenTimelineState._getEasingCurveValue = function (progress, samples, count, offset) {
+            if (progress <= 0.0) {
+                return 0.0;
+            }
+            else if (progress >= 1.0) {
+                return 1.0;
+            }
+            var segmentCount = count + 1; // + 2 - 1
+            var valueIndex = Math.floor(progress * segmentCount);
+            var fromValue = valueIndex === 0 ? 0.0 : samples[offset + valueIndex - 1];
+            var toValue = (valueIndex === segmentCount - 1) ? 10000.0 : samples[offset + valueIndex];
+            return (fromValue + (toValue - fromValue) * (progress * segmentCount - valueIndex)) * 0.0001;
+        };
+        TweenTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this._tweenType = 0 /* None */;
+            this._curveCount = 0;
+            this._framePosition = 0.0;
+            this._frameDurationR = 0.0;
+            this._tweenProgress = 0.0;
+            this._tweenEasing = 0.0;
+        };
+        TweenTimelineState.prototype._onArriveAtFrame = function () {
+            if (this._frameCount > 1 &&
+                (this._frameIndex !== this._frameCount - 1 ||
+                    this._animationState.playTimes === 0 ||
+                    this._animationState.currentPlayTimes < this._animationState.playTimes - 1)) {
+                this._tweenType = this._frameArray[this._frameOffset + 1 /* FrameTweenType */]; // TODO recode ture tween type.
+                this._tweenState = this._tweenType === 0 /* None */ ? 1 /* Once */ : 2 /* Always */;
+                if (this._tweenType === 2 /* Curve */) {
+                    this._curveCount = this._frameArray[this._frameOffset + 2 /* FrameTweenEasingOrCurveSampleCount */];
+                }
+                else if (this._tweenType !== 0 /* None */ && this._tweenType !== 1 /* Line */) {
+                    this._tweenEasing = this._frameArray[this._frameOffset + 2 /* FrameTweenEasingOrCurveSampleCount */] * 0.01;
+                }
+                this._framePosition = this._frameArray[this._frameOffset] * this._frameRateR;
+                if (this._frameIndex === this._frameCount - 1) {
+                    this._frameDurationR = 1.0 / (this._animationData.duration - this._framePosition);
+                }
+                else {
+                    var nextFrameOffset = this._animationData.frameOffset + this._timelineArray[this._timelineData.offset + 5 /* TimelineFrameOffset */ + this._frameIndex + 1];
+                    var frameDuration = this._frameArray[nextFrameOffset] * this._frameRateR - this._framePosition;
+                    if (frameDuration > 0) {
+                        this._frameDurationR = 1.0 / frameDuration;
+                    }
+                    else {
+                        this._frameDurationR = 0.0;
+                    }
+                }
+            }
+            else {
+                this._tweenState = 1 /* Once */;
+            }
+        };
+        TweenTimelineState.prototype._onUpdateFrame = function () {
+            if (this._tweenState === 2 /* Always */) {
+                this._tweenProgress = (this.currentTime - this._framePosition) * this._frameDurationR;
+                if (this._tweenType === 2 /* Curve */) {
+                    this._tweenProgress = TweenTimelineState._getEasingCurveValue(this._tweenProgress, this._frameArray, this._curveCount, this._frameOffset + 3 /* FrameCurveSamples */);
+                }
+                else if (this._tweenType !== 1 /* Line */) {
+                    this._tweenProgress = TweenTimelineState._getEasingValue(this._tweenType, this._tweenProgress, this._tweenEasing);
+                }
+            }
+            else {
+                this._tweenProgress = 0.0;
+            }
+        };
+        return TweenTimelineState;
+    }(TimelineState));
+    dragonBones.TweenTimelineState = TweenTimelineState;
+    /**
+     * @internal
+     */
+    var BoneTimelineState = /** @class */ (function (_super) {
+        __extends(BoneTimelineState, _super);
+        function BoneTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BoneTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.bone = null; //
+            this.bonePose = null; //
+        };
+        BoneTimelineState.prototype.blend = function (state) {
+            var blendWeight = this.bone._blendState.blendWeight;
+            var animationPose = this.bone.animationPose;
+            var result = this.bonePose.result;
+            if (state === 2) {
+                animationPose.x += result.x * blendWeight;
+                animationPose.y += result.y * blendWeight;
+                animationPose.rotation += result.rotation * blendWeight;
+                animationPose.skew += result.skew * blendWeight;
+                animationPose.scaleX += (result.scaleX - 1.0) * blendWeight;
+                animationPose.scaleY += (result.scaleY - 1.0) * blendWeight;
+            }
+            else if (blendWeight !== 1.0) {
+                animationPose.x = result.x * blendWeight;
+                animationPose.y = result.y * blendWeight;
+                animationPose.rotation = result.rotation * blendWeight;
+                animationPose.skew = result.skew * blendWeight;
+                animationPose.scaleX = (result.scaleX - 1.0) * blendWeight + 1.0;
+                animationPose.scaleY = (result.scaleY - 1.0) * blendWeight + 1.0;
+            }
+            else {
+                animationPose.x = result.x;
+                animationPose.y = result.y;
+                animationPose.rotation = result.rotation;
+                animationPose.skew = result.skew;
+                animationPose.scaleX = result.scaleX;
+                animationPose.scaleY = result.scaleY;
+            }
+            if (this._animationState._fadeState !== 0 || this._animationState._subFadeState !== 0) {
+                this.bone._transformDirty = true;
+            }
+        };
+        return BoneTimelineState;
+    }(TweenTimelineState));
+    dragonBones.BoneTimelineState = BoneTimelineState;
+    /**
+     * @internal
+     */
+    var SlotTimelineState = /** @class */ (function (_super) {
+        __extends(SlotTimelineState, _super);
+        function SlotTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        SlotTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.slot = null; //
+        };
+        return SlotTimelineState;
+    }(TweenTimelineState));
+    dragonBones.SlotTimelineState = SlotTimelineState;
+    /**
+     * @internal
+     */
+    var ConstraintTimelineState = /** @class */ (function (_super) {
+        __extends(ConstraintTimelineState, _super);
+        function ConstraintTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ConstraintTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.constraint = null; //
+        };
+        return ConstraintTimelineState;
+    }(TweenTimelineState));
+    dragonBones.ConstraintTimelineState = ConstraintTimelineState;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var ActionTimelineState = /** @class */ (function (_super) {
+        __extends(ActionTimelineState, _super);
+        function ActionTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ActionTimelineState.toString = function () {
+            return "[class dragonBones.ActionTimelineState]";
+        };
+        ActionTimelineState.prototype._onCrossFrame = function (frameIndex) {
+            var eventDispatcher = this._armature.eventDispatcher;
+            if (this._animationState.actionEnabled) {
+                var frameOffset = this._animationData.frameOffset + this._timelineArray[this._timelineData.offset + 5 /* TimelineFrameOffset */ + frameIndex];
+                var actionCount = this._frameArray[frameOffset + 1];
+                var actions = this._animationData.parent.actions; // May be the animaton data not belong to this armature data.
+                for (var i = 0; i < actionCount; ++i) {
+                    var actionIndex = this._frameArray[frameOffset + 2 + i];
+                    var action = actions[actionIndex];
+                    if (action.type === 0 /* Play */) {
+                        var eventObject = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                        // eventObject.time = this._frameArray[frameOffset] * this._frameRateR; // Precision problem
+                        eventObject.time = this._frameArray[frameOffset] / this._frameRate;
+                        eventObject.animationState = this._animationState;
+                        dragonBones.EventObject.actionDataToInstance(action, eventObject, this._armature);
+                        this._armature._bufferAction(eventObject, true);
+                    }
+                    else {
+                        var eventType = action.type === 10 /* Frame */ ? dragonBones.EventObject.FRAME_EVENT : dragonBones.EventObject.SOUND_EVENT;
+                        if (action.type === 11 /* Sound */ || eventDispatcher.hasDBEventListener(eventType)) {
+                            var eventObject = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                            // eventObject.time = this._frameArray[frameOffset] * this._frameRateR; // Precision problem
+                            eventObject.time = this._frameArray[frameOffset] / this._frameRate;
+                            eventObject.animationState = this._animationState;
+                            dragonBones.EventObject.actionDataToInstance(action, eventObject, this._armature);
+                            this._armature._dragonBones.bufferEvent(eventObject);
+                        }
+                    }
+                }
+            }
+        };
+        ActionTimelineState.prototype._onArriveAtFrame = function () { };
+        ActionTimelineState.prototype._onUpdateFrame = function () { };
+        ActionTimelineState.prototype.update = function (passedTime) {
+            var prevState = this.playState;
+            var prevPlayTimes = this.currentPlayTimes;
+            var prevTime = this.currentTime;
+            if (this._setCurrentTime(passedTime)) {
+                var eventDispatcher = this._armature.eventDispatcher;
+                if (prevState < 0) {
+                    if (this.playState !== prevState) {
+                        if (this._animationState.displayControl && this._animationState.resetToPose) {
+                            this._armature._sortZOrder(null, 0);
+                        }
+                        prevPlayTimes = this.currentPlayTimes;
+                        if (eventDispatcher.hasDBEventListener(dragonBones.EventObject.START)) {
+                            var eventObject = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                            eventObject.type = dragonBones.EventObject.START;
+                            eventObject.armature = this._armature;
+                            eventObject.animationState = this._animationState;
+                            this._armature._dragonBones.bufferEvent(eventObject);
+                        }
+                    }
+                    else {
+                        return;
+                    }
+                }
+                var isReverse = this._animationState.timeScale < 0.0;
+                var loopCompleteEvent = null;
+                var completeEvent = null;
+                if (this.currentPlayTimes !== prevPlayTimes) {
+                    if (eventDispatcher.hasDBEventListener(dragonBones.EventObject.LOOP_COMPLETE)) {
+                        loopCompleteEvent = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                        loopCompleteEvent.type = dragonBones.EventObject.LOOP_COMPLETE;
+                        loopCompleteEvent.armature = this._armature;
+                        loopCompleteEvent.animationState = this._animationState;
+                    }
+                    if (this.playState > 0) {
+                        if (eventDispatcher.hasDBEventListener(dragonBones.EventObject.COMPLETE)) {
+                            completeEvent = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                            completeEvent.type = dragonBones.EventObject.COMPLETE;
+                            completeEvent.armature = this._armature;
+                            completeEvent.animationState = this._animationState;
+                        }
+                    }
+                }
+                if (this._frameCount > 1) {
+                    var timelineData = this._timelineData;
+                    var timelineFrameIndex = Math.floor(this.currentTime * this._frameRate); // uint
+                    var frameIndex = this._frameIndices[timelineData.frameIndicesOffset + timelineFrameIndex];
+                    if (this._frameIndex !== frameIndex) {
+                        var crossedFrameIndex = this._frameIndex;
+                        this._frameIndex = frameIndex;
+                        if (this._timelineArray !== null) {
+                            this._frameOffset = this._animationData.frameOffset + this._timelineArray[timelineData.offset + 5 /* TimelineFrameOffset */ + this._frameIndex];
+                            if (isReverse) {
+                                if (crossedFrameIndex < 0) {
+                                    var prevFrameIndex = Math.floor(prevTime * this._frameRate);
+                                    crossedFrameIndex = this._frameIndices[timelineData.frameIndicesOffset + prevFrameIndex];
+                                    if (this.currentPlayTimes === prevPlayTimes) {
+                                        if (crossedFrameIndex === frameIndex) {
+                                            crossedFrameIndex = -1;
+                                        }
+                                    }
+                                }
+                                while (crossedFrameIndex >= 0) {
+                                    var frameOffset = this._animationData.frameOffset + this._timelineArray[timelineData.offset + 5 /* TimelineFrameOffset */ + crossedFrameIndex];
+                                    // const framePosition = this._frameArray[frameOffset] * this._frameRateR; // Precision problem
+                                    var framePosition = this._frameArray[frameOffset] / this._frameRate;
+                                    if (this._position <= framePosition &&
+                                        framePosition <= this._position + this._duration) {
+                                        this._onCrossFrame(crossedFrameIndex);
+                                    }
+                                    if (loopCompleteEvent !== null && crossedFrameIndex === 0) {
+                                        this._armature._dragonBones.bufferEvent(loopCompleteEvent);
+                                        loopCompleteEvent = null;
+                                    }
+                                    if (crossedFrameIndex > 0) {
+                                        crossedFrameIndex--;
+                                    }
+                                    else {
+                                        crossedFrameIndex = this._frameCount - 1;
+                                    }
+                                    if (crossedFrameIndex === frameIndex) {
+                                        break;
+                                    }
+                                }
+                            }
+                            else {
+                                if (crossedFrameIndex < 0) {
+                                    var prevFrameIndex = Math.floor(prevTime * this._frameRate);
+                                    crossedFrameIndex = this._frameIndices[timelineData.frameIndicesOffset + prevFrameIndex];
+                                    var frameOffset = this._animationData.frameOffset + this._timelineArray[timelineData.offset + 5 /* TimelineFrameOffset */ + crossedFrameIndex];
+                                    // const framePosition = this._frameArray[frameOffset] * this._frameRateR; // Precision problem
+                                    var framePosition = this._frameArray[frameOffset] / this._frameRate;
+                                    if (this.currentPlayTimes === prevPlayTimes) {
+                                        if (prevTime <= framePosition) {
+                                            if (crossedFrameIndex > 0) {
+                                                crossedFrameIndex--;
+                                            }
+                                            else {
+                                                crossedFrameIndex = this._frameCount - 1;
+                                            }
+                                        }
+                                        else if (crossedFrameIndex === frameIndex) {
+                                            crossedFrameIndex = -1;
+                                        }
+                                    }
+                                }
+                                while (crossedFrameIndex >= 0) {
+                                    if (crossedFrameIndex < this._frameCount - 1) {
+                                        crossedFrameIndex++;
+                                    }
+                                    else {
+                                        crossedFrameIndex = 0;
+                                    }
+                                    var frameOffset = this._animationData.frameOffset + this._timelineArray[timelineData.offset + 5 /* TimelineFrameOffset */ + crossedFrameIndex];
+                                    // const framePosition = this._frameArray[frameOffset] * this._frameRateR; // Precision problem
+                                    var framePosition = this._frameArray[frameOffset] / this._frameRate;
+                                    if (this._position <= framePosition &&
+                                        framePosition <= this._position + this._duration) {
+                                        this._onCrossFrame(crossedFrameIndex);
+                                    }
+                                    if (loopCompleteEvent !== null && crossedFrameIndex === 0) {
+                                        this._armature._dragonBones.bufferEvent(loopCompleteEvent);
+                                        loopCompleteEvent = null;
+                                    }
+                                    if (crossedFrameIndex === frameIndex) {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (this._frameIndex < 0) {
+                    this._frameIndex = 0;
+                    if (this._timelineData !== null) {
+                        this._frameOffset = this._animationData.frameOffset + this._timelineArray[this._timelineData.offset + 5 /* TimelineFrameOffset */];
+                        // Arrive at frame.
+                        var framePosition = this._frameArray[this._frameOffset] / this._frameRate;
+                        if (this.currentPlayTimes === prevPlayTimes) {
+                            if (prevTime <= framePosition) {
+                                this._onCrossFrame(this._frameIndex);
+                            }
+                        }
+                        else if (this._position <= framePosition) {
+                            if (!isReverse && loopCompleteEvent !== null) {
+                                this._armature._dragonBones.bufferEvent(loopCompleteEvent);
+                                loopCompleteEvent = null;
+                            }
+                            this._onCrossFrame(this._frameIndex);
+                        }
+                    }
+                }
+                if (loopCompleteEvent !== null) {
+                    this._armature._dragonBones.bufferEvent(loopCompleteEvent);
+                }
+                if (completeEvent !== null) {
+                    this._armature._dragonBones.bufferEvent(completeEvent);
+                }
+            }
+        };
+        ActionTimelineState.prototype.setCurrentTime = function (value) {
+            this._setCurrentTime(value);
+            this._frameIndex = -1;
+        };
+        return ActionTimelineState;
+    }(dragonBones.TimelineState));
+    dragonBones.ActionTimelineState = ActionTimelineState;
+    /**
+     * @internal
+     */
+    var ZOrderTimelineState = /** @class */ (function (_super) {
+        __extends(ZOrderTimelineState, _super);
+        function ZOrderTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ZOrderTimelineState.toString = function () {
+            return "[class dragonBones.ZOrderTimelineState]";
+        };
+        ZOrderTimelineState.prototype._onArriveAtFrame = function () {
+            if (this.playState >= 0) {
+                var count = this._frameArray[this._frameOffset + 1];
+                if (count > 0) {
+                    this._armature._sortZOrder(this._frameArray, this._frameOffset + 2);
+                }
+                else {
+                    this._armature._sortZOrder(null, 0);
+                }
+            }
+        };
+        ZOrderTimelineState.prototype._onUpdateFrame = function () { };
+        return ZOrderTimelineState;
+    }(dragonBones.TimelineState));
+    dragonBones.ZOrderTimelineState = ZOrderTimelineState;
+    /**
+     * @internal
+     */
+    var BoneAllTimelineState = /** @class */ (function (_super) {
+        __extends(BoneAllTimelineState, _super);
+        function BoneAllTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BoneAllTimelineState.toString = function () {
+            return "[class dragonBones.BoneAllTimelineState]";
+        };
+        BoneAllTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData !== null) {
+                var valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset + this._frameIndex * 6; // ...(timeline value offset)|xxxxxx|xxxxxx|(Value offset)xxxxx|(Next offset)xxxxx|xxxxxx|xxxxxx|...
+                var scale = this._armature._armatureData.scale;
+                var frameFloatArray = this._frameFloatArray;
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.x = frameFloatArray[valueOffset++] * scale;
+                current.y = frameFloatArray[valueOffset++] * scale;
+                current.rotation = frameFloatArray[valueOffset++];
+                current.skew = frameFloatArray[valueOffset++];
+                current.scaleX = frameFloatArray[valueOffset++];
+                current.scaleY = frameFloatArray[valueOffset++];
+                if (this._tweenState === 2 /* Always */) {
+                    if (this._frameIndex === this._frameCount - 1) {
+                        valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset; // + 0 * 6
+                    }
+                    delta.x = frameFloatArray[valueOffset++] * scale - current.x;
+                    delta.y = frameFloatArray[valueOffset++] * scale - current.y;
+                    delta.rotation = frameFloatArray[valueOffset++] - current.rotation;
+                    delta.skew = frameFloatArray[valueOffset++] - current.skew;
+                    delta.scaleX = frameFloatArray[valueOffset++] - current.scaleX;
+                    delta.scaleY = frameFloatArray[valueOffset++] - current.scaleY;
+                }
+                else {
+                    delta.x = 0.0;
+                    delta.y = 0.0;
+                    delta.rotation = 0.0;
+                    delta.skew = 0.0;
+                    delta.scaleX = 0.0;
+                    delta.scaleY = 0.0;
+                }
+            }
+            else {
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.x = 0.0;
+                current.y = 0.0;
+                current.rotation = 0.0;
+                current.skew = 0.0;
+                current.scaleX = 1.0;
+                current.scaleY = 1.0;
+                delta.x = 0.0;
+                delta.y = 0.0;
+                delta.rotation = 0.0;
+                delta.skew = 0.0;
+                delta.scaleX = 0.0;
+                delta.scaleY = 0.0;
+            }
+        };
+        BoneAllTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            var current = this.bonePose.current;
+            var delta = this.bonePose.delta;
+            var result = this.bonePose.result;
+            this.bone._transformDirty = true;
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            result.x = current.x + delta.x * this._tweenProgress;
+            result.y = current.y + delta.y * this._tweenProgress;
+            result.rotation = current.rotation + delta.rotation * this._tweenProgress;
+            result.skew = current.skew + delta.skew * this._tweenProgress;
+            result.scaleX = current.scaleX + delta.scaleX * this._tweenProgress;
+            result.scaleY = current.scaleY + delta.scaleY * this._tweenProgress;
+        };
+        BoneAllTimelineState.prototype.fadeOut = function () {
+            var result = this.bonePose.result;
+            result.rotation = dragonBones.Transform.normalizeRadian(result.rotation);
+            result.skew = dragonBones.Transform.normalizeRadian(result.skew);
+        };
+        return BoneAllTimelineState;
+    }(dragonBones.BoneTimelineState));
+    dragonBones.BoneAllTimelineState = BoneAllTimelineState;
+    /**
+     * @internal
+     */
+    var BoneTranslateTimelineState = /** @class */ (function (_super) {
+        __extends(BoneTranslateTimelineState, _super);
+        function BoneTranslateTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BoneTranslateTimelineState.toString = function () {
+            return "[class dragonBones.BoneTranslateTimelineState]";
+        };
+        BoneTranslateTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData !== null) {
+                var valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset + this._frameIndex * 2;
+                var scale = this._armature._armatureData.scale;
+                var frameFloatArray = this._frameFloatArray;
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.x = frameFloatArray[valueOffset++] * scale;
+                current.y = frameFloatArray[valueOffset++] * scale;
+                if (this._tweenState === 2 /* Always */) {
+                    if (this._frameIndex === this._frameCount - 1) {
+                        valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset; // + 0 * 2
+                    }
+                    delta.x = frameFloatArray[valueOffset++] * scale - current.x;
+                    delta.y = frameFloatArray[valueOffset++] * scale - current.y;
+                }
+                else {
+                    delta.x = 0.0;
+                    delta.y = 0.0;
+                }
+            }
+            else {
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.x = 0.0;
+                current.y = 0.0;
+                delta.x = 0.0;
+                delta.y = 0.0;
+            }
+        };
+        BoneTranslateTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            var current = this.bonePose.current;
+            var delta = this.bonePose.delta;
+            var result = this.bonePose.result;
+            this.bone._transformDirty = true;
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            result.x = (current.x + delta.x * this._tweenProgress);
+            result.y = (current.y + delta.y * this._tweenProgress);
+        };
+        return BoneTranslateTimelineState;
+    }(dragonBones.BoneTimelineState));
+    dragonBones.BoneTranslateTimelineState = BoneTranslateTimelineState;
+    /**
+     * @internal
+     */
+    var BoneRotateTimelineState = /** @class */ (function (_super) {
+        __extends(BoneRotateTimelineState, _super);
+        function BoneRotateTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BoneRotateTimelineState.toString = function () {
+            return "[class dragonBones.BoneRotateTimelineState]";
+        };
+        BoneRotateTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData !== null) {
+                var valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset + this._frameIndex * 2;
+                var frameFloatArray = this._frameFloatArray;
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.rotation = frameFloatArray[valueOffset++];
+                current.skew = frameFloatArray[valueOffset++];
+                if (this._tweenState === 2 /* Always */) {
+                    if (this._frameIndex === this._frameCount - 1) {
+                        valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset; // + 0 * 2
+                        delta.rotation = dragonBones.Transform.normalizeRadian(frameFloatArray[valueOffset++] - current.rotation);
+                    }
+                    else {
+                        delta.rotation = frameFloatArray[valueOffset++] - current.rotation;
+                    }
+                    delta.skew = frameFloatArray[valueOffset++] - current.skew;
+                }
+                else {
+                    delta.rotation = 0.0;
+                    delta.skew = 0.0;
+                }
+            }
+            else {
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.rotation = 0.0;
+                current.skew = 0.0;
+                delta.rotation = 0.0;
+                delta.skew = 0.0;
+            }
+        };
+        BoneRotateTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            var current = this.bonePose.current;
+            var delta = this.bonePose.delta;
+            var result = this.bonePose.result;
+            this.bone._transformDirty = true;
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            result.rotation = current.rotation + delta.rotation * this._tweenProgress;
+            result.skew = current.skew + delta.skew * this._tweenProgress;
+        };
+        BoneRotateTimelineState.prototype.fadeOut = function () {
+            var result = this.bonePose.result;
+            result.rotation = dragonBones.Transform.normalizeRadian(result.rotation);
+            result.skew = dragonBones.Transform.normalizeRadian(result.skew);
+        };
+        return BoneRotateTimelineState;
+    }(dragonBones.BoneTimelineState));
+    dragonBones.BoneRotateTimelineState = BoneRotateTimelineState;
+    /**
+     * @internal
+     */
+    var BoneScaleTimelineState = /** @class */ (function (_super) {
+        __extends(BoneScaleTimelineState, _super);
+        function BoneScaleTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BoneScaleTimelineState.toString = function () {
+            return "[class dragonBones.BoneScaleTimelineState]";
+        };
+        BoneScaleTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData !== null) {
+                var valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset + this._frameIndex * 2;
+                var frameFloatArray = this._frameFloatArray;
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.scaleX = frameFloatArray[valueOffset++];
+                current.scaleY = frameFloatArray[valueOffset++];
+                if (this._tweenState === 2 /* Always */) {
+                    if (this._frameIndex === this._frameCount - 1) {
+                        valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset; // + 0 * 2
+                    }
+                    delta.scaleX = frameFloatArray[valueOffset++] - current.scaleX;
+                    delta.scaleY = frameFloatArray[valueOffset++] - current.scaleY;
+                }
+                else {
+                    delta.scaleX = 0.0;
+                    delta.scaleY = 0.0;
+                }
+            }
+            else {
+                var current = this.bonePose.current;
+                var delta = this.bonePose.delta;
+                current.scaleX = 1.0;
+                current.scaleY = 1.0;
+                delta.scaleX = 0.0;
+                delta.scaleY = 0.0;
+            }
+        };
+        BoneScaleTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            var current = this.bonePose.current;
+            var delta = this.bonePose.delta;
+            var result = this.bonePose.result;
+            this.bone._transformDirty = true;
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            result.scaleX = current.scaleX + delta.scaleX * this._tweenProgress;
+            result.scaleY = current.scaleY + delta.scaleY * this._tweenProgress;
+        };
+        return BoneScaleTimelineState;
+    }(dragonBones.BoneTimelineState));
+    dragonBones.BoneScaleTimelineState = BoneScaleTimelineState;
+    /**
+     * @internal
+     */
+    var SurfaceTimelineState = /** @class */ (function (_super) {
+        __extends(SurfaceTimelineState, _super);
+        function SurfaceTimelineState() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._current = [];
+            _this._delta = [];
+            _this._result = [];
+            return _this;
+        }
+        SurfaceTimelineState.toString = function () {
+            return "[class dragonBones.SurfaceTimelineState]";
+        };
+        SurfaceTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.surface = null;
+            this._frameFloatOffset = 0;
+            this._valueCount = 0;
+            this._deformCount = 0;
+            this._valueOffset = 0;
+            this._current.length = 0;
+            this._delta.length = 0;
+            this._result.length = 0;
+        };
+        SurfaceTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData !== null) {
+                var valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset + this._frameIndex * this._valueCount;
+                var scale = this._armature._armatureData.scale;
+                var frameFloatArray = this._frameFloatArray;
+                if (this._tweenState === 2 /* Always */) {
+                    var nextValueOffset = valueOffset + this._valueCount;
+                    if (this._frameIndex === this._frameCount - 1) {
+                        nextValueOffset = this._animationData.frameFloatOffset + this._frameValueOffset;
+                    }
+                    for (var i = 0; i < this._valueCount; ++i) {
+                        this._delta[i] = frameFloatArray[nextValueOffset + i] * scale - (this._current[i] = frameFloatArray[valueOffset + i] * scale);
+                    }
+                }
+                else {
+                    for (var i = 0; i < this._valueCount; ++i) {
+                        this._current[i] = frameFloatArray[valueOffset + i] * scale;
+                    }
+                }
+            }
+            else {
+                for (var i = 0; i < this._valueCount; ++i) {
+                    this._current[i] = 0.0;
+                }
+            }
+        };
+        SurfaceTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            this.surface._transformDirty = true;
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            for (var i = 0; i < this._valueCount; ++i) {
+                this._result[i] = this._current[i] + this._delta[i] * this._tweenProgress;
+            }
+        };
+        SurfaceTimelineState.prototype.init = function (armature, animationState, timelineData) {
+            _super.prototype.init.call(this, armature, animationState, timelineData);
+            if (this._timelineData !== null) {
+                var frameIntOffset = this._animationData.frameIntOffset + this._timelineArray[this._timelineData.offset + 3 /* TimelineFrameValueCount */];
+                this._deformCount = this._frameIntArray[frameIntOffset + 1 /* DeformCount */];
+                this._valueCount = this._frameIntArray[frameIntOffset + 2 /* DeformValueCount */];
+                this._valueOffset = this._frameIntArray[frameIntOffset + 3 /* DeformValueOffset */];
+                this._frameFloatOffset = this._frameIntArray[frameIntOffset + 4 /* DeformFloatOffset */] + this._animationData.frameFloatOffset;
+            }
+            else {
+                this._deformCount = this.surface._deformVertices.length;
+                this._valueCount = this._deformCount;
+                this._valueOffset = 0;
+                this._frameFloatOffset = 0;
+            }
+            this._current.length = this._valueCount;
+            this._delta.length = this._valueCount;
+            this._result.length = this._valueCount;
+            for (var i = 0; i < this._valueCount; ++i) {
+                this._delta[i] = 0.0;
+            }
+        };
+        SurfaceTimelineState.prototype.blend = function (state) {
+            var blendWeight = this.surface._blendState.blendWeight;
+            var result = this.surface._deformVertices;
+            for (var i = 0; i < this._deformCount; ++i) {
+                var value = 0.0;
+                if (i < this._valueOffset) {
+                    value = this._frameFloatArray[this._frameFloatOffset + i];
+                }
+                else if (i < this._valueOffset + this._valueCount) {
+                    value = this._result[i - this._valueOffset];
+                }
+                else {
+                    value = this._frameFloatArray[this._frameFloatOffset + i - this._valueCount];
+                }
+                if (state === 2) {
+                    result[i] += value * blendWeight;
+                }
+                else if (blendWeight !== 1.0) {
+                    result[i] = value * blendWeight;
+                }
+                else {
+                    result[i] = value;
+                }
+            }
+            if (this._animationState._fadeState !== 0 || this._animationState._subFadeState !== 0) {
+                this.surface._transformDirty = true;
+            }
+        };
+        return SurfaceTimelineState;
+    }(dragonBones.TweenTimelineState));
+    dragonBones.SurfaceTimelineState = SurfaceTimelineState;
+    /**
+     * @internal
+     */
+    var SlotDislayTimelineState = /** @class */ (function (_super) {
+        __extends(SlotDislayTimelineState, _super);
+        function SlotDislayTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        SlotDislayTimelineState.toString = function () {
+            return "[class dragonBones.SlotDislayTimelineState]";
+        };
+        SlotDislayTimelineState.prototype._onArriveAtFrame = function () {
+            if (this.playState >= 0) {
+                var displayIndex = this._timelineData !== null ? this._frameArray[this._frameOffset + 1] : this.slot._slotData.displayIndex;
+                if (this.slot.displayIndex !== displayIndex) {
+                    this.slot._setDisplayIndex(displayIndex, true);
+                }
+            }
+        };
+        return SlotDislayTimelineState;
+    }(dragonBones.SlotTimelineState));
+    dragonBones.SlotDislayTimelineState = SlotDislayTimelineState;
+    /**
+     * @internal
+     */
+    var SlotColorTimelineState = /** @class */ (function (_super) {
+        __extends(SlotColorTimelineState, _super);
+        function SlotColorTimelineState() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._current = [0, 0, 0, 0, 0, 0, 0, 0];
+            _this._delta = [0, 0, 0, 0, 0, 0, 0, 0];
+            _this._result = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
+            return _this;
+        }
+        SlotColorTimelineState.toString = function () {
+            return "[class dragonBones.SlotColorTimelineState]";
+        };
+        SlotColorTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this._dirty = false;
+        };
+        SlotColorTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData !== null) {
+                var intArray = this._dragonBonesData.intArray;
+                var frameIntArray = this._frameIntArray;
+                var valueOffset = this._animationData.frameIntOffset + this._frameValueOffset + this._frameIndex * 1; // ...(timeline value offset)|x|x|(Value offset)|(Next offset)|x|x|...
+                var colorOffset = frameIntArray[valueOffset];
+                if (colorOffset < 0) {
+                    colorOffset += 65536; // Fixed out of bouds bug. 
+                }
+                this._current[0] = intArray[colorOffset++];
+                this._current[1] = intArray[colorOffset++];
+                this._current[2] = intArray[colorOffset++];
+                this._current[3] = intArray[colorOffset++];
+                this._current[4] = intArray[colorOffset++];
+                this._current[5] = intArray[colorOffset++];
+                this._current[6] = intArray[colorOffset++];
+                this._current[7] = intArray[colorOffset++];
+                if (this._tweenState === 2 /* Always */) {
+                    if (this._frameIndex === this._frameCount - 1) {
+                        colorOffset = frameIntArray[this._animationData.frameIntOffset + this._frameValueOffset];
+                    }
+                    else {
+                        colorOffset = frameIntArray[valueOffset + 1 * 1];
+                    }
+                    if (colorOffset < 0) {
+                        colorOffset += 65536; // Fixed out of bouds bug. 
+                    }
+                    this._delta[0] = intArray[colorOffset++] - this._current[0];
+                    this._delta[1] = intArray[colorOffset++] - this._current[1];
+                    this._delta[2] = intArray[colorOffset++] - this._current[2];
+                    this._delta[3] = intArray[colorOffset++] - this._current[3];
+                    this._delta[4] = intArray[colorOffset++] - this._current[4];
+                    this._delta[5] = intArray[colorOffset++] - this._current[5];
+                    this._delta[6] = intArray[colorOffset++] - this._current[6];
+                    this._delta[7] = intArray[colorOffset++] - this._current[7];
+                }
+            }
+            else {
+                var color = this.slot._slotData.color;
+                this._current[0] = color.alphaMultiplier * 100.0;
+                this._current[1] = color.redMultiplier * 100.0;
+                this._current[2] = color.greenMultiplier * 100.0;
+                this._current[3] = color.blueMultiplier * 100.0;
+                this._current[4] = color.alphaOffset;
+                this._current[5] = color.redOffset;
+                this._current[6] = color.greenOffset;
+                this._current[7] = color.blueOffset;
+            }
+        };
+        SlotColorTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            this._dirty = true;
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            this._result[0] = (this._current[0] + this._delta[0] * this._tweenProgress) * 0.01;
+            this._result[1] = (this._current[1] + this._delta[1] * this._tweenProgress) * 0.01;
+            this._result[2] = (this._current[2] + this._delta[2] * this._tweenProgress) * 0.01;
+            this._result[3] = (this._current[3] + this._delta[3] * this._tweenProgress) * 0.01;
+            this._result[4] = this._current[4] + this._delta[4] * this._tweenProgress;
+            this._result[5] = this._current[5] + this._delta[5] * this._tweenProgress;
+            this._result[6] = this._current[6] + this._delta[6] * this._tweenProgress;
+            this._result[7] = this._current[7] + this._delta[7] * this._tweenProgress;
+        };
+        SlotColorTimelineState.prototype.fadeOut = function () {
+            this._tweenState = 0 /* None */;
+            this._dirty = false;
+        };
+        SlotColorTimelineState.prototype.update = function (passedTime) {
+            _super.prototype.update.call(this, passedTime);
+            // Fade animation.
+            if (this._tweenState !== 0 /* None */ || this._dirty) {
+                var result = this.slot._colorTransform;
+                if (this._animationState._fadeState !== 0 || this._animationState._subFadeState !== 0) {
+                    if (result.alphaMultiplier !== this._result[0] ||
+                        result.redMultiplier !== this._result[1] ||
+                        result.greenMultiplier !== this._result[2] ||
+                        result.blueMultiplier !== this._result[3] ||
+                        result.alphaOffset !== this._result[4] ||
+                        result.redOffset !== this._result[5] ||
+                        result.greenOffset !== this._result[6] ||
+                        result.blueOffset !== this._result[7]) {
+                        var fadeProgress = Math.pow(this._animationState._fadeProgress, 4);
+                        result.alphaMultiplier += (this._result[0] - result.alphaMultiplier) * fadeProgress;
+                        result.redMultiplier += (this._result[1] - result.redMultiplier) * fadeProgress;
+                        result.greenMultiplier += (this._result[2] - result.greenMultiplier) * fadeProgress;
+                        result.blueMultiplier += (this._result[3] - result.blueMultiplier) * fadeProgress;
+                        result.alphaOffset += (this._result[4] - result.alphaOffset) * fadeProgress;
+                        result.redOffset += (this._result[5] - result.redOffset) * fadeProgress;
+                        result.greenOffset += (this._result[6] - result.greenOffset) * fadeProgress;
+                        result.blueOffset += (this._result[7] - result.blueOffset) * fadeProgress;
+                        this.slot._colorDirty = true;
+                    }
+                }
+                else if (this._dirty) {
+                    this._dirty = false;
+                    if (result.alphaMultiplier !== this._result[0] ||
+                        result.redMultiplier !== this._result[1] ||
+                        result.greenMultiplier !== this._result[2] ||
+                        result.blueMultiplier !== this._result[3] ||
+                        result.alphaOffset !== this._result[4] ||
+                        result.redOffset !== this._result[5] ||
+                        result.greenOffset !== this._result[6] ||
+                        result.blueOffset !== this._result[7]) {
+                        result.alphaMultiplier = this._result[0];
+                        result.redMultiplier = this._result[1];
+                        result.greenMultiplier = this._result[2];
+                        result.blueMultiplier = this._result[3];
+                        result.alphaOffset = this._result[4];
+                        result.redOffset = this._result[5];
+                        result.greenOffset = this._result[6];
+                        result.blueOffset = this._result[7];
+                        this.slot._colorDirty = true;
+                    }
+                }
+            }
+        };
+        return SlotColorTimelineState;
+    }(dragonBones.SlotTimelineState));
+    dragonBones.SlotColorTimelineState = SlotColorTimelineState;
+    /**
+     * @internal
+     */
+    var DeformTimelineState = /** @class */ (function (_super) {
+        __extends(DeformTimelineState, _super);
+        function DeformTimelineState() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._current = [];
+            _this._delta = [];
+            _this._result = [];
+            return _this;
+        }
+        DeformTimelineState.toString = function () {
+            return "[class dragonBones.DeformTimelineState]";
+        };
+        DeformTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.vertexOffset = 0;
+            this._dirty = false;
+            this._frameFloatOffset = 0;
+            this._valueCount = 0;
+            this._deformCount = 0;
+            this._valueOffset = 0;
+            this._current.length = 0;
+            this._delta.length = 0;
+            this._result.length = 0;
+        };
+        DeformTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData !== null) {
+                var valueOffset = this._animationData.frameFloatOffset + this._frameValueOffset + this._frameIndex * this._valueCount;
+                var scale = this._armature._armatureData.scale;
+                var frameFloatArray = this._frameFloatArray;
+                if (this._tweenState === 2 /* Always */) {
+                    var nextValueOffset = valueOffset + this._valueCount;
+                    if (this._frameIndex === this._frameCount - 1) {
+                        nextValueOffset = this._animationData.frameFloatOffset + this._frameValueOffset;
+                    }
+                    for (var i = 0; i < this._valueCount; ++i) {
+                        this._delta[i] = frameFloatArray[nextValueOffset + i] * scale - (this._current[i] = frameFloatArray[valueOffset + i] * scale);
+                    }
+                }
+                else {
+                    for (var i = 0; i < this._valueCount; ++i) {
+                        this._current[i] = frameFloatArray[valueOffset + i] * scale;
+                    }
+                }
+            }
+            else {
+                for (var i = 0; i < this._valueCount; ++i) {
+                    this._current[i] = 0.0;
+                }
+            }
+        };
+        DeformTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            this._dirty = true;
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            for (var i = 0; i < this._valueCount; ++i) {
+                this._result[i] = this._current[i] + this._delta[i] * this._tweenProgress;
+            }
+        };
+        DeformTimelineState.prototype.init = function (armature, animationState, timelineData) {
+            _super.prototype.init.call(this, armature, animationState, timelineData);
+            if (this._timelineData !== null) {
+                var frameIntOffset = this._animationData.frameIntOffset + this._timelineArray[this._timelineData.offset + 3 /* TimelineFrameValueCount */];
+                this.vertexOffset = this._frameIntArray[frameIntOffset + 0 /* DeformVertexOffset */];
+                if (this.vertexOffset < 0) {
+                    this.vertexOffset += 65536; // Fixed out of bouds bug. 
+                }
+                this._deformCount = this._frameIntArray[frameIntOffset + 1 /* DeformCount */];
+                this._valueCount = this._frameIntArray[frameIntOffset + 2 /* DeformValueCount */];
+                this._valueOffset = this._frameIntArray[frameIntOffset + 3 /* DeformValueOffset */];
+                this._frameFloatOffset = this._frameIntArray[frameIntOffset + 4 /* DeformFloatOffset */] + this._animationData.frameFloatOffset;
+            }
+            else {
+                var deformVertices = this.slot._deformVertices;
+                this._deformCount = deformVertices !== null ? deformVertices.vertices.length : 0;
+                this._valueCount = this._deformCount;
+                this._valueOffset = 0;
+                this._frameFloatOffset = 0;
+            }
+            this._current.length = this._valueCount;
+            this._delta.length = this._valueCount;
+            this._result.length = this._valueCount;
+            for (var i = 0; i < this._valueCount; ++i) {
+                this._delta[i] = 0.0;
+            }
+        };
+        DeformTimelineState.prototype.fadeOut = function () {
+            this._tweenState = 0 /* None */;
+            this._dirty = false;
+        };
+        DeformTimelineState.prototype.update = function (passedTime) {
+            var deformVertices = this.slot._deformVertices;
+            if (deformVertices === null || deformVertices.verticesData === null || deformVertices.verticesData.offset !== this.vertexOffset) {
+                return;
+            }
+            _super.prototype.update.call(this, passedTime);
+            // Fade animation.
+            if (this._tweenState !== 0 /* None */ || this._dirty) {
+                var result = deformVertices.vertices;
+                if (this._animationState._fadeState !== 0 || this._animationState._subFadeState !== 0) {
+                    var fadeProgress = Math.pow(this._animationState._fadeProgress, 2);
+                    for (var i = 0; i < this._deformCount; ++i) {
+                        if (i < this._valueOffset) {
+                            result[i] += (this._frameFloatArray[this._frameFloatOffset + i] - result[i]) * fadeProgress;
+                        }
+                        else if (i < this._valueOffset + this._valueCount) {
+                            result[i] += (this._result[i - this._valueOffset] - result[i]) * fadeProgress;
+                        }
+                        else {
+                            result[i] += (this._frameFloatArray[this._frameFloatOffset + i - this._valueCount] - result[i]) * fadeProgress;
+                        }
+                    }
+                    deformVertices.verticesDirty = true;
+                }
+                else if (this._dirty) {
+                    this._dirty = false;
+                    for (var i = 0; i < this._deformCount; ++i) {
+                        if (i < this._valueOffset) {
+                            result[i] = this._frameFloatArray[this._frameFloatOffset + i];
+                        }
+                        else if (i < this._valueOffset + this._valueCount) {
+                            result[i] = this._result[i - this._valueOffset];
+                        }
+                        else {
+                            result[i] = this._frameFloatArray[this._frameFloatOffset + i - this._valueCount];
+                        }
+                    }
+                    deformVertices.verticesDirty = true;
+                }
+            }
+        };
+        return DeformTimelineState;
+    }(dragonBones.SlotTimelineState));
+    dragonBones.DeformTimelineState = DeformTimelineState;
+    /**
+     * @internal
+     */
+    var IKConstraintTimelineState = /** @class */ (function (_super) {
+        __extends(IKConstraintTimelineState, _super);
+        function IKConstraintTimelineState() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        IKConstraintTimelineState.toString = function () {
+            return "[class dragonBones.IKConstraintTimelineState]";
+        };
+        IKConstraintTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this._current = 0.0;
+            this._delta = 0.0;
+        };
+        IKConstraintTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            var ikConstraint = this.constraint;
+            if (this._timelineData !== null) {
+                var valueOffset = this._animationData.frameIntOffset + this._frameValueOffset + this._frameIndex * 2;
+                var frameIntArray = this._frameIntArray;
+                var bendPositive = frameIntArray[valueOffset++] !== 0;
+                this._current = frameIntArray[valueOffset++] * 0.01;
+                if (this._tweenState === 2 /* Always */) {
+                    if (this._frameIndex === this._frameCount - 1) {
+                        valueOffset = this._animationData.frameIntOffset + this._frameValueOffset; // + 0 * 2
+                    }
+                    this._delta = frameIntArray[valueOffset + 1] * 0.01 - this._current;
+                }
+                else {
+                    this._delta = 0.0;
+                }
+                ikConstraint._bendPositive = bendPositive;
+            }
+            else {
+                var ikConstraintData = ikConstraint._constraintData;
+                this._current = ikConstraintData.weight;
+                this._delta = 0.0;
+                ikConstraint._bendPositive = ikConstraintData.bendPositive;
+            }
+            ikConstraint.invalidUpdate();
+        };
+        IKConstraintTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            var ikConstraint = this.constraint;
+            ikConstraint._weight = this._current + this._delta * this._tweenProgress;
+            ikConstraint.invalidUpdate();
+            // TODO fade update.
+        };
+        return IKConstraintTimelineState;
+    }(dragonBones.ConstraintTimelineState));
+    dragonBones.IKConstraintTimelineState = IKConstraintTimelineState;
+    /**
+     * @internal
+     */
+    var AnimationTimelineState = /** @class */ (function (_super) {
+        __extends(AnimationTimelineState, _super);
+        function AnimationTimelineState() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._floats = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
+            return _this;
+        }
+        AnimationTimelineState.toString = function () {
+            return "[class dragonBones.AnimationTimelineState]";
+        };
+        AnimationTimelineState.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this.animationState = null;
+        };
+        AnimationTimelineState.prototype._onArriveAtFrame = function () {
+            _super.prototype._onArriveAtFrame.call(this);
+            if (this._timelineData === null) {
+                return;
+            }
+            var valueOffset = this._animationData.frameIntOffset + this._frameValueOffset + this._frameIndex * 2;
+            var frameRateR = 1.0 / this.animationState._animationData.parent.frameRate;
+            var frameIntArray = this._frameIntArray;
+            this._floats[0] = frameIntArray[valueOffset++] * frameRateR;
+            this._floats[3] = frameIntArray[valueOffset++] * 0.01;
+            if (this._tweenState === 2 /* Always */) {
+                if (this._frameIndex === this._frameCount - 1) {
+                    valueOffset = this._animationData.frameIntOffset + this._frameValueOffset; // + 0 * 2
+                }
+                this._floats[1] = frameIntArray[valueOffset++] * frameRateR - this._floats[0];
+                this._floats[4] = frameIntArray[valueOffset++] * 0.01 - this._floats[3];
+            }
+            else {
+                this._floats[1] = 0.0;
+                this._floats[4] = 0.0;
+            }
+        };
+        AnimationTimelineState.prototype._onUpdateFrame = function () {
+            _super.prototype._onUpdateFrame.call(this);
+            if (this._tweenState !== 2 /* Always */) {
+                this._tweenState = 0 /* None */;
+            }
+            if (this._floats[0] >= 0.0) {
+                this._floats[2] = this._floats[0] + this._floats[1] * this._tweenProgress;
+            }
+            this._floats[5] = this._floats[3] + this._floats[4] * this._tweenProgress;
+        };
+        AnimationTimelineState.prototype.blend = function (state) {
+            var animationState = this.animationState;
+            var blendWeight = animationState._blendState.blendWeight;
+            if (state === 2) {
+                animationState.weight += this._floats[5] * blendWeight;
+                animationState.currentTime += this._floats[2] * blendWeight;
+            }
+            else {
+                animationState.weight = this._floats[5] * blendWeight;
+                animationState.currentTime = this._floats[2] * blendWeight;
+            }
+        };
+        return AnimationTimelineState;
+    }(dragonBones.TweenTimelineState));
+    dragonBones.AnimationTimelineState = AnimationTimelineState;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The properties of the object carry basic information about an event,
+     * which are passed as parameter or parameter's parameter to event listeners when an event occurs.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - 事件对象，包含有关事件的基本信息，当发生事件时，该实例将作为参数或参数的参数传递给事件侦听器。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    var EventObject = /** @class */ (function (_super) {
+        __extends(EventObject, _super);
+        function EventObject() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        /**
+         * @internal
+         * @private
+         */
+        EventObject.actionDataToInstance = function (data, instance, armature) {
+            if (data.type === 0 /* Play */) {
+                instance.type = EventObject.FRAME_EVENT;
+            }
+            else {
+                instance.type = data.type === 10 /* Frame */ ? EventObject.FRAME_EVENT : EventObject.SOUND_EVENT;
+            }
+            instance.name = data.name;
+            instance.armature = armature;
+            instance.actionData = data;
+            instance.data = data.data;
+            if (data.bone !== null) {
+                instance.bone = armature.getBone(data.bone.name);
+            }
+            if (data.slot !== null) {
+                instance.slot = armature.getSlot(data.slot.name);
+            }
+        };
+        EventObject.toString = function () {
+            return "[class dragonBones.EventObject]";
+        };
+        EventObject.prototype._onClear = function () {
+            this.time = 0.0;
+            this.type = "";
+            this.name = "";
+            this.armature = null;
+            this.bone = null;
+            this.slot = null;
+            this.animationState = null;
+            this.actionData = null;
+            this.data = null;
+        };
+        /**
+         * - Animation start play.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画开始播放。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.START = "start";
+        /**
+         * - Animation loop play complete once.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画循环播放完成一次。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.LOOP_COMPLETE = "loopComplete";
+        /**
+         * - Animation play complete.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画播放完成。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.COMPLETE = "complete";
+        /**
+         * - Animation fade in start.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡入开始。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.FADE_IN = "fadeIn";
+        /**
+         * - Animation fade in complete.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡入完成。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.FADE_IN_COMPLETE = "fadeInComplete";
+        /**
+         * - Animation fade out start.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡出开始。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.FADE_OUT = "fadeOut";
+        /**
+         * - Animation fade out complete.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画淡出完成。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.FADE_OUT_COMPLETE = "fadeOutComplete";
+        /**
+         * - Animation frame event.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画帧事件。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.FRAME_EVENT = "frameEvent";
+        /**
+         * - Animation frame sound event.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 动画帧声音事件。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        EventObject.SOUND_EVENT = "soundEvent";
+        return EventObject;
+    }(dragonBones.BaseObject));
+    dragonBones.EventObject = EventObject;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var DataParser = /** @class */ (function () {
+        function DataParser() {
+        }
+        DataParser._getArmatureType = function (value) {
+            switch (value.toLowerCase()) {
+                case "stage":
+                    return 2 /* Stage */;
+                case "armature":
+                    return 0 /* Armature */;
+                case "movieclip":
+                    return 1 /* MovieClip */;
+                default:
+                    return 0 /* Armature */;
+            }
+        };
+        DataParser._getBoneType = function (value) {
+            switch (value.toLowerCase()) {
+                case "bone":
+                    return 0 /* Bone */;
+                case "surface":
+                    return 1 /* Surface */;
+                default:
+                    return 0 /* Bone */;
+            }
+        };
+        DataParser._getDisplayType = function (value) {
+            switch (value.toLowerCase()) {
+                case "image":
+                    return 0 /* Image */;
+                case "mesh":
+                    return 2 /* Mesh */;
+                case "armature":
+                    return 1 /* Armature */;
+                case "boundingbox":
+                    return 3 /* BoundingBox */;
+                case "path":
+                    return 4 /* Path */;
+                default:
+                    return 0 /* Image */;
+            }
+        };
+        DataParser._getBoundingBoxType = function (value) {
+            switch (value.toLowerCase()) {
+                case "rectangle":
+                    return 0 /* Rectangle */;
+                case "ellipse":
+                    return 1 /* Ellipse */;
+                case "polygon":
+                    return 2 /* Polygon */;
+                default:
+                    return 0 /* Rectangle */;
+            }
+        };
+        DataParser._getActionType = function (value) {
+            switch (value.toLowerCase()) {
+                case "play":
+                    return 0 /* Play */;
+                case "frame":
+                    return 10 /* Frame */;
+                case "sound":
+                    return 11 /* Sound */;
+                default:
+                    return 0 /* Play */;
+            }
+        };
+        DataParser._getBlendMode = function (value) {
+            switch (value.toLowerCase()) {
+                case "normal":
+                    return 0 /* Normal */;
+                case "add":
+                    return 1 /* Add */;
+                case "alpha":
+                    return 2 /* Alpha */;
+                case "darken":
+                    return 3 /* Darken */;
+                case "difference":
+                    return 4 /* Difference */;
+                case "erase":
+                    return 5 /* Erase */;
+                case "hardlight":
+                    return 6 /* HardLight */;
+                case "invert":
+                    return 7 /* Invert */;
+                case "layer":
+                    return 8 /* Layer */;
+                case "lighten":
+                    return 9 /* Lighten */;
+                case "multiply":
+                    return 10 /* Multiply */;
+                case "overlay":
+                    return 11 /* Overlay */;
+                case "screen":
+                    return 12 /* Screen */;
+                case "subtract":
+                    return 13 /* Subtract */;
+                default:
+                    return 0 /* Normal */;
+            }
+        };
+        DataParser._getPositionMode = function (value) {
+            switch (value.toLocaleLowerCase()) {
+                case "percent":
+                    return 1 /* Percent */;
+                case "fixed":
+                    return 0 /* Fixed */;
+                default:
+                    return 1 /* Percent */;
+            }
+        };
+        DataParser._getSpacingMode = function (value) {
+            switch (value.toLocaleLowerCase()) {
+                case "length":
+                    return 0 /* Length */;
+                case "percent":
+                    return 2 /* Percent */;
+                case "fixed":
+                    return 1 /* Fixed */;
+                default:
+                    return 0 /* Length */;
+            }
+        };
+        DataParser._getRotateMode = function (value) {
+            switch (value.toLocaleLowerCase()) {
+                case "tangent":
+                    return 0 /* Tangent */;
+                case "chain":
+                    return 1 /* Chain */;
+                case "chainscale":
+                    return 2 /* ChainScale */;
+                default:
+                    return 0 /* Tangent */;
+            }
+        };
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parsetTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parsetTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        DataParser.parseDragonBonesData = function (rawData) {
+            console.warn("Deprecated.");
+            if (rawData instanceof ArrayBuffer) {
+                return dragonBones.BinaryDataParser.getInstance().parseDragonBonesData(rawData);
+            }
+            else {
+                return dragonBones.ObjectDataParser.getInstance().parseDragonBonesData(rawData);
+            }
+        };
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parsetTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parsetTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        DataParser.parseTextureAtlasData = function (rawData, scale) {
+            if (scale === void 0) { scale = 1; }
+            console.warn("已废弃");
+            var textureAtlasData = {};
+            var subTextureList = rawData[DataParser.SUB_TEXTURE];
+            for (var i = 0, len = subTextureList.length; i < len; i++) {
+                var subTextureObject = subTextureList[i];
+                var subTextureName = subTextureObject[DataParser.NAME];
+                var subTextureRegion = new dragonBones.Rectangle();
+                var subTextureFrame = null;
+                subTextureRegion.x = subTextureObject[DataParser.X] / scale;
+                subTextureRegion.y = subTextureObject[DataParser.Y] / scale;
+                subTextureRegion.width = subTextureObject[DataParser.WIDTH] / scale;
+                subTextureRegion.height = subTextureObject[DataParser.HEIGHT] / scale;
+                if (DataParser.FRAME_WIDTH in subTextureObject) {
+                    subTextureFrame = new dragonBones.Rectangle();
+                    subTextureFrame.x = subTextureObject[DataParser.FRAME_X] / scale;
+                    subTextureFrame.y = subTextureObject[DataParser.FRAME_Y] / scale;
+                    subTextureFrame.width = subTextureObject[DataParser.FRAME_WIDTH] / scale;
+                    subTextureFrame.height = subTextureObject[DataParser.FRAME_HEIGHT] / scale;
+                }
+                textureAtlasData[subTextureName] = { region: subTextureRegion, frame: subTextureFrame, rotated: false };
+            }
+            return textureAtlasData;
+        };
+        DataParser.DATA_VERSION_2_3 = "2.3";
+        DataParser.DATA_VERSION_3_0 = "3.0";
+        DataParser.DATA_VERSION_4_0 = "4.0";
+        DataParser.DATA_VERSION_4_5 = "4.5";
+        DataParser.DATA_VERSION_5_0 = "5.0";
+        DataParser.DATA_VERSION_5_5 = "5.5";
+        DataParser.DATA_VERSION = DataParser.DATA_VERSION_5_5;
+        DataParser.DATA_VERSIONS = [
+            DataParser.DATA_VERSION_4_0,
+            DataParser.DATA_VERSION_4_5,
+            DataParser.DATA_VERSION_5_0,
+            DataParser.DATA_VERSION_5_5
+        ];
+        DataParser.TEXTURE_ATLAS = "textureAtlas";
+        DataParser.SUB_TEXTURE = "SubTexture";
+        DataParser.FORMAT = "format";
+        DataParser.IMAGE_PATH = "imagePath";
+        DataParser.WIDTH = "width";
+        DataParser.HEIGHT = "height";
+        DataParser.ROTATED = "rotated";
+        DataParser.FRAME_X = "frameX";
+        DataParser.FRAME_Y = "frameY";
+        DataParser.FRAME_WIDTH = "frameWidth";
+        DataParser.FRAME_HEIGHT = "frameHeight";
+        DataParser.DRADON_BONES = "dragonBones";
+        DataParser.USER_DATA = "userData";
+        DataParser.ARMATURE = "armature";
+        DataParser.BONE = "bone";
+        DataParser.SURFACE = "surface";
+        DataParser.SLOT = "slot";
+        DataParser.CONSTRAINT = "constraint";
+        DataParser.IK = "ik";
+        DataParser.PATH_CONSTRAINT = "path";
+        DataParser.SKIN = "skin";
+        DataParser.DISPLAY = "display";
+        DataParser.ANIMATION = "animation";
+        DataParser.Z_ORDER = "zOrder";
+        DataParser.FFD = "ffd";
+        DataParser.FRAME = "frame";
+        DataParser.TRANSLATE_FRAME = "translateFrame";
+        DataParser.ROTATE_FRAME = "rotateFrame";
+        DataParser.SCALE_FRAME = "scaleFrame";
+        DataParser.DISPLAY_FRAME = "displayFrame";
+        DataParser.COLOR_FRAME = "colorFrame";
+        DataParser.DEFAULT_ACTIONS = "defaultActions";
+        DataParser.ACTIONS = "actions";
+        DataParser.EVENTS = "events";
+        DataParser.INTS = "ints";
+        DataParser.FLOATS = "floats";
+        DataParser.STRINGS = "strings";
+        DataParser.CANVAS = "canvas";
+        DataParser.TRANSFORM = "transform";
+        DataParser.PIVOT = "pivot";
+        DataParser.AABB = "aabb";
+        DataParser.COLOR = "color";
+        DataParser.VERSION = "version";
+        DataParser.COMPATIBLE_VERSION = "compatibleVersion";
+        DataParser.FRAME_RATE = "frameRate";
+        DataParser.TYPE = "type";
+        DataParser.SUB_TYPE = "subType";
+        DataParser.NAME = "name";
+        DataParser.PARENT = "parent";
+        DataParser.TARGET = "target";
+        DataParser.STAGE = "stage";
+        DataParser.SHARE = "share";
+        DataParser.PATH = "path";
+        DataParser.LENGTH = "length";
+        DataParser.DISPLAY_INDEX = "displayIndex";
+        DataParser.BLEND_MODE = "blendMode";
+        DataParser.INHERIT_TRANSLATION = "inheritTranslation";
+        DataParser.INHERIT_ROTATION = "inheritRotation";
+        DataParser.INHERIT_SCALE = "inheritScale";
+        DataParser.INHERIT_REFLECTION = "inheritReflection";
+        DataParser.INHERIT_ANIMATION = "inheritAnimation";
+        DataParser.INHERIT_DEFORM = "inheritDeform";
+        DataParser.SEGMENT_X = "segmentX";
+        DataParser.SEGMENT_Y = "segmentY";
+        DataParser.BEND_POSITIVE = "bendPositive";
+        DataParser.CHAIN = "chain";
+        DataParser.WEIGHT = "weight";
+        DataParser.FADE_IN_TIME = "fadeInTime";
+        DataParser.PLAY_TIMES = "playTimes";
+        DataParser.SCALE = "scale";
+        DataParser.OFFSET = "offset";
+        DataParser.POSITION = "position";
+        DataParser.DURATION = "duration";
+        DataParser.TWEEN_EASING = "tweenEasing";
+        DataParser.TWEEN_ROTATE = "tweenRotate";
+        DataParser.TWEEN_SCALE = "tweenScale";
+        DataParser.CLOCK_WISE = "clockwise";
+        DataParser.CURVE = "curve";
+        DataParser.SOUND = "sound";
+        DataParser.EVENT = "event";
+        DataParser.ACTION = "action";
+        DataParser.X = "x";
+        DataParser.Y = "y";
+        DataParser.SKEW_X = "skX";
+        DataParser.SKEW_Y = "skY";
+        DataParser.SCALE_X = "scX";
+        DataParser.SCALE_Y = "scY";
+        DataParser.VALUE = "value";
+        DataParser.ROTATE = "rotate";
+        DataParser.SKEW = "skew";
+        DataParser.ALPHA_OFFSET = "aO";
+        DataParser.RED_OFFSET = "rO";
+        DataParser.GREEN_OFFSET = "gO";
+        DataParser.BLUE_OFFSET = "bO";
+        DataParser.ALPHA_MULTIPLIER = "aM";
+        DataParser.RED_MULTIPLIER = "rM";
+        DataParser.GREEN_MULTIPLIER = "gM";
+        DataParser.BLUE_MULTIPLIER = "bM";
+        DataParser.UVS = "uvs";
+        DataParser.VERTICES = "vertices";
+        DataParser.TRIANGLES = "triangles";
+        DataParser.WEIGHTS = "weights";
+        DataParser.SLOT_POSE = "slotPose";
+        DataParser.BONE_POSE = "bonePose";
+        DataParser.GLUE_WEIGHTS = "glueWeights";
+        DataParser.GLUE_MESHES = "glueMeshes";
+        DataParser.BONES = "bones";
+        DataParser.POSITION_MODE = "positionMode";
+        DataParser.SPACING_MODE = "spacingMode";
+        DataParser.ROTATE_MODE = "rotateMode";
+        DataParser.SPACING = "spacing";
+        DataParser.ROTATE_OFFSET = "rotateOffset";
+        DataParser.ROTATE_MIX = "rotateMix";
+        DataParser.TRANSLATE_MIX = "translateMix";
+        DataParser.TARGET_DISPLAY = "targetDisplay";
+        DataParser.CLOSED = "closed";
+        DataParser.CONSTANT_SPEED = "constantSpeed";
+        DataParser.VERTEX_COUNT = "vertexCount";
+        DataParser.LENGTHS = "lengths";
+        DataParser.GOTO_AND_PLAY = "gotoAndPlay";
+        DataParser.DEFAULT_NAME = "default";
+        return DataParser;
+    }());
+    dragonBones.DataParser = DataParser;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var ObjectDataParser = /** @class */ (function (_super) {
+        __extends(ObjectDataParser, _super);
+        function ObjectDataParser() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._rawTextureAtlasIndex = 0;
+            _this._rawBones = [];
+            _this._data = null; //
+            _this._armature = null; //
+            _this._bone = null; //
+            _this._surface = null; //
+            _this._slot = null; //
+            _this._skin = null; //
+            _this._mesh = null; //
+            _this._animation = null; //
+            _this._timeline = null; //
+            _this._rawTextureAtlases = null;
+            _this._defaultColorOffset = -1;
+            _this._prevClockwise = 0;
+            _this._prevRotation = 0.0;
+            _this._helpMatrixA = new dragonBones.Matrix();
+            _this._helpMatrixB = new dragonBones.Matrix();
+            _this._helpTransform = new dragonBones.Transform();
+            _this._helpColorTransform = new dragonBones.ColorTransform();
+            _this._helpPoint = new dragonBones.Point();
+            _this._helpArray = [];
+            _this._intArray = [];
+            _this._floatArray = [];
+            _this._frameIntArray = [];
+            _this._frameFloatArray = [];
+            _this._frameArray = [];
+            _this._timelineArray = [];
+            _this._cacheRawMeshes = [];
+            _this._cacheMeshes = [];
+            _this._actionFrames = [];
+            _this._weightSlotPose = {};
+            _this._weightBonePoses = {};
+            _this._cacheBones = {};
+            _this._slotChildActions = {};
+            return _this;
+        }
+        ObjectDataParser._getBoolean = function (rawData, key, defaultValue) {
+            if (key in rawData) {
+                var value = rawData[key];
+                var type = typeof value;
+                if (type === "boolean") {
+                    return value;
+                }
+                else if (type === "string") {
+                    switch (value) {
+                        case "0":
+                        case "NaN":
+                        case "":
+                        case "false":
+                        case "null":
+                        case "undefined":
+                            return false;
+                        default:
+                            return true;
+                    }
+                }
+                else {
+                    return !!value;
+                }
+            }
+            return defaultValue;
+        };
+        ObjectDataParser._getNumber = function (rawData, key, defaultValue) {
+            if (key in rawData) {
+                var value = rawData[key];
+                if (value === null || value === "NaN") {
+                    return defaultValue;
+                }
+                return +value || 0;
+            }
+            return defaultValue;
+        };
+        ObjectDataParser._getString = function (rawData, key, defaultValue) {
+            if (key in rawData) {
+                var value = rawData[key];
+                var type = typeof value;
+                if (type === "string") {
+                    if (dragonBones.DragonBones.webAssembly) {
+                        for (var i = 0, l = value.length; i < l; ++i) {
+                            if (value.charCodeAt(i) > 255) {
+                                return encodeURI(value);
+                            }
+                        }
+                    }
+                    return value;
+                }
+                return String(value);
+            }
+            return defaultValue;
+        };
+        ObjectDataParser.prototype._getCurvePoint = function (x1, y1, x2, y2, x3, y3, x4, y4, t, result) {
+            var l_t = 1.0 - t;
+            var powA = l_t * l_t;
+            var powB = t * t;
+            var kA = l_t * powA;
+            var kB = 3.0 * t * powA;
+            var kC = 3.0 * l_t * powB;
+            var kD = t * powB;
+            result.x = kA * x1 + kB * x2 + kC * x3 + kD * x4;
+            result.y = kA * y1 + kB * y2 + kC * y3 + kD * y4;
+        };
+        ObjectDataParser.prototype._samplingEasingCurve = function (curve, samples) {
+            var curveCount = curve.length;
+            var stepIndex = -2;
+            for (var i = 0, l = samples.length; i < l; ++i) {
+                var t = (i + 1) / (l + 1); // float
+                while ((stepIndex + 6 < curveCount ? curve[stepIndex + 6] : 1) < t) {
+                    stepIndex += 6;
+                }
+                var isInCurve = stepIndex >= 0 && stepIndex + 6 < curveCount;
+                var x1 = isInCurve ? curve[stepIndex] : 0.0;
+                var y1 = isInCurve ? curve[stepIndex + 1] : 0.0;
+                var x2 = curve[stepIndex + 2];
+                var y2 = curve[stepIndex + 3];
+                var x3 = curve[stepIndex + 4];
+                var y3 = curve[stepIndex + 5];
+                var x4 = isInCurve ? curve[stepIndex + 6] : 1.0;
+                var y4 = isInCurve ? curve[stepIndex + 7] : 1.0;
+                var lower = 0.0;
+                var higher = 1.0;
+                while (higher - lower > 0.0001) {
+                    var percentage = (higher + lower) * 0.5;
+                    this._getCurvePoint(x1, y1, x2, y2, x3, y3, x4, y4, percentage, this._helpPoint);
+                    if (t - this._helpPoint.x > 0.0) {
+                        lower = percentage;
+                    }
+                    else {
+                        higher = percentage;
+                    }
+                }
+                samples[i] = this._helpPoint.y;
+            }
+        };
+        ObjectDataParser.prototype._parseActionDataInFrame = function (rawData, frameStart, bone, slot) {
+            if (dragonBones.DataParser.EVENT in rawData) {
+                this._mergeActionFrame(rawData[dragonBones.DataParser.EVENT], frameStart, 10 /* Frame */, bone, slot);
+            }
+            if (dragonBones.DataParser.SOUND in rawData) {
+                this._mergeActionFrame(rawData[dragonBones.DataParser.SOUND], frameStart, 11 /* Sound */, bone, slot);
+            }
+            if (dragonBones.DataParser.ACTION in rawData) {
+                this._mergeActionFrame(rawData[dragonBones.DataParser.ACTION], frameStart, 0 /* Play */, bone, slot);
+            }
+            if (dragonBones.DataParser.EVENTS in rawData) {
+                this._mergeActionFrame(rawData[dragonBones.DataParser.EVENTS], frameStart, 10 /* Frame */, bone, slot);
+            }
+            if (dragonBones.DataParser.ACTIONS in rawData) {
+                this._mergeActionFrame(rawData[dragonBones.DataParser.ACTIONS], frameStart, 0 /* Play */, bone, slot);
+            }
+        };
+        ObjectDataParser.prototype._mergeActionFrame = function (rawData, frameStart, type, bone, slot) {
+            var actionOffset = dragonBones.DragonBones.webAssembly ? this._armature.actions.size() : this._armature.actions.length;
+            var actions = this._parseActionData(rawData, type, bone, slot);
+            var frameIndex = 0;
+            var frame = null;
+            for (var _i = 0, actions_2 = actions; _i < actions_2.length; _i++) {
+                var action = actions_2[_i];
+                this._armature.addAction(action, false);
+            }
+            if (this._actionFrames.length === 0) {
+                frame = new ActionFrame();
+                frame.frameStart = 0;
+                this._actionFrames.push(frame);
+                frame = null;
+            }
+            for (var _a = 0, _b = this._actionFrames; _a < _b.length; _a++) {
+                var eachFrame = _b[_a];
+                if (eachFrame.frameStart === frameStart) {
+                    frame = eachFrame;
+                    break;
+                }
+                else if (eachFrame.frameStart > frameStart) {
+                    break;
+                }
+                frameIndex++;
+            }
+            if (frame === null) {
+                frame = new ActionFrame();
+                frame.frameStart = frameStart;
+                this._actionFrames.splice(frameIndex + 1, 0, frame);
+            }
+            for (var i = 0; i < actions.length; ++i) {
+                frame.actions.push(actionOffset + i);
+            }
+        };
+        ObjectDataParser.prototype._parseArmature = function (rawData, scale) {
+            var armature = dragonBones.BaseObject.borrowObject(dragonBones.ArmatureData);
+            armature.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+            armature.frameRate = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.FRAME_RATE, this._data.frameRate);
+            armature.scale = scale;
+            if (dragonBones.DataParser.TYPE in rawData && typeof rawData[dragonBones.DataParser.TYPE] === "string") {
+                armature.type = dragonBones.DataParser._getArmatureType(rawData[dragonBones.DataParser.TYPE]);
+            }
+            else {
+                armature.type = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.TYPE, 0 /* Armature */);
+            }
+            if (armature.frameRate === 0) {
+                armature.frameRate = 24;
+            }
+            this._armature = armature;
+            if (dragonBones.DataParser.CANVAS in rawData) {
+                var rawCanvas = rawData[dragonBones.DataParser.CANVAS];
+                var canvas = dragonBones.BaseObject.borrowObject(dragonBones.CanvasData);
+                if (dragonBones.DataParser.COLOR in rawCanvas) {
+                    canvas.hasBackground = true;
+                }
+                else {
+                    canvas.hasBackground = false;
+                }
+                canvas.color = ObjectDataParser._getNumber(rawCanvas, dragonBones.DataParser.COLOR, 0);
+                canvas.x = ObjectDataParser._getNumber(rawCanvas, dragonBones.DataParser.X, 0) * armature.scale;
+                canvas.y = ObjectDataParser._getNumber(rawCanvas, dragonBones.DataParser.Y, 0) * armature.scale;
+                canvas.width = ObjectDataParser._getNumber(rawCanvas, dragonBones.DataParser.WIDTH, 0) * armature.scale;
+                canvas.height = ObjectDataParser._getNumber(rawCanvas, dragonBones.DataParser.HEIGHT, 0) * armature.scale;
+                armature.canvas = canvas;
+            }
+            if (dragonBones.DataParser.AABB in rawData) {
+                var rawAABB = rawData[dragonBones.DataParser.AABB];
+                armature.aabb.x = ObjectDataParser._getNumber(rawAABB, dragonBones.DataParser.X, 0.0) * armature.scale;
+                armature.aabb.y = ObjectDataParser._getNumber(rawAABB, dragonBones.DataParser.Y, 0.0) * armature.scale;
+                armature.aabb.width = ObjectDataParser._getNumber(rawAABB, dragonBones.DataParser.WIDTH, 0.0) * armature.scale;
+                armature.aabb.height = ObjectDataParser._getNumber(rawAABB, dragonBones.DataParser.HEIGHT, 0.0) * armature.scale;
+            }
+            if (dragonBones.DataParser.BONE in rawData) {
+                var rawBones = rawData[dragonBones.DataParser.BONE];
+                for (var _i = 0, rawBones_1 = rawBones; _i < rawBones_1.length; _i++) {
+                    var rawBone = rawBones_1[_i];
+                    var parentName = ObjectDataParser._getString(rawBone, dragonBones.DataParser.PARENT, "");
+                    var bone = this._parseBone(rawBone);
+                    if (parentName.length > 0) {
+                        var parent_1 = armature.getBone(parentName);
+                        if (parent_1 !== null) {
+                            bone.parent = parent_1;
+                        }
+                        else {
+                            if (!(parentName in this._cacheBones)) {
+                                this._cacheBones[parentName] = [];
+                            }
+                            this._cacheBones[parentName].push(bone);
+                        }
+                    }
+                    if (bone.name in this._cacheBones) {
+                        for (var _a = 0, _b = this._cacheBones[bone.name]; _a < _b.length; _a++) {
+                            var child = _b[_a];
+                            child.parent = bone;
+                        }
+                        delete this._cacheBones[bone.name];
+                    }
+                    armature.addBone(bone);
+                    this._rawBones.push(bone); // Cache raw bones sort.
+                }
+            }
+            if (dragonBones.DataParser.IK in rawData) {
+                var rawIKS = rawData[dragonBones.DataParser.IK];
+                for (var _c = 0, rawIKS_1 = rawIKS; _c < rawIKS_1.length; _c++) {
+                    var rawIK = rawIKS_1[_c];
+                    var constraint = this._parseIKConstraint(rawIK);
+                    if (constraint) {
+                        armature.addConstraint(constraint);
+                    }
+                }
+            }
+            armature.sortBones();
+            if (dragonBones.DataParser.SLOT in rawData) {
+                var zOrder = 0;
+                var rawSlots = rawData[dragonBones.DataParser.SLOT];
+                for (var _d = 0, rawSlots_1 = rawSlots; _d < rawSlots_1.length; _d++) {
+                    var rawSlot = rawSlots_1[_d];
+                    armature.addSlot(this._parseSlot(rawSlot, zOrder++));
+                }
+            }
+            if (dragonBones.DataParser.SKIN in rawData) {
+                var rawSkins = rawData[dragonBones.DataParser.SKIN];
+                for (var _e = 0, rawSkins_1 = rawSkins; _e < rawSkins_1.length; _e++) {
+                    var rawSkin = rawSkins_1[_e];
+                    armature.addSkin(this._parseSkin(rawSkin));
+                }
+            }
+            if (dragonBones.DataParser.PATH_CONSTRAINT in rawData) {
+                var rawPaths = rawData[dragonBones.DataParser.PATH_CONSTRAINT];
+                for (var _f = 0, rawPaths_1 = rawPaths; _f < rawPaths_1.length; _f++) {
+                    var rawPath = rawPaths_1[_f];
+                    var constraint = this._parsePathConstraint(rawPath);
+                    if (constraint) {
+                        armature.addConstraint(constraint);
+                    }
+                }
+            }
+            for (var i = 0, l = this._cacheRawMeshes.length; i < l; ++i) {
+                var rawMeshData = this._cacheRawMeshes[i];
+                if (!(dragonBones.DataParser.GLUE_WEIGHTS in rawMeshData) || !(dragonBones.DataParser.GLUE_MESHES in rawMeshData)) {
+                    continue;
+                }
+                this._parseMeshGlue(rawMeshData, this._cacheMeshes[i]);
+            }
+            for (var i = 0, l = this._cacheRawMeshes.length; i < l; ++i) {
+                var rawData_1 = this._cacheRawMeshes[i];
+                var shareName = ObjectDataParser._getString(rawData_1, dragonBones.DataParser.SHARE, "");
+                if (shareName.length === 0) {
+                    continue;
+                }
+                var skinName = ObjectDataParser._getString(rawData_1, dragonBones.DataParser.SKIN, dragonBones.DataParser.DEFAULT_NAME);
+                if (skinName.length === 0) {
+                    skinName = dragonBones.DataParser.DEFAULT_NAME;
+                }
+                var shareMesh = armature.getMesh(skinName, "", shareName); // TODO slot;
+                if (shareMesh === null) {
+                    continue; // Error.
+                }
+                var mesh = this._cacheMeshes[i];
+                mesh.vertices.shareFrom(shareMesh.vertices);
+            }
+            if (dragonBones.DataParser.ANIMATION in rawData) {
+                var rawAnimations = rawData[dragonBones.DataParser.ANIMATION];
+                for (var _g = 0, rawAnimations_1 = rawAnimations; _g < rawAnimations_1.length; _g++) {
+                    var rawAnimation = rawAnimations_1[_g];
+                    var animation = this._parseAnimation(rawAnimation);
+                    armature.addAnimation(animation);
+                }
+            }
+            if (dragonBones.DataParser.DEFAULT_ACTIONS in rawData) {
+                var actions = this._parseActionData(rawData[dragonBones.DataParser.DEFAULT_ACTIONS], 0 /* Play */, null, null);
+                for (var _h = 0, actions_3 = actions; _h < actions_3.length; _h++) {
+                    var action = actions_3[_h];
+                    armature.addAction(action, true);
+                    if (action.type === 0 /* Play */) {
+                        var animation = armature.getAnimation(action.name);
+                        if (animation !== null) {
+                            armature.defaultAnimation = animation;
+                        }
+                    }
+                }
+            }
+            if (dragonBones.DataParser.ACTIONS in rawData) {
+                var actions = this._parseActionData(rawData[dragonBones.DataParser.ACTIONS], 0 /* Play */, null, null);
+                for (var _j = 0, actions_4 = actions; _j < actions_4.length; _j++) {
+                    var action = actions_4[_j];
+                    armature.addAction(action, false);
+                }
+            }
+            // Clear helper.
+            this._rawBones.length = 0;
+            this._cacheRawMeshes.length = 0;
+            this._cacheMeshes.length = 0;
+            this._armature = null;
+            for (var k in this._weightSlotPose) {
+                delete this._weightSlotPose[k];
+            }
+            for (var k in this._weightBonePoses) {
+                delete this._weightBonePoses[k];
+            }
+            for (var k in this._cacheBones) {
+                delete this._cacheBones[k];
+            }
+            for (var k in this._slotChildActions) {
+                delete this._slotChildActions[k];
+            }
+            return armature;
+        };
+        ObjectDataParser.prototype._parseBone = function (rawData) {
+            var type = 0 /* Bone */;
+            var scale = this._armature.scale;
+            if (dragonBones.DataParser.TYPE in rawData && typeof rawData[dragonBones.DataParser.TYPE] === "string") {
+                type = dragonBones.DataParser._getBoneType(rawData[dragonBones.DataParser.TYPE]);
+            }
+            else {
+                type = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.TYPE, 0 /* Bone */);
+            }
+            if (type === 0 /* Bone */) {
+                var bone = dragonBones.BaseObject.borrowObject(dragonBones.BoneData);
+                bone.inheritTranslation = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.INHERIT_TRANSLATION, true);
+                bone.inheritRotation = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.INHERIT_ROTATION, true);
+                bone.inheritScale = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.INHERIT_SCALE, true);
+                bone.inheritReflection = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.INHERIT_REFLECTION, true);
+                bone.length = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.LENGTH, 0) * scale;
+                bone.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+                if (dragonBones.DataParser.TRANSFORM in rawData) {
+                    this._parseTransform(rawData[dragonBones.DataParser.TRANSFORM], bone.transform, scale);
+                }
+                return bone;
+            }
+            var surface = dragonBones.BaseObject.borrowObject(dragonBones.SurfaceData);
+            surface.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+            surface.segmentX = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SEGMENT_X, 0);
+            surface.segmentY = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SEGMENT_Y, 0);
+            surface.vertices.length = (surface.segmentX + 1) * (surface.segmentY + 1) * 2;
+            if (dragonBones.DataParser.VERTICES in rawData) {
+                var rawVertices = rawData[dragonBones.DataParser.VERTICES];
+                for (var i = 0, l = surface.vertices.length; i < l; ++i) {
+                    if (i < rawVertices.length) {
+                        surface.vertices[i] = rawVertices[i] * scale;
+                    }
+                    else {
+                        surface.vertices[i] = 0.0;
+                    }
+                }
+            }
+            return surface;
+        };
+        ObjectDataParser.prototype._parseIKConstraint = function (rawData) {
+            var bone = this._armature.getBone(ObjectDataParser._getString(rawData, dragonBones.DataParser.BONE, ""));
+            if (bone === null) {
+                return null;
+            }
+            var target = this._armature.getBone(ObjectDataParser._getString(rawData, dragonBones.DataParser.TARGET, ""));
+            if (target === null) {
+                return null;
+            }
+            var constraint = dragonBones.BaseObject.borrowObject(dragonBones.IKConstraintData);
+            constraint.scaleEnabled = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.SCALE, false);
+            constraint.bendPositive = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.BEND_POSITIVE, true);
+            constraint.weight = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.WEIGHT, 1.0);
+            constraint.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+            constraint.type = 0 /* IK */;
+            constraint.target = target;
+            var chain = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.CHAIN, 0);
+            if (chain > 0 && bone.parent !== null) {
+                constraint.root = bone.parent;
+                constraint.bone = bone;
+            }
+            else {
+                constraint.root = bone;
+                constraint.bone = null;
+            }
+            return constraint;
+        };
+        ObjectDataParser.prototype._parsePathConstraint = function (rawData) {
+            var target = this._armature.getSlot(ObjectDataParser._getString(rawData, dragonBones.DataParser.TARGET, ""));
+            if (target === null) {
+                return null;
+            }
+            var defaultSkin = this._armature.defaultSkin;
+            if (defaultSkin === null) {
+                return null;
+            }
+            //TODO
+            var targetDisplay = defaultSkin.getDisplay(target.name, ObjectDataParser._getString(rawData, dragonBones.DataParser.TARGET_DISPLAY, target.name));
+            if (targetDisplay === null || !(targetDisplay instanceof dragonBones.PathDisplayData)) {
+                return null;
+            }
+            var bones = rawData[dragonBones.DataParser.BONES];
+            if (bones === null || bones.length === 0) {
+                return null;
+            }
+            var constraint = dragonBones.BaseObject.borrowObject(dragonBones.PathConstraintData);
+            constraint.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+            constraint.type = 1 /* Path */;
+            constraint.pathSlot = target;
+            constraint.pathDisplayData = targetDisplay;
+            constraint.target = target.parent;
+            constraint.positionMode = dragonBones.DataParser._getPositionMode(ObjectDataParser._getString(rawData, dragonBones.DataParser.POSITION_MODE, ""));
+            constraint.spacingMode = dragonBones.DataParser._getSpacingMode(ObjectDataParser._getString(rawData, dragonBones.DataParser.SPACING_MODE, ""));
+            constraint.rotateMode = dragonBones.DataParser._getRotateMode(ObjectDataParser._getString(rawData, dragonBones.DataParser.ROTATE_MODE, ""));
+            constraint.position = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.POSITION, 0);
+            constraint.spacing = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SPACING, 0);
+            constraint.rotateOffset = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.ROTATE_OFFSET, 0);
+            constraint.rotateMix = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.ROTATE_MIX, 1);
+            constraint.translateMix = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.TRANSLATE_MIX, 1);
+            //
+            for (var _i = 0, bones_3 = bones; _i < bones_3.length; _i++) {
+                var boneName = bones_3[_i];
+                var bone = this._armature.getBone(boneName);
+                if (bone !== null) {
+                    constraint.AddBone(bone);
+                    if (constraint.root === null) {
+                        constraint.root = bone;
+                    }
+                }
+            }
+            return constraint;
+        };
+        ObjectDataParser.prototype._parseSlot = function (rawData, zOrder) {
+            var slot = dragonBones.BaseObject.borrowObject(dragonBones.SlotData);
+            slot.displayIndex = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.DISPLAY_INDEX, 0);
+            slot.zOrder = zOrder;
+            slot.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+            slot.parent = this._armature.getBone(ObjectDataParser._getString(rawData, dragonBones.DataParser.PARENT, "")); //
+            if (dragonBones.DataParser.BLEND_MODE in rawData && typeof rawData[dragonBones.DataParser.BLEND_MODE] === "string") {
+                slot.blendMode = dragonBones.DataParser._getBlendMode(rawData[dragonBones.DataParser.BLEND_MODE]);
+            }
+            else {
+                slot.blendMode = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.BLEND_MODE, 0 /* Normal */);
+            }
+            if (dragonBones.DataParser.COLOR in rawData) {
+                slot.color = dragonBones.SlotData.createColor();
+                this._parseColorTransform(rawData[dragonBones.DataParser.COLOR], slot.color);
+            }
+            else {
+                slot.color = dragonBones.SlotData.DEFAULT_COLOR;
+            }
+            if (dragonBones.DataParser.ACTIONS in rawData) {
+                this._slotChildActions[slot.name] = this._parseActionData(rawData[dragonBones.DataParser.ACTIONS], 0 /* Play */, null, null);
+            }
+            return slot;
+        };
+        ObjectDataParser.prototype._parseSkin = function (rawData) {
+            var skin = dragonBones.BaseObject.borrowObject(dragonBones.SkinData);
+            skin.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, dragonBones.DataParser.DEFAULT_NAME);
+            if (skin.name.length === 0) {
+                skin.name = dragonBones.DataParser.DEFAULT_NAME;
+            }
+            if (dragonBones.DataParser.SLOT in rawData) {
+                var rawSlots = rawData[dragonBones.DataParser.SLOT];
+                this._skin = skin;
+                for (var _i = 0, rawSlots_2 = rawSlots; _i < rawSlots_2.length; _i++) {
+                    var rawSlot = rawSlots_2[_i];
+                    var slotName = ObjectDataParser._getString(rawSlot, dragonBones.DataParser.NAME, "");
+                    var slot = this._armature.getSlot(slotName);
+                    if (slot !== null) {
+                        this._slot = slot;
+                        if (dragonBones.DataParser.DISPLAY in rawSlot) {
+                            var rawDisplays = rawSlot[dragonBones.DataParser.DISPLAY];
+                            for (var _a = 0, rawDisplays_1 = rawDisplays; _a < rawDisplays_1.length; _a++) {
+                                var rawDisplay = rawDisplays_1[_a];
+                                if (rawDisplay) {
+                                    skin.addDisplay(slotName, this._parseDisplay(rawDisplay));
+                                }
+                                else {
+                                    skin.addDisplay(slotName, null);
+                                }
+                            }
+                        }
+                        this._slot = null; //
+                    }
+                }
+                this._skin = null; //
+            }
+            return skin;
+        };
+        ObjectDataParser.prototype._parseDisplay = function (rawData) {
+            var name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+            var path = ObjectDataParser._getString(rawData, dragonBones.DataParser.PATH, "");
+            var type = 0 /* Image */;
+            var display = null;
+            if (dragonBones.DataParser.TYPE in rawData && typeof rawData[dragonBones.DataParser.TYPE] === "string") {
+                type = dragonBones.DataParser._getDisplayType(rawData[dragonBones.DataParser.TYPE]);
+            }
+            else {
+                type = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.TYPE, type);
+            }
+            switch (type) {
+                case 0 /* Image */:
+                    var imageDisplay = display = dragonBones.BaseObject.borrowObject(dragonBones.ImageDisplayData);
+                    imageDisplay.name = name;
+                    imageDisplay.path = path.length > 0 ? path : name;
+                    this._parsePivot(rawData, imageDisplay);
+                    break;
+                case 1 /* Armature */:
+                    var armatureDisplay = display = dragonBones.BaseObject.borrowObject(dragonBones.ArmatureDisplayData);
+                    armatureDisplay.name = name;
+                    armatureDisplay.path = path.length > 0 ? path : name;
+                    armatureDisplay.inheritAnimation = true;
+                    if (dragonBones.DataParser.ACTIONS in rawData) {
+                        var actions = this._parseActionData(rawData[dragonBones.DataParser.ACTIONS], 0 /* Play */, null, null);
+                        for (var _i = 0, actions_5 = actions; _i < actions_5.length; _i++) {
+                            var action = actions_5[_i];
+                            armatureDisplay.addAction(action);
+                        }
+                    }
+                    else if (this._slot.name in this._slotChildActions) {
+                        var displays = this._skin.getDisplays(this._slot.name);
+                        if (displays === null ? this._slot.displayIndex === 0 : this._slot.displayIndex === displays.length) {
+                            for (var _a = 0, _b = this._slotChildActions[this._slot.name]; _a < _b.length; _a++) {
+                                var action = _b[_a];
+                                armatureDisplay.addAction(action);
+                            }
+                            delete this._slotChildActions[this._slot.name];
+                        }
+                    }
+                    break;
+                case 2 /* Mesh */:
+                    var meshDisplay = display = dragonBones.BaseObject.borrowObject(dragonBones.MeshDisplayData);
+                    meshDisplay.vertices.inheritDeform = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.INHERIT_DEFORM, true);
+                    meshDisplay.name = name;
+                    meshDisplay.path = path.length > 0 ? path : name;
+                    meshDisplay.vertices.data = this._data;
+                    if (dragonBones.DataParser.SHARE in rawData) {
+                        this._cacheRawMeshes.push(rawData);
+                        this._cacheMeshes.push(meshDisplay);
+                    }
+                    else {
+                        this._parseMesh(rawData, meshDisplay);
+                    }
+                    if ((dragonBones.DataParser.GLUE_WEIGHTS in rawData) && (dragonBones.DataParser.GLUE_MESHES in rawData)) {
+                        this._cacheRawMeshes.push(rawData);
+                        this._cacheMeshes.push(meshDisplay);
+                    }
+                    break;
+                case 3 /* BoundingBox */:
+                    var boundingBox = this._parseBoundingBox(rawData);
+                    if (boundingBox !== null) {
+                        var boundingBoxDisplay = display = dragonBones.BaseObject.borrowObject(dragonBones.BoundingBoxDisplayData);
+                        boundingBoxDisplay.name = name;
+                        boundingBoxDisplay.path = path.length > 0 ? path : name;
+                        boundingBoxDisplay.boundingBox = boundingBox;
+                    }
+                    break;
+                case 4 /* Path */:
+                    var rawCurveLengths = rawData[dragonBones.DataParser.LENGTHS];
+                    var pathDisplay = display = dragonBones.BaseObject.borrowObject(dragonBones.PathDisplayData);
+                    pathDisplay.closed = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.CLOSED, false);
+                    pathDisplay.constantSpeed = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.CONSTANT_SPEED, false);
+                    pathDisplay.name = name;
+                    pathDisplay.path = path.length > 0 ? path : name;
+                    pathDisplay.vertices.data = this._data;
+                    pathDisplay.curveLengths.length = rawCurveLengths.length;
+                    for (var i = 0, l = rawCurveLengths.length; i < l; ++i) {
+                        pathDisplay.curveLengths[i] = rawCurveLengths[i];
+                    }
+                    this._parsePath(rawData, pathDisplay);
+                    break;
+            }
+            if (display !== null && dragonBones.DataParser.TRANSFORM in rawData) {
+                this._parseTransform(rawData[dragonBones.DataParser.TRANSFORM], display.transform, this._armature.scale);
+            }
+            return display;
+        };
+        ObjectDataParser.prototype._parsePath = function (rawData, display) {
+            var rawVertices = rawData[dragonBones.DataParser.VERTICES];
+            var vertexCount = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.VERTEX_COUNT, 0); // uint
+            var vertexOffset = this._floatArray.length;
+            var pathOffset = this._intArray.length;
+            display.vertices.offset = pathOffset;
+            this._intArray.length += 1 + 1;
+            this._intArray[pathOffset + 0 /* PathVertexCount */] = vertexCount;
+            this._intArray[pathOffset + 2 /* PathFloatOffset */] = vertexOffset;
+            if (!(dragonBones.DataParser.WEIGHTS in rawData)) {
+                this._floatArray.length += rawVertices.length;
+                for (var i = 0, l = rawVertices.length; i < l; ++i) {
+                    this._floatArray[vertexOffset + i] = rawVertices[i];
+                }
+            }
+            else {
+                var rawWeights = rawData[dragonBones.DataParser.WEIGHTS];
+                var rawBones = rawData[dragonBones.DataParser.BONES];
+                var weightBoneCount = rawBones.length;
+                var weightCount = Math.floor(rawWeights.length - vertexCount) / 2; // uint
+                var weightOffset = this._intArray.length;
+                var floatOffset = this._floatArray.length;
+                var sortedBones = this._armature.sortedBones;
+                var weight = dragonBones.BaseObject.borrowObject(dragonBones.WeightData);
+                weight.count = weightCount;
+                weight.offset = weightOffset;
+                this._intArray.length += 1 + 1 + weightBoneCount + vertexCount + weightCount;
+                //
+                this._intArray[weightOffset + 0 /* WeigthBoneCount */] = weightBoneCount;
+                this._intArray[weightOffset + 1 /* WeigthFloatOffset */] = floatOffset;
+                for (var i = 0; i < weightBoneCount; i++) {
+                    var rawBoneIndex = rawBones[i];
+                    var bone = this._rawBones[rawBoneIndex];
+                    weight.addBone(bone);
+                    this._intArray[weightOffset + 2 /* WeigthBoneIndices */ + i] = sortedBones.indexOf(bone);
+                }
+                this._floatArray.length += weightCount * 3;
+                for (var i = 0, iW = 0, iV = 0, iB = weightOffset + 2 /* WeigthBoneIndices */ + weightBoneCount, iF = floatOffset; i < weightCount; i++) {
+                    var boneCount = rawWeights[iW++];
+                    this._intArray[iB++] = boneCount;
+                    for (var j = 0; j < boneCount; j++) {
+                        var boneIndex = rawWeights[iW++];
+                        var boneWeight = rawWeights[iW++];
+                        var x = rawVertices[iV++];
+                        var y = rawVertices[iV++];
+                        this._intArray[iB++] = rawBones.indexOf(boneIndex);
+                        this._floatArray[iF++] = boneWeight;
+                        this._floatArray[iF++] = x;
+                        this._floatArray[iF++] = y;
+                    }
+                }
+                display.vertices.weight = weight;
+            }
+        };
+        ObjectDataParser.prototype._parsePivot = function (rawData, display) {
+            if (dragonBones.DataParser.PIVOT in rawData) {
+                var rawPivot = rawData[dragonBones.DataParser.PIVOT];
+                display.pivot.x = ObjectDataParser._getNumber(rawPivot, dragonBones.DataParser.X, 0.0);
+                display.pivot.y = ObjectDataParser._getNumber(rawPivot, dragonBones.DataParser.Y, 0.0);
+            }
+            else {
+                display.pivot.x = 0.5;
+                display.pivot.y = 0.5;
+            }
+        };
+        ObjectDataParser.prototype._parseMesh = function (rawData, mesh) {
+            var rawVertices = rawData[dragonBones.DataParser.VERTICES];
+            var rawUVs = rawData[dragonBones.DataParser.UVS];
+            var rawTriangles = rawData[dragonBones.DataParser.TRIANGLES];
+            var vertexCount = Math.floor(rawVertices.length / 2); // uint
+            var triangleCount = Math.floor(rawTriangles.length / 3); // uint
+            var vertexOffset = this._floatArray.length;
+            var uvOffset = vertexOffset + vertexCount * 2;
+            var meshOffset = this._intArray.length;
+            var meshName = this._skin.name + "_" + this._slot.name + "_" + mesh.name; // Cache pose data.
+            mesh.vertices.offset = meshOffset;
+            this._intArray.length += 1 + 1 + 1 + 1 + triangleCount * 3;
+            this._intArray[meshOffset + 0 /* MeshVertexCount */] = vertexCount;
+            this._intArray[meshOffset + 1 /* MeshTriangleCount */] = triangleCount;
+            this._intArray[meshOffset + 2 /* MeshFloatOffset */] = vertexOffset;
+            for (var i = 0, l = triangleCount * 3; i < l; ++i) {
+                this._intArray[meshOffset + 4 /* MeshVertexIndices */ + i] = rawTriangles[i];
+            }
+            this._floatArray.length += vertexCount * 2 + vertexCount * 2;
+            for (var i = 0, l = vertexCount * 2; i < l; ++i) {
+                this._floatArray[vertexOffset + i] = rawVertices[i];
+                this._floatArray[uvOffset + i] = rawUVs[i];
+            }
+            if (dragonBones.DataParser.WEIGHTS in rawData) {
+                var rawWeights = rawData[dragonBones.DataParser.WEIGHTS];
+                var rawSlotPose = rawData[dragonBones.DataParser.SLOT_POSE];
+                var rawBonePoses = rawData[dragonBones.DataParser.BONE_POSE];
+                var sortedBones = this._armature.sortedBones;
+                var weightBoneIndices = new Array();
+                var weightBoneCount = Math.floor(rawBonePoses.length / 7); // uint
+                var floatOffset = this._floatArray.length;
+                var weightCount = Math.floor(rawWeights.length - vertexCount) / 2; // uint
+                var weightOffset = this._intArray.length;
+                var weight = dragonBones.BaseObject.borrowObject(dragonBones.WeightData);
+                weight.count = weightCount;
+                weight.offset = weightOffset;
+                weightBoneIndices.length = weightBoneCount;
+                this._intArray.length += 1 + 1 + weightBoneCount + vertexCount + weightCount;
+                this._intArray[weightOffset + 1 /* WeigthFloatOffset */] = floatOffset;
+                for (var i = 0; i < weightBoneCount; ++i) {
+                    var rawBoneIndex = rawBonePoses[i * 7]; // uint
+                    var bone = this._rawBones[rawBoneIndex];
+                    weight.addBone(bone);
+                    weightBoneIndices[i] = rawBoneIndex;
+                    this._intArray[weightOffset + 2 /* WeigthBoneIndices */ + i] = sortedBones.indexOf(bone);
+                }
+                this._floatArray.length += weightCount * 3;
+                this._helpMatrixA.copyFromArray(rawSlotPose, 0);
+                for (var i = 0, iW = 0, iB = weightOffset + 2 /* WeigthBoneIndices */ + weightBoneCount, iV = floatOffset; i < vertexCount; ++i) {
+                    var iD = i * 2;
+                    var vertexBoneCount = this._intArray[iB++] = rawWeights[iW++]; // uint
+                    var x = this._floatArray[vertexOffset + iD];
+                    var y = this._floatArray[vertexOffset + iD + 1];
+                    this._helpMatrixA.transformPoint(x, y, this._helpPoint);
+                    x = this._helpPoint.x;
+                    y = this._helpPoint.y;
+                    for (var j = 0; j < vertexBoneCount; ++j) {
+                        var rawBoneIndex = rawWeights[iW++]; // uint
+                        var boneIndex = weightBoneIndices.indexOf(rawBoneIndex);
+                        this._helpMatrixB.copyFromArray(rawBonePoses, boneIndex * 7 + 1);
+                        this._helpMatrixB.invert();
+                        this._helpMatrixB.transformPoint(x, y, this._helpPoint);
+                        this._intArray[iB++] = boneIndex;
+                        this._floatArray[iV++] = rawWeights[iW++];
+                        this._floatArray[iV++] = this._helpPoint.x;
+                        this._floatArray[iV++] = this._helpPoint.y;
+                    }
+                }
+                mesh.vertices.weight = weight;
+                this._weightSlotPose[meshName] = rawSlotPose;
+                this._weightBonePoses[meshName] = rawBonePoses;
+            }
+        };
+        ObjectDataParser.prototype._parseMeshGlue = function (rawData, mesh) {
+            rawData;
+            mesh;
+            // const rawWeights = rawData[DataParser.GLUE_WEIGHTS] as Array<number>;
+            // const rawMeshes = rawData[DataParser.GLUE_MESHES] as Array<string>;
+            // mesh.glue = BaseObject.borrowObject(GlueData);
+            // mesh.glue.weights.length = rawWeights.length;
+            // for (let i = 0, l = rawWeights.length; i < l; ++i) {
+            //     mesh.glue.weights[i] = rawWeights[i];
+            // }
+            // for (let i = 0, l = rawMeshes.length; i < l; i += 3) {
+            //     const glueMesh = this._armature.getMesh(rawMeshes[i], rawMeshes[i + 1], rawMeshes[i + 2]);
+            //     mesh.glue.addMesh(glueMesh);
+            // }
+        };
+        ObjectDataParser.prototype._parseBoundingBox = function (rawData) {
+            var boundingBox = null;
+            var type = 0 /* Rectangle */;
+            if (dragonBones.DataParser.SUB_TYPE in rawData && typeof rawData[dragonBones.DataParser.SUB_TYPE] === "string") {
+                type = dragonBones.DataParser._getBoundingBoxType(rawData[dragonBones.DataParser.SUB_TYPE]);
+            }
+            else {
+                type = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SUB_TYPE, type);
+            }
+            switch (type) {
+                case 0 /* Rectangle */:
+                    boundingBox = dragonBones.BaseObject.borrowObject(dragonBones.RectangleBoundingBoxData);
+                    break;
+                case 1 /* Ellipse */:
+                    boundingBox = dragonBones.BaseObject.borrowObject(dragonBones.EllipseBoundingBoxData);
+                    break;
+                case 2 /* Polygon */:
+                    boundingBox = this._parsePolygonBoundingBox(rawData);
+                    break;
+            }
+            if (boundingBox !== null) {
+                boundingBox.color = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.COLOR, 0x000000);
+                if (boundingBox.type === 0 /* Rectangle */ || boundingBox.type === 1 /* Ellipse */) {
+                    boundingBox.width = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.WIDTH, 0.0);
+                    boundingBox.height = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.HEIGHT, 0.0);
+                }
+            }
+            return boundingBox;
+        };
+        ObjectDataParser.prototype._parsePolygonBoundingBox = function (rawData) {
+            var polygonBoundingBox = dragonBones.BaseObject.borrowObject(dragonBones.PolygonBoundingBoxData);
+            if (dragonBones.DataParser.VERTICES in rawData) {
+                var scale = this._armature.scale;
+                var rawVertices = rawData[dragonBones.DataParser.VERTICES];
+                var vertices = polygonBoundingBox.vertices;
+                if (dragonBones.DragonBones.webAssembly) {
+                    vertices.resize(rawVertices.length, 0.0);
+                }
+                else {
+                    vertices.length = rawVertices.length;
+                }
+                for (var i = 0, l = rawVertices.length; i < l; i += 2) {
+                    var x = rawVertices[i] * scale;
+                    var y = rawVertices[i + 1] * scale;
+                    if (dragonBones.DragonBones.webAssembly) {
+                        vertices.set(i, x);
+                        vertices.set(i + 1, y);
+                    }
+                    else {
+                        vertices[i] = x;
+                        vertices[i + 1] = y;
+                    }
+                    // AABB.
+                    if (i === 0) {
+                        polygonBoundingBox.x = x;
+                        polygonBoundingBox.y = y;
+                        polygonBoundingBox.width = x;
+                        polygonBoundingBox.height = y;
+                    }
+                    else {
+                        if (x < polygonBoundingBox.x) {
+                            polygonBoundingBox.x = x;
+                        }
+                        else if (x > polygonBoundingBox.width) {
+                            polygonBoundingBox.width = x;
+                        }
+                        if (y < polygonBoundingBox.y) {
+                            polygonBoundingBox.y = y;
+                        }
+                        else if (y > polygonBoundingBox.height) {
+                            polygonBoundingBox.height = y;
+                        }
+                    }
+                }
+                polygonBoundingBox.width -= polygonBoundingBox.x;
+                polygonBoundingBox.height -= polygonBoundingBox.y;
+            }
+            else {
+                console.warn("Data error.\n Please reexport DragonBones Data to fixed the bug.");
+            }
+            return polygonBoundingBox;
+        };
+        ObjectDataParser.prototype._parseAnimation = function (rawData) {
+            var animation = dragonBones.BaseObject.borrowObject(dragonBones.AnimationData);
+            animation.frameCount = Math.max(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.DURATION, 1), 1);
+            animation.playTimes = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.PLAY_TIMES, 1);
+            animation.duration = animation.frameCount / this._armature.frameRate; // float
+            animation.fadeInTime = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.FADE_IN_TIME, 0.0);
+            animation.scale = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SCALE, 1.0);
+            animation.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, dragonBones.DataParser.DEFAULT_NAME);
+            if (animation.name.length === 0) {
+                animation.name = dragonBones.DataParser.DEFAULT_NAME;
+            }
+            animation.frameIntOffset = this._frameIntArray.length;
+            animation.frameFloatOffset = this._frameFloatArray.length;
+            animation.frameOffset = this._frameArray.length;
+            this._animation = animation;
+            if (dragonBones.DataParser.FRAME in rawData) {
+                var rawFrames = rawData[dragonBones.DataParser.FRAME];
+                var keyFrameCount = rawFrames.length;
+                if (keyFrameCount > 0) {
+                    for (var i = 0, frameStart = 0; i < keyFrameCount; ++i) {
+                        var rawFrame = rawFrames[i];
+                        this._parseActionDataInFrame(rawFrame, frameStart, null, null);
+                        frameStart += ObjectDataParser._getNumber(rawFrame, dragonBones.DataParser.DURATION, 1);
+                    }
+                }
+            }
+            if (dragonBones.DataParser.Z_ORDER in rawData) {
+                this._animation.zOrderTimeline = this._parseTimeline(rawData[dragonBones.DataParser.Z_ORDER], null, dragonBones.DataParser.FRAME, 1 /* ZOrder */, false, false, 0, this._parseZOrderFrame);
+            }
+            if (dragonBones.DataParser.BONE in rawData) {
+                var rawTimelines = rawData[dragonBones.DataParser.BONE];
+                for (var _i = 0, rawTimelines_1 = rawTimelines; _i < rawTimelines_1.length; _i++) {
+                    var rawTimeline = rawTimelines_1[_i];
+                    this._parseBoneTimeline(rawTimeline);
+                }
+            }
+            if (dragonBones.DataParser.SURFACE in rawData) {
+                var rawTimelines = rawData[dragonBones.DataParser.SURFACE];
+                for (var _a = 0, rawTimelines_2 = rawTimelines; _a < rawTimelines_2.length; _a++) {
+                    var rawTimeline = rawTimelines_2[_a];
+                    var surfaceName = ObjectDataParser._getString(rawTimeline, dragonBones.DataParser.NAME, "");
+                    this._surface = this._armature.getBone(surfaceName);
+                    if (this._surface === null) {
+                        continue;
+                    }
+                    var timeline = this._parseTimeline(rawTimeline, null, dragonBones.DataParser.FRAME, 50 /* Surface */, false, true, 0, this._parseSurfaceFrame);
+                    if (timeline !== null) {
+                        this._animation.addSurfaceTimeline(this._surface, timeline);
+                    }
+                    this._surface = null; //
+                }
+            }
+            if (dragonBones.DataParser.SLOT in rawData) {
+                var rawTimelines = rawData[dragonBones.DataParser.SLOT];
+                for (var _b = 0, rawTimelines_3 = rawTimelines; _b < rawTimelines_3.length; _b++) {
+                    var rawTimeline = rawTimelines_3[_b];
+                    this._parseSlotTimeline(rawTimeline);
+                }
+            }
+            if (dragonBones.DataParser.FFD in rawData) {
+                var rawTimelines = rawData[dragonBones.DataParser.FFD];
+                for (var _c = 0, rawTimelines_4 = rawTimelines; _c < rawTimelines_4.length; _c++) {
+                    var rawTimeline = rawTimelines_4[_c];
+                    var skinName = ObjectDataParser._getString(rawTimeline, dragonBones.DataParser.SKIN, dragonBones.DataParser.DEFAULT_NAME);
+                    var slotName = ObjectDataParser._getString(rawTimeline, dragonBones.DataParser.SLOT, "");
+                    var displayName = ObjectDataParser._getString(rawTimeline, dragonBones.DataParser.NAME, "");
+                    if (skinName.length === 0) {
+                        skinName = dragonBones.DataParser.DEFAULT_NAME;
+                    }
+                    this._slot = this._armature.getSlot(slotName);
+                    this._mesh = this._armature.getMesh(skinName, slotName, displayName);
+                    if (this._slot === null || this._mesh === null) {
+                        continue;
+                    }
+                    var timeline = this._parseTimeline(rawTimeline, null, dragonBones.DataParser.FRAME, 22 /* SlotDeform */, false, true, 0, this._parseSlotFFDFrame);
+                    if (timeline !== null) {
+                        this._animation.addSlotTimeline(this._slot, timeline);
+                    }
+                    this._slot = null; //
+                    this._mesh = null; //
+                }
+            }
+            if (dragonBones.DataParser.IK in rawData) {
+                var rawTimelines = rawData[dragonBones.DataParser.IK];
+                for (var _d = 0, rawTimelines_5 = rawTimelines; _d < rawTimelines_5.length; _d++) {
+                    var rawTimeline = rawTimelines_5[_d];
+                    var constraintName = ObjectDataParser._getString(rawTimeline, dragonBones.DataParser.NAME, "");
+                    var constraint = this._armature.getConstraint(constraintName);
+                    if (constraint === null) {
+                        continue;
+                    }
+                    var timeline = this._parseTimeline(rawTimeline, null, dragonBones.DataParser.FRAME, 30 /* IKConstraint */, true, false, 2, this._parseIKConstraintFrame);
+                    if (timeline !== null) {
+                        this._animation.addConstraintTimeline(constraint, timeline);
+                    }
+                }
+            }
+            if (dragonBones.DataParser.ANIMATION in rawData) {
+                var rawTimelines = rawData[dragonBones.DataParser.ANIMATION];
+                for (var _e = 0, rawTimelines_6 = rawTimelines; _e < rawTimelines_6.length; _e++) {
+                    var rawTimeline = rawTimelines_6[_e];
+                    var animationName = ObjectDataParser._getString(rawTimeline, dragonBones.DataParser.NAME, "");
+                    var timeline = this._parseTimeline(rawTimeline, null, dragonBones.DataParser.FRAME, 40 /* AnimationTime */, true, false, 2, this._parseAnimationFrame);
+                    if (timeline !== null) {
+                        this._animation.addAnimationTimeline(animationName, timeline);
+                    }
+                }
+            }
+            if (this._actionFrames.length > 0) {
+                this._animation.actionTimeline = this._parseTimeline(null, this._actionFrames, "", 0 /* Action */, false, false, 0, this._parseActionFrame);
+                this._actionFrames.length = 0;
+            }
+            this._animation = null; //
+            return animation;
+        };
+        ObjectDataParser.prototype._parseTimeline = function (rawData, rawFrames, framesKey, type, addIntOffset, addFloatOffset, frameValueCount, frameParser) {
+            if (rawData !== null && framesKey.length > 0 && framesKey in rawData) {
+                rawFrames = rawData[framesKey];
+            }
+            if (rawFrames === null) {
+                return null;
+            }
+            var keyFrameCount = rawFrames.length;
+            if (keyFrameCount === 0) {
+                return null;
+            }
+            var frameIntArrayLength = this._frameIntArray.length;
+            var frameFloatArrayLength = this._frameFloatArray.length;
+            var timeline = dragonBones.BaseObject.borrowObject(dragonBones.TimelineData);
+            var timelineOffset = this._timelineArray.length;
+            this._timelineArray.length += 1 + 1 + 1 + 1 + 1 + keyFrameCount;
+            if (rawData !== null) {
+                this._timelineArray[timelineOffset + 0 /* TimelineScale */] = Math.round(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SCALE, 1.0) * 100);
+                this._timelineArray[timelineOffset + 1 /* TimelineOffset */] = Math.round(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.OFFSET, 0.0) * 100);
+            }
+            else {
+                this._timelineArray[timelineOffset + 0 /* TimelineScale */] = 100;
+                this._timelineArray[timelineOffset + 1 /* TimelineOffset */] = 0;
+            }
+            this._timelineArray[timelineOffset + 2 /* TimelineKeyFrameCount */] = keyFrameCount;
+            this._timelineArray[timelineOffset + 3 /* TimelineFrameValueCount */] = frameValueCount;
+            if (addIntOffset) {
+                this._timelineArray[timelineOffset + 4 /* TimelineFrameValueOffset */] = frameIntArrayLength - this._animation.frameIntOffset;
+            }
+            else if (addFloatOffset) {
+                this._timelineArray[timelineOffset + 4 /* TimelineFrameValueOffset */] = frameFloatArrayLength - this._animation.frameFloatOffset;
+            }
+            else {
+                this._timelineArray[timelineOffset + 4 /* TimelineFrameValueOffset */] = 0;
+            }
+            this._timeline = timeline;
+            timeline.type = type;
+            timeline.offset = timelineOffset;
+            if (keyFrameCount === 1) {
+                timeline.frameIndicesOffset = -1;
+                this._timelineArray[timelineOffset + 5 /* TimelineFrameOffset */ + 0] = frameParser.call(this, rawFrames[0], 0, 0) - this._animation.frameOffset;
+            }
+            else {
+                var totalFrameCount = this._animation.frameCount + 1; // One more frame than animation.
+                var frameIndices = this._data.frameIndices;
+                var frameIndicesOffset = 0;
+                if (dragonBones.DragonBones.webAssembly) {
+                    frameIndicesOffset = frameIndices.size();
+                    frameIndices.resize(frameIndicesOffset + totalFrameCount, 0);
+                }
+                else {
+                    frameIndicesOffset = frameIndices.length;
+                    frameIndices.length += totalFrameCount;
+                }
+                timeline.frameIndicesOffset = frameIndicesOffset;
+                for (var i = 0, iK = 0, frameStart = 0, frameCount = 0; i < totalFrameCount; ++i) {
+                    if (frameStart + frameCount <= i && iK < keyFrameCount) {
+                        var rawFrame = rawFrames[iK];
+                        frameStart = i; // frame.frameStart;
+                        if (iK === keyFrameCount - 1) {
+                            frameCount = this._animation.frameCount - frameStart;
+                        }
+                        else {
+                            if (rawFrame instanceof ActionFrame) {
+                                frameCount = this._actionFrames[iK + 1].frameStart - frameStart;
+                            }
+                            else {
+                                frameCount = ObjectDataParser._getNumber(rawFrame, dragonBones.DataParser.DURATION, 1);
+                            }
+                        }
+                        this._timelineArray[timelineOffset + 5 /* TimelineFrameOffset */ + iK] = frameParser.call(this, rawFrame, frameStart, frameCount) - this._animation.frameOffset;
+                        iK++;
+                    }
+                    if (dragonBones.DragonBones.webAssembly) {
+                        frameIndices.set(frameIndicesOffset + i, iK - 1);
+                    }
+                    else {
+                        frameIndices[frameIndicesOffset + i] = iK - 1;
+                    }
+                }
+            }
+            this._timeline = null; //
+            return timeline;
+        };
+        ObjectDataParser.prototype._parseBoneTimeline = function (rawData) {
+            var bone = this._armature.getBone(ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, ""));
+            if (bone === null) {
+                return;
+            }
+            this._bone = bone;
+            this._slot = this._armature.getSlot(this._bone.name);
+            if (dragonBones.DataParser.TRANSLATE_FRAME in rawData) {
+                var timeline = this._parseTimeline(rawData, null, dragonBones.DataParser.TRANSLATE_FRAME, 11 /* BoneTranslate */, false, true, 2, this._parseBoneTranslateFrame);
+                if (timeline !== null) {
+                    this._animation.addBoneTimeline(bone, timeline);
+                }
+            }
+            if (dragonBones.DataParser.ROTATE_FRAME in rawData) {
+                var timeline = this._parseTimeline(rawData, null, dragonBones.DataParser.ROTATE_FRAME, 12 /* BoneRotate */, false, true, 2, this._parseBoneRotateFrame);
+                if (timeline !== null) {
+                    this._animation.addBoneTimeline(bone, timeline);
+                }
+            }
+            if (dragonBones.DataParser.SCALE_FRAME in rawData) {
+                var timeline = this._parseTimeline(rawData, null, dragonBones.DataParser.SCALE_FRAME, 13 /* BoneScale */, false, true, 2, this._parseBoneScaleFrame);
+                if (timeline !== null) {
+                    this._animation.addBoneTimeline(bone, timeline);
+                }
+            }
+            if (dragonBones.DataParser.FRAME in rawData) {
+                var timeline = this._parseTimeline(rawData, null, dragonBones.DataParser.FRAME, 10 /* BoneAll */, false, true, 6, this._parseBoneAllFrame);
+                if (timeline !== null) {
+                    this._animation.addBoneTimeline(bone, timeline);
+                }
+            }
+            this._bone = null; //
+            this._slot = null; //
+        };
+        ObjectDataParser.prototype._parseSlotTimeline = function (rawData) {
+            var slot = this._armature.getSlot(ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, ""));
+            if (slot === null) {
+                return;
+            }
+            this._slot = slot;
+            // Display timeline.
+            var displayTimeline = null;
+            if (dragonBones.DataParser.DISPLAY_FRAME in rawData) {
+                displayTimeline = this._parseTimeline(rawData, null, dragonBones.DataParser.DISPLAY_FRAME, 20 /* SlotDisplay */, false, false, 0, this._parseSlotDisplayFrame);
+            }
+            else {
+                displayTimeline = this._parseTimeline(rawData, null, dragonBones.DataParser.FRAME, 20 /* SlotDisplay */, false, false, 0, this._parseSlotDisplayFrame);
+            }
+            if (displayTimeline !== null) {
+                this._animation.addSlotTimeline(slot, displayTimeline);
+            }
+            var colorTimeline = null;
+            if (dragonBones.DataParser.COLOR_FRAME in rawData) {
+                colorTimeline = this._parseTimeline(rawData, null, dragonBones.DataParser.COLOR_FRAME, 21 /* SlotColor */, true, false, 1, this._parseSlotColorFrame);
+            }
+            else {
+                colorTimeline = this._parseTimeline(rawData, null, dragonBones.DataParser.FRAME, 21 /* SlotColor */, true, false, 1, this._parseSlotColorFrame);
+            }
+            if (colorTimeline !== null) {
+                this._animation.addSlotTimeline(slot, colorTimeline);
+            }
+            this._slot = null; //
+        };
+        ObjectDataParser.prototype._parseFrame = function (rawData, frameStart, frameCount) {
+            // tslint:disable-next-line:no-unused-expression
+            rawData;
+            // tslint:disable-next-line:no-unused-expression
+            frameCount;
+            var frameOffset = this._frameArray.length;
+            this._frameArray.length += 1;
+            this._frameArray[frameOffset + 0 /* FramePosition */] = frameStart;
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseTweenFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseFrame(rawData, frameStart, frameCount);
+            if (frameCount > 0) {
+                if (dragonBones.DataParser.CURVE in rawData) {
+                    var sampleCount = frameCount + 1;
+                    this._helpArray.length = sampleCount;
+                    this._samplingEasingCurve(rawData[dragonBones.DataParser.CURVE], this._helpArray);
+                    this._frameArray.length += 1 + 1 + this._helpArray.length;
+                    this._frameArray[frameOffset + 1 /* FrameTweenType */] = 2 /* Curve */;
+                    this._frameArray[frameOffset + 2 /* FrameTweenEasingOrCurveSampleCount */] = sampleCount;
+                    for (var i = 0; i < sampleCount; ++i) {
+                        this._frameArray[frameOffset + 3 /* FrameCurveSamples */ + i] = Math.round(this._helpArray[i] * 10000.0);
+                    }
+                }
+                else {
+                    var noTween = -2.0;
+                    var tweenEasing = noTween;
+                    if (dragonBones.DataParser.TWEEN_EASING in rawData) {
+                        tweenEasing = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.TWEEN_EASING, noTween);
+                    }
+                    if (tweenEasing === noTween) {
+                        this._frameArray.length += 1;
+                        this._frameArray[frameOffset + 1 /* FrameTweenType */] = 0 /* None */;
+                    }
+                    else if (tweenEasing === 0.0) {
+                        this._frameArray.length += 1;
+                        this._frameArray[frameOffset + 1 /* FrameTweenType */] = 1 /* Line */;
+                    }
+                    else if (tweenEasing < 0.0) {
+                        this._frameArray.length += 1 + 1;
+                        this._frameArray[frameOffset + 1 /* FrameTweenType */] = 3 /* QuadIn */;
+                        this._frameArray[frameOffset + 2 /* FrameTweenEasingOrCurveSampleCount */] = Math.round(-tweenEasing * 100.0);
+                    }
+                    else if (tweenEasing <= 1.0) {
+                        this._frameArray.length += 1 + 1;
+                        this._frameArray[frameOffset + 1 /* FrameTweenType */] = 4 /* QuadOut */;
+                        this._frameArray[frameOffset + 2 /* FrameTweenEasingOrCurveSampleCount */] = Math.round(tweenEasing * 100.0);
+                    }
+                    else {
+                        this._frameArray.length += 1 + 1;
+                        this._frameArray[frameOffset + 1 /* FrameTweenType */] = 5 /* QuadInOut */;
+                        this._frameArray[frameOffset + 2 /* FrameTweenEasingOrCurveSampleCount */] = Math.round(tweenEasing * 100.0 - 100.0);
+                    }
+                }
+            }
+            else {
+                this._frameArray.length += 1;
+                this._frameArray[frameOffset + 1 /* FrameTweenType */] = 0 /* None */;
+            }
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseActionFrame = function (frame, frameStart, frameCount) {
+            // tslint:disable-next-line:no-unused-expression
+            frameCount;
+            var frameOffset = this._frameArray.length;
+            var actionCount = frame.actions.length;
+            this._frameArray.length += 1 + 1 + actionCount;
+            this._frameArray[frameOffset + 0 /* FramePosition */] = frameStart;
+            this._frameArray[frameOffset + 0 /* FramePosition */ + 1] = actionCount; // Action count.
+            for (var i = 0; i < actionCount; ++i) {
+                this._frameArray[frameOffset + 0 /* FramePosition */ + 2 + i] = frame.actions[i];
+            }
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseZOrderFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseFrame(rawData, frameStart, frameCount);
+            if (dragonBones.DataParser.Z_ORDER in rawData) {
+                var rawZOrder = rawData[dragonBones.DataParser.Z_ORDER];
+                if (rawZOrder.length > 0) {
+                    var slotCount = this._armature.sortedSlots.length;
+                    var unchanged = new Array(slotCount - rawZOrder.length / 2);
+                    var zOrders = new Array(slotCount);
+                    for (var i_1 = 0; i_1 < unchanged.length; ++i_1) {
+                        unchanged[i_1] = 0;
+                    }
+                    for (var i_2 = 0; i_2 < slotCount; ++i_2) {
+                        zOrders[i_2] = -1;
+                    }
+                    var originalIndex = 0;
+                    var unchangedIndex = 0;
+                    for (var i_3 = 0, l = rawZOrder.length; i_3 < l; i_3 += 2) {
+                        var slotIndex = rawZOrder[i_3];
+                        var zOrderOffset = rawZOrder[i_3 + 1];
+                        while (originalIndex !== slotIndex) {
+                            unchanged[unchangedIndex++] = originalIndex++;
+                        }
+                        var index = originalIndex + zOrderOffset;
+                        zOrders[index] = originalIndex++;
+                    }
+                    while (originalIndex < slotCount) {
+                        unchanged[unchangedIndex++] = originalIndex++;
+                    }
+                    this._frameArray.length += 1 + slotCount;
+                    this._frameArray[frameOffset + 1] = slotCount;
+                    var i = slotCount;
+                    while (i--) {
+                        if (zOrders[i] === -1) {
+                            this._frameArray[frameOffset + 2 + i] = unchanged[--unchangedIndex] || 0;
+                        }
+                        else {
+                            this._frameArray[frameOffset + 2 + i] = zOrders[i] || 0;
+                        }
+                    }
+                    return frameOffset;
+                }
+            }
+            this._frameArray.length += 1;
+            this._frameArray[frameOffset + 1] = 0;
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseBoneAllFrame = function (rawData, frameStart, frameCount) {
+            this._helpTransform.identity();
+            if (dragonBones.DataParser.TRANSFORM in rawData) {
+                this._parseTransform(rawData[dragonBones.DataParser.TRANSFORM], this._helpTransform, 1.0);
+            }
+            // Modify rotation.
+            var rotation = this._helpTransform.rotation;
+            if (frameStart !== 0) {
+                if (this._prevClockwise === 0) {
+                    rotation = this._prevRotation + dragonBones.Transform.normalizeRadian(rotation - this._prevRotation);
+                }
+                else {
+                    if (this._prevClockwise > 0 ? rotation >= this._prevRotation : rotation <= this._prevRotation) {
+                        this._prevClockwise = this._prevClockwise > 0 ? this._prevClockwise - 1 : this._prevClockwise + 1;
+                    }
+                    rotation = this._prevRotation + rotation - this._prevRotation + dragonBones.Transform.PI_D * this._prevClockwise;
+                }
+            }
+            this._prevClockwise = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.TWEEN_ROTATE, 0.0);
+            this._prevRotation = rotation;
+            //
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var frameFloatOffset = this._frameFloatArray.length;
+            this._frameFloatArray.length += 6;
+            this._frameFloatArray[frameFloatOffset++] = this._helpTransform.x;
+            this._frameFloatArray[frameFloatOffset++] = this._helpTransform.y;
+            this._frameFloatArray[frameFloatOffset++] = rotation;
+            this._frameFloatArray[frameFloatOffset++] = this._helpTransform.skew;
+            this._frameFloatArray[frameFloatOffset++] = this._helpTransform.scaleX;
+            this._frameFloatArray[frameFloatOffset++] = this._helpTransform.scaleY;
+            this._parseActionDataInFrame(rawData, frameStart, this._bone, this._slot);
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseBoneTranslateFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var frameFloatOffset = this._frameFloatArray.length;
+            this._frameFloatArray.length += 2;
+            this._frameFloatArray[frameFloatOffset++] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.X, 0.0);
+            this._frameFloatArray[frameFloatOffset++] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.Y, 0.0);
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseBoneRotateFrame = function (rawData, frameStart, frameCount) {
+            // Modify rotation.
+            var rotation = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.ROTATE, 0.0) * dragonBones.Transform.DEG_RAD;
+            if (frameStart !== 0) {
+                if (this._prevClockwise === 0) {
+                    rotation = this._prevRotation + dragonBones.Transform.normalizeRadian(rotation - this._prevRotation);
+                }
+                else {
+                    if (this._prevClockwise > 0 ? rotation >= this._prevRotation : rotation <= this._prevRotation) {
+                        this._prevClockwise = this._prevClockwise > 0 ? this._prevClockwise - 1 : this._prevClockwise + 1;
+                    }
+                    rotation = this._prevRotation + rotation - this._prevRotation + dragonBones.Transform.PI_D * this._prevClockwise;
+                }
+            }
+            this._prevClockwise = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.CLOCK_WISE, 0);
+            this._prevRotation = rotation;
+            //
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var frameFloatOffset = this._frameFloatArray.length;
+            this._frameFloatArray.length += 2;
+            this._frameFloatArray[frameFloatOffset++] = rotation;
+            this._frameFloatArray[frameFloatOffset++] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SKEW, 0.0) * dragonBones.Transform.DEG_RAD;
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseBoneScaleFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var frameFloatOffset = this._frameFloatArray.length;
+            this._frameFloatArray.length += 2;
+            this._frameFloatArray[frameFloatOffset++] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.X, 1.0);
+            this._frameFloatArray[frameFloatOffset++] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.Y, 1.0);
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseSurfaceFrame = function (rawData, frameStart, frameCount) {
+            var frameFloatOffset = this._frameFloatArray.length;
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var rawVertices = rawData[dragonBones.DataParser.VERTICES];
+            var offset = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.OFFSET, 0); // uint
+            var vertexCount = this._surface.vertices.length / 2; // uint
+            var x = 0.0;
+            var y = 0.0;
+            this._frameFloatArray.length += vertexCount * 2;
+            for (var i = 0; i < vertexCount * 2; i += 2) {
+                if (i < offset || i - offset >= rawVertices.length) {
+                    x = 0.0;
+                }
+                else {
+                    x = rawVertices[i - offset];
+                }
+                if (i + 1 < offset || i + 1 - offset >= rawVertices.length) {
+                    y = 0.0;
+                }
+                else {
+                    y = rawVertices[i + 1 - offset];
+                }
+                this._frameFloatArray[frameFloatOffset + i] = x;
+                this._frameFloatArray[frameFloatOffset + i + 1] = y;
+            }
+            if (frameStart === 0) {
+                var frameIntOffset = this._frameIntArray.length;
+                this._frameIntArray.length += 1 + 1 + 1 + 1 + 1;
+                this._frameIntArray[frameIntOffset + 0 /* DeformVertexOffset */] = 0; // 
+                this._frameIntArray[frameIntOffset + 1 /* DeformCount */] = this._frameFloatArray.length - frameFloatOffset;
+                this._frameIntArray[frameIntOffset + 2 /* DeformValueCount */] = this._frameFloatArray.length - frameFloatOffset;
+                this._frameIntArray[frameIntOffset + 3 /* DeformValueOffset */] = 0;
+                this._frameIntArray[frameIntOffset + 4 /* DeformFloatOffset */] = frameFloatOffset - this._animation.frameFloatOffset;
+                this._timelineArray[this._timeline.offset + 3 /* TimelineFrameValueCount */] = frameIntOffset - this._animation.frameIntOffset;
+            }
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseSlotDisplayFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseFrame(rawData, frameStart, frameCount);
+            this._frameArray.length += 1;
+            if (dragonBones.DataParser.VALUE in rawData) {
+                this._frameArray[frameOffset + 1] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.VALUE, 0);
+            }
+            else {
+                this._frameArray[frameOffset + 1] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.DISPLAY_INDEX, 0);
+            }
+            this._parseActionDataInFrame(rawData, frameStart, this._slot.parent, this._slot);
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseSlotColorFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var colorOffset = -1;
+            if (dragonBones.DataParser.VALUE in rawData || dragonBones.DataParser.COLOR in rawData) {
+                var rawColor = dragonBones.DataParser.VALUE in rawData ? rawData[dragonBones.DataParser.VALUE] : rawData[dragonBones.DataParser.COLOR];
+                for (var k in rawColor) {
+                    // tslint:disable-next-line:no-unused-expression
+                    k;
+                    this._parseColorTransform(rawColor, this._helpColorTransform);
+                    colorOffset = this._intArray.length;
+                    this._intArray.length += 8;
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.alphaMultiplier * 100);
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.redMultiplier * 100);
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.greenMultiplier * 100);
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.blueMultiplier * 100);
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.alphaOffset);
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.redOffset);
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.greenOffset);
+                    this._intArray[colorOffset++] = Math.round(this._helpColorTransform.blueOffset);
+                    colorOffset -= 8;
+                    break;
+                }
+            }
+            if (colorOffset < 0) {
+                if (this._defaultColorOffset < 0) {
+                    this._defaultColorOffset = colorOffset = this._intArray.length;
+                    this._intArray.length += 8;
+                    this._intArray[colorOffset++] = 100;
+                    this._intArray[colorOffset++] = 100;
+                    this._intArray[colorOffset++] = 100;
+                    this._intArray[colorOffset++] = 100;
+                    this._intArray[colorOffset++] = 0;
+                    this._intArray[colorOffset++] = 0;
+                    this._intArray[colorOffset++] = 0;
+                    this._intArray[colorOffset++] = 0;
+                }
+                colorOffset = this._defaultColorOffset;
+            }
+            var frameIntOffset = this._frameIntArray.length;
+            this._frameIntArray.length += 1;
+            this._frameIntArray[frameIntOffset] = colorOffset;
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseSlotFFDFrame = function (rawData, frameStart, frameCount) {
+            var frameFloatOffset = this._frameFloatArray.length;
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var rawVertices = dragonBones.DataParser.VERTICES in rawData ? rawData[dragonBones.DataParser.VERTICES] : null;
+            var offset = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.OFFSET, 0); // uint
+            var vertexCount = this._intArray[this._mesh.vertices.offset + 0 /* MeshVertexCount */];
+            var meshName = this._mesh.parent.name + "_" + this._slot.name + "_" + this._mesh.name;
+            var weight = this._mesh.vertices.weight;
+            var x = 0.0;
+            var y = 0.0;
+            var iB = 0;
+            var iV = 0;
+            if (weight !== null) {
+                var rawSlotPose = this._weightSlotPose[meshName];
+                this._helpMatrixA.copyFromArray(rawSlotPose, 0);
+                this._frameFloatArray.length += weight.count * 2;
+                iB = weight.offset + 2 /* WeigthBoneIndices */ + weight.bones.length;
+            }
+            else {
+                this._frameFloatArray.length += vertexCount * 2;
+            }
+            for (var i = 0; i < vertexCount * 2; i += 2) {
+                if (rawVertices === null) {
+                    x = 0.0;
+                    y = 0.0;
+                }
+                else {
+                    if (i < offset || i - offset >= rawVertices.length) {
+                        x = 0.0;
+                    }
+                    else {
+                        x = rawVertices[i - offset];
+                    }
+                    if (i + 1 < offset || i + 1 - offset >= rawVertices.length) {
+                        y = 0.0;
+                    }
+                    else {
+                        y = rawVertices[i + 1 - offset];
+                    }
+                }
+                if (weight !== null) {
+                    var rawBonePoses = this._weightBonePoses[meshName];
+                    var vertexBoneCount = this._intArray[iB++];
+                    this._helpMatrixA.transformPoint(x, y, this._helpPoint, true);
+                    x = this._helpPoint.x;
+                    y = this._helpPoint.y;
+                    for (var j = 0; j < vertexBoneCount; ++j) {
+                        var boneIndex = this._intArray[iB++];
+                        this._helpMatrixB.copyFromArray(rawBonePoses, boneIndex * 7 + 1);
+                        this._helpMatrixB.invert();
+                        this._helpMatrixB.transformPoint(x, y, this._helpPoint, true);
+                        this._frameFloatArray[frameFloatOffset + iV++] = this._helpPoint.x;
+                        this._frameFloatArray[frameFloatOffset + iV++] = this._helpPoint.y;
+                    }
+                }
+                else {
+                    this._frameFloatArray[frameFloatOffset + i] = x;
+                    this._frameFloatArray[frameFloatOffset + i + 1] = y;
+                }
+            }
+            if (frameStart === 0) {
+                var frameIntOffset = this._frameIntArray.length;
+                this._frameIntArray.length += 1 + 1 + 1 + 1 + 1;
+                this._frameIntArray[frameIntOffset + 0 /* DeformVertexOffset */] = this._mesh.vertices.offset;
+                this._frameIntArray[frameIntOffset + 1 /* DeformCount */] = this._frameFloatArray.length - frameFloatOffset;
+                this._frameIntArray[frameIntOffset + 2 /* DeformValueCount */] = this._frameFloatArray.length - frameFloatOffset;
+                this._frameIntArray[frameIntOffset + 3 /* DeformValueOffset */] = 0;
+                this._frameIntArray[frameIntOffset + 4 /* DeformFloatOffset */] = frameFloatOffset - this._animation.frameFloatOffset;
+                this._timelineArray[this._timeline.offset + 3 /* TimelineFrameValueCount */] = frameIntOffset - this._animation.frameIntOffset;
+            }
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseIKConstraintFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var frameIntOffset = this._frameIntArray.length;
+            this._frameIntArray.length += 2;
+            this._frameIntArray[frameIntOffset++] = ObjectDataParser._getBoolean(rawData, dragonBones.DataParser.BEND_POSITIVE, true) ? 1 : 0;
+            this._frameIntArray[frameIntOffset++] = Math.round(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.WEIGHT, 1.0) * 100.0);
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseAnimationFrame = function (rawData, frameStart, frameCount) {
+            var frameOffset = this._parseTweenFrame(rawData, frameStart, frameCount);
+            var frameIntOffset = this._frameIntArray.length;
+            this._frameIntArray.length += 2;
+            this._frameIntArray[frameIntOffset++] = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.VALUE, 0);
+            this._frameIntArray[frameIntOffset++] = Math.round(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.WEIGHT, 1.0) * 100.0);
+            return frameOffset;
+        };
+        ObjectDataParser.prototype._parseActionData = function (rawData, type, bone, slot) {
+            var actions = new Array();
+            if (typeof rawData === "string") {
+                var action = dragonBones.BaseObject.borrowObject(dragonBones.ActionData);
+                action.type = type;
+                action.name = rawData;
+                action.bone = bone;
+                action.slot = slot;
+                actions.push(action);
+            }
+            else if (rawData instanceof Array) {
+                for (var _i = 0, rawData_2 = rawData; _i < rawData_2.length; _i++) {
+                    var rawAction = rawData_2[_i];
+                    var action = dragonBones.BaseObject.borrowObject(dragonBones.ActionData);
+                    if (dragonBones.DataParser.GOTO_AND_PLAY in rawAction) {
+                        action.type = 0 /* Play */;
+                        action.name = ObjectDataParser._getString(rawAction, dragonBones.DataParser.GOTO_AND_PLAY, "");
+                    }
+                    else {
+                        if (dragonBones.DataParser.TYPE in rawAction && typeof rawAction[dragonBones.DataParser.TYPE] === "string") {
+                            action.type = dragonBones.DataParser._getActionType(rawAction[dragonBones.DataParser.TYPE]);
+                        }
+                        else {
+                            action.type = ObjectDataParser._getNumber(rawAction, dragonBones.DataParser.TYPE, type);
+                        }
+                        action.name = ObjectDataParser._getString(rawAction, dragonBones.DataParser.NAME, "");
+                    }
+                    if (dragonBones.DataParser.BONE in rawAction) {
+                        var boneName = ObjectDataParser._getString(rawAction, dragonBones.DataParser.BONE, "");
+                        action.bone = this._armature.getBone(boneName);
+                    }
+                    else {
+                        action.bone = bone;
+                    }
+                    if (dragonBones.DataParser.SLOT in rawAction) {
+                        var slotName = ObjectDataParser._getString(rawAction, dragonBones.DataParser.SLOT, "");
+                        action.slot = this._armature.getSlot(slotName);
+                    }
+                    else {
+                        action.slot = slot;
+                    }
+                    var userData = null;
+                    if (dragonBones.DataParser.INTS in rawAction) {
+                        if (userData === null) {
+                            userData = dragonBones.BaseObject.borrowObject(dragonBones.UserData);
+                        }
+                        var rawInts = rawAction[dragonBones.DataParser.INTS];
+                        for (var _a = 0, rawInts_1 = rawInts; _a < rawInts_1.length; _a++) {
+                            var rawValue = rawInts_1[_a];
+                            userData.addInt(rawValue);
+                        }
+                    }
+                    if (dragonBones.DataParser.FLOATS in rawAction) {
+                        if (userData === null) {
+                            userData = dragonBones.BaseObject.borrowObject(dragonBones.UserData);
+                        }
+                        var rawFloats = rawAction[dragonBones.DataParser.FLOATS];
+                        for (var _b = 0, rawFloats_1 = rawFloats; _b < rawFloats_1.length; _b++) {
+                            var rawValue = rawFloats_1[_b];
+                            userData.addFloat(rawValue);
+                        }
+                    }
+                    if (dragonBones.DataParser.STRINGS in rawAction) {
+                        if (userData === null) {
+                            userData = dragonBones.BaseObject.borrowObject(dragonBones.UserData);
+                        }
+                        var rawStrings = rawAction[dragonBones.DataParser.STRINGS];
+                        for (var _c = 0, rawStrings_1 = rawStrings; _c < rawStrings_1.length; _c++) {
+                            var rawValue = rawStrings_1[_c];
+                            userData.addString(rawValue);
+                        }
+                    }
+                    action.data = userData;
+                    actions.push(action);
+                }
+            }
+            return actions;
+        };
+        ObjectDataParser.prototype._parseTransform = function (rawData, transform, scale) {
+            transform.x = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.X, 0.0) * scale;
+            transform.y = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.Y, 0.0) * scale;
+            if (dragonBones.DataParser.ROTATE in rawData || dragonBones.DataParser.SKEW in rawData) {
+                transform.rotation = dragonBones.Transform.normalizeRadian(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.ROTATE, 0.0) * dragonBones.Transform.DEG_RAD);
+                transform.skew = dragonBones.Transform.normalizeRadian(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SKEW, 0.0) * dragonBones.Transform.DEG_RAD);
+            }
+            else if (dragonBones.DataParser.SKEW_X in rawData || dragonBones.DataParser.SKEW_Y in rawData) {
+                transform.rotation = dragonBones.Transform.normalizeRadian(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SKEW_Y, 0.0) * dragonBones.Transform.DEG_RAD);
+                transform.skew = dragonBones.Transform.normalizeRadian(ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SKEW_X, 0.0) * dragonBones.Transform.DEG_RAD) - transform.rotation;
+            }
+            transform.scaleX = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SCALE_X, 1.0);
+            transform.scaleY = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SCALE_Y, 1.0);
+        };
+        ObjectDataParser.prototype._parseColorTransform = function (rawData, color) {
+            color.alphaMultiplier = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.ALPHA_MULTIPLIER, 100) * 0.01;
+            color.redMultiplier = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.RED_MULTIPLIER, 100) * 0.01;
+            color.greenMultiplier = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.GREEN_MULTIPLIER, 100) * 0.01;
+            color.blueMultiplier = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.BLUE_MULTIPLIER, 100) * 0.01;
+            color.alphaOffset = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.ALPHA_OFFSET, 0);
+            color.redOffset = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.RED_OFFSET, 0);
+            color.greenOffset = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.GREEN_OFFSET, 0);
+            color.blueOffset = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.BLUE_OFFSET, 0);
+        };
+        ObjectDataParser.prototype._parseArray = function (rawData) {
+            // tslint:disable-next-line:no-unused-expression
+            rawData;
+            this._intArray.length = 0;
+            this._floatArray.length = 0;
+            this._frameIntArray.length = 0;
+            this._frameFloatArray.length = 0;
+            this._frameArray.length = 0;
+            this._timelineArray.length = 0;
+        };
+        ObjectDataParser.prototype._modifyArray = function () {
+            // Align.
+            if ((this._intArray.length % Int16Array.BYTES_PER_ELEMENT) !== 0) {
+                this._intArray.push(0);
+            }
+            if ((this._frameIntArray.length % Int16Array.BYTES_PER_ELEMENT) !== 0) {
+                this._frameIntArray.push(0);
+            }
+            if ((this._frameArray.length % Int16Array.BYTES_PER_ELEMENT) !== 0) {
+                this._frameArray.push(0);
+            }
+            if ((this._timelineArray.length % Uint16Array.BYTES_PER_ELEMENT) !== 0) {
+                this._timelineArray.push(0);
+            }
+            var l1 = this._intArray.length * Int16Array.BYTES_PER_ELEMENT;
+            var l2 = this._floatArray.length * Float32Array.BYTES_PER_ELEMENT;
+            var l3 = this._frameIntArray.length * Int16Array.BYTES_PER_ELEMENT;
+            var l4 = this._frameFloatArray.length * Float32Array.BYTES_PER_ELEMENT;
+            var l5 = this._frameArray.length * Int16Array.BYTES_PER_ELEMENT;
+            var l6 = this._timelineArray.length * Uint16Array.BYTES_PER_ELEMENT;
+            var lTotal = l1 + l2 + l3 + l4 + l5 + l6;
+            if (dragonBones.DragonBones.webAssembly) {
+                var shareBuffer = dragonBones.webAssemblyModule.HEAP16.buffer;
+                var bufferPointer = dragonBones.webAssemblyModule._malloc(lTotal);
+                var intArray = new Int16Array(shareBuffer, bufferPointer, this._intArray.length);
+                var floatArray = new Float32Array(shareBuffer, bufferPointer + l1, this._floatArray.length);
+                var frameIntArray = new Int16Array(shareBuffer, bufferPointer + l1 + l2, this._frameIntArray.length);
+                var frameFloatArray = new Float32Array(shareBuffer, bufferPointer + l1 + l2 + l3, this._frameFloatArray.length);
+                var frameArray = new Int16Array(shareBuffer, bufferPointer + l1 + l2 + l3 + l4, this._frameArray.length);
+                var timelineArray = new Uint16Array(shareBuffer, bufferPointer + l1 + l2 + l3 + l4 + l5, this._timelineArray.length);
+                for (var i = 0, l = this._intArray.length; i < l; ++i) {
+                    intArray[i] = this._intArray[i];
+                }
+                for (var i = 0, l = this._floatArray.length; i < l; ++i) {
+                    floatArray[i] = this._floatArray[i];
+                }
+                for (var i = 0, l = this._frameIntArray.length; i < l; ++i) {
+                    frameIntArray[i] = this._frameIntArray[i];
+                }
+                for (var i = 0, l = this._frameFloatArray.length; i < l; ++i) {
+                    frameFloatArray[i] = this._frameFloatArray[i];
+                }
+                for (var i = 0, l = this._frameArray.length; i < l; ++i) {
+                    frameArray[i] = this._frameArray[i];
+                }
+                for (var i = 0, l = this._timelineArray.length; i < l; ++i) {
+                    timelineArray[i] = this._timelineArray[i];
+                }
+                dragonBones.webAssemblyModule.setDataBinary(this._data, bufferPointer, l1, l2, l3, l4, l5, l6);
+            }
+            else {
+                var binary = new ArrayBuffer(lTotal);
+                var intArray = new Int16Array(binary, 0, this._intArray.length);
+                var floatArray = new Float32Array(binary, l1, this._floatArray.length);
+                var frameIntArray = new Int16Array(binary, l1 + l2, this._frameIntArray.length);
+                var frameFloatArray = new Float32Array(binary, l1 + l2 + l3, this._frameFloatArray.length);
+                var frameArray = new Int16Array(binary, l1 + l2 + l3 + l4, this._frameArray.length);
+                var timelineArray = new Uint16Array(binary, l1 + l2 + l3 + l4 + l5, this._timelineArray.length);
+                for (var i = 0, l = this._intArray.length; i < l; ++i) {
+                    intArray[i] = this._intArray[i];
+                }
+                for (var i = 0, l = this._floatArray.length; i < l; ++i) {
+                    floatArray[i] = this._floatArray[i];
+                }
+                for (var i = 0, l = this._frameIntArray.length; i < l; ++i) {
+                    frameIntArray[i] = this._frameIntArray[i];
+                }
+                for (var i = 0, l = this._frameFloatArray.length; i < l; ++i) {
+                    frameFloatArray[i] = this._frameFloatArray[i];
+                }
+                for (var i = 0, l = this._frameArray.length; i < l; ++i) {
+                    frameArray[i] = this._frameArray[i];
+                }
+                for (var i = 0, l = this._timelineArray.length; i < l; ++i) {
+                    timelineArray[i] = this._timelineArray[i];
+                }
+                this._data.binary = binary;
+                this._data.intArray = intArray;
+                this._data.floatArray = floatArray;
+                this._data.frameIntArray = frameIntArray;
+                this._data.frameFloatArray = frameFloatArray;
+                this._data.frameArray = frameArray;
+                this._data.timelineArray = timelineArray;
+            }
+            this._defaultColorOffset = -1;
+        };
+        ObjectDataParser.prototype.parseDragonBonesData = function (rawData, scale) {
+            if (scale === void 0) { scale = 1; }
+            console.assert(rawData !== null && rawData !== undefined, "Data error.");
+            var version = ObjectDataParser._getString(rawData, dragonBones.DataParser.VERSION, "");
+            var compatibleVersion = ObjectDataParser._getString(rawData, dragonBones.DataParser.COMPATIBLE_VERSION, "");
+            if (dragonBones.DataParser.DATA_VERSIONS.indexOf(version) >= 0 ||
+                dragonBones.DataParser.DATA_VERSIONS.indexOf(compatibleVersion) >= 0) {
+                var data = dragonBones.BaseObject.borrowObject(dragonBones.DragonBonesData);
+                data.version = version;
+                data.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+                data.frameRate = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.FRAME_RATE, 24);
+                if (data.frameRate === 0) {
+                    data.frameRate = 24;
+                }
+                if (dragonBones.DataParser.ARMATURE in rawData) {
+                    this._data = data;
+                    this._parseArray(rawData);
+                    var rawArmatures = rawData[dragonBones.DataParser.ARMATURE];
+                    for (var _i = 0, rawArmatures_1 = rawArmatures; _i < rawArmatures_1.length; _i++) {
+                        var rawArmature = rawArmatures_1[_i];
+                        data.addArmature(this._parseArmature(rawArmature, scale));
+                    }
+                    if (!this._data.binary) {
+                        this._modifyArray();
+                    }
+                    if (dragonBones.DataParser.STAGE in rawData) {
+                        data.stage = data.getArmature(ObjectDataParser._getString(rawData, dragonBones.DataParser.STAGE, ""));
+                    }
+                    else if (data.armatureNames.length > 0) {
+                        data.stage = data.getArmature(data.armatureNames[0]);
+                    }
+                    this._data = null;
+                }
+                if (dragonBones.DataParser.TEXTURE_ATLAS in rawData) {
+                    this._rawTextureAtlases = rawData[dragonBones.DataParser.TEXTURE_ATLAS];
+                }
+                return data;
+            }
+            else {
+                console.assert(false, "Nonsupport data version: " + version + "\n" +
+                    "Please convert DragonBones data to support version.\n" +
+                    "Read more: https://github.com/DragonBones/Tools/");
+            }
+            return null;
+        };
+        ObjectDataParser.prototype.parseTextureAtlasData = function (rawData, textureAtlasData, scale) {
+            if (scale === void 0) { scale = 1.0; }
+            console.assert(rawData !== undefined);
+            if (rawData === null) {
+                if (this._rawTextureAtlases === null || this._rawTextureAtlases.length === 0) {
+                    return false;
+                }
+                var rawTextureAtlas = this._rawTextureAtlases[this._rawTextureAtlasIndex++];
+                this.parseTextureAtlasData(rawTextureAtlas, textureAtlasData, scale);
+                if (this._rawTextureAtlasIndex >= this._rawTextureAtlases.length) {
+                    this._rawTextureAtlasIndex = 0;
+                    this._rawTextureAtlases = null;
+                }
+                return true;
+            }
+            // Texture format.
+            textureAtlasData.width = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.WIDTH, 0);
+            textureAtlasData.height = ObjectDataParser._getNumber(rawData, dragonBones.DataParser.HEIGHT, 0);
+            textureAtlasData.scale = scale === 1.0 ? (1.0 / ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SCALE, 1.0)) : scale;
+            textureAtlasData.name = ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, "");
+            textureAtlasData.imagePath = ObjectDataParser._getString(rawData, dragonBones.DataParser.IMAGE_PATH, "");
+            if (dragonBones.DataParser.SUB_TEXTURE in rawData) {
+                var rawTextures = rawData[dragonBones.DataParser.SUB_TEXTURE];
+                for (var i = 0, l = rawTextures.length; i < l; ++i) {
+                    var rawTexture = rawTextures[i];
+                    var textureData = textureAtlasData.createTexture();
+                    textureData.rotated = ObjectDataParser._getBoolean(rawTexture, dragonBones.DataParser.ROTATED, false);
+                    textureData.name = ObjectDataParser._getString(rawTexture, dragonBones.DataParser.NAME, "");
+                    textureData.region.x = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.X, 0.0);
+                    textureData.region.y = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.Y, 0.0);
+                    textureData.region.width = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.WIDTH, 0.0);
+                    textureData.region.height = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.HEIGHT, 0.0);
+                    var frameWidth = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.FRAME_WIDTH, -1.0);
+                    var frameHeight = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.FRAME_HEIGHT, -1.0);
+                    if (frameWidth > 0.0 && frameHeight > 0.0) {
+                        textureData.frame = dragonBones.TextureData.createRectangle();
+                        textureData.frame.x = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.FRAME_X, 0.0);
+                        textureData.frame.y = ObjectDataParser._getNumber(rawTexture, dragonBones.DataParser.FRAME_Y, 0.0);
+                        textureData.frame.width = frameWidth;
+                        textureData.frame.height = frameHeight;
+                    }
+                    textureAtlasData.addTexture(textureData);
+                }
+            }
+            return true;
+        };
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parseDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parseDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        ObjectDataParser.getInstance = function () {
+            if (ObjectDataParser._objectDataParserInstance === null) {
+                ObjectDataParser._objectDataParserInstance = new ObjectDataParser();
+            }
+            return ObjectDataParser._objectDataParserInstance;
+        };
+        ObjectDataParser._objectDataParserInstance = null;
+        return ObjectDataParser;
+    }(dragonBones.DataParser));
+    dragonBones.ObjectDataParser = ObjectDataParser;
+    /**
+     * @internal
+     */
+    var ActionFrame = /** @class */ (function () {
+        function ActionFrame() {
+            this.frameStart = 0;
+            this.actions = [];
+        }
+        return ActionFrame;
+    }());
+    dragonBones.ActionFrame = ActionFrame;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    var BinaryDataParser = /** @class */ (function (_super) {
+        __extends(BinaryDataParser, _super);
+        function BinaryDataParser() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        BinaryDataParser.prototype._inRange = function (a, min, max) {
+            return min <= a && a <= max;
+        };
+        BinaryDataParser.prototype._decodeUTF8 = function (data) {
+            var EOF_byte = -1;
+            var EOF_code_point = -1;
+            var FATAL_POINT = 0xFFFD;
+            var pos = 0;
+            var result = "";
+            var code_point;
+            var utf8_code_point = 0;
+            var utf8_bytes_needed = 0;
+            var utf8_bytes_seen = 0;
+            var utf8_lower_boundary = 0;
+            while (data.length > pos) {
+                var _byte = data[pos++];
+                if (_byte === EOF_byte) {
+                    if (utf8_bytes_needed !== 0) {
+                        code_point = FATAL_POINT;
+                    }
+                    else {
+                        code_point = EOF_code_point;
+                    }
+                }
+                else {
+                    if (utf8_bytes_needed === 0) {
+                        if (this._inRange(_byte, 0x00, 0x7F)) {
+                            code_point = _byte;
+                        }
+                        else {
+                            if (this._inRange(_byte, 0xC2, 0xDF)) {
+                                utf8_bytes_needed = 1;
+                                utf8_lower_boundary = 0x80;
+                                utf8_code_point = _byte - 0xC0;
+                            }
+                            else if (this._inRange(_byte, 0xE0, 0xEF)) {
+                                utf8_bytes_needed = 2;
+                                utf8_lower_boundary = 0x800;
+                                utf8_code_point = _byte - 0xE0;
+                            }
+                            else if (this._inRange(_byte, 0xF0, 0xF4)) {
+                                utf8_bytes_needed = 3;
+                                utf8_lower_boundary = 0x10000;
+                                utf8_code_point = _byte - 0xF0;
+                            }
+                            else {
+                            }
+                            utf8_code_point = utf8_code_point * Math.pow(64, utf8_bytes_needed);
+                            code_point = null;
+                        }
+                    }
+                    else if (!this._inRange(_byte, 0x80, 0xBF)) {
+                        utf8_code_point = 0;
+                        utf8_bytes_needed = 0;
+                        utf8_bytes_seen = 0;
+                        utf8_lower_boundary = 0;
+                        pos--;
+                        code_point = _byte;
+                    }
+                    else {
+                        utf8_bytes_seen += 1;
+                        utf8_code_point = utf8_code_point + (_byte - 0x80) * Math.pow(64, utf8_bytes_needed - utf8_bytes_seen);
+                        if (utf8_bytes_seen !== utf8_bytes_needed) {
+                            code_point = null;
+                        }
+                        else {
+                            var cp = utf8_code_point;
+                            var lower_boundary = utf8_lower_boundary;
+                            utf8_code_point = 0;
+                            utf8_bytes_needed = 0;
+                            utf8_bytes_seen = 0;
+                            utf8_lower_boundary = 0;
+                            if (this._inRange(cp, lower_boundary, 0x10FFFF) && !this._inRange(cp, 0xD800, 0xDFFF)) {
+                                code_point = cp;
+                            }
+                            else {
+                                code_point = _byte;
+                            }
+                        }
+                    }
+                }
+                //Decode string
+                if (code_point !== null && code_point !== EOF_code_point) {
+                    if (code_point <= 0xFFFF) {
+                        if (code_point > 0)
+                            result += String.fromCharCode(code_point);
+                    }
+                    else {
+                        code_point -= 0x10000;
+                        result += String.fromCharCode(0xD800 + ((code_point >> 10) & 0x3ff));
+                        result += String.fromCharCode(0xDC00 + (code_point & 0x3ff));
+                    }
+                }
+            }
+            return result;
+        };
+        BinaryDataParser.prototype._getUTF16Key = function (value) {
+            for (var i = 0, l = value.length; i < l; ++i) {
+                if (value.charCodeAt(i) > 255) {
+                    return encodeURI(value);
+                }
+            }
+            return value;
+        };
+        BinaryDataParser.prototype._parseBinaryTimeline = function (type, offset, timelineData) {
+            if (timelineData === void 0) { timelineData = null; }
+            var timeline = timelineData !== null ? timelineData : dragonBones.BaseObject.borrowObject(dragonBones.TimelineData);
+            timeline.type = type;
+            timeline.offset = offset;
+            this._timeline = timeline;
+            var keyFrameCount = this._timelineArrayBuffer[timeline.offset + 2 /* TimelineKeyFrameCount */];
+            if (keyFrameCount === 1) {
+                timeline.frameIndicesOffset = -1;
+            }
+            else {
+                var frameIndicesOffset = 0;
+                var totalFrameCount = this._animation.frameCount + 1; // One more frame than animation.
+                var frameIndices = this._data.frameIndices;
+                if (dragonBones.DragonBones.webAssembly) {
+                    frameIndicesOffset = frameIndices.size();
+                    frameIndices.resize(frameIndicesOffset + totalFrameCount, 0);
+                }
+                else {
+                    frameIndicesOffset = frameIndices.length;
+                    frameIndices.length += totalFrameCount;
+                }
+                timeline.frameIndicesOffset = frameIndicesOffset;
+                for (var i = 0, iK = 0, frameStart = 0, frameCount = 0; i < totalFrameCount; ++i) {
+                    if (frameStart + frameCount <= i && iK < keyFrameCount) {
+                        frameStart = this._frameArrayBuffer[this._animation.frameOffset + this._timelineArrayBuffer[timeline.offset + 5 /* TimelineFrameOffset */ + iK]];
+                        if (iK === keyFrameCount - 1) {
+                            frameCount = this._animation.frameCount - frameStart;
+                        }
+                        else {
+                            frameCount = this._frameArrayBuffer[this._animation.frameOffset + this._timelineArrayBuffer[timeline.offset + 5 /* TimelineFrameOffset */ + iK + 1]] - frameStart;
+                        }
+                        iK++;
+                    }
+                    if (dragonBones.DragonBones.webAssembly) {
+                        frameIndices.set(frameIndicesOffset + i, iK - 1);
+                    }
+                    else {
+                        frameIndices[frameIndicesOffset + i] = iK - 1;
+                    }
+                }
+            }
+            this._timeline = null; //
+            return timeline;
+        };
+        BinaryDataParser.prototype._parseVertices = function (rawData, vertices) {
+            vertices.offset = rawData[dragonBones.DataParser.OFFSET];
+            var weightOffset = this._intArrayBuffer[vertices.offset + 3 /* MeshWeightOffset */];
+            if (weightOffset >= 0) {
+                var weight = dragonBones.BaseObject.borrowObject(dragonBones.WeightData);
+                var vertexCount = this._intArrayBuffer[vertices.offset + 0 /* MeshVertexCount */];
+                var boneCount = this._intArrayBuffer[weightOffset + 0 /* WeigthBoneCount */];
+                weight.offset = weightOffset;
+                for (var i = 0; i < boneCount; ++i) {
+                    var boneIndex = this._intArrayBuffer[weightOffset + 2 /* WeigthBoneIndices */ + i];
+                    weight.addBone(this._rawBones[boneIndex]);
+                }
+                var boneIndicesOffset = weightOffset + 2 /* WeigthBoneIndices */ + boneCount;
+                var weightCount = 0;
+                for (var i = 0, l = vertexCount; i < l; ++i) {
+                    var vertexBoneCount = this._intArrayBuffer[boneIndicesOffset++];
+                    weightCount += vertexBoneCount;
+                    boneIndicesOffset += vertexBoneCount;
+                }
+                weight.count = weightCount;
+                vertices.weight = weight;
+            }
+        };
+        BinaryDataParser.prototype._parseMesh = function (rawData, mesh) {
+            this._parseVertices(rawData, mesh.vertices);
+        };
+        BinaryDataParser.prototype._parsePath = function (rawData, path) {
+            this._parseVertices(rawData, path.vertices);
+        };
+        BinaryDataParser.prototype._parseAnimation = function (rawData) {
+            var animation = dragonBones.BaseObject.borrowObject(dragonBones.AnimationData);
+            animation.frameCount = Math.max(dragonBones.ObjectDataParser._getNumber(rawData, dragonBones.DataParser.DURATION, 1), 1);
+            animation.playTimes = dragonBones.ObjectDataParser._getNumber(rawData, dragonBones.DataParser.PLAY_TIMES, 1);
+            animation.duration = animation.frameCount / this._armature.frameRate; // float
+            animation.fadeInTime = dragonBones.ObjectDataParser._getNumber(rawData, dragonBones.DataParser.FADE_IN_TIME, 0.0);
+            animation.scale = dragonBones.ObjectDataParser._getNumber(rawData, dragonBones.DataParser.SCALE, 1.0);
+            animation.name = dragonBones.ObjectDataParser._getString(rawData, dragonBones.DataParser.NAME, dragonBones.DataParser.DEFAULT_NAME);
+            if (animation.name.length === 0) {
+                animation.name = dragonBones.DataParser.DEFAULT_NAME;
+            }
+            // Offsets.
+            var offsets = rawData[dragonBones.DataParser.OFFSET];
+            animation.frameIntOffset = offsets[0];
+            animation.frameFloatOffset = offsets[1];
+            animation.frameOffset = offsets[2];
+            this._animation = animation;
+            if (dragonBones.DataParser.ACTION in rawData) {
+                animation.actionTimeline = this._parseBinaryTimeline(0 /* Action */, rawData[dragonBones.DataParser.ACTION]);
+            }
+            if (dragonBones.DataParser.Z_ORDER in rawData) {
+                animation.zOrderTimeline = this._parseBinaryTimeline(1 /* ZOrder */, rawData[dragonBones.DataParser.Z_ORDER]);
+            }
+            if (dragonBones.DataParser.BONE in rawData) {
+                var rawTimeliness = rawData[dragonBones.DataParser.BONE];
+                for (var k in rawTimeliness) {
+                    var rawTimelines = rawTimeliness[k];
+                    if (dragonBones.DragonBones.webAssembly) {
+                        k = this._getUTF16Key(k);
+                    }
+                    var bone = this._armature.getBone(k);
+                    if (bone === null) {
+                        continue;
+                    }
+                    for (var i = 0, l = rawTimelines.length; i < l; i += 2) {
+                        var timelineType = rawTimelines[i];
+                        var timelineOffset = rawTimelines[i + 1];
+                        var timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                        this._animation.addBoneTimeline(bone, timeline);
+                    }
+                }
+            }
+            if (dragonBones.DataParser.SURFACE in rawData) {
+                var rawTimeliness = rawData[dragonBones.DataParser.SURFACE];
+                for (var k in rawTimeliness) {
+                    var rawTimelines = rawTimeliness[k];
+                    if (dragonBones.DragonBones.webAssembly) {
+                        k = this._getUTF16Key(k);
+                    }
+                    var surface = this._armature.getBone(k);
+                    if (surface === null) {
+                        continue;
+                    }
+                    for (var i = 0, l = rawTimelines.length; i < l; i += 2) {
+                        var timelineType = rawTimelines[i];
+                        var timelineOffset = rawTimelines[i + 1];
+                        var timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                        this._animation.addSurfaceTimeline(surface, timeline);
+                    }
+                }
+            }
+            if (dragonBones.DataParser.SLOT in rawData) {
+                var rawTimeliness = rawData[dragonBones.DataParser.SLOT];
+                for (var k in rawTimeliness) {
+                    var rawTimelines = rawTimeliness[k];
+                    if (dragonBones.DragonBones.webAssembly) {
+                        k = this._getUTF16Key(k);
+                    }
+                    var slot = this._armature.getSlot(k);
+                    if (slot === null) {
+                        continue;
+                    }
+                    for (var i = 0, l = rawTimelines.length; i < l; i += 2) {
+                        var timelineType = rawTimelines[i];
+                        var timelineOffset = rawTimelines[i + 1];
+                        var timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                        this._animation.addSlotTimeline(slot, timeline);
+                    }
+                }
+            }
+            if (dragonBones.DataParser.CONSTRAINT in rawData) {
+                var rawTimeliness = rawData[dragonBones.DataParser.CONSTRAINT];
+                for (var k in rawTimeliness) {
+                    var rawTimelines = rawTimeliness[k];
+                    if (dragonBones.DragonBones.webAssembly) {
+                        k = this._getUTF16Key(k);
+                    }
+                    var constraint = this._armature.getConstraint(k);
+                    if (constraint === null) {
+                        continue;
+                    }
+                    for (var i = 0, l = rawTimelines.length; i < l; i += 2) {
+                        var timelineType = rawTimelines[i];
+                        var timelineOffset = rawTimelines[i + 1];
+                        var timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                        this._animation.addConstraintTimeline(constraint, timeline);
+                    }
+                }
+            }
+            if (dragonBones.DataParser.ANIMATION in rawData) {
+                var rawTimeliness = rawData[dragonBones.DataParser.ANIMATION];
+                for (var k in rawTimeliness) {
+                    var rawTimelines = rawTimeliness[k];
+                    if (dragonBones.DragonBones.webAssembly) {
+                        k = this._getUTF16Key(k);
+                    }
+                    for (var i = 0, l = rawTimelines.length; i < l; i += 2) {
+                        var timelineType = rawTimelines[i];
+                        var timelineOffset = rawTimelines[i + 1];
+                        var timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                        this._animation.addAnimationTimeline(k, timeline);
+                    }
+                }
+            }
+            this._animation = null;
+            return animation;
+        };
+        BinaryDataParser.prototype._parseArray = function (rawData) {
+            var offsets = rawData[dragonBones.DataParser.OFFSET];
+            var l1 = offsets[1];
+            var l2 = offsets[3];
+            var l3 = offsets[5];
+            var l4 = offsets[7];
+            var l5 = offsets[9];
+            var l6 = offsets[11];
+            var intArray = new Int16Array(this._binary, this._binaryOffset + offsets[0], l1 / Int16Array.BYTES_PER_ELEMENT);
+            var floatArray = new Float32Array(this._binary, this._binaryOffset + offsets[2], l2 / Float32Array.BYTES_PER_ELEMENT);
+            var frameIntArray = new Int16Array(this._binary, this._binaryOffset + offsets[4], l3 / Int16Array.BYTES_PER_ELEMENT);
+            var frameFloatArray = new Float32Array(this._binary, this._binaryOffset + offsets[6], l4 / Float32Array.BYTES_PER_ELEMENT);
+            var frameArray = new Int16Array(this._binary, this._binaryOffset + offsets[8], l5 / Int16Array.BYTES_PER_ELEMENT);
+            var timelineArray = new Uint16Array(this._binary, this._binaryOffset + offsets[10], l6 / Uint16Array.BYTES_PER_ELEMENT);
+            if (dragonBones.DragonBones.webAssembly) {
+                var lTotal = l1 + l2 + l3 + l4 + l5 + l6;
+                var bufferPointer = dragonBones.webAssemblyModule._malloc(lTotal);
+                var rawArray = new Uint8Array(this._binary, this._binaryOffset, lTotal / Uint8Array.BYTES_PER_ELEMENT);
+                var copyArray = new Uint8Array(dragonBones.webAssemblyModule.HEAP16.buffer, bufferPointer, rawArray.length);
+                for (var i = 0, l = rawArray.length; i < l; ++i) {
+                    copyArray[i] = rawArray[i];
+                }
+                dragonBones.webAssemblyModule.setDataBinary(this._data, bufferPointer, l1, l2, l3, l4, l5, l6);
+                this._intArrayBuffer = intArray;
+                this._floatArrayBuffer = floatArray;
+                this._frameIntArrayBuffer = frameIntArray;
+                this._frameFloatArrayBuffer = frameFloatArray;
+                this._frameArrayBuffer = frameArray;
+                this._timelineArrayBuffer = timelineArray;
+            }
+            else {
+                this._data.binary = this._binary;
+                this._data.intArray = this._intArrayBuffer = intArray;
+                this._data.floatArray = this._floatArrayBuffer = floatArray;
+                this._data.frameIntArray = this._frameIntArrayBuffer = frameIntArray;
+                this._data.frameFloatArray = this._frameFloatArrayBuffer = frameFloatArray;
+                this._data.frameArray = this._frameArrayBuffer = frameArray;
+                this._data.timelineArray = this._timelineArrayBuffer = timelineArray;
+            }
+        };
+        BinaryDataParser.prototype.parseDragonBonesData = function (rawData, scale) {
+            if (scale === void 0) { scale = 1; }
+            console.assert(rawData !== null && rawData !== undefined && rawData instanceof ArrayBuffer, "Data error.");
+            var tag = new Uint8Array(rawData, 0, 8);
+            if (tag[0] !== "D".charCodeAt(0) ||
+                tag[1] !== "B".charCodeAt(0) ||
+                tag[2] !== "D".charCodeAt(0) ||
+                tag[3] !== "T".charCodeAt(0)) {
+                console.assert(false, "Nonsupport data.");
+                return null;
+            }
+            var headerLength = new Uint32Array(rawData, 8, 1)[0];
+            var headerBytes = new Uint8Array(rawData, 8 + 4, headerLength);
+            var headerString = this._decodeUTF8(headerBytes);
+            var header = JSON.parse(headerString);
+            //
+            this._binaryOffset = 8 + 4 + headerLength;
+            this._binary = rawData;
+            return _super.prototype.parseDragonBonesData.call(this, header, scale);
+        };
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#parseDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#parseDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        BinaryDataParser.getInstance = function () {
+            if (BinaryDataParser._binaryDataParserInstance === null) {
+                BinaryDataParser._binaryDataParserInstance = new BinaryDataParser();
+            }
+            return BinaryDataParser._binaryDataParserInstance;
+        };
+        BinaryDataParser._binaryDataParserInstance = null;
+        return BinaryDataParser;
+    }(dragonBones.ObjectDataParser));
+    dragonBones.BinaryDataParser = BinaryDataParser;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - Base class for the factory that create the armatures. (Typically only one global factory instance is required)
+     * The factory instance create armatures by parsed and added DragonBonesData instances and TextureAtlasData instances.
+     * Once the data has been parsed, it has been cached in the factory instance and does not need to be parsed again until it is cleared by the factory instance.
+     * @see dragonBones.DragonBonesData
+     * @see dragonBones.TextureAtlasData
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - 创建骨架的工厂基类。 （通常只需要一个全局工厂实例）
+     * 工厂通过解析并添加的 DragonBonesData 实例和 TextureAtlasData 实例来创建骨架。
+     * 当数据被解析过之后，已经添加到工厂中，在没有被工厂清理之前，不需要再次解析。
+     * @see dragonBones.DragonBonesData
+     * @see dragonBones.TextureAtlasData
+     * @see dragonBones.ArmatureData
+     * @see dragonBones.Armature
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var BaseFactory = /** @class */ (function () {
+        /**
+         * - Create a factory instance. (typically only one global factory instance is required)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建一个工厂实例。 （通常只需要一个全局工厂实例）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        function BaseFactory(dataParser) {
+            if (dataParser === void 0) { dataParser = null; }
+            /**
+             * @private
+             */
+            this.autoSearch = false;
+            this._dragonBonesDataMap = {};
+            this._textureAtlasDataMap = {};
+            this._dragonBones = null;
+            this._dataParser = null;
+            if (BaseFactory._objectParser === null) {
+                BaseFactory._objectParser = new dragonBones.ObjectDataParser();
+            }
+            if (BaseFactory._binaryParser === null) {
+                BaseFactory._binaryParser = new dragonBones.BinaryDataParser();
+            }
+            this._dataParser = dataParser !== null ? dataParser : BaseFactory._objectParser;
+        }
+        BaseFactory.prototype._isSupportMesh = function () {
+            return true;
+        };
+        BaseFactory.prototype._getTextureData = function (textureAtlasName, textureName) {
+            if (textureAtlasName in this._textureAtlasDataMap) {
+                for (var _i = 0, _a = this._textureAtlasDataMap[textureAtlasName]; _i < _a.length; _i++) {
+                    var textureAtlasData = _a[_i];
+                    var textureData = textureAtlasData.getTexture(textureName);
+                    if (textureData !== null) {
+                        return textureData;
+                    }
+                }
+            }
+            if (this.autoSearch) {
+                for (var k in this._textureAtlasDataMap) {
+                    for (var _b = 0, _c = this._textureAtlasDataMap[k]; _b < _c.length; _b++) {
+                        var textureAtlasData = _c[_b];
+                        if (textureAtlasData.autoSearch) {
+                            var textureData = textureAtlasData.getTexture(textureName);
+                            if (textureData !== null) {
+                                return textureData;
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        };
+        BaseFactory.prototype._fillBuildArmaturePackage = function (dataPackage, dragonBonesName, armatureName, skinName, textureAtlasName) {
+            var dragonBonesData = null;
+            var armatureData = null;
+            if (dragonBonesName.length > 0) {
+                if (dragonBonesName in this._dragonBonesDataMap) {
+                    dragonBonesData = this._dragonBonesDataMap[dragonBonesName];
+                    armatureData = dragonBonesData.getArmature(armatureName);
+                }
+            }
+            if (armatureData === null && (dragonBonesName.length === 0 || this.autoSearch)) {
+                for (var k in this._dragonBonesDataMap) {
+                    dragonBonesData = this._dragonBonesDataMap[k];
+                    if (dragonBonesName.length === 0 || dragonBonesData.autoSearch) {
+                        armatureData = dragonBonesData.getArmature(armatureName);
+                        if (armatureData !== null) {
+                            dragonBonesName = k;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (armatureData !== null) {
+                dataPackage.dataName = dragonBonesName;
+                dataPackage.textureAtlasName = textureAtlasName;
+                dataPackage.data = dragonBonesData;
+                dataPackage.armature = armatureData;
+                dataPackage.skin = null;
+                if (skinName.length > 0) {
+                    dataPackage.skin = armatureData.getSkin(skinName);
+                    if (dataPackage.skin === null && this.autoSearch) {
+                        for (var k in this._dragonBonesDataMap) {
+                            var skinDragonBonesData = this._dragonBonesDataMap[k];
+                            var skinArmatureData = skinDragonBonesData.getArmature(skinName);
+                            if (skinArmatureData !== null) {
+                                dataPackage.skin = skinArmatureData.defaultSkin;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (dataPackage.skin === null) {
+                    dataPackage.skin = armatureData.defaultSkin;
+                }
+                return true;
+            }
+            return false;
+        };
+        BaseFactory.prototype._buildBones = function (dataPackage, armature) {
+            for (var _i = 0, _a = dataPackage.armature.sortedBones; _i < _a.length; _i++) {
+                var boneData = _a[_i];
+                var bone = dragonBones.BaseObject.borrowObject(boneData.type === 0 /* Bone */ ? dragonBones.Bone : dragonBones.Surface);
+                bone.init(boneData, armature);
+            }
+        };
+        /**
+         * @private
+         */
+        BaseFactory.prototype._buildSlots = function (dataPackage, armature) {
+            var currentSkin = dataPackage.skin;
+            var defaultSkin = dataPackage.armature.defaultSkin;
+            if (currentSkin === null || defaultSkin === null) {
+                return;
+            }
+            var skinSlots = {};
+            for (var k in defaultSkin.displays) {
+                var displays = defaultSkin.getDisplays(k);
+                skinSlots[k] = displays;
+            }
+            if (currentSkin !== defaultSkin) {
+                for (var k in currentSkin.displays) {
+                    var displays = currentSkin.getDisplays(k);
+                    skinSlots[k] = displays;
+                }
+            }
+            for (var _i = 0, _a = dataPackage.armature.sortedSlots; _i < _a.length; _i++) {
+                var slotData = _a[_i];
+                var displayDatas = slotData.name in skinSlots ? skinSlots[slotData.name] : null;
+                var slot = this._buildSlot(dataPackage, slotData, armature);
+                slot.rawDisplayDatas = displayDatas;
+                if (displayDatas !== null) {
+                    var displayList = new Array();
+                    // for (const displayData of displays) 
+                    for (var i = 0, l = dragonBones.DragonBones.webAssembly ? displayDatas.size() : displayDatas.length; i < l; ++i) {
+                        var displayData = dragonBones.DragonBones.webAssembly ? displayDatas.get(i) : displayDatas[i];
+                        if (displayData !== null) {
+                            displayList.push(this._getSlotDisplay(dataPackage, displayData, null, slot));
+                        }
+                        else {
+                            displayList.push(null);
+                        }
+                    }
+                    slot._setDisplayList(displayList);
+                }
+                slot._setDisplayIndex(slotData.displayIndex, true);
+            }
+        };
+        BaseFactory.prototype._buildConstraints = function (dataPackage, armature) {
+            var constraints = dataPackage.armature.constraints;
+            for (var k in constraints) {
+                var constraintData = constraints[k];
+                // TODO more constraint type.
+                switch (constraintData.type) {
+                    case 0 /* IK */:
+                        var ikConstraint = dragonBones.BaseObject.borrowObject(dragonBones.IKConstraint);
+                        ikConstraint.init(constraintData, armature);
+                        armature._addConstraint(ikConstraint);
+                        break;
+                    case 1 /* Path */:
+                        var pathConstraint = dragonBones.BaseObject.borrowObject(dragonBones.PathConstraint);
+                        pathConstraint.init(constraintData, armature);
+                        armature._addConstraint(pathConstraint);
+                        break;
+                    default:
+                        var constraint = dragonBones.BaseObject.borrowObject(dragonBones.IKConstraint);
+                        constraint.init(constraintData, armature);
+                        armature._addConstraint(constraint);
+                        break;
+                }
+            }
+        };
+        BaseFactory.prototype._buildChildArmature = function (dataPackage, slot, displayData) {
+            // tslint:disable-next-line:no-unused-expression
+            slot;
+            return this.buildArmature(displayData.path, dataPackage !== null ? dataPackage.dataName : "", "", dataPackage !== null ? dataPackage.textureAtlasName : "");
+        };
+        BaseFactory.prototype._getSlotDisplay = function (dataPackage, displayData, rawDisplayData, slot) {
+            var dataName = dataPackage !== null ? dataPackage.dataName : displayData.parent.parent.parent.name;
+            var display = null;
+            switch (displayData.type) {
+                case 0 /* Image */: {
+                    var imageDisplayData = displayData;
+                    if (imageDisplayData.texture === null) {
+                        imageDisplayData.texture = this._getTextureData(dataName, displayData.path);
+                    }
+                    else if (dataPackage !== null && dataPackage.textureAtlasName.length > 0) {
+                        imageDisplayData.texture = this._getTextureData(dataPackage.textureAtlasName, displayData.path);
+                    }
+                    if (rawDisplayData !== null && rawDisplayData.type === 2 /* Mesh */ && this._isSupportMesh()) {
+                        display = slot.meshDisplay;
+                    }
+                    else {
+                        display = slot.rawDisplay;
+                    }
+                    break;
+                }
+                case 2 /* Mesh */: {
+                    var meshDisplayData = displayData;
+                    if (meshDisplayData.texture === null) {
+                        meshDisplayData.texture = this._getTextureData(dataName, meshDisplayData.path);
+                    }
+                    else if (dataPackage !== null && dataPackage.textureAtlasName.length > 0) {
+                        meshDisplayData.texture = this._getTextureData(dataPackage.textureAtlasName, meshDisplayData.path);
+                    }
+                    if (this._isSupportMesh()) {
+                        display = slot.meshDisplay;
+                    }
+                    else {
+                        display = slot.rawDisplay;
+                    }
+                    break;
+                }
+                case 1 /* Armature */: {
+                    var armatureDisplayData = displayData;
+                    var childArmature = this._buildChildArmature(dataPackage, slot, displayData);
+                    if (childArmature !== null) {
+                        childArmature.inheritAnimation = armatureDisplayData.inheritAnimation;
+                        if (!childArmature.inheritAnimation) {
+                            var actions = armatureDisplayData.actions.length > 0 ? armatureDisplayData.actions : childArmature.armatureData.defaultActions;
+                            if (actions.length > 0) {
+                                for (var _i = 0, actions_6 = actions; _i < actions_6.length; _i++) {
+                                    var action = actions_6[_i];
+                                    var eventObject = dragonBones.BaseObject.borrowObject(dragonBones.EventObject);
+                                    dragonBones.EventObject.actionDataToInstance(action, eventObject, slot.armature);
+                                    eventObject.slot = slot;
+                                    slot.armature._bufferAction(eventObject, false);
+                                }
+                            }
+                            else {
+                                childArmature.animation.play();
+                            }
+                        }
+                        armatureDisplayData.armature = childArmature.armatureData; // 
+                    }
+                    display = childArmature;
+                    break;
+                }
+                case 3 /* BoundingBox */:
+                    break;
+                default:
+                    break;
+            }
+            return display;
+        };
+        /**
+         * - Parse the raw data to a DragonBonesData instance and cache it to the factory.
+         * @param rawData - The raw data.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (If not set, use the instance name instead)
+         * @param scale - Specify a scaling value for all armatures. (Default: 1.0)
+         * @returns DragonBonesData instance
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 将原始数据解析为 DragonBonesData 实例，并缓存到工厂中。
+         * @param rawData - 原始数据。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @param scale - 为所有的骨架指定一个缩放值。 （默认: 1.0）
+         * @returns DragonBonesData 实例
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseFactory.prototype.parseDragonBonesData = function (rawData, name, scale) {
+            if (name === void 0) { name = null; }
+            if (scale === void 0) { scale = 1.0; }
+            var dataParser = rawData instanceof ArrayBuffer ? BaseFactory._binaryParser : this._dataParser;
+            var dragonBonesData = dataParser.parseDragonBonesData(rawData, scale);
+            while (true) {
+                var textureAtlasData = this._buildTextureAtlasData(null, null);
+                if (dataParser.parseTextureAtlasData(null, textureAtlasData, scale)) {
+                    this.addTextureAtlasData(textureAtlasData, name);
+                }
+                else {
+                    textureAtlasData.returnToPool();
+                    break;
+                }
+            }
+            if (dragonBonesData !== null) {
+                this.addDragonBonesData(dragonBonesData, name);
+            }
+            return dragonBonesData;
+        };
+        /**
+         * - Parse the raw texture atlas data and the texture atlas object to a TextureAtlasData instance and cache it to the factory.
+         * @param rawData - The raw texture atlas data.
+         * @param textureAtlas - The texture atlas object.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (If not set, use the instance name instead)
+         * @param scale - Specify a scaling value for the map set. (Default: 1.0)
+         * @returns TextureAtlasData instance
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 将原始贴图集数据和贴图集对象解析为 TextureAtlasData 实例，并缓存到工厂中。
+         * @param rawData - 原始贴图集数据。
+         * @param textureAtlas - 贴图集对象。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @param scale - 为贴图集指定一个缩放值。 （默认: 1.0）
+         * @returns TextureAtlasData 实例
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseFactory.prototype.parseTextureAtlasData = function (rawData, textureAtlas, name, scale) {
+            if (name === void 0) { name = null; }
+            if (scale === void 0) { scale = 1.0; }
+            var textureAtlasData = this._buildTextureAtlasData(null, null);
+            this._dataParser.parseTextureAtlasData(rawData, textureAtlasData, scale);
+            this._buildTextureAtlasData(textureAtlasData, textureAtlas || null);
+            this.addTextureAtlasData(textureAtlasData, name);
+            return textureAtlasData;
+        };
+        /**
+         * @private
+         */
+        BaseFactory.prototype.updateTextureAtlasData = function (name, textureAtlases) {
+            var textureAtlasDatas = this.getTextureAtlasData(name);
+            if (textureAtlasDatas !== null) {
+                for (var i = 0, l = textureAtlasDatas.length; i < l; ++i) {
+                    if (i < textureAtlases.length) {
+                        this._buildTextureAtlasData(textureAtlasDatas[i], textureAtlases[i]);
+                    }
+                }
+            }
+        };
+        /**
+         * - Get a specific DragonBonesData instance.
+         * @param name - The DragonBonesData instance cache name.
+         * @returns DragonBonesData instance
+         * @see #parseDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的 DragonBonesData 实例。
+         * @param name - DragonBonesData 实例的缓存名称。
+         * @returns DragonBonesData 实例
+         * @see #parseDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        BaseFactory.prototype.getDragonBonesData = function (name) {
+            return (name in this._dragonBonesDataMap) ? this._dragonBonesDataMap[name] : null;
+        };
+        /**
+         * - Cache a DragonBonesData instance to the factory.
+         * @param data - The DragonBonesData instance.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (if not set, use the instance name instead)
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将 DragonBonesData 实例缓存到工厂中。
+         * @param data - DragonBonesData 实例。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #removeDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        BaseFactory.prototype.addDragonBonesData = function (data, name) {
+            if (name === void 0) { name = null; }
+            name = name !== null ? name : data.name;
+            if (name in this._dragonBonesDataMap) {
+                if (this._dragonBonesDataMap[name] === data) {
+                    return;
+                }
+                console.warn("Can not add same name data: " + name);
+                return;
+            }
+            this._dragonBonesDataMap[name] = data;
+        };
+        /**
+         * - Remove a DragonBonesData instance.
+         * @param name - The DragonBonesData instance cache name.
+         * @param disposeData - Whether to dispose data. (Default: true)
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 移除 DragonBonesData 实例。
+         * @param name - DragonBonesData 实例缓存名称。
+         * @param disposeData - 是否释放数据。 （默认: true）
+         * @see #parseDragonBonesData()
+         * @see #getDragonBonesData()
+         * @see #addDragonBonesData()
+         * @see dragonBones.DragonBonesData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        BaseFactory.prototype.removeDragonBonesData = function (name, disposeData) {
+            if (disposeData === void 0) { disposeData = true; }
+            if (name in this._dragonBonesDataMap) {
+                if (disposeData) {
+                    this._dragonBones.bufferObject(this._dragonBonesDataMap[name]);
+                }
+                delete this._dragonBonesDataMap[name];
+            }
+        };
+        /**
+         * - Get a list of specific TextureAtlasData instances.
+         * @param name - The TextureAtlasData cahce name.
+         * @see #parseTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 获取特定的 TextureAtlasData 实例列表。
+         * @param name - TextureAtlasData 实例缓存名称。
+         * @see #parseTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        BaseFactory.prototype.getTextureAtlasData = function (name) {
+            return (name in this._textureAtlasDataMap) ? this._textureAtlasDataMap[name] : null;
+        };
+        /**
+         * - Cache a TextureAtlasData instance to the factory.
+         * @param data - The TextureAtlasData instance.
+         * @param name - Specify a cache name for the instance so that the instance can be obtained through this name. (if not set, use the instance name instead)
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 将 TextureAtlasData 实例缓存到工厂中。
+         * @param data - TextureAtlasData 实例。
+         * @param name - 为该实例指定一个缓存名称，以便可以通过此名称获取该实例。 （如果未设置，则使用该实例中的名称）
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #removeTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        BaseFactory.prototype.addTextureAtlasData = function (data, name) {
+            if (name === void 0) { name = null; }
+            name = name !== null ? name : data.name;
+            var textureAtlasList = (name in this._textureAtlasDataMap) ? this._textureAtlasDataMap[name] : (this._textureAtlasDataMap[name] = []);
+            if (textureAtlasList.indexOf(data) < 0) {
+                textureAtlasList.push(data);
+            }
+        };
+        /**
+         * - Remove a TextureAtlasData instance.
+         * @param name - The TextureAtlasData instance cache name.
+         * @param disposeData - Whether to dispose data.
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 移除 TextureAtlasData 实例。
+         * @param name - TextureAtlasData 实例的缓存名称。
+         * @param disposeData - 是否释放数据。
+         * @see #parseTextureAtlasData()
+         * @see #getTextureAtlasData()
+         * @see #addTextureAtlasData()
+         * @see dragonBones.TextureAtlasData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        BaseFactory.prototype.removeTextureAtlasData = function (name, disposeData) {
+            if (disposeData === void 0) { disposeData = true; }
+            if (name in this._textureAtlasDataMap) {
+                var textureAtlasDataList = this._textureAtlasDataMap[name];
+                if (disposeData) {
+                    for (var _i = 0, textureAtlasDataList_1 = textureAtlasDataList; _i < textureAtlasDataList_1.length; _i++) {
+                        var textureAtlasData = textureAtlasDataList_1[_i];
+                        this._dragonBones.bufferObject(textureAtlasData);
+                    }
+                }
+                delete this._textureAtlasDataMap[name];
+            }
+        };
+        /**
+         * - Get a specific armature data.
+         * @param name - The armature data name.
+         * @param dragonBonesName - The cached name for DragonbonesData instance.
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 获取特定的骨架数据。
+         * @param name - 骨架数据名称。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        BaseFactory.prototype.getArmatureData = function (name, dragonBonesName) {
+            if (dragonBonesName === void 0) { dragonBonesName = ""; }
+            var dataPackage = new BuildArmaturePackage();
+            if (!this._fillBuildArmaturePackage(dataPackage, dragonBonesName, name, "", "")) {
+                return null;
+            }
+            return dataPackage.armature;
+        };
+        /**
+         * - Clear all cached DragonBonesData instances and TextureAtlasData instances.
+         * @param disposeData - Whether to dispose data.
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 清除缓存的所有 DragonBonesData 实例和 TextureAtlasData 实例。
+         * @param disposeData - 是否释放数据。
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseFactory.prototype.clear = function (disposeData) {
+            if (disposeData === void 0) { disposeData = true; }
+            for (var k in this._dragonBonesDataMap) {
+                if (disposeData) {
+                    this._dragonBones.bufferObject(this._dragonBonesDataMap[k]);
+                }
+                delete this._dragonBonesDataMap[k];
+            }
+            for (var k in this._textureAtlasDataMap) {
+                if (disposeData) {
+                    var textureAtlasDataList = this._textureAtlasDataMap[k];
+                    for (var _i = 0, textureAtlasDataList_2 = textureAtlasDataList; _i < textureAtlasDataList_2.length; _i++) {
+                        var textureAtlasData = textureAtlasDataList_2[_i];
+                        this._dragonBones.bufferObject(textureAtlasData);
+                    }
+                }
+                delete this._textureAtlasDataMap[k];
+            }
+        };
+        /**
+         * - Create a armature from cached DragonBonesData instances and TextureAtlasData instances.
+         * Note that when the created armature that is no longer in use, you need to explicitly dispose {@link #dragonBones.Armature#dispose()}.
+         * @param armatureName - The armature data name.
+         * @param dragonBonesName - The cached name of the DragonBonesData instance. (If not set, all DragonBonesData instances are retrieved, and when multiple DragonBonesData instances contain a the same name armature data, it may not be possible to accurately create a specific armature)
+         * @param skinName - The skin name, you can set a different ArmatureData name to share it's skin data. (If not set, use the default skin data)
+         * @returns The armature.
+         * @example
+         * <pre>
+         *     let armature = factory.buildArmature("armatureName", "dragonBonesName");
+         *     armature.clock = factory.clock;
+         * </pre>
+         * @see dragonBones.DragonBonesData
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 通过缓存的 DragonBonesData 实例和 TextureAtlasData 实例创建一个骨架。
+         * 注意，创建的骨架不再使用时，需要显式释放 {@link #dragonBones.Armature#dispose()}。
+         * @param armatureName - 骨架数据名称。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。 （如果未设置，将检索所有的 DragonBonesData 实例，当多个 DragonBonesData 实例中包含同名的骨架数据时，可能无法准确的创建出特定的骨架）
+         * @param skinName - 皮肤名称，可以设置一个其他骨架数据名称来共享其皮肤数据。（如果未设置，则使用默认的皮肤数据）
+         * @returns 骨架。
+         * @example
+         * <pre>
+         *     let armature = factory.buildArmature("armatureName", "dragonBonesName");
+         *     armature.clock = factory.clock;
+         * </pre>
+         * @see dragonBones.DragonBonesData
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        BaseFactory.prototype.buildArmature = function (armatureName, dragonBonesName, skinName, textureAtlasName) {
+            if (dragonBonesName === void 0) { dragonBonesName = ""; }
+            if (skinName === void 0) { skinName = ""; }
+            if (textureAtlasName === void 0) { textureAtlasName = ""; }
+            var dataPackage = new BuildArmaturePackage();
+            if (!this._fillBuildArmaturePackage(dataPackage, dragonBonesName || "", armatureName, skinName || "", textureAtlasName || "")) {
+                console.warn("No armature data: " + armatureName + ", " + (dragonBonesName !== null ? dragonBonesName : ""));
+                return null;
+            }
+            var armature = this._buildArmature(dataPackage);
+            this._buildBones(dataPackage, armature);
+            this._buildSlots(dataPackage, armature);
+            this._buildConstraints(dataPackage, armature);
+            armature.invalidUpdate(null, true);
+            armature.advanceTime(0.0); // Update armature pose.
+            return armature;
+        };
+        /**
+         * @private
+         */
+        BaseFactory.prototype.replaceDisplay = function (slot, displayData, displayIndex) {
+            if (displayIndex === void 0) { displayIndex = -1; }
+            if (displayIndex < 0) {
+                displayIndex = slot.displayIndex;
+            }
+            if (displayIndex < 0) {
+                displayIndex = 0;
+            }
+            slot.replaceDisplayData(displayData, displayIndex);
+            var displayList = slot.displayList; // Copy.
+            if (displayList.length <= displayIndex) {
+                displayList.length = displayIndex + 1;
+                for (var i = 0, l = displayList.length; i < l; ++i) {
+                    if (!displayList[i]) {
+                        displayList[i] = null;
+                    }
+                }
+            }
+            if (displayData !== null) {
+                var rawDisplayDatas = slot.rawDisplayDatas;
+                var rawDisplayData = null;
+                if (rawDisplayDatas) {
+                    if (dragonBones.DragonBones.webAssembly) {
+                        if (displayIndex < rawDisplayDatas.size()) {
+                            rawDisplayData = rawDisplayDatas.get(displayIndex);
+                        }
+                    }
+                    else {
+                        if (displayIndex < rawDisplayDatas.length) {
+                            rawDisplayData = rawDisplayDatas[displayIndex];
+                        }
+                    }
+                }
+                displayList[displayIndex] = this._getSlotDisplay(null, displayData, rawDisplayData, slot);
+            }
+            else {
+                displayList[displayIndex] = null;
+            }
+            slot.displayList = displayList;
+        };
+        /**
+         * - Replaces the current display data for a particular slot with a specific display data.
+         * Specify display data with "dragonBonesName/armatureName/slotName/displayName".
+         * @param dragonBonesName - The DragonBonesData instance cache name.
+         * @param armatureName - The armature data name.
+         * @param slotName - The slot data name.
+         * @param displayName - The display data name.
+         * @param slot - The slot.
+         * @param displayIndex - The index of the display data that is replaced. (If it is not set, replaces the current display data)
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         *     factory.replaceSlotDisplay("dragonBonesName", "armatureName", "slotName", "displayName", slot);
+         * </pre>
+         * @version DragonBones 4.5
+         * @language en_US
+         */
+        /**
+         * - 用特定的显示对象数据替换特定插槽当前的显示对象数据。
+         * 用 "dragonBonesName/armatureName/slotName/displayName" 指定显示对象数据。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。
+         * @param armatureName - 骨架数据名称。
+         * @param slotName - 插槽数据名称。
+         * @param displayName - 显示对象数据名称。
+         * @param slot - 插槽。
+         * @param displayIndex - 被替换的显示对象数据的索引。 （如果未设置，则替换当前的显示对象数据）
+         * @example
+         * <pre>
+         *     let slot = armature.getSlot("weapon");
+         *     factory.replaceSlotDisplay("dragonBonesName", "armatureName", "slotName", "displayName", slot);
+         * </pre>
+         * @version DragonBones 4.5
+         * @language zh_CN
+         */
+        BaseFactory.prototype.replaceSlotDisplay = function (dragonBonesName, armatureName, slotName, displayName, slot, displayIndex) {
+            if (displayIndex === void 0) { displayIndex = -1; }
+            var armatureData = this.getArmatureData(armatureName, dragonBonesName || "");
+            if (!armatureData || !armatureData.defaultSkin) {
+                return false;
+            }
+            var displayData = armatureData.defaultSkin.getDisplay(slotName, displayName);
+            if (!displayData) {
+                return false;
+            }
+            this.replaceDisplay(slot, displayData, displayIndex);
+            return true;
+        };
+        /**
+         * @private
+         */
+        BaseFactory.prototype.replaceSlotDisplayList = function (dragonBonesName, armatureName, slotName, slot) {
+            var armatureData = this.getArmatureData(armatureName, dragonBonesName || "");
+            if (!armatureData || !armatureData.defaultSkin) {
+                return false;
+            }
+            var displays = armatureData.defaultSkin.getDisplays(slotName);
+            if (!displays) {
+                return false;
+            }
+            var displayIndex = 0;
+            // for (const displayData of displays) 
+            for (var i = 0, l = dragonBones.DragonBones.webAssembly ? displays.size() : displays.length; i < l; ++i) {
+                var displayData = dragonBones.DragonBones.webAssembly ? displays.get(i) : displays[i];
+                this.replaceDisplay(slot, displayData, displayIndex++);
+            }
+            return true;
+        };
+        /**
+         * - Share specific skin data with specific armature.
+         * @param armature - The armature.
+         * @param skin - The skin data.
+         * @param isOverride - Whether it completely override the original skin. (Default: false)
+         * @param exclude - A list of slot names that do not need to be replace.
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB && armatureDataB.defaultSkin) {
+         *     factory.replaceSkin(armatureA, armatureDataB.defaultSkin, false, ["arm_l", "weapon_l"]);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.SkinData
+         * @version DragonBones 5.6
+         * @language en_US
+         */
+        /**
+         * - 将特定的皮肤数据共享给特定的骨架使用。
+         * @param armature - 骨架。
+         * @param skin - 皮肤数据。
+         * @param isOverride - 是否完全覆盖原来的皮肤。 （默认: false）
+         * @param exclude - 不需要被替换的插槽名称列表。
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB && armatureDataB.defaultSkin) {
+         *     factory.replaceSkin(armatureA, armatureDataB.defaultSkin, false, ["arm_l", "weapon_l"]);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.SkinData
+         * @version DragonBones 5.6
+         * @language zh_CN
+         */
+        BaseFactory.prototype.replaceSkin = function (armature, skin, isOverride, exclude) {
+            if (isOverride === void 0) { isOverride = false; }
+            if (exclude === void 0) { exclude = null; }
+            var success = false;
+            var defaultSkin = skin.parent.defaultSkin;
+            for (var _i = 0, _a = armature.getSlots(); _i < _a.length; _i++) {
+                var slot = _a[_i];
+                if (exclude !== null && exclude.indexOf(slot.name) >= 0) {
+                    continue;
+                }
+                var displays = skin.getDisplays(slot.name);
+                if (!displays) {
+                    if (defaultSkin !== null && skin !== defaultSkin) {
+                        displays = defaultSkin.getDisplays(slot.name);
+                    }
+                    if (!displays) {
+                        if (isOverride) {
+                            slot.rawDisplayDatas = null;
+                            slot.displayList = []; //
+                        }
+                        continue;
+                    }
+                }
+                var displayCount = dragonBones.DragonBones.webAssembly ? displays.size() : displays.length;
+                var displayList = slot.displayList; // Copy.
+                displayList.length = displayCount; // Modify displayList length.
+                for (var i = 0, l = displayCount; i < l; ++i) {
+                    var displayData = dragonBones.DragonBones.webAssembly ? displays.get(i) : displays[i];
+                    if (displayData !== null) {
+                        displayList[i] = this._getSlotDisplay(null, displayData, null, slot);
+                    }
+                    else {
+                        displayList[i] = null;
+                    }
+                }
+                success = true;
+                slot.rawDisplayDatas = displays;
+                slot.displayList = displayList;
+            }
+            return success;
+        };
+        /**
+         * - Replaces the existing animation data for a specific armature with the animation data for the specific armature data.
+         * This enables you to make a armature template so that other armature without animations can share it's animations.
+         * @param armature - The armtaure.
+         * @param armatureData - The armature data.
+         * @param isOverride - Whether to completely overwrite the original animation. (Default: false)
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB) {
+         *     factory.replaceAnimation(armatureA, armatureDataB);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.6
+         * @language en_US
+         */
+        /**
+         * - 用特定骨架数据的动画数据替换特定骨架现有的动画数据。
+         * 这样就能实现制作一个骨架动画模板，让其他没有制作动画的骨架共享该动画。
+         * @param armature - 骨架。
+         * @param armatureData - 骨架数据。
+         * @param isOverride - 是否完全覆盖原来的动画。（默认: false）
+         * @example
+         * <pre>
+         *     let armatureA = factory.buildArmature("armatureA", "dragonBonesA");
+         *     let armatureDataB = factory.getArmatureData("armatureB", "dragonBonesB");
+         *     if (armatureDataB) {
+         *     factory.replaceAnimation(armatureA, armatureDataB);
+         *     }
+         * </pre>
+         * @see dragonBones.Armature
+         * @see dragonBones.ArmatureData
+         * @version DragonBones 5.6
+         * @language zh_CN
+         */
+        BaseFactory.prototype.replaceAnimation = function (armature, armatureData, isOverride) {
+            if (isOverride === void 0) { isOverride = true; }
+            var skinData = armatureData.defaultSkin;
+            if (skinData === null) {
+                return false;
+            }
+            if (isOverride) {
+                armature.animation.animations = armatureData.animations;
+            }
+            else {
+                var rawAnimations = armature.animation.animations;
+                var animations = {};
+                for (var k in rawAnimations) {
+                    animations[k] = rawAnimations[k];
+                }
+                for (var k in armatureData.animations) {
+                    animations[k] = armatureData.animations[k];
+                }
+                armature.animation.animations = animations;
+            }
+            for (var _i = 0, _a = armature.getSlots(); _i < _a.length; _i++) {
+                var slot = _a[_i];
+                var index = 0;
+                for (var _b = 0, _c = slot.displayList; _b < _c.length; _b++) {
+                    var display = _c[_b];
+                    if (display instanceof dragonBones.Armature) {
+                        var displayDatas = skinData.getDisplays(slot.name);
+                        if (displayDatas !== null && index < (dragonBones.DragonBones.webAssembly ? displayDatas.size() : displayDatas.length)) {
+                            var displayData = dragonBones.DragonBones.webAssembly ? displayDatas.get(index) : displayDatas[index];
+                            if (displayData !== null && displayData.type === 1 /* Armature */) {
+                                var childArmatureData = this.getArmatureData(displayData.path, displayData.parent.parent.parent.name);
+                                if (childArmatureData) {
+                                    this.replaceAnimation(display, childArmatureData, isOverride);
+                                }
+                            }
+                        }
+                    }
+                    index++;
+                }
+            }
+            return true;
+        };
+        /**
+         * @private
+         */
+        BaseFactory.prototype.getAllDragonBonesData = function () {
+            return this._dragonBonesDataMap;
+        };
+        /**
+         * @private
+         */
+        BaseFactory.prototype.getAllTextureAtlasData = function () {
+            return this._textureAtlasDataMap;
+        };
+        Object.defineProperty(BaseFactory.prototype, "clock", {
+            /**
+             * - An Worldclock instance updated by engine.
+             * @version DragonBones 5.7
+             * @language en_US
+             */
+            /**
+             * - 由引擎驱动的 WorldClock 实例。
+             * @version DragonBones 5.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._dragonBones.clock;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(BaseFactory.prototype, "dragonBones", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this._dragonBones;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link #replaceSkin}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #replaceSkin}。
+         * @deprecated
+         * @language zh_CN
+         */
+        BaseFactory.prototype.changeSkin = function (armature, skin, exclude) {
+            if (exclude === void 0) { exclude = null; }
+            return this.replaceSkin(armature, skin, false, exclude);
+        };
+        /**
+         * - Deprecated, please refer to {@link #replaceAnimation}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #replaceAnimation}。
+         * @deprecated
+         * @language zh_CN
+         */
+        BaseFactory.prototype.copyAnimationsToArmature = function (toArmature, fromArmatreName, fromSkinName, fromDragonBonesDataName, replaceOriginalAnimation) {
+            if (fromSkinName === void 0) { fromSkinName = ""; }
+            if (fromDragonBonesDataName === void 0) { fromDragonBonesDataName = ""; }
+            if (replaceOriginalAnimation === void 0) { replaceOriginalAnimation = true; }
+            // tslint:disable-next-line:no-unused-expression
+            fromSkinName;
+            var armatureData = this.getArmatureData(fromArmatreName, fromDragonBonesDataName);
+            if (!armatureData) {
+                return false;
+            }
+            return this.replaceAnimation(toArmature, armatureData, replaceOriginalAnimation);
+        };
+        BaseFactory._objectParser = null;
+        BaseFactory._binaryParser = null;
+        return BaseFactory;
+    }());
+    dragonBones.BaseFactory = BaseFactory;
+    /**
+     * @internal
+     */
+    var BuildArmaturePackage = /** @class */ (function () {
+        function BuildArmaturePackage() {
+            this.dataName = "";
+            this.textureAtlasName = "";
+            this.skin = null;
+        }
+        return BuildArmaturePackage;
+    }());
+    dragonBones.BuildArmaturePackage = BuildArmaturePackage;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The egret texture atlas data.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Egret 贴图集数据。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var EgretTextureAtlasData = /** @class */ (function (_super) {
+        __extends(EgretTextureAtlasData, _super);
+        function EgretTextureAtlasData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._renderTexture = null; // Initial value.
+            return _this;
+        }
+        EgretTextureAtlasData.toString = function () {
+            return "[class dragonBones.EgretTextureAtlasData]";
+        };
+        EgretTextureAtlasData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            if (this.disposeEnabled && this._renderTexture !== null) {
+                this._renderTexture.dispose();
+            }
+            this.disposeEnabled = false;
+            this._renderTexture = null;
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretTextureAtlasData.prototype.createTexture = function () {
+            return dragonBones.BaseObject.borrowObject(EgretTextureData);
+        };
+        Object.defineProperty(EgretTextureAtlasData.prototype, "renderTexture", {
+            /**
+             * - The Egret texture.
+             * @version DragonBones 3.0
+             * @language en_US
+             */
+            /**
+             * - Egret 贴图。
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            get: function () {
+                return this._renderTexture;
+            },
+            set: function (value) {
+                if (this._renderTexture === value) {
+                    return;
+                }
+                this._renderTexture = value;
+                if (this._renderTexture !== null) {
+                    var bitmapData = this._renderTexture.bitmapData;
+                    var textureAtlasWidth = this.width > 0.0 ? this.width : bitmapData.width;
+                    var textureAtlasHeight = this.height > 0.0 ? this.height : bitmapData.height;
+                    for (var k in this.textures) {
+                        var scale = egret.$TextureScaleFactor;
+                        var textureData = this.textures[k];
+                        var subTextureWidth = textureData.region.width;
+                        var subTextureHeight = textureData.region.height;
+                        if (textureData.renderTexture === null) {
+                            textureData.renderTexture = new egret.Texture();
+                        }
+                        textureData.renderTexture.bitmapData = bitmapData;
+                        if (textureData.rotated) {
+                            textureData.renderTexture.$initData(textureData.region.x * scale, textureData.region.y * scale, subTextureHeight * scale, subTextureWidth * scale, 0, 0, subTextureHeight * scale, subTextureWidth * scale, textureAtlasWidth, textureAtlasHeight, textureData.rotated);
+                        }
+                        else {
+                            textureData.renderTexture.$initData(textureData.region.x * scale, textureData.region.y * scale, subTextureWidth * scale, subTextureHeight * scale, 0, 0, subTextureWidth * scale, subTextureHeight * scale, textureAtlasWidth, textureAtlasHeight);
+                        }
+                    }
+                }
+                else {
+                    for (var k in this.textures) {
+                        var textureData = this.textures[k];
+                        textureData.renderTexture = null;
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link dragonBones.BaseFactory#removeTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.BaseFactory#removeTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretTextureAtlasData.prototype.dispose = function () {
+            console.warn("已废弃。");
+            this.returnToPool();
+        };
+        Object.defineProperty(EgretTextureAtlasData.prototype, "texture", {
+            /**
+             * - Deprecated, please refer to {@link #renderTexture}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #renderTexture}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                console.warn("已废弃。");
+                return this.renderTexture;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return EgretTextureAtlasData;
+    }(dragonBones.TextureAtlasData));
+    dragonBones.EgretTextureAtlasData = EgretTextureAtlasData;
+    /**
+     * @internal
+     */
+    var EgretTextureData = /** @class */ (function (_super) {
+        __extends(EgretTextureData, _super);
+        function EgretTextureData() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.renderTexture = null; // Initial value.
+            return _this;
+        }
+        EgretTextureData.toString = function () {
+            return "[class dragonBones.EgretTextureData]";
+        };
+        EgretTextureData.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            if (this.renderTexture !== null) {
+                //this.renderTexture.dispose(false);
+                //this.renderTexture.dispose();
+            }
+            this.renderTexture = null;
+        };
+        return EgretTextureData;
+    }(dragonBones.TextureData));
+    dragonBones.EgretTextureData = EgretTextureData;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The egret event.
+     * @version DragonBones 4.5
+     * @language en_US
+     */
+    /**
+     * - Egret 事件。
+     * @version DragonBones 4.5
+     * @language zh_CN
+     */
+    var EgretEvent = /** @class */ (function (_super) {
+        __extends(EgretEvent, _super);
+        function EgretEvent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(EgretEvent.prototype, "eventObject", {
+            /**
+             * - The event object.
+             * @see dragonBones.EventObject
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 事件对象。
+             * @see dragonBones.EventObject
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this.data;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "animationName", {
+            /**
+             * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#animationState}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#animationState}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                var animationState = this.eventObject.animationState;
+                return animationState !== null ? animationState.name : "";
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "armature", {
+            /**
+             * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#armature}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#armature}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return this.eventObject.armature;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "bone", {
+            /**
+             * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#bone}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#bone}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return this.eventObject.bone;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "slot", {
+            /**
+             * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#slot}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#slot}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return this.eventObject.slot;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "animationState", {
+            /**
+             * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#animationState}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#animationState}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return this.eventObject.animationState;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "frameLabel", {
+            /**
+             * Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#name}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#name}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return this.eventObject.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "sound", {
+            /**
+             * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#name}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#name}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return this.eventObject.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretEvent.prototype, "movementID", {
+            /**
+             * - Deprecated, please refer to {@link #eventObject} {@link #dragonBones.EventObject#animationState}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #eventObject} {@link #dragonBones.EventObject#animationState}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return this.animationName;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.START}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.START}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.START = dragonBones.EventObject.START;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.LOOP_COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.LOOP_COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.LOOP_COMPLETE = dragonBones.EventObject.LOOP_COMPLETE;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.COMPLETE = dragonBones.EventObject.COMPLETE;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_IN}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_IN}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.FADE_IN = dragonBones.EventObject.FADE_IN;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_IN_COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_IN_COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.FADE_IN_COMPLETE = dragonBones.EventObject.FADE_IN_COMPLETE;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_OUT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_OUT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.FADE_OUT = dragonBones.EventObject.FADE_OUT;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FADE_OUT_COMPLETE}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FADE_OUT_COMPLETE}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.FADE_OUT_COMPLETE = dragonBones.EventObject.FADE_OUT_COMPLETE;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.FRAME_EVENT = dragonBones.EventObject.FRAME_EVENT;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.SOUND_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.SOUND_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.SOUND_EVENT = dragonBones.EventObject.SOUND_EVENT;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.ANIMATION_FRAME_EVENT = dragonBones.EventObject.FRAME_EVENT;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.BONE_FRAME_EVENT = dragonBones.EventObject.FRAME_EVENT;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.FRAME_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.FRAME_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.MOVEMENT_FRAME_EVENT = dragonBones.EventObject.FRAME_EVENT;
+        /**
+         * - Deprecated, please refer to {@link #dragonBones.EventObject.SOUND_EVENT}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #dragonBones.EventObject.SOUND_EVENT}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretEvent.SOUND = dragonBones.EventObject.SOUND_EVENT;
+        return EgretEvent;
+    }(egret.Event));
+    dragonBones.EgretEvent = EgretEvent;
+    /**
+     * @inheritDoc
+     */
+    var EgretArmatureDisplay = /** @class */ (function (_super) {
+        __extends(EgretArmatureDisplay, _super);
+        function EgretArmatureDisplay() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * @private
+             */
+            _this.debugDraw = false;
+            /**
+             * @internal
+             */
+            _this._batchEnabled = !(global["nativeRender"] || global["bricks"]); //
+            /**
+             * @internal
+             */
+            _this._childDirty = true;
+            _this._debugDraw = false;
+            _this._armature = null; //
+            _this._bounds = null;
+            _this._debugDrawer = null;
+            return _this;
+        }
+        EgretArmatureDisplay._cleanBeforeRender = function () { };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.dbInit = function (armature) {
+            this._armature = armature;
+            if (this._batchEnabled) {
+                this.$renderNode = new egret.sys.GroupNode();
+                this.$renderNode.cleanBeforeRender = EgretArmatureDisplay._cleanBeforeRender;
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.dbClear = function () {
+            this._armature = null;
+            this._bounds = null;
+            this._debugDrawer = null;
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.dbUpdate = function () {
+            var drawed = dragonBones.DragonBones.debugDraw || this.debugDraw;
+            if (drawed || this._debugDraw) {
+                this._debugDraw = drawed;
+                if (this._debugDraw) {
+                    if (this._debugDrawer === null) {
+                        this._debugDrawer = new egret.Sprite();
+                    }
+                    if (this._debugDrawer.parent !== this) {
+                        this.addChild(this._debugDrawer);
+                    }
+                    var boneStep = 2.0;
+                    var graphics = this._debugDrawer.graphics;
+                    graphics.clear();
+                    for (var _i = 0, _a = this._armature.getBones(); _i < _a.length; _i++) {
+                        var bone = _a[_i];
+                        if (bone.boneData.type === 0 /* Bone */) {
+                            var boneLength = Math.max(bone.boneData.length, boneStep);
+                            var startX = bone.globalTransformMatrix.tx;
+                            var startY = bone.globalTransformMatrix.ty;
+                            var aX = startX - bone.globalTransformMatrix.a * boneStep;
+                            var aY = startY - bone.globalTransformMatrix.b * boneStep;
+                            var bX = startX + bone.globalTransformMatrix.a * boneLength;
+                            var bY = startY + bone.globalTransformMatrix.b * boneLength;
+                            var cX = startX + aY - startY;
+                            var cY = startY + aX - startX;
+                            var dX = startX - aY + startY;
+                            var dY = startY - aX + startX;
+                            //
+                            graphics.lineStyle(2.0, 0x00FFFF, 0.7);
+                            graphics.moveTo(aX, aY);
+                            graphics.lineTo(bX, bY);
+                            graphics.moveTo(cX, cY);
+                            graphics.lineTo(dX, dY);
+                        }
+                        else {
+                            var surface = bone;
+                            var surfaceData = surface._boneData;
+                            var segmentX = surfaceData.segmentX;
+                            var segmentY = surfaceData.segmentY;
+                            var vertices = surface._vertices;
+                            graphics.lineStyle(2.0, 0xFFFF00, 0.7);
+                            for (var iY = 0; iY < segmentY; ++iY) {
+                                for (var iX = 0; iX < segmentX; ++iX) {
+                                    var vertexIndex = (iX + iY * (segmentX + 1)) * 2;
+                                    var x = vertices[vertexIndex];
+                                    var y = vertices[vertexIndex + 1];
+                                    graphics.moveTo(x, y);
+                                    graphics.lineTo(vertices[vertexIndex + 2], vertices[vertexIndex + 3]);
+                                    graphics.moveTo(x, y);
+                                    graphics.lineTo(vertices[vertexIndex + (segmentX + 1) * 2], vertices[vertexIndex + (segmentX + 1) * 2 + 1]);
+                                    if (iX === segmentX - 1) {
+                                        graphics.moveTo(vertices[vertexIndex + 2], vertices[vertexIndex + 3]);
+                                        graphics.lineTo(vertices[vertexIndex + (segmentX + 2) * 2], vertices[vertexIndex + (segmentX + 2) * 2 + 1]);
+                                    }
+                                    if (iY === segmentY - 1) {
+                                        graphics.moveTo(vertices[vertexIndex + (segmentX + 1) * 2], vertices[vertexIndex + (segmentX + 1) * 2 + 1]);
+                                        graphics.lineTo(vertices[vertexIndex + (segmentX + 2) * 2], vertices[vertexIndex + (segmentX + 2) * 2 + 1]);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    for (var _b = 0, _c = this._armature.getSlots(); _b < _c.length; _b++) {
+                        var slot = _c[_b];
+                        var boundingBoxData = slot.boundingBoxData;
+                        if (boundingBoxData !== null) {
+                            var child = this._debugDrawer.getChildByName(slot.name);
+                            if (child === null) {
+                                child = new egret.Shape();
+                                child.name = slot.name;
+                                this._debugDrawer.addChild(child);
+                            }
+                            child.graphics.clear();
+                            child.graphics.lineStyle(2.0, 0xFF00FF, 0.7);
+                            switch (boundingBoxData.type) {
+                                case 0 /* Rectangle */:
+                                    child.graphics.drawRect(-boundingBoxData.width * 0.5, -boundingBoxData.height * 0.5, boundingBoxData.width, boundingBoxData.height);
+                                    break;
+                                case 1 /* Ellipse */:
+                                    child.graphics.drawEllipse(-boundingBoxData.width * 0.5, -boundingBoxData.height * 0.5, boundingBoxData.width, boundingBoxData.height);
+                                    break;
+                                case 2 /* Polygon */:
+                                    var vertices = boundingBoxData.vertices;
+                                    for (var i = 0; i < vertices.length; i += 2) {
+                                        var x = vertices[i];
+                                        var y = vertices[i + 1];
+                                        if (i === 0) {
+                                            child.graphics.moveTo(x, y);
+                                        }
+                                        else {
+                                            child.graphics.lineTo(x, y);
+                                        }
+                                    }
+                                    child.graphics.lineTo(vertices[0], vertices[1]);
+                                    break;
+                                default:
+                                    break;
+                            }
+                            slot.updateTransformAndMatrix();
+                            slot.updateGlobalTransform();
+                            child.$setMatrix(slot.globalTransformMatrix, false);
+                        }
+                        else {
+                            var child = this._debugDrawer.getChildByName(slot.name);
+                            if (child !== null) {
+                                this._debugDrawer.removeChild(child);
+                            }
+                        }
+                    }
+                }
+                else if (this._debugDrawer !== null && this._debugDrawer.parent === this) {
+                    this.removeChild(this._debugDrawer);
+                }
+            }
+            if (!dragonBones.isV5 && this._batchEnabled && this._childDirty) {
+                this.$invalidateContentBounds();
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.dispose = function (disposeProxy) {
+            if (disposeProxy === void 0) { disposeProxy = true; }
+            // tslint:disable-next-line:no-unused-expression
+            disposeProxy;
+            if (this._armature !== null) {
+                this._armature.dispose();
+                this._armature = null;
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.dispatchDBEvent = function (type, eventObject) {
+            var event = egret.Event.create(EgretEvent, type);
+            event.data = eventObject;
+            _super.prototype.dispatchEvent.call(this, event);
+            egret.Event.release(event);
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.hasDBEventListener = function (type) {
+            return this.hasEventListener(type);
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.addDBEventListener = function (type, listener, target) {
+            this.addEventListener(type, listener, target);
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.removeDBEventListener = function (type, listener, target) {
+            this.removeEventListener(type, listener, target);
+        };
+        /**
+         * - Disable the batch.
+         * Batch rendering for performance reasons, the boundary properties of the render object are not updated.
+         * This will not correctly obtain the wide-height properties of the rendered object and the transformation properties of its internal display objects,
+         * which can turn off batch rendering if you need to use these properties.
+         * @version DragonBones 5.1
+         * @language en_US
+         */
+        /**
+         * - 关闭批次渲染。
+         * 批次渲染出于性能考虑，不会更新渲染对象的边界属性。
+         * 这样将无法正确获得渲染对象的宽高属性以及其内部显示对象的变换属性，如果需要使用这些属性，可以关闭批次渲染。
+         * @version DragonBones 5.1
+         * @language zh_CN
+         */
+        EgretArmatureDisplay.prototype.disableBatch = function () {
+            if (!this._batchEnabled || !this._armature) {
+                return;
+            }
+            for (var _i = 0, _a = this._armature.getSlots(); _i < _a.length; _i++) {
+                var slot = _a[_i];
+                // (slot as EgretSlot).transformUpdateEnabled = true;
+                var display = ((slot._deformVertices && slot._deformVertices.verticesData) ? slot.meshDisplay : slot.rawDisplay);
+                if (!slot.display && display === slot.meshDisplay) {
+                    display = slot.rawDisplay;
+                }
+                var node = display.$renderNode;
+                // Transform.
+                if (node.matrix) {
+                    display.$setMatrix(slot.globalTransformMatrix, false);
+                }
+                // ZOrder.
+                this.addChild(display);
+            }
+            this._batchEnabled = false;
+            this.$renderNode.cleanBeforeRender = null;
+            this.$renderNode = null;
+            this.armature.invalidUpdate(null, true);
+        };
+        Object.defineProperty(EgretArmatureDisplay.prototype, "armature", {
+            /**
+             * @inheritDoc
+             */
+            get: function () {
+                return this._armature;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretArmatureDisplay.prototype, "animation", {
+            /**
+             * @inheritDoc
+             */
+            get: function () {
+                return this._armature.animation;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.$measureContentBounds = function (bounds) {
+            if (this._batchEnabled && this._armature) {
+                if (this._childDirty) {
+                    this._childDirty = false;
+                    var isFirst = true;
+                    var helpRectangle = new egret.Rectangle();
+                    for (var _i = 0, _a = this._armature.getSlots(); _i < _a.length; _i++) {
+                        var slot = _a[_i];
+                        var display = slot.display;
+                        if (!display || !display.$renderNode || !display.$renderNode.image) {
+                            continue;
+                        }
+                        var matrix = display.$renderNode.matrix;
+                        if (display === slot.meshDisplay) {
+                            var vertices = display.$renderNode.vertices;
+                            if (vertices && vertices.length > 0) {
+                                helpRectangle.setTo(999999.0, 999999.0, -999999.0, -999999.0);
+                                for (var i = 0, l = vertices.length; i < l; i += 2) {
+                                    var x = vertices[i];
+                                    var y = vertices[i + 1];
+                                    if (helpRectangle.x > x)
+                                        helpRectangle.x = x;
+                                    if (helpRectangle.width < x)
+                                        helpRectangle.width = x;
+                                    if (helpRectangle.y > y)
+                                        helpRectangle.y = y;
+                                    if (helpRectangle.height < y)
+                                        helpRectangle.height = y;
+                                }
+                                helpRectangle.width -= helpRectangle.x;
+                                helpRectangle.height -= helpRectangle.y;
+                            }
+                            else {
+                                continue;
+                            }
+                        }
+                        else {
+                            var displayData = slot.displayData;
+                            if (displayData && displayData instanceof dragonBones.ImageDisplayData && displayData.texture) {
+                                var scale = displayData.texture.parent.scale;
+                                helpRectangle.x = 0;
+                                helpRectangle.y = 0;
+                                helpRectangle.width = displayData.texture.region.width * scale;
+                                helpRectangle.height = displayData.texture.region.height * scale;
+                            }
+                            else {
+                                continue;
+                            }
+                        }
+                        matrix.$transformBounds(helpRectangle);
+                        var left = helpRectangle.x;
+                        var top_1 = helpRectangle.y;
+                        var right = helpRectangle.x + helpRectangle.width;
+                        var bottom = helpRectangle.y + helpRectangle.height;
+                        if (isFirst) {
+                            isFirst = false;
+                            bounds.x = left;
+                            bounds.y = top_1;
+                            bounds.width = right;
+                            bounds.height = bottom;
+                        }
+                        else {
+                            if (left < bounds.x) {
+                                bounds.x = left;
+                            }
+                            if (top_1 < bounds.y) {
+                                bounds.y = top_1;
+                            }
+                            if (right > bounds.width) {
+                                bounds.width = right;
+                            }
+                            if (bottom > bounds.height) {
+                                bounds.height = bottom;
+                            }
+                        }
+                    }
+                    bounds.width -= bounds.x;
+                    bounds.height -= bounds.y;
+                    if (dragonBones.isV5) {
+                        if (this._bounds === null) {
+                            this._bounds = new egret.Rectangle();
+                        }
+                        this._bounds.copyFrom(bounds);
+                    }
+                }
+                else if (dragonBones.isV5) {
+                    if (this._bounds === null) {
+                        this._bounds = new egret.Rectangle();
+                    }
+                    bounds.copyFrom(this._bounds);
+                }
+                return bounds; // V5
+            }
+            return _super.prototype.$measureContentBounds.call(this, bounds); // V5
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.hasEvent = function (type) {
+            return this.hasDBEventListener(type);
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.addEvent = function (type, listener, target) {
+            this.addDBEventListener(type, listener, target);
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretArmatureDisplay.prototype.removeEvent = function (type, listener, target) {
+            this.removeDBEventListener(type, listener, target);
+        };
+        /**
+         * - Deprecated, please refer to {@link dragonBones.Armature#clock} {@link dragonBones.BaseFactory#clock}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link dragonBones.Armature#clock} {@link dragonBones.BaseFactory#clock}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretArmatureDisplay.prototype.advanceTimeBySelf = function (on) {
+            if (on) {
+                this._armature.clock = dragonBones.EgretFactory.factory.clock;
+            }
+            else {
+                this._armature.clock = null;
+            }
+        };
+        return EgretArmatureDisplay;
+    }(egret.DisplayObjectContainer));
+    dragonBones.EgretArmatureDisplay = EgretArmatureDisplay;
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var Event = /** @class */ (function (_super) {
+        __extends(Event, _super);
+        function Event() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return Event;
+    }(EgretEvent));
+    dragonBones.Event = Event;
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var ArmatureEvent = /** @class */ (function (_super) {
+        __extends(ArmatureEvent, _super);
+        function ArmatureEvent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return ArmatureEvent;
+    }(EgretEvent));
+    dragonBones.ArmatureEvent = ArmatureEvent;
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var AnimationEvent = /** @class */ (function (_super) {
+        __extends(AnimationEvent, _super);
+        function AnimationEvent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return AnimationEvent;
+    }(EgretEvent));
+    dragonBones.AnimationEvent = AnimationEvent;
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var FrameEvent = /** @class */ (function (_super) {
+        __extends(FrameEvent, _super);
+        function FrameEvent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return FrameEvent;
+    }(EgretEvent));
+    dragonBones.FrameEvent = FrameEvent;
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretEvent}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var SoundEvent = /** @class */ (function (_super) {
+        __extends(SoundEvent, _super);
+        function SoundEvent() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return SoundEvent;
+    }(EgretEvent));
+    dragonBones.SoundEvent = SoundEvent;
+    /**
+     * 已废弃，请参考 {@link dragonBones.BaseFacory#parseTextureAtlasData()}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var EgretTextureAtlas = /** @class */ (function (_super) {
+        __extends(EgretTextureAtlas, _super);
+        /**
+         * 已废弃，请参考 {@link dragonBones.BaseFacory#parseTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        function EgretTextureAtlas(texture, rawData, scale) {
+            if (scale === void 0) { scale = 1; }
+            var _this = _super.call(this) || this;
+            console.warn("已废弃");
+            _this._onClear();
+            dragonBones.ObjectDataParser.getInstance().parseTextureAtlasData(rawData, _this, scale);
+            _this.renderTexture = texture;
+            return _this;
+        }
+        EgretTextureAtlas.toString = function () {
+            return "[class dragonBones.EgretTextureAtlas]";
+        };
+        return EgretTextureAtlas;
+    }(dragonBones.EgretTextureAtlasData));
+    dragonBones.EgretTextureAtlas = EgretTextureAtlas;
+    /**
+     * 已废弃，请参考 {@link dragonBones.BaseFacory#parseTextureAtlasData()}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var EgretSheetAtlas = /** @class */ (function (_super) {
+        __extends(EgretSheetAtlas, _super);
+        function EgretSheetAtlas() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return EgretSheetAtlas;
+    }(EgretTextureAtlas));
+    dragonBones.EgretSheetAtlas = EgretSheetAtlas;
+    /**
+     * 已废弃，请参考 {@link dragonBones.EgretFactory#soundEventManager}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var SoundEventManager = /** @class */ (function () {
+        function SoundEventManager() {
+        }
+        /**
+         * 已废弃，请参考 {@link dragonBones.EgretFactory#soundEventManager}。
+         * @deprecated
+         * @language zh_CN
+         */
+        SoundEventManager.getInstance = function () {
+            console.warn("已废弃");
+            return dragonBones.EgretFactory.factory.soundEventManager;
+        };
+        return SoundEventManager;
+    }());
+    dragonBones.SoundEventManager = SoundEventManager;
+    /**
+     * 已废弃，请参考 {@link dragonBones.Armature#cacheFrameRate}。
+     * @deprecated
+     * @language zh_CN
+     */
+    var AnimationCacheManager = /** @class */ (function () {
+        /**
+         * 已废弃，请参考 {@link dragonBones.Armature#cacheFrameRate}。
+         * @deprecated
+         * @language zh_CN
+         */
+        function AnimationCacheManager() {
+            console.warn("已废弃");
+        }
+        return AnimationCacheManager;
+    }());
+    dragonBones.AnimationCacheManager = AnimationCacheManager;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * - The egret slot.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Egret 插槽。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var EgretSlot = /** @class */ (function (_super) {
+        __extends(EgretSlot, _super);
+        function EgretSlot() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            /**
+             * - Whether to update the transform properties of the display object.
+             * For better performance, the transform properties of display object (x, y, rotation, ScaleX, ScaleX) are not updated and need to be set to true if these properties need to be accessed correctly.
+             * @default false
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            /**
+             * - 是否更新显示对象的变换属性。
+             * 为了更好的性能, 默认并不会更新显示对象的变换属性 (x, y, rotation, scaleX, scaleX), 如果需要正确访问这些属性, 则需要设置为 true 。
+             * @default false
+             * @version DragonBones 3.0
+             * @language zh_CN
+             */
+            _this.transformUpdateEnabled = false;
+            _this._armatureDisplay = null;
+            _this._renderDisplay = null;
+            _this._colorFilter = null;
+            return _this;
+        }
+        EgretSlot.toString = function () {
+            return "[class dragonBones.EgretSlot]";
+        };
+        /**
+         * @inheritDoc
+         */
+        EgretSlot.prototype.init = function (slotData, armatureValue, rawDisplay, meshDisplay) {
+            _super.prototype.init.call(this, slotData, armatureValue, rawDisplay, meshDisplay);
+            if (dragonBones.isV5) {
+                this._updateTransform = this._updateTransformV5;
+            }
+            else {
+                this._updateTransform = this._updateTransformV4;
+            }
+        };
+        EgretSlot.prototype._onClear = function () {
+            _super.prototype._onClear.call(this);
+            this._armatureDisplay = null; //
+            this._renderDisplay = null; //
+            this._colorFilter = null;
+        };
+        EgretSlot.prototype._initDisplay = function (value, isRetain) {
+            // tslint:disable-next-line:no-unused-expression
+            value;
+            // tslint:disable-next-line:no-unused-expression
+            isRetain;
+        };
+        EgretSlot.prototype._disposeDisplay = function (value, isRelease) {
+            // tslint:disable-next-line:no-unused-expression
+            value;
+            // tslint:disable-next-line:no-unused-expression
+            isRelease;
+        };
+        EgretSlot.prototype._onUpdateDisplay = function () {
+            this._armatureDisplay = this._armature.display;
+            this._renderDisplay = (this._display !== null ? this._display : this._rawDisplay);
+            if (dragonBones.isV5 && this._armatureDisplay._batchEnabled) {
+                if (this._renderDisplay === this._rawDisplay && !(this._renderDisplay.$renderNode instanceof egret.sys.BitmapNode)) {
+                    this._renderDisplay.$renderNode = new egret.sys.BitmapNode(); // 默认是 sys.NormalBitmapNode 没有矩阵，需要替换成 egret.sys.BitmapNode。
+                }
+            }
+            if (this._armatureDisplay._batchEnabled) {
+                if (this._renderDisplay !== this._rawDisplay && this._renderDisplay !== this._meshDisplay) {
+                    this._armatureDisplay.disableBatch();
+                }
+                else {
+                    var node = this._renderDisplay.$renderNode;
+                    if (!node.matrix) {
+                        node.matrix = new egret.Matrix();
+                    }
+                }
+            }
+        };
+        EgretSlot.prototype._addDisplay = function () {
+            if (this._armatureDisplay._batchEnabled) {
+                this._armatureDisplay.$renderNode.addNode(this._renderDisplay.$renderNode);
+            }
+            else {
+                this._armatureDisplay.addChild(this._renderDisplay);
+            }
+        };
+        EgretSlot.prototype._replaceDisplay = function (value) {
+            var prevDisplay = value;
+            if (this._armatureDisplay._batchEnabled) {
+                var nodes = this._armatureDisplay.$renderNode.drawData;
+                nodes[nodes.indexOf(prevDisplay.$renderNode)] = this._renderDisplay.$renderNode;
+            }
+            else {
+                this._armatureDisplay.addChild(this._renderDisplay);
+                this._armatureDisplay.swapChildren(this._renderDisplay, prevDisplay);
+                this._armatureDisplay.removeChild(prevDisplay);
+            }
+        };
+        EgretSlot.prototype._removeDisplay = function () {
+            if (this._armatureDisplay._batchEnabled) {
+                var nodes = this._armatureDisplay.$renderNode.drawData;
+                nodes.splice(nodes.indexOf(this._renderDisplay.$renderNode), 1);
+            }
+            else {
+                this._renderDisplay.parent.removeChild(this._renderDisplay);
+            }
+        };
+        EgretSlot.prototype._updateZOrder = function () {
+            if (this._armatureDisplay._batchEnabled) {
+                var nodes = this._armatureDisplay.$renderNode.drawData;
+                nodes[this._zOrder] = this._renderDisplay.$renderNode;
+            }
+            else {
+                var index = this._armatureDisplay.getChildIndex(this._renderDisplay);
+                if (index === this._zOrder) {
+                    return;
+                }
+                this._armatureDisplay.addChildAt(this._renderDisplay, this._zOrder);
+            }
+        };
+        /**
+         * @internal
+         */
+        EgretSlot.prototype._updateVisible = function () {
+            var visible = this._parent.visible && this._visible;
+            if (this._armatureDisplay._batchEnabled) {
+                var node = this._renderDisplay.$renderNode;
+                node.alpha = visible ? 1.0 : 0.0;
+            }
+            else {
+                this._renderDisplay.visible = visible;
+            }
+        };
+        EgretSlot.prototype._updateBlendMode = function () {
+            switch (this._blendMode) {
+                case 0 /* Normal */:
+                    this._renderDisplay.blendMode = egret.BlendMode.NORMAL;
+                    break;
+                case 1 /* Add */:
+                    this._renderDisplay.blendMode = egret.BlendMode.ADD;
+                    break;
+                case 5 /* Erase */:
+                    this._renderDisplay.blendMode = egret.BlendMode.ERASE;
+                    break;
+                default:
+                    break;
+            }
+            if (this._armatureDisplay._batchEnabled) {
+                var node = this._renderDisplay.$renderNode;
+                node.blendMode = egret.sys.blendModeToNumber(this._renderDisplay.blendMode);
+            }
+        };
+        EgretSlot.prototype._updateColor = function () {
+            if (this._colorTransform.redMultiplier !== 1.0 ||
+                this._colorTransform.greenMultiplier !== 1.0 ||
+                this._colorTransform.blueMultiplier !== 1.0 ||
+                this._colorTransform.redOffset !== 0 ||
+                this._colorTransform.greenOffset !== 0 ||
+                this._colorTransform.blueOffset !== 0 ||
+                this._colorTransform.alphaOffset !== 0) {
+                if (this._colorFilter === null) {
+                    this._colorFilter = new egret.ColorMatrixFilter();
+                }
+                var colorMatrix = this._colorFilter.matrix;
+                colorMatrix[0] = this._colorTransform.redMultiplier;
+                colorMatrix[6] = this._colorTransform.greenMultiplier;
+                colorMatrix[12] = this._colorTransform.blueMultiplier;
+                colorMatrix[18] = this._colorTransform.alphaMultiplier;
+                colorMatrix[4] = this._colorTransform.redOffset;
+                colorMatrix[9] = this._colorTransform.greenOffset;
+                colorMatrix[14] = this._colorTransform.blueOffset;
+                colorMatrix[19] = this._colorTransform.alphaOffset;
+                this._colorFilter.matrix = colorMatrix;
+                if (this._armatureDisplay._batchEnabled) {
+                    var node = this._renderDisplay.$renderNode;
+                    node.filter = this._colorFilter;
+                    node.alpha = 1.0;
+                }
+                var filters = this._renderDisplay.filters;
+                if (!filters) {
+                    filters = [];
+                }
+                if (filters.indexOf(this._colorFilter) < 0) {
+                    filters.push(this._colorFilter);
+                }
+                this._renderDisplay.filters = filters;
+                this._renderDisplay.alpha = 1.0;
+            }
+            else {
+                if (this._armatureDisplay._batchEnabled) {
+                    var node = this._renderDisplay.$renderNode;
+                    node.filter = null;
+                    node.alpha = this._colorTransform.alphaMultiplier;
+                }
+                this._renderDisplay.filters = null;
+                this._renderDisplay.alpha = this._colorTransform.alphaMultiplier;
+            }
+        };
+        EgretSlot.prototype._updateFrame = function () {
+            var currentVerticesData = (this._deformVertices !== null && this._display === this._meshDisplay) ? this._deformVertices.verticesData : null;
+            var currentTextureData = this._textureData;
+            if (this._displayIndex >= 0 && this._display !== null && currentTextureData !== null) {
+                if (this._armature.replacedTexture !== null && this._rawDisplayDatas !== null && this._rawDisplayDatas.indexOf(this._displayData) >= 0) {
+                    var currentTextureAtlasData = currentTextureData.parent;
+                    if (this._armature._replaceTextureAtlasData === null) {
+                        currentTextureAtlasData = dragonBones.BaseObject.borrowObject(dragonBones.EgretTextureAtlasData);
+                        currentTextureAtlasData.copyFrom(currentTextureData.parent);
+                        currentTextureAtlasData.renderTexture = this._armature.replacedTexture;
+                        this._armature._replaceTextureAtlasData = currentTextureAtlasData;
+                    }
+                    else {
+                        currentTextureAtlasData = this._armature._replaceTextureAtlasData;
+                    }
+                    currentTextureData = currentTextureAtlasData.getTexture(currentTextureData.name);
+                }
+                if (currentTextureData.renderTexture !== null) {
+                    if (currentVerticesData !== null) {
+                        var data = currentVerticesData.data;
+                        var intArray = data.intArray;
+                        var floatArray = data.floatArray;
+                        var vertexCount = intArray[currentVerticesData.offset + 0 /* MeshVertexCount */];
+                        var triangleCount = intArray[currentVerticesData.offset + 1 /* MeshTriangleCount */];
+                        var vertexOffset = intArray[currentVerticesData.offset + 2 /* MeshFloatOffset */];
+                        if (vertexOffset < 0) {
+                            vertexOffset += 65536; // Fixed out of bouds bug. 
+                        }
+                        var uvOffset = vertexOffset + vertexCount * 2;
+                        var scale = this._armature._armatureData.scale;
+                        var meshDisplay = this._renderDisplay;
+                        var meshNode = meshDisplay.$renderNode;
+                        meshNode.uvs.length = vertexCount * 2;
+                        meshNode.vertices.length = vertexCount * 2;
+                        meshNode.indices.length = triangleCount * 3;
+                        for (var i = 0, l = vertexCount * 2; i < l; ++i) {
+                            meshNode.vertices[i] = floatArray[vertexOffset + i] * scale;
+                            meshNode.uvs[i] = floatArray[uvOffset + i];
+                        }
+                        for (var i = 0; i < triangleCount * 3; ++i) {
+                            meshNode.indices[i] = intArray[currentVerticesData.offset + 4 /* MeshVertexIndices */ + i];
+                        }
+                        if (this._armatureDisplay._batchEnabled) {
+                            var texture = currentTextureData.renderTexture;
+                            var node = this._renderDisplay.$renderNode;
+                            egret.sys.RenderNode.prototype.cleanBeforeRender.call(node);
+                            node.image = texture.bitmapData;
+                            if (dragonBones.isV5) {
+                                node.drawMesh(texture.$bitmapX, texture.$bitmapY, texture.$bitmapWidth, texture.$bitmapHeight, texture.$offsetX, texture.$offsetY, texture.textureWidth, texture.textureHeight);
+                                node.imageWidth = texture.$sourceWidth;
+                                node.imageHeight = texture.$sourceHeight;
+                            }
+                            else {
+                                var textureV4 = texture;
+                                node.drawMesh(textureV4._bitmapX, textureV4._bitmapY, textureV4._bitmapWidth, textureV4._bitmapHeight, textureV4._offsetX, textureV4._offsetY, textureV4.textureWidth, textureV4.textureHeight);
+                                node.imageWidth = textureV4._sourceWidth;
+                                node.imageHeight = textureV4._sourceHeight;
+                            }
+                            this._blendModeDirty = true;
+                            this._colorDirty = true;
+                        }
+                        meshDisplay.texture = currentTextureData.renderTexture;
+                        meshDisplay.anchorOffsetX = this._pivotX;
+                        meshDisplay.anchorOffsetY = this._pivotY;
+                        meshDisplay.$updateVertices();
+                        if (!dragonBones.isV5) {
+                            meshDisplay.$invalidateTransform();
+                        }
+                        var isSkinned = currentVerticesData.weight !== null;
+                        var isSurface = this._parent._boneData.type !== 0 /* Bone */;
+                        if (isSkinned || isSurface) {
+                            this._identityTransform();
+                        }
+                    }
+                    else {
+                        var scale = currentTextureData.parent.scale * this._armature._armatureData.scale;
+                        var textureWidth = (currentTextureData.rotated ? currentTextureData.region.height : currentTextureData.region.width) * scale;
+                        var textureHeight = (currentTextureData.rotated ? currentTextureData.region.width : currentTextureData.region.height) * scale;
+                        var normalDisplay_1 = this._renderDisplay;
+                        var texture = currentTextureData.renderTexture;
+                        normalDisplay_1.texture = texture;
+                        if (this._armatureDisplay._batchEnabled) {
+                            var node = this._renderDisplay.$renderNode;
+                            egret.sys.RenderNode.prototype.cleanBeforeRender.call(node);
+                            node.image = texture.bitmapData;
+                            if (dragonBones.isV5) {
+                                node.drawImage(texture.$bitmapX, texture.$bitmapY, texture.$bitmapWidth, texture.$bitmapHeight, texture.$offsetX, texture.$offsetY, textureWidth, textureHeight);
+                                node.imageWidth = texture.$sourceWidth;
+                                node.imageHeight = texture.$sourceHeight;
+                            }
+                            else {
+                                var textureV4 = texture;
+                                node.drawImage(textureV4._bitmapX, textureV4._bitmapY, textureV4._bitmapWidth, textureV4._bitmapHeight, textureV4._offsetX, textureV4._offsetY, textureWidth, textureHeight);
+                                node.imageWidth = textureV4._sourceWidth;
+                                node.imageHeight = textureV4._sourceHeight;
+                            }
+                            this._blendModeDirty = true;
+                            this._colorDirty = true;
+                        }
+                        else {
+                            normalDisplay_1.width = textureWidth;
+                            normalDisplay_1.height = textureHeight;
+                        }
+                        normalDisplay_1.anchorOffsetX = this._pivotX;
+                        normalDisplay_1.anchorOffsetY = this._pivotY;
+                    }
+                    this._visibleDirty = true;
+                    return;
+                }
+            }
+            if (this._armatureDisplay._batchEnabled) {
+                this._renderDisplay.$renderNode.image = null;
+            }
+            var normalDisplay = this._renderDisplay;
+            normalDisplay.texture = null;
+            normalDisplay.x = 0.0;
+            normalDisplay.y = 0.0;
+            normalDisplay.visible = false;
+        };
+        EgretSlot.prototype._updateMesh = function () {
+            var scale = this._armature._armatureData.scale;
+            var deformVertices = this._deformVertices.vertices;
+            var bones = this._deformVertices.bones;
+            var verticesData = this._deformVertices.verticesData;
+            var weightData = verticesData.weight;
+            var hasDeform = deformVertices.length > 0 && verticesData.inheritDeform;
+            var meshDisplay = this._renderDisplay;
+            var meshNode = meshDisplay.$renderNode;
+            if (weightData !== null) {
+                var data = verticesData.data;
+                var intArray = data.intArray;
+                var floatArray = data.floatArray;
+                var vertexCount = intArray[verticesData.offset + 0 /* MeshVertexCount */];
+                var weightFloatOffset = intArray[weightData.offset + 1 /* WeigthFloatOffset */];
+                if (weightFloatOffset < 0) {
+                    weightFloatOffset += 65536; // Fixed out of bouds bug. 
+                }
+                for (var i = 0, iD = 0, iB = weightData.offset + 2 /* WeigthBoneIndices */ + bones.length, iV = weightFloatOffset, iF = 0; i < vertexCount; ++i) {
+                    var boneCount = intArray[iB++];
+                    var xG = 0.0, yG = 0.0;
+                    for (var j = 0; j < boneCount; ++j) {
+                        var boneIndex = intArray[iB++];
+                        var bone = bones[boneIndex];
+                        if (bone !== null) {
+                            var matrix = bone.globalTransformMatrix;
+                            var weight = floatArray[iV++];
+                            var xL = floatArray[iV++] * scale;
+                            var yL = floatArray[iV++] * scale;
+                            if (hasDeform) {
+                                xL += deformVertices[iF++];
+                                yL += deformVertices[iF++];
+                            }
+                            xG += (matrix.a * xL + matrix.c * yL + matrix.tx) * weight;
+                            yG += (matrix.b * xL + matrix.d * yL + matrix.ty) * weight;
+                        }
+                    }
+                    meshNode.vertices[iD++] = xG;
+                    meshNode.vertices[iD++] = yG;
+                }
+                meshDisplay.$updateVertices();
+                if (!dragonBones.isV5) {
+                    meshDisplay.$invalidateTransform();
+                }
+            }
+            else if (hasDeform) {
+                var isSurface = this._parent._boneData.type !== 0 /* Bone */;
+                var data = verticesData.data;
+                var intArray = data.intArray;
+                var floatArray = data.floatArray;
+                var vertexCount = intArray[verticesData.offset + 0 /* MeshVertexCount */];
+                var vertexOffset = intArray[verticesData.offset + 2 /* MeshFloatOffset */];
+                if (vertexOffset < 0) {
+                    vertexOffset += 65536; // Fixed out of bouds bug. 
+                }
+                for (var i = 0, l = vertexCount * 2; i < l; i += 2) {
+                    var x = floatArray[vertexOffset + i] * scale + deformVertices[i];
+                    var y = floatArray[vertexOffset + i + 1] * scale + deformVertices[i + 1];
+                    if (isSurface) {
+                        var matrix = this._parent._getGlobalTransformMatrix(x, y);
+                        meshNode.vertices[i] = matrix.a * x + matrix.c * y + matrix.tx;
+                        meshNode.vertices[i + 1] = matrix.b * x + matrix.d * y + matrix.ty;
+                    }
+                    else {
+                        meshNode.vertices[i] = x;
+                        meshNode.vertices[i + 1] = y;
+                    }
+                }
+                meshDisplay.$updateVertices();
+                if (!dragonBones.isV5) {
+                    meshDisplay.$invalidateTransform();
+                }
+            }
+            if (this._armatureDisplay._batchEnabled) {
+                this._armatureDisplay._childDirty = true;
+            }
+        };
+        /**
+         * @internal
+         */
+        EgretSlot.prototype._updateGlueMesh = function () {
+        };
+        EgretSlot.prototype._updateTransform = function () {
+            throw new Error();
+        };
+        EgretSlot.prototype._identityTransform = function () {
+            if (this._armatureDisplay._batchEnabled) {
+                this._armatureDisplay._childDirty = true;
+                var displayMatrix = this._renderDisplay.$renderNode.matrix;
+                displayMatrix.a = 1.0;
+                displayMatrix.b = 0.0;
+                displayMatrix.c = 0.0;
+                displayMatrix.d = 1.0;
+                displayMatrix.tx = 0.0;
+                displayMatrix.ty = 0.0;
+            }
+            else {
+                egret.$TempMatrix.identity();
+                this._renderDisplay.$setMatrix(egret.$TempMatrix, this.transformUpdateEnabled);
+            }
+        };
+        EgretSlot.prototype._updateTransformV4 = function () {
+            var globalTransformMatrix = this.globalTransformMatrix;
+            if (this._armatureDisplay._batchEnabled) {
+                this._armatureDisplay._childDirty = true;
+                var displayMatrix = this._renderDisplay.$renderNode.matrix;
+                displayMatrix.a = globalTransformMatrix.a;
+                displayMatrix.b = globalTransformMatrix.b;
+                displayMatrix.c = globalTransformMatrix.c;
+                displayMatrix.d = globalTransformMatrix.d;
+                displayMatrix.tx = this.globalTransformMatrix.tx - (this.globalTransformMatrix.a * this._pivotX + this.globalTransformMatrix.c * this._pivotY);
+                displayMatrix.ty = this.globalTransformMatrix.ty - (this.globalTransformMatrix.b * this._pivotX + this.globalTransformMatrix.d * this._pivotY);
+            }
+            else if (this.transformUpdateEnabled) {
+                this._renderDisplay.$setMatrix(globalTransformMatrix, true);
+            }
+            else {
+                var values = this._renderDisplay.$DisplayObject;
+                var displayMatrix = values[6];
+                displayMatrix.a = this.globalTransformMatrix.a;
+                displayMatrix.b = this.globalTransformMatrix.b;
+                displayMatrix.c = this.globalTransformMatrix.c;
+                displayMatrix.d = this.globalTransformMatrix.d;
+                displayMatrix.tx = this.globalTransformMatrix.tx;
+                displayMatrix.ty = this.globalTransformMatrix.ty;
+                this._renderDisplay.$removeFlags(8);
+                this._renderDisplay.$invalidatePosition();
+            }
+        };
+        EgretSlot.prototype._updateTransformV5 = function () {
+            var globalTransformMatrix = this.globalTransformMatrix;
+            if (this._armatureDisplay._batchEnabled) {
+                this._armatureDisplay._childDirty = true;
+                var displayMatrix = this._renderDisplay.$renderNode.matrix;
+                displayMatrix.a = globalTransformMatrix.a;
+                displayMatrix.b = globalTransformMatrix.b;
+                displayMatrix.c = globalTransformMatrix.c;
+                displayMatrix.d = globalTransformMatrix.d;
+                displayMatrix.tx = this.globalTransformMatrix.tx - (this.globalTransformMatrix.a * this._pivotX + this.globalTransformMatrix.c * this._pivotY);
+                displayMatrix.ty = this.globalTransformMatrix.ty - (this.globalTransformMatrix.b * this._pivotX + this.globalTransformMatrix.d * this._pivotY);
+            }
+            else {
+                this._renderDisplay.$setMatrix(globalTransformMatrix, this.transformUpdateEnabled);
+            }
+        };
+        return EgretSlot;
+    }(dragonBones.Slot));
+    dragonBones.EgretSlot = EgretSlot;
+})(dragonBones || (dragonBones = {}));
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012-2018 DragonBones team and other contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @internal
+     */
+    dragonBones.isV5 = Number(egret.Capabilities.engineVersion.substr(0, 3)) >= 5.1;
+    /**
+     * - The Egret factory.
+     * @version DragonBones 3.0
+     * @language en_US
+     */
+    /**
+     * - Egret 工厂。
+     * @version DragonBones 3.0
+     * @language zh_CN
+     */
+    var EgretFactory = /** @class */ (function (_super) {
+        __extends(EgretFactory, _super);
+        /**
+         * @inheritDoc
+         */
+        function EgretFactory(dataParser) {
+            if (dataParser === void 0) { dataParser = null; }
+            var _this = _super.call(this, dataParser) || this;
+            if (EgretFactory._dragonBonesInstance === null) {
+                //
+                var eventManager = new dragonBones.EgretArmatureDisplay();
+                EgretFactory._dragonBonesInstance = new dragonBones.DragonBones(eventManager);
+                EgretFactory._time = egret.getTimer() * 0.001;
+                egret.startTick(EgretFactory._clockHandler, EgretFactory);
+            }
+            _this._dragonBones = EgretFactory._dragonBonesInstance;
+            return _this;
+        }
+        EgretFactory._clockHandler = function (time) {
+            time *= 0.001;
+            var passedTime = time - this._time;
+            EgretFactory._dragonBonesInstance.advanceTime(passedTime);
+            this._time = time;
+            return false;
+        };
+        Object.defineProperty(EgretFactory, "factory", {
+            /**
+             * - A global factory instance that can be used directly.
+             * @version DragonBones 4.7
+             * @language en_US
+             */
+            /**
+             * - 一个可以直接使用的全局工厂实例。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                if (EgretFactory._factory === null) {
+                    EgretFactory._factory = new EgretFactory();
+                }
+                return EgretFactory._factory;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        EgretFactory.prototype._isSupportMesh = function () {
+            if (egret.Capabilities.renderMode === "webgl" || egret.Capabilities.runtimeType === egret.RuntimeType.NATIVE) {
+                return true;
+            }
+            console.warn("Canvas can not support mesh, please change renderMode to webgl.");
+            return false;
+        };
+        EgretFactory.prototype._buildTextureAtlasData = function (textureAtlasData, textureAtlas) {
+            if (textureAtlasData !== null) {
+                if (textureAtlas instanceof egret.Texture) {
+                    textureAtlasData.renderTexture = textureAtlas;
+                }
+                else {
+                    var egretTexture = new egret.Texture();
+                    egretTexture.bitmapData = new egret.BitmapData(textureAtlas);
+                    textureAtlasData.disposeEnabled = true;
+                    textureAtlasData.renderTexture = egretTexture;
+                }
+            }
+            else {
+                textureAtlasData = dragonBones.BaseObject.borrowObject(dragonBones.EgretTextureAtlasData);
+            }
+            return textureAtlasData;
+        };
+        EgretFactory.prototype._buildArmature = function (dataPackage) {
+            var armature = dragonBones.BaseObject.borrowObject(dragonBones.Armature);
+            var armatureDisplay = new dragonBones.EgretArmatureDisplay();
+            armature.init(dataPackage.armature, armatureDisplay, armatureDisplay, this._dragonBones);
+            return armature;
+        };
+        EgretFactory.prototype._buildSlot = function (dataPackage, slotData, armature) {
+            // tslint:disable-next-line:no-unused-expression
+            dataPackage;
+            var slot = dragonBones.BaseObject.borrowObject(dragonBones.EgretSlot);
+            slot.init(slotData, armature, new egret.Bitmap(), new egret.Mesh());
+            return slot;
+        };
+        /**
+         * - Create a armature from cached DragonBonesData instances and TextureAtlasData instances, then use the {@link #clock} to update it.
+         * Note that when the created armature proxy that is no longer in use, you need to explicitly dispose {@link #dragonBones.IArmatureProxy#dispose()}.
+         * The difference is that the armature created by {@link #buildArmature} is not WorldClock instance update.
+         * @param armatureName - The armature data name.
+         * @param dragonBonesName - The cached name of the DragonBonesData instance. (If not set, all DragonBonesData instances are retrieved, and when multiple DragonBonesData instances contain a the same name armature data, it may not be possible to accurately create a specific armature)
+         * @param skinName - The skin name, you can set a different ArmatureData name to share it's skin data. (If not set, use the default skin data)
+         * @returns The armature display container.
+         * @see dragonBones.IArmatureProxy
+         * @see dragonBones.BaseFactory#buildArmature
+         * @version DragonBones 4.5
+         * @example
+         * <pre>
+         *     let armatureDisplay = factory.buildArmatureDisplay("armatureName", "dragonBonesName");
+         * </pre>
+         * @language en_US
+         */
+        /**
+         * - 通过缓存的 DragonBonesData 实例和 TextureAtlasData 实例创建一个骨架，并用 {@link #clock} 更新该骨架。
+         * 区别在于由 {@link #buildArmature} 创建的骨架没有 WorldClock 实例驱动。
+         * 注意，创建的骨架代理不再使用时，需要显式释放 {@link #dragonBones.IArmatureProxy#dispose()}。
+         * @param armatureName - 骨架数据名称。
+         * @param dragonBonesName - DragonBonesData 实例的缓存名称。 （如果未设置，将检索所有的 DragonBonesData 实例，当多个 DragonBonesData 实例中包含同名的骨架数据时，可能无法准确的创建出特定的骨架）
+         * @param skinName - 皮肤名称，可以设置一个其他骨架数据名称来共享其皮肤数据。（如果未设置，则使用默认的皮肤数据）
+         * @returns 骨架的显示容器。
+         * @see dragonBones.IArmatureProxy
+         * @see dragonBones.BaseFactory#buildArmature
+         * @version DragonBones 4.5
+         * @example
+         * <pre>
+         *     let armatureDisplay = factory.buildArmatureDisplay("armatureName", "dragonBonesName");
+         * </pre>
+         * @language zh_CN
+         */
+        EgretFactory.prototype.buildArmatureDisplay = function (armatureName, dragonBonesName, skinName, textureAtlasName) {
+            if (dragonBonesName === void 0) { dragonBonesName = ""; }
+            if (skinName === void 0) { skinName = ""; }
+            if (textureAtlasName === void 0) { textureAtlasName = ""; }
+            var armature = this.buildArmature(armatureName, dragonBonesName || "", skinName || "", textureAtlasName || "");
+            if (armature !== null) {
+                this._dragonBones.clock.add(armature);
+                return armature.display;
+            }
+            return null;
+        };
+        /**
+         * - Create the display object with the specified texture.
+         * @param textureName - The texture data name.
+         * @param textureAtlasName - The texture atlas data name. (Of not set, all texture atlas data will be searched)
+         * @version DragonBones 3.0
+         * @language en_US
+         */
+        /**
+         * - 创建带有指定贴图的显示对象。
+         * @param textureName - 贴图数据名称。
+         * @param textureAtlasName - 贴图集数据名称。 （如果未设置，将检索所有的贴图集数据）
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        EgretFactory.prototype.getTextureDisplay = function (textureName, textureAtlasName) {
+            if (textureAtlasName === void 0) { textureAtlasName = null; }
+            var textureData = this._getTextureData(textureAtlasName !== null ? textureAtlasName : "", textureName);
+            if (textureData !== null && textureData.renderTexture !== null) {
+                var texture = textureData.renderTexture;
+                var bitmap = new egret.Bitmap(texture);
+                bitmap.width = texture.textureWidth * textureData.parent.scale;
+                bitmap.height = texture.textureHeight * textureData.parent.scale;
+                return bitmap;
+            }
+            return null;
+        };
+        Object.defineProperty(EgretFactory.prototype, "soundEventManager", {
+            /**
+             * - A global sound event manager.
+             * Sound events can be listened to uniformly from the manager.
+             * @version DragonBones 4.5
+             * @language en_US
+             */
+            /**
+             * - 全局声音事件管理器。
+             * 声音事件可以从该管理器统一侦听。
+             * @version DragonBones 4.5
+             * @language zh_CN
+             */
+            get: function () {
+                return this._dragonBones.eventManager;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EgretFactory, "clock", {
+            /**
+             * - Deprecated, please refer to {@link #clock}.
+             * @deprecated
+             * @language en_US
+             */
+            /**
+             * - 已废弃，请参考 {@link #clock}。
+             * @deprecated
+             * @language zh_CN
+             */
+            get: function () {
+                return EgretFactory.factory.clock;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * - Deprecated, please refer to {@link #addDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #addDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.addSkeletonData = function (dragonBonesData, dragonBonesName) {
+            if (dragonBonesName === void 0) { dragonBonesName = null; }
+            console.warn("已废弃");
+            this.addDragonBonesData(dragonBonesData, dragonBonesName);
+        };
+        /**
+         * - Deprecated, please refer to {@link #getDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #getDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.getSkeletonData = function (dragonBonesName) {
+            console.warn("已废弃");
+            return this.getDragonBonesData(dragonBonesName);
+        };
+        /**
+         * - Deprecated, please refer to {@link #removeDragonBonesData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #removeDragonBonesData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.removeSkeletonData = function (dragonBonesName) {
+            console.warn("已废弃");
+            this.removeDragonBonesData(dragonBonesName);
+        };
+        /**
+         * - Deprecated, please refer to {@link #addTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #addTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.addTextureAtlas = function (textureAtlasData, dragonBonesName) {
+            if (dragonBonesName === void 0) { dragonBonesName = null; }
+            console.warn("已废弃");
+            this.addTextureAtlasData(textureAtlasData, dragonBonesName);
+        };
+        /**
+         * - Deprecated, please refer to {@link #getTextureAtlas()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #getTextureAtlas()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.getTextureAtlas = function (dragonBonesName) {
+            console.warn("已废弃");
+            return this.getTextureAtlasData(dragonBonesName);
+        };
+        /**
+         * - Deprecated, please refer to {@link #removeTextureAtlasData()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #removeTextureAtlasData()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.removeTextureAtlas = function (dragonBonesName) {
+            console.warn("已废弃");
+            this.removeTextureAtlasData(dragonBonesName);
+        };
+        /**
+         * - Deprecated, please refer to {@link #buildArmature()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #buildArmature()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.buildFastArmature = function (armatureName, dragonBonesName, skinName) {
+            if (dragonBonesName === void 0) { dragonBonesName = ""; }
+            if (skinName === void 0) { skinName = ""; }
+            console.warn("已废弃");
+            return this.buildArmature(armatureName, dragonBonesName || "", skinName || "");
+        };
+        /**
+         * - Deprecated, please refer to {@link #clear()}.
+         * @deprecated
+         * @language en_US
+         */
+        /**
+         * - 已废弃，请参考 {@link #clear()}。
+         * @deprecated
+         * @language zh_CN
+         */
+        EgretFactory.prototype.dispose = function () {
+            console.warn("已废弃");
+            this.clear();
+        };
+        EgretFactory._time = 0.0;
+        EgretFactory._dragonBonesInstance = null;
+        EgretFactory._factory = null;
+        return EgretFactory;
+    }(dragonBones.BaseFactory));
+    dragonBones.EgretFactory = EgretFactory;
+})(dragonBones || (dragonBones = {}));
+var dragonBones;
+(function (dragonBones) {
+    /**
+     * @private
+     */
+    var _helpRectangle = new egret.Rectangle();
+    /**
+     * @private
+     */
+    var _helpMatrix = new egret.Matrix();
+    /**
+     * @private
+     */
+    var _groupConfigMap = {};
+    /**
+     * @private
+     */
+    function _findObjectInArray(array, name) {
+        for (var i = 0, l = array.length; i < l; ++i) {
+            var data = array[i];
+            if (data.name === name) {
+                return data;
+            }
+        }
+        return null;
+    }
+    /**
+     * @private
+     */
+    function _fillCreateMovieHelper(createMovieHelper) {
+        if (createMovieHelper.groupName) {
+            var groupConfig = _groupConfigMap[createMovieHelper.groupName];
+            if (groupConfig) {
+                var movieConfig = _findObjectInArray(groupConfig.movie || groupConfig.animation, createMovieHelper.movieName);
+                if (movieConfig) {
+                    createMovieHelper.groupConfig = groupConfig;
+                    createMovieHelper.movieConfig = movieConfig;
+                    return true;
+                }
+            }
+        }
+        if (!createMovieHelper.groupName) {
+            for (var groupName in _groupConfigMap) {
+                var groupConfig = _groupConfigMap[groupName];
+                if (!createMovieHelper.groupName) {
+                    var movieConfig = _findObjectInArray(groupConfig.movie || groupConfig.animation, createMovieHelper.movieName);
+                    if (movieConfig) {
+                        createMovieHelper.groupName = groupName;
+                        createMovieHelper.groupConfig = groupConfig;
+                        createMovieHelper.movieConfig = movieConfig;
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * 是否包含指定名称的动画组。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function hasMovieGroup(groupName) {
+        return groupName in _groupConfigMap;
+    }
+    dragonBones.hasMovieGroup = hasMovieGroup;
+    /**
+     * 添加动画组。
+     * @param groupData 动画二进制数据。
+     * @param textureAtlas 贴图集或贴图集列表。
+     * @param groupName 为动画组指定一个名称，如果未设置，则使用数据中的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function addMovieGroup(groupData, textureAtlas, groupName) {
+        if (groupName === void 0) { groupName = null; }
+        if (groupData) {
+            var byteArray = new egret.ByteArray(groupData);
+            byteArray.endian = egret.Endian.LITTLE_ENDIAN;
+            byteArray.position = 8; // TODO format
+            var groupConfig = JSON.parse(byteArray.readUTF());
+            groupConfig.offset = byteArray.position;
+            groupConfig.arrayBuffer = groupData;
+            groupConfig.textures = [];
+            var p = groupConfig.offset % 4;
+            if (p) {
+                groupConfig.offset += 4 - p;
+            }
+            for (var i = 0, l = groupConfig.position.length; i < l; i += 3) {
+                switch (i / 3) {
+                    case 1:
+                        groupConfig.displayFrameArray = new Int16Array(groupConfig.arrayBuffer, groupConfig.offset + groupConfig.position[i], groupConfig.position[i + 1] / groupConfig.position[i + 2]);
+                        break;
+                    case 2:
+                        groupConfig.rectangleArray = new Float32Array(groupConfig.arrayBuffer, groupConfig.offset + groupConfig.position[i], groupConfig.position[i + 1] / groupConfig.position[i + 2]);
+                        break;
+                    case 3:
+                        groupConfig.transformArray = new Float32Array(groupConfig.arrayBuffer, groupConfig.offset + groupConfig.position[i], groupConfig.position[i + 1] / groupConfig.position[i + 2]);
+                        break;
+                    case 4:
+                        groupConfig.colorArray = new Int16Array(groupConfig.arrayBuffer, groupConfig.offset + groupConfig.position[i], groupConfig.position[i + 1] / groupConfig.position[i + 2]);
+                        break;
+                }
+            }
+            groupName = groupName || groupConfig.name;
+            if (_groupConfigMap[groupName]) {
+                console.warn("Replace group: " + groupName);
+            }
+            _groupConfigMap[groupName] = groupConfig;
+            //
+            if (textureAtlas instanceof Array) {
+                for (var i = 0, l = textureAtlas.length; i < l; ++i) {
+                    var texture = textureAtlas[i];
+                    groupConfig.textures.push(texture);
+                }
+            }
+            else {
+                groupConfig.textures.push(textureAtlas);
+            }
+        }
+        else {
+            throw new Error();
+        }
+    }
+    dragonBones.addMovieGroup = addMovieGroup;
+    /**
+     * 移除动画组。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function removeMovieGroup(groupName) {
+        var groupConfig = _groupConfigMap[groupName];
+        if (groupConfig) {
+            delete _groupConfigMap[groupName];
+        }
+    }
+    dragonBones.removeMovieGroup = removeMovieGroup;
+    /**
+     * 移除所有的动画组。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function removeAllMovieGroup() {
+        for (var i in _groupConfigMap) {
+            delete _groupConfigMap[i];
+        }
+    }
+    dragonBones.removeAllMovieGroup = removeAllMovieGroup;
+    /**
+     * 创建一个动画。
+     * @param movieName 动画的名称。
+     * @param groupName 动画组的名称，如果未设置，将检索所有的动画组，当多个动画组中包含同名的动画时，可能无法创建出准确的动画。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function buildMovie(movieName, groupName) {
+        if (groupName === void 0) { groupName = null; }
+        var createMovieHelper = { movieName: movieName, groupName: groupName };
+        if (_fillCreateMovieHelper(createMovieHelper)) {
+            var movie = new Movie(createMovieHelper);
+            movie.clock = dragonBones.EgretFactory.factory.clock;
+            return movie;
+        }
+        else {
+            console.warn("No movie named: " + movieName);
+        }
+        return null;
+    }
+    dragonBones.buildMovie = buildMovie;
+    /**
+     * 获取指定动画组内包含的所有动画名称。
+     * @param groupName 动画组的名称。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    function getMovieNames(groupName) {
+        var groupConfig = _groupConfigMap[groupName];
+        if (groupConfig) {
+            var movieNameGroup = [];
+            var movie = groupConfig.movie || groupConfig.animation;
+            for (var i = 0, l = movie.length; i < l; ++i) {
+                movieNameGroup.push(movie[i].name);
+            }
+            return movieNameGroup;
+        }
+        else {
+            console.warn("No group named: " + groupName);
+        }
+        return null;
+    }
+    dragonBones.getMovieNames = getMovieNames;
+    /**
+     * 动画事件。
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    var MovieEvent = /** @class */ (function (_super) {
+        __extends(MovieEvent, _super);
+        /**
+         * @private
+         */
+        function MovieEvent(type) {
+            var _this = _super.call(this, type) || this;
+            /**
+             * 事件名称。 (帧标签的名称或声音的名称)
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            _this.name = "";
+            /**
+             * 发出事件的插槽名称。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            _this.slotName = "";
+            /**
+             * 发出事件的动画剪辑名称。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            _this.clipName = "";
+            return _this;
+        }
+        Object.defineProperty(MovieEvent.prototype, "armature", {
+            //========================================= // 兼容旧数据
+            /**
+             * @private
+             */
+            get: function () {
+                return this.movie;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieEvent.prototype, "bone", {
+            /**
+             * @private
+             */
+            get: function () {
+                return null;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieEvent.prototype, "animationState", {
+            /**
+             * @private
+             */
+            get: function () {
+                return { name: this.clipName };
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieEvent.prototype, "frameLabel", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(MovieEvent.prototype, "movementID", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this.clipName;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * 动画剪辑开始播放。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        MovieEvent.START = "start";
+        /**
+         * 动画剪辑循环播放一次完成。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        MovieEvent.LOOP_COMPLETE = "loopComplete";
+        /**
+         * 动画剪辑播放完成。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        MovieEvent.COMPLETE = "complete";
+        /**
+         * 动画剪辑帧事件。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        MovieEvent.FRAME_EVENT = "frameEvent";
+        /**
+         * 动画剪辑声音事件。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        MovieEvent.SOUND_EVENT = "soundEvent";
+        return MovieEvent;
+    }(egret.Event));
+    dragonBones.MovieEvent = MovieEvent;
+    /**
+     * @private
+     */
+    var MovieSlot = /** @class */ (function (_super) {
+        __extends(MovieSlot, _super);
+        function MovieSlot(slotConfig) {
+            var _this = _super.call(this) || this;
+            _this.displayIndex = -1;
+            _this.colorIndex = -1;
+            _this.transformIndex = -1;
+            _this.rawDisplay = new egret.Bitmap();
+            _this.childMovies = {};
+            _this.displayConfig = null;
+            _this.childMovie = null;
+            _this.colorFilter = null;
+            _this.display = _this.rawDisplay;
+            _this.config = slotConfig;
+            _this.rawDisplay.name = _this.config.name;
+            if (!_this.config.blendMode) {
+                _this.config.blendMode = 0 /* Normal */;
+            }
+            return _this;
+        }
+        MovieSlot.prototype.dispose = function () {
+            this.rawDisplay = null;
+            this.childMovies = null;
+            this.config = null;
+            this.displayConfig = null;
+            this.display = null;
+            this.childMovie = null;
+            this.colorFilter = null;
+        };
+        return MovieSlot;
+    }(egret.HashObject));
+    /**
+     * 通过读取缓存的二进制动画数据来更新动画，具有良好的运行性能，同时对内存的占用也非常低。
+     * @see dragonBones.buildMovie
+     * @version DragonBones 4.7
+     * @language zh_CN
+     */
+    var Movie = /** @class */ (function (_super) {
+        __extends(Movie, _super);
+        function Movie(createMovieHelper) {
+            var _this = _super.call(this) || this;
+            /**
+             * 动画的播放速度。 [(-N~0): 倒转播放, 0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+             * @default 1
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            _this.timeScale = 1;
+            /**
+             * 动画剪辑的播放速度。 [(-N~0): 倒转播放, 0: 停止播放, (0~1): 慢速播放, 1: 正常播放, (1~N): 快速播放]
+             * （当再次播放其他动画剪辑时，此值将被重置为 1）
+             * @default 1
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            _this.clipTimeScale = 1;
+            _this._batchEnabled = true;
+            _this._isLockDispose = false;
+            _this._isDelayDispose = false;
+            _this._isStarted = false;
+            _this._isPlaying = false;
+            _this._isReversing = false;
+            _this._isCompleted = false;
+            _this._playTimes = 0;
+            _this._time = 0;
+            _this._currentTime = 0;
+            _this._currentPlayTimes = 0;
+            _this._cacheFrameIndex = 0;
+            _this._frameSize = 0;
+            _this._cacheRectangle = null;
+            _this._clock = null;
+            _this._currentFrameConfig = null;
+            _this._clipNames = [];
+            _this._slots = [];
+            _this._childMovies = [];
+            _this._groupConfig = createMovieHelper.groupConfig;
+            _this._config = createMovieHelper.movieConfig;
+            _this._batchEnabled = !(_this._config.isNested || _this._config.hasChildAnimation);
+            if (_this._batchEnabled) {
+                _this.$renderNode = new egret.sys.GroupNode();
+                _this.$renderNode.cleanBeforeRender = Movie._cleanBeforeRender;
+            }
+            _this._clipNames.length = 0;
+            for (var i = 0, l = _this._config.clip.length; i < l; ++i) {
+                _this._clipNames.push(_this._config.clip[i].name);
+            }
+            for (var i = 0, l = _this._config.slot.length; i < l; ++i) {
+                var slot = new MovieSlot(_this._config.slot[i]);
+                _this._updateSlotBlendMode(slot);
+                _this._slots.push(slot);
+                if (_this._batchEnabled) {
+                    _this.$renderNode.addNode(slot.rawDisplay.$renderNode);
+                }
+                else {
+                    _this.addChild(slot.rawDisplay);
+                }
+            }
+            _this._frameSize = (1 + 1) * _this._slots.length; // displayFrame, transformFrame.
+            _this.name = _this._config.name;
+            _this.play();
+            _this.advanceTime(0.000001);
+            _this.stop();
+            return _this;
+        }
+        Movie._cleanBeforeRender = function () { };
+        Movie.prototype._configToEvent = function (config, event) {
+            event.movie = this;
+            event.clipName = this._clipConfig.name;
+            event.name = config.name;
+            event.slotName = config.slot || "";
+        };
+        Movie.prototype._onCrossFrame = function (frameConfig) {
+            for (var i = 0, l = frameConfig.actionAndEvent.length; i < l; ++i) {
+                var actionAndEvent = frameConfig.actionAndEvent[i];
+                if (actionAndEvent) {
+                    switch (actionAndEvent.type) {
+                        case 11 /* Sound */:
+                            if (dragonBones.EgretFactory.factory.soundEventManager.hasEventListener(MovieEvent.SOUND_EVENT)) {
+                                var event_1 = egret.Event.create(MovieEvent, MovieEvent.SOUND_EVENT);
+                                this._configToEvent(actionAndEvent, event_1);
+                                dragonBones.EgretFactory.factory.soundEventManager.dispatchEvent(event_1);
+                                egret.Event.release(event_1);
+                            }
+                            break;
+                        case 10 /* Frame */:
+                            if (this.hasEventListener(MovieEvent.FRAME_EVENT)) {
+                                var event_2 = egret.Event.create(MovieEvent, MovieEvent.FRAME_EVENT);
+                                this._configToEvent(actionAndEvent, event_2);
+                                this.dispatchEvent(event_2);
+                                egret.Event.release(event_2);
+                            }
+                            break;
+                        case 0 /* Play */:
+                            if (actionAndEvent.slot) {
+                                var slot = this._getSlot(actionAndEvent.slot);
+                                if (slot && slot.childMovie) {
+                                    slot.childMovie.play(actionAndEvent.name);
+                                }
+                            }
+                            else {
+                                this.play(actionAndEvent.name);
+                            }
+                            break;
+                    }
+                }
+            }
+        };
+        Movie.prototype._updateSlotBlendMode = function (slot) {
+            var blendMode = "";
+            switch (slot.config.blendMode) {
+                case 0 /* Normal */:
+                    blendMode = egret.BlendMode.NORMAL;
+                    break;
+                case 1 /* Add */:
+                    blendMode = egret.BlendMode.ADD;
+                    break;
+                case 5 /* Erase */:
+                    blendMode = egret.BlendMode.ERASE;
+                    break;
+                default:
+                    break;
+            }
+            if (blendMode) {
+                if (this._batchEnabled) {
+                    // RenderNode display.
+                    slot.display.$renderNode.blendMode = egret.sys.blendModeToNumber(blendMode);
+                }
+                else {
+                    // Classic display.
+                    slot.display.blendMode = blendMode;
+                }
+            }
+        };
+        Movie.prototype._updateSlotColor = function (slot, aM, rM, gM, bM, aO, rO, gO, bO) {
+            if (rM !== 1 ||
+                gM !== 1 ||
+                bM !== 1 ||
+                rO !== 0 ||
+                gO !== 0 ||
+                bO !== 0 ||
+                aO !== 0) {
+                if (!slot.colorFilter) {
+                    slot.colorFilter = new egret.ColorMatrixFilter();
+                }
+                var colorMatrix = slot.colorFilter.matrix;
+                colorMatrix[0] = rM;
+                colorMatrix[6] = gM;
+                colorMatrix[12] = bM;
+                colorMatrix[18] = aM;
+                colorMatrix[4] = rO;
+                colorMatrix[9] = gO;
+                colorMatrix[14] = bO;
+                colorMatrix[19] = aO;
+                slot.colorFilter.matrix = colorMatrix;
+                if (this._batchEnabled) {
+                    // RenderNode display.
+                    slot.display.$renderNode.filter = slot.colorFilter;
+                    slot.display.$renderNode.alpha = 1.0;
+                }
+                else {
+                    // Classic display.
+                    var filters = slot.display.filters;
+                    if (!filters) {
+                        filters = [];
+                    }
+                    if (filters.indexOf(slot.colorFilter) < 0) {
+                        filters.push(slot.colorFilter);
+                    }
+                    slot.display.filters = filters;
+                    slot.display.$setAlpha(1.0);
+                }
+            }
+            else {
+                if (slot.colorFilter) {
+                    slot.colorFilter = null;
+                }
+                if (this._batchEnabled) {
+                    // RenderNode display.
+                    slot.display.$renderNode.filter = null;
+                    slot.display.$renderNode.alpha = aM;
+                }
+                else {
+                    // Classic display.
+                    slot.display.filters = null;
+                    slot.display.$setAlpha(aM);
+                }
+            }
+        };
+        Movie.prototype._updateSlotDisplay = function (slot) {
+            var prevDisplay = slot.display || slot.rawDisplay;
+            var prevChildMovie = slot.childMovie;
+            if (slot.displayIndex >= 0) {
+                slot.displayConfig = this._groupConfig.display[slot.displayIndex];
+                if (slot.displayConfig.type === 1 /* Armature */) {
+                    var childMovie = slot.displayConfig.name in slot.childMovies ? slot.childMovies[slot.displayConfig.name] : null;
+                    if (!childMovie) {
+                        childMovie = buildMovie(slot.displayConfig.name, this._groupConfig.name);
+                        if (childMovie) {
+                            slot.childMovies[slot.displayConfig.name] = childMovie;
+                        }
+                    }
+                    if (childMovie) {
+                        slot.display = childMovie;
+                        slot.childMovie = childMovie;
+                    }
+                    else {
+                        slot.display = slot.rawDisplay;
+                        slot.childMovie = null;
+                    }
+                }
+                else {
+                    slot.display = slot.rawDisplay;
+                    slot.childMovie = null;
+                }
+            }
+            else {
+                slot.displayConfig = null;
+                slot.display = slot.rawDisplay;
+                slot.childMovie = null;
+            }
+            if (slot.display !== prevDisplay) {
+                if (prevDisplay) {
+                    this.addChild(slot.display);
+                    this.swapChildren(slot.display, prevDisplay);
+                    this.removeChild(prevDisplay);
+                }
+                // Update blendMode.
+                this._updateSlotBlendMode(slot);
+            }
+            // Update frame.
+            if (slot.display === slot.rawDisplay) {
+                if (slot.displayConfig && slot.displayConfig.regionIndex !== null && slot.displayConfig.regionIndex !== undefined) {
+                    if (!slot.displayConfig.texture) {
+                        var textureAtlasTexture = this._groupConfig.textures[slot.displayConfig.textureIndex || 0];
+                        var regionIndex = slot.displayConfig.regionIndex * 4;
+                        var x = this._groupConfig.rectangleArray[regionIndex];
+                        var y = this._groupConfig.rectangleArray[regionIndex + 1];
+                        var width = this._groupConfig.rectangleArray[regionIndex + 2];
+                        var height = this._groupConfig.rectangleArray[regionIndex + 3];
+                        slot.displayConfig.texture = new egret.Texture();
+                        slot.displayConfig.texture.bitmapData = textureAtlasTexture.bitmapData;
+                        slot.displayConfig.texture.$initData(x, y, Math.min(width, textureAtlasTexture.textureWidth - x), Math.min(height, textureAtlasTexture.textureHeight - y), 0, 0, Math.min(width, textureAtlasTexture.textureWidth - x), Math.min(height, textureAtlasTexture.textureHeight - y), textureAtlasTexture.textureWidth, textureAtlasTexture.textureHeight);
+                    }
+                    if (this._batchEnabled) {
+                        // RenderNode display.
+                        var texture = slot.displayConfig.texture;
+                        var bitmapNode = slot.rawDisplay.$renderNode;
+                        egret.sys.RenderNode.prototype.cleanBeforeRender.call(slot.rawDisplay.$renderNode);
+                        bitmapNode.image = texture.bitmapData;
+                        if (dragonBones.isV5) {
+                            bitmapNode.drawImage(texture.$bitmapX, texture.$bitmapY, texture.$bitmapWidth, texture.$bitmapHeight, texture.$offsetX, texture.$offsetY, texture.textureWidth, texture.textureHeight);
+                            bitmapNode.imageWidth = texture._sourceWidth;
+                            bitmapNode.imageHeight = texture._sourceHeight;
+                        }
+                        else {
+                            var textureV4 = texture;
+                            bitmapNode.drawImage(textureV4._bitmapX, textureV4._bitmapY, textureV4._bitmapWidth, textureV4._bitmapHeight, textureV4._offsetX, textureV4._offsetY, texture.textureWidth, texture.textureHeight);
+                            bitmapNode.imageWidth = textureV4._sourceWidth;
+                            bitmapNode.imageHeight = textureV4._sourceHeight;
+                        }
+                    }
+                    else {
+                        // Classic display.
+                        slot.rawDisplay.visible = true;
+                        slot.rawDisplay.$setBitmapData(slot.displayConfig.texture);
+                    }
+                }
+                else {
+                    if (this._batchEnabled) {
+                        // RenderNode display.
+                        slot.rawDisplay.$renderNode.image = null;
+                    }
+                    else {
+                        // Classic display.
+                        slot.rawDisplay.visible = false;
+                        slot.rawDisplay.$setBitmapData(null);
+                    }
+                }
+            }
+            // Update child movie.
+            if (slot.childMovie !== prevChildMovie) {
+                if (prevChildMovie) {
+                    prevChildMovie.stop();
+                    this._childMovies.slice(this._childMovies.indexOf(prevChildMovie), 1);
+                }
+                if (slot.childMovie) {
+                    if (this._childMovies.indexOf(slot.childMovie) < 0) {
+                        this._childMovies.push(slot.childMovie);
+                    }
+                    if (slot.config.action) {
+                        slot.childMovie.play(slot.config.action);
+                    }
+                    else {
+                        slot.childMovie.play(slot.childMovie._config.action);
+                    }
+                }
+            }
+        };
+        Movie.prototype._getSlot = function (name) {
+            for (var i = 0, l = this._slots.length; i < l; ++i) {
+                var slot = this._slots[i];
+                if (slot.config.name === name) {
+                    return slot;
+                }
+            }
+            return null;
+        };
+        /**
+         * @inheritDoc
+         */
+        Movie.prototype.$render = function () {
+            if (this._batchEnabled) {
+                // RenderNode display.
+            }
+            else {
+                // Classic display.
+                _super.prototype.$render.call(this);
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        Movie.prototype.$updateRenderNode = function () {
+            if (this._batchEnabled) {
+                // RenderNode display.
+            }
+            else {
+                // Classic display.
+                _super.prototype.$updateRenderNode.call(this);
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        Movie.prototype.$measureContentBounds = function (bounds) {
+            if (this._batchEnabled && this._cacheRectangle) {
+                // RenderNode display.
+                bounds.setTo(this._cacheRectangle.x, this._cacheRectangle.y, this._cacheRectangle.width - this._cacheRectangle.x, this._cacheRectangle.height - this._cacheRectangle.y);
+            }
+            else {
+                // Classic display.
+                _super.prototype.$measureContentBounds.call(this, bounds);
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        Movie.prototype.$doAddChild = function (child, index, notifyListeners) {
+            if (this._batchEnabled) {
+                // RenderNode display.
+                console.warn("Can not add child.");
+                return null;
+            }
+            // Classic display.
+            return _super.prototype.$doAddChild.call(this, child, index, notifyListeners);
+        };
+        /**
+         * @inheritDoc
+         */
+        Movie.prototype.$doRemoveChild = function (index, notifyListeners) {
+            if (this._batchEnabled) {
+                // RenderNode display.
+                console.warn("Can not remove child.");
+                return null;
+            }
+            // Classic display.
+            return _super.prototype.$doRemoveChild.call(this, index, notifyListeners);
+        };
+        /**
+         * 释放动画。
+         * @version DragonBones 3.0
+         * @language zh_CN
+         */
+        Movie.prototype.dispose = function () {
+            if (this._isLockDispose) {
+                this._isDelayDispose = true;
+            }
+            else {
+                if (this._clock) {
+                    this._clock.remove(this);
+                }
+                if (this._slots) {
+                    for (var i = 0, l = this._slots.length; i < l; ++i) {
+                        this._slots[i].dispose();
+                    }
+                }
+                this._isPlaying = false;
+                this._cacheRectangle = null;
+                this._clock = null;
+                this._groupConfig = null;
+                this._config = null;
+                this._clipConfig = null;
+                this._currentFrameConfig = null;
+                this._clipArray = null;
+                this._clipNames = null;
+                this._slots = null;
+                this._childMovies = null;
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        Movie.prototype.advanceTime = function (passedTime) {
+            if (this._isPlaying) {
+                this._isLockDispose = true;
+                if (passedTime < 0) {
+                    passedTime = -passedTime;
+                }
+                passedTime *= this.timeScale;
+                this._time += passedTime * this.clipTimeScale;
+                // Modify time.            
+                var duration = this._clipConfig.duration;
+                var totalTime = duration * this._playTimes;
+                var currentTime = this._time;
+                var currentPlayTimes = this._currentPlayTimes;
+                if (this._playTimes > 0 && (currentTime >= totalTime || currentTime <= -totalTime)) {
+                    this._isCompleted = true;
+                    currentPlayTimes = this._playTimes;
+                    if (currentTime < 0) {
+                        currentTime = 0;
+                    }
+                    else {
+                        currentTime = duration;
+                    }
+                }
+                else {
+                    this._isCompleted = false;
+                    if (currentTime < 0) {
+                        currentPlayTimes = Math.floor(-currentTime / duration);
+                        currentTime = duration - (-currentTime % duration);
+                    }
+                    else {
+                        currentPlayTimes = Math.floor(currentTime / duration);
+                        currentTime %= duration;
+                    }
+                    if (this._playTimes > 0 && currentPlayTimes > this._playTimes) {
+                        currentPlayTimes = this._playTimes;
+                    }
+                }
+                if (this._currentTime === currentTime) {
+                    return;
+                }
+                var cacheFrameIndex = Math.floor(currentTime * this._clipConfig.cacheTimeToFrameScale);
+                if (this._cacheFrameIndex !== cacheFrameIndex) {
+                    this._cacheFrameIndex = cacheFrameIndex;
+                    var displayFrameArray = this._groupConfig.displayFrameArray;
+                    var transformArray = this._groupConfig.transformArray;
+                    var colorArray = this._groupConfig.colorArray;
+                    //
+                    var isFirst = true;
+                    var hasDisplay = false;
+                    var needCacheRectangle = false;
+                    var prevCacheRectangle = this._cacheRectangle;
+                    this._cacheRectangle = this._clipConfig.cacheRectangles[this._cacheFrameIndex];
+                    if (this._batchEnabled && !this._cacheRectangle) {
+                        needCacheRectangle = true;
+                        this._cacheRectangle = new egret.Rectangle();
+                        this._clipConfig.cacheRectangles[this._cacheFrameIndex] = this._cacheRectangle;
+                    }
+                    // Update slots.
+                    for (var i = 0, l = this._slots.length; i < l; ++i) {
+                        var slot = this._slots[i];
+                        var clipFrameIndex = this._frameSize * this._cacheFrameIndex + i * 2;
+                        if (clipFrameIndex >= this._clipArray.length) {
+                            clipFrameIndex = this._frameSize * (this._cacheFrameIndex - 1) + i * 2;
+                        }
+                        var displayFrameIndex = this._clipArray[clipFrameIndex] * 2;
+                        if (displayFrameIndex >= 0) {
+                            var displayIndex = displayFrameArray[displayFrameIndex];
+                            var colorIndex = displayFrameArray[displayFrameIndex + 1] * 8;
+                            var transformIndex = this._clipArray[clipFrameIndex + 1] * 6;
+                            var colorChange = false;
+                            if (slot.displayIndex !== displayIndex) {
+                                slot.displayIndex = displayIndex;
+                                colorChange = true;
+                                this._updateSlotDisplay(slot);
+                            }
+                            if (slot.colorIndex !== colorIndex || colorChange) {
+                                slot.colorIndex = colorIndex;
+                                if (slot.colorIndex >= 0) {
+                                    this._updateSlotColor(slot, colorArray[colorIndex] * 0.01, colorArray[colorIndex + 1] * 0.01, colorArray[colorIndex + 2] * 0.01, colorArray[colorIndex + 3] * 0.01, colorArray[colorIndex + 4], colorArray[colorIndex + 5], colorArray[colorIndex + 6], colorArray[colorIndex + 7]);
+                                }
+                                else {
+                                    this._updateSlotColor(slot, 1, 1, 1, 1, 0, 0, 0, 0);
+                                }
+                            }
+                            hasDisplay = true;
+                            if (slot.transformIndex !== transformIndex) {
+                                slot.transformIndex = transformIndex;
+                                if (this._batchEnabled) {
+                                    // RenderNode display.
+                                    var matrix = slot.display.$renderNode.matrix;
+                                    if (!matrix) {
+                                        matrix = slot.display.$renderNode.matrix = new egret.Matrix();
+                                    }
+                                    matrix.a = transformArray[transformIndex];
+                                    matrix.b = transformArray[transformIndex + 1];
+                                    matrix.c = transformArray[transformIndex + 2];
+                                    matrix.d = transformArray[transformIndex + 3];
+                                    matrix.tx = transformArray[transformIndex + 4];
+                                    matrix.ty = transformArray[transformIndex + 5];
+                                }
+                                else {
+                                    // Classic display.
+                                    _helpMatrix.a = transformArray[transformIndex];
+                                    _helpMatrix.b = transformArray[transformIndex + 1];
+                                    _helpMatrix.c = transformArray[transformIndex + 2];
+                                    _helpMatrix.d = transformArray[transformIndex + 3];
+                                    _helpMatrix.tx = transformArray[transformIndex + 4];
+                                    _helpMatrix.ty = transformArray[transformIndex + 5];
+                                    slot.display.$setMatrix(_helpMatrix);
+                                }
+                            }
+                            // 
+                            if (this._batchEnabled && needCacheRectangle && slot.displayConfig) {
+                                // RenderNode display.
+                                var matrix = slot.display.$renderNode.matrix;
+                                _helpRectangle.x = 0;
+                                _helpRectangle.y = 0;
+                                _helpRectangle.width = slot.displayConfig.texture.textureWidth;
+                                _helpRectangle.height = slot.displayConfig.texture.textureHeight;
+                                matrix.$transformBounds(_helpRectangle);
+                                if (isFirst) {
+                                    isFirst = false;
+                                    this._cacheRectangle.x = _helpRectangle.x;
+                                    this._cacheRectangle.width = _helpRectangle.x + _helpRectangle.width;
+                                    this._cacheRectangle.y = _helpRectangle.y;
+                                    this._cacheRectangle.height = _helpRectangle.y + _helpRectangle.height;
+                                }
+                                else {
+                                    this._cacheRectangle.x = Math.min(this._cacheRectangle.x, _helpRectangle.x);
+                                    this._cacheRectangle.width = Math.max(this._cacheRectangle.width, _helpRectangle.x + _helpRectangle.width);
+                                    this._cacheRectangle.y = Math.min(this._cacheRectangle.y, _helpRectangle.y);
+                                    this._cacheRectangle.height = Math.max(this._cacheRectangle.height, _helpRectangle.y + _helpRectangle.height);
+                                }
+                            }
+                        }
+                        else if (slot.displayIndex !== -1) {
+                            slot.displayIndex = -1;
+                            this._updateSlotDisplay(slot);
+                        }
+                    }
+                    //
+                    if (this._cacheRectangle) {
+                        if (hasDisplay && needCacheRectangle && isFirst && prevCacheRectangle) {
+                            this._cacheRectangle.x = prevCacheRectangle.x;
+                            this._cacheRectangle.y = prevCacheRectangle.y;
+                            this._cacheRectangle.width = prevCacheRectangle.width;
+                            this._cacheRectangle.height = prevCacheRectangle.height;
+                        }
+                        if (!dragonBones.isV5) {
+                            this.$invalidateContentBounds();
+                        }
+                    }
+                }
+                if (this._isCompleted) {
+                    this._isPlaying = false;
+                }
+                if (!this._isStarted) {
+                    this._isStarted = true;
+                    if (this.hasEventListener(MovieEvent.START)) {
+                        var event_3 = egret.Event.create(MovieEvent, MovieEvent.START);
+                        event_3.movie = this;
+                        event_3.clipName = this._clipConfig.name;
+                        event_3.name = "";
+                        event_3.slotName = "";
+                        this.dispatchEvent(event_3);
+                    }
+                }
+                this._isReversing = this._currentTime > currentTime && this._currentPlayTimes === currentPlayTimes;
+                this._currentTime = currentTime;
+                // Action and event.
+                var frameCount = this._clipConfig.frame ? this._clipConfig.frame.length : 0;
+                if (frameCount > 0) {
+                    var currentFrameIndex = Math.floor(this._currentTime * this._config.frameRate);
+                    var currentFrameConfig = this._groupConfig.frame[this._clipConfig.frame[currentFrameIndex]];
+                    if (this._currentFrameConfig !== currentFrameConfig) {
+                        if (frameCount > 1) {
+                            var crossedFrameConfig = this._currentFrameConfig;
+                            this._currentFrameConfig = currentFrameConfig;
+                            if (!crossedFrameConfig) {
+                                var prevFrameIndex = Math.floor(this._currentTime * this._config.frameRate);
+                                crossedFrameConfig = this._groupConfig.frame[this._clipConfig.frame[prevFrameIndex]];
+                                if (this._isReversing) {
+                                }
+                                else {
+                                    if (this._currentTime <= crossedFrameConfig.position ||
+                                        this._currentPlayTimes !== currentPlayTimes) {
+                                        crossedFrameConfig = this._groupConfig.frame[crossedFrameConfig.prev];
+                                    }
+                                }
+                            }
+                            if (this._isReversing) {
+                                while (crossedFrameConfig !== currentFrameConfig) {
+                                    this._onCrossFrame(crossedFrameConfig);
+                                    crossedFrameConfig = this._groupConfig.frame[crossedFrameConfig.prev];
+                                }
+                            }
+                            else {
+                                while (crossedFrameConfig !== currentFrameConfig) {
+                                    crossedFrameConfig = this._groupConfig.frame[crossedFrameConfig.next];
+                                    this._onCrossFrame(crossedFrameConfig);
+                                }
+                            }
+                        }
+                        else {
+                            this._currentFrameConfig = currentFrameConfig;
+                            if (this._currentFrameConfig) {
+                                this._onCrossFrame(this._currentFrameConfig);
+                            }
+                        }
+                    }
+                }
+                if (this._currentPlayTimes !== currentPlayTimes) {
+                    this._currentPlayTimes = currentPlayTimes;
+                    if (this.hasEventListener(MovieEvent.LOOP_COMPLETE)) {
+                        var event_4 = egret.Event.create(MovieEvent, MovieEvent.LOOP_COMPLETE);
+                        event_4.movie = this;
+                        event_4.clipName = this._clipConfig.name;
+                        event_4.name = "";
+                        event_4.slotName = "";
+                        this.dispatchEvent(event_4);
+                        egret.Event.release(event_4);
+                    }
+                    if (this._isCompleted && this.hasEventListener(MovieEvent.COMPLETE)) {
+                        var event_5 = egret.Event.create(MovieEvent, MovieEvent.COMPLETE);
+                        event_5.movie = this;
+                        event_5.clipName = this._clipConfig.name;
+                        event_5.name = "";
+                        event_5.slotName = "";
+                        this.dispatchEvent(event_5);
+                        egret.Event.release(event_5);
+                    }
+                }
+            }
+            this._isLockDispose = false;
+            if (this._isDelayDispose) {
+                this.dispose();
+            }
+        };
+        /**
+         * 播放动画剪辑。
+         * @param clipName 动画剪辑的名称，如果未设置，则播放默认动画剪辑，或将暂停状态切换为播放状态，或重新播放上一个正在播放的动画剪辑。
+         * @param playTimes 动画剪辑需要播放的次数。 [-1: 使用动画剪辑默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        Movie.prototype.play = function (clipName, playTimes) {
+            if (clipName === void 0) { clipName = null; }
+            if (playTimes === void 0) { playTimes = -1; }
+            if (clipName) {
+                var clipConfig = null;
+                for (var i = 0, l = this._config.clip.length; i < l; ++i) {
+                    var data = this._config.clip[i];
+                    if (data.name === clipName) {
+                        clipConfig = data;
+                    }
+                }
+                if (clipConfig) {
+                    this._clipConfig = clipConfig;
+                    this._clipArray = new Int16Array(this._groupConfig.arrayBuffer, this._groupConfig.offset + this._groupConfig.position[0] + this._clipConfig.p, this._clipConfig.s / this._groupConfig.position[2]);
+                    if (!this._clipConfig.cacheRectangles) {
+                        this._clipConfig.cacheRectangles = [];
+                    }
+                    this._isPlaying = true;
+                    this._isStarted = false;
+                    this._isCompleted = false;
+                    if (playTimes < 0 || playTimes !== playTimes) {
+                        this._playTimes = this._clipConfig.playTimes;
+                    }
+                    else {
+                        this._playTimes = playTimes;
+                    }
+                    this._time = 0;
+                    this._currentTime = 0;
+                    this._currentPlayTimes = 0;
+                    this._cacheFrameIndex = -1;
+                    this._currentFrameConfig = null;
+                    this._cacheRectangle = null;
+                    this.clipTimeScale = 1 / this._clipConfig.scale;
+                }
+                else {
+                    console.warn("No clip in movie.", this._config.name, clipName);
+                }
+            }
+            else if (this._clipConfig) {
+                if (this._isPlaying || this._isCompleted) {
+                    this.play(this._clipConfig.name, this._playTimes);
+                }
+                else {
+                    this._isPlaying = true;
+                }
+                // playTimes
+            }
+            else if (this._config.action) {
+                this.play(this._config.action, playTimes);
+            }
+        };
+        /**
+         * 暂停播放动画。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        Movie.prototype.stop = function () {
+            this._isPlaying = false;
+        };
+        /**
+         * 从指定时间播放动画。
+         * @param clipName 动画剪辑的名称。
+         * @param time 指定时间。（以秒为单位）
+         * @param playTimes 动画剪辑需要播放的次数。 [-1: 使用动画剪辑默认值, 0: 无限循环播放, [1~N]: 循环播放 N 次]
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        Movie.prototype.gotoAndPlay = function (clipName, time, playTimes) {
+            if (clipName === void 0) { clipName = null; }
+            if (playTimes === void 0) { playTimes = -1; }
+            time %= this._clipConfig.duration;
+            if (time < 0) {
+                time += this._clipConfig.duration;
+            }
+            this.play(clipName, playTimes);
+            this._time = time;
+            this._currentTime = time;
+        };
+        /**
+         * 将动画停止到指定时间。
+         * @param clipName 动画剪辑的名称。
+         * @param time 指定时间。（以秒为单位）
+         * @version DragonBones 5.0
+         * @language zh_CN
+         */
+        Movie.prototype.gotoAndStop = function (clipName, time) {
+            if (clipName === void 0) { clipName = null; }
+            time %= this._clipConfig.duration;
+            if (time < 0) {
+                time += this._clipConfig.duration;
+            }
+            this.play(clipName, 1);
+            this._time = time;
+            this._currentTime = time;
+            this.advanceTime(0.001);
+            this.stop();
+        };
+        /**
+         * 是否包含指定动画剪辑。
+         * @param clipName 动画剪辑的名称。
+         * @version DragonBones 4.7
+         * @language zh_CN
+         */
+        Movie.prototype.hasClip = function (clipName) {
+            for (var i = 0, l = this._config.clip.length; i < l; ++i) {
+                var clip = this._config.clip[i];
+                if (clip.name === clipName) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        Object.defineProperty(Movie.prototype, "isPlaying", {
+            /**
+             * 动画剪辑是否处正在播放。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._isPlaying && !this._isCompleted;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "isComplete", {
+            /**
+             * 动画剪辑是否均播放完毕。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._isCompleted;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "currentTime", {
+            /**
+             * 当前动画剪辑的播放时间。 (以秒为单位)
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._currentTime;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "totalTime", {
+            /**
+             * 当前动画剪辑的总时间。 (以秒为单位)
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._clipConfig ? this._clipConfig.duration : 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "currentPlayTimes", {
+            /**
+             * 当前动画剪辑的播放次数。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._currentPlayTimes;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "playTimes", {
+            /**
+             * 当前动画剪辑需要播放的次数。 [0: 无限循环播放, [1~N]: 循环播放 N 次]
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._playTimes;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "groupName", {
+            get: function () {
+                return this._groupConfig.name;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "clipName", {
+            /**
+             * 正在播放的动画剪辑名称。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._clipConfig ? this._clipConfig.name : "";
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "clipNames", {
+            /**
+             * 所有动画剪辑的名称。
+             * @version DragonBones 4.7
+             * @language zh_CN
+             */
+            get: function () {
+                return this._clipNames;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "clock", {
+            /**
+             * @inheritDoc
+             */
+            get: function () {
+                return this._clock;
+            },
+            set: function (value) {
+                if (this._clock === value) {
+                    return;
+                }
+                var prevClock = this._clock;
+                if (prevClock) {
+                    prevClock.remove(this);
+                }
+                this._clock = value;
+                if (this._clock) {
+                    this._clock.add(this);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * 已废弃，请参考 {@link dragonBones.Movie#clock} {@link dragonBones.Movie#clock} {@link dragonBones.EgretFactory#clock}。
+         * @deprecated
+         * @language zh_CN
+         */
+        Movie.prototype.advanceTimeBySelf = function (on) {
+            if (on) {
+                this.clock = dragonBones.EgretFactory.clock;
+            }
+            else {
+                this.clock = null;
+            }
+        };
+        Object.defineProperty(Movie.prototype, "display", {
+            //========================================= // 兼容旧数据
+            /**
+             * @private
+             */
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "animation", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "armature", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @private
+         */
+        Movie.prototype.getAnimation = function () {
+            return this;
+        };
+        /**
+         * @private
+         */
+        Movie.prototype.getArmature = function () {
+            return this;
+        };
+        /**
+         * @private
+         */
+        Movie.prototype.getDisplay = function () {
+            return this;
+        };
+        /**
+         * @private
+         */
+        Movie.prototype.hasAnimation = function (name) {
+            return this.hasClip(name);
+        };
+        /**
+         * @private
+         */
+        Movie.prototype.invalidUpdate = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            // tslint:disable-next-line:no-unused-expression
+            args;
+        };
+        Object.defineProperty(Movie.prototype, "lastAnimationName", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this.clipName;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "animationNames", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this.clipNames;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Movie.prototype, "animationList", {
+            /**
+             * @private
+             */
+            get: function () {
+                return this.clipNames;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return Movie;
+    }(egret.DisplayObjectContainer));
+    dragonBones.Movie = Movie;
+})(dragonBones || (dragonBones = {}));
diff --git a/demo/libs/modules/dragonBones/dragonBones.min.js b/demo/libs/modules/dragonBones/dragonBones.min.js
new file mode 100644
index 00000000..bfd59c17
--- /dev/null
+++ b/demo/libs/modules/dragonBones/dragonBones.min.js
@@ -0,0 +1 @@
+"use strict";var __extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var a in e)if(e.hasOwnProperty(a))t[a]=e[a]};return function(e,a){t(e,a);function r(){this.constructor=e}e.prototype=a===null?Object.create(a):(r.prototype=a.prototype,new r)}}();var dragonBones;(function(t){})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function e(a){this._clock=new t.WorldClock;this._events=[];this._objects=[];this._eventManager=null;this._eventManager=a;console.info("DragonBones: "+e.VERSION+"\nWebsite: http://dragonbones.com/\nSource and Demo: https://github.com/DragonBones/")}e.prototype.advanceTime=function(e){if(this._objects.length>0){for(var a=0,r=this._objects;a<r.length;a++){var i=r[a];i.returnToPool()}this._objects.length=0}this._clock.advanceTime(e);if(this._events.length>0){for(var n=0;n<this._events.length;++n){var s=this._events[n];var o=s.armature;if(o._armatureData!==null){o.eventDispatcher.dispatchDBEvent(s.type,s);if(s.type===t.EventObject.SOUND_EVENT){this._eventManager.dispatchDBEvent(s.type,s)}}this.bufferObject(s)}this._events.length=0}};e.prototype.bufferEvent=function(t){if(this._events.indexOf(t)<0){this._events.push(t)}};e.prototype.bufferObject=function(t){if(this._objects.indexOf(t)<0){this._objects.push(t)}};Object.defineProperty(e.prototype,"clock",{get:function(){return this._clock},enumerable:true,configurable:true});Object.defineProperty(e.prototype,"eventManager",{get:function(){return this._eventManager},enumerable:true,configurable:true});e.VERSION="5.6.300";e.yDown=true;e.debug=false;e.debugDraw=false;e.webAssembly=false;return e}();t.DragonBones=e})(dragonBones||(dragonBones={}));if(typeof global==="undefined"){var global=window}if(!console.warn){console.warn=function(){}}if(!console.assert){console.assert=function(){}}if(!Date.now){Date.now=function t(){return(new Date).getTime()}}var __extends=function(t,e){function a(){this.constructor=t}for(var r in e){if(e.hasOwnProperty(r)){t[r]=e[r]}}a.prototype=e.prototype,t.prototype=new a};var dragonBones;(function(t){var e=function(){function t(){this.hashCode=t._hashCode++;this._isInPool=false}t._returnObject=function(e){var a=String(e.constructor);var r=a in t._maxCountMap?t._maxCountMap[a]:t._defaultMaxCount;var i=t._poolsMap[a]=t._poolsMap[a]||[];if(i.length<r){if(!e._isInPool){e._isInPool=true;i.push(e)}else{console.warn("The object is already in the pool.")}}else{}};t.toString=function(){throw new Error};t.setMaxCount=function(e,a){if(a<0||a!==a){a=0}if(e!==null){var r=String(e);var i=r in t._poolsMap?t._poolsMap[r]:null;if(i!==null&&i.length>a){i.length=a}t._maxCountMap[r]=a}else{t._defaultMaxCount=a;for(var r in t._poolsMap){var i=t._poolsMap[r];if(i.length>a){i.length=a}if(r in t._maxCountMap){t._maxCountMap[r]=a}}}};t.clearPool=function(e){if(e===void 0){e=null}if(e!==null){var a=String(e);var r=a in t._poolsMap?t._poolsMap[a]:null;if(r!==null&&r.length>0){r.length=0}}else{for(var i in t._poolsMap){var r=t._poolsMap[i];r.length=0}}};t.borrowObject=function(e){var a=String(e);var r=a in t._poolsMap?t._poolsMap[a]:null;if(r!==null&&r.length>0){var i=r.pop();i._isInPool=false;return i}var n=new e;n._onClear();return n};t.prototype.returnToPool=function(){this._onClear();t._returnObject(this)};t._hashCode=0;t._defaultMaxCount=3e3;t._maxCountMap={};t._poolsMap={};return t}();t.BaseObject=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function t(t,e,a,r,i,n){if(t===void 0){t=1}if(e===void 0){e=0}if(a===void 0){a=0}if(r===void 0){r=1}if(i===void 0){i=0}if(n===void 0){n=0}this.a=t;this.b=e;this.c=a;this.d=r;this.tx=i;this.ty=n}t.prototype.toString=function(){return"[object dragonBones.Matrix] a:"+this.a+" b:"+this.b+" c:"+this.c+" d:"+this.d+" tx:"+this.tx+" ty:"+this.ty};t.prototype.copyFrom=function(t){this.a=t.a;this.b=t.b;this.c=t.c;this.d=t.d;this.tx=t.tx;this.ty=t.ty;return this};t.prototype.copyFromArray=function(t,e){if(e===void 0){e=0}this.a=t[e];this.b=t[e+1];this.c=t[e+2];this.d=t[e+3];this.tx=t[e+4];this.ty=t[e+5];return this};t.prototype.identity=function(){this.a=this.d=1;this.b=this.c=0;this.tx=this.ty=0;return this};t.prototype.concat=function(t){var e=this.a*t.a;var a=0;var r=0;var i=this.d*t.d;var n=this.tx*t.a+t.tx;var s=this.ty*t.d+t.ty;if(this.b!==0||this.c!==0){e+=this.b*t.c;a+=this.b*t.d;r+=this.c*t.a;i+=this.c*t.b}if(t.b!==0||t.c!==0){a+=this.a*t.b;r+=this.d*t.c;n+=this.ty*t.c;s+=this.tx*t.b}this.a=e;this.b=a;this.c=r;this.d=i;this.tx=n;this.ty=s;return this};t.prototype.invert=function(){var t=this.a;var e=this.b;var a=this.c;var r=this.d;var i=this.tx;var n=this.ty;if(e===0&&a===0){this.b=this.c=0;if(t===0||r===0){this.a=this.b=this.tx=this.ty=0}else{t=this.a=1/t;r=this.d=1/r;this.tx=-t*i;this.ty=-r*n}return this}var s=t*r-e*a;if(s===0){this.a=this.d=1;this.b=this.c=0;this.tx=this.ty=0;return this}s=1/s;var o=this.a=r*s;e=this.b=-e*s;a=this.c=-a*s;r=this.d=t*s;this.tx=-(o*i+a*n);this.ty=-(e*i+r*n);return this};t.prototype.transformPoint=function(t,e,a,r){if(r===void 0){r=false}a.x=this.a*t+this.c*e;a.y=this.b*t+this.d*e;if(!r){a.x+=this.tx;a.y+=this.ty}};t.prototype.transformRectangle=function(t,e){if(e===void 0){e=false}var a=this.a;var r=this.b;var i=this.c;var n=this.d;var s=e?0:this.tx;var o=e?0:this.ty;var l=t.x;var h=t.y;var f=l+t.width;var u=h+t.height;var _=a*l+i*h+s;var c=r*l+n*h+o;var p=a*f+i*h+s;var m=r*f+n*h+o;var d=a*f+i*u+s;var v=r*f+n*u+o;var y=a*l+i*u+s;var g=r*l+n*u+o;var b=0;if(_>p){b=_;_=p;p=b}if(d>y){b=d;d=y;y=b}t.x=Math.floor(_<d?_:d);t.width=Math.ceil((p>y?p:y)-t.x);if(c>m){b=c;c=m;m=b}if(v>g){b=v;v=g;g=b}t.y=Math.floor(c<v?c:v);t.height=Math.ceil((m>g?m:g)-t.y)};return t}();t.Matrix=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function t(t,e,a,r,i,n){if(t===void 0){t=0}if(e===void 0){e=0}if(a===void 0){a=0}if(r===void 0){r=0}if(i===void 0){i=1}if(n===void 0){n=1}this.x=t;this.y=e;this.skew=a;this.rotation=r;this.scaleX=i;this.scaleY=n}t.normalizeRadian=function(t){t=(t+Math.PI)%(Math.PI*2);t+=t>0?-Math.PI:Math.PI;return t};t.prototype.toString=function(){return"[object dragonBones.Transform] x:"+this.x+" y:"+this.y+" skewX:"+this.skew*180/Math.PI+" skewY:"+this.rotation*180/Math.PI+" scaleX:"+this.scaleX+" scaleY:"+this.scaleY};t.prototype.copyFrom=function(t){this.x=t.x;this.y=t.y;this.skew=t.skew;this.rotation=t.rotation;this.scaleX=t.scaleX;this.scaleY=t.scaleY;return this};t.prototype.identity=function(){this.x=this.y=0;this.skew=this.rotation=0;this.scaleX=this.scaleY=1;return this};t.prototype.add=function(t){this.x+=t.x;this.y+=t.y;this.skew+=t.skew;this.rotation+=t.rotation;this.scaleX*=t.scaleX;this.scaleY*=t.scaleY;return this};t.prototype.minus=function(t){this.x-=t.x;this.y-=t.y;this.skew-=t.skew;this.rotation-=t.rotation;this.scaleX/=t.scaleX;this.scaleY/=t.scaleY;return this};t.prototype.fromMatrix=function(e){var a=this.scaleX,r=this.scaleY;var i=t.PI_Q;this.x=e.tx;this.y=e.ty;this.rotation=Math.atan(e.b/e.a);var n=Math.atan(-e.c/e.d);this.scaleX=this.rotation>-i&&this.rotation<i?e.a/Math.cos(this.rotation):e.b/Math.sin(this.rotation);this.scaleY=n>-i&&n<i?e.d/Math.cos(n):-e.c/Math.sin(n);if(a>=0&&this.scaleX<0){this.scaleX=-this.scaleX;this.rotation=this.rotation-Math.PI}if(r>=0&&this.scaleY<0){this.scaleY=-this.scaleY;n=n-Math.PI}this.skew=n-this.rotation;return this};t.prototype.toMatrix=function(t){if(this.rotation===0){t.a=1;t.b=0}else{t.a=Math.cos(this.rotation);t.b=Math.sin(this.rotation)}if(this.skew===0){t.c=-t.b;t.d=t.a}else{t.c=-Math.sin(this.skew+this.rotation);t.d=Math.cos(this.skew+this.rotation)}if(this.scaleX!==1){t.a*=this.scaleX;t.b*=this.scaleX}if(this.scaleY!==1){t.c*=this.scaleY;t.d*=this.scaleY}t.tx=this.x;t.ty=this.y;return this};t.PI=Math.PI;t.PI_D=Math.PI*2;t.PI_H=Math.PI/2;t.PI_Q=Math.PI/4;t.RAD_DEG=180/Math.PI;t.DEG_RAD=Math.PI/180;return t}();t.Transform=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function t(t,e,a,r,i,n,s,o){if(t===void 0){t=1}if(e===void 0){e=1}if(a===void 0){a=1}if(r===void 0){r=1}if(i===void 0){i=0}if(n===void 0){n=0}if(s===void 0){s=0}if(o===void 0){o=0}this.alphaMultiplier=t;this.redMultiplier=e;this.greenMultiplier=a;this.blueMultiplier=r;this.alphaOffset=i;this.redOffset=n;this.greenOffset=s;this.blueOffset=o}t.prototype.copyFrom=function(t){this.alphaMultiplier=t.alphaMultiplier;this.redMultiplier=t.redMultiplier;this.greenMultiplier=t.greenMultiplier;this.blueMultiplier=t.blueMultiplier;this.alphaOffset=t.alphaOffset;this.redOffset=t.redOffset;this.greenOffset=t.greenOffset;this.blueOffset=t.blueOffset};t.prototype.identity=function(){this.alphaMultiplier=this.redMultiplier=this.greenMultiplier=this.blueMultiplier=1;this.alphaOffset=this.redOffset=this.greenOffset=this.blueOffset=0};return t}();t.ColorTransform=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function t(t,e){if(t===void 0){t=0}if(e===void 0){e=0}this.x=t;this.y=e}t.prototype.copyFrom=function(t){this.x=t.x;this.y=t.y};t.prototype.clear=function(){this.x=this.y=0};return t}();t.Point=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function t(t,e,a,r){if(t===void 0){t=0}if(e===void 0){e=0}if(a===void 0){a=0}if(r===void 0){r=0}this.x=t;this.y=e;this.width=a;this.height=r}t.prototype.copyFrom=function(t){this.x=t.x;this.y=t.y;this.width=t.width;this.height=t.height};t.prototype.clear=function(){this.x=this.y=0;this.width=this.height=0};return t}();t.Rectangle=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.ints=[];e.floats=[];e.strings=[];return e}e.toString=function(){return"[class dragonBones.UserData]"};e.prototype._onClear=function(){this.ints.length=0;this.floats.length=0;this.strings.length=0};e.prototype.addInt=function(t){this.ints.push(t)};e.prototype.addFloat=function(t){this.floats.push(t)};e.prototype.addString=function(t){this.strings.push(t)};e.prototype.getInt=function(t){if(t===void 0){t=0}return t>=0&&t<this.ints.length?this.ints[t]:0};e.prototype.getFloat=function(t){if(t===void 0){t=0}return t>=0&&t<this.floats.length?this.floats[t]:0};e.prototype.getString=function(t){if(t===void 0){t=0}return t>=0&&t<this.strings.length?this.strings[t]:""};return e}(t.BaseObject);t.UserData=e;var a=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.data=null;return e}e.toString=function(){return"[class dragonBones.ActionData]"};e.prototype._onClear=function(){if(this.data!==null){this.data.returnToPool()}this.type=0;this.name="";this.bone=null;this.slot=null;this.data=null};return e}(t.BaseObject);t.ActionData=a})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.frameIndices=[];e.cachedFrames=[];e.armatureNames=[];e.armatures={};e.userData=null;return e}e.toString=function(){return"[class dragonBones.DragonBonesData]"};e.prototype._onClear=function(){for(var t in this.armatures){this.armatures[t].returnToPool();delete this.armatures[t]}if(this.userData!==null){this.userData.returnToPool()}this.autoSearch=false;this.frameRate=0;this.version="";this.name="";this.stage=null;this.frameIndices.length=0;this.cachedFrames.length=0;this.armatureNames.length=0;this.binary=null;this.intArray=null;this.floatArray=null;this.frameIntArray=null;this.frameFloatArray=null;this.frameArray=null;this.timelineArray=null;this.userData=null};e.prototype.addArmature=function(t){if(t.name in this.armatures){console.warn("Same armature: "+t.name);return}t.parent=this;this.armatures[t.name]=t;this.armatureNames.push(t.name)};e.prototype.getArmature=function(t){return t in this.armatures?this.armatures[t]:null};e.prototype.dispose=function(){console.warn("已废弃");this.returnToPool()};return e}(t.BaseObject);t.DragonBonesData=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.aabb=new t.Rectangle;a.animationNames=[];a.sortedBones=[];a.sortedSlots=[];a.defaultActions=[];a.actions=[];a.bones={};a.slots={};a.constraints={};a.skins={};a.animations={};a.canvas=null;a.userData=null;return a}a.toString=function(){return"[class dragonBones.ArmatureData]"};a.prototype._onClear=function(){for(var t=0,e=this.defaultActions;t<e.length;t++){var a=e[t];a.returnToPool()}for(var r=0,i=this.actions;r<i.length;r++){var a=i[r];a.returnToPool()}for(var n in this.bones){this.bones[n].returnToPool();delete this.bones[n]}for(var n in this.slots){this.slots[n].returnToPool();delete this.slots[n]}for(var n in this.constraints){this.constraints[n].returnToPool();delete this.constraints[n]}for(var n in this.skins){this.skins[n].returnToPool();delete this.skins[n]}for(var n in this.animations){this.animations[n].returnToPool();delete this.animations[n]}if(this.canvas!==null){this.canvas.returnToPool()}if(this.userData!==null){this.userData.returnToPool()}this.type=0;this.frameRate=0;this.cacheFrameRate=0;this.scale=1;this.name="";this.aabb.clear();this.animationNames.length=0;this.sortedBones.length=0;this.sortedSlots.length=0;this.defaultActions.length=0;this.actions.length=0;this.defaultSkin=null;this.defaultAnimation=null;this.canvas=null;this.userData=null;this.parent=null};a.prototype.sortBones=function(){var t=this.sortedBones.length;if(t<=0){return}var e=this.sortedBones.concat();var a=0;var r=0;this.sortedBones.length=0;while(r<t){var i=e[a++];if(a>=t){a=0}if(this.sortedBones.indexOf(i)>=0){continue}var n=false;for(var s in this.constraints){var o=this.constraints[s];if(o.root===i&&this.sortedBones.indexOf(o.target)<0){n=true;break}}if(n){continue}if(i.parent!==null&&this.sortedBones.indexOf(i.parent)<0){continue}this.sortedBones.push(i);r++}};a.prototype.cacheFrames=function(t){if(this.cacheFrameRate>0){return}this.cacheFrameRate=t;for(var e in this.animations){this.animations[e].cacheFrames(this.cacheFrameRate)}};a.prototype.setCacheFrame=function(t,e){var a=this.parent.cachedFrames;var r=a.length;a.length+=10;a[r]=t.a;a[r+1]=t.b;a[r+2]=t.c;a[r+3]=t.d;a[r+4]=t.tx;a[r+5]=t.ty;a[r+6]=e.rotation;a[r+7]=e.skew;a[r+8]=e.scaleX;a[r+9]=e.scaleY;return r};a.prototype.getCacheFrame=function(t,e,a){var r=this.parent.cachedFrames;t.a=r[a];t.b=r[a+1];t.c=r[a+2];t.d=r[a+3];t.tx=r[a+4];t.ty=r[a+5];e.rotation=r[a+6];e.skew=r[a+7];e.scaleX=r[a+8];e.scaleY=r[a+9];e.x=t.tx;e.y=t.ty};a.prototype.addBone=function(t){if(t.name in this.bones){console.warn("Same bone: "+t.name);return}this.bones[t.name]=t;this.sortedBones.push(t)};a.prototype.addSlot=function(t){if(t.name in this.slots){console.warn("Same slot: "+t.name);return}this.slots[t.name]=t;this.sortedSlots.push(t)};a.prototype.addConstraint=function(t){if(t.name in this.constraints){console.warn("Same constraint: "+t.name);return}this.constraints[t.name]=t};a.prototype.addSkin=function(t){if(t.name in this.skins){console.warn("Same skin: "+t.name);return}t.parent=this;this.skins[t.name]=t;if(this.defaultSkin===null){this.defaultSkin=t}if(t.name==="default"){this.defaultSkin=t}};a.prototype.addAnimation=function(t){if(t.name in this.animations){console.warn("Same animation: "+t.name);return}t.parent=this;this.animations[t.name]=t;this.animationNames.push(t.name);if(this.defaultAnimation===null){this.defaultAnimation=t}};a.prototype.addAction=function(t,e){if(e){this.defaultActions.push(t)}else{this.actions.push(t)}};a.prototype.getBone=function(t){return t in this.bones?this.bones[t]:null};a.prototype.getSlot=function(t){return t in this.slots?this.slots[t]:null};a.prototype.getConstraint=function(t){return t in this.constraints?this.constraints[t]:null};a.prototype.getSkin=function(t){return t in this.skins?this.skins[t]:null};a.prototype.getMesh=function(t,e,a){var r=this.getSkin(t);if(r===null){return null}return r.getDisplay(e,a)};a.prototype.getAnimation=function(t){return t in this.animations?this.animations[t]:null};return a}(t.BaseObject);t.ArmatureData=e;var a=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.transform=new t.Transform;a.userData=null;return a}a.toString=function(){return"[class dragonBones.BoneData]"};a.prototype._onClear=function(){if(this.userData!==null){this.userData.returnToPool()}this.inheritTranslation=false;this.inheritRotation=false;this.inheritScale=false;this.inheritReflection=false;this.type=0;this.length=0;this.name="";this.transform.identity();this.userData=null;this.parent=null};return a}(t.BaseObject);t.BoneData=a;var r=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.vertices=[];return e}e.toString=function(){return"[class dragonBones.SurfaceData]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.type=1;this.segmentX=0;this.segmentY=0;this.vertices.length=0};return e}(a);t.SurfaceData=r;var i=function(e){__extends(a,e);function a(){var t=e!==null&&e.apply(this,arguments)||this;t.color=null;t.userData=null;return t}a.createColor=function(){return new t.ColorTransform};a.toString=function(){return"[class dragonBones.SlotData]"};a.prototype._onClear=function(){if(this.userData!==null){this.userData.returnToPool()}this.blendMode=0;this.displayIndex=0;this.zOrder=0;this.name="";this.color=null;this.userData=null;this.parent=null};a.DEFAULT_COLOR=new t.ColorTransform;return a}(t.BaseObject);t.SlotData=i})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.CanvasData]"};e.prototype._onClear=function(){this.hasBackground=false;this.color=0;this.x=0;this.y=0;this.width=0;this.height=0};return e}(t.BaseObject);t.CanvasData=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.displays={};return e}e.toString=function(){return"[class dragonBones.SkinData]"};e.prototype._onClear=function(){for(var t in this.displays){var e=this.displays[t];for(var a=0,r=e;a<r.length;a++){var i=r[a];if(i!==null){i.returnToPool()}}delete this.displays[t]}this.name="";this.parent=null};e.prototype.addDisplay=function(t,e){if(!(t in this.displays)){this.displays[t]=[]}if(e!==null){e.parent=this}var a=this.displays[t];a.push(e)};e.prototype.getDisplay=function(t,e){var a=this.getDisplays(t);if(a!==null){for(var r=0,i=a;r<i.length;r++){var n=i[r];if(n!==null&&n.name===e){return n}}}return null};e.prototype.getDisplays=function(t){if(!(t in this.displays)){return null}return this.displays[t]};return e}(t.BaseObject);t.SkinData=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.prototype._onClear=function(){this.order=0;this.name="";this.type=0;this.target=null;this.root=null;this.bone=null};return e}(t.BaseObject);t.ConstraintData=e;var a=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.IKConstraintData]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.scaleEnabled=false;this.bendPositive=false;this.weight=1};return e}(e);t.IKConstraintData=a;var r=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.bones=[];return e}e.toString=function(){return"[class dragonBones.PathConstraintData]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.pathSlot=null;this.pathDisplayData=null;this.bones.length=0;this.positionMode=0;this.spacingMode=1;this.rotateMode=1;this.position=0;this.spacing=0;this.rotateOffset=0;this.rotateMix=0;this.translateMix=0};e.prototype.AddBone=function(t){this.bones.push(t)};return e}(e);t.PathConstraintData=r})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function t(){this.weight=null}t.prototype.clear=function(){if(!this.isShared&&this.weight!==null){this.weight.returnToPool()}this.isShared=false;this.inheritDeform=false;this.offset=0;this.data=null;this.weight=null};t.prototype.shareFrom=function(t){this.isShared=true;this.offset=t.offset;this.weight=t.weight};return t}();t.VerticesData=e;var a=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.transform=new t.Transform;return a}a.prototype._onClear=function(){this.name="";this.path="";this.transform.identity();this.parent=null};return a}(t.BaseObject);t.DisplayData=a;var r=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.pivot=new t.Point;return a}a.toString=function(){return"[class dragonBones.ImageDisplayData]"};a.prototype._onClear=function(){e.prototype._onClear.call(this);this.type=0;this.pivot.clear();this.texture=null};return a}(a);t.ImageDisplayData=r;var i=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.actions=[];return e}e.toString=function(){return"[class dragonBones.ArmatureDisplayData]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);for(var e=0,a=this.actions;e<a.length;e++){var r=a[e];r.returnToPool()}this.type=1;this.inheritAnimation=false;this.actions.length=0;this.armature=null};e.prototype.addAction=function(t){this.actions.push(t)};return e}(a);t.ArmatureDisplayData=i;var n=function(t){__extends(a,t);function a(){var a=t!==null&&t.apply(this,arguments)||this;a.vertices=new e;return a}a.toString=function(){return"[class dragonBones.MeshDisplayData]"};a.prototype._onClear=function(){t.prototype._onClear.call(this);this.type=2;this.vertices.clear();this.texture=null};return a}(a);t.MeshDisplayData=n;var s=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.boundingBox=null;return e}e.toString=function(){return"[class dragonBones.BoundingBoxDisplayData]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);if(this.boundingBox!==null){this.boundingBox.returnToPool()}this.type=3;this.boundingBox=null};return e}(a);t.BoundingBoxDisplayData=s;var o=function(t){__extends(a,t);function a(){var a=t!==null&&t.apply(this,arguments)||this;a.vertices=new e;a.curveLengths=[];return a}a.toString=function(){return"[class dragonBones.PathDisplayData]"};a.prototype._onClear=function(){t.prototype._onClear.call(this);this.type=4;this.closed=false;this.constantSpeed=false;this.vertices.clear();this.curveLengths.length=0};return a}(a);t.PathDisplayData=o;var l=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.bones=[];return e}e.toString=function(){return"[class dragonBones.WeightData]"};e.prototype._onClear=function(){this.count=0;this.offset=0;this.bones.length=0};e.prototype.addBone=function(t){this.bones.push(t)};return e}(t.BaseObject);t.WeightData=l})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.prototype._onClear=function(){this.color=0;this.width=0;this.height=0};return e}(t.BaseObject);t.BoundingBoxData=e;var a=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.RectangleBoundingBoxData]"};e._computeOutCode=function(t,e,a,r,i,n){var s=0;if(t<a){s|=1}else if(t>i){s|=2}if(e<r){s|=4}else if(e>n){s|=8}return s};e.rectangleIntersectsSegment=function(t,a,r,i,n,s,o,l,h,f,u){if(h===void 0){h=null}if(f===void 0){f=null}if(u===void 0){u=null}var _=t>n&&t<o&&a>s&&a<l;var c=r>n&&r<o&&i>s&&i<l;if(_&&c){return-1}var p=0;var m=e._computeOutCode(t,a,n,s,o,l);var d=e._computeOutCode(r,i,n,s,o,l);while(true){if((m|d)===0){p=2;break}else if((m&d)!==0){break}var v=0;var y=0;var g=0;var b=m!==0?m:d;if((b&4)!==0){v=t+(r-t)*(s-a)/(i-a);y=s;if(u!==null){g=-Math.PI*.5}}else if((b&8)!==0){v=t+(r-t)*(l-a)/(i-a);y=l;if(u!==null){g=Math.PI*.5}}else if((b&2)!==0){y=a+(i-a)*(o-t)/(r-t);v=o;if(u!==null){g=0}}else if((b&1)!==0){y=a+(i-a)*(n-t)/(r-t);v=n;if(u!==null){g=Math.PI}}if(b===m){t=v;a=y;m=e._computeOutCode(t,a,n,s,o,l);if(u!==null){u.x=g}}else{r=v;i=y;d=e._computeOutCode(r,i,n,s,o,l);if(u!==null){u.y=g}}}if(p){if(_){p=2;if(h!==null){h.x=r;h.y=i}if(f!==null){f.x=r;f.y=r}if(u!==null){u.x=u.y+Math.PI}}else if(c){p=1;if(h!==null){h.x=t;h.y=a}if(f!==null){f.x=t;f.y=a}if(u!==null){u.y=u.x+Math.PI}}else{p=3;if(h!==null){h.x=t;h.y=a}if(f!==null){f.x=r;f.y=i}}}return p};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.type=0};e.prototype.containsPoint=function(t,e){var a=this.width*.5;if(t>=-a&&t<=a){var r=this.height*.5;if(e>=-r&&e<=r){return true}}return false};e.prototype.intersectsSegment=function(t,a,r,i,n,s,o){if(n===void 0){n=null}if(s===void 0){s=null}if(o===void 0){o=null}var l=this.width*.5;var h=this.height*.5;var f=e.rectangleIntersectsSegment(t,a,r,i,-l,-h,l,h,n,s,o);return f};return e}(e);t.RectangleBoundingBoxData=a;var r=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.EllipseData]"};e.ellipseIntersectsSegment=function(t,e,a,r,i,n,s,o,l,h,f){if(l===void 0){l=null}if(h===void 0){h=null}if(f===void 0){f=null}var u=s/o;var _=u*u;e*=u;r*=u;var c=a-t;var p=r-e;var m=Math.sqrt(c*c+p*p);var d=c/m;var v=p/m;var y=(i-t)*d+(n-e)*v;var g=y*y;var b=t*t+e*e;var D=s*s;var T=D-b+g;var A=0;if(T>=0){var x=Math.sqrt(T);var P=y-x;var O=y+x;var S=P<0?-1:P<=m?0:1;var E=O<0?-1:O<=m?0:1;var M=S*E;if(M<0){return-1}else if(M===0){if(S===-1){A=2;a=t+O*d;r=(e+O*v)/u;if(l!==null){l.x=a;l.y=r}if(h!==null){h.x=a;h.y=r}if(f!==null){f.x=Math.atan2(r/D*_,a/D);f.y=f.x+Math.PI}}else if(E===1){A=1;t=t+P*d;e=(e+P*v)/u;if(l!==null){l.x=t;l.y=e}if(h!==null){h.x=t;h.y=e}if(f!==null){f.x=Math.atan2(e/D*_,t/D);f.y=f.x+Math.PI}}else{A=3;if(l!==null){l.x=t+P*d;l.y=(e+P*v)/u;if(f!==null){f.x=Math.atan2(l.y/D*_,l.x/D)}}if(h!==null){h.x=t+O*d;h.y=(e+O*v)/u;if(f!==null){f.y=Math.atan2(h.y/D*_,h.x/D)}}}}}return A};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.type=1};e.prototype.containsPoint=function(t,e){var a=this.width*.5;if(t>=-a&&t<=a){var r=this.height*.5;if(e>=-r&&e<=r){e*=a/r;return Math.sqrt(t*t+e*e)<=a}}return false};e.prototype.intersectsSegment=function(t,a,r,i,n,s,o){if(n===void 0){n=null}if(s===void 0){s=null}if(o===void 0){o=null}var l=e.ellipseIntersectsSegment(t,a,r,i,0,0,this.width*.5,this.height*.5,n,s,o);return l};return e}(e);t.EllipseBoundingBoxData=r;var i=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.vertices=[];return e}e.toString=function(){return"[class dragonBones.PolygonBoundingBoxData]"};e.polygonIntersectsSegment=function(t,e,a,r,i,n,s,o){if(n===void 0){n=null}if(s===void 0){s=null}if(o===void 0){o=null}if(t===a){t=a+1e-6}if(e===r){e=r+1e-6}var l=i.length;var h=t-a;var f=e-r;var u=t*r-e*a;var _=0;var c=i[l-2];var p=i[l-1];var m=0;var d=0;var v=0;var y=0;var g=0;var b=0;for(var D=0;D<l;D+=2){var T=i[D];var A=i[D+1];if(c===T){c=T+1e-4}if(p===A){p=A+1e-4}var x=c-T;var P=p-A;var O=c*A-p*T;var S=h*P-f*x;var E=(u*x-h*O)/S;if((E>=c&&E<=T||E>=T&&E<=c)&&(h===0||E>=t&&E<=a||E>=a&&E<=t)){var M=(u*P-f*O)/S;if((M>=p&&M<=A||M>=A&&M<=p)&&(f===0||M>=e&&M<=r||M>=r&&M<=e)){if(s!==null){var B=E-t;if(B<0){B=-B}if(_===0){m=B;d=B;v=E;y=M;g=E;b=M;if(o!==null){o.x=Math.atan2(A-p,T-c)-Math.PI*.5;o.y=o.x}}else{if(B<m){m=B;v=E;y=M;if(o!==null){o.x=Math.atan2(A-p,T-c)-Math.PI*.5}}if(B>d){d=B;g=E;b=M;if(o!==null){o.y=Math.atan2(A-p,T-c)-Math.PI*.5}}}_++}else{v=E;y=M;g=E;b=M;_++;if(o!==null){o.x=Math.atan2(A-p,T-c)-Math.PI*.5;o.y=o.x}break}}}c=T;p=A}if(_===1){if(n!==null){n.x=v;n.y=y}if(s!==null){s.x=v;s.y=y}if(o!==null){o.y=o.x+Math.PI}}else if(_>1){_++;if(n!==null){n.x=v;n.y=y}if(s!==null){s.x=g;s.y=b}}return _};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.type=2;this.x=0;this.y=0;this.vertices.length=0};e.prototype.containsPoint=function(t,e){var a=false;if(t>=this.x&&t<=this.width&&e>=this.y&&e<=this.height){for(var r=0,i=this.vertices.length,n=i-2;r<i;r+=2){var s=this.vertices[n+1];var o=this.vertices[r+1];if(o<e&&s>=e||s<e&&o>=e){var l=this.vertices[n];var h=this.vertices[r];if((e-o)*(l-h)/(s-o)+h<t){a=!a}}n=r}}return a};e.prototype.intersectsSegment=function(t,r,i,n,s,o,l){if(s===void 0){s=null}if(o===void 0){o=null}if(l===void 0){l=null}var h=0;if(a.rectangleIntersectsSegment(t,r,i,n,this.x,this.y,this.x+this.width,this.y+this.height,null,null,null)!==0){h=e.polygonIntersectsSegment(t,r,i,n,this.vertices,s,o,l)}return h};return e}(e);t.PolygonBoundingBoxData=i})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.cachedFrames=[];e.boneTimelines={};e.surfaceTimelines={};e.slotTimelines={};e.constraintTimelines={};e.animationTimelines={};e.boneCachedFrameIndices={};e.slotCachedFrameIndices={};e.actionTimeline=null;e.zOrderTimeline=null;return e}e.toString=function(){return"[class dragonBones.AnimationData]"};e.prototype._onClear=function(){for(var t in this.boneTimelines){for(var e=0,a=this.boneTimelines[t];e<a.length;e++){var r=a[e];r.returnToPool()}delete this.boneTimelines[t]}for(var t in this.surfaceTimelines){for(var i=0,n=this.surfaceTimelines[t];i<n.length;i++){var r=n[i];r.returnToPool()}delete this.surfaceTimelines[t]}for(var t in this.slotTimelines){for(var s=0,o=this.slotTimelines[t];s<o.length;s++){var r=o[s];r.returnToPool()}delete this.slotTimelines[t]}for(var t in this.constraintTimelines){for(var l=0,h=this.constraintTimelines[t];l<h.length;l++){var r=h[l];r.returnToPool()}delete this.constraintTimelines[t]}for(var t in this.animationTimelines){for(var f=0,u=this.animationTimelines[t];f<u.length;f++){var r=u[f];r.returnToPool()}delete this.animationTimelines[t]}for(var t in this.boneCachedFrameIndices){delete this.boneCachedFrameIndices[t]}for(var t in this.slotCachedFrameIndices){delete this.slotCachedFrameIndices[t]}if(this.actionTimeline!==null){this.actionTimeline.returnToPool()}if(this.zOrderTimeline!==null){this.zOrderTimeline.returnToPool()}this.frameIntOffset=0;this.frameFloatOffset=0;this.frameOffset=0;this.frameCount=0;this.playTimes=0;this.duration=0;this.scale=1;this.fadeInTime=0;this.cacheFrameRate=0;this.name="";this.cachedFrames.length=0;this.actionTimeline=null;this.zOrderTimeline=null;this.parent=null};e.prototype.cacheFrames=function(t){if(this.cacheFrameRate>0){return}this.cacheFrameRate=Math.max(Math.ceil(t*this.scale),1);var e=Math.ceil(this.cacheFrameRate*this.duration)+1;this.cachedFrames.length=e;for(var a=0,r=this.cacheFrames.length;a<r;++a){this.cachedFrames[a]=false}for(var i=0,n=this.parent.sortedBones;i<n.length;i++){var s=n[i];var o=new Array(e);for(var a=0,r=o.length;a<r;++a){o[a]=-1}this.boneCachedFrameIndices[s.name]=o}for(var l=0,h=this.parent.sortedSlots;l<h.length;l++){var f=h[l];var o=new Array(e);for(var a=0,r=o.length;a<r;++a){o[a]=-1}this.slotCachedFrameIndices[f.name]=o}};e.prototype.addBoneTimeline=function(t,e){var a=t.name in this.boneTimelines?this.boneTimelines[t.name]:this.boneTimelines[t.name]=[];if(a.indexOf(e)<0){a.push(e)}};e.prototype.addSurfaceTimeline=function(t,e){var a=t.name in this.surfaceTimelines?this.surfaceTimelines[t.name]:this.surfaceTimelines[t.name]=[];if(a.indexOf(e)<0){a.push(e)}};e.prototype.addSlotTimeline=function(t,e){var a=t.name in this.slotTimelines?this.slotTimelines[t.name]:this.slotTimelines[t.name]=[];if(a.indexOf(e)<0){a.push(e)}};e.prototype.addConstraintTimeline=function(t,e){var a=t.name in this.constraintTimelines?this.constraintTimelines[t.name]:this.constraintTimelines[t.name]=[];if(a.indexOf(e)<0){a.push(e)}};e.prototype.addAnimationTimeline=function(t,e){var a=t in this.animationTimelines?this.animationTimelines[t]:this.animationTimelines[t]=[];if(a.indexOf(e)<0){a.push(e)}};e.prototype.getBoneTimelines=function(t){return t in this.boneTimelines?this.boneTimelines[t]:null};e.prototype.getSurfaceTimelines=function(t){return t in this.surfaceTimelines?this.surfaceTimelines[t]:null};e.prototype.getSlotTimelines=function(t){return t in this.slotTimelines?this.slotTimelines[t]:null};e.prototype.getConstraintTimelines=function(t){return t in this.constraintTimelines?this.constraintTimelines[t]:null};e.prototype.getAnimationTimelines=function(t){return t in this.animationTimelines?this.animationTimelines[t]:null};e.prototype.getBoneCachedFrameIndices=function(t){return t in this.boneCachedFrameIndices?this.boneCachedFrameIndices[t]:null};e.prototype.getSlotCachedFrameIndices=function(t){return t in this.slotCachedFrameIndices?this.slotCachedFrameIndices[t]:null};return e}(t.BaseObject);t.AnimationData=e;var a=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.TimelineData]"};e.prototype._onClear=function(){this.type=10;this.offset=0;this.frameIndicesOffset=-1};return e}(t.BaseObject);t.TimelineData=a})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.boneMask=[];return e}e.toString=function(){return"[class dragonBones.AnimationConfig]"};e.prototype._onClear=function(){this.pauseFadeOut=true;this.fadeOutMode=4;this.fadeOutTweenType=1;this.fadeOutTime=-1;this.actionEnabled=true;this.additiveBlending=false;this.displayControl=true;this.pauseFadeIn=true;this.resetToPose=true;this.fadeInTweenType=1;this.playTimes=-1;this.layer=0;this.position=0;this.duration=-1;this.timeScale=-100;this.weight=1;this.fadeInTime=-1;this.autoFadeOutTime=-1;this.name="";this.animation="";this.group="";this.boneMask.length=0};e.prototype.clear=function(){this._onClear()};e.prototype.copyFrom=function(t){this.pauseFadeOut=t.pauseFadeOut;this.fadeOutMode=t.fadeOutMode;this.autoFadeOutTime=t.autoFadeOutTime;this.fadeOutTweenType=t.fadeOutTweenType;this.actionEnabled=t.actionEnabled;this.additiveBlending=t.additiveBlending;this.displayControl=t.displayControl;this.pauseFadeIn=t.pauseFadeIn;this.resetToPose=t.resetToPose;this.playTimes=t.playTimes;this.layer=t.layer;this.position=t.position;this.duration=t.duration;this.timeScale=t.timeScale;this.fadeInTime=t.fadeInTime;this.fadeOutTime=t.fadeOutTime;this.fadeInTweenType=t.fadeInTweenType;this.weight=t.weight;this.name=t.name;this.animation=t.animation;this.group=t.group;this.boneMask.length=t.boneMask.length;for(var e=0,a=this.boneMask.length;e<a;++e){this.boneMask[e]=t.boneMask[e]}};e.prototype.containsBoneMask=function(t){return this.boneMask.length===0||this.boneMask.indexOf(t)>=0};e.prototype.addBoneMask=function(t,e,a){if(a===void 0){a=true}var r=t.getBone(e);if(r===null){return}if(this.boneMask.indexOf(e)<0){this.boneMask.push(e)}if(a){for(var i=0,n=t.getBones();i<n.length;i++){var s=n[i];if(this.boneMask.indexOf(s.name)<0&&r.contains(s)){this.boneMask.push(s.name)}}}};e.prototype.removeBoneMask=function(t,e,a){if(a===void 0){a=true}var r=this.boneMask.indexOf(e);if(r>=0){this.boneMask.splice(r,1)}if(a){var i=t.getBone(e);if(i!==null){if(this.boneMask.length>0){for(var n=0,s=t.getBones();n<s.length;n++){var o=s[n];var l=this.boneMask.indexOf(o.name);if(l>=0&&i.contains(o)){this.boneMask.splice(l,1)}}}else{for(var h=0,f=t.getBones();h<f.length;h++){var o=f[h];if(o===i){continue}if(!i.contains(o)){this.boneMask.push(o.name)}}}}}};return e}(t.BaseObject);t.AnimationConfig=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.textures={};return e}e.prototype._onClear=function(){for(var t in this.textures){this.textures[t].returnToPool();delete this.textures[t]}this.autoSearch=false;this.width=0;this.height=0;this.scale=1;this.name="";this.imagePath=""};e.prototype.copyFrom=function(t){this.autoSearch=t.autoSearch;this.scale=t.scale;this.width=t.width;this.height=t.height;this.name=t.name;this.imagePath=t.imagePath;for(var e in this.textures){this.textures[e].returnToPool();delete this.textures[e]}for(var e in t.textures){var a=this.createTexture();a.copyFrom(t.textures[e]);this.textures[e]=a}};e.prototype.addTexture=function(t){if(t.name in this.textures){console.warn("Same texture: "+t.name);return}t.parent=this;this.textures[t.name]=t};e.prototype.getTexture=function(t){return t in this.textures?this.textures[t]:null};return e}(t.BaseObject);t.TextureAtlasData=e;var a=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.region=new t.Rectangle;a.frame=null;return a}a.createRectangle=function(){return new t.Rectangle};a.prototype._onClear=function(){this.rotated=false;this.name="";this.region.clear();this.parent=null;this.frame=null};a.prototype.copyFrom=function(t){this.rotated=t.rotated;this.name=t.name;this.region.copyFrom(t.region);this.parent=t.parent;if(this.frame===null&&t.frame!==null){this.frame=a.createRectangle()}else if(this.frame!==null&&t.frame===null){this.frame=null}if(this.frame!==null&&t.frame!==null){this.frame.copyFrom(t.frame)}};return a}(t.BaseObject);t.TextureData=a})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.vertices=[];e.bones=[];return e}e.toString=function(){return"[class dragonBones.DeformVertices]"};e.prototype._onClear=function(){this.verticesDirty=false;this.vertices.length=0;this.bones.length=0;this.verticesData=null};e.prototype.init=function(t,e){this.verticesData=t;if(this.verticesData!==null){var a=0;if(this.verticesData.weight!==null){a=this.verticesData.weight.count*2}else{a=this.verticesData.data.intArray[this.verticesData.offset+0]*2}this.verticesDirty=true;this.vertices.length=a;this.bones.length=0;for(var r=0,i=this.vertices.length;r<i;++r){this.vertices[r]=0}if(this.verticesData.weight!==null){for(var r=0,i=this.verticesData.weight.bones.length;r<i;++r){var n=e.getBone(this.verticesData.weight.bones[r].name);this.bones.push(n)}}}else{this.verticesDirty=false;this.vertices.length=0;this.bones.length=0;this.verticesData=null}};e.prototype.isBonesUpdate=function(){for(var t=0,e=this.bones;t<e.length;t++){var a=e[t];if(a!==null&&a._childrenTransformDirty){return true}}return false};return e}(t.BaseObject);t.DeformVertices=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){var t=e!==null&&e.apply(this,arguments)||this;t._bones=[];t._slots=[];t._constraints=[];t._actions=[];t._animation=null;t._proxy=null;t._replaceTextureAtlasData=null;t._clock=null;return t}a.toString=function(){return"[class dragonBones.Armature]"};a._onSortSlots=function(t,e){return t._zOrder>e._zOrder?1:-1};a.prototype._onClear=function(){if(this._clock!==null){this._clock.remove(this)}for(var t=0,e=this._bones;t<e.length;t++){var a=e[t];a.returnToPool()}for(var r=0,i=this._slots;r<i.length;r++){var n=i[r];n.returnToPool()}for(var s=0,o=this._constraints;s<o.length;s++){var l=o[s];l.returnToPool()}for(var h=0,f=this._actions;h<f.length;h++){var u=f[h];u.returnToPool()}if(this._animation!==null){this._animation.returnToPool()}if(this._proxy!==null){this._proxy.dbClear()}if(this._replaceTextureAtlasData!==null){this._replaceTextureAtlasData.returnToPool()}this.inheritAnimation=true;this.userData=null;this._lockUpdate=false;this._slotsDirty=true;this._zOrderDirty=false;this._flipX=false;this._flipY=false;this._cacheFrameIndex=-1;this._bones.length=0;this._slots.length=0;this._constraints.length=0;this._actions.length=0;this._armatureData=null;this._animation=null;this._proxy=null;this._display=null;this._replaceTextureAtlasData=null;this._replacedTexture=null;this._dragonBones=null;this._clock=null;this._parent=null};a.prototype._sortZOrder=function(t,e){var a=this._armatureData.sortedSlots;var r=t===null;if(this._zOrderDirty||!r){for(var i=0,n=a.length;i<n;++i){var s=r?i:t[e+i];if(s<0||s>=n){continue}var o=a[s];var l=this.getSlot(o.name);if(l!==null){l._setZorder(i)}}this._slotsDirty=true;this._zOrderDirty=!r}};a.prototype._addBone=function(t){if(this._bones.indexOf(t)<0){this._bones.push(t)}};a.prototype._addSlot=function(t){if(this._slots.indexOf(t)<0){this._slots.push(t)}};a.prototype._addConstraint=function(t){if(this._constraints.indexOf(t)<0){this._constraints.push(t)}};a.prototype._bufferAction=function(t,e){if(this._actions.indexOf(t)<0){if(e){this._actions.push(t)}else{this._actions.unshift(t)}}};a.prototype.dispose=function(){if(this._armatureData!==null){this._lockUpdate=true;this._dragonBones.bufferObject(this)}};a.prototype.init=function(e,a,r,i){if(this._armatureData!==null){return}this._armatureData=e;this._animation=t.BaseObject.borrowObject(t.Animation);this._proxy=a;this._display=r;this._dragonBones=i;this._proxy.dbInit(this);this._animation.init(this);this._animation.animations=this._armatureData.animations};a.prototype.advanceTime=function(t){if(this._lockUpdate){return}if(this._armatureData===null){console.warn("The armature has been disposed.");return}else if(this._armatureData.parent===null){console.warn("The armature data has been disposed.\nPlease make sure dispose armature before call factory.clear().");return}var e=this._cacheFrameIndex;this._animation.advanceTime(t);if(this._slotsDirty){this._slotsDirty=false;this._slots.sort(a._onSortSlots)}if(this._cacheFrameIndex<0||this._cacheFrameIndex!==e){var r=0,i=0;for(r=0,i=this._bones.length;r<i;++r){this._bones[r].update(this._cacheFrameIndex)}for(r=0,i=this._slots.length;r<i;++r){this._slots[r].update(this._cacheFrameIndex)}}if(this._actions.length>0){this._lockUpdate=true;for(var n=0,s=this._actions;n<s.length;n++){var o=s[n];var l=o.actionData;if(l!==null){if(l.type===0){if(o.slot!==null){var h=o.slot.childArmature;if(h!==null){h.animation.fadeIn(l.name)}}else if(o.bone!==null){for(var f=0,u=this.getSlots();f<u.length;f++){var _=u[f];if(_.parent===o.bone){var h=_.childArmature;if(h!==null){h.animation.fadeIn(l.name)}}}}else{this._animation.fadeIn(l.name)}}}o.returnToPool()}this._actions.length=0;this._lockUpdate=false}this._proxy.dbUpdate()};a.prototype.invalidUpdate=function(t,e){if(t===void 0){t=null}if(e===void 0){e=false}if(t!==null&&t.length>0){var a=this.getBone(t);if(a!==null){a.invalidUpdate();if(e){for(var r=0,i=this._slots;r<i.length;r++){var n=i[r];if(n.parent===a){n.invalidUpdate()}}}}}else{for(var s=0,o=this._bones;s<o.length;s++){var a=o[s];a.invalidUpdate()}if(e){for(var l=0,h=this._slots;l<h.length;l++){var n=h[l];n.invalidUpdate()}}}};a.prototype.containsPoint=function(t,e){for(var a=0,r=this._slots;a<r.length;a++){var i=r[a];if(i.containsPoint(t,e)){return i}}return null};a.prototype.intersectsSegment=function(t,e,a,r,i,n,s){if(i===void 0){i=null}if(n===void 0){n=null}if(s===void 0){s=null}var o=t===a;var l=0;var h=0;var f=0;var u=0;var _=0;var c=0;var p=0;var m=0;var d=null;var v=null;for(var y=0,g=this._slots;y<g.length;y++){var b=g[y];var D=b.intersectsSegment(t,e,a,r,i,n,s);if(D>0){if(i!==null||n!==null){if(i!==null){var T=o?i.y-e:i.x-t;if(T<0){T=-T}if(d===null||T<l){l=T;f=i.x;u=i.y;d=b;if(s){p=s.x}}}if(n!==null){var T=n.x-t;if(T<0){T=-T}if(v===null||T>h){h=T;_=n.x;c=n.y;v=b;if(s!==null){m=s.y}}}}else{d=b;break}}}if(d!==null&&i!==null){i.x=f;i.y=u;if(s!==null){s.x=p}}if(v!==null&&n!==null){n.x=_;n.y=c;if(s!==null){s.y=m}}return d};a.prototype.getBone=function(t){for(var e=0,a=this._bones;e<a.length;e++){var r=a[e];if(r.name===t){return r}}return null};a.prototype.getBoneByDisplay=function(t){var e=this.getSlotByDisplay(t);return e!==null?e.parent:null};a.prototype.getSlot=function(t){for(var e=0,a=this._slots;e<a.length;e++){var r=a[e];if(r.name===t){return r}}return null};a.prototype.getSlotByDisplay=function(t){if(t!==null){for(var e=0,a=this._slots;e<a.length;e++){var r=a[e];if(r.display===t){return r}}}return null};a.prototype.getBones=function(){return this._bones};a.prototype.getSlots=function(){return this._slots};Object.defineProperty(a.prototype,"flipX",{get:function(){return this._flipX},set:function(t){if(this._flipX===t){return}this._flipX=t;this.invalidUpdate()},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"flipY",{get:function(){return this._flipY},set:function(t){if(this._flipY===t){return}this._flipY=t;this.invalidUpdate()},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"cacheFrameRate",{get:function(){return this._armatureData.cacheFrameRate},set:function(t){if(this._armatureData.cacheFrameRate!==t){this._armatureData.cacheFrames(t);for(var e=0,a=this._slots;e<a.length;e++){var r=a[e];var i=r.childArmature;if(i!==null){i.cacheFrameRate=t}}}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"name",{get:function(){return this._armatureData.name},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"armatureData",{get:function(){return this._armatureData},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"animation",{get:function(){return this._animation},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"proxy",{get:function(){return this._proxy},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"eventDispatcher",{get:function(){return this._proxy},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"display",{get:function(){return this._display},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"replacedTexture",{get:function(){return this._replacedTexture},set:function(t){if(this._replacedTexture===t){return}if(this._replaceTextureAtlasData!==null){this._replaceTextureAtlasData.returnToPool();this._replaceTextureAtlasData=null}this._replacedTexture=t;for(var e=0,a=this._slots;e<a.length;e++){var r=a[e];r.invalidUpdate();r.update(-1)}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"clock",{get:function(){return this._clock},set:function(t){if(this._clock===t){return}if(this._clock!==null){this._clock.remove(this)}this._clock=t;if(this._clock){this._clock.add(this)}for(var e=0,a=this._slots;e<a.length;e++){var r=a[e];var i=r.childArmature;if(i!==null){i.clock=this._clock}}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"parent",{get:function(){return this._parent},enumerable:true,configurable:true});a.prototype.replaceTexture=function(t){this.replacedTexture=t};a.prototype.hasEventListener=function(t){console.warn("Deprecated.");return this._proxy.hasDBEventListener(t)};a.prototype.addEventListener=function(t,e,a){console.warn("Deprecated.");this._proxy.addDBEventListener(t,e,a)};a.prototype.removeEventListener=function(t,e,a){console.warn("Deprecated.");this._proxy.removeDBEventListener(t,e,a)};a.prototype.enableAnimationCache=function(t){console.warn("Deprecated.");this.cacheFrameRate=t};a.prototype.getDisplay=function(){return this._display};return a}(t.BaseObject);t.Armature=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.globalTransformMatrix=new t.Matrix;a.global=new t.Transform;a.offset=new t.Transform;return a}a.prototype._onClear=function(){this.globalTransformMatrix.identity();this.global.identity();this.offset.identity();this.origin=null;this.userData=null;this._globalDirty=false;this._armature=null};a.prototype.updateGlobalTransform=function(){if(this._globalDirty){this._globalDirty=false;this.global.fromMatrix(this.globalTransformMatrix)}};Object.defineProperty(a.prototype,"armature",{get:function(){return this._armature},enumerable:true,configurable:true});a._helpMatrix=new t.Matrix;a._helpTransform=new t.Transform;a._helpPoint=new t.Point;return a}(t.BaseObject);t.TransformObject=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.animationPose=new t.Transform;a._blendState=new t.BlendState;return a}a.toString=function(){return"[class dragonBones.Bone]"};a.prototype._onClear=function(){e.prototype._onClear.call(this);this.offsetMode=1;this.animationPose.identity();this._transformDirty=false;this._childrenTransformDirty=false;this._localDirty=true;this._hasConstraint=false;this._visible=true;this._cachedFrameIndex=-1;this._blendState.clear();this._boneData=null;this._parent=null;this._cachedFrameIndices=null};a.prototype._updateGlobalTransformMatrix=function(e){var a=this._boneData;var r=this.global;var i=this.globalTransformMatrix;var n=this.origin;var s=this.offset;var o=this.animationPose;var l=this._parent;var h=this._armature.flipX;var f=this._armature.flipY===t.DragonBones.yDown;var u=l!==null;var _=0;if(this.offsetMode===1){if(n!==null){r.x=n.x+s.x+o.x;r.y=n.y+s.y+o.y;r.skew=n.skew+s.skew+o.skew;r.rotation=n.rotation+s.rotation+o.rotation;r.scaleX=n.scaleX*s.scaleX*o.scaleX;r.scaleY=n.scaleY*s.scaleY*o.scaleY}else{r.copyFrom(s).add(o)}}else if(this.offsetMode===0){if(n!==null){r.copyFrom(n).add(o)}else{r.copyFrom(o)}}else{u=false;r.copyFrom(s)}if(u){var c=l._boneData.type===0?l.globalTransformMatrix:l._getGlobalTransformMatrix(r.x,r.y);if(a.inheritScale){if(!a.inheritRotation){l.updateGlobalTransform();if(h&&f){_=r.rotation-(l.global.rotation+Math.PI)}else if(h){_=r.rotation+l.global.rotation+Math.PI}else if(f){_=r.rotation+l.global.rotation}else{_=r.rotation-l.global.rotation}r.rotation=_}r.toMatrix(i);i.concat(c);if(a.inheritTranslation){r.x=i.tx;r.y=i.ty}else{i.tx=r.x;i.ty=r.y}if(e){r.fromMatrix(i)}else{this._globalDirty=true}}else{if(a.inheritTranslation){var p=r.x;var m=r.y;r.x=c.a*p+c.c*m+c.tx;r.y=c.b*p+c.d*m+c.ty}else{if(h){r.x=-r.x}if(f){r.y=-r.y}}if(a.inheritRotation){l.updateGlobalTransform();if(l.global.scaleX<0){_=r.rotation+l.global.rotation+Math.PI}else{_=r.rotation+l.global.rotation}if(c.a*c.d-c.b*c.c<0){_-=r.rotation*2;if(h!==f||a.inheritReflection){r.skew+=Math.PI}}r.rotation=_}else if(h||f){if(h&&f){_=r.rotation+Math.PI}else{if(h){_=Math.PI-r.rotation}else{_=-r.rotation}r.skew+=Math.PI}r.rotation=_}r.toMatrix(i)}}else{if(h||f){if(h){r.x=-r.x}if(f){r.y=-r.y}if(h&&f){_=r.rotation+Math.PI}else{if(h){_=Math.PI-r.rotation}else{_=-r.rotation}r.skew+=Math.PI}r.rotation=_}r.toMatrix(i)}};a.prototype.init=function(t,e){if(this._boneData!==null){return}this._boneData=t;this._armature=e;if(this._boneData.parent!==null){this._parent=this._armature.getBone(this._boneData.parent.name)}this._armature._addBone(this);this.origin=this._boneData.transform};a.prototype.update=function(t){this._blendState.dirty=false;if(t>=0&&this._cachedFrameIndices!==null){var e=this._cachedFrameIndices[t];if(e>=0&&this._cachedFrameIndex===e){this._transformDirty=false}else if(e>=0){this._transformDirty=true;this._cachedFrameIndex=e}else{if(this._hasConstraint){for(var a=0,r=this._armature._constraints;a<r.length;a++){var i=r[a];if(i._root===this){i.update()}}}if(this._transformDirty||this._parent!==null&&this._parent._childrenTransformDirty){this._transformDirty=true;this._cachedFrameIndex=-1}else if(this._cachedFrameIndex>=0){this._transformDirty=false;this._cachedFrameIndices[t]=this._cachedFrameIndex}else{this._transformDirty=true;this._cachedFrameIndex=-1}}}else{if(this._hasConstraint){for(var n=0,s=this._armature._constraints;n<s.length;n++){var i=s[n];if(i._root===this){i.update()}}}if(this._transformDirty||this._parent!==null&&this._parent._childrenTransformDirty){t=-1;this._transformDirty=true;this._cachedFrameIndex=-1}}if(this._transformDirty){this._transformDirty=false;this._childrenTransformDirty=true;if(this._cachedFrameIndex<0){var o=t>=0;if(this._localDirty){this._updateGlobalTransformMatrix(o)}if(o&&this._cachedFrameIndices!==null){this._cachedFrameIndex=this._cachedFrameIndices[t]=this._armature._armatureData.setCacheFrame(this.globalTransformMatrix,this.global)}}else{this._armature._armatureData.getCacheFrame(this.globalTransformMatrix,this.global,this._cachedFrameIndex)}}else if(this._childrenTransformDirty){this._childrenTransformDirty=false}this._localDirty=true};a.prototype.updateByConstraint=function(){if(this._localDirty){this._localDirty=false;if(this._transformDirty||this._parent!==null&&this._parent._childrenTransformDirty){this._updateGlobalTransformMatrix(true)}this._transformDirty=true}};a.prototype.invalidUpdate=function(){this._transformDirty=true};a.prototype.contains=function(t){if(t===this){return false}var e=t;while(e!==this&&e!==null){e=e.parent}return e===this};Object.defineProperty(a.prototype,"boneData",{get:function(){return this._boneData},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"visible",{get:function(){return this._visible},set:function(t){if(this._visible===t){return}this._visible=t;for(var e=0,a=this._armature.getSlots();e<a.length;e++){var r=a[e];if(r.parent===this){r._updateVisible()}}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"name",{get:function(){return this._boneData.name},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"parent",{get:function(){return this._parent},enumerable:true,configurable:true});a.prototype.getBones=function(){console.warn("Deprecated.");var t=new Array;for(var e=0,a=this._armature.getBones();e<a.length;e++){var r=a[e];if(r.parent===this){t.push(r)}}return t};a.prototype.getSlots=function(){console.warn("Deprecated.");var t=new Array;for(var e=0,a=this._armature.getSlots();e<a.length;e++){var r=a[e];if(r.parent===this){t.push(r)}}return t};Object.defineProperty(a.prototype,"slot",{get:function(){console.warn("Deprecated.");for(var t=0,e=this._armature.getSlots();t<e.length;t++){var a=e[t];if(a.parent===this){return a}}return null},enumerable:true,configurable:true});return a}(t.TransformObject);t.Bone=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e._vertices=[];e._deformVertices=[];e._hullCache=[];e._matrixCahce=[];return e}e.toString=function(){return"[class dragonBones.Surface]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this._dX=0;this._dY=0;this._k=0;this._kX=0;this._kY=0;this._vertices.length=0;this._deformVertices.length=0;this._matrixCahce.length=0;this._hullCache.length=0};e.prototype._getAffineTransform=function(t,e,a,r,i,n,s,o,l,h,f,u,_){var c=s-i;var p=o-n;var m=l-i;var d=h-n;f.rotation=Math.atan2(p,c);f.skew=Math.atan2(d,m)-Math.PI*.5-f.rotation;if(_){f.rotation+=Math.PI}f.scaleX=Math.sqrt(c*c+p*p)/a;f.scaleY=Math.sqrt(m*m+d*d)/r;f.toMatrix(u);f.x=u.tx=i-(u.a*t+u.c*e);f.y=u.ty=n-(u.b*t+u.d*e)};e.prototype._updateVertices=function(){var t=this._boneData.vertices;var e=this._vertices;var a=this._deformVertices;if(this._parent!==null){if(this._parent._boneData.type===1){for(var r=0,i=t.length;r<i;r+=2){var n=t[r]+a[r];var s=t[r+1]+a[r];var o=this._parent._getGlobalTransformMatrix(n,s);e[r]=o.a*n+o.c*s+o.tx;e[r+1]=o.b*n+o.d*s+o.ty}}else{var l=this._parent.globalTransformMatrix;for(var r=0,i=t.length;r<i;r+=2){var n=t[r]+a[r];var s=t[r+1]+a[r+1];e[r]=l.a*n+l.c*s+l.tx;e[r+1]=l.b*n+l.d*s+l.ty}}}else{for(var r=0,i=t.length;r<i;r+=2){e[r]=t[r]+a[r];e[r+1]=t[r+1]+a[r+1]}}};e.prototype._updateGlobalTransformMatrix=function(t){t;var e=this._boneData.segmentX*2;var a=this._vertices.length-2;var r=200;var i=this._vertices[0];var n=this._vertices[1];var s=this._vertices[e];var o=this._vertices[e+1];var l=this._vertices[a];var h=this._vertices[a+1];var f=this._vertices[a-e];var u=this._vertices[a-e+1];var _=i+(l-i)*.5;var c=n+(h-n)*.5;var p=s+(f-s)*.5;var m=o+(u-o)*.5;var d=_+(p-_)*.5;var v=c+(m-c)*.5;var y=s+(l-s)*.5;var g=o+(h-o)*.5;var b=f+(l-f)*.5;var D=u+(h-u)*.5;this._globalDirty=false;this._getAffineTransform(0,0,r,r,d,v,y,g,b,D,this.global,this.globalTransformMatrix,false)};e.prototype._getGlobalTransformMatrix=function(t,a){var r=1e3;if(t<-r||r<t||a<-r||r<a){return this.globalTransformMatrix}var i=false;var n=200;var s=this._boneData;var o=s.segmentX;var l=s.segmentY;var h=s.segmentX*2;var f=this._dX;var u=this._dY;var _=Math.floor((t+n)/f);var c=Math.floor((a+n)/u);var p=0;var m=_*f-n;var d=c*u-n;var v=this._matrixCahce;var y=e._helpMatrix;if(t<-n){if(a<-n||a>=n){return this.globalTransformMatrix}i=a>this._kX*(t+n)+d;p=((o*(l+1)+o*2+l+c)*2+(i?1:0))*7;if(this._matrixCahce[p]>0){y.copyFromArray(v,p+1)}else{var g=c*(h+2);var b=this._hullCache[4];var D=this._hullCache[5];var T=this._hullCache[2]-(l-c)*b;var A=this._hullCache[3]-(l-c)*D;var x=this._vertices;if(i){this._getAffineTransform(-n,d+u,r-n,u,x[g+h+2],x[g+h+3],T+b,A+D,x[g],x[g+1],e._helpTransform,y,true)}else{this._getAffineTransform(-r,d,r-n,u,T,A,x[g],x[g+1],T+b,A+D,e._helpTransform,y,false)}v[p]=1;v[p+1]=y.a;v[p+2]=y.b;v[p+3]=y.c;v[p+4]=y.d;v[p+5]=y.tx;v[p+6]=y.ty}}else if(t>=n){if(a<-n||a>=n){return this.globalTransformMatrix}i=a>this._kX*(t-r)+d;p=((o*(l+1)+o+c)*2+(i?1:0))*7;if(this._matrixCahce[p]>0){y.copyFromArray(v,p+1)}else{var g=(c+1)*(h+2)-2;var b=this._hullCache[4];var D=this._hullCache[5];var T=this._hullCache[0]+c*b;var A=this._hullCache[1]+c*D;var x=this._vertices;if(i){this._getAffineTransform(r,d+u,r-n,u,T+b,A+D,x[g+h+2],x[g+h+3],T,A,e._helpTransform,y,true)}else{this._getAffineTransform(n,d,r-n,u,x[g],x[g+1],T,A,x[g+h+2],x[g+h+3],e._helpTransform,y,false)}v[p]=1;v[p+1]=y.a;v[p+2]=y.b;v[p+3]=y.c;v[p+4]=y.d;v[p+5]=y.tx;v[p+6]=y.ty}}else if(a<-n){if(t<-n||t>=n){return this.globalTransformMatrix}i=a>this._kY*(t-m-f)-r;p=(o*(l+1)+_*2+(i?1:0))*7;if(this._matrixCahce[p]>0){y.copyFromArray(v,p+1)}else{var g=_*2;var b=this._hullCache[10];var D=this._hullCache[11];var T=this._hullCache[8]+_*b;var A=this._hullCache[9]+_*D;var x=this._vertices;if(i){this._getAffineTransform(m+f,-n,f,r-n,x[g+2],x[g+3],x[g],x[g+1],T+b,A+D,e._helpTransform,y,true)}else{this._getAffineTransform(m,-r,f,r-n,T,A,T+b,A+D,x[g],x[g+1],e._helpTransform,y,false)}v[p]=1;v[p+1]=y.a;v[p+2]=y.b;v[p+3]=y.c;v[p+4]=y.d;v[p+5]=y.tx;v[p+6]=y.ty}}else if(a>=n){if(t<-n||t>=n){return this.globalTransformMatrix}i=a>this._kY*(t-m-f)+n;p=((o*(l+1)+o+l+c)*2+(i?1:0))*7;if(this._matrixCahce[p]>0){y.copyFromArray(v,p+1)}else{var g=l*(h+2)+_*2;var b=this._hullCache[10];var D=this._hullCache[11];var T=this._hullCache[6]-(o-_)*b;var A=this._hullCache[7]-(o-_)*D;var x=this._vertices;if(i){this._getAffineTransform(m+f,r,f,r-n,T+b,A+D,T,A,x[g+2],x[g+3],e._helpTransform,y,true)}else{this._getAffineTransform(m,n,f,r-n,x[g],x[g+1],x[g+2],x[g+3],T,A,e._helpTransform,y,false)}v[p]=1;v[p+1]=y.a;v[p+2]=y.b;v[p+3]=y.c;v[p+4]=y.d;v[p+5]=y.tx;v[p+6]=y.ty}}else{i=a>this._k*(t-m-f)+d;p=((o*c+_)*2+(i?1:0))*7;if(this._matrixCahce[p]>0){y.copyFromArray(v,p+1)}else{var g=_*2+c*(h+2);var x=this._vertices;if(i){this._getAffineTransform(m+f,d+u,f,u,x[g+h+4],x[g+h+5],x[g+h+2],x[g+h+3],x[g+2],x[g+3],e._helpTransform,y,true)}else{this._getAffineTransform(m,d,f,u,x[g],x[g+1],x[g+2],x[g+3],x[g+h+2],x[g+h+3],e._helpTransform,y,false)}v[p]=1;v[p+1]=y.a;v[p+2]=y.b;v[p+3]=y.c;v[p+4]=y.d;v[p+5]=y.tx;v[p+6]=y.ty}}return y};e.prototype.init=function(e,a){if(this._boneData!==null){return}t.prototype.init.call(this,e,a);var r=e.segmentX;var i=e.segmentY;var n=e.vertices.length;var s=1e3;var o=200;this._dX=o*2/r;this._dY=o*2/i;this._k=-this._dY/this._dX;this._kX=-this._dY/(s-o);this._kY=-(s-o)/this._dX;this._vertices.length=n;this._deformVertices.length=n;this._matrixCahce.length=(r*i+r*2+i*2)*2*7;this._hullCache.length=10;for(var l=0;l<n;++l){this._deformVertices[l]=0}};e.prototype.update=function(t){this._blendState.dirty=false;if(t>=0&&this._cachedFrameIndices!==null){var a=this._cachedFrameIndices[t];if(a>=0&&this._cachedFrameIndex===a){this._transformDirty=false}else if(a>=0){this._transformDirty=true;this._cachedFrameIndex=a}else{if(this._hasConstraint){for(var r=0,i=this._armature._constraints;r<i.length;r++){var n=i[r];if(n._root===this){n.update()}}}if(this._transformDirty||this._parent!==null&&this._parent._childrenTransformDirty){this._transformDirty=true;this._cachedFrameIndex=-1}else if(this._cachedFrameIndex>=0){this._transformDirty=false;this._cachedFrameIndices[t]=this._cachedFrameIndex}else{this._transformDirty=true;this._cachedFrameIndex=-1}}}else{if(this._hasConstraint){for(var s=0,o=this._armature._constraints;s<o.length;s++){var n=o[s];if(n._root===this){n.update()}}}if(this._transformDirty||this._parent!==null&&this._parent._childrenTransformDirty){t=-1;this._transformDirty=true;this._cachedFrameIndex=-1}}if(this._transformDirty){this._transformDirty=false;this._childrenTransformDirty=true;for(var l=0,h=this._matrixCahce.length;l<h;l+=7){this._matrixCahce[l]=-1}this._updateVertices();if(this._cachedFrameIndex<0){var f=t>=0;if(this._localDirty){this._updateGlobalTransformMatrix(f)}if(f&&this._cachedFrameIndices!==null){this._cachedFrameIndex=this._cachedFrameIndices[t]=this._armature._armatureData.setCacheFrame(this.globalTransformMatrix,this.global)}}else{this._armature._armatureData.getCacheFrame(this.globalTransformMatrix,this.global,this._cachedFrameIndex)}var u=1e3;var _=200;var c=2*this.global.x;var p=2*this.global.y;var m=e._helpPoint;this.globalTransformMatrix.transformPoint(u,-_,m);this._hullCache[0]=m.x;this._hullCache[1]=m.y;this._hullCache[2]=c-m.x;this._hullCache[3]=p-m.y;this.globalTransformMatrix.transformPoint(0,this._dY,m,true);this._hullCache[4]=m.x;this._hullCache[5]=m.y;this.globalTransformMatrix.transformPoint(_,u,m);this._hullCache[6]=m.x;this._hullCache[7]=m.y;this._hullCache[8]=c-m.x;this._hullCache[9]=p-m.y;this.globalTransformMatrix.transformPoint(this._dX,0,m,true);this._hullCache[10]=m.x;this._hullCache[11]=m.y}else if(this._childrenTransformDirty){this._childrenTransformDirty=false}this._localDirty=true};return e}(t.Bone);t.Surface=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a._localMatrix=new t.Matrix;a._colorTransform=new t.ColorTransform;a._displayDatas=[];a._displayList=[];a._deformVertices=null;a._rawDisplay=null;a._meshDisplay=null;return a}a.prototype._onClear=function(){e.prototype._onClear.call(this);var a=[];for(var r=0,i=this._displayList;r<i.length;r++){var n=i[r];if(n!==null&&n!==this._rawDisplay&&n!==this._meshDisplay&&a.indexOf(n)<0){a.push(n)}}for(var s=0,o=a;s<o.length;s++){var n=o[s];if(n instanceof t.Armature){n.dispose()}else{this._disposeDisplay(n,true)}}if(this._deformVertices!==null){this._deformVertices.returnToPool()}if(this._meshDisplay!==null&&this._meshDisplay!==this._rawDisplay){this._disposeDisplay(this._meshDisplay,false)}if(this._rawDisplay!==null){this._disposeDisplay(this._rawDisplay,false)}this.displayController=null;this._displayDirty=false;this._zOrderDirty=false;this._blendModeDirty=false;this._colorDirty=false;this._transformDirty=false;this._visible=true;this._blendMode=0;this._displayIndex=-1;this._animationDisplayIndex=-1;this._zOrder=0;this._cachedFrameIndex=-1;this._pivotX=0;this._pivotY=0;this._localMatrix.identity();this._colorTransform.identity();this._displayList.length=0;this._displayDatas.length=0;this._slotData=null;this._rawDisplayDatas=null;this._displayData=null;this._boundingBoxData=null;this._textureData=null;this._deformVertices=null;this._rawDisplay=null;this._meshDisplay=null;this._display=null;this._childArmature=null;this._parent=null;this._cachedFrameIndices=null};a.prototype._getDefaultRawDisplayData=function(t){var e=this._armature._armatureData.defaultSkin;if(e!==null){var a=e.getDisplays(this._slotData.name);if(a!==null){return t<a.length?a[t]:null}}return null};a.prototype._updateDisplayData=function(){var e=this._displayData;var r=this._deformVertices!==null?this._deformVertices.verticesData:null;var i=this._textureData;var n=null;var s=null;this._displayData=null;this._boundingBoxData=null;this._textureData=null;if(this._displayIndex>=0){if(this._rawDisplayDatas!==null){n=this._displayIndex<this._rawDisplayDatas.length?this._rawDisplayDatas[this._displayIndex]:null}if(n===null){n=this._getDefaultRawDisplayData(this._displayIndex)}if(this._displayIndex<this._displayDatas.length){this._displayData=this._displayDatas[this._displayIndex]}}if(this._displayData!==null){if(this._displayData.type===2){s=this._displayData.vertices}else if(this._displayData.type===4){s=this._displayData.vertices}else if(n!==null){if(n.type===2){s=n.vertices}else if(n.type===4){s=n.vertices}}if(this._displayData.type===3){this._boundingBoxData=this._displayData.boundingBox}else if(n!==null){if(n.type===3){this._boundingBoxData=n.boundingBox}}if(this._displayData.type===0){this._textureData=this._displayData.texture}else if(this._displayData.type===2){this._textureData=this._displayData.texture}}if(this._displayData!==e||s!==r||this._textureData!==i){if(s===null&&this._textureData!==null){var o=this._displayData;var l=this._textureData.parent.scale*this._armature._armatureData.scale;var h=this._textureData.frame;this._pivotX=o.pivot.x;this._pivotY=o.pivot.y;var f=h!==null?h:this._textureData.region;var u=f.width;var _=f.height;if(this._textureData.rotated&&h===null){u=f.height;_=f.width}this._pivotX*=u*l;this._pivotY*=_*l;if(h!==null){this._pivotX+=h.x*l;this._pivotY+=h.y*l}if(this._displayData!==null&&n!==null&&this._displayData!==n){n.transform.toMatrix(a._helpMatrix);a._helpMatrix.invert();a._helpMatrix.transformPoint(0,0,a._helpPoint);this._pivotX-=a._helpPoint.x;this._pivotY-=a._helpPoint.y;this._displayData.transform.toMatrix(a._helpMatrix);a._helpMatrix.invert();a._helpMatrix.transformPoint(0,0,a._helpPoint);this._pivotX+=a._helpPoint.x;this._pivotY+=a._helpPoint.y}if(!t.DragonBones.yDown){this._pivotY=(this._textureData.rotated?this._textureData.region.width:this._textureData.region.height)*l-this._pivotY}}else{this._pivotX=0;this._pivotY=0}if(n!==null){this.origin=n.transform}else if(this._displayData!==null){this.origin=this._displayData.transform}else{this.origin=null}if(s!==r){if(this._deformVertices===null){this._deformVertices=t.BaseObject.borrowObject(t.DeformVertices)}this._deformVertices.init(s,this._armature)}else if(this._deformVertices!==null&&this._textureData!==i){this._deformVertices.verticesDirty=true}this._displayDirty=true;this._transformDirty=true}};a.prototype._updateDisplay=function(){var e=this._display!==null?this._display:this._rawDisplay;var a=this._childArmature;if(this._displayIndex>=0&&this._displayIndex<this._displayList.length){this._display=this._displayList[this._displayIndex];if(this._display!==null&&this._display instanceof t.Armature){this._childArmature=this._display;this._display=this._childArmature.display}else{this._childArmature=null}}else{this._display=null;this._childArmature=null}var r=this._display!==null?this._display:this._rawDisplay;if(r!==e){this._onUpdateDisplay();this._replaceDisplay(e);this._transformDirty=true;this._visibleDirty=true;this._blendModeDirty=true;this._colorDirty=true}if(r===this._rawDisplay||r===this._meshDisplay){this._updateFrame()}if(this._childArmature!==a){if(a!==null){a._parent=null;a.clock=null;if(a.inheritAnimation){a.animation.reset()}}if(this._childArmature!==null){this._childArmature._parent=this;this._childArmature.clock=this._armature.clock;if(this._childArmature.inheritAnimation){if(this._childArmature.cacheFrameRate===0){var i=this._armature.cacheFrameRate;if(i!==0){this._childArmature.cacheFrameRate=i}}var n=null;if(this._displayData!==null&&this._displayData.type===1){n=this._displayData.actions}else if(this._displayIndex>=0&&this._rawDisplayDatas!==null){var s=this._displayIndex<this._rawDisplayDatas.length?this._rawDisplayDatas[this._displayIndex]:null;if(s===null){s=this._getDefaultRawDisplayData(this._displayIndex)}if(s!==null&&s.type===1){n=s.actions}}if(n!==null&&n.length>0){for(var o=0,l=n;o<l.length;o++){var h=l[o];var f=t.BaseObject.borrowObject(t.EventObject);t.EventObject.actionDataToInstance(h,f,this._armature);f.slot=this;this._armature._bufferAction(f,false)}}else{this._childArmature.animation.play()}}}}};a.prototype._updateGlobalTransformMatrix=function(t){var e=this._parent._boneData.type===0?this._parent.globalTransformMatrix:this._parent._getGlobalTransformMatrix(this.global.x,this.global.y);this.globalTransformMatrix.copyFrom(this._localMatrix);this.globalTransformMatrix.concat(e);if(t){this.global.fromMatrix(this.globalTransformMatrix)}else{this._globalDirty=true}};a.prototype._setDisplayIndex=function(t,e){if(e===void 0){e=false}if(e){if(this._animationDisplayIndex===t){return false}this._animationDisplayIndex=t}if(this._displayIndex===t){return false}this._displayIndex=t;this._displayDirty=true;this._updateDisplayData();return this._displayDirty};a.prototype._setZorder=function(t){if(this._zOrder===t){}this._zOrder=t;this._zOrderDirty=true;return this._zOrderDirty};a.prototype._setColor=function(t){this._colorTransform.copyFrom(t);this._colorDirty=true;return this._colorDirty};a.prototype._setDisplayList=function(e){if(e!==null&&e.length>0){if(this._displayList.length!==e.length){this._displayList.length=e.length}for(var a=0,r=e.length;a<r;++a){var i=e[a];if(i!==null&&i!==this._rawDisplay&&i!==this._meshDisplay&&!(i instanceof t.Armature)&&this._displayList.indexOf(i)<0){this._initDisplay(i,true)}this._displayList[a]=i}}else if(this._displayList.length>0){this._displayList.length=0}if(this._displayIndex>=0&&this._displayIndex<this._displayList.length){this._displayDirty=this._display!==this._displayList[this._displayIndex]}else{this._displayDirty=this._display!==null}this._updateDisplayData();return this._displayDirty};a.prototype.init=function(t,e,a,r){if(this._slotData!==null){return}this._slotData=t;this._visibleDirty=true;this._blendModeDirty=true;this._colorDirty=true;this._blendMode=this._slotData.blendMode;this._zOrder=this._slotData.zOrder;this._colorTransform.copyFrom(this._slotData.color);this._rawDisplay=a;this._meshDisplay=r;this._armature=e;var i=this._armature.getBone(this._slotData.parent.name);if(i!==null){this._parent=i}else{}this._armature._addSlot(this);this._initDisplay(this._rawDisplay,false);if(this._rawDisplay!==this._meshDisplay){this._initDisplay(this._meshDisplay,false)}this._onUpdateDisplay();this._addDisplay()};a.prototype.update=function(t){if(this._displayDirty){this._displayDirty=false;this._updateDisplay();if(this._transformDirty){if(this.origin!==null){this.global.copyFrom(this.origin).add(this.offset).toMatrix(this._localMatrix)}else{this.global.copyFrom(this.offset).toMatrix(this._localMatrix)}}}if(this._zOrderDirty){this._zOrderDirty=false;this._updateZOrder()}if(t>=0&&this._cachedFrameIndices!==null){var e=this._cachedFrameIndices[t];if(e>=0&&this._cachedFrameIndex===e){this._transformDirty=false}else if(e>=0){this._transformDirty=true;this._cachedFrameIndex=e}else if(this._transformDirty||this._parent._childrenTransformDirty){this._transformDirty=true;this._cachedFrameIndex=-1}else if(this._cachedFrameIndex>=0){this._transformDirty=false;this._cachedFrameIndices[t]=this._cachedFrameIndex}else{this._transformDirty=true;this._cachedFrameIndex=-1}}else if(this._transformDirty||this._parent._childrenTransformDirty){t=-1;this._transformDirty=true;this._cachedFrameIndex=-1}if(this._display===null){return}if(this._visibleDirty){this._visibleDirty=false;this._updateVisible()}if(this._blendModeDirty){this._blendModeDirty=false;this._updateBlendMode()}if(this._colorDirty){this._colorDirty=false;this._updateColor()}if(this._deformVertices!==null&&this._deformVertices.verticesData!==null&&this._display===this._meshDisplay){var a=this._deformVertices.verticesData.weight!==null;var r=this._parent._boneData.type!==0;if(this._deformVertices.verticesDirty||a&&this._deformVertices.isBonesUpdate()||r&&this._parent._childrenTransformDirty){this._deformVertices.verticesDirty=false;this._updateMesh()}if(a||r){return}}if(this._transformDirty){this._transformDirty=false;if(this._cachedFrameIndex<0){var i=t>=0;this._updateGlobalTransformMatrix(i);if(i&&this._cachedFrameIndices!==null){this._cachedFrameIndex=this._cachedFrameIndices[t]=this._armature._armatureData.setCacheFrame(this.globalTransformMatrix,this.global)}}else{this._armature._armatureData.getCacheFrame(this.globalTransformMatrix,this.global,this._cachedFrameIndex)}this._updateTransform()}};a.prototype.updateTransformAndMatrix=function(){if(this._transformDirty){this._transformDirty=false;this._updateGlobalTransformMatrix(false)}};a.prototype.replaceDisplayData=function(t,e){if(e===void 0){e=-1}if(e<0){if(this._displayIndex<0){e=0}else{e=this._displayIndex}}if(this._displayDatas.length<=e){this._displayDatas.length=e+1;for(var a=0,r=this._displayDatas.length;a<r;++a){if(!this._displayDatas[a]){this._displayDatas[a]=null}}}this._displayDatas[e]=t};a.prototype.containsPoint=function(t,e){if(this._boundingBoxData===null){return false}this.updateTransformAndMatrix();a._helpMatrix.copyFrom(this.globalTransformMatrix);a._helpMatrix.invert();a._helpMatrix.transformPoint(t,e,a._helpPoint);return this._boundingBoxData.containsPoint(a._helpPoint.x,a._helpPoint.y)};a.prototype.intersectsSegment=function(t,e,r,i,n,s,o){if(n===void 0){n=null}if(s===void 0){s=null}if(o===void 0){o=null}if(this._boundingBoxData===null){return 0}this.updateTransformAndMatrix();a._helpMatrix.copyFrom(this.globalTransformMatrix);a._helpMatrix.invert();a._helpMatrix.transformPoint(t,e,a._helpPoint);t=a._helpPoint.x;e=a._helpPoint.y;a._helpMatrix.transformPoint(r,i,a._helpPoint);r=a._helpPoint.x;i=a._helpPoint.y;var l=this._boundingBoxData.intersectsSegment(t,e,r,i,n,s,o);if(l>0){if(l===1||l===2){if(n!==null){this.globalTransformMatrix.transformPoint(n.x,n.y,n);if(s!==null){s.x=n.x;s.y=n.y}}else if(s!==null){this.globalTransformMatrix.transformPoint(s.x,s.y,s)}}else{if(n!==null){this.globalTransformMatrix.transformPoint(n.x,n.y,n)}if(s!==null){this.globalTransformMatrix.transformPoint(s.x,s.y,s)}}if(o!==null){this.globalTransformMatrix.transformPoint(Math.cos(o.x),Math.sin(o.x),a._helpPoint,true);o.x=Math.atan2(a._helpPoint.y,a._helpPoint.x);this.globalTransformMatrix.transformPoint(Math.cos(o.y),Math.sin(o.y),a._helpPoint,true);o.y=Math.atan2(a._helpPoint.y,a._helpPoint.x)}}return l};a.prototype.invalidUpdate=function(){this._displayDirty=true;this._transformDirty=true};Object.defineProperty(a.prototype,"visible",{get:function(){return this._visible},set:function(t){if(this._visible===t){return}this._visible=t;this._updateVisible()},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"displayIndex",{get:function(){return this._displayIndex},set:function(t){if(this._setDisplayIndex(t)){this.update(-1)}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"name",{get:function(){return this._slotData.name},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"displayList",{get:function(){return this._displayList.concat()},set:function(e){var a=this._displayList.concat();var r=new Array;if(this._setDisplayList(e)){this.update(-1)}for(var i=0,n=a;i<n.length;i++){var s=n[i];if(s!==null&&s!==this._rawDisplay&&s!==this._meshDisplay&&this._displayList.indexOf(s)<0&&r.indexOf(s)<0){r.push(s)}}for(var o=0,l=r;o<l.length;o++){var s=l[o];if(s instanceof t.Armature){}else{this._disposeDisplay(s,true)}}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"slotData",{get:function(){return this._slotData},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"rawDisplayDatas",{get:function(){return this._rawDisplayDatas},set:function(t){if(this._rawDisplayDatas===t){return}this._displayDirty=true;this._rawDisplayDatas=t;if(this._rawDisplayDatas!==null){this._displayDatas.length=this._rawDisplayDatas.length;for(var e=0,a=this._displayDatas.length;e<a;++e){var r=this._rawDisplayDatas[e];if(r===null){r=this._getDefaultRawDisplayData(e)}this._displayDatas[e]=r}}else{this._displayDatas.length=0}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"displayData",{get:function(){return this._displayData},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"boundingBoxData",{get:function(){return this._boundingBoxData},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"rawDisplay",{get:function(){return this._rawDisplay},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"meshDisplay",{get:function(){return this._meshDisplay},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"display",{get:function(){return this._display},set:function(t){if(this._display===t){return}var e=this._displayList.length;if(this._displayIndex<0&&e===0){this._displayIndex=0}if(this._displayIndex<0){return}else{var a=this.displayList;if(e<=this._displayIndex){a.length=this._displayIndex+1}a[this._displayIndex]=t;this.displayList=a}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"childArmature",{get:function(){return this._childArmature},set:function(t){if(this._childArmature===t){return}this.display=t},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"parent",{get:function(){return this._parent},enumerable:true,configurable:true});a.prototype.getDisplay=function(){return this._display};a.prototype.setDisplay=function(t){this.display=t};return a}(t.TransformObject);t.Slot=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){return e!==null&&e.apply(this,arguments)||this}a.prototype._onClear=function(){this._armature=null;this._target=null;this._root=null;this._bone=null};Object.defineProperty(a.prototype,"name",{get:function(){return this._constraintData.name},enumerable:true,configurable:true});a._helpMatrix=new t.Matrix;a._helpTransform=new t.Transform;a._helpPoint=new t.Point;return a}(t.BaseObject);t.Constraint=e;var a=function(e){__extends(a,e);function a(){return e!==null&&e.apply(this,arguments)||this}a.toString=function(){return"[class dragonBones.IKConstraint]"};a.prototype._onClear=function(){e.prototype._onClear.call(this);this._scaleEnabled=false;this._bendPositive=false;this._weight=1;this._constraintData=null};a.prototype._computeA=function(){var e=this._target.global;var a=this._root.global;var r=this._root.globalTransformMatrix;var i=Math.atan2(e.y-a.y,e.x-a.x);if(a.scaleX<0){i+=Math.PI}a.rotation+=t.Transform.normalizeRadian(i-a.rotation)*this._weight;a.toMatrix(r)};a.prototype._computeB=function(){var e=this._bone._boneData.length;var a=this._root;var r=this._target.global;var i=a.global;var n=this._bone.global;var s=this._bone.globalTransformMatrix;var o=s.a*e;var l=s.b*e;var h=o*o+l*l;var f=Math.sqrt(h);var u=n.x-i.x;var _=n.y-i.y;var c=u*u+_*_;var p=Math.sqrt(c);var m=n.rotation;var d=i.rotation;var v=Math.atan2(_,u);u=r.x-i.x;_=r.y-i.y;var y=u*u+_*_;var g=Math.sqrt(y);var b=0;if(f+p<=g||g+f<=p||g+p<=f){b=Math.atan2(r.y-i.y,r.x-i.x);if(f+p<=g){}else if(p<f){b+=Math.PI}}else{var D=(c-h+y)/(2*y);var T=Math.sqrt(c-D*D*y)/g;var A=i.x+u*D;var x=i.y+_*D;var P=-_*T;var O=u*T;var S=false;var E=a.parent;if(E!==null){var M=E.globalTransformMatrix;S=M.a*M.d-M.b*M.c<0}if(S!==this._bendPositive){n.x=A-P;n.y=x-O}else{n.x=A+P;n.y=x+O}b=Math.atan2(n.y-i.y,n.x-i.x)}var B=t.Transform.normalizeRadian(b-v);i.rotation=d+B*this._weight;i.toMatrix(a.globalTransformMatrix);var C=v+B*this._weight;n.x=i.x+Math.cos(C)*p;n.y=i.y+Math.sin(C)*p;var w=Math.atan2(r.y-n.y,r.x-n.x);if(n.scaleX<0){w+=Math.PI}n.rotation=i.rotation+m-d+t.Transform.normalizeRadian(w-B-m)*this._weight;n.toMatrix(s)};a.prototype.init=function(t,e){if(this._constraintData!==null){return}this._constraintData=t;this._armature=e;this._target=this._armature.getBone(this._constraintData.target.name);this._root=this._armature.getBone(this._constraintData.root.name);this._bone=this._constraintData.bone!==null?this._armature.getBone(this._constraintData.bone.name):null;{var a=this._constraintData;this._scaleEnabled=a.scaleEnabled;this._bendPositive=a.bendPositive;this._weight=a.weight}this._root._hasConstraint=true};a.prototype.update=function(){this._root.updateByConstraint();if(this._bone!==null){this._bone.updateByConstraint();this._computeB()}else{this._computeA()}};a.prototype.invalidUpdate=function(){this._root.invalidUpdate();if(this._bone!==null){this._bone.invalidUpdate()}};return a}(e);t.IKConstraint=a;var r=function(e){__extends(a,e);function a(){var t=e!==null&&e.apply(this,arguments)||this;t._bones=[];t._spaces=[];t._positions=[];t._curves=[];t._boneLengths=[];t._pathGlobalVertices=[];t._segments=[10];return t}a.toString=function(){return"[class dragonBones.PathConstraint]"};a.prototype._onClear=function(){e.prototype._onClear.call(this);this.dirty=false;this.pathOffset=0;this.position=0;this.spacing=0;this.rotateOffset=0;this.rotateMix=1;this.translateMix=1;this._pathSlot=null;this._bones.length=0;this._spaces.length=0;this._positions.length=0;this._curves.length=0;this._boneLengths.length=0;this._pathGlobalVertices.length=0};a.prototype._updatePathVertices=function(t){var e=this._armature;var a=e.armatureData.parent;var r=e.armatureData.scale;var i=a.intArray;var n=a.floatArray;var s=t.offset;var o=i[s+0];var l=i[s+2];this._pathGlobalVertices.length=o*2;var h=t.weight;if(h===null){var f=this._pathSlot.parent;f.updateByConstraint();var u=f.globalTransformMatrix;for(var _=0,c=l;_<o;_+=2){var p=n[c++]*r;var m=n[c++]*r;var d=u.a*p+u.c*m+u.tx;var v=u.b*p+u.d*m+u.ty;this._pathGlobalVertices[_]=d;this._pathGlobalVertices[_+1]=v}return}var y=this._pathSlot._deformVertices.bones;var g=h.bones.length;var b=h.offset;var D=i[b+1];var T=D;var A=b+2+g;for(var _=0,x=0;_<o;_++){var P=i[A++];var O=0,S=0;for(var E=0,M=P;E<M;E++){var B=i[A++];var C=y[B];if(C===null){continue}C.updateByConstraint();var u=C.globalTransformMatrix;var w=n[T++];var p=n[T++]*r;var m=n[T++]*r;O+=(u.a*p+u.c*m+u.tx)*w;S+=(u.b*p+u.d*m+u.ty)*w}this._pathGlobalVertices[x++]=O;this._pathGlobalVertices[x++]=S}};a.prototype._computeVertices=function(t,e,a,r){for(var i=a,n=t;i<e;i+=2){r[i]=this._pathGlobalVertices[n++];r[i+1]=this._pathGlobalVertices[n++]}};a.prototype._computeBezierCurve=function(t,e,a,r,i){var n=this._armature;var s=n.armatureData.parent.intArray;var o=s[t.vertices.offset+0];var l=this._positions;var h=this._spaces;var f=t.closed;var u=Array();var _=o*2;var c=_/6;var p=-1;var m=this.position;l.length=e*3+2;var d=0;if(!t.constantSpeed){var v=t.curveLengths;c-=f?1:2;d=v[c];if(r){m*=d}if(i){for(var y=0;y<e;y++){h[y]*=d}}u.length=8;for(var y=0,g=0,b=0;y<e;y++,g+=3){var D=h[y];m+=D;if(f){m%=d;if(m<0){m+=d}b=0}else if(m<0){continue}else if(m>d){continue}var T=0;for(;;b++){var A=v[b];if(m>A){continue}if(b===0){T=m/A}else{var x=v[b-1];T=(m-x)/(A-x)}break}if(b!==p){p=b;if(f&&b===c){this._computeVertices(_-4,4,0,u);this._computeVertices(0,4,4,u)}else{this._computeVertices(b*6+2,8,0,u)}}this.addCurvePosition(T,u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7],l,g,a)}return}if(f){_+=2;u.length=o;this._computeVertices(2,_-4,0,u);this._computeVertices(0,2,_-4,u);u[_-2]=u[0];u[_-1]=u[1]}else{c--;_-=4;u.length=_;this._computeVertices(2,_,0,u)}var P=new Array(c);d=0;var O=u[0],S=u[1],E=0,M=0,B=0,C=0,w=0,I=0;var F,N,R,k,j,L,V,U;for(var y=0,Y=2;y<c;y++,Y+=6){E=u[Y];M=u[Y+1];B=u[Y+2];C=u[Y+3];w=u[Y+4];I=u[Y+5];F=(O-E*2+B)*.1875;N=(S-M*2+C)*.1875;R=((E-B)*3-O+w)*.09375;k=((M-C)*3-S+I)*.09375;j=F*2+R;L=N*2+k;V=(E-O)*.75+F+R*.16666667;U=(M-S)*.75+N+k*.16666667;d+=Math.sqrt(V*V+U*U);V+=j;U+=L;j+=R;L+=k;d+=Math.sqrt(V*V+U*U);V+=j;U+=L;d+=Math.sqrt(V*V+U*U);V+=j+R;U+=L+k;d+=Math.sqrt(V*V+U*U);P[y]=d;O=w;S=I}if(r){m*=d}if(i){for(var y=0;y<e;y++){h[y]*=d}}var X=this._segments;var H=0;for(var y=0,g=0,b=0,$=0;y<e;y++,g+=3){var D=h[y];m+=D;var G=m;if(f){G%=d;if(G<0)G+=d;b=0}else if(G<0){continue}else if(G>d){continue}for(;;b++){var W=P[b];if(G>W)continue;if(b===0)G/=W;else{var z=P[b-1];G=(G-z)/(W-z)}break}if(b!==p){p=b;var K=b*6;O=u[K];S=u[K+1];E=u[K+2];M=u[K+3];B=u[K+4];C=u[K+5];w=u[K+6];I=u[K+7];F=(O-E*2+B)*.03;N=(S-M*2+C)*.03;R=((E-B)*3-O+w)*.006;k=((M-C)*3-S+I)*.006;j=F*2+R;L=N*2+k;V=(E-O)*.3+F+R*.16666667;U=(M-S)*.3+N+k*.16666667;H=Math.sqrt(V*V+U*U);X[0]=H;for(K=1;K<8;K++){V+=j;U+=L;j+=R;L+=k;H+=Math.sqrt(V*V+U*U);X[K]=H}V+=j;U+=L;H+=Math.sqrt(V*V+U*U);X[8]=H;V+=j+R;U+=L+k;H+=Math.sqrt(V*V+U*U);X[9]=H;$=0}G*=H;for(;;$++){var Z=X[$];if(G>Z)continue;if($===0)G/=Z;else{var z=X[$-1];G=$+(G-z)/(Z-z)}break}this.addCurvePosition(G*.1,O,S,E,M,B,C,w,I,l,g,a)}};a.prototype.addCurvePosition=function(t,e,a,r,i,n,s,o,l,h,f,u){if(t===0){h[f]=e;h[f+1]=a;h[f+2]=0;return}if(t===1){h[f]=o;h[f+1]=l;h[f+2]=0;return}var _=1-t;var c=_*_;var p=t*t;var m=c*_;var d=c*t*3;var v=_*p*3;var y=t*p;var g=m*e+d*r+v*n+y*o;var b=m*a+d*i+v*s+y*l;h[f]=g;h[f+1]=b;if(u){h[f+2]=Math.atan2(b-(m*a+d*i+v*s),g-(m*e+d*r+v*n))}else{h[f+2]=0}};a.prototype.init=function(t,e){this._constraintData=t;this._armature=e;var a=t;this.pathOffset=a.pathDisplayData.vertices.offset;this.position=a.position;this.spacing=a.spacing;this.rotateOffset=a.rotateOffset;this.rotateMix=a.rotateMix;this.translateMix=a.translateMix;this._root=this._armature.getBone(a.root.name);this._target=this._armature.getBone(a.target.name);this._pathSlot=this._armature.getSlot(a.pathSlot.name);for(var r=0,i=a.bones.length;r<i;r++){var n=this._armature.getBone(a.bones[r].name);if(n!==null){this._bones.push(n)}}if(a.rotateMode===2){this._boneLengths.length=this._bones.length}this._root._hasConstraint=true};a.prototype.update=function(){var e=this._pathSlot;if(e._deformVertices===null||e._deformVertices.verticesData===null||e._deformVertices.verticesData.offset!==this.pathOffset){return}var a=this._constraintData;var r=e._displayData;var i=false;var n=e._deformVertices;if(this._root._childrenTransformDirty){this._updatePathVertices(r.vertices);i=true}else if(n!==null&&(n.verticesDirty||n.isBonesUpdate())){this._updatePathVertices(r.vertices);n.verticesDirty=false;i=true}if(!i&&!this.dirty){return}var s=a.positionMode;var o=a.spacingMode;var l=a.rotateMode;var h=this._bones;var f=o===0;var u=l===2;var _=l===0;var c=h.length;var p=_?c:c+1;var m=this.spacing;var d=this._spaces;d.length=p;if(u||f){d[0]=0;for(var v=0,y=p-1;v<y;v++){var g=h[v];g.updateByConstraint();var b=g._boneData.length;var D=g.globalTransformMatrix;var T=b*D.a;var A=b*D.b;var x=Math.sqrt(T*T+A*A);if(u){this._boneLengths[v]=x}d[v+1]=(b+m)*x/b}}else{for(var v=0;v<p;v++){d[v]=m}}this._computeBezierCurve(r,p,_,s===1,o===2);var P=this._positions;var O=this.rotateOffset;var S=P[0],E=P[1];var M;if(O===0){M=l===1}else{M=false;var g=e.parent;if(g!==null){var D=g.globalTransformMatrix;O*=D.a*D.d-D.b*D.c>0?t.Transform.DEG_RAD:-t.Transform.DEG_RAD}}var B=this.rotateMix;var C=this.translateMix;for(var v=0,w=3;v<c;v++,w+=3){var g=h[v];g.updateByConstraint();var D=g.globalTransformMatrix;D.tx+=(S-D.tx)*C;D.ty+=(E-D.ty)*C;var T=P[w],A=P[w+1];var I=T-S,F=A-E;if(u){var N=this._boneLengths[v];var R=(Math.sqrt(I*I+F*F)/N-1)*B+1;D.a*=R;D.b*=R}S=T;E=A;if(B>0){var k=D.a,j=D.b,L=D.c,V=D.d,U=void 0,Y=void 0,X=void 0;if(_){U=P[w-1]}else{U=Math.atan2(F,I)}U-=Math.atan2(j,k);if(M){Y=Math.cos(U);X=Math.sin(U);var H=g._boneData.length;S+=(H*(Y*k-X*j)-I)*B;E+=(H*(X*k+Y*j)-F)*B}else{U+=O}if(U>t.Transform.PI){U-=t.Transform.PI_D}else if(U<-t.Transform.PI){U+=t.Transform.PI_D}U*=B;Y=Math.cos(U);X=Math.sin(U);D.a=Y*k-X*j;D.b=X*k+Y*j;D.c=Y*L-X*V;D.d=X*L+Y*V}g.global.fromMatrix(D)}this.dirty=false};a.prototype.invalidUpdate=function(){};return a}(e);t.PathConstraint=r})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function t(t){if(t===void 0){t=0}this.time=0;this.timeScale=1;this._systemTime=0;this._animatebles=[];this._clock=null;this.time=t;this._systemTime=(new Date).getTime()*.001}t.prototype.advanceTime=function(t){if(t!==t){t=0}var e=Date.now()*.001;if(t<0){t=e-this._systemTime}this._systemTime=e;if(this.timeScale!==1){t*=this.timeScale}if(t===0){return}if(t<0){this.time-=t}else{this.time+=t}var a=0,r=0,i=this._animatebles.length;for(;a<i;++a){var n=this._animatebles[a];if(n!==null){if(r>0){this._animatebles[a-r]=n;this._animatebles[a]=null}n.advanceTime(t)}else{r++}}if(r>0){i=this._animatebles.length;for(;a<i;++a){var s=this._animatebles[a];if(s!==null){this._animatebles[a-r]=s}else{r++}}this._animatebles.length-=r}};t.prototype.contains=function(t){if(t===this){return false}var e=t;while(e!==this&&e!==null){e=e.clock}return e===this};t.prototype.add=function(t){if(this._animatebles.indexOf(t)<0){this._animatebles.push(t);t.clock=this}};t.prototype.remove=function(t){var e=this._animatebles.indexOf(t);if(e>=0){this._animatebles[e]=null;t.clock=null}};t.prototype.clear=function(){for(var t=0,e=this._animatebles;t<e.length;t++){var a=e[t];if(a!==null){a.clock=null}}};Object.defineProperty(t.prototype,"clock",{get:function(){return this._clock},set:function(t){if(this._clock===t){return}if(this._clock!==null){this._clock.remove(this)}this._clock=t;if(this._clock!==null){this._clock.add(this)}},enumerable:true,configurable:true});t.clock=new t;return t}();t.WorldClock=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){var t=e!==null&&e.apply(this,arguments)||this;t._animationNames=[];t._animationStates=[];t._animations={};t._animationConfig=null;return t}a.toString=function(){return"[class dragonBones.Animation]"};a.prototype._onClear=function(){for(var t=0,e=this._animationStates;t<e.length;t++){var a=e[t];a.returnToPool()}for(var r in this._animations){delete this._animations[r]}if(this._animationConfig!==null){this._animationConfig.returnToPool()}this.timeScale=1;this._lockUpdate=false;this._animationDirty=false;this._inheritTimeScale=1;this._animationNames.length=0;this._animationStates.length=0;this._armature=null;this._animationConfig=null;this._lastAnimationState=null};a.prototype._fadeOut=function(t){switch(t.fadeOutMode){case 1:for(var e=0,a=this._animationStates;e<a.length;e++){var r=a[e];if(r._parent!==null){continue}if(r.layer===t.layer){r.fadeOut(t.fadeOutTime,t.pauseFadeOut)}}break;case 2:for(var i=0,n=this._animationStates;i<n.length;i++){var r=n[i];if(r._parent!==null){continue}if(r.group===t.group){r.fadeOut(t.fadeOutTime,t.pauseFadeOut)}}break;case 3:for(var s=0,o=this._animationStates;s<o.length;s++){var r=o[s];if(r._parent!==null){continue}if(r.layer===t.layer&&r.group===t.group){r.fadeOut(t.fadeOutTime,t.pauseFadeOut)}}break;case 4:for(var l=0,h=this._animationStates;l<h.length;l++){var r=h[l];if(r._parent!==null){continue}r.fadeOut(t.fadeOutTime,t.pauseFadeOut)}break;case 0:case 5:default:break}};a.prototype.init=function(e){if(this._armature!==null){return}this._armature=e;this._animationConfig=t.BaseObject.borrowObject(t.AnimationConfig)};a.prototype.advanceTime=function(t){if(t<0){t=-t}if(this._armature.inheritAnimation&&this._armature._parent!==null){this._inheritTimeScale=this._armature._parent._armature.animation._inheritTimeScale*this.timeScale}else{this._inheritTimeScale=this.timeScale}if(this._inheritTimeScale!==1){t*=this._inheritTimeScale}var e=this._animationStates.length;if(e===1){var a=this._animationStates[0];if(a._fadeState>0&&a._subFadeState>0){this._armature._dragonBones.bufferObject(a);this._animationStates.length=0;this._lastAnimationState=null}else{var r=a._animationData;var i=r.cacheFrameRate;if(this._animationDirty&&i>0){this._animationDirty=false;for(var n=0,s=this._armature.getBones();n<s.length;n++){var o=s[n];o._cachedFrameIndices=r.getBoneCachedFrameIndices(o.name)}for(var l=0,h=this._armature.getSlots();l<h.length;l++){var f=h[l];var u=f.rawDisplayDatas;if(u!==null&&u.length>0){var _=u[0];if(_!==null){if(_.parent===this._armature.armatureData.defaultSkin){f._cachedFrameIndices=r.getSlotCachedFrameIndices(f.name);continue}}}f._cachedFrameIndices=null}}a.advanceTime(t,i)}}else if(e>1){for(var c=0,p=0;c<e;++c){var a=this._animationStates[c];if(a._fadeState>0&&a._subFadeState>0){p++;this._armature._dragonBones.bufferObject(a);this._animationDirty=true;if(this._lastAnimationState===a){this._lastAnimationState=null}}else{if(p>0){this._animationStates[c-p]=a}a.advanceTime(t,0)}if(c===e-1&&p>0){this._animationStates.length-=p;if(this._lastAnimationState===null&&this._animationStates.length>0){this._lastAnimationState=this._animationStates[this._animationStates.length-1]}}}this._armature._cacheFrameIndex=-1}else{this._armature._cacheFrameIndex=-1}};a.prototype.reset=function(){for(var t=0,e=this._animationStates;t<e.length;t++){var a=e[t];a.returnToPool()}this._animationDirty=false;this._animationConfig.clear();this._animationStates.length=0;this._lastAnimationState=null};a.prototype.stop=function(t){if(t===void 0){t=null}if(t!==null){var e=this.getState(t);if(e!==null){e.stop()}}else{for(var a=0,r=this._animationStates;a<r.length;a++){var e=r[a];e.stop()}}};a.prototype.playConfig=function(e){var a=e.animation;if(!(a in this._animations)){console.warn("Non-existent animation.\n","DragonBones name: "+this._armature.armatureData.parent.name,"Armature name: "+this._armature.name,"Animation name: "+a);return null}var r=this._animations[a];if(e.fadeOutMode===5){for(var i=0,n=this._animationStates;i<n.length;i++){var s=n[i];if(s._animationData===r){return s}}}if(this._animationStates.length===0){e.fadeInTime=0}else if(e.fadeInTime<0){e.fadeInTime=r.fadeInTime}if(e.fadeOutTime<0){e.fadeOutTime=e.fadeInTime}if(e.timeScale<=-100){e.timeScale=1/r.scale}if(r.frameCount>1){if(e.position<0){e.position%=r.duration;e.position=r.duration-e.position}else if(e.position===r.duration){e.position-=1e-6}else if(e.position>r.duration){e.position%=r.duration}if(e.duration>0&&e.position+e.duration>r.duration){e.duration=r.duration-e.position}if(e.playTimes<0){e.playTimes=r.playTimes}}else{e.playTimes=1;e.position=0;if(e.duration>0){e.duration=0}}if(e.duration===0){e.duration=-1}this._fadeOut(e);var o=t.BaseObject.borrowObject(t.AnimationState);o.init(this._armature,r,e);this._animationDirty=true;this._armature._cacheFrameIndex=-1;if(this._animationStates.length>0){var l=false;for(var h=0,f=this._animationStates.length;h<f;++h){if(o.layer>this._animationStates[h].layer){l=true;this._animationStates.splice(h,0,o);break}else if(h!==f-1&&o.layer>this._animationStates[h+1].layer){l=true;this._animationStates.splice(h+1,0,o);break}}if(!l){this._animationStates.push(o)}}else{this._animationStates.push(o)}for(var u=0,_=this._armature.getSlots();u<_.length;u++){var c=_[u];var p=c.childArmature;if(p!==null&&p.inheritAnimation&&p.animation.hasAnimation(a)&&p.animation.getState(a)===null){p.animation.fadeIn(a)}}var m=false;for(var d in r.animationTimelines){if(!this._lockUpdate){m=true;this._lockUpdate=true}var v=this.fadeIn(d,e.fadeInTime,1,o.layer,null,0);if(v!==null){v.resetToPose=false;v._parent=o;v.stop()}}if(m){this._lockUpdate=false}if(!this._lockUpdate){if(e.fadeInTime<=0){this._armature.advanceTime(0)}this._lastAnimationState=o}return o};a.prototype.play=function(t,e){if(t===void 0){t=null}if(e===void 0){e=-1}this._animationConfig.clear();this._animationConfig.resetToPose=true;this._animationConfig.playTimes=e;this._animationConfig.fadeInTime=0;this._animationConfig.animation=t!==null?t:"";if(t!==null&&t.length>0){this.playConfig(this._animationConfig)}else if(this._lastAnimationState===null){var a=this._armature.armatureData.defaultAnimation;if(a!==null){this._animationConfig.animation=a.name;this.playConfig(this._animationConfig)}}else if(!this._lastAnimationState.isPlaying&&!this._lastAnimationState.isCompleted){this._lastAnimationState.play()}else{this._animationConfig.animation=this._lastAnimationState.name;this.playConfig(this._animationConfig)}return this._lastAnimationState};a.prototype.fadeIn=function(t,e,a,r,i,n){if(e===void 0){e=-1}if(a===void 0){a=-1}if(r===void 0){r=0}if(i===void 0){i=null}if(n===void 0){n=3}this._animationConfig.clear();this._animationConfig.fadeOutMode=n;this._animationConfig.playTimes=a;this._animationConfig.layer=r;this._animationConfig.fadeInTime=e;this._animationConfig.animation=t;this._animationConfig.group=i!==null?i:"";return this.playConfig(this._animationConfig)};a.prototype.gotoAndPlayByTime=function(t,e,a){if(e===void 0){e=0}if(a===void 0){a=-1}this._animationConfig.clear();this._animationConfig.resetToPose=true;this._animationConfig.playTimes=a;this._animationConfig.position=e;this._animationConfig.fadeInTime=0;this._animationConfig.animation=t;return this.playConfig(this._animationConfig)};a.prototype.gotoAndPlayByFrame=function(t,e,a){if(e===void 0){e=0}if(a===void 0){a=-1}this._animationConfig.clear();this._animationConfig.resetToPose=true;this._animationConfig.playTimes=a;this._animationConfig.fadeInTime=0;this._animationConfig.animation=t;var r=t in this._animations?this._animations[t]:null;if(r!==null){this._animationConfig.position=r.duration*e/r.frameCount}return this.playConfig(this._animationConfig)};a.prototype.gotoAndPlayByProgress=function(t,e,a){if(e===void 0){e=0}if(a===void 0){a=-1}this._animationConfig.clear();this._animationConfig.resetToPose=true;this._animationConfig.playTimes=a;this._animationConfig.fadeInTime=0;this._animationConfig.animation=t;var r=t in this._animations?this._animations[t]:null;if(r!==null){this._animationConfig.position=r.duration*(e>0?e:0)}return this.playConfig(this._animationConfig)};a.prototype.gotoAndStopByTime=function(t,e){if(e===void 0){e=0}var a=this.gotoAndPlayByTime(t,e,1);if(a!==null){a.stop()}return a};a.prototype.gotoAndStopByFrame=function(t,e){if(e===void 0){e=0}var a=this.gotoAndPlayByFrame(t,e,1);if(a!==null){a.stop()}return a};a.prototype.gotoAndStopByProgress=function(t,e){if(e===void 0){e=0}var a=this.gotoAndPlayByProgress(t,e,1);if(a!==null){a.stop()}return a};a.prototype.getState=function(t){var e=this._animationStates.length;while(e--){var a=this._animationStates[e];if(a.name===t){return a}}return null};a.prototype.hasAnimation=function(t){return t in this._animations};a.prototype.getStates=function(){return this._animationStates};Object.defineProperty(a.prototype,"isPlaying",{get:function(){for(var t=0,e=this._animationStates;t<e.length;t++){var a=e[t];if(a.isPlaying){return true}}return false},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"isCompleted",{get:function(){for(var t=0,e=this._animationStates;t<e.length;t++){var a=e[t];if(!a.isCompleted){return false}}return this._animationStates.length>0},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"lastAnimationName",{get:function(){return this._lastAnimationState!==null?this._lastAnimationState.name:""},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"animationNames",{get:function(){return this._animationNames},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"animations",{get:function(){return this._animations},set:function(t){if(this._animations===t){return}this._animationNames.length=0;for(var e in this._animations){delete this._animations[e]}for(var e in t){this._animationNames.push(e);this._animations[e]=t[e]}},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"animationConfig",{get:function(){this._animationConfig.clear();return this._animationConfig},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"lastAnimationState",{get:function(){return this._lastAnimationState},enumerable:true,configurable:true});a.prototype.gotoAndPlay=function(t,e,a,r,i,n,s,o,l){if(e===void 0){e=-1}if(a===void 0){a=-1}if(r===void 0){r=-1}if(i===void 0){i=0}if(n===void 0){n=null}if(s===void 0){s=3}if(o===void 0){o=true}if(l===void 0){l=true}console.warn("Deprecated.");o;l;this._animationConfig.clear();this._animationConfig.resetToPose=true;this._animationConfig.fadeOutMode=s;this._animationConfig.playTimes=r;this._animationConfig.layer=i;this._animationConfig.fadeInTime=e;this._animationConfig.animation=t;this._animationConfig.group=n!==null?n:"";var h=this._animations[t];if(h&&a>0){this._animationConfig.timeScale=h.duration/a}return this.playConfig(this._animationConfig)};a.prototype.gotoAndStop=function(t,e){if(e===void 0){e=0}console.warn("Deprecated.");return this.gotoAndStopByTime(t,e)};Object.defineProperty(a.prototype,"animationList",{get:function(){console.warn("Deprecated.");return this._animationNames},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"animationDataList",{get:function(){console.warn("Deprecated.");var t=[];for(var e=0,a=this._animationNames.length;e<a;++e){t.push(this._animations[this._animationNames[e]])}return t},enumerable:true,configurable:true});return a}(t.BaseObject);t.Animation=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(i,e);function i(){var t=e!==null&&e.apply(this,arguments)||this;t._blendState=new r;t._boneMask=[];t._boneTimelines=[];t._surfaceTimelines=[];t._slotTimelines=[];t._constraintTimelines=[];t._animationTimelines=[];t._poseTimelines=[];t._bonePoses={};t._actionTimeline=null;t._zOrderTimeline=null;t._parent=null;return t}i.toString=function(){return"[class dragonBones.AnimationState]"};i.prototype._onClear=function(){for(var t=0,e=this._boneTimelines;t<e.length;t++){var a=e[t];a.returnToPool()}for(var r=0,i=this._surfaceTimelines;r<i.length;r++){var a=i[r];a.returnToPool()}for(var n=0,s=this._slotTimelines;n<s.length;n++){var a=s[n];a.returnToPool()}for(var o=0,l=this._constraintTimelines;o<l.length;o++){var a=l[o];a.returnToPool()}for(var h=0,f=this._animationTimelines;h<f.length;h++){var a=f[h];a.returnToPool()}for(var u in this._bonePoses){this._bonePoses[u].returnToPool();delete this._bonePoses[u]}if(this._actionTimeline!==null){this._actionTimeline.returnToPool()}if(this._zOrderTimeline!==null){this._zOrderTimeline.returnToPool()}this.actionEnabled=false;this.additiveBlending=false;this.displayControl=false;this.resetToPose=false;this.playTimes=1;this.layer=0;this.timeScale=1;this.weight=1;this.autoFadeOutTime=0;this.fadeTotalTime=0;this.name="";this.group="";this._timelineDirty=2;this._playheadState=0;this._fadeState=-1;this._subFadeState=-1;this._position=0;this._duration=0;this._fadeTime=0;this._time=0;this._fadeProgress=0;this._weightResult=0;this._blendState.clear();this._boneMask.length=0;this._boneTimelines.length=0;this._surfaceTimelines.length=0;this._slotTimelines.length=0;this._constraintTimelines.length=0;this._animationTimelines.length=0;this._poseTimelines.length=0;this._animationData=null;this._armature=null;this._actionTimeline=null;this._zOrderTimeline=null;this._parent=null};i.prototype._updateTimelines=function(){{for(var e=0,a=this._armature._constraints;e<a.length;e++){var r=a[e];var i=this._animationData.getConstraintTimelines(r.name);if(i!==null){for(var n=0,s=i;n<s.length;n++){var o=s[n];switch(o.type){case 30:{var l=t.BaseObject.borrowObject(t.IKConstraintTimelineState);l.constraint=r;l.init(this._armature,this,o);this._constraintTimelines.push(l);break}default:break}}}else if(this.resetToPose){var l=t.BaseObject.borrowObject(t.IKConstraintTimelineState);l.constraint=r;l.init(this._armature,this,null);this._constraintTimelines.push(l);this._poseTimelines.push(l)}}}{for(var h=0,f=this._armature.animation.getStates();h<f.length;h++){var u=f[h];if(u._parent!==this){continue}var i=this._animationData.getAnimationTimelines(u.name);if(i===null){continue}for(var _=0,c=i;_<c.length;_++){var o=c[_];switch(o.type){case 40:{var l=t.BaseObject.borrowObject(t.AnimationTimelineState);l.animationState=u;l.init(this._armature,this,o);this._animationTimelines.push(l);break}default:break}}}}};i.prototype._updateBoneAndSlotTimelines=function(){{var e={};for(var r=0,i=this._boneTimelines;r<i.length;r++){var n=i[r];var s=n.bone.name;if(!(s in e)){e[s]=[]}e[s].push(n)}for(var o=0,l=this._armature.getBones();o<l.length;o++){var h=l[o];var s=h.name;if(!this.containsBoneMask(s)){continue}if(s in e){delete e[s]}else if(h._boneData.type===0){var f=this._animationData.getBoneTimelines(s);var u=s in this._bonePoses?this._bonePoses[s]:this._bonePoses[s]=t.BaseObject.borrowObject(a);if(f!==null){for(var _=0,c=f;_<c.length;_++){var p=c[_];switch(p.type){case 10:{var n=t.BaseObject.borrowObject(t.BoneAllTimelineState);n.bone=h;n.bonePose=u;n.init(this._armature,this,p);this._boneTimelines.push(n);break}case 11:{var n=t.BaseObject.borrowObject(t.BoneTranslateTimelineState);n.bone=h;n.bonePose=u;n.init(this._armature,this,p);this._boneTimelines.push(n);break}case 12:{var n=t.BaseObject.borrowObject(t.BoneRotateTimelineState);n.bone=h;n.bonePose=u;n.init(this._armature,this,p);this._boneTimelines.push(n);break}case 13:{var n=t.BaseObject.borrowObject(t.BoneScaleTimelineState);n.bone=h;n.bonePose=u;n.init(this._armature,this,p);this._boneTimelines.push(n);break}default:break}}}else if(this.resetToPose){var n=t.BaseObject.borrowObject(t.BoneAllTimelineState);n.bone=h;n.bonePose=u;n.init(this._armature,this,null);this._boneTimelines.push(n);this._poseTimelines.push(n)}}else if(h._boneData.type===1){var f=this._animationData.getSurfaceTimelines(s);if(f!==null){for(var m=0,d=f;m<d.length;m++){var p=d[m];switch(p.type){case 50:{var n=t.BaseObject.borrowObject(t.SurfaceTimelineState);n.surface=h;n.init(this._armature,this,p);this._surfaceTimelines.push(n);break}default:break}}}else if(this.resetToPose){var n=t.BaseObject.borrowObject(t.SurfaceTimelineState);n.surface=h;n.init(this._armature,this,null);this._surfaceTimelines.push(n);this._poseTimelines.push(n)}}}for(var v in e){for(var y=0,g=e[v];y<g.length;y++){var n=g[y];this._boneTimelines.splice(this._boneTimelines.indexOf(n),1);n.returnToPool()}}}{var b={};var D=[];for(var T=0,A=this._slotTimelines;T<A.length;T++){var n=A[T];var s=n.slot.name;if(!(s in b)){b[s]=[]}b[s].push(n)}for(var x=0,P=this._armature.getSlots();x<P.length;x++){var O=P[x];var S=O.parent.name;if(!this.containsBoneMask(S)){continue}var s=O.name;var f=this._animationData.getSlotTimelines(s);if(s in b){delete b[s]}else{var E=false;var M=false;D.length=0;if(f!==null){for(var B=0,C=f;B<C.length;B++){var p=C[B];switch(p.type){case 20:{var n=t.BaseObject.borrowObject(t.SlotDislayTimelineState);n.slot=O;n.init(this._armature,this,p);this._slotTimelines.push(n);E=true;break}case 21:{var n=t.BaseObject.borrowObject(t.SlotColorTimelineState);n.slot=O;n.init(this._armature,this,p);this._slotTimelines.push(n);M=true;break}case 22:{var n=t.BaseObject.borrowObject(t.DeformTimelineState);n.slot=O;n.init(this._armature,this,p);this._slotTimelines.push(n);D.push(n.vertexOffset);break}default:break}}}if(this.resetToPose){if(!E){var n=t.BaseObject.borrowObject(t.SlotDislayTimelineState);n.slot=O;n.init(this._armature,this,null);this._slotTimelines.push(n);this._poseTimelines.push(n)}if(!M){var n=t.BaseObject.borrowObject(t.SlotColorTimelineState);n.slot=O;n.init(this._armature,this,null);this._slotTimelines.push(n);this._poseTimelines.push(n)}if(O.rawDisplayDatas!==null){for(var w=0,I=O.rawDisplayDatas;w<I.length;w++){var F=I[w];if(F!==null&&F.type===2){var N=F.vertices.offset;if(D.indexOf(N)<0){var n=t.BaseObject.borrowObject(t.DeformTimelineState);n.vertexOffset=N;n.slot=O;n.init(this._armature,this,null);this._slotTimelines.push(n);this._poseTimelines.push(n)}}}}}}}for(var v in b){for(var R=0,k=b[v];R<k.length;R++){var n=k[R];this._slotTimelines.splice(this._slotTimelines.indexOf(n),1);n.returnToPool()}}}};i.prototype._advanceFadeTime=function(e){var a=this._fadeState>0;if(this._subFadeState<0){this._subFadeState=0;var r=a?t.EventObject.FADE_OUT:t.EventObject.FADE_IN;if(this._armature.eventDispatcher.hasDBEventListener(r)){var i=t.BaseObject.borrowObject(t.EventObject);i.type=r;i.armature=this._armature;i.animationState=this;this._armature._dragonBones.bufferEvent(i)}}if(e<0){e=-e}this._fadeTime+=e;if(this._fadeTime>=this.fadeTotalTime){this._subFadeState=1;this._fadeProgress=a?0:1}else if(this._fadeTime>0){this._fadeProgress=a?1-this._fadeTime/this.fadeTotalTime:this._fadeTime/this.fadeTotalTime}else{this._fadeProgress=a?1:0}if(this._subFadeState>0){if(!a){this._playheadState|=1;this._fadeState=0}var r=a?t.EventObject.FADE_OUT_COMPLETE:t.EventObject.FADE_IN_COMPLETE;if(this._armature.eventDispatcher.hasDBEventListener(r)){var i=t.BaseObject.borrowObject(t.EventObject);i.type=r;i.armature=this._armature;i.animationState=this;this._armature._dragonBones.bufferEvent(i)}}};i.prototype.init=function(e,a,r){if(this._armature!==null){return}this._armature=e;this._animationData=a;this.resetToPose=r.resetToPose;this.additiveBlending=r.additiveBlending;this.displayControl=r.displayControl;this.actionEnabled=r.actionEnabled;this.layer=r.layer;this.playTimes=r.playTimes;this.timeScale=r.timeScale;this.fadeTotalTime=r.fadeInTime;this.autoFadeOutTime=r.autoFadeOutTime;this.weight=r.weight;this.name=r.name.length>0?r.name:r.animation;this.group=r.group;if(r.pauseFadeIn){this._playheadState=2}else{this._playheadState=3}if(r.duration<0){this._position=0;this._duration=this._animationData.duration;if(r.position!==0){if(this.timeScale>=0){this._time=r.position}else{this._time=r.position-this._duration}}else{this._time=0}}else{this._position=r.position;this._duration=r.duration;this._time=0}if(this.timeScale<0&&this._time===0){this._time=-1e-6}if(this.fadeTotalTime<=0){this._fadeProgress=.999999}if(r.boneMask.length>0){this._boneMask.length=r.boneMask.length;for(var i=0,n=this._boneMask.length;i<n;++i){this._boneMask[i]=r.boneMask[i]}}this._actionTimeline=t.BaseObject.borrowObject(t.ActionTimelineState);this._actionTimeline.init(this._armature,this,this._animationData.actionTimeline);this._actionTimeline.currentTime=this._time;if(this._actionTimeline.currentTime<0){this._actionTimeline.currentTime=this._duration-this._actionTimeline.currentTime}if(this._animationData.zOrderTimeline!==null){this._zOrderTimeline=t.BaseObject.borrowObject(t.ZOrderTimelineState);this._zOrderTimeline.init(this._armature,this,this._animationData.zOrderTimeline)}};i.prototype.advanceTime=function(e,a){this._blendState.dirty=false;if(this._fadeState!==0||this._subFadeState!==0){this._advanceFadeTime(e)}if(this._playheadState===3){if(this.timeScale!==1){e*=this.timeScale}this._time+=e}if(this._timelineDirty!==0){if(this._timelineDirty===2){this._updateTimelines()}this._timelineDirty=0;this._updateBoneAndSlotTimelines()}if(this.weight===0){return}var r=this._fadeState===0&&a>0;var i=true;var n=true;var s=this._time;this._weightResult=this.weight*this._fadeProgress;if(this._parent!==null){this._weightResult*=this._parent._weightResult/this._parent._fadeProgress}if(this._actionTimeline.playState<=0){this._actionTimeline.update(s)}if(r){var o=a*2;this._actionTimeline.currentTime=Math.floor(this._actionTimeline.currentTime*o)/o}if(this._zOrderTimeline!==null&&this._zOrderTimeline.playState<=0){this._zOrderTimeline.update(s)}if(r){var l=Math.floor(this._actionTimeline.currentTime*a);if(this._armature._cacheFrameIndex===l){i=false;n=false}else{this._armature._cacheFrameIndex=l;if(this._animationData.cachedFrames[l]){n=false}else{this._animationData.cachedFrames[l]=true}}}if(i){if(n){for(var h=0,f=this._boneTimelines.length;h<f;++h){var u=this._boneTimelines[h];if(u.playState<=0){u.update(s)}if(h===f-1||u.bone!==this._boneTimelines[h+1].bone){var _=u.bone._blendState.update(this._weightResult,this.layer);if(_!==0){u.blend(_)}}}}for(var h=0,f=this._surfaceTimelines.length;h<f;++h){var u=this._surfaceTimelines[h];var _=u.surface._blendState.update(this._weightResult,this.layer);if(u.playState<=0){u.update(s)}if(_!==0){u.blend(_)}}if(this.displayControl){for(var h=0,f=this._slotTimelines.length;h<f;++h){var u=this._slotTimelines[h];var c=u.slot.displayController;if(c===null||c===this.name||c===this.group){if(u.playState<=0){u.update(s)}}}}for(var h=0,f=this._constraintTimelines.length;h<f;++h){var u=this._constraintTimelines[h];if(u.playState<=0){u.update(s)}}for(var h=0,f=this._animationTimelines.length;h<f;++h){var u=this._animationTimelines[h];var _=u.animationState._blendState.update(this._weightResult,this.layer);if(u.playState<=0){u.update(s)}if(_!==0){u.blend(_)}}}if(this._fadeState===0){if(this._subFadeState>0){this._subFadeState=0;if(this._poseTimelines.length>0){for(var p=0,m=this._poseTimelines;p<m.length;p++){var u=m[p];if(u instanceof t.BoneTimelineState){this._boneTimelines.splice(this._boneTimelines.indexOf(u),1)}else if(u instanceof t.SurfaceTimelineState){this._surfaceTimelines.splice(this._surfaceTimelines.indexOf(u),1)}else if(u instanceof t.SlotTimelineState){this._slotTimelines.splice(this._slotTimelines.indexOf(u),1)}else if(u instanceof t.ConstraintTimelineState){this._constraintTimelines.splice(this._constraintTimelines.indexOf(u),1)}u.returnToPool()}this._poseTimelines.length=0}}if(this._actionTimeline.playState>0){if(this.autoFadeOutTime>=0){this.fadeOut(this.autoFadeOutTime)}}}};i.prototype.play=function(){this._playheadState=3};i.prototype.stop=function(){this._playheadState&=1};i.prototype.fadeOut=function(t,e){if(e===void 0){e=true}if(t<0){t=0}if(e){this._playheadState&=2}if(this._fadeState>0){if(t>this.fadeTotalTime-this._fadeTime){return}}else{this._fadeState=1;this._subFadeState=-1;if(t<=0||this._fadeProgress<=0){this._fadeProgress=1e-6}for(var a=0,r=this._boneTimelines;a<r.length;a++){var i=r[a];i.fadeOut()}for(var n=0,s=this._surfaceTimelines;n<s.length;n++){var i=s[n];i.fadeOut()}for(var o=0,l=this._slotTimelines;o<l.length;o++){var i=l[o];i.fadeOut()}for(var h=0,f=this._constraintTimelines;h<f.length;h++){var i=f[h];i.fadeOut()}for(var u=0,_=this._animationTimelines;u<_.length;u++){var i=_[u];i.animationState.fadeOut(t,e);i.fadeOut()}}this.displayControl=false;this.fadeTotalTime=this._fadeProgress>1e-6?t/this._fadeProgress:0;this._fadeTime=this.fadeTotalTime*(1-this._fadeProgress)};i.prototype.containsBoneMask=function(t){return this._boneMask.length===0||this._boneMask.indexOf(t)>=0};i.prototype.addBoneMask=function(t,e){if(e===void 0){e=true}var a=this._armature.getBone(t);if(a===null){return}if(this._boneMask.indexOf(t)<0){this._boneMask.push(t)}if(e){for(var r=0,i=this._armature.getBones();r<i.length;r++){var n=i[r];if(this._boneMask.indexOf(n.name)<0&&a.contains(n)){this._boneMask.push(n.name)}}}this._timelineDirty=1};i.prototype.removeBoneMask=function(t,e){if(e===void 0){e=true}var a=this._boneMask.indexOf(t);if(a>=0){this._boneMask.splice(a,1)}if(e){var r=this._armature.getBone(t);if(r!==null){var i=this._armature.getBones();if(this._boneMask.length>0){for(var n=0,s=i;n<s.length;n++){var o=s[n];var l=this._boneMask.indexOf(o.name);if(l>=0&&r.contains(o)){this._boneMask.splice(l,1)}}}else{for(var h=0,f=i;h<f.length;h++){var o=f[h];if(o===r){continue}if(!r.contains(o)){this._boneMask.push(o.name)}}}}}this._timelineDirty=1};i.prototype.removeAllBoneMask=function(){this._boneMask.length=0;this._timelineDirty=1};Object.defineProperty(i.prototype,"isFadeIn",{get:function(){return this._fadeState<0},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"isFadeOut",{get:function(){return this._fadeState>0},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"isFadeComplete",{get:function(){return this._fadeState===0},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"isPlaying",{get:function(){return(this._playheadState&2)!==0&&this._actionTimeline.playState<=0},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"isCompleted",{get:function(){return this._actionTimeline.playState>0},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"currentPlayTimes",{get:function(){return this._actionTimeline.currentPlayTimes},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"totalTime",{get:function(){return this._duration},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"currentTime",{get:function(){return this._actionTimeline.currentTime},set:function(t){var e=this._actionTimeline.currentPlayTimes-(this._actionTimeline.playState>0?1:0);if(t<0||this._duration<t){t=t%this._duration+e*this._duration;if(t<0){t+=this._duration}}if(this.playTimes>0&&e===this.playTimes-1&&t===this._duration){t=this._duration-1e-6}if(this._time===t){return}this._time=t;this._actionTimeline.setCurrentTime(this._time);if(this._zOrderTimeline!==null){this._zOrderTimeline.playState=-1}for(var a=0,r=this._boneTimelines;a<r.length;a++){var i=r[a];i.playState=-1}for(var n=0,s=this._slotTimelines;n<s.length;n++){var i=s[n];i.playState=-1}},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"animationData",{get:function(){return this._animationData},enumerable:true,configurable:true});return i}(t.BaseObject);t.AnimationState=e;var a=function(e){__extends(a,e);function a(){var a=e!==null&&e.apply(this,arguments)||this;a.current=new t.Transform;a.delta=new t.Transform;a.result=new t.Transform;return a}a.toString=function(){return"[class dragonBones.BonePose]"};a.prototype._onClear=function(){this.current.identity();this.delta.identity();this.result.identity()};return a}(t.BaseObject);t.BonePose=a;var r=function(){function t(){}t.prototype.update=function(t,e){if(this.dirty){if(this.leftWeight>0){if(this.layer!==e){if(this.layerWeight>=this.leftWeight){this.leftWeight=0;return 0}else{this.layer=e;this.leftWeight-=this.layerWeight;this.layerWeight=0}}}else{return 0}t*=this.leftWeight;this.layerWeight+=t;this.blendWeight=t;return 2}this.dirty=true;this.layer=e;this.layerWeight=t;this.leftWeight=1;this.blendWeight=t;return 1};t.prototype.clear=function(){this.dirty=false;this.layer=0;this.leftWeight=0;this.layerWeight=0;this.blendWeight=0};return t}();t.BlendState=r})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.prototype._onClear=function(){this.playState=-1;this.currentPlayTimes=-1;this.currentTime=-1;this._tweenState=0;this._frameRate=0;this._frameValueOffset=0;this._frameCount=0;this._frameOffset=0;this._frameIndex=-1;this._frameRateR=0;this._position=0;this._duration=0;this._timeScale=1;this._timeOffset=0;this._dragonBonesData=null;this._animationData=null;this._timelineData=null;this._armature=null;this._animationState=null;this._actionTimeline=null;this._frameArray=null;this._frameIntArray=null;this._frameFloatArray=null;this._timelineArray=null;this._frameIndices=null};e.prototype._setCurrentTime=function(t){var e=this.playState;var a=this.currentPlayTimes;var r=this.currentTime;if(this._actionTimeline!==null&&this._frameCount<=1){this.playState=this._actionTimeline.playState>=0?1:-1;this.currentPlayTimes=1;this.currentTime=this._actionTimeline.currentTime}else if(this._actionTimeline===null||this._timeScale!==1||this._timeOffset!==0){var i=this._animationState.playTimes;var n=i*this._duration;t*=this._timeScale;if(this._timeOffset!==0){t+=this._timeOffset*this._animationData.duration}if(i>0&&(t>=n||t<=-n)){if(this.playState<=0&&this._animationState._playheadState===3){this.playState=1}this.currentPlayTimes=i;if(t<0){this.currentTime=0}else{this.currentTime=this._duration+1e-6}}else{if(this.playState!==0&&this._animationState._playheadState===3){this.playState=0}if(t<0){t=-t;this.currentPlayTimes=Math.floor(t/this._duration);this.currentTime=this._duration-t%this._duration}else{this.currentPlayTimes=Math.floor(t/this._duration);this.currentTime=t%this._duration}}this.currentTime+=this._position}else{this.playState=this._actionTimeline.playState;this.currentPlayTimes=this._actionTimeline.currentPlayTimes;this.currentTime=this._actionTimeline.currentTime}if(this.currentPlayTimes===a&&this.currentTime===r){return false}if(e<0&&this.playState!==e||this.playState<=0&&this.currentPlayTimes!==a){this._frameIndex=-1}return true};e.prototype.init=function(t,e,a){this._armature=t;this._animationState=e;this._timelineData=a;this._actionTimeline=this._animationState._actionTimeline;if(this===this._actionTimeline){this._actionTimeline=null}this._animationData=this._animationState._animationData;this._frameRate=this._animationData.parent.frameRate;this._frameRateR=1/this._frameRate;this._position=this._animationState._position;this._duration=this._animationState._duration;this._dragonBonesData=this._animationData.parent.parent;if(this._timelineData!==null){this._frameIntArray=this._dragonBonesData.frameIntArray;this._frameFloatArray=this._dragonBonesData.frameFloatArray;this._frameArray=this._dragonBonesData.frameArray;this._timelineArray=this._dragonBonesData.timelineArray;this._frameIndices=this._dragonBonesData.frameIndices;this._frameCount=this._timelineArray[this._timelineData.offset+2];this._frameValueOffset=this._timelineArray[this._timelineData.offset+4];this._timeScale=100/this._timelineArray[this._timelineData.offset+0];this._timeOffset=this._timelineArray[this._timelineData.offset+1]*.01}};e.prototype.fadeOut=function(){};e.prototype.update=function(t){if(this._setCurrentTime(t)){if(this._frameCount>1){var e=Math.floor(this.currentTime*this._frameRate);var a=this._frameIndices[this._timelineData.frameIndicesOffset+e];if(this._frameIndex!==a){this._frameIndex=a;this._frameOffset=this._animationData.frameOffset+this._timelineArray[this._timelineData.offset+5+this._frameIndex];this._onArriveAtFrame()}}else if(this._frameIndex<0){this._frameIndex=0;if(this._timelineData!==null){this._frameOffset=this._animationData.frameOffset+this._timelineArray[this._timelineData.offset+5]}this._onArriveAtFrame()}if(this._tweenState!==0){this._onUpdateFrame()}}};return e}(t.BaseObject);t.TimelineState=e;var a=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e._getEasingValue=function(t,e,a){var r=e;switch(t){case 3:r=Math.pow(e,2);break;case 4:r=1-Math.pow(1-e,2);break;case 5:r=.5*(1-Math.cos(e*Math.PI));break}return(r-e)*a+e};e._getEasingCurveValue=function(t,e,a,r){if(t<=0){return 0}else if(t>=1){return 1}var i=a+1;var n=Math.floor(t*i);var s=n===0?0:e[r+n-1];var o=n===i-1?1e4:e[r+n];return(s+(o-s)*(t*i-n))*1e-4};e.prototype._onClear=function(){t.prototype._onClear.call(this);this._tweenType=0;this._curveCount=0;this._framePosition=0;this._frameDurationR=0;this._tweenProgress=0;this._tweenEasing=0};e.prototype._onArriveAtFrame=function(){if(this._frameCount>1&&(this._frameIndex!==this._frameCount-1||this._animationState.playTimes===0||this._animationState.currentPlayTimes<this._animationState.playTimes-1)){this._tweenType=this._frameArray[this._frameOffset+1];this._tweenState=this._tweenType===0?1:2;if(this._tweenType===2){this._curveCount=this._frameArray[this._frameOffset+2]}else if(this._tweenType!==0&&this._tweenType!==1){this._tweenEasing=this._frameArray[this._frameOffset+2]*.01}this._framePosition=this._frameArray[this._frameOffset]*this._frameRateR;if(this._frameIndex===this._frameCount-1){this._frameDurationR=1/(this._animationData.duration-this._framePosition)}else{var t=this._animationData.frameOffset+this._timelineArray[this._timelineData.offset+5+this._frameIndex+1];var e=this._frameArray[t]*this._frameRateR-this._framePosition;if(e>0){this._frameDurationR=1/e}else{this._frameDurationR=0}}}else{this._tweenState=1}};e.prototype._onUpdateFrame=function(){if(this._tweenState===2){this._tweenProgress=(this.currentTime-this._framePosition)*this._frameDurationR;if(this._tweenType===2){this._tweenProgress=e._getEasingCurveValue(this._tweenProgress,this._frameArray,this._curveCount,this._frameOffset+3)}else if(this._tweenType!==1){this._tweenProgress=e._getEasingValue(this._tweenType,this._tweenProgress,this._tweenEasing)}}else{this._tweenProgress=0}};return e}(e);t.TweenTimelineState=a;var r=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.prototype._onClear=function(){t.prototype._onClear.call(this);this.bone=null;this.bonePose=null};e.prototype.blend=function(t){var e=this.bone._blendState.blendWeight;var a=this.bone.animationPose;var r=this.bonePose.result;if(t===2){a.x+=r.x*e;a.y+=r.y*e;a.rotation+=r.rotation*e;a.skew+=r.skew*e;a.scaleX+=(r.scaleX-1)*e;a.scaleY+=(r.scaleY-1)*e}else if(e!==1){a.x=r.x*e;a.y=r.y*e;a.rotation=r.rotation*e;a.skew=r.skew*e;a.scaleX=(r.scaleX-1)*e+1;a.scaleY=(r.scaleY-1)*e+1}else{a.x=r.x;a.y=r.y;a.rotation=r.rotation;a.skew=r.skew;a.scaleX=r.scaleX;a.scaleY=r.scaleY}if(this._animationState._fadeState!==0||this._animationState._subFadeState!==0){this.bone._transformDirty=true}};return e}(a);t.BoneTimelineState=r;var i=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.prototype._onClear=function(){t.prototype._onClear.call(this);this.slot=null};return e}(a);t.SlotTimelineState=i;var n=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.prototype._onClear=function(){t.prototype._onClear.call(this);this.constraint=null};return e}(a);t.ConstraintTimelineState=n})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){return e!==null&&e.apply(this,arguments)||this}a.toString=function(){return"[class dragonBones.ActionTimelineState]"};a.prototype._onCrossFrame=function(e){var a=this._armature.eventDispatcher;if(this._animationState.actionEnabled){var r=this._animationData.frameOffset+this._timelineArray[this._timelineData.offset+5+e];var i=this._frameArray[r+1];var n=this._animationData.parent.actions;for(var s=0;s<i;++s){var o=this._frameArray[r+2+s];var l=n[o];if(l.type===0){var h=t.BaseObject.borrowObject(t.EventObject);h.time=this._frameArray[r]/this._frameRate;h.animationState=this._animationState;t.EventObject.actionDataToInstance(l,h,this._armature);this._armature._bufferAction(h,true)}else{var f=l.type===10?t.EventObject.FRAME_EVENT:t.EventObject.SOUND_EVENT;if(l.type===11||a.hasDBEventListener(f)){var h=t.BaseObject.borrowObject(t.EventObject);h.time=this._frameArray[r]/this._frameRate;h.animationState=this._animationState;t.EventObject.actionDataToInstance(l,h,this._armature);this._armature._dragonBones.bufferEvent(h)}}}}};a.prototype._onArriveAtFrame=function(){};a.prototype._onUpdateFrame=function(){};a.prototype.update=function(e){var a=this.playState;var r=this.currentPlayTimes;var i=this.currentTime;if(this._setCurrentTime(e)){var n=this._armature.eventDispatcher;if(a<0){if(this.playState!==a){if(this._animationState.displayControl&&this._animationState.resetToPose){this._armature._sortZOrder(null,0)}r=this.currentPlayTimes;if(n.hasDBEventListener(t.EventObject.START)){var s=t.BaseObject.borrowObject(t.EventObject);s.type=t.EventObject.START;s.armature=this._armature;s.animationState=this._animationState;this._armature._dragonBones.bufferEvent(s)}}else{return}}var o=this._animationState.timeScale<0;var l=null;var h=null;if(this.currentPlayTimes!==r){if(n.hasDBEventListener(t.EventObject.LOOP_COMPLETE)){l=t.BaseObject.borrowObject(t.EventObject);l.type=t.EventObject.LOOP_COMPLETE;l.armature=this._armature;l.animationState=this._animationState}if(this.playState>0){if(n.hasDBEventListener(t.EventObject.COMPLETE)){h=t.BaseObject.borrowObject(t.EventObject);h.type=t.EventObject.COMPLETE;h.armature=this._armature;h.animationState=this._animationState}}}if(this._frameCount>1){var f=this._timelineData;var u=Math.floor(this.currentTime*this._frameRate);var _=this._frameIndices[f.frameIndicesOffset+u];if(this._frameIndex!==_){var c=this._frameIndex;this._frameIndex=_;if(this._timelineArray!==null){this._frameOffset=this._animationData.frameOffset+this._timelineArray[f.offset+5+this._frameIndex];if(o){if(c<0){var p=Math.floor(i*this._frameRate);c=this._frameIndices[f.frameIndicesOffset+p];if(this.currentPlayTimes===r){if(c===_){c=-1}}}while(c>=0){var m=this._animationData.frameOffset+this._timelineArray[f.offset+5+c];var d=this._frameArray[m]/this._frameRate;if(this._position<=d&&d<=this._position+this._duration){this._onCrossFrame(c)}if(l!==null&&c===0){this._armature._dragonBones.bufferEvent(l);l=null}if(c>0){c--}else{c=this._frameCount-1}if(c===_){break}}}else{if(c<0){var p=Math.floor(i*this._frameRate);c=this._frameIndices[f.frameIndicesOffset+p];var m=this._animationData.frameOffset+this._timelineArray[f.offset+5+c];var d=this._frameArray[m]/this._frameRate;if(this.currentPlayTimes===r){if(i<=d){if(c>0){c--}else{c=this._frameCount-1}}else if(c===_){c=-1}}}while(c>=0){if(c<this._frameCount-1){c++}else{c=0}var m=this._animationData.frameOffset+this._timelineArray[f.offset+5+c];var d=this._frameArray[m]/this._frameRate;if(this._position<=d&&d<=this._position+this._duration){this._onCrossFrame(c)}if(l!==null&&c===0){this._armature._dragonBones.bufferEvent(l);l=null}if(c===_){break}}}}}}else if(this._frameIndex<0){this._frameIndex=0;if(this._timelineData!==null){this._frameOffset=this._animationData.frameOffset+this._timelineArray[this._timelineData.offset+5];var d=this._frameArray[this._frameOffset]/this._frameRate;if(this.currentPlayTimes===r){if(i<=d){this._onCrossFrame(this._frameIndex)}}else if(this._position<=d){if(!o&&l!==null){this._armature._dragonBones.bufferEvent(l);l=null}this._onCrossFrame(this._frameIndex)}}}if(l!==null){this._armature._dragonBones.bufferEvent(l)}if(h!==null){this._armature._dragonBones.bufferEvent(h)}}};a.prototype.setCurrentTime=function(t){this._setCurrentTime(t);this._frameIndex=-1};return a}(t.TimelineState);t.ActionTimelineState=e;var a=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.ZOrderTimelineState]"};e.prototype._onArriveAtFrame=function(){if(this.playState>=0){var t=this._frameArray[this._frameOffset+1];if(t>0){this._armature._sortZOrder(this._frameArray,this._frameOffset+2)}else{this._armature._sortZOrder(null,0)}}};e.prototype._onUpdateFrame=function(){};return e}(t.TimelineState);t.ZOrderTimelineState=a;var r=function(e){__extends(a,e);function a(){return e!==null&&e.apply(this,arguments)||this}a.toString=function(){return"[class dragonBones.BoneAllTimelineState]"};a.prototype._onArriveAtFrame=function(){e.prototype._onArriveAtFrame.call(this);if(this._timelineData!==null){var t=this._animationData.frameFloatOffset+this._frameValueOffset+this._frameIndex*6;var a=this._armature._armatureData.scale;var r=this._frameFloatArray;var i=this.bonePose.current;var n=this.bonePose.delta;i.x=r[t++]*a;i.y=r[t++]*a;i.rotation=r[t++];i.skew=r[t++];i.scaleX=r[t++];i.scaleY=r[t++];if(this._tweenState===2){if(this._frameIndex===this._frameCount-1){t=this._animationData.frameFloatOffset+this._frameValueOffset}n.x=r[t++]*a-i.x;n.y=r[t++]*a-i.y;n.rotation=r[t++]-i.rotation;n.skew=r[t++]-i.skew;n.scaleX=r[t++]-i.scaleX;n.scaleY=r[t++]-i.scaleY}else{n.x=0;n.y=0;n.rotation=0;n.skew=0;n.scaleX=0;n.scaleY=0}}else{var i=this.bonePose.current;var n=this.bonePose.delta;i.x=0;i.y=0;i.rotation=0;i.skew=0;i.scaleX=1;i.scaleY=1;n.x=0;n.y=0;n.rotation=0;n.skew=0;n.scaleX=0;n.scaleY=0}};a.prototype._onUpdateFrame=function(){e.prototype._onUpdateFrame.call(this);var t=this.bonePose.current;var a=this.bonePose.delta;var r=this.bonePose.result;this.bone._transformDirty=true;if(this._tweenState!==2){this._tweenState=0}r.x=t.x+a.x*this._tweenProgress;r.y=t.y+a.y*this._tweenProgress;r.rotation=t.rotation+a.rotation*this._tweenProgress;r.skew=t.skew+a.skew*this._tweenProgress;r.scaleX=t.scaleX+a.scaleX*this._tweenProgress;r.scaleY=t.scaleY+a.scaleY*this._tweenProgress};a.prototype.fadeOut=function(){var e=this.bonePose.result;e.rotation=t.Transform.normalizeRadian(e.rotation);e.skew=t.Transform.normalizeRadian(e.skew)};return a}(t.BoneTimelineState);t.BoneAllTimelineState=r;var i=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.BoneTranslateTimelineState]"};e.prototype._onArriveAtFrame=function(){t.prototype._onArriveAtFrame.call(this);if(this._timelineData!==null){var e=this._animationData.frameFloatOffset+this._frameValueOffset+this._frameIndex*2;var a=this._armature._armatureData.scale;var r=this._frameFloatArray;var i=this.bonePose.current;var n=this.bonePose.delta;i.x=r[e++]*a;i.y=r[e++]*a;if(this._tweenState===2){if(this._frameIndex===this._frameCount-1){e=this._animationData.frameFloatOffset+this._frameValueOffset}n.x=r[e++]*a-i.x;n.y=r[e++]*a-i.y}else{n.x=0;n.y=0}}else{var i=this.bonePose.current;var n=this.bonePose.delta;i.x=0;i.y=0;n.x=0;n.y=0}};e.prototype._onUpdateFrame=function(){t.prototype._onUpdateFrame.call(this);var e=this.bonePose.current;var a=this.bonePose.delta;var r=this.bonePose.result;this.bone._transformDirty=true;if(this._tweenState!==2){this._tweenState=0}r.x=e.x+a.x*this._tweenProgress;r.y=e.y+a.y*this._tweenProgress};return e}(t.BoneTimelineState);t.BoneTranslateTimelineState=i;var n=function(e){__extends(a,e);function a(){return e!==null&&e.apply(this,arguments)||this}a.toString=function(){return"[class dragonBones.BoneRotateTimelineState]"};a.prototype._onArriveAtFrame=function(){e.prototype._onArriveAtFrame.call(this);if(this._timelineData!==null){var a=this._animationData.frameFloatOffset+this._frameValueOffset+this._frameIndex*2;var r=this._frameFloatArray;var i=this.bonePose.current;var n=this.bonePose.delta;i.rotation=r[a++];i.skew=r[a++];if(this._tweenState===2){if(this._frameIndex===this._frameCount-1){a=this._animationData.frameFloatOffset+this._frameValueOffset;n.rotation=t.Transform.normalizeRadian(r[a++]-i.rotation)}else{n.rotation=r[a++]-i.rotation}n.skew=r[a++]-i.skew}else{n.rotation=0;n.skew=0}}else{var i=this.bonePose.current;var n=this.bonePose.delta;i.rotation=0;i.skew=0;n.rotation=0;n.skew=0}};a.prototype._onUpdateFrame=function(){e.prototype._onUpdateFrame.call(this);var t=this.bonePose.current;var a=this.bonePose.delta;var r=this.bonePose.result;this.bone._transformDirty=true;if(this._tweenState!==2){this._tweenState=0}r.rotation=t.rotation+a.rotation*this._tweenProgress;r.skew=t.skew+a.skew*this._tweenProgress};a.prototype.fadeOut=function(){var e=this.bonePose.result;e.rotation=t.Transform.normalizeRadian(e.rotation);e.skew=t.Transform.normalizeRadian(e.skew)};return a}(t.BoneTimelineState);t.BoneRotateTimelineState=n;var s=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.BoneScaleTimelineState]"};e.prototype._onArriveAtFrame=function(){t.prototype._onArriveAtFrame.call(this);if(this._timelineData!==null){var e=this._animationData.frameFloatOffset+this._frameValueOffset+this._frameIndex*2;var a=this._frameFloatArray;var r=this.bonePose.current;var i=this.bonePose.delta;r.scaleX=a[e++];r.scaleY=a[e++];if(this._tweenState===2){if(this._frameIndex===this._frameCount-1){e=this._animationData.frameFloatOffset+this._frameValueOffset}i.scaleX=a[e++]-r.scaleX;i.scaleY=a[e++]-r.scaleY}else{i.scaleX=0;i.scaleY=0}}else{var r=this.bonePose.current;var i=this.bonePose.delta;r.scaleX=1;r.scaleY=1;i.scaleX=0;i.scaleY=0}};e.prototype._onUpdateFrame=function(){t.prototype._onUpdateFrame.call(this);var e=this.bonePose.current;var a=this.bonePose.delta;var r=this.bonePose.result;this.bone._transformDirty=true;if(this._tweenState!==2){this._tweenState=0}r.scaleX=e.scaleX+a.scaleX*this._tweenProgress;r.scaleY=e.scaleY+a.scaleY*this._tweenProgress};return e}(t.BoneTimelineState);t.BoneScaleTimelineState=s;var o=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e._current=[];e._delta=[];e._result=[];return e}e.toString=function(){return"[class dragonBones.SurfaceTimelineState]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.surface=null;this._frameFloatOffset=0;this._valueCount=0;this._deformCount=0;this._valueOffset=0;this._current.length=0;this._delta.length=0;this._result.length=0};e.prototype._onArriveAtFrame=function(){t.prototype._onArriveAtFrame.call(this);if(this._timelineData!==null){var e=this._animationData.frameFloatOffset+this._frameValueOffset+this._frameIndex*this._valueCount;var a=this._armature._armatureData.scale;var r=this._frameFloatArray;if(this._tweenState===2){var i=e+this._valueCount;if(this._frameIndex===this._frameCount-1){i=this._animationData.frameFloatOffset+this._frameValueOffset}for(var n=0;n<this._valueCount;++n){this._delta[n]=r[i+n]*a-(this._current[n]=r[e+n]*a)}}else{for(var n=0;n<this._valueCount;++n){this._current[n]=r[e+n]*a}}}else{for(var n=0;n<this._valueCount;++n){this._current[n]=0}}};e.prototype._onUpdateFrame=function(){t.prototype._onUpdateFrame.call(this);this.surface._transformDirty=true;if(this._tweenState!==2){this._tweenState=0}for(var e=0;e<this._valueCount;++e){this._result[e]=this._current[e]+this._delta[e]*this._tweenProgress}};e.prototype.init=function(e,a,r){t.prototype.init.call(this,e,a,r);if(this._timelineData!==null){var i=this._animationData.frameIntOffset+this._timelineArray[this._timelineData.offset+3];this._deformCount=this._frameIntArray[i+1];this._valueCount=this._frameIntArray[i+2];this._valueOffset=this._frameIntArray[i+3];this._frameFloatOffset=this._frameIntArray[i+4]+this._animationData.frameFloatOffset}else{this._deformCount=this.surface._deformVertices.length;this._valueCount=this._deformCount;this._valueOffset=0;this._frameFloatOffset=0}this._current.length=this._valueCount;this._delta.length=this._valueCount;this._result.length=this._valueCount;for(var n=0;n<this._valueCount;++n){this._delta[n]=0}};e.prototype.blend=function(t){var e=this.surface._blendState.blendWeight;var a=this.surface._deformVertices;for(var r=0;r<this._deformCount;++r){var i=0;if(r<this._valueOffset){i=this._frameFloatArray[this._frameFloatOffset+r]}else if(r<this._valueOffset+this._valueCount){i=this._result[r-this._valueOffset]}else{i=this._frameFloatArray[this._frameFloatOffset+r-this._valueCount]}if(t===2){a[r]+=i*e}else if(e!==1){a[r]=i*e}else{a[r]=i}}if(this._animationState._fadeState!==0||this._animationState._subFadeState!==0){this.surface._transformDirty=true}};return e}(t.TweenTimelineState);t.SurfaceTimelineState=o;var l=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.SlotDislayTimelineState]"};e.prototype._onArriveAtFrame=function(){if(this.playState>=0){var t=this._timelineData!==null?this._frameArray[this._frameOffset+1]:this.slot._slotData.displayIndex;if(this.slot.displayIndex!==t){this.slot._setDisplayIndex(t,true)}}};return e}(t.SlotTimelineState);t.SlotDislayTimelineState=l;var h=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e._current=[0,0,0,0,0,0,0,0];e._delta=[0,0,0,0,0,0,0,0];e._result=[0,0,0,0,0,0,0,0];return e}e.toString=function(){return"[class dragonBones.SlotColorTimelineState]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this._dirty=false};e.prototype._onArriveAtFrame=function(){t.prototype._onArriveAtFrame.call(this);if(this._timelineData!==null){var e=this._dragonBonesData.intArray;var a=this._frameIntArray;var r=this._animationData.frameIntOffset+this._frameValueOffset+this._frameIndex*1;var i=a[r];if(i<0){i+=65536}this._current[0]=e[i++];this._current[1]=e[i++];this._current[2]=e[i++];this._current[3]=e[i++];this._current[4]=e[i++];this._current[5]=e[i++];this._current[6]=e[i++];this._current[7]=e[i++];if(this._tweenState===2){if(this._frameIndex===this._frameCount-1){i=a[this._animationData.frameIntOffset+this._frameValueOffset]}else{i=a[r+1*1]}if(i<0){i+=65536}this._delta[0]=e[i++]-this._current[0];this._delta[1]=e[i++]-this._current[1];this._delta[2]=e[i++]-this._current[2];this._delta[3]=e[i++]-this._current[3];this._delta[4]=e[i++]-this._current[4];this._delta[5]=e[i++]-this._current[5];this._delta[6]=e[i++]-this._current[6];this._delta[7]=e[i++]-this._current[7]}}else{var n=this.slot._slotData.color;this._current[0]=n.alphaMultiplier*100;this._current[1]=n.redMultiplier*100;this._current[2]=n.greenMultiplier*100;this._current[3]=n.blueMultiplier*100;this._current[4]=n.alphaOffset;this._current[5]=n.redOffset;this._current[6]=n.greenOffset;this._current[7]=n.blueOffset}};e.prototype._onUpdateFrame=function(){t.prototype._onUpdateFrame.call(this);this._dirty=true;if(this._tweenState!==2){this._tweenState=0}this._result[0]=(this._current[0]+this._delta[0]*this._tweenProgress)*.01;this._result[1]=(this._current[1]+this._delta[1]*this._tweenProgress)*.01;this._result[2]=(this._current[2]+this._delta[2]*this._tweenProgress)*.01;this._result[3]=(this._current[3]+this._delta[3]*this._tweenProgress)*.01;this._result[4]=this._current[4]+this._delta[4]*this._tweenProgress;this._result[5]=this._current[5]+this._delta[5]*this._tweenProgress;this._result[6]=this._current[6]+this._delta[6]*this._tweenProgress;this._result[7]=this._current[7]+this._delta[7]*this._tweenProgress};e.prototype.fadeOut=function(){this._tweenState=0;this._dirty=false};e.prototype.update=function(e){t.prototype.update.call(this,e);if(this._tweenState!==0||this._dirty){var a=this.slot._colorTransform;if(this._animationState._fadeState!==0||this._animationState._subFadeState!==0){if(a.alphaMultiplier!==this._result[0]||a.redMultiplier!==this._result[1]||a.greenMultiplier!==this._result[2]||a.blueMultiplier!==this._result[3]||a.alphaOffset!==this._result[4]||a.redOffset!==this._result[5]||a.greenOffset!==this._result[6]||a.blueOffset!==this._result[7]){var r=Math.pow(this._animationState._fadeProgress,4);a.alphaMultiplier+=(this._result[0]-a.alphaMultiplier)*r;a.redMultiplier+=(this._result[1]-a.redMultiplier)*r;a.greenMultiplier+=(this._result[2]-a.greenMultiplier)*r;a.blueMultiplier+=(this._result[3]-a.blueMultiplier)*r;a.alphaOffset+=(this._result[4]-a.alphaOffset)*r;a.redOffset+=(this._result[5]-a.redOffset)*r;a.greenOffset+=(this._result[6]-a.greenOffset)*r;a.blueOffset+=(this._result[7]-a.blueOffset)*r;this.slot._colorDirty=true}}else if(this._dirty){this._dirty=false;if(a.alphaMultiplier!==this._result[0]||a.redMultiplier!==this._result[1]||a.greenMultiplier!==this._result[2]||a.blueMultiplier!==this._result[3]||a.alphaOffset!==this._result[4]||a.redOffset!==this._result[5]||a.greenOffset!==this._result[6]||a.blueOffset!==this._result[7]){a.alphaMultiplier=this._result[0];a.redMultiplier=this._result[1];a.greenMultiplier=this._result[2];a.blueMultiplier=this._result[3];a.alphaOffset=this._result[4];a.redOffset=this._result[5];a.greenOffset=this._result[6];a.blueOffset=this._result[7];this.slot._colorDirty=true}}}};return e}(t.SlotTimelineState);t.SlotColorTimelineState=h;var f=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e._current=[];e._delta=[];e._result=[];return e}e.toString=function(){return"[class dragonBones.DeformTimelineState]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.vertexOffset=0;this._dirty=false;this._frameFloatOffset=0;this._valueCount=0;this._deformCount=0;this._valueOffset=0;this._current.length=0;this._delta.length=0;this._result.length=0};e.prototype._onArriveAtFrame=function(){t.prototype._onArriveAtFrame.call(this);if(this._timelineData!==null){var e=this._animationData.frameFloatOffset+this._frameValueOffset+this._frameIndex*this._valueCount;var a=this._armature._armatureData.scale;var r=this._frameFloatArray;if(this._tweenState===2){var i=e+this._valueCount;if(this._frameIndex===this._frameCount-1){i=this._animationData.frameFloatOffset+this._frameValueOffset}for(var n=0;n<this._valueCount;++n){this._delta[n]=r[i+n]*a-(this._current[n]=r[e+n]*a)}}else{for(var n=0;n<this._valueCount;++n){this._current[n]=r[e+n]*a}}}else{for(var n=0;n<this._valueCount;++n){this._current[n]=0}}};e.prototype._onUpdateFrame=function(){t.prototype._onUpdateFrame.call(this);this._dirty=true;if(this._tweenState!==2){this._tweenState=0}for(var e=0;e<this._valueCount;++e){this._result[e]=this._current[e]+this._delta[e]*this._tweenProgress}};e.prototype.init=function(e,a,r){t.prototype.init.call(this,e,a,r);if(this._timelineData!==null){var i=this._animationData.frameIntOffset+this._timelineArray[this._timelineData.offset+3];this.vertexOffset=this._frameIntArray[i+0];if(this.vertexOffset<0){this.vertexOffset+=65536}this._deformCount=this._frameIntArray[i+1];this._valueCount=this._frameIntArray[i+2];this._valueOffset=this._frameIntArray[i+3];this._frameFloatOffset=this._frameIntArray[i+4]+this._animationData.frameFloatOffset}else{var n=this.slot._deformVertices;this._deformCount=n!==null?n.vertices.length:0;this._valueCount=this._deformCount;this._valueOffset=0;this._frameFloatOffset=0}this._current.length=this._valueCount;this._delta.length=this._valueCount;this._result.length=this._valueCount;for(var s=0;s<this._valueCount;++s){this._delta[s]=0}};e.prototype.fadeOut=function(){this._tweenState=0;this._dirty=false};e.prototype.update=function(e){var a=this.slot._deformVertices;if(a===null||a.verticesData===null||a.verticesData.offset!==this.vertexOffset){return}t.prototype.update.call(this,e);if(this._tweenState!==0||this._dirty){var r=a.vertices;if(this._animationState._fadeState!==0||this._animationState._subFadeState!==0){var i=Math.pow(this._animationState._fadeProgress,2);for(var n=0;n<this._deformCount;++n){if(n<this._valueOffset){r[n]+=(this._frameFloatArray[this._frameFloatOffset+n]-r[n])*i}else if(n<this._valueOffset+this._valueCount){r[n]+=(this._result[n-this._valueOffset]-r[n])*i}else{r[n]+=(this._frameFloatArray[this._frameFloatOffset+n-this._valueCount]-r[n])*i}}a.verticesDirty=true}else if(this._dirty){this._dirty=false;for(var n=0;n<this._deformCount;++n){if(n<this._valueOffset){r[n]=this._frameFloatArray[this._frameFloatOffset+n]}else if(n<this._valueOffset+this._valueCount){r[n]=this._result[n-this._valueOffset]}else{r[n]=this._frameFloatArray[this._frameFloatOffset+n-this._valueCount]}}a.verticesDirty=true}}};return e}(t.SlotTimelineState);t.DeformTimelineState=f;var u=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.toString=function(){return"[class dragonBones.IKConstraintTimelineState]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this._current=0;this._delta=0};e.prototype._onArriveAtFrame=function(){t.prototype._onArriveAtFrame.call(this);var e=this.constraint;if(this._timelineData!==null){var a=this._animationData.frameIntOffset+this._frameValueOffset+this._frameIndex*2;var r=this._frameIntArray;var i=r[a++]!==0;this._current=r[a++]*.01;if(this._tweenState===2){if(this._frameIndex===this._frameCount-1){a=this._animationData.frameIntOffset+this._frameValueOffset}this._delta=r[a+1]*.01-this._current}else{this._delta=0}e._bendPositive=i}else{var n=e._constraintData;this._current=n.weight;this._delta=0;e._bendPositive=n.bendPositive}e.invalidUpdate()};e.prototype._onUpdateFrame=function(){t.prototype._onUpdateFrame.call(this);if(this._tweenState!==2){this._tweenState=0}var e=this.constraint;e._weight=this._current+this._delta*this._tweenProgress;e.invalidUpdate()};return e}(t.ConstraintTimelineState);t.IKConstraintTimelineState=u;var _=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e._floats=[0,0,0,0,0,0];return e}e.toString=function(){return"[class dragonBones.AnimationTimelineState]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);this.animationState=null};e.prototype._onArriveAtFrame=function(){t.prototype._onArriveAtFrame.call(this);if(this._timelineData===null){return}var e=this._animationData.frameIntOffset+this._frameValueOffset+this._frameIndex*2;var a=1/this.animationState._animationData.parent.frameRate;var r=this._frameIntArray;this._floats[0]=r[e++]*a;this._floats[3]=r[e++]*.01;if(this._tweenState===2){if(this._frameIndex===this._frameCount-1){e=this._animationData.frameIntOffset+this._frameValueOffset}this._floats[1]=r[e++]*a-this._floats[0];this._floats[4]=r[e++]*.01-this._floats[3]}else{this._floats[1]=0;this._floats[4]=0}};e.prototype._onUpdateFrame=function(){t.prototype._onUpdateFrame.call(this);if(this._tweenState!==2){this._tweenState=0}if(this._floats[0]>=0){this._floats[2]=this._floats[0]+this._floats[1]*this._tweenProgress}this._floats[5]=this._floats[3]+this._floats[4]*this._tweenProgress};e.prototype.blend=function(t){var e=this.animationState;var a=e._blendState.blendWeight;if(t===2){e.weight+=this._floats[5]*a;e.currentTime+=this._floats[2]*a}else{e.weight=this._floats[5]*a;e.currentTime=this._floats[2]*a}};return e}(t.TweenTimelineState);t.AnimationTimelineState=_})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}e.actionDataToInstance=function(t,a,r){if(t.type===0){a.type=e.FRAME_EVENT}else{a.type=t.type===10?e.FRAME_EVENT:e.SOUND_EVENT}a.name=t.name;a.armature=r;a.actionData=t;a.data=t.data;if(t.bone!==null){a.bone=r.getBone(t.bone.name)}if(t.slot!==null){a.slot=r.getSlot(t.slot.name)}};e.toString=function(){return"[class dragonBones.EventObject]"};e.prototype._onClear=function(){this.time=0;this.type="";this.name="";this.armature=null;this.bone=null;this.slot=null;this.animationState=null;this.actionData=null;this.data=null};e.START="start";e.LOOP_COMPLETE="loopComplete";e.COMPLETE="complete";e.FADE_IN="fadeIn";e.FADE_IN_COMPLETE="fadeInComplete";e.FADE_OUT="fadeOut";e.FADE_OUT_COMPLETE="fadeOutComplete";e.FRAME_EVENT="frameEvent";e.SOUND_EVENT="soundEvent";return e}(t.BaseObject);t.EventObject=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function e(){}e._getArmatureType=function(t){switch(t.toLowerCase()){case"stage":return 2;case"armature":return 0;case"movieclip":return 1;default:return 0}};e._getBoneType=function(t){switch(t.toLowerCase()){case"bone":return 0;case"surface":return 1;default:return 0}};e._getDisplayType=function(t){switch(t.toLowerCase()){case"image":return 0;case"mesh":return 2;case"armature":return 1;case"boundingbox":return 3;case"path":return 4;default:return 0}};e._getBoundingBoxType=function(t){switch(t.toLowerCase()){case"rectangle":return 0;case"ellipse":return 1;case"polygon":return 2;default:return 0}};e._getActionType=function(t){switch(t.toLowerCase()){case"play":return 0;case"frame":return 10;case"sound":return 11;default:return 0}};e._getBlendMode=function(t){switch(t.toLowerCase()){case"normal":return 0;case"add":return 1;case"alpha":return 2;case"darken":return 3;case"difference":return 4;case"erase":return 5;case"hardlight":return 6;case"invert":return 7;case"layer":return 8;case"lighten":return 9;case"multiply":return 10;case"overlay":return 11;case"screen":return 12;case"subtract":return 13;default:return 0}};e._getPositionMode=function(t){switch(t.toLocaleLowerCase()){case"percent":return 1;case"fixed":return 0;default:return 1}};e._getSpacingMode=function(t){switch(t.toLocaleLowerCase()){case"length":return 0;case"percent":return 2;case"fixed":return 1;default:return 0}};e._getRotateMode=function(t){switch(t.toLocaleLowerCase()){case"tangent":return 0;case"chain":return 1;case"chainscale":return 2;default:return 0}};e.parseDragonBonesData=function(e){console.warn("Deprecated.");if(e instanceof ArrayBuffer){return t.BinaryDataParser.getInstance().parseDragonBonesData(e)}else{return t.ObjectDataParser.getInstance().parseDragonBonesData(e)}};e.parseTextureAtlasData=function(a,r){if(r===void 0){r=1}console.warn("已废弃");var i={};var n=a[e.SUB_TEXTURE];for(var s=0,o=n.length;s<o;s++){var l=n[s];var h=l[e.NAME];var f=new t.Rectangle;var u=null;f.x=l[e.X]/r;f.y=l[e.Y]/r;f.width=l[e.WIDTH]/r;f.height=l[e.HEIGHT]/r;if(e.FRAME_WIDTH in l){u=new t.Rectangle;u.x=l[e.FRAME_X]/r;u.y=l[e.FRAME_Y]/r;u.width=l[e.FRAME_WIDTH]/r;u.height=l[e.FRAME_HEIGHT]/r}i[h]={region:f,frame:u,rotated:false}}return i};e.DATA_VERSION_2_3="2.3";e.DATA_VERSION_3_0="3.0";e.DATA_VERSION_4_0="4.0";e.DATA_VERSION_4_5="4.5";e.DATA_VERSION_5_0="5.0";e.DATA_VERSION_5_5="5.5";e.DATA_VERSION=e.DATA_VERSION_5_5;e.DATA_VERSIONS=[e.DATA_VERSION_4_0,e.DATA_VERSION_4_5,e.DATA_VERSION_5_0,e.DATA_VERSION_5_5];e.TEXTURE_ATLAS="textureAtlas";e.SUB_TEXTURE="SubTexture";e.FORMAT="format";e.IMAGE_PATH="imagePath";e.WIDTH="width";e.HEIGHT="height";e.ROTATED="rotated";e.FRAME_X="frameX";e.FRAME_Y="frameY";e.FRAME_WIDTH="frameWidth";e.FRAME_HEIGHT="frameHeight";e.DRADON_BONES="dragonBones";e.USER_DATA="userData";e.ARMATURE="armature";e.BONE="bone";e.SURFACE="surface";e.SLOT="slot";e.CONSTRAINT="constraint";e.IK="ik";e.PATH_CONSTRAINT="path";e.SKIN="skin";e.DISPLAY="display";e.ANIMATION="animation";e.Z_ORDER="zOrder";e.FFD="ffd";e.FRAME="frame";e.TRANSLATE_FRAME="translateFrame";e.ROTATE_FRAME="rotateFrame";e.SCALE_FRAME="scaleFrame";e.DISPLAY_FRAME="displayFrame";e.COLOR_FRAME="colorFrame";e.DEFAULT_ACTIONS="defaultActions";e.ACTIONS="actions";e.EVENTS="events";e.INTS="ints";e.FLOATS="floats";e.STRINGS="strings";e.CANVAS="canvas";e.TRANSFORM="transform";e.PIVOT="pivot";e.AABB="aabb";e.COLOR="color";e.VERSION="version";e.COMPATIBLE_VERSION="compatibleVersion";e.FRAME_RATE="frameRate";e.TYPE="type";e.SUB_TYPE="subType";e.NAME="name";e.PARENT="parent";e.TARGET="target";e.STAGE="stage";e.SHARE="share";e.PATH="path";e.LENGTH="length";e.DISPLAY_INDEX="displayIndex";e.BLEND_MODE="blendMode";e.INHERIT_TRANSLATION="inheritTranslation";e.INHERIT_ROTATION="inheritRotation";e.INHERIT_SCALE="inheritScale";e.INHERIT_REFLECTION="inheritReflection";e.INHERIT_ANIMATION="inheritAnimation";e.INHERIT_DEFORM="inheritDeform";e.SEGMENT_X="segmentX";e.SEGMENT_Y="segmentY";e.BEND_POSITIVE="bendPositive";e.CHAIN="chain";e.WEIGHT="weight";e.FADE_IN_TIME="fadeInTime";e.PLAY_TIMES="playTimes";e.SCALE="scale";e.OFFSET="offset";e.POSITION="position";e.DURATION="duration";e.TWEEN_EASING="tweenEasing";e.TWEEN_ROTATE="tweenRotate";e.TWEEN_SCALE="tweenScale";e.CLOCK_WISE="clockwise";e.CURVE="curve";e.SOUND="sound";e.EVENT="event";e.ACTION="action";e.X="x";e.Y="y";e.SKEW_X="skX";e.SKEW_Y="skY";e.SCALE_X="scX";e.SCALE_Y="scY";e.VALUE="value";e.ROTATE="rotate";e.SKEW="skew";e.ALPHA_OFFSET="aO";e.RED_OFFSET="rO";e.GREEN_OFFSET="gO";e.BLUE_OFFSET="bO";e.ALPHA_MULTIPLIER="aM";e.RED_MULTIPLIER="rM";e.GREEN_MULTIPLIER="gM";e.BLUE_MULTIPLIER="bM";e.UVS="uvs";e.VERTICES="vertices";e.TRIANGLES="triangles";e.WEIGHTS="weights";e.SLOT_POSE="slotPose";e.BONE_POSE="bonePose";e.GLUE_WEIGHTS="glueWeights";e.GLUE_MESHES="glueMeshes";e.BONES="bones";e.POSITION_MODE="positionMode";e.SPACING_MODE="spacingMode";e.ROTATE_MODE="rotateMode";e.SPACING="spacing";e.ROTATE_OFFSET="rotateOffset";e.ROTATE_MIX="rotateMix";e.TRANSLATE_MIX="translateMix";e.TARGET_DISPLAY="targetDisplay";e.CLOSED="closed";e.CONSTANT_SPEED="constantSpeed";e.VERTEX_COUNT="vertexCount";e.LENGTHS="lengths";e.GOTO_AND_PLAY="gotoAndPlay";e.DEFAULT_NAME="default";return e}();t.DataParser=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(r,e);function r(){var a=e!==null&&e.apply(this,arguments)||this;a._rawTextureAtlasIndex=0;a._rawBones=[];a._data=null;a._armature=null;a._bone=null;a._surface=null;a._slot=null;a._skin=null;a._mesh=null;a._animation=null;a._timeline=null;a._rawTextureAtlases=null;a._defaultColorOffset=-1;a._prevClockwise=0;a._prevRotation=0;a._helpMatrixA=new t.Matrix;a._helpMatrixB=new t.Matrix;a._helpTransform=new t.Transform;a._helpColorTransform=new t.ColorTransform;a._helpPoint=new t.Point;a._helpArray=[];a._intArray=[];a._floatArray=[];a._frameIntArray=[];a._frameFloatArray=[];a._frameArray=[];a._timelineArray=[];a._cacheRawMeshes=[];a._cacheMeshes=[];a._actionFrames=[];a._weightSlotPose={};a._weightBonePoses={};a._cacheBones={};a._slotChildActions={};return a}r._getBoolean=function(t,e,a){if(e in t){var r=t[e];var i=typeof r;if(i==="boolean"){return r}else if(i==="string"){switch(r){case"0":case"NaN":case"":case"false":case"null":case"undefined":return false;default:return true}}else{return!!r}}return a};r._getNumber=function(t,e,a){if(e in t){var r=t[e];if(r===null||r==="NaN"){return a}return+r||0}return a};r._getString=function(e,a,r){if(a in e){var i=e[a];var n=typeof i;if(n==="string"){if(t.DragonBones.webAssembly){for(var s=0,o=i.length;s<o;++s){if(i.charCodeAt(s)>255){return encodeURI(i)}}}return i}return String(i)}return r};r.prototype._getCurvePoint=function(t,e,a,r,i,n,s,o,l,h){var f=1-l;var u=f*f;var _=l*l;var c=f*u;var p=3*l*u;var m=3*f*_;var d=l*_;h.x=c*t+p*a+m*i+d*s;h.y=c*e+p*r+m*n+d*o};r.prototype._samplingEasingCurve=function(t,e){var a=t.length;var r=-2;for(var i=0,n=e.length;i<n;++i){var s=(i+1)/(n+1);while((r+6<a?t[r+6]:1)<s){r+=6}var o=r>=0&&r+6<a;var l=o?t[r]:0;var h=o?t[r+1]:0;var f=t[r+2];var u=t[r+3];var _=t[r+4];var c=t[r+5];var p=o?t[r+6]:1;var m=o?t[r+7]:1;var d=0;var v=1;while(v-d>1e-4){var y=(v+d)*.5;this._getCurvePoint(l,h,f,u,_,c,p,m,y,this._helpPoint);if(s-this._helpPoint.x>0){d=y}else{v=y}}e[i]=this._helpPoint.y}};r.prototype._parseActionDataInFrame=function(e,a,r,i){if(t.DataParser.EVENT in e){this._mergeActionFrame(e[t.DataParser.EVENT],a,10,r,i)}if(t.DataParser.SOUND in e){this._mergeActionFrame(e[t.DataParser.SOUND],a,11,r,i)}if(t.DataParser.ACTION in e){this._mergeActionFrame(e[t.DataParser.ACTION],a,0,r,i)}if(t.DataParser.EVENTS in e){this._mergeActionFrame(e[t.DataParser.EVENTS],a,10,r,i)}if(t.DataParser.ACTIONS in e){this._mergeActionFrame(e[t.DataParser.ACTIONS],a,0,r,i)}};r.prototype._mergeActionFrame=function(e,r,i,n,s){var o=t.DragonBones.webAssembly?this._armature.actions.size():this._armature.actions.length;var l=this._parseActionData(e,i,n,s);var h=0;var f=null;for(var u=0,_=l;u<_.length;u++){var c=_[u];this._armature.addAction(c,false)}if(this._actionFrames.length===0){f=new a;f.frameStart=0;this._actionFrames.push(f);f=null}for(var p=0,m=this._actionFrames;p<m.length;p++){var d=m[p];if(d.frameStart===r){f=d;break}else if(d.frameStart>r){break}h++}if(f===null){f=new a;f.frameStart=r;this._actionFrames.splice(h+1,0,f)}for(var v=0;v<l.length;++v){f.actions.push(o+v)}};r.prototype._parseArmature=function(e,a){var i=t.BaseObject.borrowObject(t.ArmatureData);i.name=r._getString(e,t.DataParser.NAME,"");i.frameRate=r._getNumber(e,t.DataParser.FRAME_RATE,this._data.frameRate);i.scale=a;if(t.DataParser.TYPE in e&&typeof e[t.DataParser.TYPE]==="string"){i.type=t.DataParser._getArmatureType(e[t.DataParser.TYPE])}else{i.type=r._getNumber(e,t.DataParser.TYPE,0)}if(i.frameRate===0){i.frameRate=24}this._armature=i;if(t.DataParser.CANVAS in e){var n=e[t.DataParser.CANVAS];var s=t.BaseObject.borrowObject(t.CanvasData);if(t.DataParser.COLOR in n){s.hasBackground=true}else{s.hasBackground=false}s.color=r._getNumber(n,t.DataParser.COLOR,0);s.x=r._getNumber(n,t.DataParser.X,0)*i.scale;s.y=r._getNumber(n,t.DataParser.Y,0)*i.scale;s.width=r._getNumber(n,t.DataParser.WIDTH,0)*i.scale;s.height=r._getNumber(n,t.DataParser.HEIGHT,0)*i.scale;i.canvas=s}if(t.DataParser.AABB in e){var o=e[t.DataParser.AABB];i.aabb.x=r._getNumber(o,t.DataParser.X,0)*i.scale;i.aabb.y=r._getNumber(o,t.DataParser.Y,0)*i.scale;i.aabb.width=r._getNumber(o,t.DataParser.WIDTH,0)*i.scale;i.aabb.height=r._getNumber(o,t.DataParser.HEIGHT,0)*i.scale}if(t.DataParser.BONE in e){var l=e[t.DataParser.BONE];for(var h=0,f=l;h<f.length;h++){var u=f[h];var _=r._getString(u,t.DataParser.PARENT,"");var c=this._parseBone(u);if(_.length>0){var p=i.getBone(_);if(p!==null){c.parent=p}else{if(!(_ in this._cacheBones)){this._cacheBones[_]=[]}this._cacheBones[_].push(c)}}if(c.name in this._cacheBones){for(var m=0,d=this._cacheBones[c.name];m<d.length;m++){var v=d[m];v.parent=c}delete this._cacheBones[c.name]}i.addBone(c);this._rawBones.push(c)}}if(t.DataParser.IK in e){var y=e[t.DataParser.IK];for(var g=0,b=y;g<b.length;g++){var D=b[g];var T=this._parseIKConstraint(D);if(T){i.addConstraint(T)}}}i.sortBones();if(t.DataParser.SLOT in e){var A=0;var x=e[t.DataParser.SLOT];for(var P=0,O=x;P<O.length;P++){var S=O[P];i.addSlot(this._parseSlot(S,A++))}}if(t.DataParser.SKIN in e){var E=e[t.DataParser.SKIN];for(var M=0,B=E;M<B.length;M++){var C=B[M];i.addSkin(this._parseSkin(C))}}if(t.DataParser.PATH_CONSTRAINT in e){var w=e[t.DataParser.PATH_CONSTRAINT];for(var I=0,F=w;I<F.length;I++){var N=F[I];var T=this._parsePathConstraint(N);if(T){i.addConstraint(T)}}}for(var R=0,k=this._cacheRawMeshes.length;R<k;++R){var j=this._cacheRawMeshes[R];if(!(t.DataParser.GLUE_WEIGHTS in j)||!(t.DataParser.GLUE_MESHES in j)){continue}this._parseMeshGlue(j,this._cacheMeshes[R])}for(var R=0,k=this._cacheRawMeshes.length;R<k;++R){var L=this._cacheRawMeshes[R];var V=r._getString(L,t.DataParser.SHARE,"");if(V.length===0){continue}var U=r._getString(L,t.DataParser.SKIN,t.DataParser.DEFAULT_NAME);if(U.length===0){U=t.DataParser.DEFAULT_NAME}var Y=i.getMesh(U,"",V);if(Y===null){continue}var X=this._cacheMeshes[R];X.vertices.shareFrom(Y.vertices)}if(t.DataParser.ANIMATION in e){var H=e[t.DataParser.ANIMATION];for(var $=0,G=H;$<G.length;$++){var W=G[$];var z=this._parseAnimation(W);i.addAnimation(z)}}if(t.DataParser.DEFAULT_ACTIONS in e){var K=this._parseActionData(e[t.DataParser.DEFAULT_ACTIONS],0,null,null);for(var Z=0,q=K;Z<q.length;Z++){var J=q[Z];i.addAction(J,true);if(J.type===0){var z=i.getAnimation(J.name);if(z!==null){i.defaultAnimation=z}}}}if(t.DataParser.ACTIONS in e){var K=this._parseActionData(e[t.DataParser.ACTIONS],0,null,null);for(var Q=0,tt=K;Q<tt.length;Q++){var J=tt[Q];i.addAction(J,false)}}this._rawBones.length=0;this._cacheRawMeshes.length=0;this._cacheMeshes.length=0;this._armature=null;for(var et in this._weightSlotPose){delete this._weightSlotPose[et]}for(var et in this._weightBonePoses){delete this._weightBonePoses[et]}for(var et in this._cacheBones){delete this._cacheBones[et]}for(var et in this._slotChildActions){delete this._slotChildActions[et]}return i};r.prototype._parseBone=function(e){var a=0;var i=this._armature.scale;if(t.DataParser.TYPE in e&&typeof e[t.DataParser.TYPE]==="string"){a=t.DataParser._getBoneType(e[t.DataParser.TYPE])}else{a=r._getNumber(e,t.DataParser.TYPE,0)}if(a===0){var n=t.BaseObject.borrowObject(t.BoneData);n.inheritTranslation=r._getBoolean(e,t.DataParser.INHERIT_TRANSLATION,true);n.inheritRotation=r._getBoolean(e,t.DataParser.INHERIT_ROTATION,true);n.inheritScale=r._getBoolean(e,t.DataParser.INHERIT_SCALE,true);n.inheritReflection=r._getBoolean(e,t.DataParser.INHERIT_REFLECTION,true);n.length=r._getNumber(e,t.DataParser.LENGTH,0)*i;n.name=r._getString(e,t.DataParser.NAME,"");if(t.DataParser.TRANSFORM in e){this._parseTransform(e[t.DataParser.TRANSFORM],n.transform,i)}return n}var s=t.BaseObject.borrowObject(t.SurfaceData);s.name=r._getString(e,t.DataParser.NAME,"");s.segmentX=r._getNumber(e,t.DataParser.SEGMENT_X,0);s.segmentY=r._getNumber(e,t.DataParser.SEGMENT_Y,0);s.vertices.length=(s.segmentX+1)*(s.segmentY+1)*2;if(t.DataParser.VERTICES in e){var o=e[t.DataParser.VERTICES];for(var l=0,h=s.vertices.length;l<h;++l){if(l<o.length){s.vertices[l]=o[l]*i}else{s.vertices[l]=0}}}return s};r.prototype._parseIKConstraint=function(e){var a=this._armature.getBone(r._getString(e,t.DataParser.BONE,""));if(a===null){return null}var i=this._armature.getBone(r._getString(e,t.DataParser.TARGET,""));if(i===null){return null}var n=t.BaseObject.borrowObject(t.IKConstraintData);n.scaleEnabled=r._getBoolean(e,t.DataParser.SCALE,false);n.bendPositive=r._getBoolean(e,t.DataParser.BEND_POSITIVE,true);n.weight=r._getNumber(e,t.DataParser.WEIGHT,1);n.name=r._getString(e,t.DataParser.NAME,"");n.type=0;n.target=i;var s=r._getNumber(e,t.DataParser.CHAIN,0);if(s>0&&a.parent!==null){n.root=a.parent;n.bone=a}else{n.root=a;n.bone=null}return n};r.prototype._parsePathConstraint=function(e){var a=this._armature.getSlot(r._getString(e,t.DataParser.TARGET,""));if(a===null){return null}var i=this._armature.defaultSkin;if(i===null){return null}var n=i.getDisplay(a.name,r._getString(e,t.DataParser.TARGET_DISPLAY,a.name));if(n===null||!(n instanceof t.PathDisplayData)){return null}var s=e[t.DataParser.BONES];if(s===null||s.length===0){return null}var o=t.BaseObject.borrowObject(t.PathConstraintData);o.name=r._getString(e,t.DataParser.NAME,"");o.type=1;o.pathSlot=a;o.pathDisplayData=n;o.target=a.parent;o.positionMode=t.DataParser._getPositionMode(r._getString(e,t.DataParser.POSITION_MODE,""));o.spacingMode=t.DataParser._getSpacingMode(r._getString(e,t.DataParser.SPACING_MODE,""));o.rotateMode=t.DataParser._getRotateMode(r._getString(e,t.DataParser.ROTATE_MODE,""));o.position=r._getNumber(e,t.DataParser.POSITION,0);o.spacing=r._getNumber(e,t.DataParser.SPACING,0);o.rotateOffset=r._getNumber(e,t.DataParser.ROTATE_OFFSET,0);o.rotateMix=r._getNumber(e,t.DataParser.ROTATE_MIX,1);o.translateMix=r._getNumber(e,t.DataParser.TRANSLATE_MIX,1);for(var l=0,h=s;l<h.length;l++){var f=h[l];var u=this._armature.getBone(f);if(u!==null){o.AddBone(u);if(o.root===null){o.root=u}}}return o};r.prototype._parseSlot=function(e,a){var i=t.BaseObject.borrowObject(t.SlotData);i.displayIndex=r._getNumber(e,t.DataParser.DISPLAY_INDEX,0);i.zOrder=a;i.name=r._getString(e,t.DataParser.NAME,"");i.parent=this._armature.getBone(r._getString(e,t.DataParser.PARENT,""));if(t.DataParser.BLEND_MODE in e&&typeof e[t.DataParser.BLEND_MODE]==="string"){i.blendMode=t.DataParser._getBlendMode(e[t.DataParser.BLEND_MODE])}else{i.blendMode=r._getNumber(e,t.DataParser.BLEND_MODE,0)}if(t.DataParser.COLOR in e){i.color=t.SlotData.createColor();this._parseColorTransform(e[t.DataParser.COLOR],i.color)}else{i.color=t.SlotData.DEFAULT_COLOR}if(t.DataParser.ACTIONS in e){this._slotChildActions[i.name]=this._parseActionData(e[t.DataParser.ACTIONS],0,null,null)}return i};r.prototype._parseSkin=function(e){var a=t.BaseObject.borrowObject(t.SkinData);a.name=r._getString(e,t.DataParser.NAME,t.DataParser.DEFAULT_NAME);if(a.name.length===0){a.name=t.DataParser.DEFAULT_NAME}if(t.DataParser.SLOT in e){var i=e[t.DataParser.SLOT];this._skin=a;for(var n=0,s=i;n<s.length;n++){var o=s[n];var l=r._getString(o,t.DataParser.NAME,"");var h=this._armature.getSlot(l);if(h!==null){this._slot=h;if(t.DataParser.DISPLAY in o){var f=o[t.DataParser.DISPLAY];for(var u=0,_=f;u<_.length;u++){var c=_[u];if(c){a.addDisplay(l,this._parseDisplay(c))}else{a.addDisplay(l,null)}}}this._slot=null}}this._skin=null}return a};r.prototype._parseDisplay=function(e){var a=r._getString(e,t.DataParser.NAME,"");var i=r._getString(e,t.DataParser.PATH,"");var n=0;var s=null;if(t.DataParser.TYPE in e&&typeof e[t.DataParser.TYPE]==="string"){n=t.DataParser._getDisplayType(e[t.DataParser.TYPE])}else{n=r._getNumber(e,t.DataParser.TYPE,n)}switch(n){case 0:var o=s=t.BaseObject.borrowObject(t.ImageDisplayData);o.name=a;o.path=i.length>0?i:a;this._parsePivot(e,o);break;case 1:var l=s=t.BaseObject.borrowObject(t.ArmatureDisplayData);l.name=a;l.path=i.length>0?i:a;l.inheritAnimation=true;if(t.DataParser.ACTIONS in e){var h=this._parseActionData(e[t.DataParser.ACTIONS],0,null,null);for(var f=0,u=h;f<u.length;f++){var _=u[f];l.addAction(_)}}else if(this._slot.name in this._slotChildActions){var c=this._skin.getDisplays(this._slot.name);if(c===null?this._slot.displayIndex===0:this._slot.displayIndex===c.length){for(var p=0,m=this._slotChildActions[this._slot.name];p<m.length;p++){var _=m[p];l.addAction(_)}delete this._slotChildActions[this._slot.name]}}break;case 2:var d=s=t.BaseObject.borrowObject(t.MeshDisplayData);d.vertices.inheritDeform=r._getBoolean(e,t.DataParser.INHERIT_DEFORM,true);d.name=a;d.path=i.length>0?i:a;d.vertices.data=this._data;if(t.DataParser.SHARE in e){this._cacheRawMeshes.push(e);this._cacheMeshes.push(d)}else{this._parseMesh(e,d)}if(t.DataParser.GLUE_WEIGHTS in e&&t.DataParser.GLUE_MESHES in e){this._cacheRawMeshes.push(e);this._cacheMeshes.push(d)}break;case 3:var v=this._parseBoundingBox(e);if(v!==null){var y=s=t.BaseObject.borrowObject(t.BoundingBoxDisplayData);y.name=a;y.path=i.length>0?i:a;y.boundingBox=v}break;case 4:var g=e[t.DataParser.LENGTHS];var b=s=t.BaseObject.borrowObject(t.PathDisplayData);b.closed=r._getBoolean(e,t.DataParser.CLOSED,false);b.constantSpeed=r._getBoolean(e,t.DataParser.CONSTANT_SPEED,false);b.name=a;b.path=i.length>0?i:a;b.vertices.data=this._data;b.curveLengths.length=g.length;for(var D=0,T=g.length;D<T;++D){b.curveLengths[D]=g[D]}this._parsePath(e,b);break}if(s!==null&&t.DataParser.TRANSFORM in e){this._parseTransform(e[t.DataParser.TRANSFORM],s.transform,this._armature.scale)}return s};r.prototype._parsePath=function(e,a){var i=e[t.DataParser.VERTICES];var n=r._getNumber(e,t.DataParser.VERTEX_COUNT,0);var s=this._floatArray.length;var o=this._intArray.length;a.vertices.offset=o;this._intArray.length+=1+1;this._intArray[o+0]=n;this._intArray[o+2]=s;if(!(t.DataParser.WEIGHTS in e)){this._floatArray.length+=i.length;for(var l=0,h=i.length;l<h;++l){this._floatArray[s+l]=i[l]}}else{var f=e[t.DataParser.WEIGHTS];var u=e[t.DataParser.BONES];var _=u.length;var c=Math.floor(f.length-n)/2;var p=this._intArray.length;var m=this._floatArray.length;var d=this._armature.sortedBones;var v=t.BaseObject.borrowObject(t.WeightData);v.count=c;v.offset=p;this._intArray.length+=1+1+_+n+c;this._intArray[p+0]=_;this._intArray[p+1]=m;for(var l=0;l<_;l++){var y=u[l];var g=this._rawBones[y];v.addBone(g);this._intArray[p+2+l]=d.indexOf(g)}this._floatArray.length+=c*3;for(var l=0,b=0,D=0,T=p+2+_,A=m;l<c;l++){var x=f[b++];this._intArray[T++]=x;for(var P=0;P<x;P++){var O=f[b++];var S=f[b++];var E=i[D++];var M=i[D++];this._intArray[T++]=u.indexOf(O);this._floatArray[A++]=S;this._floatArray[A++]=E;this._floatArray[A++]=M}}a.vertices.weight=v}};r.prototype._parsePivot=function(e,a){if(t.DataParser.PIVOT in e){var i=e[t.DataParser.PIVOT];a.pivot.x=r._getNumber(i,t.DataParser.X,0);a.pivot.y=r._getNumber(i,t.DataParser.Y,0)}else{a.pivot.x=.5;a.pivot.y=.5}};r.prototype._parseMesh=function(e,a){var r=e[t.DataParser.VERTICES];var i=e[t.DataParser.UVS];var n=e[t.DataParser.TRIANGLES];var s=Math.floor(r.length/2);var o=Math.floor(n.length/3);var l=this._floatArray.length;var h=l+s*2;var f=this._intArray.length;var u=this._skin.name+"_"+this._slot.name+"_"+a.name;a.vertices.offset=f;this._intArray.length+=1+1+1+1+o*3;this._intArray[f+0]=s;this._intArray[f+1]=o;this._intArray[f+2]=l;for(var _=0,c=o*3;_<c;++_){this._intArray[f+4+_]=n[_]}this._floatArray.length+=s*2+s*2;for(var _=0,c=s*2;_<c;++_){this._floatArray[l+_]=r[_];this._floatArray[h+_]=i[_]}if(t.DataParser.WEIGHTS in e){var p=e[t.DataParser.WEIGHTS];var m=e[t.DataParser.SLOT_POSE];var d=e[t.DataParser.BONE_POSE];var v=this._armature.sortedBones;var y=new Array;var g=Math.floor(d.length/7);var b=this._floatArray.length;var D=Math.floor(p.length-s)/2;var T=this._intArray.length;var A=t.BaseObject.borrowObject(t.WeightData);A.count=D;A.offset=T;y.length=g;this._intArray.length+=1+1+g+s+D;this._intArray[T+1]=b;for(var _=0;_<g;++_){var x=d[_*7];var P=this._rawBones[x];A.addBone(P);y[_]=x;this._intArray[T+2+_]=v.indexOf(P)}this._floatArray.length+=D*3;this._helpMatrixA.copyFromArray(m,0);for(var _=0,O=0,S=T+2+g,E=b;_<s;++_){var M=_*2;var B=this._intArray[S++]=p[O++];var C=this._floatArray[l+M];var w=this._floatArray[l+M+1];this._helpMatrixA.transformPoint(C,w,this._helpPoint);C=this._helpPoint.x;w=this._helpPoint.y;for(var I=0;I<B;++I){var x=p[O++];var F=y.indexOf(x);this._helpMatrixB.copyFromArray(d,F*7+1);this._helpMatrixB.invert();this._helpMatrixB.transformPoint(C,w,this._helpPoint);this._intArray[S++]=F;this._floatArray[E++]=p[O++];this._floatArray[E++]=this._helpPoint.x;this._floatArray[E++]=this._helpPoint.y}}a.vertices.weight=A;this._weightSlotPose[u]=m;this._weightBonePoses[u]=d}};r.prototype._parseMeshGlue=function(t,e){t;e};r.prototype._parseBoundingBox=function(e){var a=null;var i=0;if(t.DataParser.SUB_TYPE in e&&typeof e[t.DataParser.SUB_TYPE]==="string"){i=t.DataParser._getBoundingBoxType(e[t.DataParser.SUB_TYPE])}else{i=r._getNumber(e,t.DataParser.SUB_TYPE,i)}switch(i){case 0:a=t.BaseObject.borrowObject(t.RectangleBoundingBoxData);break;case 1:a=t.BaseObject.borrowObject(t.EllipseBoundingBoxData);break;case 2:a=this._parsePolygonBoundingBox(e);break}if(a!==null){a.color=r._getNumber(e,t.DataParser.COLOR,0);if(a.type===0||a.type===1){a.width=r._getNumber(e,t.DataParser.WIDTH,0);a.height=r._getNumber(e,t.DataParser.HEIGHT,0)}}return a};r.prototype._parsePolygonBoundingBox=function(e){var a=t.BaseObject.borrowObject(t.PolygonBoundingBoxData);if(t.DataParser.VERTICES in e){var r=this._armature.scale;var i=e[t.DataParser.VERTICES];var n=a.vertices;if(t.DragonBones.webAssembly){n.resize(i.length,0)}else{n.length=i.length}for(var s=0,o=i.length;s<o;s+=2){var l=i[s]*r;var h=i[s+1]*r;if(t.DragonBones.webAssembly){n.set(s,l);n.set(s+1,h)}else{n[s]=l;n[s+1]=h}if(s===0){a.x=l;a.y=h;a.width=l;a.height=h}else{if(l<a.x){a.x=l}else if(l>a.width){a.width=l}if(h<a.y){a.y=h}else if(h>a.height){a.height=h}}}a.width-=a.x;a.height-=a.y}else{console.warn("Data error.\n Please reexport DragonBones Data to fixed the bug.")}return a};r.prototype._parseAnimation=function(e){var a=t.BaseObject.borrowObject(t.AnimationData);a.frameCount=Math.max(r._getNumber(e,t.DataParser.DURATION,1),1);a.playTimes=r._getNumber(e,t.DataParser.PLAY_TIMES,1);a.duration=a.frameCount/this._armature.frameRate;a.fadeInTime=r._getNumber(e,t.DataParser.FADE_IN_TIME,0);a.scale=r._getNumber(e,t.DataParser.SCALE,1);a.name=r._getString(e,t.DataParser.NAME,t.DataParser.DEFAULT_NAME);if(a.name.length===0){a.name=t.DataParser.DEFAULT_NAME}a.frameIntOffset=this._frameIntArray.length;a.frameFloatOffset=this._frameFloatArray.length;a.frameOffset=this._frameArray.length;this._animation=a;if(t.DataParser.FRAME in e){var i=e[t.DataParser.FRAME];var n=i.length;if(n>0){for(var s=0,o=0;s<n;++s){var l=i[s];this._parseActionDataInFrame(l,o,null,null);o+=r._getNumber(l,t.DataParser.DURATION,1)}}}if(t.DataParser.Z_ORDER in e){this._animation.zOrderTimeline=this._parseTimeline(e[t.DataParser.Z_ORDER],null,t.DataParser.FRAME,1,false,false,0,this._parseZOrderFrame)}if(t.DataParser.BONE in e){var h=e[t.DataParser.BONE];for(var f=0,u=h;f<u.length;f++){var _=u[f];this._parseBoneTimeline(_)}}if(t.DataParser.SURFACE in e){var h=e[t.DataParser.SURFACE];for(var c=0,p=h;c<p.length;c++){var _=p[c];var m=r._getString(_,t.DataParser.NAME,"");this._surface=this._armature.getBone(m);if(this._surface===null){continue}var d=this._parseTimeline(_,null,t.DataParser.FRAME,50,false,true,0,this._parseSurfaceFrame);if(d!==null){this._animation.addSurfaceTimeline(this._surface,d)}this._surface=null}}if(t.DataParser.SLOT in e){var h=e[t.DataParser.SLOT];for(var v=0,y=h;v<y.length;v++){var _=y[v];this._parseSlotTimeline(_)}}if(t.DataParser.FFD in e){var h=e[t.DataParser.FFD];for(var g=0,b=h;g<b.length;g++){var _=b[g];var D=r._getString(_,t.DataParser.SKIN,t.DataParser.DEFAULT_NAME);var T=r._getString(_,t.DataParser.SLOT,"");var A=r._getString(_,t.DataParser.NAME,"");if(D.length===0){D=t.DataParser.DEFAULT_NAME}this._slot=this._armature.getSlot(T);this._mesh=this._armature.getMesh(D,T,A);if(this._slot===null||this._mesh===null){continue}var d=this._parseTimeline(_,null,t.DataParser.FRAME,22,false,true,0,this._parseSlotFFDFrame);if(d!==null){this._animation.addSlotTimeline(this._slot,d)}this._slot=null;this._mesh=null}}if(t.DataParser.IK in e){var h=e[t.DataParser.IK];for(var x=0,P=h;x<P.length;x++){var _=P[x];var O=r._getString(_,t.DataParser.NAME,"");var S=this._armature.getConstraint(O);if(S===null){continue}var d=this._parseTimeline(_,null,t.DataParser.FRAME,30,true,false,2,this._parseIKConstraintFrame);if(d!==null){this._animation.addConstraintTimeline(S,d)}}}if(t.DataParser.ANIMATION in e){var h=e[t.DataParser.ANIMATION];for(var E=0,M=h;E<M.length;E++){var _=M[E];var B=r._getString(_,t.DataParser.NAME,"");var d=this._parseTimeline(_,null,t.DataParser.FRAME,40,true,false,2,this._parseAnimationFrame);if(d!==null){this._animation.addAnimationTimeline(B,d)}}}if(this._actionFrames.length>0){this._animation.actionTimeline=this._parseTimeline(null,this._actionFrames,"",0,false,false,0,this._parseActionFrame);this._actionFrames.length=0}this._animation=null;return a};r.prototype._parseTimeline=function(e,i,n,s,o,l,h,f){if(e!==null&&n.length>0&&n in e){i=e[n]}if(i===null){return null}var u=i.length;if(u===0){return null}var _=this._frameIntArray.length;var c=this._frameFloatArray.length;var p=t.BaseObject.borrowObject(t.TimelineData);var m=this._timelineArray.length;this._timelineArray.length+=1+1+1+1+1+u;if(e!==null){this._timelineArray[m+0]=Math.round(r._getNumber(e,t.DataParser.SCALE,1)*100);this._timelineArray[m+1]=Math.round(r._getNumber(e,t.DataParser.OFFSET,0)*100)}else{this._timelineArray[m+0]=100;this._timelineArray[m+1]=0}this._timelineArray[m+2]=u;this._timelineArray[m+3]=h;if(o){this._timelineArray[m+4]=_-this._animation.frameIntOffset}else if(l){this._timelineArray[m+4]=c-this._animation.frameFloatOffset}else{this._timelineArray[m+4]=0}this._timeline=p;p.type=s;p.offset=m;if(u===1){p.frameIndicesOffset=-1;this._timelineArray[m+5+0]=f.call(this,i[0],0,0)-this._animation.frameOffset}else{var d=this._animation.frameCount+1;var v=this._data.frameIndices;var y=0;if(t.DragonBones.webAssembly){y=v.size();v.resize(y+d,0)}else{y=v.length;v.length+=d}p.frameIndicesOffset=y;for(var g=0,b=0,D=0,T=0;g<d;++g){if(D+T<=g&&b<u){var A=i[b];D=g;if(b===u-1){T=this._animation.frameCount-D}else{if(A instanceof a){T=this._actionFrames[b+1].frameStart-D}else{T=r._getNumber(A,t.DataParser.DURATION,1)}}this._timelineArray[m+5+b]=f.call(this,A,D,T)-this._animation.frameOffset;b++}if(t.DragonBones.webAssembly){v.set(y+g,b-1)}else{v[y+g]=b-1}}}this._timeline=null;return p};r.prototype._parseBoneTimeline=function(e){var a=this._armature.getBone(r._getString(e,t.DataParser.NAME,""));if(a===null){return}this._bone=a;this._slot=this._armature.getSlot(this._bone.name);if(t.DataParser.TRANSLATE_FRAME in e){var i=this._parseTimeline(e,null,t.DataParser.TRANSLATE_FRAME,11,false,true,2,this._parseBoneTranslateFrame);if(i!==null){this._animation.addBoneTimeline(a,i)}}if(t.DataParser.ROTATE_FRAME in e){var i=this._parseTimeline(e,null,t.DataParser.ROTATE_FRAME,12,false,true,2,this._parseBoneRotateFrame);if(i!==null){this._animation.addBoneTimeline(a,i)}}if(t.DataParser.SCALE_FRAME in e){var i=this._parseTimeline(e,null,t.DataParser.SCALE_FRAME,13,false,true,2,this._parseBoneScaleFrame);if(i!==null){this._animation.addBoneTimeline(a,i)}}if(t.DataParser.FRAME in e){var i=this._parseTimeline(e,null,t.DataParser.FRAME,10,false,true,6,this._parseBoneAllFrame);if(i!==null){this._animation.addBoneTimeline(a,i)}}this._bone=null;this._slot=null};r.prototype._parseSlotTimeline=function(e){var a=this._armature.getSlot(r._getString(e,t.DataParser.NAME,""));if(a===null){return}this._slot=a;var i=null;if(t.DataParser.DISPLAY_FRAME in e){i=this._parseTimeline(e,null,t.DataParser.DISPLAY_FRAME,20,false,false,0,this._parseSlotDisplayFrame)}else{i=this._parseTimeline(e,null,t.DataParser.FRAME,20,false,false,0,this._parseSlotDisplayFrame)}if(i!==null){this._animation.addSlotTimeline(a,i)}var n=null;if(t.DataParser.COLOR_FRAME in e){n=this._parseTimeline(e,null,t.DataParser.COLOR_FRAME,21,true,false,1,this._parseSlotColorFrame)}else{n=this._parseTimeline(e,null,t.DataParser.FRAME,21,true,false,1,this._parseSlotColorFrame)}if(n!==null){this._animation.addSlotTimeline(a,n)}this._slot=null};r.prototype._parseFrame=function(t,e,a){t;a;var r=this._frameArray.length;this._frameArray.length+=1;this._frameArray[r+0]=e;return r};r.prototype._parseTweenFrame=function(e,a,i){var n=this._parseFrame(e,a,i);if(i>0){if(t.DataParser.CURVE in e){var s=i+1;this._helpArray.length=s;this._samplingEasingCurve(e[t.DataParser.CURVE],this._helpArray);this._frameArray.length+=1+1+this._helpArray.length;this._frameArray[n+1]=2;this._frameArray[n+2]=s;for(var o=0;o<s;++o){this._frameArray[n+3+o]=Math.round(this._helpArray[o]*1e4)}}else{var l=-2;var h=l;if(t.DataParser.TWEEN_EASING in e){h=r._getNumber(e,t.DataParser.TWEEN_EASING,l)}if(h===l){this._frameArray.length+=1;this._frameArray[n+1]=0}else if(h===0){this._frameArray.length+=1;this._frameArray[n+1]=1}else if(h<0){this._frameArray.length+=1+1;this._frameArray[n+1]=3;this._frameArray[n+2]=Math.round(-h*100)}else if(h<=1){this._frameArray.length+=1+1;this._frameArray[n+1]=4;this._frameArray[n+2]=Math.round(h*100)}else{this._frameArray.length+=1+1;this._frameArray[n+1]=5;this._frameArray[n+2]=Math.round(h*100-100)}}}else{this._frameArray.length+=1;this._frameArray[n+1]=0}return n};r.prototype._parseActionFrame=function(t,e,a){a;var r=this._frameArray.length;var i=t.actions.length;this._frameArray.length+=1+1+i;this._frameArray[r+0]=e;this._frameArray[r+0+1]=i;for(var n=0;n<i;++n){this._frameArray[r+0+2+n]=t.actions[n]}return r};r.prototype._parseZOrderFrame=function(e,a,r){var i=this._parseFrame(e,a,r);if(t.DataParser.Z_ORDER in e){var n=e[t.DataParser.Z_ORDER];if(n.length>0){var s=this._armature.sortedSlots.length;var o=new Array(s-n.length/2);var l=new Array(s);for(var h=0;h<o.length;++h){o[h]=0}for(var f=0;f<s;++f){l[f]=-1}var u=0;var _=0;for(var c=0,p=n.length;c<p;c+=2){var m=n[c];var d=n[c+1];while(u!==m){o[_++]=u++}var v=u+d;l[v]=u++}while(u<s){o[_++]=u++}this._frameArray.length+=1+s;this._frameArray[i+1]=s;var y=s;while(y--){if(l[y]===-1){this._frameArray[i+2+y]=o[--_]||0}else{this._frameArray[i+2+y]=l[y]||0}}return i}}this._frameArray.length+=1;this._frameArray[i+1]=0;return i};r.prototype._parseBoneAllFrame=function(e,a,i){this._helpTransform.identity();if(t.DataParser.TRANSFORM in e){this._parseTransform(e[t.DataParser.TRANSFORM],this._helpTransform,1)}var n=this._helpTransform.rotation;if(a!==0){if(this._prevClockwise===0){n=this._prevRotation+t.Transform.normalizeRadian(n-this._prevRotation)}else{if(this._prevClockwise>0?n>=this._prevRotation:n<=this._prevRotation){this._prevClockwise=this._prevClockwise>0?this._prevClockwise-1:this._prevClockwise+1}n=this._prevRotation+n-this._prevRotation+t.Transform.PI_D*this._prevClockwise}}this._prevClockwise=r._getNumber(e,t.DataParser.TWEEN_ROTATE,0);this._prevRotation=n;var s=this._parseTweenFrame(e,a,i);var o=this._frameFloatArray.length;this._frameFloatArray.length+=6;this._frameFloatArray[o++]=this._helpTransform.x;this._frameFloatArray[o++]=this._helpTransform.y;this._frameFloatArray[o++]=n;this._frameFloatArray[o++]=this._helpTransform.skew;this._frameFloatArray[o++]=this._helpTransform.scaleX;this._frameFloatArray[o++]=this._helpTransform.scaleY;this._parseActionDataInFrame(e,a,this._bone,this._slot);return s};r.prototype._parseBoneTranslateFrame=function(e,a,i){var n=this._parseTweenFrame(e,a,i);var s=this._frameFloatArray.length;this._frameFloatArray.length+=2;this._frameFloatArray[s++]=r._getNumber(e,t.DataParser.X,0);this._frameFloatArray[s++]=r._getNumber(e,t.DataParser.Y,0);return n};r.prototype._parseBoneRotateFrame=function(e,a,i){var n=r._getNumber(e,t.DataParser.ROTATE,0)*t.Transform.DEG_RAD;if(a!==0){if(this._prevClockwise===0){n=this._prevRotation+t.Transform.normalizeRadian(n-this._prevRotation)}else{if(this._prevClockwise>0?n>=this._prevRotation:n<=this._prevRotation){this._prevClockwise=this._prevClockwise>0?this._prevClockwise-1:this._prevClockwise+1}n=this._prevRotation+n-this._prevRotation+t.Transform.PI_D*this._prevClockwise}}this._prevClockwise=r._getNumber(e,t.DataParser.CLOCK_WISE,0);this._prevRotation=n;var s=this._parseTweenFrame(e,a,i);var o=this._frameFloatArray.length;this._frameFloatArray.length+=2;this._frameFloatArray[o++]=n;this._frameFloatArray[o++]=r._getNumber(e,t.DataParser.SKEW,0)*t.Transform.DEG_RAD;return s};r.prototype._parseBoneScaleFrame=function(e,a,i){var n=this._parseTweenFrame(e,a,i);var s=this._frameFloatArray.length;this._frameFloatArray.length+=2;this._frameFloatArray[s++]=r._getNumber(e,t.DataParser.X,1);this._frameFloatArray[s++]=r._getNumber(e,t.DataParser.Y,1);return n};r.prototype._parseSurfaceFrame=function(e,a,i){var n=this._frameFloatArray.length;var s=this._parseTweenFrame(e,a,i);var o=e[t.DataParser.VERTICES];var l=r._getNumber(e,t.DataParser.OFFSET,0);var h=this._surface.vertices.length/2;var f=0;var u=0;this._frameFloatArray.length+=h*2;for(var _=0;_<h*2;_+=2){if(_<l||_-l>=o.length){f=0}else{f=o[_-l]}if(_+1<l||_+1-l>=o.length){u=0}else{u=o[_+1-l]}this._frameFloatArray[n+_]=f;this._frameFloatArray[n+_+1]=u}if(a===0){var c=this._frameIntArray.length;this._frameIntArray.length+=1+1+1+1+1;this._frameIntArray[c+0]=0;this._frameIntArray[c+1]=this._frameFloatArray.length-n;this._frameIntArray[c+2]=this._frameFloatArray.length-n;this._frameIntArray[c+3]=0;this._frameIntArray[c+4]=n-this._animation.frameFloatOffset;this._timelineArray[this._timeline.offset+3]=c-this._animation.frameIntOffset}return s};r.prototype._parseSlotDisplayFrame=function(e,a,i){var n=this._parseFrame(e,a,i);this._frameArray.length+=1;if(t.DataParser.VALUE in e){this._frameArray[n+1]=r._getNumber(e,t.DataParser.VALUE,0)}else{this._frameArray[n+1]=r._getNumber(e,t.DataParser.DISPLAY_INDEX,0)}this._parseActionDataInFrame(e,a,this._slot.parent,this._slot);return n};r.prototype._parseSlotColorFrame=function(e,a,r){var i=this._parseTweenFrame(e,a,r);var n=-1;if(t.DataParser.VALUE in e||t.DataParser.COLOR in e){var s=t.DataParser.VALUE in e?e[t.DataParser.VALUE]:e[t.DataParser.COLOR];for(var o in s){o;this._parseColorTransform(s,this._helpColorTransform);n=this._intArray.length;this._intArray.length+=8;this._intArray[n++]=Math.round(this._helpColorTransform.alphaMultiplier*100);this._intArray[n++]=Math.round(this._helpColorTransform.redMultiplier*100);this._intArray[n++]=Math.round(this._helpColorTransform.greenMultiplier*100);this._intArray[n++]=Math.round(this._helpColorTransform.blueMultiplier*100);this._intArray[n++]=Math.round(this._helpColorTransform.alphaOffset);this._intArray[n++]=Math.round(this._helpColorTransform.redOffset);this._intArray[n++]=Math.round(this._helpColorTransform.greenOffset);this._intArray[n++]=Math.round(this._helpColorTransform.blueOffset);n-=8;break}}if(n<0){if(this._defaultColorOffset<0){this._defaultColorOffset=n=this._intArray.length;this._intArray.length+=8;this._intArray[n++]=100;this._intArray[n++]=100;this._intArray[n++]=100;this._intArray[n++]=100;this._intArray[n++]=0;this._intArray[n++]=0;this._intArray[n++]=0;this._intArray[n++]=0}n=this._defaultColorOffset}var l=this._frameIntArray.length;this._frameIntArray.length+=1;this._frameIntArray[l]=n;return i};r.prototype._parseSlotFFDFrame=function(e,a,i){var n=this._frameFloatArray.length;var s=this._parseTweenFrame(e,a,i);var o=t.DataParser.VERTICES in e?e[t.DataParser.VERTICES]:null;var l=r._getNumber(e,t.DataParser.OFFSET,0);var h=this._intArray[this._mesh.vertices.offset+0];var f=this._mesh.parent.name+"_"+this._slot.name+"_"+this._mesh.name;var u=this._mesh.vertices.weight;var _=0;var c=0;var p=0;var m=0;if(u!==null){var d=this._weightSlotPose[f];this._helpMatrixA.copyFromArray(d,0);this._frameFloatArray.length+=u.count*2;p=u.offset+2+u.bones.length}else{this._frameFloatArray.length+=h*2}for(var v=0;v<h*2;v+=2){if(o===null){_=0;c=0}else{if(v<l||v-l>=o.length){_=0}else{_=o[v-l]}if(v+1<l||v+1-l>=o.length){c=0}else{c=o[v+1-l]}}if(u!==null){var y=this._weightBonePoses[f];var g=this._intArray[p++];this._helpMatrixA.transformPoint(_,c,this._helpPoint,true);_=this._helpPoint.x;c=this._helpPoint.y;for(var b=0;b<g;++b){var D=this._intArray[p++];this._helpMatrixB.copyFromArray(y,D*7+1);this._helpMatrixB.invert();this._helpMatrixB.transformPoint(_,c,this._helpPoint,true);this._frameFloatArray[n+m++]=this._helpPoint.x;this._frameFloatArray[n+m++]=this._helpPoint.y}}else{this._frameFloatArray[n+v]=_;this._frameFloatArray[n+v+1]=c}}if(a===0){var T=this._frameIntArray.length;this._frameIntArray.length+=1+1+1+1+1;this._frameIntArray[T+0]=this._mesh.vertices.offset;this._frameIntArray[T+1]=this._frameFloatArray.length-n;this._frameIntArray[T+2]=this._frameFloatArray.length-n;this._frameIntArray[T+3]=0;this._frameIntArray[T+4]=n-this._animation.frameFloatOffset;this._timelineArray[this._timeline.offset+3]=T-this._animation.frameIntOffset}return s};r.prototype._parseIKConstraintFrame=function(e,a,i){var n=this._parseTweenFrame(e,a,i);var s=this._frameIntArray.length;this._frameIntArray.length+=2;this._frameIntArray[s++]=r._getBoolean(e,t.DataParser.BEND_POSITIVE,true)?1:0;this._frameIntArray[s++]=Math.round(r._getNumber(e,t.DataParser.WEIGHT,1)*100);return n};r.prototype._parseAnimationFrame=function(e,a,i){var n=this._parseTweenFrame(e,a,i);var s=this._frameIntArray.length;this._frameIntArray.length+=2;this._frameIntArray[s++]=r._getNumber(e,t.DataParser.VALUE,0);this._frameIntArray[s++]=Math.round(r._getNumber(e,t.DataParser.WEIGHT,1)*100);return n};r.prototype._parseActionData=function(e,a,i,n){var s=new Array;if(typeof e==="string"){var o=t.BaseObject.borrowObject(t.ActionData);o.type=a;o.name=e;o.bone=i;o.slot=n;s.push(o)}else if(e instanceof Array){for(var l=0,h=e;l<h.length;l++){var f=h[l];var o=t.BaseObject.borrowObject(t.ActionData);if(t.DataParser.GOTO_AND_PLAY in f){o.type=0;o.name=r._getString(f,t.DataParser.GOTO_AND_PLAY,"")}else{if(t.DataParser.TYPE in f&&typeof f[t.DataParser.TYPE]==="string"){o.type=t.DataParser._getActionType(f[t.DataParser.TYPE])}else{o.type=r._getNumber(f,t.DataParser.TYPE,a)}o.name=r._getString(f,t.DataParser.NAME,"")}if(t.DataParser.BONE in f){var u=r._getString(f,t.DataParser.BONE,"");o.bone=this._armature.getBone(u)}else{o.bone=i}if(t.DataParser.SLOT in f){var _=r._getString(f,t.DataParser.SLOT,"");o.slot=this._armature.getSlot(_)}else{o.slot=n}var c=null;if(t.DataParser.INTS in f){if(c===null){c=t.BaseObject.borrowObject(t.UserData)}var p=f[t.DataParser.INTS];for(var m=0,d=p;m<d.length;m++){var v=d[m];c.addInt(v)}}if(t.DataParser.FLOATS in f){if(c===null){c=t.BaseObject.borrowObject(t.UserData)}var y=f[t.DataParser.FLOATS];for(var g=0,b=y;g<b.length;g++){var v=b[g];c.addFloat(v)}}if(t.DataParser.STRINGS in f){if(c===null){c=t.BaseObject.borrowObject(t.UserData)}var D=f[t.DataParser.STRINGS];for(var T=0,A=D;T<A.length;T++){var v=A[T];c.addString(v)}}o.data=c;s.push(o)}}return s};r.prototype._parseTransform=function(e,a,i){a.x=r._getNumber(e,t.DataParser.X,0)*i;a.y=r._getNumber(e,t.DataParser.Y,0)*i;if(t.DataParser.ROTATE in e||t.DataParser.SKEW in e){a.rotation=t.Transform.normalizeRadian(r._getNumber(e,t.DataParser.ROTATE,0)*t.Transform.DEG_RAD);a.skew=t.Transform.normalizeRadian(r._getNumber(e,t.DataParser.SKEW,0)*t.Transform.DEG_RAD)}else if(t.DataParser.SKEW_X in e||t.DataParser.SKEW_Y in e){a.rotation=t.Transform.normalizeRadian(r._getNumber(e,t.DataParser.SKEW_Y,0)*t.Transform.DEG_RAD);a.skew=t.Transform.normalizeRadian(r._getNumber(e,t.DataParser.SKEW_X,0)*t.Transform.DEG_RAD)-a.rotation}a.scaleX=r._getNumber(e,t.DataParser.SCALE_X,1);a.scaleY=r._getNumber(e,t.DataParser.SCALE_Y,1)};r.prototype._parseColorTransform=function(e,a){a.alphaMultiplier=r._getNumber(e,t.DataParser.ALPHA_MULTIPLIER,100)*.01;a.redMultiplier=r._getNumber(e,t.DataParser.RED_MULTIPLIER,100)*.01;a.greenMultiplier=r._getNumber(e,t.DataParser.GREEN_MULTIPLIER,100)*.01;a.blueMultiplier=r._getNumber(e,t.DataParser.BLUE_MULTIPLIER,100)*.01;a.alphaOffset=r._getNumber(e,t.DataParser.ALPHA_OFFSET,0);a.redOffset=r._getNumber(e,t.DataParser.RED_OFFSET,0);a.greenOffset=r._getNumber(e,t.DataParser.GREEN_OFFSET,0);a.blueOffset=r._getNumber(e,t.DataParser.BLUE_OFFSET,0)};r.prototype._parseArray=function(t){t;this._intArray.length=0;this._floatArray.length=0;this._frameIntArray.length=0;this._frameFloatArray.length=0;this._frameArray.length=0;this._timelineArray.length=0};r.prototype._modifyArray=function(){if(this._intArray.length%Int16Array.BYTES_PER_ELEMENT!==0){this._intArray.push(0)}if(this._frameIntArray.length%Int16Array.BYTES_PER_ELEMENT!==0){this._frameIntArray.push(0)}if(this._frameArray.length%Int16Array.BYTES_PER_ELEMENT!==0){this._frameArray.push(0)}if(this._timelineArray.length%Uint16Array.BYTES_PER_ELEMENT!==0){this._timelineArray.push(0)}var e=this._intArray.length*Int16Array.BYTES_PER_ELEMENT;var a=this._floatArray.length*Float32Array.BYTES_PER_ELEMENT;var r=this._frameIntArray.length*Int16Array.BYTES_PER_ELEMENT;var i=this._frameFloatArray.length*Float32Array.BYTES_PER_ELEMENT;var n=this._frameArray.length*Int16Array.BYTES_PER_ELEMENT;var s=this._timelineArray.length*Uint16Array.BYTES_PER_ELEMENT;var o=e+a+r+i+n+s;if(t.DragonBones.webAssembly){var l=t.webAssemblyModule.HEAP16.buffer;var h=t.webAssemblyModule._malloc(o);var f=new Int16Array(l,h,this._intArray.length);var u=new Float32Array(l,h+e,this._floatArray.length);var _=new Int16Array(l,h+e+a,this._frameIntArray.length);var c=new Float32Array(l,h+e+a+r,this._frameFloatArray.length);var p=new Int16Array(l,h+e+a+r+i,this._frameArray.length);var m=new Uint16Array(l,h+e+a+r+i+n,this._timelineArray.length);for(var d=0,v=this._intArray.length;d<v;++d){f[d]=this._intArray[d]}for(var d=0,v=this._floatArray.length;d<v;++d){u[d]=this._floatArray[d]}for(var d=0,v=this._frameIntArray.length;d<v;++d){_[d]=this._frameIntArray[d]}for(var d=0,v=this._frameFloatArray.length;d<v;++d){c[d]=this._frameFloatArray[d]}for(var d=0,v=this._frameArray.length;d<v;++d){p[d]=this._frameArray[d]}for(var d=0,v=this._timelineArray.length;d<v;++d){m[d]=this._timelineArray[d]}t.webAssemblyModule.setDataBinary(this._data,h,e,a,r,i,n,s)}else{var y=new ArrayBuffer(o);var f=new Int16Array(y,0,this._intArray.length);var u=new Float32Array(y,e,this._floatArray.length);var _=new Int16Array(y,e+a,this._frameIntArray.length);var c=new Float32Array(y,e+a+r,this._frameFloatArray.length);var p=new Int16Array(y,e+a+r+i,this._frameArray.length);var m=new Uint16Array(y,e+a+r+i+n,this._timelineArray.length);for(var d=0,v=this._intArray.length;d<v;++d){f[d]=this._intArray[d]}for(var d=0,v=this._floatArray.length;d<v;++d){u[d]=this._floatArray[d]}for(var d=0,v=this._frameIntArray.length;d<v;++d){_[d]=this._frameIntArray[d]}for(var d=0,v=this._frameFloatArray.length;d<v;++d){c[d]=this._frameFloatArray[d]}for(var d=0,v=this._frameArray.length;d<v;++d){p[d]=this._frameArray[d]}for(var d=0,v=this._timelineArray.length;d<v;++d){m[d]=this._timelineArray[d]}this._data.binary=y;this._data.intArray=f;this._data.floatArray=u;this._data.frameIntArray=_;this._data.frameFloatArray=c;this._data.frameArray=p;this._data.timelineArray=m}this._defaultColorOffset=-1};r.prototype.parseDragonBonesData=function(e,a){if(a===void 0){a=1}console.assert(e!==null&&e!==undefined,"Data error.");var i=r._getString(e,t.DataParser.VERSION,"");var n=r._getString(e,t.DataParser.COMPATIBLE_VERSION,"");if(t.DataParser.DATA_VERSIONS.indexOf(i)>=0||t.DataParser.DATA_VERSIONS.indexOf(n)>=0){var s=t.BaseObject.borrowObject(t.DragonBonesData);s.version=i;s.name=r._getString(e,t.DataParser.NAME,"");s.frameRate=r._getNumber(e,t.DataParser.FRAME_RATE,24);if(s.frameRate===0){s.frameRate=24}if(t.DataParser.ARMATURE in e){this._data=s;this._parseArray(e);var o=e[t.DataParser.ARMATURE];for(var l=0,h=o;l<h.length;l++){var f=h[l];s.addArmature(this._parseArmature(f,a))}if(!this._data.binary){this._modifyArray()}if(t.DataParser.STAGE in e){s.stage=s.getArmature(r._getString(e,t.DataParser.STAGE,""))}else if(s.armatureNames.length>0){s.stage=s.getArmature(s.armatureNames[0])}this._data=null}if(t.DataParser.TEXTURE_ATLAS in e){this._rawTextureAtlases=e[t.DataParser.TEXTURE_ATLAS]}return s}else{console.assert(false,"Nonsupport data version: "+i+"\n"+"Please convert DragonBones data to support version.\n"+"Read more: https://github.com/DragonBones/Tools/")}return null};r.prototype.parseTextureAtlasData=function(e,a,i){if(i===void 0){i=1}console.assert(e!==undefined);if(e===null){if(this._rawTextureAtlases===null||this._rawTextureAtlases.length===0){return false}var n=this._rawTextureAtlases[this._rawTextureAtlasIndex++];this.parseTextureAtlasData(n,a,i);if(this._rawTextureAtlasIndex>=this._rawTextureAtlases.length){this._rawTextureAtlasIndex=0;this._rawTextureAtlases=null}return true}a.width=r._getNumber(e,t.DataParser.WIDTH,0);a.height=r._getNumber(e,t.DataParser.HEIGHT,0);a.scale=i===1?1/r._getNumber(e,t.DataParser.SCALE,1):i;a.name=r._getString(e,t.DataParser.NAME,"");a.imagePath=r._getString(e,t.DataParser.IMAGE_PATH,"");if(t.DataParser.SUB_TEXTURE in e){var s=e[t.DataParser.SUB_TEXTURE];for(var o=0,l=s.length;o<l;++o){var h=s[o];var f=a.createTexture();f.rotated=r._getBoolean(h,t.DataParser.ROTATED,false);f.name=r._getString(h,t.DataParser.NAME,"");f.region.x=r._getNumber(h,t.DataParser.X,0);f.region.y=r._getNumber(h,t.DataParser.Y,0);f.region.width=r._getNumber(h,t.DataParser.WIDTH,0);f.region.height=r._getNumber(h,t.DataParser.HEIGHT,0);var u=r._getNumber(h,t.DataParser.FRAME_WIDTH,-1);var _=r._getNumber(h,t.DataParser.FRAME_HEIGHT,-1);if(u>0&&_>0){f.frame=t.TextureData.createRectangle();f.frame.x=r._getNumber(h,t.DataParser.FRAME_X,0);f.frame.y=r._getNumber(h,t.DataParser.FRAME_Y,0);f.frame.width=u;f.frame.height=_}a.addTexture(f)}}return true};r.getInstance=function(){if(r._objectDataParserInstance===null){r._objectDataParserInstance=new r}return r._objectDataParserInstance};r._objectDataParserInstance=null;return r}(t.DataParser);t.ObjectDataParser=e;var a=function(){function t(){this.frameStart=0;this.actions=[]}return t}();t.ActionFrame=a})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){return e!==null&&e.apply(this,arguments)||this}a.prototype._inRange=function(t,e,a){return e<=t&&t<=a};a.prototype._decodeUTF8=function(t){var e=-1;var a=-1;var r=65533;var i=0;var n="";var s;var o=0;var l=0;var h=0;var f=0;while(t.length>i){var u=t[i++];if(u===e){if(l!==0){s=r}else{s=a}}else{if(l===0){if(this._inRange(u,0,127)){s=u}else{if(this._inRange(u,194,223)){l=1;f=128;o=u-192}else if(this._inRange(u,224,239)){l=2;f=2048;o=u-224}else if(this._inRange(u,240,244)){l=3;f=65536;o=u-240}else{}o=o*Math.pow(64,l);s=null}}else if(!this._inRange(u,128,191)){o=0;l=0;h=0;f=0;i--;s=u}else{h+=1;o=o+(u-128)*Math.pow(64,l-h);if(h!==l){s=null}else{var _=o;var c=f;o=0;l=0;h=0;f=0;if(this._inRange(_,c,1114111)&&!this._inRange(_,55296,57343)){s=_}else{s=u}}}}if(s!==null&&s!==a){if(s<=65535){if(s>0)n+=String.fromCharCode(s)}else{s-=65536;n+=String.fromCharCode(55296+(s>>10&1023));n+=String.fromCharCode(56320+(s&1023))}}}return n};a.prototype._getUTF16Key=function(t){for(var e=0,a=t.length;e<a;++e){if(t.charCodeAt(e)>255){return encodeURI(t)}}return t};a.prototype._parseBinaryTimeline=function(e,a,r){if(r===void 0){r=null}var i=r!==null?r:t.BaseObject.borrowObject(t.TimelineData);i.type=e;i.offset=a;this._timeline=i;var n=this._timelineArrayBuffer[i.offset+2];if(n===1){i.frameIndicesOffset=-1}else{var s=0;var o=this._animation.frameCount+1;var l=this._data.frameIndices;if(t.DragonBones.webAssembly){s=l.size();l.resize(s+o,0)}else{s=l.length;l.length+=o}i.frameIndicesOffset=s;for(var h=0,f=0,u=0,_=0;h<o;++h){if(u+_<=h&&f<n){u=this._frameArrayBuffer[this._animation.frameOffset+this._timelineArrayBuffer[i.offset+5+f]];if(f===n-1){_=this._animation.frameCount-u}else{_=this._frameArrayBuffer[this._animation.frameOffset+this._timelineArrayBuffer[i.offset+5+f+1]]-u}f++}if(t.DragonBones.webAssembly){l.set(s+h,f-1)}else{l[s+h]=f-1}}}this._timeline=null;return i};a.prototype._parseVertices=function(e,a){a.offset=e[t.DataParser.OFFSET];var r=this._intArrayBuffer[a.offset+3];if(r>=0){var i=t.BaseObject.borrowObject(t.WeightData);var n=this._intArrayBuffer[a.offset+0];var s=this._intArrayBuffer[r+0];i.offset=r;for(var o=0;o<s;++o){var l=this._intArrayBuffer[r+2+o];i.addBone(this._rawBones[l])}var h=r+2+s;var f=0;for(var o=0,u=n;o<u;++o){var _=this._intArrayBuffer[h++];f+=_;h+=_}i.count=f;a.weight=i}};a.prototype._parseMesh=function(t,e){this._parseVertices(t,e.vertices)};a.prototype._parsePath=function(t,e){this._parseVertices(t,e.vertices)};a.prototype._parseAnimation=function(e){var a=t.BaseObject.borrowObject(t.AnimationData);a.frameCount=Math.max(t.ObjectDataParser._getNumber(e,t.DataParser.DURATION,1),1);a.playTimes=t.ObjectDataParser._getNumber(e,t.DataParser.PLAY_TIMES,1);a.duration=a.frameCount/this._armature.frameRate;a.fadeInTime=t.ObjectDataParser._getNumber(e,t.DataParser.FADE_IN_TIME,0);a.scale=t.ObjectDataParser._getNumber(e,t.DataParser.SCALE,1);a.name=t.ObjectDataParser._getString(e,t.DataParser.NAME,t.DataParser.DEFAULT_NAME);if(a.name.length===0){a.name=t.DataParser.DEFAULT_NAME}var r=e[t.DataParser.OFFSET];a.frameIntOffset=r[0];a.frameFloatOffset=r[1];a.frameOffset=r[2];this._animation=a;if(t.DataParser.ACTION in e){a.actionTimeline=this._parseBinaryTimeline(0,e[t.DataParser.ACTION])}if(t.DataParser.Z_ORDER in e){a.zOrderTimeline=this._parseBinaryTimeline(1,e[t.DataParser.Z_ORDER])}if(t.DataParser.BONE in e){var i=e[t.DataParser.BONE];for(var n in i){var s=i[n];if(t.DragonBones.webAssembly){n=this._getUTF16Key(n)}var o=this._armature.getBone(n);if(o===null){continue}for(var l=0,h=s.length;l<h;l+=2){var f=s[l];var u=s[l+1];var _=this._parseBinaryTimeline(f,u);this._animation.addBoneTimeline(o,_)}}}if(t.DataParser.SURFACE in e){var i=e[t.DataParser.SURFACE];for(var n in i){var s=i[n];if(t.DragonBones.webAssembly){n=this._getUTF16Key(n)}var c=this._armature.getBone(n);if(c===null){continue}for(var l=0,h=s.length;l<h;l+=2){var f=s[l];var u=s[l+1];var _=this._parseBinaryTimeline(f,u);this._animation.addSurfaceTimeline(c,_)}}}if(t.DataParser.SLOT in e){var i=e[t.DataParser.SLOT];for(var n in i){var s=i[n];if(t.DragonBones.webAssembly){n=this._getUTF16Key(n)}var p=this._armature.getSlot(n);if(p===null){continue}for(var l=0,h=s.length;l<h;l+=2){var f=s[l];var u=s[l+1];var _=this._parseBinaryTimeline(f,u);this._animation.addSlotTimeline(p,_)}}}if(t.DataParser.CONSTRAINT in e){var i=e[t.DataParser.CONSTRAINT];for(var n in i){var s=i[n];if(t.DragonBones.webAssembly){n=this._getUTF16Key(n)}var m=this._armature.getConstraint(n);if(m===null){continue}for(var l=0,h=s.length;l<h;l+=2){var f=s[l];var u=s[l+1];var _=this._parseBinaryTimeline(f,u);this._animation.addConstraintTimeline(m,_)}}}if(t.DataParser.ANIMATION in e){var i=e[t.DataParser.ANIMATION];for(var n in i){var s=i[n];if(t.DragonBones.webAssembly){n=this._getUTF16Key(n)}for(var l=0,h=s.length;l<h;l+=2){var f=s[l];var u=s[l+1];var _=this._parseBinaryTimeline(f,u);this._animation.addAnimationTimeline(n,_)}}}this._animation=null;return a};a.prototype._parseArray=function(e){var a=e[t.DataParser.OFFSET];var r=a[1];var i=a[3];var n=a[5];var s=a[7];var o=a[9];var l=a[11];var h=new Int16Array(this._binary,this._binaryOffset+a[0],r/Int16Array.BYTES_PER_ELEMENT);var f=new Float32Array(this._binary,this._binaryOffset+a[2],i/Float32Array.BYTES_PER_ELEMENT);var u=new Int16Array(this._binary,this._binaryOffset+a[4],n/Int16Array.BYTES_PER_ELEMENT);var _=new Float32Array(this._binary,this._binaryOffset+a[6],s/Float32Array.BYTES_PER_ELEMENT);var c=new Int16Array(this._binary,this._binaryOffset+a[8],o/Int16Array.BYTES_PER_ELEMENT);var p=new Uint16Array(this._binary,this._binaryOffset+a[10],l/Uint16Array.BYTES_PER_ELEMENT);if(t.DragonBones.webAssembly){var m=r+i+n+s+o+l;var d=t.webAssemblyModule._malloc(m);var v=new Uint8Array(this._binary,this._binaryOffset,m/Uint8Array.BYTES_PER_ELEMENT);var y=new Uint8Array(t.webAssemblyModule.HEAP16.buffer,d,v.length);for(var g=0,b=v.length;g<b;++g){y[g]=v[g]}t.webAssemblyModule.setDataBinary(this._data,d,r,i,n,s,o,l);this._intArrayBuffer=h;this._floatArrayBuffer=f;this._frameIntArrayBuffer=u;this._frameFloatArrayBuffer=_;this._frameArrayBuffer=c;this._timelineArrayBuffer=p}else{this._data.binary=this._binary;this._data.intArray=this._intArrayBuffer=h;this._data.floatArray=this._floatArrayBuffer=f;this._data.frameIntArray=this._frameIntArrayBuffer=u;this._data.frameFloatArray=this._frameFloatArrayBuffer=_;this._data.frameArray=this._frameArrayBuffer=c;this._data.timelineArray=this._timelineArrayBuffer=p}};a.prototype.parseDragonBonesData=function(t,a){if(a===void 0){a=1}console.assert(t!==null&&t!==undefined&&t instanceof ArrayBuffer,"Data error.");var r=new Uint8Array(t,0,8);if(r[0]!=="D".charCodeAt(0)||r[1]!=="B".charCodeAt(0)||r[2]!=="D".charCodeAt(0)||r[3]!=="T".charCodeAt(0)){console.assert(false,"Nonsupport data.");return null}var i=new Uint32Array(t,8,1)[0];var n=new Uint8Array(t,8+4,i);var s=this._decodeUTF8(n);var o=JSON.parse(s);this._binaryOffset=8+4+i;this._binary=t;return e.prototype.parseDragonBonesData.call(this,o,a)};a.getInstance=function(){if(a._binaryDataParserInstance===null){a._binaryDataParserInstance=new a}return a._binaryDataParserInstance};a._binaryDataParserInstance=null;return a}(t.ObjectDataParser);t.BinaryDataParser=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(){function e(a){if(a===void 0){a=null}this.autoSearch=false;this._dragonBonesDataMap={};this._textureAtlasDataMap={};this._dragonBones=null;this._dataParser=null;if(e._objectParser===null){e._objectParser=new t.ObjectDataParser}if(e._binaryParser===null){e._binaryParser=new t.BinaryDataParser}this._dataParser=a!==null?a:e._objectParser}e.prototype._isSupportMesh=function(){return true};e.prototype._getTextureData=function(t,e){if(t in this._textureAtlasDataMap){for(var a=0,r=this._textureAtlasDataMap[t];a<r.length;a++){var i=r[a];var n=i.getTexture(e);if(n!==null){return n}}}if(this.autoSearch){for(var s in this._textureAtlasDataMap){for(var o=0,l=this._textureAtlasDataMap[s];o<l.length;o++){var i=l[o];if(i.autoSearch){var n=i.getTexture(e);if(n!==null){return n}}}}}return null};e.prototype._fillBuildArmaturePackage=function(t,e,a,r,i){var n=null;var s=null;if(e.length>0){if(e in this._dragonBonesDataMap){n=this._dragonBonesDataMap[e];s=n.getArmature(a)}}if(s===null&&(e.length===0||this.autoSearch)){for(var o in this._dragonBonesDataMap){n=this._dragonBonesDataMap[o];if(e.length===0||n.autoSearch){s=n.getArmature(a);if(s!==null){e=o;break}}}}if(s!==null){t.dataName=e;t.textureAtlasName=i;t.data=n;t.armature=s;t.skin=null;if(r.length>0){t.skin=s.getSkin(r);if(t.skin===null&&this.autoSearch){for(var o in this._dragonBonesDataMap){var l=this._dragonBonesDataMap[o];var h=l.getArmature(r);if(h!==null){t.skin=h.defaultSkin;break}}}}if(t.skin===null){t.skin=s.defaultSkin}return true}return false};e.prototype._buildBones=function(e,a){for(var r=0,i=e.armature.sortedBones;r<i.length;r++){var n=i[r];var s=t.BaseObject.borrowObject(n.type===0?t.Bone:t.Surface);s.init(n,a)}};e.prototype._buildSlots=function(e,a){var r=e.skin;var i=e.armature.defaultSkin;if(r===null||i===null){return}var n={};for(var s in i.displays){var o=i.getDisplays(s);n[s]=o}if(r!==i){for(var s in r.displays){var o=r.getDisplays(s);n[s]=o}}for(var l=0,h=e.armature.sortedSlots;l<h.length;l++){var f=h[l];var u=f.name in n?n[f.name]:null;var _=this._buildSlot(e,f,a);_.rawDisplayDatas=u;if(u!==null){var c=new Array;for(var p=0,m=t.DragonBones.webAssembly?u.size():u.length;p<m;++p){var d=t.DragonBones.webAssembly?u.get(p):u[p];if(d!==null){c.push(this._getSlotDisplay(e,d,null,_))}else{c.push(null)}}_._setDisplayList(c)}_._setDisplayIndex(f.displayIndex,true)}};e.prototype._buildConstraints=function(e,a){var r=e.armature.constraints;for(var i in r){var n=r[i];switch(n.type){case 0:var s=t.BaseObject.borrowObject(t.IKConstraint);s.init(n,a);a._addConstraint(s);break;case 1:var o=t.BaseObject.borrowObject(t.PathConstraint);o.init(n,a);a._addConstraint(o);break;default:var l=t.BaseObject.borrowObject(t.IKConstraint);l.init(n,a);a._addConstraint(l);break}}};e.prototype._buildChildArmature=function(t,e,a){e;return this.buildArmature(a.path,t!==null?t.dataName:"","",t!==null?t.textureAtlasName:"")};e.prototype._getSlotDisplay=function(e,a,r,i){var n=e!==null?e.dataName:a.parent.parent.parent.name;var s=null;switch(a.type){case 0:{var o=a;if(o.texture===null){o.texture=this._getTextureData(n,a.path)}else if(e!==null&&e.textureAtlasName.length>0){o.texture=this._getTextureData(e.textureAtlasName,a.path)}if(r!==null&&r.type===2&&this._isSupportMesh()){s=i.meshDisplay}else{s=i.rawDisplay}break}case 2:{var l=a;if(l.texture===null){l.texture=this._getTextureData(n,l.path)}else if(e!==null&&e.textureAtlasName.length>0){l.texture=this._getTextureData(e.textureAtlasName,l.path)}if(this._isSupportMesh()){s=i.meshDisplay}else{s=i.rawDisplay}break}case 1:{var h=a;var f=this._buildChildArmature(e,i,a);if(f!==null){f.inheritAnimation=h.inheritAnimation;if(!f.inheritAnimation){var u=h.actions.length>0?h.actions:f.armatureData.defaultActions;if(u.length>0){for(var _=0,c=u;_<c.length;_++){var p=c[_];var m=t.BaseObject.borrowObject(t.EventObject);t.EventObject.actionDataToInstance(p,m,i.armature);m.slot=i;i.armature._bufferAction(m,false)}}else{f.animation.play()}}h.armature=f.armatureData}s=f;break}case 3:break;default:break}return s};e.prototype.parseDragonBonesData=function(t,a,r){if(a===void 0){a=null}if(r===void 0){r=1}var i=t instanceof ArrayBuffer?e._binaryParser:this._dataParser;var n=i.parseDragonBonesData(t,r);while(true){var s=this._buildTextureAtlasData(null,null);if(i.parseTextureAtlasData(null,s,r)){this.addTextureAtlasData(s,a)}else{s.returnToPool();break}}if(n!==null){this.addDragonBonesData(n,a)}return n};e.prototype.parseTextureAtlasData=function(t,e,a,r){if(a===void 0){a=null}if(r===void 0){r=1}var i=this._buildTextureAtlasData(null,null);this._dataParser.parseTextureAtlasData(t,i,r);this._buildTextureAtlasData(i,e||null);this.addTextureAtlasData(i,a);return i};e.prototype.updateTextureAtlasData=function(t,e){var a=this.getTextureAtlasData(t);if(a!==null){for(var r=0,i=a.length;r<i;++r){if(r<e.length){this._buildTextureAtlasData(a[r],e[r])}}}};e.prototype.getDragonBonesData=function(t){return t in this._dragonBonesDataMap?this._dragonBonesDataMap[t]:null};e.prototype.addDragonBonesData=function(t,e){if(e===void 0){e=null}e=e!==null?e:t.name;if(e in this._dragonBonesDataMap){if(this._dragonBonesDataMap[e]===t){return}console.warn("Can not add same name data: "+e);return}this._dragonBonesDataMap[e]=t};e.prototype.removeDragonBonesData=function(t,e){if(e===void 0){e=true}if(t in this._dragonBonesDataMap){if(e){this._dragonBones.bufferObject(this._dragonBonesDataMap[t])}delete this._dragonBonesDataMap[t]}};e.prototype.getTextureAtlasData=function(t){return t in this._textureAtlasDataMap?this._textureAtlasDataMap[t]:null};e.prototype.addTextureAtlasData=function(t,e){if(e===void 0){e=null}e=e!==null?e:t.name;var a=e in this._textureAtlasDataMap?this._textureAtlasDataMap[e]:this._textureAtlasDataMap[e]=[];if(a.indexOf(t)<0){a.push(t)}};e.prototype.removeTextureAtlasData=function(t,e){if(e===void 0){e=true}if(t in this._textureAtlasDataMap){var a=this._textureAtlasDataMap[t];if(e){for(var r=0,i=a;r<i.length;r++){var n=i[r];this._dragonBones.bufferObject(n)}}delete this._textureAtlasDataMap[t]}};e.prototype.getArmatureData=function(t,e){if(e===void 0){e=""}var r=new a;if(!this._fillBuildArmaturePackage(r,e,t,"","")){return null}return r.armature};e.prototype.clear=function(t){if(t===void 0){t=true}for(var e in this._dragonBonesDataMap){if(t){this._dragonBones.bufferObject(this._dragonBonesDataMap[e])}delete this._dragonBonesDataMap[e]}for(var e in this._textureAtlasDataMap){if(t){var a=this._textureAtlasDataMap[e];for(var r=0,i=a;r<i.length;r++){var n=i[r];this._dragonBones.bufferObject(n)}}delete this._textureAtlasDataMap[e]}};e.prototype.buildArmature=function(t,e,r,i){if(e===void 0){e=""}if(r===void 0){r=""}if(i===void 0){i=""}var n=new a;if(!this._fillBuildArmaturePackage(n,e||"",t,r||"",i||"")){console.warn("No armature data: "+t+", "+(e!==null?e:""));return null}var s=this._buildArmature(n);this._buildBones(n,s);this._buildSlots(n,s);this._buildConstraints(n,s);s.invalidUpdate(null,true);s.advanceTime(0);return s};e.prototype.replaceDisplay=function(e,a,r){if(r===void 0){r=-1}if(r<0){r=e.displayIndex}if(r<0){r=0}e.replaceDisplayData(a,r);var i=e.displayList;if(i.length<=r){i.length=r+1;for(var n=0,s=i.length;n<s;++n){if(!i[n]){i[n]=null}}}if(a!==null){var o=e.rawDisplayDatas;var l=null;if(o){if(t.DragonBones.webAssembly){if(r<o.size()){l=o.get(r)}}else{if(r<o.length){l=o[r]}}}i[r]=this._getSlotDisplay(null,a,l,e)}else{i[r]=null}e.displayList=i};e.prototype.replaceSlotDisplay=function(t,e,a,r,i,n){if(n===void 0){n=-1}var s=this.getArmatureData(e,t||"");if(!s||!s.defaultSkin){return false}var o=s.defaultSkin.getDisplay(a,r);if(!o){return false}this.replaceDisplay(i,o,n);return true};e.prototype.replaceSlotDisplayList=function(e,a,r,i){var n=this.getArmatureData(a,e||"");if(!n||!n.defaultSkin){return false}var s=n.defaultSkin.getDisplays(r);if(!s){return false}var o=0;for(var l=0,h=t.DragonBones.webAssembly?s.size():s.length;l<h;++l){var f=t.DragonBones.webAssembly?s.get(l):s[l];this.replaceDisplay(i,f,o++)}return true};e.prototype.replaceSkin=function(e,a,r,i){if(r===void 0){r=false}if(i===void 0){i=null}var n=false;var s=a.parent.defaultSkin;for(var o=0,l=e.getSlots();o<l.length;o++){var h=l[o];if(i!==null&&i.indexOf(h.name)>=0){continue}var f=a.getDisplays(h.name);if(!f){if(s!==null&&a!==s){f=s.getDisplays(h.name)}if(!f){if(r){h.rawDisplayDatas=null;h.displayList=[]}continue}}var u=t.DragonBones.webAssembly?f.size():f.length;var _=h.displayList;_.length=u;for(var c=0,p=u;c<p;++c){var m=t.DragonBones.webAssembly?f.get(c):f[c];if(m!==null){_[c]=this._getSlotDisplay(null,m,null,h)}else{_[c]=null}}n=true;h.rawDisplayDatas=f;h.displayList=_}return n};e.prototype.replaceAnimation=function(e,a,r){if(r===void 0){r=true}var i=a.defaultSkin;if(i===null){return false}if(r){e.animation.animations=a.animations}else{var n=e.animation.animations;var s={};for(var o in n){s[o]=n[o]}for(var o in a.animations){s[o]=a.animations[o]}e.animation.animations=s}for(var l=0,h=e.getSlots();l<h.length;l++){var f=h[l];var u=0;for(var _=0,c=f.displayList;_<c.length;_++){var p=c[_];if(p instanceof t.Armature){var m=i.getDisplays(f.name);if(m!==null&&u<(t.DragonBones.webAssembly?m.size():m.length)){var d=t.DragonBones.webAssembly?m.get(u):m[u];if(d!==null&&d.type===1){var v=this.getArmatureData(d.path,d.parent.parent.parent.name);if(v){this.replaceAnimation(p,v,r)}}}}u++}}return true};e.prototype.getAllDragonBonesData=function(){return this._dragonBonesDataMap};e.prototype.getAllTextureAtlasData=function(){return this._textureAtlasDataMap};Object.defineProperty(e.prototype,"clock",{get:function(){return this._dragonBones.clock},enumerable:true,configurable:true});Object.defineProperty(e.prototype,"dragonBones",{get:function(){return this._dragonBones},enumerable:true,configurable:true});e.prototype.changeSkin=function(t,e,a){if(a===void 0){a=null}return this.replaceSkin(t,e,false,a)};e.prototype.copyAnimationsToArmature=function(t,e,a,r,i){if(a===void 0){a=""}if(r===void 0){r=""}if(i===void 0){i=true}a;var n=this.getArmatureData(e,r);if(!n){return false}return this.replaceAnimation(t,n,i)};e._objectParser=null;e._binaryParser=null;return e}();t.BaseFactory=e;var a=function(){function t(){this.dataName="";this.textureAtlasName="";this.skin=null}return t}();t.BuildArmaturePackage=a})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(r,e);function r(){var t=e!==null&&e.apply(this,arguments)||this;t._renderTexture=null;return t}r.toString=function(){return"[class dragonBones.EgretTextureAtlasData]"};r.prototype._onClear=function(){e.prototype._onClear.call(this);if(this.disposeEnabled&&this._renderTexture!==null){this._renderTexture.dispose()}this.disposeEnabled=false;this._renderTexture=null};r.prototype.createTexture=function(){return t.BaseObject.borrowObject(a)};Object.defineProperty(r.prototype,"renderTexture",{get:function(){return this._renderTexture},set:function(t){if(this._renderTexture===t){return}this._renderTexture=t;if(this._renderTexture!==null){var e=this._renderTexture.bitmapData;var a=this.width>0?this.width:e.width;var r=this.height>0?this.height:e.height;for(var i in this.textures){var n=egret.$TextureScaleFactor;var s=this.textures[i];var o=s.region.width;var l=s.region.height;if(s.renderTexture===null){s.renderTexture=new egret.Texture}s.renderTexture.bitmapData=e;if(s.rotated){s.renderTexture.$initData(s.region.x*n,s.region.y*n,l*n,o*n,0,0,l*n,o*n,a,r,s.rotated)}else{s.renderTexture.$initData(s.region.x*n,s.region.y*n,o*n,l*n,0,0,o*n,l*n,a,r)}}}else{for(var i in this.textures){var s=this.textures[i];s.renderTexture=null}}},enumerable:true,configurable:true});r.prototype.dispose=function(){console.warn("已废弃。");this.returnToPool()};Object.defineProperty(r.prototype,"texture",{get:function(){console.warn("已废弃。");return this.renderTexture},enumerable:true,configurable:true});return r}(t.TextureAtlasData);t.EgretTextureAtlasData=e;var a=function(t){__extends(e,t);function e(){var e=t!==null&&t.apply(this,arguments)||this;e.renderTexture=null;return e}e.toString=function(){return"[class dragonBones.EgretTextureData]"};e.prototype._onClear=function(){t.prototype._onClear.call(this);if(this.renderTexture!==null){}this.renderTexture=null};return e}(t.TextureData);t.EgretTextureData=a})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){return e!==null&&e.apply(this,arguments)||this}Object.defineProperty(a.prototype,"eventObject",{get:function(){return this.data},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"animationName",{get:function(){var t=this.eventObject.animationState;return t!==null?t.name:""},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"armature",{get:function(){return this.eventObject.armature},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"bone",{get:function(){return this.eventObject.bone},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"slot",{get:function(){return this.eventObject.slot},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"animationState",{get:function(){return this.eventObject.animationState},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"frameLabel",{get:function(){return this.eventObject.name},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"sound",{get:function(){return this.eventObject.name},enumerable:true,configurable:true});Object.defineProperty(a.prototype,"movementID",{get:function(){return this.animationName},enumerable:true,configurable:true});a.START=t.EventObject.START;a.LOOP_COMPLETE=t.EventObject.LOOP_COMPLETE;a.COMPLETE=t.EventObject.COMPLETE;a.FADE_IN=t.EventObject.FADE_IN;a.FADE_IN_COMPLETE=t.EventObject.FADE_IN_COMPLETE;a.FADE_OUT=t.EventObject.FADE_OUT;a.FADE_OUT_COMPLETE=t.EventObject.FADE_OUT_COMPLETE;a.FRAME_EVENT=t.EventObject.FRAME_EVENT;a.SOUND_EVENT=t.EventObject.SOUND_EVENT;a.ANIMATION_FRAME_EVENT=t.EventObject.FRAME_EVENT;a.BONE_FRAME_EVENT=t.EventObject.FRAME_EVENT;a.MOVEMENT_FRAME_EVENT=t.EventObject.FRAME_EVENT;a.SOUND=t.EventObject.SOUND_EVENT;return a}(egret.Event);t.EgretEvent=e;var a=function(a){__extends(r,a);function r(){var t=a!==null&&a.apply(this,arguments)||this;t.debugDraw=false;t._batchEnabled=!(global["nativeRender"]||global["bricks"]);t._childDirty=true;t._debugDraw=false;t._armature=null;t._bounds=null;t._debugDrawer=null;return t}r._cleanBeforeRender=function(){};r.prototype.dbInit=function(t){this._armature=t;if(this._batchEnabled){this.$renderNode=new egret.sys.GroupNode;this.$renderNode.cleanBeforeRender=r._cleanBeforeRender}};r.prototype.dbClear=function(){this._armature=null;this._bounds=null;this._debugDrawer=null};r.prototype.dbUpdate=function(){var e=t.DragonBones.debugDraw||this.debugDraw;if(e||this._debugDraw){this._debugDraw=e;if(this._debugDraw){if(this._debugDrawer===null){this._debugDrawer=new egret.Sprite}if(this._debugDrawer.parent!==this){this.addChild(this._debugDrawer)}var a=2;var r=this._debugDrawer.graphics;r.clear();for(var i=0,n=this._armature.getBones();i<n.length;i++){var s=n[i];if(s.boneData.type===0){var o=Math.max(s.boneData.length,a);var l=s.globalTransformMatrix.tx;var h=s.globalTransformMatrix.ty;var f=l-s.globalTransformMatrix.a*a;var u=h-s.globalTransformMatrix.b*a;var _=l+s.globalTransformMatrix.a*o;var c=h+s.globalTransformMatrix.b*o;var p=l+u-h;var m=h+f-l;var d=l-u+h;var v=h-f+l;r.lineStyle(2,65535,.7);r.moveTo(f,u);r.lineTo(_,c);r.moveTo(p,m);r.lineTo(d,v)}else{var y=s;var g=y._boneData;var b=g.segmentX;var D=g.segmentY;var T=y._vertices;r.lineStyle(2,16776960,.7);for(var A=0;A<D;++A){for(var x=0;x<b;++x){var P=(x+A*(b+1))*2;var O=T[P];var S=T[P+1];r.moveTo(O,S);r.lineTo(T[P+2],T[P+3]);r.moveTo(O,S);r.lineTo(T[P+(b+1)*2],T[P+(b+1)*2+1]);if(x===b-1){r.moveTo(T[P+2],T[P+3]);r.lineTo(T[P+(b+2)*2],T[P+(b+2)*2+1])}if(A===D-1){r.moveTo(T[P+(b+1)*2],T[P+(b+1)*2+1]);r.lineTo(T[P+(b+2)*2],T[P+(b+2)*2+1])}}}}}for(var E=0,M=this._armature.getSlots();E<M.length;E++){var B=M[E];var C=B.boundingBoxData;if(C!==null){var w=this._debugDrawer.getChildByName(B.name);if(w===null){w=new egret.Shape;w.name=B.name;this._debugDrawer.addChild(w)}w.graphics.clear();w.graphics.lineStyle(2,16711935,.7);switch(C.type){case 0:w.graphics.drawRect(-C.width*.5,-C.height*.5,C.width,C.height);break;case 1:w.graphics.drawEllipse(-C.width*.5,-C.height*.5,C.width,C.height);break;case 2:var T=C.vertices;for(var I=0;I<T.length;I+=2){var O=T[I];var S=T[I+1];if(I===0){w.graphics.moveTo(O,S)}else{w.graphics.lineTo(O,S)}}w.graphics.lineTo(T[0],T[1]);break;default:break}B.updateTransformAndMatrix();B.updateGlobalTransform();w.$setMatrix(B.globalTransformMatrix,false)}else{var w=this._debugDrawer.getChildByName(B.name);if(w!==null){this._debugDrawer.removeChild(w)}}}}else if(this._debugDrawer!==null&&this._debugDrawer.parent===this){this.removeChild(this._debugDrawer)}}if(!t.isV5&&this._batchEnabled&&this._childDirty){this.$invalidateContentBounds()}};r.prototype.dispose=function(t){if(t===void 0){t=true}t;if(this._armature!==null){this._armature.dispose();this._armature=null}};r.prototype.dispatchDBEvent=function(t,r){var i=egret.Event.create(e,t);i.data=r;a.prototype.dispatchEvent.call(this,i);egret.Event.release(i)};r.prototype.hasDBEventListener=function(t){return this.hasEventListener(t)};r.prototype.addDBEventListener=function(t,e,a){this.addEventListener(t,e,a)};r.prototype.removeDBEventListener=function(t,e,a){this.removeEventListener(t,e,a)};r.prototype.disableBatch=function(){if(!this._batchEnabled||!this._armature){return}for(var t=0,e=this._armature.getSlots();t<e.length;t++){var a=e[t];var r=a._deformVertices&&a._deformVertices.verticesData?a.meshDisplay:a.rawDisplay;if(!a.display&&r===a.meshDisplay){r=a.rawDisplay}var i=r.$renderNode;if(i.matrix){r.$setMatrix(a.globalTransformMatrix,false)}this.addChild(r)}this._batchEnabled=false;this.$renderNode.cleanBeforeRender=null;this.$renderNode=null;this.armature.invalidUpdate(null,true)};Object.defineProperty(r.prototype,"armature",{get:function(){return this._armature},enumerable:true,configurable:true});Object.defineProperty(r.prototype,"animation",{get:function(){return this._armature.animation},enumerable:true,configurable:true});r.prototype.$measureContentBounds=function(e){if(this._batchEnabled&&this._armature){if(this._childDirty){this._childDirty=false;var r=true;var i=new egret.Rectangle;for(var n=0,s=this._armature.getSlots();n<s.length;n++){var o=s[n];var l=o.display;if(!l||!l.$renderNode||!l.$renderNode.image){continue}var h=l.$renderNode.matrix;if(l===o.meshDisplay){var f=l.$renderNode.vertices;if(f&&f.length>0){i.setTo(999999,999999,-999999,-999999);for(var u=0,_=f.length;u<_;u+=2){var c=f[u];var p=f[u+1];if(i.x>c)i.x=c;if(i.width<c)i.width=c;if(i.y>p)i.y=p;if(i.height<p)i.height=p}i.width-=i.x;i.height-=i.y}else{continue}}else{var m=o.displayData;if(m&&m instanceof t.ImageDisplayData&&m.texture){var d=m.texture.parent.scale;i.x=0;i.y=0;i.width=m.texture.region.width*d;i.height=m.texture.region.height*d}else{continue}}h.$transformBounds(i);var v=i.x;var y=i.y;var g=i.x+i.width;var b=i.y+i.height;if(r){r=false;e.x=v;e.y=y;e.width=g;e.height=b}else{if(v<e.x){e.x=v}if(y<e.y){e.y=y}if(g>e.width){e.width=g}if(b>e.height){e.height=b}}}e.width-=e.x;e.height-=e.y;if(t.isV5){if(this._bounds===null){this._bounds=new egret.Rectangle}this._bounds.copyFrom(e)}}else if(t.isV5){if(this._bounds===null){this._bounds=new egret.Rectangle}e.copyFrom(this._bounds)}return e}return a.prototype.$measureContentBounds.call(this,e)};r.prototype.hasEvent=function(t){return this.hasDBEventListener(t)};r.prototype.addEvent=function(t,e,a){this.addDBEventListener(t,e,a)};r.prototype.removeEvent=function(t,e,a){this.removeDBEventListener(t,e,a)};r.prototype.advanceTimeBySelf=function(e){if(e){this._armature.clock=t.EgretFactory.factory.clock}else{this._armature.clock=null}};return r}(egret.DisplayObjectContainer);t.EgretArmatureDisplay=a;var r=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e}(e);t.Event=r;var i=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e}(e);t.ArmatureEvent=i;var n=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e}(e);t.AnimationEvent=n;var s=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e}(e);t.FrameEvent=s;var o=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e}(e);t.SoundEvent=o;var l=function(e){__extends(a,e);function a(a,r,i){if(i===void 0){i=1}var n=e.call(this)||this;console.warn("已废弃");n._onClear();t.ObjectDataParser.getInstance().parseTextureAtlasData(r,n,i);n.renderTexture=a;return n}a.toString=function(){return"[class dragonBones.EgretTextureAtlas]"};return a}(t.EgretTextureAtlasData);t.EgretTextureAtlas=l;var h=function(t){__extends(e,t);function e(){return t!==null&&t.apply(this,arguments)||this}return e}(l);t.EgretSheetAtlas=h;var f=function(){function e(){}e.getInstance=function(){console.warn("已废弃");return t.EgretFactory.factory.soundEventManager};return e}();t.SoundEventManager=f;var u=function(){function t(){console.warn("已废弃")}return t}();t.AnimationCacheManager=u})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=function(e){__extends(a,e);function a(){var t=e!==null&&e.apply(this,arguments)||this;t.transformUpdateEnabled=false;t._armatureDisplay=null;t._renderDisplay=null;t._colorFilter=null;return t}a.toString=function(){return"[class dragonBones.EgretSlot]"};a.prototype.init=function(a,r,i,n){e.prototype.init.call(this,a,r,i,n);if(t.isV5){this._updateTransform=this._updateTransformV5}else{this._updateTransform=this._updateTransformV4}};a.prototype._onClear=function(){e.prototype._onClear.call(this);this._armatureDisplay=null;this._renderDisplay=null;this._colorFilter=null};a.prototype._initDisplay=function(t,e){t;e};a.prototype._disposeDisplay=function(t,e){t;e};a.prototype._onUpdateDisplay=function(){this._armatureDisplay=this._armature.display;this._renderDisplay=this._display!==null?this._display:this._rawDisplay;if(t.isV5&&this._armatureDisplay._batchEnabled){if(this._renderDisplay===this._rawDisplay&&!(this._renderDisplay.$renderNode instanceof egret.sys.BitmapNode)){this._renderDisplay.$renderNode=new egret.sys.BitmapNode}}if(this._armatureDisplay._batchEnabled){if(this._renderDisplay!==this._rawDisplay&&this._renderDisplay!==this._meshDisplay){this._armatureDisplay.disableBatch()}else{var e=this._renderDisplay.$renderNode;if(!e.matrix){e.matrix=new egret.Matrix}}}};a.prototype._addDisplay=function(){if(this._armatureDisplay._batchEnabled){this._armatureDisplay.$renderNode.addNode(this._renderDisplay.$renderNode)}else{this._armatureDisplay.addChild(this._renderDisplay)}};a.prototype._replaceDisplay=function(t){var e=t;if(this._armatureDisplay._batchEnabled){var a=this._armatureDisplay.$renderNode.drawData;a[a.indexOf(e.$renderNode)]=this._renderDisplay.$renderNode}else{this._armatureDisplay.addChild(this._renderDisplay);this._armatureDisplay.swapChildren(this._renderDisplay,e);this._armatureDisplay.removeChild(e)}};a.prototype._removeDisplay=function(){if(this._armatureDisplay._batchEnabled){var t=this._armatureDisplay.$renderNode.drawData;t.splice(t.indexOf(this._renderDisplay.$renderNode),1)}else{this._renderDisplay.parent.removeChild(this._renderDisplay)}};a.prototype._updateZOrder=function(){if(this._armatureDisplay._batchEnabled){var t=this._armatureDisplay.$renderNode.drawData;t[this._zOrder]=this._renderDisplay.$renderNode}else{var e=this._armatureDisplay.getChildIndex(this._renderDisplay);if(e===this._zOrder){return}this._armatureDisplay.addChildAt(this._renderDisplay,this._zOrder)}};a.prototype._updateVisible=function(){var t=this._parent.visible&&this._visible;if(this._armatureDisplay._batchEnabled){var e=this._renderDisplay.$renderNode;e.alpha=t?1:0}else{this._renderDisplay.visible=t}};a.prototype._updateBlendMode=function(){switch(this._blendMode){case 0:this._renderDisplay.blendMode=egret.BlendMode.NORMAL;break;case 1:this._renderDisplay.blendMode=egret.BlendMode.ADD;break;case 5:this._renderDisplay.blendMode=egret.BlendMode.ERASE;break;default:break}if(this._armatureDisplay._batchEnabled){var t=this._renderDisplay.$renderNode;t.blendMode=egret.sys.blendModeToNumber(this._renderDisplay.blendMode)}};a.prototype._updateColor=function(){if(this._colorTransform.redMultiplier!==1||this._colorTransform.greenMultiplier!==1||this._colorTransform.blueMultiplier!==1||this._colorTransform.redOffset!==0||this._colorTransform.greenOffset!==0||this._colorTransform.blueOffset!==0||this._colorTransform.alphaOffset!==0){if(this._colorFilter===null){this._colorFilter=new egret.ColorMatrixFilter}var t=this._colorFilter.matrix;t[0]=this._colorTransform.redMultiplier;t[6]=this._colorTransform.greenMultiplier;t[12]=this._colorTransform.blueMultiplier;t[18]=this._colorTransform.alphaMultiplier;t[4]=this._colorTransform.redOffset;t[9]=this._colorTransform.greenOffset;t[14]=this._colorTransform.blueOffset;t[19]=this._colorTransform.alphaOffset;this._colorFilter.matrix=t;if(this._armatureDisplay._batchEnabled){var e=this._renderDisplay.$renderNode;e.filter=this._colorFilter;e.alpha=1}var a=this._renderDisplay.filters;if(!a){a=[]}if(a.indexOf(this._colorFilter)<0){a.push(this._colorFilter)}this._renderDisplay.filters=a;this._renderDisplay.alpha=1}else{if(this._armatureDisplay._batchEnabled){var e=this._renderDisplay.$renderNode;e.filter=null;e.alpha=this._colorTransform.alphaMultiplier}this._renderDisplay.filters=null;this._renderDisplay.alpha=this._colorTransform.alphaMultiplier}};a.prototype._updateFrame=function(){var e=this._deformVertices!==null&&this._display===this._meshDisplay?this._deformVertices.verticesData:null;var a=this._textureData;if(this._displayIndex>=0&&this._display!==null&&a!==null){if(this._armature.replacedTexture!==null&&this._rawDisplayDatas!==null&&this._rawDisplayDatas.indexOf(this._displayData)>=0){var r=a.parent;if(this._armature._replaceTextureAtlasData===null){r=t.BaseObject.borrowObject(t.EgretTextureAtlasData);r.copyFrom(a.parent);r.renderTexture=this._armature.replacedTexture;this._armature._replaceTextureAtlasData=r}else{r=this._armature._replaceTextureAtlasData}a=r.getTexture(a.name)}if(a.renderTexture!==null){if(e!==null){var i=e.data;var n=i.intArray;var s=i.floatArray;var o=n[e.offset+0];var l=n[e.offset+1];var h=n[e.offset+2];if(h<0){h+=65536}var f=h+o*2;var u=this._armature._armatureData.scale;var _=this._renderDisplay;var c=_.$renderNode;c.uvs.length=o*2;c.vertices.length=o*2;c.indices.length=l*3;for(var p=0,m=o*2;p<m;++p){c.vertices[p]=s[h+p]*u;c.uvs[p]=s[f+p]}for(var p=0;p<l*3;++p){c.indices[p]=n[e.offset+4+p]}if(this._armatureDisplay._batchEnabled){var d=a.renderTexture;var v=this._renderDisplay.$renderNode;egret.sys.RenderNode.prototype.cleanBeforeRender.call(v);v.image=d.bitmapData;if(t.isV5){v.drawMesh(d.$bitmapX,d.$bitmapY,d.$bitmapWidth,d.$bitmapHeight,d.$offsetX,d.$offsetY,d.textureWidth,d.textureHeight);v.imageWidth=d.$sourceWidth;v.imageHeight=d.$sourceHeight}else{var y=d;v.drawMesh(y._bitmapX,y._bitmapY,y._bitmapWidth,y._bitmapHeight,y._offsetX,y._offsetY,y.textureWidth,y.textureHeight);v.imageWidth=y._sourceWidth;v.imageHeight=y._sourceHeight}this._blendModeDirty=true;this._colorDirty=true}_.texture=a.renderTexture;_.anchorOffsetX=this._pivotX;_.anchorOffsetY=this._pivotY;_.$updateVertices();if(!t.isV5){_.$invalidateTransform()}var g=e.weight!==null;var b=this._parent._boneData.type!==0;if(g||b){this._identityTransform()}}else{var u=a.parent.scale*this._armature._armatureData.scale;var D=(a.rotated?a.region.height:a.region.width)*u;var T=(a.rotated?a.region.width:a.region.height)*u;var A=this._renderDisplay;var d=a.renderTexture;A.texture=d;if(this._armatureDisplay._batchEnabled){var v=this._renderDisplay.$renderNode;egret.sys.RenderNode.prototype.cleanBeforeRender.call(v);v.image=d.bitmapData;if(t.isV5){v.drawImage(d.$bitmapX,d.$bitmapY,d.$bitmapWidth,d.$bitmapHeight,d.$offsetX,d.$offsetY,D,T);v.imageWidth=d.$sourceWidth;v.imageHeight=d.$sourceHeight}else{var y=d;v.drawImage(y._bitmapX,y._bitmapY,y._bitmapWidth,y._bitmapHeight,y._offsetX,y._offsetY,D,T);v.imageWidth=y._sourceWidth;v.imageHeight=y._sourceHeight}this._blendModeDirty=true;this._colorDirty=true}else{A.width=D;A.height=T}A.anchorOffsetX=this._pivotX;A.anchorOffsetY=this._pivotY}this._visibleDirty=true;return}}if(this._armatureDisplay._batchEnabled){this._renderDisplay.$renderNode.image=null}var x=this._renderDisplay;x.texture=null;x.x=0;x.y=0;x.visible=false};a.prototype._updateMesh=function(){var e=this._armature._armatureData.scale;var a=this._deformVertices.vertices;var r=this._deformVertices.bones;var i=this._deformVertices.verticesData;var n=i.weight;var s=a.length>0&&i.inheritDeform;var o=this._renderDisplay;var l=o.$renderNode;if(n!==null){var h=i.data;var f=h.intArray;var u=h.floatArray;var _=f[i.offset+0];var c=f[n.offset+1];if(c<0){c+=65536}for(var p=0,m=0,d=n.offset+2+r.length,v=c,y=0;p<_;++p){var g=f[d++];var b=0,D=0;for(var T=0;T<g;++T){var A=f[d++];var x=r[A];if(x!==null){var P=x.globalTransformMatrix;var O=u[v++];var S=u[v++]*e;var E=u[v++]*e;if(s){S+=a[y++];E+=a[y++]}b+=(P.a*S+P.c*E+P.tx)*O;D+=(P.b*S+P.d*E+P.ty)*O}}l.vertices[m++]=b;l.vertices[m++]=D}o.$updateVertices();if(!t.isV5){o.$invalidateTransform()}}else if(s){var M=this._parent._boneData.type!==0;var h=i.data;var f=h.intArray;var u=h.floatArray;var _=f[i.offset+0];var B=f[i.offset+2];if(B<0){B+=65536}for(var p=0,C=_*2;p<C;p+=2){var w=u[B+p]*e+a[p];var I=u[B+p+1]*e+a[p+1];if(M){var P=this._parent._getGlobalTransformMatrix(w,I);l.vertices[p]=P.a*w+P.c*I+P.tx;l.vertices[p+1]=P.b*w+P.d*I+P.ty}else{l.vertices[p]=w;l.vertices[p+1]=I}}o.$updateVertices();if(!t.isV5){o.$invalidateTransform()}}if(this._armatureDisplay._batchEnabled){this._armatureDisplay._childDirty=true}};a.prototype._updateGlueMesh=function(){};a.prototype._updateTransform=function(){throw new Error};a.prototype._identityTransform=function(){if(this._armatureDisplay._batchEnabled){this._armatureDisplay._childDirty=true;var t=this._renderDisplay.$renderNode.matrix;t.a=1;t.b=0;t.c=0;t.d=1;t.tx=0;t.ty=0}else{egret.$TempMatrix.identity();this._renderDisplay.$setMatrix(egret.$TempMatrix,this.transformUpdateEnabled)}};a.prototype._updateTransformV4=function(){var t=this.globalTransformMatrix;if(this._armatureDisplay._batchEnabled){this._armatureDisplay._childDirty=true;var e=this._renderDisplay.$renderNode.matrix;e.a=t.a;e.b=t.b;e.c=t.c;e.d=t.d;e.tx=this.globalTransformMatrix.tx-(this.globalTransformMatrix.a*this._pivotX+this.globalTransformMatrix.c*this._pivotY);e.ty=this.globalTransformMatrix.ty-(this.globalTransformMatrix.b*this._pivotX+this.globalTransformMatrix.d*this._pivotY)}else if(this.transformUpdateEnabled){this._renderDisplay.$setMatrix(t,true)}else{var a=this._renderDisplay.$DisplayObject;var e=a[6];e.a=this.globalTransformMatrix.a;e.b=this.globalTransformMatrix.b;e.c=this.globalTransformMatrix.c;e.d=this.globalTransformMatrix.d;e.tx=this.globalTransformMatrix.tx;e.ty=this.globalTransformMatrix.ty;this._renderDisplay.$removeFlags(8);this._renderDisplay.$invalidatePosition()}};a.prototype._updateTransformV5=function(){var t=this.globalTransformMatrix;if(this._armatureDisplay._batchEnabled){this._armatureDisplay._childDirty=true;var e=this._renderDisplay.$renderNode.matrix;e.a=t.a;e.b=t.b;e.c=t.c;e.d=t.d;e.tx=this.globalTransformMatrix.tx-(this.globalTransformMatrix.a*this._pivotX+this.globalTransformMatrix.c*this._pivotY);e.ty=this.globalTransformMatrix.ty-(this.globalTransformMatrix.b*this._pivotX+this.globalTransformMatrix.d*this._pivotY)}else{this._renderDisplay.$setMatrix(t,this.transformUpdateEnabled)}};return a}(t.Slot);t.EgretSlot=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){t.isV5=Number(egret.Capabilities.engineVersion.substr(0,3))>=5.1;var e=function(e){__extends(a,e);function a(r){if(r===void 0){r=null}var i=e.call(this,r)||this;if(a._dragonBonesInstance===null){var n=new t.EgretArmatureDisplay;a._dragonBonesInstance=new t.DragonBones(n);a._time=egret.getTimer()*.001;egret.startTick(a._clockHandler,a)}i._dragonBones=a._dragonBonesInstance;return i}a._clockHandler=function(t){t*=.001;var e=t-this._time;a._dragonBonesInstance.advanceTime(e);this._time=t;return false};Object.defineProperty(a,"factory",{get:function(){if(a._factory===null){a._factory=new a}return a._factory},enumerable:true,configurable:true});a.prototype._isSupportMesh=function(){if(egret.Capabilities.renderMode==="webgl"||egret.Capabilities.runtimeType===egret.RuntimeType.NATIVE){return true}console.warn("Canvas can not support mesh, please change renderMode to webgl.");return false};a.prototype._buildTextureAtlasData=function(e,a){if(e!==null){if(a instanceof egret.Texture){e.renderTexture=a}else{var r=new egret.Texture;r.bitmapData=new egret.BitmapData(a);e.disposeEnabled=true;e.renderTexture=r}}else{e=t.BaseObject.borrowObject(t.EgretTextureAtlasData)}return e};a.prototype._buildArmature=function(e){var a=t.BaseObject.borrowObject(t.Armature);var r=new t.EgretArmatureDisplay;a.init(e.armature,r,r,this._dragonBones);return a};a.prototype._buildSlot=function(e,a,r){e;var i=t.BaseObject.borrowObject(t.EgretSlot);i.init(a,r,new egret.Bitmap,new egret.Mesh);return i};a.prototype.buildArmatureDisplay=function(t,e,a,r){if(e===void 0){e=""}if(a===void 0){a=""}if(r===void 0){r=""}var i=this.buildArmature(t,e||"",a||"",r||"");if(i!==null){this._dragonBones.clock.add(i);return i.display}return null};a.prototype.getTextureDisplay=function(t,e){if(e===void 0){e=null}var a=this._getTextureData(e!==null?e:"",t);if(a!==null&&a.renderTexture!==null){var r=a.renderTexture;var i=new egret.Bitmap(r);i.width=r.textureWidth*a.parent.scale;i.height=r.textureHeight*a.parent.scale;return i}return null};Object.defineProperty(a.prototype,"soundEventManager",{get:function(){return this._dragonBones.eventManager},enumerable:true,configurable:true});Object.defineProperty(a,"clock",{get:function(){return a.factory.clock},enumerable:true,configurable:true});a.prototype.addSkeletonData=function(t,e){if(e===void 0){e=null}console.warn("已废弃");this.addDragonBonesData(t,e)};a.prototype.getSkeletonData=function(t){console.warn("已废弃");return this.getDragonBonesData(t)};a.prototype.removeSkeletonData=function(t){console.warn("已废弃");this.removeDragonBonesData(t)};a.prototype.addTextureAtlas=function(t,e){if(e===void 0){e=null}console.warn("已废弃");this.addTextureAtlasData(t,e)};a.prototype.getTextureAtlas=function(t){console.warn("已废弃");return this.getTextureAtlasData(t)};a.prototype.removeTextureAtlas=function(t){console.warn("已废弃");this.removeTextureAtlasData(t)};a.prototype.buildFastArmature=function(t,e,a){if(e===void 0){e=""}if(a===void 0){a=""}console.warn("已废弃");return this.buildArmature(t,e||"",a||"")};a.prototype.dispose=function(){console.warn("已废弃");this.clear()};a._time=0;a._dragonBonesInstance=null;a._factory=null;return a}(t.BaseFactory);t.EgretFactory=e})(dragonBones||(dragonBones={}));var dragonBones;(function(t){var e=new egret.Rectangle;var a=new egret.Matrix;var r={};function i(t,e){for(var a=0,r=t.length;a<r;++a){var i=t[a];if(i.name===e){return i}}return null}function n(t){if(t.groupName){var e=r[t.groupName];if(e){var a=i(e.movie||e.animation,t.movieName);if(a){t.groupConfig=e;t.movieConfig=a;return true}}}if(!t.groupName){for(var n in r){var e=r[n];if(!t.groupName){var a=i(e.movie||e.animation,t.movieName);if(a){t.groupName=n;t.groupConfig=e;t.movieConfig=a;return true}}}}return false}function s(t){return t in r}t.hasMovieGroup=s;function o(t,e,a){if(a===void 0){a=null}if(t){var i=new egret.ByteArray(t);i.endian=egret.Endian.LITTLE_ENDIAN;i.position=8;var n=JSON.parse(i.readUTF());n.offset=i.position;n.arrayBuffer=t;n.textures=[];var s=n.offset%4;if(s){n.offset+=4-s}for(var o=0,l=n.position.length;o<l;o+=3){switch(o/3){case 1:n.displayFrameArray=new Int16Array(n.arrayBuffer,n.offset+n.position[o],n.position[o+1]/n.position[o+2]);break;case 2:n.rectangleArray=new Float32Array(n.arrayBuffer,n.offset+n.position[o],n.position[o+1]/n.position[o+2]);break;case 3:n.transformArray=new Float32Array(n.arrayBuffer,n.offset+n.position[o],n.position[o+1]/n.position[o+2]);break;case 4:n.colorArray=new Int16Array(n.arrayBuffer,n.offset+n.position[o],n.position[o+1]/n.position[o+2]);break}}a=a||n.name;if(r[a]){console.warn("Replace group: "+a)}r[a]=n;if(e instanceof Array){for(var o=0,l=e.length;o<l;++o){var h=e[o];n.textures.push(h)}}else{n.textures.push(e)}}else{throw new Error}}t.addMovieGroup=o;function l(t){var e=r[t];if(e){delete r[t]}}t.removeMovieGroup=l;function h(){for(var t in r){delete r[t]}}t.removeAllMovieGroup=h;function f(e,a){if(a===void 0){a=null}var r={movieName:e,groupName:a};if(n(r)){var i=new p(r);i.clock=t.EgretFactory.factory.clock;return i}else{console.warn("No movie named: "+e)}return null}t.buildMovie=f;function u(t){var e=r[t];if(e){var a=[];var i=e.movie||e.animation;for(var n=0,s=i.length;n<s;++n){a.push(i[n].name)}return a}else{console.warn("No group named: "+t)}return null}t.getMovieNames=u;var _=function(t){__extends(e,t);function e(e){var a=t.call(this,e)||this;a.name="";a.slotName="";a.clipName="";return a}Object.defineProperty(e.prototype,"armature",{get:function(){return this.movie},enumerable:true,configurable:true});Object.defineProperty(e.prototype,"bone",{get:function(){return null},enumerable:true,configurable:true});Object.defineProperty(e.prototype,"animationState",{get:function(){return{name:this.clipName}},enumerable:true,configurable:true});Object.defineProperty(e.prototype,"frameLabel",{get:function(){return this.name},enumerable:true,configurable:true});Object.defineProperty(e.prototype,"movementID",{get:function(){return this.clipName},enumerable:true,configurable:true});e.START="start";e.LOOP_COMPLETE="loopComplete";e.COMPLETE="complete";e.FRAME_EVENT="frameEvent";e.SOUND_EVENT="soundEvent";return e}(egret.Event);t.MovieEvent=_;var c=function(t){__extends(e,t);function e(e){var a=t.call(this)||this;a.displayIndex=-1;a.colorIndex=-1;a.transformIndex=-1;a.rawDisplay=new egret.Bitmap;a.childMovies={};a.displayConfig=null;a.childMovie=null;a.colorFilter=null;a.display=a.rawDisplay;a.config=e;a.rawDisplay.name=a.config.name;if(!a.config.blendMode){a.config.blendMode=0}return a}e.prototype.dispose=function(){this.rawDisplay=null;this.childMovies=null;this.config=null;this.displayConfig=null;this.display=null;this.childMovie=null;this.colorFilter=null};return e}(egret.HashObject);var p=function(r){__extends(i,r);function i(t){var e=r.call(this)||this;e.timeScale=1;e.clipTimeScale=1;e._batchEnabled=true;e._isLockDispose=false;e._isDelayDispose=false;e._isStarted=false;e._isPlaying=false;e._isReversing=false;e._isCompleted=false;e._playTimes=0;e._time=0;e._currentTime=0;e._currentPlayTimes=0;e._cacheFrameIndex=0;e._frameSize=0;e._cacheRectangle=null;e._clock=null;e._currentFrameConfig=null;e._clipNames=[];e._slots=[];e._childMovies=[];e._groupConfig=t.groupConfig;e._config=t.movieConfig;e._batchEnabled=!(e._config.isNested||e._config.hasChildAnimation);if(e._batchEnabled){e.$renderNode=new egret.sys.GroupNode;e.$renderNode.cleanBeforeRender=i._cleanBeforeRender}e._clipNames.length=0;for(var a=0,n=e._config.clip.length;a<n;++a){e._clipNames.push(e._config.clip[a].name)}for(var a=0,n=e._config.slot.length;a<n;++a){var s=new c(e._config.slot[a]);e._updateSlotBlendMode(s);e._slots.push(s);if(e._batchEnabled){e.$renderNode.addNode(s.rawDisplay.$renderNode)}else{e.addChild(s.rawDisplay)}}e._frameSize=(1+1)*e._slots.length;e.name=e._config.name;e.play();e.advanceTime(1e-6);e.stop();return e}i._cleanBeforeRender=function(){};i.prototype._configToEvent=function(t,e){e.movie=this;e.clipName=this._clipConfig.name;e.name=t.name;e.slotName=t.slot||""};i.prototype._onCrossFrame=function(e){for(var a=0,r=e.actionAndEvent.length;a<r;++a){var i=e.actionAndEvent[a];if(i){switch(i.type){case 11:if(t.EgretFactory.factory.soundEventManager.hasEventListener(_.SOUND_EVENT)){var n=egret.Event.create(_,_.SOUND_EVENT);this._configToEvent(i,n);t.EgretFactory.factory.soundEventManager.dispatchEvent(n);egret.Event.release(n)}break;case 10:if(this.hasEventListener(_.FRAME_EVENT)){var s=egret.Event.create(_,_.FRAME_EVENT);this._configToEvent(i,s);this.dispatchEvent(s);egret.Event.release(s)}break;case 0:if(i.slot){var o=this._getSlot(i.slot);if(o&&o.childMovie){o.childMovie.play(i.name)}}else{this.play(i.name)}break}}}};i.prototype._updateSlotBlendMode=function(t){var e="";switch(t.config.blendMode){case 0:e=egret.BlendMode.NORMAL;break;case 1:e=egret.BlendMode.ADD;break;case 5:e=egret.BlendMode.ERASE;break;default:break}if(e){if(this._batchEnabled){t.display.$renderNode.blendMode=egret.sys.blendModeToNumber(e)}else{t.display.blendMode=e}}};i.prototype._updateSlotColor=function(t,e,a,r,i,n,s,o,l){if(a!==1||r!==1||i!==1||s!==0||o!==0||l!==0||n!==0){if(!t.colorFilter){t.colorFilter=new egret.ColorMatrixFilter}var h=t.colorFilter.matrix;h[0]=a;h[6]=r;h[12]=i;h[18]=e;h[4]=s;h[9]=o;h[14]=l;h[19]=n;t.colorFilter.matrix=h;if(this._batchEnabled){t.display.$renderNode.filter=t.colorFilter;t.display.$renderNode.alpha=1}else{var f=t.display.filters;if(!f){f=[]}if(f.indexOf(t.colorFilter)<0){f.push(t.colorFilter)}t.display.filters=f;t.display.$setAlpha(1)}}else{if(t.colorFilter){t.colorFilter=null}if(this._batchEnabled){t.display.$renderNode.filter=null;t.display.$renderNode.alpha=e}else{t.display.filters=null;t.display.$setAlpha(e)}}};i.prototype._updateSlotDisplay=function(e){var a=e.display||e.rawDisplay;var r=e.childMovie;if(e.displayIndex>=0){e.displayConfig=this._groupConfig.display[e.displayIndex];if(e.displayConfig.type===1){var i=e.displayConfig.name in e.childMovies?e.childMovies[e.displayConfig.name]:null;if(!i){i=f(e.displayConfig.name,this._groupConfig.name);if(i){e.childMovies[e.displayConfig.name]=i}}if(i){e.display=i;e.childMovie=i}else{e.display=e.rawDisplay;e.childMovie=null}}else{e.display=e.rawDisplay;e.childMovie=null}}else{e.displayConfig=null;e.display=e.rawDisplay;e.childMovie=null}if(e.display!==a){if(a){this.addChild(e.display);this.swapChildren(e.display,a);this.removeChild(a)}this._updateSlotBlendMode(e)}if(e.display===e.rawDisplay){if(e.displayConfig&&e.displayConfig.regionIndex!==null&&e.displayConfig.regionIndex!==undefined){if(!e.displayConfig.texture){var n=this._groupConfig.textures[e.displayConfig.textureIndex||0];var s=e.displayConfig.regionIndex*4;var o=this._groupConfig.rectangleArray[s];var l=this._groupConfig.rectangleArray[s+1];var h=this._groupConfig.rectangleArray[s+2];var u=this._groupConfig.rectangleArray[s+3];e.displayConfig.texture=new egret.Texture;e.displayConfig.texture.bitmapData=n.bitmapData;e.displayConfig.texture.$initData(o,l,Math.min(h,n.textureWidth-o),Math.min(u,n.textureHeight-l),0,0,Math.min(h,n.textureWidth-o),Math.min(u,n.textureHeight-l),n.textureWidth,n.textureHeight)}if(this._batchEnabled){var _=e.displayConfig.texture;var c=e.rawDisplay.$renderNode;egret.sys.RenderNode.prototype.cleanBeforeRender.call(e.rawDisplay.$renderNode);c.image=_.bitmapData;if(t.isV5){c.drawImage(_.$bitmapX,_.$bitmapY,_.$bitmapWidth,_.$bitmapHeight,_.$offsetX,_.$offsetY,_.textureWidth,_.textureHeight);c.imageWidth=_._sourceWidth;c.imageHeight=_._sourceHeight}else{var p=_;c.drawImage(p._bitmapX,p._bitmapY,p._bitmapWidth,p._bitmapHeight,p._offsetX,p._offsetY,_.textureWidth,_.textureHeight);c.imageWidth=p._sourceWidth;c.imageHeight=p._sourceHeight}}else{e.rawDisplay.visible=true;e.rawDisplay.$setBitmapData(e.displayConfig.texture)}}else{if(this._batchEnabled){e.rawDisplay.$renderNode.image=null}else{e.rawDisplay.visible=false;e.rawDisplay.$setBitmapData(null)}}}if(e.childMovie!==r){if(r){r.stop();this._childMovies.slice(this._childMovies.indexOf(r),1)}if(e.childMovie){if(this._childMovies.indexOf(e.childMovie)<0){this._childMovies.push(e.childMovie)}if(e.config.action){e.childMovie.play(e.config.action)}else{e.childMovie.play(e.childMovie._config.action)}}}};i.prototype._getSlot=function(t){for(var e=0,a=this._slots.length;e<a;++e){var r=this._slots[e];if(r.config.name===t){return r}}return null};i.prototype.$render=function(){if(this._batchEnabled){}else{r.prototype.$render.call(this)}};i.prototype.$updateRenderNode=function(){if(this._batchEnabled){}else{r.prototype.$updateRenderNode.call(this)}};i.prototype.$measureContentBounds=function(t){if(this._batchEnabled&&this._cacheRectangle){t.setTo(this._cacheRectangle.x,this._cacheRectangle.y,this._cacheRectangle.width-this._cacheRectangle.x,this._cacheRectangle.height-this._cacheRectangle.y)}else{r.prototype.$measureContentBounds.call(this,t)}};i.prototype.$doAddChild=function(t,e,a){if(this._batchEnabled){console.warn("Can not add child.");return null}return r.prototype.$doAddChild.call(this,t,e,a)};i.prototype.$doRemoveChild=function(t,e){if(this._batchEnabled){console.warn("Can not remove child.");return null}return r.prototype.$doRemoveChild.call(this,t,e)};i.prototype.dispose=function(){if(this._isLockDispose){this._isDelayDispose=true}else{if(this._clock){this._clock.remove(this)}if(this._slots){for(var t=0,e=this._slots.length;t<e;++t){this._slots[t].dispose()}}this._isPlaying=false;this._cacheRectangle=null;this._clock=null;this._groupConfig=null;this._config=null;this._clipConfig=null;this._currentFrameConfig=null;this._clipArray=null;this._clipNames=null;this._slots=null;this._childMovies=null}};i.prototype.advanceTime=function(r){if(this._isPlaying){this._isLockDispose=true;if(r<0){r=-r}r*=this.timeScale;this._time+=r*this.clipTimeScale;var i=this._clipConfig.duration;var n=i*this._playTimes;var s=this._time;var o=this._currentPlayTimes;if(this._playTimes>0&&(s>=n||s<=-n)){this._isCompleted=true;o=this._playTimes;if(s<0){s=0}else{s=i}}else{this._isCompleted=false;if(s<0){o=Math.floor(-s/i);s=i- -s%i}else{o=Math.floor(s/i);s%=i}if(this._playTimes>0&&o>this._playTimes){o=this._playTimes}}if(this._currentTime===s){return}var l=Math.floor(s*this._clipConfig.cacheTimeToFrameScale);if(this._cacheFrameIndex!==l){this._cacheFrameIndex=l;var h=this._groupConfig.displayFrameArray;var f=this._groupConfig.transformArray;var u=this._groupConfig.colorArray;var c=true;var p=false;var m=false;var d=this._cacheRectangle;this._cacheRectangle=this._clipConfig.cacheRectangles[this._cacheFrameIndex];if(this._batchEnabled&&!this._cacheRectangle){m=true;this._cacheRectangle=new egret.Rectangle;this._clipConfig.cacheRectangles[this._cacheFrameIndex]=this._cacheRectangle}for(var v=0,y=this._slots.length;v<y;++v){var g=this._slots[v];var b=this._frameSize*this._cacheFrameIndex+v*2;if(b>=this._clipArray.length){b=this._frameSize*(this._cacheFrameIndex-1)+v*2}var D=this._clipArray[b]*2;if(D>=0){var T=h[D];var A=h[D+1]*8;var x=this._clipArray[b+1]*6;var P=false;if(g.displayIndex!==T){g.displayIndex=T;P=true;this._updateSlotDisplay(g)}if(g.colorIndex!==A||P){g.colorIndex=A;if(g.colorIndex>=0){this._updateSlotColor(g,u[A]*.01,u[A+1]*.01,u[A+2]*.01,u[A+3]*.01,u[A+4],u[A+5],u[A+6],u[A+7])}else{this._updateSlotColor(g,1,1,1,1,0,0,0,0)}}p=true;if(g.transformIndex!==x){g.transformIndex=x;if(this._batchEnabled){var O=g.display.$renderNode.matrix;if(!O){O=g.display.$renderNode.matrix=new egret.Matrix}O.a=f[x];O.b=f[x+1];O.c=f[x+2];O.d=f[x+3];O.tx=f[x+4];O.ty=f[x+5]}else{a.a=f[x];a.b=f[x+1];a.c=f[x+2];a.d=f[x+3];a.tx=f[x+4];a.ty=f[x+5];g.display.$setMatrix(a)}}if(this._batchEnabled&&m&&g.displayConfig){var O=g.display.$renderNode.matrix;e.x=0;e.y=0;e.width=g.displayConfig.texture.textureWidth;e.height=g.displayConfig.texture.textureHeight;O.$transformBounds(e);if(c){c=false;this._cacheRectangle.x=e.x;this._cacheRectangle.width=e.x+e.width;this._cacheRectangle.y=e.y;this._cacheRectangle.height=e.y+e.height}else{this._cacheRectangle.x=Math.min(this._cacheRectangle.x,e.x);this._cacheRectangle.width=Math.max(this._cacheRectangle.width,e.x+e.width);this._cacheRectangle.y=Math.min(this._cacheRectangle.y,e.y);this._cacheRectangle.height=Math.max(this._cacheRectangle.height,e.y+e.height)}}}else if(g.displayIndex!==-1){g.displayIndex=-1;this._updateSlotDisplay(g)}}if(this._cacheRectangle){if(p&&m&&c&&d){this._cacheRectangle.x=d.x;this._cacheRectangle.y=d.y;this._cacheRectangle.width=d.width;this._cacheRectangle.height=d.height}if(!t.isV5){this.$invalidateContentBounds()}}}if(this._isCompleted){this._isPlaying=false}if(!this._isStarted){this._isStarted=true;if(this.hasEventListener(_.START)){var S=egret.Event.create(_,_.START);S.movie=this;S.clipName=this._clipConfig.name;S.name="";S.slotName="";this.dispatchEvent(S)}}this._isReversing=this._currentTime>s&&this._currentPlayTimes===o;this._currentTime=s;var E=this._clipConfig.frame?this._clipConfig.frame.length:0;if(E>0){var M=Math.floor(this._currentTime*this._config.frameRate);var B=this._groupConfig.frame[this._clipConfig.frame[M]];if(this._currentFrameConfig!==B){if(E>1){var C=this._currentFrameConfig;this._currentFrameConfig=B;if(!C){var w=Math.floor(this._currentTime*this._config.frameRate);C=this._groupConfig.frame[this._clipConfig.frame[w]];if(this._isReversing){}else{if(this._currentTime<=C.position||this._currentPlayTimes!==o){C=this._groupConfig.frame[C.prev]}}}if(this._isReversing){while(C!==B){this._onCrossFrame(C);C=this._groupConfig.frame[C.prev]}}else{while(C!==B){C=this._groupConfig.frame[C.next];this._onCrossFrame(C)}}}else{this._currentFrameConfig=B;if(this._currentFrameConfig){this._onCrossFrame(this._currentFrameConfig)}}}}if(this._currentPlayTimes!==o){this._currentPlayTimes=o;if(this.hasEventListener(_.LOOP_COMPLETE)){var I=egret.Event.create(_,_.LOOP_COMPLETE);I.movie=this;I.clipName=this._clipConfig.name;I.name="";I.slotName="";this.dispatchEvent(I);egret.Event.release(I)}if(this._isCompleted&&this.hasEventListener(_.COMPLETE)){var F=egret.Event.create(_,_.COMPLETE);F.movie=this;F.clipName=this._clipConfig.name;F.name="";F.slotName="";this.dispatchEvent(F);egret.Event.release(F)}}}this._isLockDispose=false;if(this._isDelayDispose){this.dispose()}};i.prototype.play=function(t,e){if(t===void 0){t=null}if(e===void 0){e=-1}if(t){var a=null;for(var r=0,i=this._config.clip.length;r<i;++r){var n=this._config.clip[r];if(n.name===t){a=n}}if(a){this._clipConfig=a;this._clipArray=new Int16Array(this._groupConfig.arrayBuffer,this._groupConfig.offset+this._groupConfig.position[0]+this._clipConfig.p,this._clipConfig.s/this._groupConfig.position[2]);if(!this._clipConfig.cacheRectangles){this._clipConfig.cacheRectangles=[]}this._isPlaying=true;this._isStarted=false;this._isCompleted=false;if(e<0||e!==e){this._playTimes=this._clipConfig.playTimes}else{this._playTimes=e}this._time=0;this._currentTime=0;this._currentPlayTimes=0;this._cacheFrameIndex=-1;this._currentFrameConfig=null;this._cacheRectangle=null;this.clipTimeScale=1/this._clipConfig.scale}else{console.warn("No clip in movie.",this._config.name,t)}}else if(this._clipConfig){if(this._isPlaying||this._isCompleted){this.play(this._clipConfig.name,this._playTimes)}else{this._isPlaying=true}}else if(this._config.action){this.play(this._config.action,e)}};i.prototype.stop=function(){this._isPlaying=false};i.prototype.gotoAndPlay=function(t,e,a){if(t===void 0){t=null}if(a===void 0){a=-1}e%=this._clipConfig.duration;if(e<0){e+=this._clipConfig.duration}this.play(t,a);this._time=e;this._currentTime=e};i.prototype.gotoAndStop=function(t,e){if(t===void 0){t=null}e%=this._clipConfig.duration;if(e<0){e+=this._clipConfig.duration}this.play(t,1);this._time=e;this._currentTime=e;this.advanceTime(.001);this.stop()};i.prototype.hasClip=function(t){for(var e=0,a=this._config.clip.length;e<a;++e){var r=this._config.clip[e];if(r.name===t){return true}}return false};Object.defineProperty(i.prototype,"isPlaying",{get:function(){return this._isPlaying&&!this._isCompleted},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"isComplete",{get:function(){return this._isCompleted},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"currentTime",{get:function(){return this._currentTime},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"totalTime",{get:function(){return this._clipConfig?this._clipConfig.duration:0},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"currentPlayTimes",{get:function(){return this._currentPlayTimes},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"playTimes",{get:function(){return this._playTimes},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"groupName",{get:function(){return this._groupConfig.name},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"clipName",{get:function(){return this._clipConfig?this._clipConfig.name:""},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"clipNames",{get:function(){return this._clipNames},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"clock",{get:function(){return this._clock},set:function(t){if(this._clock===t){return}var e=this._clock;if(e){e.remove(this)}this._clock=t;if(this._clock){this._clock.add(this)}},enumerable:true,configurable:true});i.prototype.advanceTimeBySelf=function(e){if(e){this.clock=t.EgretFactory.clock}else{this.clock=null}};Object.defineProperty(i.prototype,"display",{get:function(){return this},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"animation",{get:function(){return this},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"armature",{get:function(){return this},enumerable:true,configurable:true});i.prototype.getAnimation=function(){return this};i.prototype.getArmature=function(){return this};i.prototype.getDisplay=function(){return this};i.prototype.hasAnimation=function(t){return this.hasClip(t)};i.prototype.invalidUpdate=function(){var t=[];for(var e=0;e<arguments.length;e++){t[e]=arguments[e]}t};Object.defineProperty(i.prototype,"lastAnimationName",{get:function(){return this.clipName},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"animationNames",{get:function(){return this.clipNames},enumerable:true,configurable:true});Object.defineProperty(i.prototype,"animationList",{get:function(){return this.clipNames},enumerable:true,configurable:true});return i}(egret.DisplayObjectContainer);t.Movie=p})(dragonBones||(dragonBones={}));
\ No newline at end of file
diff --git a/demo/manifest.json b/demo/manifest.json
index 522c8eec..cf93774c 100644
--- a/demo/manifest.json
+++ b/demo/manifest.json
@@ -7,19 +7,38 @@
 		"libs/modules/game/game.js",
 		"libs/modules/tween/tween.js",
 		"libs/modules/promise/promise.js",
+		"libs/modules/dragonBones/dragonBones.js",
 		"libs/framework/framework.js",
-		"libs/long/long.js"
+		"libs/long/long.js",
+		"libs/fairygui/fairygui.js"
 	],
 	"game": [
-		"bin-debug/AssetAdapter.js",
-		"bin-debug/LoadingUI.js",
-		"bin-debug/Main.js",
+		"bin-debug/Fgui/common/commonBinder.js",
+		"bin-debug/UI/mvc/BaseView.js",
+		"bin-debug/SampleHelpers/SampleScene.js",
+		"bin-debug/UI/loading/LoadingView.js",
+		"bin-debug/Scenes/Empty Scene/BasicScene.js",
+		"bin-debug/Fgui/common/UI_com_tips.js",
+		"bin-debug/Fgui/loading/loadingBinder.js",
+		"bin-debug/Fgui/loading/UI_View_loading.js",
+		"bin-debug/Fgui/sc/scBinder.js",
+		"bin-debug/Fgui/sc/UI_btn_sc.js",
+		"bin-debug/Fgui/sc/UI_View_sc.js",
 		"bin-debug/Platform.js",
+		"bin-debug/Scenes/Animated Tiles/AnimatedTilesScene.js",
+		"bin-debug/Main.js",
+		"bin-debug/UI/PopManager.js",
+		"bin-debug/UI/loading/LoadingControl.js",
+		"bin-debug/UI/loading/LoadingEvents.js",
 		"bin-debug/ThemeAdapter.js",
-		"bin-debug/game/MainScene.js",
-		"bin-debug/game/PlayerController.js",
-		"bin-debug/game/SimplePooled.js",
-		"bin-debug/game/SpawnerComponent.js",
-		"bin-debug/game/SpawnerSystem.js"
+		"bin-debug/AssetAdapter.js",
+		"bin-debug/UI/mvc/EventManager.js",
+		"bin-debug/UI/mvc/Extension.js",
+		"bin-debug/UI/mvc/FguiUtils.js",
+		"bin-debug/UI/mvc/LayerManager.js",
+		"bin-debug/UI/mvc/ViewManager.js",
+		"bin-debug/UI/sc/ScControl.js",
+		"bin-debug/UI/sc/ScEvents.js",
+		"bin-debug/UI/sc/ScView.js"
 	]
 }
\ No newline at end of file
diff --git a/demo/resource/assets/Button/button_down.png b/demo/resource/assets/Button/button_down.png
deleted file mode 100644
index fbf0c9dc..00000000
Binary files a/demo/resource/assets/Button/button_down.png and /dev/null differ
diff --git a/demo/resource/assets/Button/button_up.png b/demo/resource/assets/Button/button_up.png
deleted file mode 100644
index 15b99231..00000000
Binary files a/demo/resource/assets/Button/button_up.png and /dev/null differ
diff --git a/demo/resource/assets/CheckBox/checkbox_select_disabled.png b/demo/resource/assets/CheckBox/checkbox_select_disabled.png
deleted file mode 100644
index adeb01ee..00000000
Binary files a/demo/resource/assets/CheckBox/checkbox_select_disabled.png and /dev/null differ
diff --git a/demo/resource/assets/CheckBox/checkbox_select_down.png b/demo/resource/assets/CheckBox/checkbox_select_down.png
deleted file mode 100644
index c181dd22..00000000
Binary files a/demo/resource/assets/CheckBox/checkbox_select_down.png and /dev/null differ
diff --git a/demo/resource/assets/CheckBox/checkbox_select_up.png b/demo/resource/assets/CheckBox/checkbox_select_up.png
deleted file mode 100644
index 473c0c2d..00000000
Binary files a/demo/resource/assets/CheckBox/checkbox_select_up.png and /dev/null differ
diff --git a/demo/resource/assets/CheckBox/checkbox_unselect.png b/demo/resource/assets/CheckBox/checkbox_unselect.png
deleted file mode 100644
index 168da460..00000000
Binary files a/demo/resource/assets/CheckBox/checkbox_unselect.png and /dev/null differ
diff --git a/demo/resource/assets/ItemRenderer/selected.png b/demo/resource/assets/ItemRenderer/selected.png
deleted file mode 100644
index 3023c68f..00000000
Binary files a/demo/resource/assets/ItemRenderer/selected.png and /dev/null differ
diff --git a/demo/resource/assets/Panel/border.png b/demo/resource/assets/Panel/border.png
deleted file mode 100644
index 9583294e..00000000
Binary files a/demo/resource/assets/Panel/border.png and /dev/null differ
diff --git a/demo/resource/assets/Panel/header.png b/demo/resource/assets/Panel/header.png
deleted file mode 100644
index fc3ac875..00000000
Binary files a/demo/resource/assets/Panel/header.png and /dev/null differ
diff --git a/demo/resource/assets/ProgressBar/thumb_pb.png b/demo/resource/assets/ProgressBar/thumb_pb.png
deleted file mode 100644
index 83056846..00000000
Binary files a/demo/resource/assets/ProgressBar/thumb_pb.png and /dev/null differ
diff --git a/demo/resource/assets/ProgressBar/track_pb.png b/demo/resource/assets/ProgressBar/track_pb.png
deleted file mode 100644
index 939a4b90..00000000
Binary files a/demo/resource/assets/ProgressBar/track_pb.png and /dev/null differ
diff --git a/demo/resource/assets/RadioButton/radiobutton_select_disabled.png b/demo/resource/assets/RadioButton/radiobutton_select_disabled.png
deleted file mode 100644
index 97d93261..00000000
Binary files a/demo/resource/assets/RadioButton/radiobutton_select_disabled.png and /dev/null differ
diff --git a/demo/resource/assets/RadioButton/radiobutton_select_down.png b/demo/resource/assets/RadioButton/radiobutton_select_down.png
deleted file mode 100644
index 97d93261..00000000
Binary files a/demo/resource/assets/RadioButton/radiobutton_select_down.png and /dev/null differ
diff --git a/demo/resource/assets/RadioButton/radiobutton_select_up.png b/demo/resource/assets/RadioButton/radiobutton_select_up.png
deleted file mode 100644
index ac4ef5e7..00000000
Binary files a/demo/resource/assets/RadioButton/radiobutton_select_up.png and /dev/null differ
diff --git a/demo/resource/assets/RadioButton/radiobutton_unselect.png b/demo/resource/assets/RadioButton/radiobutton_unselect.png
deleted file mode 100644
index b47c17ca..00000000
Binary files a/demo/resource/assets/RadioButton/radiobutton_unselect.png and /dev/null differ
diff --git a/demo/resource/assets/ScrollBar/roundthumb.png b/demo/resource/assets/ScrollBar/roundthumb.png
deleted file mode 100644
index 0704b3c4..00000000
Binary files a/demo/resource/assets/ScrollBar/roundthumb.png and /dev/null differ
diff --git a/demo/resource/assets/ScrollBar/track_sb.png b/demo/resource/assets/ScrollBar/track_sb.png
deleted file mode 100644
index da7bce6a..00000000
Binary files a/demo/resource/assets/ScrollBar/track_sb.png and /dev/null differ
diff --git a/demo/resource/assets/Slider/thumb.png b/demo/resource/assets/Slider/thumb.png
deleted file mode 100644
index c65c2224..00000000
Binary files a/demo/resource/assets/Slider/thumb.png and /dev/null differ
diff --git a/demo/resource/assets/Slider/track.png b/demo/resource/assets/Slider/track.png
deleted file mode 100644
index 5fb1fd55..00000000
Binary files a/demo/resource/assets/Slider/track.png and /dev/null differ
diff --git a/demo/resource/assets/Slider/tracklight.png b/demo/resource/assets/Slider/tracklight.png
deleted file mode 100644
index 0704b3c4..00000000
Binary files a/demo/resource/assets/Slider/tracklight.png and /dev/null differ
diff --git a/demo/resource/assets/ToggleSwitch/handle.png b/demo/resource/assets/ToggleSwitch/handle.png
deleted file mode 100644
index 332c8321..00000000
Binary files a/demo/resource/assets/ToggleSwitch/handle.png and /dev/null differ
diff --git a/demo/resource/assets/ToggleSwitch/off.png b/demo/resource/assets/ToggleSwitch/off.png
deleted file mode 100644
index 73658393..00000000
Binary files a/demo/resource/assets/ToggleSwitch/off.png and /dev/null differ
diff --git a/demo/resource/assets/ToggleSwitch/on.png b/demo/resource/assets/ToggleSwitch/on.png
deleted file mode 100644
index 43ee5751..00000000
Binary files a/demo/resource/assets/ToggleSwitch/on.png and /dev/null differ
diff --git a/demo/resource/assets/backgroundSet.png b/demo/resource/assets/backgroundSet.png
deleted file mode 100644
index 1be6bb1c..00000000
Binary files a/demo/resource/assets/backgroundSet.png and /dev/null differ
diff --git a/demo/resource/assets/bg.jpg b/demo/resource/assets/bg.jpg
deleted file mode 100644
index 8829fd13..00000000
Binary files a/demo/resource/assets/bg.jpg and /dev/null differ
diff --git a/demo/resource/assets/block.png b/demo/resource/assets/block.png
deleted file mode 100644
index 382c3d81..00000000
Binary files a/demo/resource/assets/block.png and /dev/null differ
diff --git a/demo/resource/assets/buttonHelp.png b/demo/resource/assets/buttonHelp.png
deleted file mode 100644
index 920a3809..00000000
Binary files a/demo/resource/assets/buttonHelp.png and /dev/null differ
diff --git a/demo/resource/assets/buttonStart.png b/demo/resource/assets/buttonStart.png
deleted file mode 100644
index 415dd549..00000000
Binary files a/demo/resource/assets/buttonStart.png and /dev/null differ
diff --git a/demo/resource/assets/cloud.png b/demo/resource/assets/cloud.png
deleted file mode 100644
index f51cdce8..00000000
Binary files a/demo/resource/assets/cloud.png and /dev/null differ
diff --git a/demo/resource/assets/egret_icon.png b/demo/resource/assets/egret_icon.png
deleted file mode 100644
index 7d29b2a8..00000000
Binary files a/demo/resource/assets/egret_icon.png and /dev/null differ
diff --git a/demo/resource/assets/gem.png b/demo/resource/assets/gem.png
deleted file mode 100644
index 1e95975d..00000000
Binary files a/demo/resource/assets/gem.png and /dev/null differ
diff --git a/demo/resource/assets/heart.png b/demo/resource/assets/heart.png
deleted file mode 100644
index d471b59e..00000000
Binary files a/demo/resource/assets/heart.png and /dev/null differ
diff --git a/demo/resource/assets/helpBackground.png b/demo/resource/assets/helpBackground.png
deleted file mode 100644
index ad20725b..00000000
Binary files a/demo/resource/assets/helpBackground.png and /dev/null differ
diff --git a/demo/resource/assets/isometric_grass_and_water.json b/demo/resource/assets/isometric_grass_and_water.json
deleted file mode 100644
index aeb0d798..00000000
--- a/demo/resource/assets/isometric_grass_and_water.json
+++ /dev/null
@@ -1,345 +0,0 @@
-{ "height":25,
- "infinite":false,
- "layers":[
-        {
-         "data":[24, 24, 23, 11, 19, 19, 12, 23, 24, 24, 23, 7, 2, 2, 1, 4, 2, 2, 3, 4, 4, 1, 3, 4, 1, 24, 23, 23, 14, 3, 3, 8, 12, 24, 24, 18, 4, 1, 3, 1, 3, 3, 4, 4, 1, 3, 1, 4, 3, 4, 11, 15, 15, 7, 1, 4, 3, 20, 23, 11, 7, 2, 1, 3, 1, 3, 4, 4, 3, 2, 2, 3, 4, 2, 1, 18, 4, 3, 2, 2, 4, 3, 8, 12, 18, 2, 4, 4, 3, 3, 1, 4, 2, 1, 4, 4, 4, 1, 1, 1, 14, 2, 1, 4, 2, 1, 4, 2, 8, 7, 5, 17, 6, 3, 3, 3, 4, 3, 4, 4, 3, 2, 4, 3, 4, 10, 6, 2, 1, 4, 4, 1, 3, 4, 3, 8, 12, 10, 6, 2, 1, 1, 1, 1, 2, 1, 4, 2, 1, 1, 24, 18, 1, 2, 4, 3, 3, 5, 6, 5, 13, 9, 11, 7, 3, 4, 1, 3, 1, 3, 4, 2, 4, 4, 4, 24, 14, 4, 2, 5, 6, 2, 8, 22, 9, 23, 24, 10, 6, 2, 1, 3, 1, 5, 6, 2, 3, 4, 4, 2, 19, 7, 3, 1, 8, 7, 4, 1, 8, 12, 24, 23, 23, 10, 17, 6, 3, 1, 8, 7, 1, 3, 3, 3, 1, 1, 2, 4, 2, 2, 3, 3, 4, 3, 20, 24, 23, 23, 23, 23, 18, 2, 2, 3, 1, 4, 4, 1, 1, 1, 3, 3, 5, 13, 6, 1, 2, 2, 5, 9, 23, 23, 24, 23, 24, 14, 1, 3, 1, 1, 3, 3, 4, 4, 4, 2, 4, 16, 24, 10, 6, 2, 4, 20, 23, 23, 24, 23, 23, 24, 14, 2, 4, 2, 4, 5, 6, 4, 3, 1, 3, 1, 20, 23, 24, 10, 6, 3, 8, 12, 24, 23, 23, 23, 24, 14, 1, 2, 1, 5, 9, 18, 4, 3, 4, 4, 2, 8, 12, 23, 24, 18, 4, 3, 16, 24, 24, 24, 23, 24, 18, 1, 3, 1, 16, 24, 14, 1, 3, 2, 4, 1, 2, 8, 12, 24, 14, 4, 1, 8, 15, 12, 24, 23, 11, 7, 2, 1, 2, 16, 23, 18, 1, 4, 2, 3, 4, 3, 2, 8, 19, 7, 2, 2, 3, 3, 8, 15, 19, 7, 3, 1, 2, 5, 9, 24, 14, 1, 2, 3, 2, 2, 1, 4, 4, 1, 2, 5, 6, 2, 2, 2, 1, 3, 4, 3, 5, 13, 9, 24, 24, 18, 4, 3, 4, 1, 4, 1, 3, 2, 5, 13, 9, 14, 3, 1, 3, 2, 4, 4, 5, 21, 19, 12, 24, 11, 7, 1, 2, 3, 2, 1, 3, 3, 3, 20, 23, 24, 18, 4, 4, 2, 3, 1, 1, 8, 7, 5, 9, 23, 18, 1, 3, 4, 2, 4, 2, 4, 1, 2, 8, 15, 19, 7, 4, 5, 6, 4, 2, 4, 5, 17, 9, 23, 11, 22, 13, 6, 4, 1, 3, 2, 2, 4, 4, 3, 2, 1, 4, 2, 8, 7, 4, 2, 3, 16, 24, 23, 11, 7, 16, 23, 18, 3, 1, 1, 3, 1, 2, 3, 3, 3, 4, 2, 1, 3, 2, 3, 4, 3, 8, 15, 15, 7, 4, 8, 19, 7, 3, 4, 1, 2, 3, 4, 1, 3, 4, 4, 4, 1, 4, 4, 3, 2, 3, 4, 1, 2, 4, 2, 1, 2, 2, 4, 1, 4, 2, 3, 2, 1, 4, 2, 2, 1, 2, 2, 2, 4, 3, 3, 2, 3, 3, 2, 3, 2, 4, 1, 3, 1, 1, 1, 1, 4, 1, 3, 3, 2, 1, 4, 2, 1, 3, 1, 3, 3, 4, 3, 4, 2, 1, 2, 3, 1, 1],
-         "height":25,
-         "id":1,
-         "name":"Tile Layer 1",
-         "opacity":1,
-         "type":"tilelayer",
-         "visible":true,
-         "width":25,
-         "x":0,
-         "y":0
-        }],
- "nextlayerid":2,
- "nextobjectid":1,
- "orientation":"isometric",
- "renderorder":"right-down",
- "tiledversion":"1.2.1",
- "tileheight":32,
- "tilesets":[
-        {
-         "columns":4,
-         "firstgid":1,
-         "grid":
-            {
-             "height":32,
-             "orientation":"isometric",
-             "width":64
-            },
-         "image":"isometric_grass_and_water.png",
-         "imageheight":384,
-         "imagewidth":256,
-         "margin":0,
-         "name":"isometric_grass_and_water",
-         "spacing":0,
-         "terrains":[
-                {
-                 "name":"Grass",
-                 "tile":0
-                }, 
-                {
-                 "name":"Water",
-                 "tile":22
-                }],
-         "tilecount":24,
-         "tileheight":64,
-         "tileoffset":
-            {
-             "x":0,
-             "y":16
-            },
-         "tiles":[
-                {
-                 "id":0,
-                 "terrain":[0, 0, 0, 0]
-                }, 
-                {
-                 "id":1,
-                 "terrain":[0, 0, 0, 0]
-                }, 
-                {
-                 "id":2,
-                 "terrain":[0, 0, 0, 0]
-                }, 
-                {
-                 "id":3,
-                 "terrain":[0, 0, 0, 0]
-                }, 
-                {
-                 "id":4,
-                 "terrain":[0, 0, 0, 1]
-                }, 
-                {
-                 "id":5,
-                 "terrain":[0, 0, 1, 0]
-                }, 
-                {
-                 "id":6,
-                 "terrain":[1, 0, 0, 0]
-                }, 
-                {
-                 "id":7,
-                 "terrain":[0, 1, 0, 0]
-                }, 
-                {
-                 "id":8,
-                 "terrain":[0, 1, 1, 1]
-                }, 
-                {
-                 "id":9,
-                 "terrain":[1, 0, 1, 1]
-                }, 
-                {
-                 "id":10,
-                 "terrain":[1, 1, 1, 0]
-                }, 
-                {
-                 "id":11,
-                 "terrain":[1, 1, 0, 1]
-                }, 
-                {
-                 "id":12,
-                 "terrain":[0, 0, 1, 1]
-                }, 
-                {
-                 "id":13,
-                 "terrain":[1, 0, 1, 0]
-                }, 
-                {
-                 "id":14,
-                 "terrain":[1, 1, 0, 0]
-                }, 
-                {
-                 "id":15,
-                 "terrain":[0, 1, 0, 1]
-                }, 
-                {
-                 "id":16,
-                 "terrain":[0, 0, 1, 1]
-                }, 
-                {
-                 "id":17,
-                 "terrain":[1, 0, 1, 0]
-                }, 
-                {
-                 "id":18,
-                 "terrain":[1, 1, 0, 0]
-                }, 
-                {
-                 "id":19,
-                 "terrain":[0, 1, 0, 1]
-                }, 
-                {
-                 "id":20,
-                 "terrain":[0, 1, 1, 0]
-                }, 
-                {
-                 "id":21,
-                 "terrain":[1, 0, 0, 1]
-                }, 
-                {
-                 "id":22,
-                 "terrain":[1, 1, 1, 1]
-                }, 
-                {
-                 "id":23,
-                 "terrain":[1, 1, 1, 1]
-                }],
-         "tilewidth":64,
-         "wangsets":[
-                {
-                 "cornercolors":[
-                        {
-                         "color":"#8ab022",
-                         "name":"Grass",
-                         "probability":1,
-                         "tile":0
-                        }, 
-                        {
-                         "color":"#378dc2",
-                         "name":"Water",
-                         "probability":1,
-                         "tile":23
-                        }],
-                 "edgecolors":[],
-                 "name":"Grass and Water",
-                 "tile":15,
-                 "wangtiles":[
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":0,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":1,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":2,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":3,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":4,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 2, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":5,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 2, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":6,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 1, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":7,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 1, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":8,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 2, 0, 2, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":9,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 2, 0, 2, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":10,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 1, 0, 2, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":11,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 2, 0, 1, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":12,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 2, 0, 2, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":13,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 2, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":14,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 1, 0, 1, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":15,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 2, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":16,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 2, 0, 2, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":17,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 1, 0, 2, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":18,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 1, 0, 1, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":19,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 2, 0, 1, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":20,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 1, 0, 2, 0, 1]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":21,
-                         "vflip":false,
-                         "wangid":[0, 1, 0, 2, 0, 1, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":22,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 2, 0, 2, 0, 2]
-                        }, 
-                        {
-                         "dflip":false,
-                         "hflip":false,
-                         "tileid":23,
-                         "vflip":false,
-                         "wangid":[0, 2, 0, 2, 0, 2, 0, 2]
-                        }]
-                }]
-        }],
- "tilewidth":64,
- "type":"map",
- "version":1.2,
- "width":25
-}
\ No newline at end of file
diff --git a/demo/resource/assets/isometric_grass_and_water.png b/demo/resource/assets/isometric_grass_and_water.png
deleted file mode 100644
index b342a0cb..00000000
Binary files a/demo/resource/assets/isometric_grass_and_water.png and /dev/null differ
diff --git a/demo/resource/assets/shield.png b/demo/resource/assets/shield.png
deleted file mode 100644
index 1474ad0e..00000000
Binary files a/demo/resource/assets/shield.png and /dev/null differ
diff --git a/demo/resource/assets/title.json b/demo/resource/assets/title.json
deleted file mode 100644
index 95b7beb3..00000000
--- a/demo/resource/assets/title.json
+++ /dev/null
@@ -1,281 +0,0 @@
-{ "backgroundcolor":"#3b97d3",
- "height":26,
- "layers":[
-        {
-         "draworder":"topdown",
-         "height":26,
-         "name":"background",
-         "objects":[
-                {
-                 "gid":7,
-                 "height":262.666666666667,
-                 "id":11,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":1736,
-                 "x":-256,
-                 "y":920.666666666667
-                }, 
-                {
-                 "gid":6,
-                 "height":832,
-                 "id":34,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":1216,
-                 "x":122,
-                 "y":810
-                }],
-         "opacity":1,
-         "type":"objectgroup",
-         "visible":true,
-         "width":38,
-         "x":0,
-         "y":0
-        }, 
-        {
-         "draworder":"topdown",
-         "height":26,
-         "name":"clouds",
-         "objects":[
-                {
-                 "gid":8,
-                 "height":61.3333333333333,
-                 "id":14,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":184,
-                 "x":640,
-                 "y":320
-                }, 
-                {
-                 "gid":8,
-                 "height":61.3333333333333,
-                 "id":17,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":184,
-                 "x":336,
-                 "y":144
-                }, 
-                {
-                 "gid":8,
-                 "height":61.3333333333333,
-                 "id":21,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":192,
-                 "x":1024,
-                 "y":145
-                }, 
-                {
-                 "gid":2147483656,
-                 "height":61.3333333333333,
-                 "id":23,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":184,
-                 "x":44,
-                 "y":136
-                }, 
-                {
-                 "gid":6,
-                 "height":600,
-                 "id":8,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":954,
-                 "x":-226,
-                 "y":768
-                }, 
-                {
-                 "gid":2147483654,
-                 "height":546,
-                 "id":35,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":826,
-                 "x":710,
-                 "y":782
-                }, 
-                {
-                 "gid":2147483656,
-                 "height":103.333333333333,
-                 "id":36,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":284,
-                 "x":926,
-                 "y":307
-                }, 
-                {
-                 "gid":8,
-                 "height":103.333333333333,
-                 "id":37,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":284,
-                 "x":124,
-                 "y":353
-                }],
-         "opacity":0.490000009536743,
-         "type":"objectgroup",
-         "visible":true,
-         "width":38,
-         "x":0,
-         "y":0
-        }, 
-        {
-         "draworder":"topdown",
-         "height":38,
-         "name":"title",
-         "objects":[
-                {
-                 "gid":4,
-                 "height":386,
-                 "id":1,
-                 "name":"logo",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":736,
-                 "x":256,
-                 "y":480
-                }],
-         "opacity":1,
-         "type":"objectgroup",
-         "visible":true,
-         "width":25,
-         "x":0,
-         "y":0
-        }, 
-        {
-         "draworder":"topdown",
-         "height":26,
-         "name":"help",
-         "objects":[
-                {
-                 "gid":3,
-                 "height":715.669407858419,
-                 "id":26,
-                 "name":"",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":745.251573276788,
-                 "x":237.507948400548,
-                 "y":739.425850721188
-                }],
-         "opacity":1,
-         "type":"objectgroup",
-         "visible":false,
-         "width":38,
-         "x":0,
-         "y":0
-        }, 
-        {
-         "draworder":"topdown",
-         "height":38,
-         "name":"buttons",
-         "objects":[
-                {
-                 "gid":2,
-                 "height":85.3333333333333,
-                 "id":2,
-                 "name":"start",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":256,
-                 "x":485,
-                 "y":655.333333333333
-                }, 
-                {
-                 "gid":1,
-                 "height":64,
-                 "id":3,
-                 "name":"help",
-                 "rotation":0,
-                 "type":"",
-                 "visible":true,
-                 "width":192,
-                 "x":515.599635905335,
-                 "y":761.206553703963
-                }],
-         "opacity":1,
-         "type":"objectgroup",
-         "visible":true,
-         "width":26,
-         "x":0,
-         "y":0
-        }],
- "nextobjectid":38,
- "orientation":"orthogonal",
- "renderorder":"right-down",
- "tileheight":32,
- "tilesets":[
-        {
-         "columns":0,
-         "firstgid":1,
-         "margin":0,
-         "name":"ui",
-         "spacing":0,
-         "tilecount":7,
-         "tileheight":832,
-         "tiles":
-            {
-             "0":
-                {
-                 "image":"buttonHelp.png"
-                },
-             "1":
-                {
-                 "image":"buttonStart.png"
-                },
-             "2":
-                {
-                 "image":"helpBackground.png"
-                },
-             "3":
-                {
-                 "image":"title.png"
-                },
-             "5":
-                {
-                 "image":"backgroundSet.png"
-                },
-             "6":
-                {
-                 "image":"block.png"
-                },
-             "7":
-                {
-                 "image":"cloud.png"
-                }
-            },
-         "tilewidth":1232
-        }],
- "tilewidth":32,
- "version":1,
- "width":38
-}
\ No newline at end of file
diff --git a/demo/resource/assets/title.png b/demo/resource/assets/title.png
deleted file mode 100644
index 8a6f161a..00000000
Binary files a/demo/resource/assets/title.png and /dev/null differ
diff --git a/demo/resource/config/description.json b/demo/resource/config/description.json
deleted file mode 100644
index 9f06a30e..00000000
--- a/demo/resource/config/description.json
+++ /dev/null
@@ -1,5 +0,0 @@
-[
-    "<font color=0x00ff0c>Open-source</font>,<font color=0x00ff0c>Free</font>,<font color=0x00ff0c>Multi-platform</font>",
-    "Push <font color=0x00ff0c>Game </font>Forward",
-    "<font color=0x00ff0c>HTML5 </font>Game Engine"
-]
\ No newline at end of file
diff --git a/demo/resource/default.res.json b/demo/resource/default.res.json
index fd053281..a694d201 100644
--- a/demo/resource/default.res.json
+++ b/demo/resource/default.res.json
@@ -1,165 +1,72 @@
 {
 	"groups": [
 		{
-			"keys": "checkbox_select_disabled_png,checkbox_select_down_png,checkbox_select_up_png,checkbox_unselect_png,selected_png,border_png,header_png,radiobutton_select_disabled_png,radiobutton_select_down_png,radiobutton_select_up_png,radiobutton_unselect_png,roundthumb_png,thumb_png,track_png,tracklight_png,handle_png,off_png,on_png,button_down_png,button_up_png,thumb_pb_png,track_pb_png,track_sb_png,bg_jpg,egret_icon_png,description_json,isometric_grass_and_water_json,orthogonal-outside_json,title_json",
+			"keys": "bg_png,bgNorm_png,moon_png,orange_png,moonNorm_png,orangeNorm_png,orthogonal-outside_json",
 			"name": "preload"
+		},
+		{
+			"keys": "loading",
+			"name": "loading"
+		},
+		{
+			"keys": "sc",
+			"name": "sc"
+		},
+		{
+			"keys": "common",
+			"name": "common"
 		}
 	],
 	"resources": [
 		{
-			"url": "assets/CheckBox/checkbox_select_disabled.png",
+			"url": "fgui/loading.fui",
+			"type": "bin",
+			"name": "loading"
+		},
+		{
+			"url": "preload/bg.png",
 			"type": "image",
-			"name": "checkbox_select_disabled_png"
+			"name": "bg_png"
 		},
 		{
-			"url": "assets/CheckBox/checkbox_select_down.png",
+			"url": "preload/bgNorm.png",
 			"type": "image",
-			"name": "checkbox_select_down_png"
+			"name": "bgNorm_png"
 		},
 		{
-			"url": "assets/CheckBox/checkbox_select_up.png",
+			"url": "preload/moon.png",
 			"type": "image",
-			"name": "checkbox_select_up_png"
+			"name": "moon_png"
 		},
 		{
-			"url": "assets/CheckBox/checkbox_unselect.png",
+			"url": "preload/orange.png",
 			"type": "image",
-			"name": "checkbox_unselect_png"
+			"name": "orange_png"
 		},
 		{
-			"url": "assets/ItemRenderer/selected.png",
+			"url": "preload/moonNorm.png",
 			"type": "image",
-			"name": "selected_png"
+			"name": "moonNorm_png"
 		},
 		{
-			"url": "assets/Panel/border.png",
+			"url": "preload/orangeNorm.png",
 			"type": "image",
-			"name": "border_png"
+			"name": "orangeNorm_png"
 		},
 		{
-			"url": "assets/Panel/header.png",
-			"type": "image",
-			"name": "header_png"
+			"url": "fgui/sc.fui",
+			"type": "bin",
+			"name": "sc"
 		},
 		{
-			"url": "assets/RadioButton/radiobutton_select_disabled.png",
-			"type": "image",
-			"name": "radiobutton_select_disabled_png"
+			"url": "fgui/common.fui",
+			"type": "bin",
+			"name": "common"
 		},
 		{
-			"url": "assets/RadioButton/radiobutton_select_down.png",
-			"type": "image",
-			"name": "radiobutton_select_down_png"
-		},
-		{
-			"url": "assets/RadioButton/radiobutton_select_up.png",
-			"type": "image",
-			"name": "radiobutton_select_up_png"
-		},
-		{
-			"url": "assets/RadioButton/radiobutton_unselect.png",
-			"type": "image",
-			"name": "radiobutton_unselect_png"
-		},
-		{
-			"url": "assets/ScrollBar/roundthumb.png",
-			"type": "image",
-			"name": "roundthumb_png"
-		},
-		{
-			"url": "assets/Slider/thumb.png",
-			"type": "image",
-			"name": "thumb_png"
-		},
-		{
-			"url": "assets/Slider/track.png",
-			"type": "image",
-			"name": "track_png"
-		},
-		{
-			"url": "assets/Slider/tracklight.png",
-			"type": "image",
-			"name": "tracklight_png"
-		},
-		{
-			"url": "assets/ToggleSwitch/handle.png",
-			"type": "image",
-			"name": "handle_png"
-		},
-		{
-			"url": "assets/ToggleSwitch/off.png",
-			"type": "image",
-			"name": "off_png"
-		},
-		{
-			"url": "assets/ToggleSwitch/on.png",
-			"type": "image",
-			"name": "on_png"
-		},
-		{
-			"url": "assets/Button/button_down.png",
-			"type": "image",
-			"name": "button_down_png"
-		},
-		{
-			"url": "assets/Button/button_up.png",
-			"type": "image",
-			"name": "button_up_png"
-		},
-		{
-			"url": "assets/ProgressBar/thumb_pb.png",
-			"type": "image",
-			"name": "thumb_pb_png"
-		},
-		{
-			"url": "assets/ProgressBar/track_pb.png",
-			"type": "image",
-			"name": "track_pb_png"
-		},
-		{
-			"url": "assets/ScrollBar/track_sb.png",
-			"type": "image",
-			"name": "track_sb_png"
-		},
-		{
-			"url": "assets/bg.jpg",
-			"type": "image",
-			"name": "bg_jpg"
-		},
-		{
-			"url": "assets/egret_icon.png",
-			"type": "image",
-			"name": "egret_icon_png"
-		},
-		{
-			"url": "config/description.json",
-			"type": "json",
-			"name": "description_json"
-		},
-		{
-			"url": "assets/isometric_grass_and_water.json",
-			"type": "json",
-			"name": "isometric_grass_and_water_json"
-		},
-		{
-			"url": "assets/isometric_grass_and_water.png",
-			"type": "image",
-			"name": "isometric_grass_and_water_png"
-		},
-		{
-			"url": "assets/000010000.img.json",
-			"type": "json",
-			"name": "000010000.img_json"
-		},
-		{
-			"url": "assets/orthogonal-outside.json",
+			"url": "preload/orthogonal-outside.json",
 			"type": "json",
 			"name": "orthogonal-outside_json"
-		},
-		{
-			"url": "assets/title.json",
-			"type": "json",
-			"name": "title_json"
 		}
 	]
 }
\ No newline at end of file
diff --git a/demo/resource/eui_skins/ButtonSkin.exml b/demo/resource/eui_skins/ButtonSkin.exml
deleted file mode 100644
index d4b4b2f6..00000000
--- a/demo/resource/eui_skins/ButtonSkin.exml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<e:Skin class="skins.ButtonSkin" states="up,down,disabled" minHeight="50" minWidth="100" xmlns:e="http://ns.egret.com/eui">
-    <e:Image width="100%" height="100%" scale9Grid="1,3,8,8" alpha.disabled="0.5"
-             source="button_up_png"
-             source.down="button_down_png"/>
-    <e:Label id="labelDisplay" top="8" bottom="8" left="8" right="8"
-             size="20"
-             textColor="0xFFFFFF" verticalAlign="middle" textAlign="center"/>
-    <e:Image id="iconDisplay" horizontalCenter="0" verticalCenter="0"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/CheckBoxSkin.exml b/demo/resource/eui_skins/CheckBoxSkin.exml
deleted file mode 100644
index 1d640094..00000000
--- a/demo/resource/eui_skins/CheckBoxSkin.exml
+++ /dev/null
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.CheckBoxSkin" states="up,down,disabled,upAndSelected,downAndSelected,disabledAndSelected" xmlns:e="http://ns.egret.com/eui">
-    <e:Group width="100%" height="100%">
-        <e:layout>
-            <e:HorizontalLayout verticalAlign="middle"/>
-        </e:layout>
-        <e:Image fillMode="scale" alpha="1" alpha.disabled="0.5" alpha.down="0.7"
-                 source="checkbox_unselect_png"
-                 source.upAndSelected="checkbox_select_up_png"
-                 source.downAndSelected="checkbox_select_down_png"
-                 source.disabledAndSelected="checkbox_select_disabled_png"/>
-        <e:Label id="labelDisplay" size="20" textColor="0x707070"
-                 textAlign="center" verticalAlign="middle"
-                 fontFamily="Tahoma"/>
-    </e:Group>
-</e:Skin>
diff --git a/demo/resource/eui_skins/HScrollBarSkin.exml b/demo/resource/eui_skins/HScrollBarSkin.exml
deleted file mode 100644
index 5321570b..00000000
--- a/demo/resource/eui_skins/HScrollBarSkin.exml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.HScrollBarSkin" minWidth="20" minHeight="8" xmlns:e="http://ns.egret.com/eui">
-    <e:Image id="thumb" source="roundthumb_png" scale9Grid="3,3,2,2" height="8" width="30" verticalCenter="0"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/HSliderSkin.exml b/demo/resource/eui_skins/HSliderSkin.exml
deleted file mode 100644
index d25c5b58..00000000
--- a/demo/resource/eui_skins/HSliderSkin.exml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.HSliderSkin" minWidth="20" minHeight="8" xmlns:e="http://ns.egret.com/eui">
-    <e:Image id="track" source="track_sb_png" scale9Grid="1,1,4,4" width="100%"
-             height="6" verticalCenter="0"/>
-    <e:Image id="thumb" source="thumb_png" verticalCenter="0"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/ItemRendererSkin.exml b/demo/resource/eui_skins/ItemRendererSkin.exml
deleted file mode 100644
index 8ec85be8..00000000
--- a/demo/resource/eui_skins/ItemRendererSkin.exml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<e:Skin class="skins.ItemRendererSkin" states="up,down,disabled" minHeight="50" minWidth="100" xmlns:e="http://ns.egret.com/eui">
-    <e:Image width="100%" height="100%" scale9Grid="1,3,8,8" alpha.disabled="0.5"
-             source="button_up_png"
-             source.down="button_down_png"/>
-    <e:Label id="labelDisplay" top="8" bottom="8" left="8" right="8"
-             size="20" fontFamily="Tahoma"
-             textColor="0xFFFFFF" text="{data}" verticalAlign="middle" textAlign="center"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/PanelSkin.exml b/demo/resource/eui_skins/PanelSkin.exml
deleted file mode 100644
index 9b176f5b..00000000
--- a/demo/resource/eui_skins/PanelSkin.exml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.PanelSkin" minHeight="230" minWidth="450" xmlns:e="http://ns.egret.com/eui">
-    <e:Image left="0" right="0" bottom="0"  top="0" source="border_png" scale9Grid="2,2,12,12" />
-    <e:Group id="moveArea" left="0" right="0" top="0" height="45">
-        <e:Image left="0" right="0" bottom="0"  top="0" source="header_png"/>
-        <e:Label id="titleDisplay" size="20" fontFamily="Tahoma" textColor="0xFFFFFF"
-                 wordWrap="false" left="15" right="5" verticalCenter="0"/>
-    </e:Group>
-    <e:Button id="closeButton" label="close" bottom="5" horizontalCenter="0"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/ProgressBarSkin.exml b/demo/resource/eui_skins/ProgressBarSkin.exml
deleted file mode 100644
index 0be17fb3..00000000
--- a/demo/resource/eui_skins/ProgressBarSkin.exml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.ProgressBarSkin" minWidth="30" minHeight="18" xmlns:e="http://ns.egret.com/eui">
-	<e:Image source="track_pb_png" scale9Grid="1,1,4,4" width="100%"
-			 height="100%" verticalCenter="0"/>
-	<e:Image id="thumb" height="100%" width="100%" source="thumb_pb_png"/>
-	<e:Label id="labelDisplay" textAlign="center" verticalAlign="middle"
-			 size="15" fontFamily="Tahoma" textColor="0x707070"
-			 horizontalCenter="0" verticalCenter="0"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/RadioButtonSkin.exml b/demo/resource/eui_skins/RadioButtonSkin.exml
deleted file mode 100644
index 15aa6395..00000000
--- a/demo/resource/eui_skins/RadioButtonSkin.exml
+++ /dev/null
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.RadioButtonSkin" states="up,down,disabled,upAndSelected,downAndSelected,disabledAndSelected" xmlns:e="http://ns.egret.com/eui">
-    <e:Group width="100%" height="100%">
-        <e:layout>
-            <e:HorizontalLayout verticalAlign="middle"/>
-        </e:layout>
-        <e:Image fillMode="scale" alpha="1" alpha.disabled="0.5" alpha.down="0.7"
-                 source="radiobutton_unselect_png"
-                 source.upAndSelected="radiobutton_select_up_png"
-                 source.downAndSelected="radiobutton_select_down_png"
-                 source.disabledAndSelected="radiobutton_select_disabled_png"/>
-        <e:Label id="labelDisplay" size="20" textColor="0x707070"
-                 textAlign="center" verticalAlign="middle"
-                 fontFamily="Tahoma"/>
-    </e:Group>
-</e:Skin>
diff --git a/demo/resource/eui_skins/ScrollerSkin.exml b/demo/resource/eui_skins/ScrollerSkin.exml
deleted file mode 100644
index 1473f8e9..00000000
--- a/demo/resource/eui_skins/ScrollerSkin.exml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.ScrollerSkin" minWidth="20" minHeight="20" xmlns:e="http://ns.egret.com/eui">
-    <e:HScrollBar id="horizontalScrollBar" width="100%" bottom="0"/>
-    <e:VScrollBar id="verticalScrollBar" height="100%" right="0"/>
-</e:Skin>
\ No newline at end of file
diff --git a/demo/resource/eui_skins/TextInputSkin.exml b/demo/resource/eui_skins/TextInputSkin.exml
deleted file mode 100644
index b6efb8ab..00000000
--- a/demo/resource/eui_skins/TextInputSkin.exml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<e:Skin class="skins.TextInputSkin" minHeight="40" minWidth="300" states="normal,disabled,normalWithPrompt,disabledWithPrompt" xmlns:e="http://ns.egret.com/eui">
-	<e:Image width="100%" height="100%" scale9Grid="1,3,8,8" source="button_up_png"/>
-	<e:Rect height="100%" width="100%" fillColor="0xffffff"/>
- 	<e:EditableText id="textDisplay" verticalCenter="0" left="10" right="10"
-	                textColor="0x000000" textColor.disabled="0xff0000" width="100%" height="24" size="20" />
-	<e:Label id="promptDisplay" verticalCenter="0" left="10" right="10"
-	                textColor="0xa9a9a9" width="100%" height="24" size="20" touchEnabled="false" includeIn="normalWithPrompt,disabledWithPrompt"/>
-</e:Skin>
\ No newline at end of file
diff --git a/demo/resource/eui_skins/ToggleSwitchSkin.exml b/demo/resource/eui_skins/ToggleSwitchSkin.exml
deleted file mode 100644
index 6b5f9c0e..00000000
--- a/demo/resource/eui_skins/ToggleSwitchSkin.exml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.ToggleSwitchSkin" states="up,down,disabled,upAndSelected,downAndSelected,disabledAndSelected" xmlns:e="http://ns.egret.com/eui">
-    <e:Image source="on_png"
-             source.up="off_png"
-             source.down="off_png"
-             source.disabled="off_png"/>
-    <e:Image source="handle_png"
-             horizontalCenter="-18"
-             horizontalCenter.upAndSelected="18"
-             horizontalCenter.downAndSelected="18"
-             horizontalCenter.disabledAndSelected="18"
-             verticalCenter="0"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/VScrollBarSkin.exml b/demo/resource/eui_skins/VScrollBarSkin.exml
deleted file mode 100644
index d548c9c5..00000000
--- a/demo/resource/eui_skins/VScrollBarSkin.exml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.VScrollBarSkin" minWidth="8" minHeight="20" xmlns:e="http://ns.egret.com/eui">
-    <e:Image id="thumb" source="roundthumb_png" scale9Grid="3,3,2,2" height="30" width="8" horizontalCenter="0"/>
-</e:Skin>
diff --git a/demo/resource/eui_skins/VSliderSkin.exml b/demo/resource/eui_skins/VSliderSkin.exml
deleted file mode 100644
index 19a3de51..00000000
--- a/demo/resource/eui_skins/VSliderSkin.exml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="skins.VSliderSkin" minWidth="25" minHeight="30" xmlns:e="http://ns.egret.com/eui">
-    <e:Image id="track" source="track_png" scale9Grid="1,1,4,4" width="7" height="100%" horizontalCenter="0"/>
-    <e:Image id="thumb" source="thumb_png" horizontalCenter="0" />
-</e:Skin>
diff --git a/demo/resource/fgui/common.fui b/demo/resource/fgui/common.fui
new file mode 100644
index 00000000..6bade6c9
Binary files /dev/null and b/demo/resource/fgui/common.fui differ
diff --git a/demo/resource/fgui/loading.fui b/demo/resource/fgui/loading.fui
new file mode 100644
index 00000000..81ebc4d1
Binary files /dev/null and b/demo/resource/fgui/loading.fui differ
diff --git a/demo/resource/fgui/sc.fui b/demo/resource/fgui/sc.fui
new file mode 100644
index 00000000..5bdce279
Binary files /dev/null and b/demo/resource/fgui/sc.fui differ
diff --git a/demo/resource/preload/bg.png b/demo/resource/preload/bg.png
new file mode 100644
index 00000000..94c21fe9
Binary files /dev/null and b/demo/resource/preload/bg.png differ
diff --git a/demo/resource/preload/bgNorm.png b/demo/resource/preload/bgNorm.png
new file mode 100644
index 00000000..759b0955
Binary files /dev/null and b/demo/resource/preload/bgNorm.png differ
diff --git a/demo/resource/preload/moon.png b/demo/resource/preload/moon.png
new file mode 100644
index 00000000..5d215867
Binary files /dev/null and b/demo/resource/preload/moon.png differ
diff --git a/demo/resource/preload/moonNorm.png b/demo/resource/preload/moonNorm.png
new file mode 100644
index 00000000..b054a3fe
Binary files /dev/null and b/demo/resource/preload/moonNorm.png differ
diff --git a/demo/resource/preload/orange.png b/demo/resource/preload/orange.png
new file mode 100644
index 00000000..fca8c904
Binary files /dev/null and b/demo/resource/preload/orange.png differ
diff --git a/demo/resource/preload/orangeNorm.png b/demo/resource/preload/orangeNorm.png
new file mode 100644
index 00000000..bcc6f0ca
Binary files /dev/null and b/demo/resource/preload/orangeNorm.png differ
diff --git a/demo/resource/assets/orthogonal-outside.json b/demo/resource/preload/orthogonal-outside.json
similarity index 100%
rename from demo/resource/assets/orthogonal-outside.json
rename to demo/resource/preload/orthogonal-outside.json
diff --git a/demo/src/Fgui/common/UI_com_tips.ts b/demo/src/Fgui/common/UI_com_tips.ts
new file mode 100644
index 00000000..959bf25e
--- /dev/null
+++ b/demo/src/Fgui/common/UI_com_tips.ts
@@ -0,0 +1,19 @@
+/** This is an automatically generated class by FairyGUI. Please do not modify it. **/
+
+module FUI.common {
+
+	export class UI_com_tips extends fairygui.GComponent {
+		public m_content:fairygui.GTextField;
+		public static URL:string = "ui://minsdstak7mf0";
+
+		public static createInstance():UI_com_tips {
+			return <UI_com_tips>(fairygui.UIPackage.createObject("common", "com_tips"));
+		}
+
+		protected constructFromXML(xml:any):void {
+			super.constructFromXML(xml);
+
+			this.m_content = <fairygui.GTextField>(this.getChildAt(1));
+		}
+	}
+}
\ No newline at end of file
diff --git a/demo/src/Fgui/common/commonBinder.ts b/demo/src/Fgui/common/commonBinder.ts
new file mode 100644
index 00000000..1c05d82d
--- /dev/null
+++ b/demo/src/Fgui/common/commonBinder.ts
@@ -0,0 +1,10 @@
+/** This is an automatically generated class by FairyGUI. Please do not modify it. **/
+
+module FUI.common {
+
+	export class commonBinder {
+		public static bindAll():void {
+			fairygui.UIObjectFactory.setPackageItemExtension(UI_com_tips.URL, UI_com_tips);
+		}
+	}
+}
\ No newline at end of file
diff --git a/demo/src/Fgui/loading/UI_View_loading.ts b/demo/src/Fgui/loading/UI_View_loading.ts
new file mode 100644
index 00000000..4d07a886
--- /dev/null
+++ b/demo/src/Fgui/loading/UI_View_loading.ts
@@ -0,0 +1,21 @@
+/** This is an automatically generated class by FairyGUI. Please do not modify it. **/
+
+module FUI.loading {
+
+	export class UI_View_loading extends fairygui.GComponent {
+		public m_title:fairygui.GTextField;
+		public m_pg_loading:fairygui.GProgressBar;
+		public static URL:string = "ui://mk2d64e7r5ro0";
+
+		public static createInstance():UI_View_loading {
+			return <UI_View_loading>(fairygui.UIPackage.createObject("loading", "View_loading"));
+		}
+
+		protected constructFromXML(xml:any):void {
+			super.constructFromXML(xml);
+
+			this.m_title = <fairygui.GTextField>(this.getChildAt(1));
+			this.m_pg_loading = <fairygui.GProgressBar>(this.getChildAt(2));
+		}
+	}
+}
\ No newline at end of file
diff --git a/demo/src/Fgui/loading/loadingBinder.ts b/demo/src/Fgui/loading/loadingBinder.ts
new file mode 100644
index 00000000..d299cf33
--- /dev/null
+++ b/demo/src/Fgui/loading/loadingBinder.ts
@@ -0,0 +1,10 @@
+/** This is an automatically generated class by FairyGUI. Please do not modify it. **/
+
+module FUI.loading {
+
+	export class loadingBinder {
+		public static bindAll():void {
+			fairygui.UIObjectFactory.setPackageItemExtension(UI_View_loading.URL, UI_View_loading);
+		}
+	}
+}
\ No newline at end of file
diff --git a/demo/src/Fgui/sc/UI_View_sc.ts b/demo/src/Fgui/sc/UI_View_sc.ts
new file mode 100644
index 00000000..d31be2d5
--- /dev/null
+++ b/demo/src/Fgui/sc/UI_View_sc.ts
@@ -0,0 +1,19 @@
+/** This is an automatically generated class by FairyGUI. Please do not modify it. **/
+
+module FUI.sc {
+
+	export class UI_View_sc extends fairygui.GComponent {
+		public m_list_sc:fairygui.GList;
+		public static URL:string = "ui://m4sln17ak7mf0";
+
+		public static createInstance():UI_View_sc {
+			return <UI_View_sc>(fairygui.UIPackage.createObject("sc", "View_sc"));
+		}
+
+		protected constructFromXML(xml:any):void {
+			super.constructFromXML(xml);
+
+			this.m_list_sc = <fairygui.GList>(this.getChildAt(0));
+		}
+	}
+}
\ No newline at end of file
diff --git a/demo/src/Fgui/sc/UI_btn_sc.ts b/demo/src/Fgui/sc/UI_btn_sc.ts
new file mode 100644
index 00000000..5a9e042f
--- /dev/null
+++ b/demo/src/Fgui/sc/UI_btn_sc.ts
@@ -0,0 +1,19 @@
+/** This is an automatically generated class by FairyGUI. Please do not modify it. **/
+
+module FUI.sc {
+
+	export class UI_btn_sc extends fairygui.GButton {
+		public m_name:fairygui.GTextField;
+		public static URL:string = "ui://m4sln17ak7mf2";
+
+		public static createInstance():UI_btn_sc {
+			return <UI_btn_sc>(fairygui.UIPackage.createObject("sc", "btn_sc"));
+		}
+
+		protected constructFromXML(xml:any):void {
+			super.constructFromXML(xml);
+
+			this.m_name = <fairygui.GTextField>(this.getChildAt(3));
+		}
+	}
+}
\ No newline at end of file
diff --git a/demo/src/Fgui/sc/scBinder.ts b/demo/src/Fgui/sc/scBinder.ts
new file mode 100644
index 00000000..58af4c70
--- /dev/null
+++ b/demo/src/Fgui/sc/scBinder.ts
@@ -0,0 +1,11 @@
+/** This is an automatically generated class by FairyGUI. Please do not modify it. **/
+
+module FUI.sc {
+
+	export class scBinder {
+		public static bindAll():void {
+			fairygui.UIObjectFactory.setPackageItemExtension(UI_View_sc.URL, UI_View_sc);
+			fairygui.UIObjectFactory.setPackageItemExtension(UI_btn_sc.URL, UI_btn_sc);
+		}
+	}
+}
\ No newline at end of file
diff --git a/demo/src/LoadingUI.ts b/demo/src/LoadingUI.ts
deleted file mode 100644
index e6110461..00000000
--- a/demo/src/LoadingUI.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (c) 2014-present, Egret Technology.
-//  All rights reserved.
-//  Redistribution and use in source and binary forms, with or without
-//  modification, are permitted provided that the following conditions are met:
-//
-//     * Redistributions of source code must retain the above copyright
-//       notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above copyright
-//       notice, this list of conditions and the following disclaimer in the
-//       documentation and/or other materials provided with the distribution.
-//     * Neither the name of the Egret nor the
-//       names of its contributors may be used to endorse or promote products
-//       derived from this software without specific prior written permission.
-//
-//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
-//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
-//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-//////////////////////////////////////////////////////////////////////////////////////
-
-class LoadingUI extends egret.Sprite implements RES.PromiseTaskReporter {
-
-    public constructor() {
-        super();
-        this.createView();
-    }
-
-    private textField: egret.TextField;
-
-    private createView(): void {
-        this.textField = new egret.TextField();
-        this.addChild(this.textField);
-        this.textField.y = 300;
-        this.textField.width = 480;
-        this.textField.height = 100;
-        this.textField.textAlign = "center";
-    }
-
-    public onProgress(current: number, total: number): void {
-        this.textField.text = `Loading...${current}/${total}`;
-    }
-}
diff --git a/demo/src/Main.ts b/demo/src/Main.ts
index 0ac8bbb8..dd14b905 100644
--- a/demo/src/Main.ts
+++ b/demo/src/Main.ts
@@ -27,36 +27,42 @@
 //
 //////////////////////////////////////////////////////////////////////////////////////
 
+import LoadingView = loading.LoadingView;
+
 class Main extends es.Core {
     protected initialize() {
-        this.runGame();
+        try {
+            this.runGame();
+        } catch(err) {
+            console.error(err);
+        }
     }
 
     private runGame() {
+        egret.ImageLoader.crossOrigin = "anonymous";
+        this.initUIConfig();
         this.loadResource();
+        this.initGameControl();
     }
 
+    private initUIConfig(){
+        LayerManager.getInstance().init(this.stage);
+        FguiUtils.packageNamespace = FUI;
+        fairygui.UIConfig.defaultFont = "黑体";
+        fairygui.UIConfig.bringWindowToFrontOnClick = false;
+        this.stage.addChild(fgui.GRoot.inst.displayListContainer);
+    }
 
     private loadResource() {
-        const loadingView = new LoadingUI();
-        this.stage.addChild(loadingView);
         RES.loadConfig("resource/default.res.json", "resource/").then(()=>{
-            RES.loadGroup("preload", 0, loadingView).then(()=>{
-                this.stage.removeChild(loadingView);
-                this.createGameScene();
-            }).catch(err => {
-                console.error(err);
-            });
+            EventManager.getInstance().dispatch(loading.LoadingEvents.OPENVIEW);
         }).catch(err =>{
             console.error(err);
         });
     }
 
-    /**
-     * 创建场景界面
-     * Create scene interface
-     */
-    protected createGameScene(): void {
-        es.Core.scene = new scene.MainScene();
+    private initGameControl(){
+        loading.LoadingControl.getInstance();
+        sc.ScControl.getInstance();
     }
 }
diff --git a/demo/src/SampleHelpers/SampleScene.ts b/demo/src/SampleHelpers/SampleScene.ts
new file mode 100644
index 00000000..c682144e
--- /dev/null
+++ b/demo/src/SampleHelpers/SampleScene.ts
@@ -0,0 +1,35 @@
+module samples {
+    import ScreenSpaceRenderer = es.ScreenSpaceRenderer;
+    import RenderLayerExcludeRenderer = es.RenderLayerExcludeRenderer;
+    import SpriteRenderer = es.SpriteRenderer;
+
+    export class SampleScene extends es.Scene {
+        public static readonly screenSpaceRenderLayer = 999;
+        public canvas: SpriteRenderer;
+
+        public static _needsFullRender: boolean;
+        public _screenSpaceRenderer: ScreenSpaceRenderer;
+
+        constructor(addExcludeRenderer: boolean = true, needsFullRender: boolean = false){
+            super();
+            SampleScene._needsFullRender = needsFullRender;
+
+            if (needsFullRender){
+                this._screenSpaceRenderer = this.addRenderer(new ScreenSpaceRenderer(100, SampleScene.screenSpaceRenderLayer));
+                this._screenSpaceRenderer.shouldDebugRender = false;
+            }else{
+                this.addRenderer(new ScreenSpaceRenderer(100, SampleScene.screenSpaceRenderLayer));
+            }
+
+            if (addExcludeRenderer)
+                this.addRenderer(new RenderLayerExcludeRenderer(0, SampleScene.screenSpaceRenderLayer));
+
+            this.canvas = this.createEntity("ui").addComponent(new SpriteRenderer());
+            this.canvas.renderLayer = SampleScene.screenSpaceRenderLayer;
+            this.setupSceneSelector();
+        }
+
+        public setupSceneSelector(){
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/Scenes/Animated Tiles/AnimatedTilesScene.ts b/demo/src/Scenes/Animated Tiles/AnimatedTilesScene.ts
new file mode 100644
index 00000000..4ff250ae
--- /dev/null
+++ b/demo/src/Scenes/Animated Tiles/AnimatedTilesScene.ts	
@@ -0,0 +1,21 @@
+module samples {
+    export class AnimatedTilesScene extends SampleScene {
+        constructor(){
+            super(true, true);
+        }
+
+        public initialize(){
+            super.initialize();
+
+            let tiledEntity = this.createEntity("tiled-map-entity");
+            try {
+                es.TiledMapLoader.loadTmxMap(new es.TmxMap(), "orthogonal-outside_json").then(map => {
+                    tiledEntity.addComponent(new es.TiledMapRenderer(map));
+                    manager.AlterManager.alter_tips("Tiled tiles场景加载成功");
+                });
+            } catch (err){
+                console.error(err);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/Scenes/Empty Scene/BasicScene.ts b/demo/src/Scenes/Empty Scene/BasicScene.ts
new file mode 100644
index 00000000..79d28db7
--- /dev/null
+++ b/demo/src/Scenes/Empty Scene/BasicScene.ts	
@@ -0,0 +1,8 @@
+module samples {
+    export class BasicScene extends SampleScene {
+        public async onStart() {
+            super.onStart();
+            manager.AlterManager.alter_tips("空白场景加载成功");
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/PopManager.ts b/demo/src/UI/PopManager.ts
new file mode 100644
index 00000000..b8730706
--- /dev/null
+++ b/demo/src/UI/PopManager.ts
@@ -0,0 +1,25 @@
+module manager {
+    export class AlterManager {
+        public static alter_tips(txt: string){
+            let item_tip = FUI.common.UI_com_tips.createInstance();
+            if (!item_tip)
+                return;
+            item_tip.m_content.text = txt;
+            item_tip.ensureBoundsCorrect();
+            item_tip.x = es.Core.Instance.stage.stageWidth / 2 - item_tip.width / 2;
+            item_tip.y = es.Core.Instance.stage.stageHeight / 2 - item_tip.height / 2;
+            LayerManager.getInstance().tipsLayer.addChild(item_tip.displayObject);
+
+            item_tip.alpha = 0;
+            let originY = item_tip.y;
+            egret.Tween.get(item_tip).to({alpha: 1, y: originY - 100}, 700, egret.Ease.cubicInOut).wait(1000)
+                .to({alpha: 0, y: originY - 200}, 700, egret.Ease.cubicInOut).call(()=>{
+                    egret.Tween.removeTweens(item_tip.displayObject);
+                    if (item_tip.displayObject && item_tip.displayObject.parent)
+                        item_tip.displayObject.parent.removeChild(item_tip.displayObject);
+                    item_tip.dispose();
+                    item_tip = null;
+                });
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/loading/LoadingControl.ts b/demo/src/UI/loading/LoadingControl.ts
new file mode 100644
index 00000000..e19f1726
--- /dev/null
+++ b/demo/src/UI/loading/LoadingControl.ts
@@ -0,0 +1,27 @@
+module loading {
+    export class LoadingControl {
+        private _eventManager: EventManager;
+        private _viewManager: ViewManager;
+        private static single: LoadingControl;
+        public static getInstance(){
+            if (!this.single) this.single = new LoadingControl();
+            
+            return this.single;
+        }
+        
+        constructor(){
+            this.addEvents();
+        }
+        
+        private addEvents(){
+            this._eventManager = EventManager.getInstance();
+            this._viewManager = ViewManager.getInstance();
+            // 事件监听
+            this._eventManager.addListener(LoadingEvents.OPENVIEW, this.openView, this);
+        }
+        
+        private openView(){
+            this._viewManager.openView(LoadingView);
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/loading/LoadingEvents.ts b/demo/src/UI/loading/LoadingEvents.ts
new file mode 100644
index 00000000..7c7b9776
--- /dev/null
+++ b/demo/src/UI/loading/LoadingEvents.ts
@@ -0,0 +1,5 @@
+module loading {
+    export module LoadingEvents {
+        export const OPENVIEW = Symbol();
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/loading/LoadingView.ts b/demo/src/UI/loading/LoadingView.ts
new file mode 100644
index 00000000..8c047279
--- /dev/null
+++ b/demo/src/UI/loading/LoadingView.ts
@@ -0,0 +1,59 @@
+module loading {
+    import commonBinder = FUI.common.commonBinder;
+    import ResourceInfo = RES.ResourceInfo;
+
+    export class LoadingView extends BaseView implements RES.PromiseTaskReporter {
+        private _ui: FUI.loading.UI_View_loading;
+        private _loadGroup = ["preload", "common"];
+        private _maxProgress = 0;
+        private _currentProgress = 0;
+
+        constructor() {
+            super("loading");
+        }
+
+        public init() {
+            this._ui = this._fuiView = FUI.loading.UI_View_loading.createInstance();
+            this.addChild(this._ui.displayObject);
+            super.init();
+        }
+
+        public async show() {
+            this._ui.m_pg_loading.value = 0;
+            for (let i = 0; i < this._loadGroup.length; i ++){
+                this._maxProgress += RES.getGroupByName(this._loadGroup[i]).length;
+            }
+            this._ui.m_pg_loading.max = this._maxProgress;
+            for (let i = 0; i < this._loadGroup.length; i ++){
+                await RES.loadGroup(this._loadGroup[i], 0, this);
+            }
+        }
+
+        public onProgress(current: number, total: number, resItem: ResourceInfo): void {
+            this._ui.m_pg_loading.tweenValue(this._currentProgress++, 1);
+            if (this._currentProgress == this._maxProgress) {
+                if (resItem.name == "common"){
+                    fairygui.UIPackage.addPackage(resItem.name);
+                    commonBinder.bindAll();
+                }
+                egret.setTimeout(() => {
+                    this.openMainScene();
+                }, this, 1000)
+            }
+        }
+
+        public openMainScene() {
+            es.Core.scene = new samples.BasicScene();
+            EventManager.getInstance().dispatch(sc.ScEvents.OPENVIEW);
+            this.close();
+        }
+
+        public destroy() {
+            if (this._ui) {
+                this._ui.dispose();
+                this._ui = null;
+            }
+            super.destroy();
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/mvc/BaseView.ts b/demo/src/UI/mvc/BaseView.ts
new file mode 100644
index 00000000..4c541442
--- /dev/null
+++ b/demo/src/UI/mvc/BaseView.ts
@@ -0,0 +1,101 @@
+class BaseView extends egret.DisplayObjectContainer {
+    private _name: string;
+    public get name(){
+        return this._name;
+    }
+    public set name(value: string){
+        this._name = value;
+    }
+    public viewLayer: viewLayer = viewLayer.pop;
+    /** 是否可以被销毁 */
+    protected _destoryChildren: boolean;
+    protected _isDispose: boolean;
+    /** fui界面 */
+    protected _fuiView: fairygui.GComponent;
+    /** 是否已经显示 */
+    protected _isShow: boolean;
+    /** 视图数据 */
+    protected _showData: any;
+
+    constructor(name?: string){
+        super();
+        this._isDispose = false;
+        if (name){
+            this.name = name;
+        }
+    }
+
+    /**
+     * 当界面被初始化时调用
+     */
+    public init(){
+        this._destoryChildren = true;
+    }
+
+    /**
+     * 当界面大小被改变时
+     */
+    public resize(){
+        if (this._fuiView && this._isShow){
+            this._fuiView.width = LayerManager.getInstance().stage.stageWidth;
+            this._fuiView.height = LayerManager.getInstance().stage.stageHeight;
+        }
+    }
+
+    /**
+     * 
+     * @param showData 
+     */
+    public baseShow(showData?: any){
+        this._isShow = true;
+        this._showData = showData;
+        egret.callLater(this.resize, this);
+    }
+
+    /**
+     * 打开界面时调用
+     */
+    public show() {
+
+    }
+
+    /**
+     * 当界面关闭时调用
+     */
+    public close() {
+        this._isShow = false;
+        ViewManager.getInstance().closeView(this);
+    }
+
+    /**
+     * 
+     * @param showData 
+     */
+    public baseRefresh(showData?: any){
+        this._showData = showData;
+    }
+
+    /**
+     * 当界面刷新时调用
+     */
+    public refresh(showData?: any){
+        this._showData = showData;
+    }    
+
+    /**
+     * 当界面销毁时调用
+     */
+    public destroy(){
+        this._isDispose = true;
+        if (this.parent)
+            this.parent.removeChild(this);
+
+        if (this._destoryChildren){
+            this._fuiView = null;
+            while (this.numChildren > 0){
+                this.removeChildAt(0);
+            }
+            this._destoryChildren = false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/mvc/EventManager.ts b/demo/src/UI/mvc/EventManager.ts
new file mode 100644
index 00000000..f6738bec
--- /dev/null
+++ b/demo/src/UI/mvc/EventManager.ts
@@ -0,0 +1,104 @@
+class EventManager {
+    private static _single: EventManager;
+    private _dict: any;
+    private _eventList: EventVo[];
+
+    public static getInstance() {
+        if (!this._single) this._single = new EventManager();
+        return this._single;
+    }
+
+    constructor() {
+        this._dict = {};
+        this._eventList = [];
+    }
+
+    /**
+     * 添加消息监听
+     * @param type 
+     * @param listener 
+     * @param thisObj 
+     */
+    public addListener(type: string | symbol, listener: Function, thisObj: any): void {
+        var arr: any[] = this._dict[type];
+        if (arr == null) {
+            arr = [];
+            this._dict[type] = arr;
+        }
+        var i: number, len: number = arr.length;
+        for (i = 0; i < len; i++) {
+            if (arr[i][0] == listener && arr[i][1] == thisObj) return;
+        }
+        arr.push([listener, thisObj]);
+    }
+
+    /**
+     * 移除监听
+     * @param type 
+     * @param listener 
+     * @param thisObj 
+     */
+    public removeListener(type: string | symbol, listener: Function, thisObj: any): void {
+        var arr: any[] = this._dict[type];
+        if (arr == null) return;
+
+        var i: number, len: number = Array.length;
+        for (i = 0; i < len; i++) {
+            if (arr[i][0] == listener && arr[i][1] == thisObj) {
+                arr.splice(i, 1);
+                i--;
+                break;
+            }
+        }
+
+        if (arr.length == 0) {
+            delete this._dict[type];
+            this._dict[type] = null;
+        }
+    }
+
+    /**
+     * 事件派发
+     * @param type 
+     * @param param 
+     */
+    public dispatch(type: string | symbol, ...param: any[]): void {
+        if (this._dict[type] == null) return;
+
+        var vo: EventVo = new EventVo();
+        vo.type = type;
+        vo.param = param;
+
+        this.dealMsg(vo);
+    }
+
+    /**
+     * 事件处理
+     * @param vo 
+     */
+    private dealMsg(vo: EventVo): void {
+        var listeners: Array<any> = this._dict[vo.type];
+        if (listeners && listeners.length > 0) {
+            var i: number = 0, len: number = listeners.length, listener: Array<any> = null;
+            while (i < len) {
+                listener = listeners[i];
+                listener[0].apply(listener[1], vo.param);
+                if (listeners.length != len) {
+                    len = listeners.length;
+                    i--;
+                }
+                i++;
+            }
+        }
+        vo.dispose();
+    }
+}
+
+class EventVo {
+    public type: string | symbol;
+    public param: any[];
+    public dispose() {
+        this.type = null;
+        this.param = null;
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/mvc/Extension.ts b/demo/src/UI/mvc/Extension.ts
new file mode 100644
index 00000000..132a61d6
--- /dev/null
+++ b/demo/src/UI/mvc/Extension.ts
@@ -0,0 +1,389 @@
+declare interface String {
+  /**
+   * 去除字符串头部空格或指定字符
+   * @param c 指定字符（字符串）
+   */
+  trimStart(c);
+  /**
+   * 去除字符串尾部空格或指定字符
+   * @param c 指定字符（字符串）
+   */
+  trimEnd(c);
+}
+
+String.prototype.trimStart = function (c) {
+  function trimStart(str, c) {
+    let regExp;
+    if (!c) {
+      regExp = new RegExp(/^\s*/);
+    } else {
+      regExp = new RegExp("^" + c);
+    }
+
+    return str.replace(regExp, "");
+  }
+
+  return trimStart(this, c);
+};
+
+String.prototype.trimEnd = function (c) {
+  function trimEnd(str, c) {
+    let regExp;
+    if (!c) {
+      regExp = new RegExp(/\s*$/);
+    } else {
+      regExp = new RegExp(c + "$");
+    }
+
+    return str.replace(regExp, "");
+  }
+
+  return trimEnd(this, c);
+};
+
+declare interface Array<T> {
+  /**
+   * 获取满足表达式的数组元素索引
+   * @param predicate 表达式
+   */
+  findIndex(predicate: Function): number;
+  /**
+   * 是否存在满足表达式的数组元素
+   * @param predicate 表达式
+   */
+  any(predicate: Function): boolean;
+  /**
+   * 获取满足表达式的第一个或默认数组元素
+   * @param predicate 表达式
+   */
+  firstOrDefault(predicate: Function): T;
+  /**
+   * 获取满足表达式的第一个数组元素
+   * @param predicate 表达式
+   */
+  find(predicate: Function): T;
+  /**
+   * 筛选满足表达式的数组元素
+   * @param predicate 表达式
+   */
+  where(predicate: Function): Array<T>;
+  /**
+   * 获取满足表达式的数组元素的计数
+   * @param predicate 表达式
+   */
+  count(predicate: Function): number;
+  /**
+   * 获取满足表达式的数组元素的数组
+   * @param predicate 表达式
+   */
+  findAll(predicate: Function): Array<T>;
+  /**
+   * 移除满足表达式的数组元素
+   * @param predicate 表达式
+   */
+  removeAll(predicate: Function): void;
+  /**
+   * 移除数组元素
+   * @param element 数组元素
+   */
+  remove(element): boolean;
+  /**
+   * 移除特定索引数组元素
+   * @param index 索引
+   */
+  removeAt(index): void;
+  /**
+   * 移除范围数组元素
+   * @param index 开始索引
+   * @param count 删除的个数
+   */
+  removeRange(index, count): void;
+  /**
+   * 获取通过选择器转换的数组
+   * @param selector 选择器
+   */
+  select(selector: Function): Array<T>;
+  /**
+   * 排序（升序）
+   * @param keySelector key选择器
+   * @param comparer 比较器
+   */
+  orderBy(keySelector: Function, comparer: Function): Array<T>;
+  /**
+   * 排序（降序）
+   * @param keySelector key选择器
+   * @param comparer 比较器
+   */
+  orderByDescending(keySelector: Function, comparer: Function): Array<T>;
+  /**
+   * 分组
+   * @param keySelector key选择器
+   */
+  groupBy(keySelector: Function): Array<T>;
+  /**
+   * 求和
+   * @param selector  选择器
+   */
+  sum(selector);
+}
+
+Array.prototype.findIndex = function (predicate) {
+  function findIndex(array, predicate) {
+    for (let i = 0, len = array.length; i < len; i++) {
+      if (predicate.call(arguments[2], array[i], i, array)) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  return findIndex(this, predicate);
+};
+
+Array.prototype.any = function (predicate) {
+  function any(array, predicate) {
+    return array.findIndex(predicate) > -1;
+  }
+
+  return any(this, predicate);
+};
+
+Array.prototype.firstOrDefault = function (predicate) {
+  function firstOrDefault(array, predicate) {
+    let index = array.findIndex(predicate);
+    return index == -1 ? null : array[index];
+  }
+
+  return firstOrDefault(this, predicate);
+};
+
+Array.prototype.find = function (predicate) {
+  function find(array, predicate) {
+    return array.firstOrDefault(predicate);
+  }
+
+  return find(this, predicate);
+};
+
+Array.prototype.where = function (predicate) {
+  function where(array, predicate) {
+    if (typeof array.reduce === "function") {
+      return array.reduce(function (ret, element, index) {
+        if (predicate.call(arguments[2], element, index, array)) {
+          ret.push(element);
+        }
+
+        return ret;
+      }, []);
+    } else {
+      let ret = [];
+      for (let i = 0, len = array.length; i < len; i++) {
+        let element = array[i];
+        if (predicate.call(arguments[2], element, i, array)) {
+          ret.push(element);
+        }
+      }
+
+      return ret;
+    }
+  }
+
+  return where(this, predicate);
+};
+
+Array.prototype.count = function (predicate) {
+  function count(array, predicate) {
+    return array.where(predicate).length;
+  }
+
+  return count(this, predicate);
+};
+
+Array.prototype.findAll = function (predicate) {
+  function findAll(array, predicate) {
+    return array.where(predicate);
+  }
+
+  return findAll(this, predicate);
+};
+
+Array.prototype.removeAll = function (predicate) {
+  function removeAll(array, predicate) {
+    let index;
+    do {
+      index = array.findIndex(predicate);
+      if (index >= 0) {
+        array.splice(index, 1);
+      }
+    } while (index >= 0);
+  }
+
+  removeAll(this, predicate);
+};
+
+Array.prototype.remove = function (element) {
+  function remove(array, element) {
+    let index = array.findIndex(function (x) {
+      return x === element;
+    });
+
+    if (index >= 0) {
+      array.splice(index, 1);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  return remove(this, element);
+};
+
+Array.prototype.removeAt = function (index) {
+  function removeAt(array, index) {
+    array.splice(index, 1);
+  }
+
+  return removeAt(this, index);
+};
+
+Array.prototype.removeRange = function (index, count) {
+  function removeRange(array, index, count) {
+    array.splice(index, count);
+  }
+
+  return removeRange(this, index, count);
+};
+
+Array.prototype.select = function (selector) {
+  function select(array, selector) {
+    if (typeof array.reduce === "function") {
+      return array.reduce(function (ret, element, index) {
+        ret.push(selector.call(arguments[2], element, index, array));
+        return ret;
+      }, []);
+    } else {
+      let ret = [];
+      for (let i = 0, len = array.length; i < len; i++) {
+        ret.push(selector.call(arguments[2], array[i], i, array));
+      }
+
+      return ret;
+    }
+  }
+
+  return select(this, selector);
+};
+
+Array.prototype.orderBy = function (keySelector, comparer) {
+  function orderBy(array, keySelector, comparer) {
+    array.sort(function (x, y) {
+      let v1 = keySelector(x);
+      let v2 = keySelector(y);
+      if (comparer) {
+        return comparer(v1, v2);
+      } else {
+        return v1 > v2 ? 1 : -1;
+      }
+    });
+
+    return array;
+  }
+
+  return orderBy(this, keySelector, comparer);
+};
+
+Array.prototype.orderByDescending = function (keySelector, comparer) {
+  function orderByDescending(array, keySelector, comparer) {
+    array.sort(function (x, y) {
+      let v1 = keySelector(x);
+      let v2 = keySelector(y);
+      if (comparer) {
+        return -comparer(v1, v2);
+      } else {
+        return v1 < v2 ? 1 : -1;
+      }
+    });
+
+    return array;
+  }
+
+  return orderByDescending(this, keySelector, comparer);
+};
+
+Array.prototype.groupBy = function (keySelector) {
+  function groupBy(array, keySelector) {
+    if (typeof array.reduce === "function") {
+      let keys = [];
+      return array.reduce(function (groups, element, index) {
+        let key = JSON.stringify(
+          keySelector.call(arguments[1], element, index, array)
+        );
+        let index2 = keys.findIndex(function (x) {
+          return x === key;
+        });
+
+        if (index2 < 0) {
+          index2 = keys.push(key) - 1;
+        }
+
+        if (!groups[index2]) {
+          groups[index2] = [];
+        }
+
+        groups[index2].push(element);
+        return groups;
+      }, []);
+    } else {
+      let groups = [];
+      let keys = [];
+      for (let i = 0, len = array.length; i < len; i++) {
+        let key = JSON.stringify(
+          keySelector.call(arguments[1], array[i], i, array)
+        );
+        let index = keys.findIndex(function (x) {
+          return x === key;
+        });
+
+        if (index < 0) {
+          index = keys.push(key) - 1;
+        }
+
+        if (!groups[index]) {
+          groups[index] = [];
+        }
+
+        groups[index].push(array[i]);
+      }
+
+      return groups;
+    }
+  }
+
+  return groupBy(this, keySelector);
+};
+
+Array.prototype.sum = function (selector) {
+  function sum(array, selector) {
+    let ret;
+    for (let i = 0, len = array.length; i < len; i++) {
+      if (i == 0) {
+        if (selector) {
+          ret = selector.call(arguments[2], array[i], i, array);
+        } else {
+          ret = array[i];
+        }
+      } else {
+        if (selector) {
+          ret += selector.call(arguments[2], array[i], i, array);
+        } else {
+          ret += array[i];
+        }
+      }
+    }
+
+    return ret;
+  }
+
+  return sum(this, selector);
+};
\ No newline at end of file
diff --git a/demo/src/UI/mvc/FguiUtils.ts b/demo/src/UI/mvc/FguiUtils.ts
new file mode 100644
index 00000000..58206834
--- /dev/null
+++ b/demo/src/UI/mvc/FguiUtils.ts
@@ -0,0 +1,25 @@
+class FguiUtils {
+    /** 包的命名空间 */
+    public static packageNamespace: any;
+    /** 加载fgui资源 */
+    public static load(name: string): Promise<any> {
+        return new Promise((resolve, reject) => {
+            let existPkg = fairygui.UIPackage.getByName(name);
+            if (existPkg) {
+                resolve();
+            }
+
+            RES.loadGroup(name, 0).then(()=>{
+                fairygui.UIPackage.addPackage(name);
+                if (this.packageNamespace[name][name + "Binder"])
+                    this.packageNamespace[name][name + "Binder"].bindAll();
+
+                resolve();
+            }).catch(err => {
+                console.error("loadfgui error:" + err);
+                reject();
+            });
+        });
+
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/mvc/LayerManager.ts b/demo/src/UI/mvc/LayerManager.ts
new file mode 100644
index 00000000..7f9b4e5c
--- /dev/null
+++ b/demo/src/UI/mvc/LayerManager.ts
@@ -0,0 +1,46 @@
+/**
+ * 视图类型
+ */
+enum viewLayer {
+    pop,
+}
+
+/**
+ * 视图管理器
+ */
+class LayerManager {
+    private static _single: LayerManager;
+    public static getInstance(): LayerManager{
+        if (!this._single) this._single = new LayerManager();
+
+        return this._single;
+    }
+
+    private _stage: egret.Stage;
+    /** 弹窗层 */
+    public popLayer: egret.DisplayObjectContainer;
+    public tipsLayer: egret.DisplayObjectContainer;
+    /** 获取舞台 */
+    public get stage(){
+        return this._stage;
+    }
+
+    public init(stage: egret.Stage){
+        this._stage = stage;
+
+        this.popLayer = new egret.DisplayObjectContainer();
+        this.tipsLayer = new egret.DisplayObjectContainer();
+
+        this._stage.addChild(this.popLayer);
+        this._stage.addChild(this.tipsLayer);
+    }
+
+    /**
+     * 添加到layer上
+     * @param view 
+     */
+    public addLayerToView(view: BaseView){
+        let layerName = viewLayer[view.viewLayer] + "Layer";
+        this[layerName].addChild(view);
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/mvc/ViewManager.ts b/demo/src/UI/mvc/ViewManager.ts
new file mode 100644
index 00000000..979e4e27
--- /dev/null
+++ b/demo/src/UI/mvc/ViewManager.ts
@@ -0,0 +1,125 @@
+/** 窗口控制器 */
+class ViewManager {
+    private static _single: ViewManager;
+    /** 已打开的列表 存储视图实例 */
+    private _openDic: BaseView[] = [];
+    /** 跳过关闭的列表 用于主视图 存储视图类型 */
+    private _skipCloseDic = [];
+    /** 层级管理器 */
+    private _layerManager: LayerManager;
+
+    public static getInstance(): ViewManager{
+        if (!this._single) this._single = new ViewManager();
+
+        return this._single;
+    }
+
+    constructor(){
+        this._layerManager = LayerManager.getInstance();
+    }
+
+    /**
+     * 打开界面
+     * @param viewCls 视图类型
+     * @param viewData 视图数据
+     */
+    public openView(viewCls, viewData?: any): Promise<any>{
+        return new Promise((resolve, reject)=>{
+            let newView: BaseView = this.getView<BaseView>(viewCls);
+            if (!newView) newView = new viewCls();
+
+            if (this.isOpenView(viewCls)){
+                newView.refresh(viewData);
+                return;
+            }
+
+            this._openDic.push(newView);
+            FguiUtils.load(newView.name).then(()=>{
+                newView.init();
+                newView.baseShow(viewData);
+                newView.show();
+
+                this._layerManager.addLayerToView(newView);
+                resolve();
+            }).catch(()=>{
+                this._openDic.remove(newView);
+                newView.destroy();
+                newView = null;
+                reject();
+            });
+        });
+    }
+
+    /**
+     * 根据视图关闭
+     * @param view 视图实例
+     */
+    public closeView(view: BaseView){
+        let wantToCloseView = this._openDic.firstOrDefault(a => {
+            return a == view;
+        })
+        if (wantToCloseView) {
+            this._openDic.remove(wantToCloseView);
+
+            wantToCloseView.destroy();
+            wantToCloseView = null;
+        }
+    }
+
+    /**
+     * 关闭所有视图
+     */
+    public closeAll(){
+        for (let z = 0; z < this._openDic.length; z++) {
+            let element = this._openDic[z];
+            let canClose = true;
+            for (let i = 0; i < this._skipCloseDic.length; i ++){
+                if (element == this.getView(this._skipCloseDic[i])){
+                    canClose = false;
+                }
+            }
+            if (canClose) {
+                this.closeView(element);
+                z--;
+            }
+        }
+    }
+
+    /**
+     * 根据视图类型关闭窗口
+     * @param viewCls 视图类型
+     */
+    public closeViewByCls(viewCls){
+        let wantToCloseView = this._openDic.firstOrDefault(a => {
+            return a instanceof viewCls;
+        })
+        if (wantToCloseView) {
+            this._openDic.remove(wantToCloseView);
+            wantToCloseView.destroy();
+            wantToCloseView = null;
+        }
+    }
+
+    /**
+     * 根据视图类型获得窗口
+     * 如果窗口未打开则返回null
+     * @param viewCls 视图类型
+     */
+    public getView<T>(viewCls: new () => T): T{
+        let result: any = this._openDic.firstOrDefault(a => {
+            return a instanceof viewCls;
+        });
+
+        return result as T;
+    }
+
+    /**
+     * 根据视图类型获得窗口是否打开
+     * @param viewCls 
+     */
+    public isOpenView(viewCls: any): boolean {
+        return this._openDic.findIndex(a => {
+            return a instanceof viewCls;
+        }) != -1;
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/sc/ScControl.ts b/demo/src/UI/sc/ScControl.ts
new file mode 100644
index 00000000..090613a6
--- /dev/null
+++ b/demo/src/UI/sc/ScControl.ts
@@ -0,0 +1,27 @@
+module sc {
+    export class ScControl {
+        private _eventManager: EventManager;
+        private _viewManager: ViewManager;
+        private static single: ScControl;
+        public static getInstance(){
+            if (!this.single) this.single = new ScControl();
+            
+            return this.single;
+        }
+        
+        constructor(){
+            this.addEvents();
+        }
+        
+        private addEvents(){
+            this._eventManager = EventManager.getInstance();
+            this._viewManager = ViewManager.getInstance();
+            // 事件监听
+            this._eventManager.addListener(ScEvents.OPENVIEW, this.openView, this);
+        }
+        
+        private openView(){
+            this._viewManager.openView(ScView);
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/sc/ScEvents.ts b/demo/src/UI/sc/ScEvents.ts
new file mode 100644
index 00000000..d6d8e5a0
--- /dev/null
+++ b/demo/src/UI/sc/ScEvents.ts
@@ -0,0 +1,5 @@
+module sc {
+    export module ScEvents {
+        export const OPENVIEW = Symbol();
+    }
+}
\ No newline at end of file
diff --git a/demo/src/UI/sc/ScView.ts b/demo/src/UI/sc/ScView.ts
new file mode 100644
index 00000000..c4efe74a
--- /dev/null
+++ b/demo/src/UI/sc/ScView.ts
@@ -0,0 +1,55 @@
+module sc {
+    export class ScView extends BaseView {
+        private _ui: FUI.sc.UI_View_sc;
+        private _sceneList: SceneData[] = [
+            new SceneData("空白场景", samples.BasicScene),
+            new SceneData("Tiled Tiles", samples.AnimatedTilesScene),
+        ];
+
+        constructor() {
+            super("sc");
+        }
+
+        public init() {
+            this._ui = this._fuiView = FUI.sc.UI_View_sc.createInstance();
+            this.addChild(this._ui.displayObject);
+            super.init();
+        }
+
+        public show() {
+            this._ui.m_list_sc.callbackThisObj = this;
+            this._ui.m_list_sc.itemRenderer = this.scItemRender;
+            this._ui.m_list_sc.numItems = this._sceneList.length;
+        }
+
+        public scItemRender(index: number, item: FUI.sc.UI_btn_sc){
+            let sceneData = this._sceneList[index];
+            item.m_name.text = sceneData.name;
+            item.data = sceneData.type;
+            item.addClickListener(this.scItemOnClick, this);
+        }
+
+        private scItemOnClick(evt: egret.Event){
+            let data = evt.currentTarget.data;
+            es.Core.scene = new data();
+        }
+
+        public destroy() {
+            if (this._ui) {
+                this._ui.dispose();
+                this._ui = null;
+            }
+            super.destroy();
+        }
+    }
+
+    export class SceneData {
+        public name: string;
+        public type: any;
+
+        constructor(name: string, type: any){
+            this.name = name;
+            this.type = type;
+        }
+    }
+}
\ No newline at end of file
diff --git a/demo/src/game/MainScene.ts b/demo/src/game/MainScene.ts
deleted file mode 100644
index 08041fa4..00000000
--- a/demo/src/game/MainScene.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-module scene {
-    export class MainScene extends es.Scene {
-        constructor() {
-            super();
-
-            // this.addEntityProcessor(new SpawnerSystem(new Matcher()));
-            this.astarTest();
-            this.dijkstraTest();
-            this.breadthfirstTest();
-        }
-
-        public async onStart() {
-            let mapData = await es.TiledMapLoader.loadTmxMap(new es.TmxMap(), "title_json");
-            let map = this.createEntity("map");
-            let tiledMap = map.addComponent(new es.TiledMapRenderer(mapData)).setRenderLayer(1);
-            console.log(mapData);
-
-            // let sprite = new es.Sprite(RES.getRes("checkbox_select_disabled_png"));
-            // this.createEntityAsync("bg").then(bg => {
-            //     bg.addComponent(new component.PlayerController());
-            //     bg.addComponent(new es.Mover());
-            //     let spriteRenderer = bg.addComponent(new es.ScrollingSpriteRenderer(sprite)).setRenderLayer(0);
-            //     // spriteRenderer.scrollX = -30;
-            //     // bg.addComponent(new es.BoxCollider());
-
-            //     this.camera.follow(bg, es.CameraStyle.lockOn);
-            // });
-            
-            this.camera.position = new es.Vector2(300, 265);
-            es.Core.debugRenderEndabled = true;
-            this.scaleX = 0.5;
-            this.scaleY = 0.5;
-            // // bg.addComponent(new es.SpriteRenderer()).setSprite(sprite).setColor(0xff0000);
-
-            // for (let i = 0; i < 20; i++) {
-            //     let sprite = new es.Sprite(RES.getRes("checkbox_select_disabled_png"));
-            //     let player2 = this.createEntity("bg");
-            //     player2.addComponent(new es.SpriteRenderer()).setSprite(sprite).setRenderLayer(i);
-            //     player2.position = new es.Vector2(30 * i, 30 * i);
-            //     // player2.addComponent(new es.BoxCollider());
-            // }
-
-
-            let pool = new es.ComponentPool<component.SimplePooled>(component.SimplePooled);
-            let c1 = pool.obtain();
-            let c2 = pool.obtain();
-            pool.free(c1);
-            let c1b = pool.obtain();
-
-            console.log(c1 != c2);
-            console.log(c1 == c1b);
-
-            let button = new eui.Button();
-            button.label = "切换场景";
-            this.addChild(button);
-            button.addEventListener(egret.TouchEvent.TOUCH_TAP, () => {
-                es.Core.startSceneTransition(new es.FadeTransition(() => {
-                    return new MainScene();
-                }));
-            }, this);
-        }
-
-        public breadthfirstTest() {
-            let graph = new es.UnweightedGraph<string>();
-
-            graph.addEdgesForNode("a", ["b"]); // a->b
-            graph.addEdgesForNode("b", ["a", "c", "d"]); // b->a b->c b->d
-            graph.addEdgesForNode("c", ["a"]); // c->a
-            graph.addEdgesForNode("d", ["e", "a"]); // d->e d->a
-            graph.addEdgesForNode("e", ["b"]); // e->b
-
-            // 计算从c到e的路径
-            let path = es.BreadthFirstPathfinder.search(graph, "c", "e");
-            console.log(path);
-        }
-
-        public dijkstraTest() {
-            let graph = new es.WeightedGridGraph(20, 20);
-
-            graph.weightedNodes.push(new es.Vector2(3, 3));
-            graph.weightedNodes.push(new es.Vector2(3, 4));
-            graph.weightedNodes.push(new es.Vector2(4, 3));
-            graph.weightedNodes.push(new es.Vector2(4, 4));
-
-            let path = graph.search(new es.Vector2(3, 4), new es.Vector2(15, 17));
-            console.log(path);
-        }
-
-        public astarTest() {
-            let graph = new es.AstarGridGraph(30, 30);
-
-            // graph.weightedNodes.push(new Vector2(3, 3));
-            // graph.weightedNodes.push(new Vector2(3, 4));
-            // graph.weightedNodes.push(new Vector2(4, 3));
-            // graph.weightedNodes.push(new Vector2(4, 4));
-
-            let startTime = egret.getTimer();
-            let path = graph.search(new es.Vector2(1, 1), new es.Vector2(29, 29));
-            console.log(egret.getTimer() - startTime);
-        }
-    }
-}
diff --git a/demo/src/game/PlayerController.ts b/demo/src/game/PlayerController.ts
deleted file mode 100644
index 332fb945..00000000
--- a/demo/src/game/PlayerController.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-module component {
-    import Component = es.Component;
-    import Vector2 = es.Vector2;
-    import Mover = es.Mover;
-    import SpriteRenderer = es.SpriteRenderer;
-    import Time = es.Time;
-    import Input = es.Input;
-    import CollisionResult = es.CollisionResult;
-
-    export class PlayerController extends Component {
-        private down: boolean = false;
-        private touchPoint: Vector2 = Vector2.zero;
-        private mover: Mover;
-        private spriteRenderer: SpriteRenderer;
-
-        public onAddedToEntity(){
-            this.entity.scene.stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
-            this.entity.scene.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchBegin, this);
-            this.entity.scene.stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);
-        }
-
-        private touchBegin(evt: egret.TouchEvent){
-            this.down = true;
-            this.touchPoint = new Vector2(evt.stageX, evt.stageY);
-        }
-
-        private touchEnd(evt: egret.TouchEvent){
-            this.down = false;
-            this.touchPoint = new Vector2(evt.stageX, evt.stageY);
-        }
-
-        public update(){
-            if (!this.mover)
-                this.mover = this.entity.getComponent<Mover>(Mover);
-
-            if (!this.spriteRenderer)
-                this.spriteRenderer = this.entity.getComponent<SpriteRenderer>(SpriteRenderer);
-
-            if (!this.mover)
-                return;
-
-            if (!SpriteRenderer)
-                return;
-
-            if (this.down){
-                let moveLeft: number = 0;
-                let moveRight: number = 0;
-                let speed = 100;
-                let worldPos = this.entity.scene.camera.mouseToWorldPoint();
-                if (worldPos.x < this.spriteRenderer.transform.position.x){
-                    moveLeft = -1;
-                } else if(worldPos.x > this.spriteRenderer.transform.position.x){
-                    moveLeft = 1;
-                }
-
-                if (worldPos.y < this.spriteRenderer.transform.position.y){
-                    moveRight = -1;
-                } else if(worldPos.y > this.spriteRenderer.transform.position.y){
-                    moveRight = 1;
-                }
-                let collisionResult = new CollisionResult();
-                this.mover.move(new Vector2(moveLeft * speed * Time.deltaTime, moveRight * speed * Time.deltaTime), collisionResult);
-            }
-        }
-    }
-}
diff --git a/demo/src/game/SimplePooled.ts b/demo/src/game/SimplePooled.ts
deleted file mode 100644
index c455db33..00000000
--- a/demo/src/game/SimplePooled.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-module component {
-    import PooledComponent = es.PooledComponent;
-
-    export class SimplePooled extends PooledComponent {
-        public reset(){
-
-        }
-    }
-}
diff --git a/demo/src/game/SpawnerComponent.ts b/demo/src/game/SpawnerComponent.ts
deleted file mode 100644
index fb50ee0e..00000000
--- a/demo/src/game/SpawnerComponent.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-module component {
-    export class SpawnComponent extends es.Component implements es.ITriggerListener {
-        public cooldown = -1;
-        public minInterval = 2;
-        public maxInterval = 60;
-        public enemyType = EnemyType.worm;
-        public numSpawned = 0;
-        public numAlive = 0;
-
-        constructor(enemyType: EnemyType) {
-            super();
-            this.enemyType = enemyType;
-        }
-
-        public initialize() {
-            // console.log("initialize");
-        }
-
-        public update() {
-            // console.log("update");
-        }
-
-        public onTriggerEnter(other: es.Collider, local: es.Collider){
-            if (other == local)
-                console.log("repeat collider");
-            console.log("enter collider");
-        }
-
-        public onTriggerExit(other: es.Collider, local: es.Collider){
-            console.log("exit collider");
-        }
-    }
-
-    export enum EnemyType {
-        worm
-    }
-}
diff --git a/demo/src/game/SpawnerSystem.ts b/demo/src/game/SpawnerSystem.ts
deleted file mode 100644
index fa3a418a..00000000
--- a/demo/src/game/SpawnerSystem.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-module system {
-    export class SpawnerSystem extends es.EntityProcessingSystem {
-        constructor(matcher: es.Matcher){
-            super(matcher);
-        }
-
-        public processEntity(entity: es.Entity){
-            let spawner = entity.getComponent<component.SpawnComponent>(component.SpawnComponent);
-            if (!spawner)
-                return;
-
-            if (spawner.numAlive <= 0)
-                spawner.enabled = true;
-
-            if (!spawner.enabled)
-                return;
-
-            console.log("cooldown", spawner.cooldown);
-            if (spawner.cooldown == -1){
-                spawner.cooldown = Math.random() * 60;
-                spawner.cooldown /= 4;
-            }
-
-            spawner.cooldown -= es.Time.deltaTime;
-            if (spawner.cooldown <= 0){
-                spawner.cooldown = Math.random() * 60;
-                // CreateEnemy
-                spawner.numSpawned ++;
-                spawner.numAlive ++;
-
-                if (spawner.numAlive > 0)
-                    spawner.enabled = false;
-            }
-        }
-    }
-}
diff --git a/demo/template/runtime/native_require.js b/demo/template/runtime/native_require.js
index 8fbfce27..3df96bc9 100644
--- a/demo/template/runtime/native_require.js
+++ b/demo/template/runtime/native_require.js
@@ -37,7 +37,7 @@ egret_native.egretStart = function () {
 		contentWidth: 640,
 		contentHeight: 1136,
 		showPaintRect: false,
-		showFPS: true,
+		showFPS: false,
 		fpsStyles: "x:0,y:0,size:12,textColor:0xffffff,bgAlpha:0.9",
 		showLog: false,
 		logFilter: "",
diff --git a/demo_fgui/.objs/fonts.json b/demo_fgui/.objs/fonts.json
new file mode 100644
index 00000000..e69de29b
diff --git a/demo_fgui/assets/common/com_tips.xml b/demo_fgui/assets/common/com_tips.xml
new file mode 100644
index 00000000..560d2c34
--- /dev/null
+++ b/demo_fgui/assets/common/com_tips.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<component size="54,54">
+  <displayList>
+    <graph id="n0_k7mf" name="n0" xy="0,0" size="54,54" alpha="0.8" type="rect" lineSize="0" corner="15">
+      <relation target="n1_k7mf" sidePair="width-width"/>
+    </graph>
+    <text id="n1_k7mf" name="content" xy="22,10" pivot="0.5,0.5" size="10,34" fontSize="24" align="center" vAlign="middle" text="">
+      <relation target="" sidePair="center-center"/>
+    </text>
+  </displayList>
+  <relation target="n0_k7mf" sidePair="width-width,height-height"/>
+</component>
\ No newline at end of file
diff --git a/demo_fgui/assets/common/package.xml b/demo_fgui/assets/common/package.xml
new file mode 100644
index 00000000..d6962ec1
--- /dev/null
+++ b/demo_fgui/assets/common/package.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packageDescription id="minsdsta">
+  <resources>
+    <component id="k7mf0" name="com_tips.xml" path="/" exported="true"/>
+  </resources>
+  <publish name="" genCode="true"/>
+</packageDescription>
\ No newline at end of file
diff --git a/demo_fgui/assets/loading/View_loading.xml b/demo_fgui/assets/loading/View_loading.xml
new file mode 100644
index 00000000..88614486
--- /dev/null
+++ b/demo_fgui/assets/loading/View_loading.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<component size="640,1136">
+  <displayList>
+    <graph id="n0_k7mf" name="n0" xy="0,0" pivot="0.5,0.5" size="640,1136" type="rect" fillColor="#ff333333"/>
+    <text id="n2_k7mf" name="title" xy="167,541" pivot="0.5,0.5" size="304,54" font="hakuyoxingshu7000" fontSize="40" color="#ffffff" align="center" vAlign="middle" text="Egret Framework">
+      <relation target="" sidePair="center-center,middle-middle"/>
+    </text>
+    <component id="n5_k7mf" name="pg_loading" src="k7mf2" fileName="组件/pg_loading.xml" xy="30,617" pivot="0.5,0.5" size="580,10">
+      <ProgressBar value="50" max="100"/>
+    </component>
+  </displayList>
+</component>
\ No newline at end of file
diff --git a/demo_fgui/assets/loading/package.xml b/demo_fgui/assets/loading/package.xml
new file mode 100644
index 00000000..f3c57e05
--- /dev/null
+++ b/demo_fgui/assets/loading/package.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packageDescription id="mk2d64e7">
+  <resources>
+    <component id="r5ro0" name="View_loading.xml" path="/" exported="true"/>
+    <component id="k7mf2" name="pg_loading.xml" path="/组件/"/>
+  </resources>
+  <publish name="" genCode="true"/>
+</packageDescription>
\ No newline at end of file
diff --git a/demo_fgui/assets/loading/组件/pg_loading.xml b/demo_fgui/assets/loading/组件/pg_loading.xml
new file mode 100644
index 00000000..e977c372
--- /dev/null
+++ b/demo_fgui/assets/loading/组件/pg_loading.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<component size="50,10" extention="ProgressBar">
+  <ProgressBar/>
+  <displayList>
+    <graph id="n0_k7mf" name="n0" xy="0,0" size="50,10" type="rect" lineSize="1" lineColor="#A0A0A0" fillColor="#F0F0F0">
+      <relation target="" sidePair="width,height"/>
+    </graph>
+    <graph id="n1_k7mf" name="bar" xy="0,3" size="50,4" type="rect" lineSize="0" fillColor="#3399FF"/>
+  </displayList>
+</component>
\ No newline at end of file
diff --git a/demo_fgui/assets/sc/View_sc.xml b/demo_fgui/assets/sc/View_sc.xml
new file mode 100644
index 00000000..3f666b7a
--- /dev/null
+++ b/demo_fgui/assets/sc/View_sc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<component size="640,1136" opaque="false">
+  <displayList>
+    <list id="n0_k7mf" name="list_sc" xy="0,0" size="211,1136" overflow="scroll" lineGap="20" colGap="11" defaultItem="ui://m4sln17ak7mf2" align="center"/>
+  </displayList>
+</component>
\ No newline at end of file
diff --git a/demo_fgui/assets/sc/package.xml b/demo_fgui/assets/sc/package.xml
new file mode 100644
index 00000000..b7093a73
--- /dev/null
+++ b/demo_fgui/assets/sc/package.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packageDescription id="m4sln17a">
+  <resources>
+    <component id="k7mf0" name="View_sc.xml" path="/" exported="true"/>
+    <component id="k7mf2" name="btn_sc.xml" path="/组件/" exported="true"/>
+  </resources>
+  <publish name="" genCode="true"/>
+</packageDescription>
\ No newline at end of file
diff --git a/demo_fgui/assets/sc/组件/btn_sc.xml b/demo_fgui/assets/sc/组件/btn_sc.xml
new file mode 100644
index 00000000..0688b85b
--- /dev/null
+++ b/demo_fgui/assets/sc/组件/btn_sc.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<component size="100,20" extention="Button">
+  <controller name="button" pages="0,up,1,down,2,over,3,selectedOver" selected="0"/>
+  <displayList>
+    <graph id="n0_k7mf" name="n0" xy="0,0" size="100,20" touchable="false" type="rect" lineSize="0" fillColor="#fff0f0f0">
+      <gearDisplay controller="button" pages="0"/>
+      <relation target="" sidePair="width-width,height-height"/>
+    </graph>
+    <graph id="n1_k7mf" name="n1" xy="0,0" size="100,20" touchable="false" type="rect" lineSize="0" fillColor="#fffafafa">
+      <gearDisplay controller="button" pages="2"/>
+      <relation target="" sidePair="width-width,height-height"/>
+    </graph>
+    <graph id="n2_k7mf" name="n2" xy="0,0" size="100,20" touchable="false" type="rect" lineSize="0" fillColor="#ffcccccc">
+      <gearDisplay controller="button" pages="1,3"/>
+      <relation target="" sidePair="width-width,height-height"/>
+    </graph>
+    <text id="n3_k7mf" name="name" xy="0,0" size="100,20" fontSize="16" align="center" vAlign="middle" autoSize="none" singleLine="true" text="">
+      <relation target="" sidePair="width-width,height-height"/>
+    </text>
+  </displayList>
+  <Button/>
+</component>
\ No newline at end of file
diff --git a/demo_fgui/demo_fgui.fairy b/demo_fgui/demo_fgui.fairy
new file mode 100644
index 00000000..095a52f6
--- /dev/null
+++ b/demo_fgui/demo_fgui.fairy
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<projectDescription id="d07459cf38241e9b17edc6f05ec4503f" type="Egret" version="5.0"/>
\ No newline at end of file
diff --git a/demo_fgui/settings/Adaptation.json b/demo_fgui/settings/Adaptation.json
new file mode 100644
index 00000000..36a8834b
--- /dev/null
+++ b/demo_fgui/settings/Adaptation.json
@@ -0,0 +1,8 @@
+{
+  "scaleMode": "ConstantPixelSize",
+  "screenMathMode": "MatchWidthOrHeight",
+  "designResolutionX": 0,
+  "designResolutionY": 0,
+  "devices": [],
+  "fileName": "Adaptation"
+}
\ No newline at end of file
diff --git a/demo_fgui/settings/Common.json b/demo_fgui/settings/Common.json
new file mode 100644
index 00000000..e7a2ef06
--- /dev/null
+++ b/demo_fgui/settings/Common.json
@@ -0,0 +1,24 @@
+{
+  "font": "",
+  "fontSize": 16,
+  "textColor": "#000000",
+  "fontAdjustment": false,
+  "colorScheme": [
+    "自定义颜色 #FF0000"
+  ],
+  "fontSizeScheme": [
+    "自定义字体大小 30"
+  ],
+  "fontScheme": [
+    "默认字体"
+  ],
+  "scrollBars": {
+    "horizontal": "",
+    "vertical": "",
+    "defaultDisplay": "visible"
+  },
+  "tipsRes": "ui://minsdstak7mf0",
+  "buttonClickSound": "",
+  "pivot": "center",
+  "fileName": "Common"
+}
\ No newline at end of file
diff --git a/demo_fgui/settings/CustomProperties.json b/demo_fgui/settings/CustomProperties.json
new file mode 100644
index 00000000..9e26dfee
--- /dev/null
+++ b/demo_fgui/settings/CustomProperties.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/demo_fgui/settings/Publish.json b/demo_fgui/settings/Publish.json
new file mode 100644
index 00000000..a4dd9905
--- /dev/null
+++ b/demo_fgui/settings/Publish.json
@@ -0,0 +1,35 @@
+{
+  "path": "E:\\egret-framework\\demo\\resource\\fgui",
+  "branchPath": "",
+  "fileExtension": "fui",
+  "packageCount": 2,
+  "compressDesc": true,
+  "binaryFormat": true,
+  "jpegQuality": 80,
+  "compressPNG": false,
+  "codeGeneration": {
+    "allowGenCode": true,
+    "codePath": "E:\\egret-framework\\demo\\src\\Fgui",
+    "classNamePrefix": "UI_",
+    "memberNamePrefix": "m_",
+    "packageName": "FUI",
+    "ignoreNoname": true,
+    "getMemberByName": false,
+    "codeType": ""
+  },
+  "includeHighResolution": 0,
+  "branchProcessing": 0,
+  "seperatedAtlasForBranch": false,
+  "atlasSetting": {
+    "maxSize": 2048,
+    "paging": true,
+    "sizeOption": "pot",
+    "forceSquare": false,
+    "allowRotation": true,
+    "trimImage": true
+  },
+  "include2x": false,
+  "include3x": false,
+  "include4x": false,
+  "fileName": "Publish"
+}
\ No newline at end of file
diff --git a/demo_fgui/settings/i18n.json b/demo_fgui/settings/i18n.json
new file mode 100644
index 00000000..53e034f5
--- /dev/null
+++ b/demo_fgui/settings/i18n.json
@@ -0,0 +1,3 @@
+{
+  "langFiles": []
+}
\ No newline at end of file
diff --git a/demo/.idea/.gitignore b/source/.idea/.gitignore
similarity index 61%
rename from demo/.idea/.gitignore
rename to source/.idea/.gitignore
index e7e9d11d..5c98b428 100644
--- a/demo/.idea/.gitignore
+++ b/source/.idea/.gitignore
@@ -1,2 +1,2 @@
 # Default ignored files
-/workspace.xml
+/workspace.xml
\ No newline at end of file
diff --git a/demo/.idea/misc.xml b/source/.idea/misc.xml
similarity index 100%
rename from demo/.idea/misc.xml
rename to source/.idea/misc.xml
diff --git a/demo/.idea/modules.xml b/source/.idea/modules.xml
similarity index 59%
rename from demo/.idea/modules.xml
rename to source/.idea/modules.xml
index c95e899e..66f33508 100644
--- a/demo/.idea/modules.xml
+++ b/source/.idea/modules.xml
@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/demo.iml" filepath="$PROJECT_DIR$/.idea/demo.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/source.iml" filepath="$PROJECT_DIR$/.idea/source.iml" />
     </modules>
   </component>
 </project>
\ No newline at end of file
diff --git a/demo/.idea/demo.iml b/source/.idea/source.iml
similarity index 52%
rename from demo/.idea/demo.iml
rename to source/.idea/source.iml
index c956989b..24643cc3 100644
--- a/demo/.idea/demo.iml
+++ b/source/.idea/source.iml
@@ -1,7 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="WEB_MODULE" version="4">
   <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
diff --git a/demo/.idea/vcs.xml b/source/.idea/vcs.xml
similarity index 100%
rename from demo/.idea/vcs.xml
rename to source/.idea/vcs.xml
diff --git a/source/bin/framework.d.ts b/source/bin/framework.d.ts
index e2631a2e..dff79797 100644
--- a/source/bin/framework.d.ts
+++ b/source/bin/framework.d.ts
@@ -328,6 +328,7 @@ declare module es {
         onAddedToScene(): void;
         onRemovedFromScene(): void;
         update(): void;
+        debugRender(): void;
         addComponent<T extends Component>(component: T): T;
         getComponent<T extends Component>(type: any): T;
         hasComponent<T extends Component>(type: any): boolean;
@@ -923,6 +924,7 @@ declare module es {
         onEntityTransformChanged(comp: transform.Component): void;
         onEntityEnabled(): void;
         onEntityDisabled(): void;
+        debugRender(): void;
     }
 }
 declare module es {
@@ -1008,6 +1010,7 @@ declare module es {
         isVisible: boolean;
         isVisibleFromCamera(camera: Camera): any;
         render(camera: Camera): any;
+        debugRender(): any;
     }
     class RenderableComparer {
         compare(self: IRenderable, other: IRenderable): number;
@@ -1152,6 +1155,9 @@ declare module es {
     abstract class Renderer {
         camera: Camera;
         readonly renderOrder: number;
+        renderTexture: egret.RenderTexture;
+        shouldDebugRender: boolean;
+        readonly wantsToRenderToSceneRenderTarget: boolean;
         protected constructor(renderOrder: number, camera?: Camera);
         onAddedToScene(scene: Scene): void;
         unload(): void;
@@ -1160,6 +1166,7 @@ declare module es {
         compareTo(other: Renderer): number;
         protected beginRender(cam: Camera): void;
         protected renderAfterStateCheck(renderable: IRenderable, cam: Camera): void;
+        protected debugRender(scene: Scene, cam: Camera): void;
     }
 }
 declare module es {
@@ -1168,9 +1175,21 @@ declare module es {
         render(scene: Scene): void;
     }
 }
+declare module es {
+    class RenderLayerExcludeRenderer extends Renderer {
+        excludedRenderLayers: number[];
+        constructor(renderOrder: number, ...excludedRenderLayers: number[]);
+        render(scene: es.Scene): void;
+        protected debugRender(scene: es.Scene, cam: es.Camera): void;
+    }
+}
 declare module es {
     class ScreenSpaceRenderer extends Renderer {
+        renderLayers: number[];
+        constructor(renderOrder: number, ...renderLayers: number[]);
         render(scene: Scene): void;
+        protected debugRender(scene: es.Scene, cam: es.Camera): void;
+        onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): void;
     }
 }
 declare module es {
diff --git a/source/bin/framework.js b/source/bin/framework.js
index b25829a9..edc88ec3 100644
--- a/source/bin/framework.js
+++ b/source/bin/framework.js
@@ -1536,6 +1536,9 @@ var es;
         Entity.prototype.update = function () {
             this.components.update();
         };
+        Entity.prototype.debugRender = function () {
+            this.components.debugRender();
+        };
         Entity.prototype.addComponent = function (component) {
             component.entity = this;
             this.components.add(component);
@@ -2712,6 +2715,8 @@ var es;
             this._areBoundsDirty = true;
         };
         RenderableComponent.prototype.isVisibleFromCamera = function (camera) {
+            if (!camera)
+                return false;
             this.isVisible = camera.bounds.intersects(this.displayObject.getBounds().union(this.bounds));
             return this.isVisible;
         };
@@ -4230,6 +4235,12 @@ var es;
             for (var i = 0; i < this._components.length; i++)
                 this._components[i].onDisabled();
         };
+        ComponentList.prototype.debugRender = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                if (this._components[i].enabled)
+                    this._components[i].debugRender();
+            }
+        };
         ComponentList.compareUpdatableOrder = new es.IUpdatableComparer();
         return ComponentList;
     }());
@@ -5444,9 +5455,17 @@ var es;
         function Renderer(renderOrder, camera) {
             if (camera === void 0) { camera = null; }
             this.renderOrder = 0;
+            this.shouldDebugRender = true;
             this.camera = camera;
             this.renderOrder = renderOrder;
         }
+        Object.defineProperty(Renderer.prototype, "wantsToRenderToSceneRenderTarget", {
+            get: function () {
+                return !!this.renderTexture;
+            },
+            enumerable: true,
+            configurable: true
+        });
         Renderer.prototype.onAddedToScene = function (scene) {
         };
         Renderer.prototype.unload = function () {
@@ -5461,6 +5480,13 @@ var es;
         Renderer.prototype.renderAfterStateCheck = function (renderable, cam) {
             renderable.render(cam);
         };
+        Renderer.prototype.debugRender = function (scene, cam) {
+            for (var i = 0; i < scene.entities.count; i++) {
+                var entity = scene.entities.buffer[i];
+                if (entity.enabled)
+                    entity.debugRender();
+            }
+        };
         return Renderer;
     }());
     es.Renderer = Renderer;
@@ -5486,13 +5512,85 @@ var es;
     es.DefaultRenderer = DefaultRenderer;
 })(es || (es = {}));
 var es;
+(function (es) {
+    var RenderLayerExcludeRenderer = (function (_super) {
+        __extends(RenderLayerExcludeRenderer, _super);
+        function RenderLayerExcludeRenderer(renderOrder) {
+            var excludedRenderLayers = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                excludedRenderLayers[_i - 1] = arguments[_i];
+            }
+            var _this = _super.call(this, renderOrder, null) || this;
+            _this.excludedRenderLayers = excludedRenderLayers;
+            return _this;
+        }
+        RenderLayerExcludeRenderer.prototype.render = function (scene) {
+            var cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
+            for (var i = 0; i < scene.renderableComponents.count; i++) {
+                var renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
+            if (this.shouldDebugRender && es.Core.debugRenderEndabled)
+                this.debugRender(scene, cam);
+        };
+        RenderLayerExcludeRenderer.prototype.debugRender = function (scene, cam) {
+            for (var i = 0; i < scene.renderableComponents.count; i++) {
+                var renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    renderable.debugRender();
+            }
+            _super.prototype.debugRender.call(this, scene, cam);
+        };
+        return RenderLayerExcludeRenderer;
+    }(es.Renderer));
+    es.RenderLayerExcludeRenderer = RenderLayerExcludeRenderer;
+})(es || (es = {}));
+var es;
 (function (es) {
     var ScreenSpaceRenderer = (function (_super) {
         __extends(ScreenSpaceRenderer, _super);
-        function ScreenSpaceRenderer() {
-            return _super !== null && _super.apply(this, arguments) || this;
+        function ScreenSpaceRenderer(renderOrder) {
+            var renderLayers = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                renderLayers[_i - 1] = arguments[_i];
+            }
+            var _this = _super.call(this, renderOrder, null) || this;
+            renderLayers.sort();
+            renderLayers.reverse();
+            _this.renderLayers = renderLayers;
+            return _this;
         }
         ScreenSpaceRenderer.prototype.render = function (scene) {
+            this.beginRender(this.camera);
+            for (var i = 0; i < this.renderLayers.length; i++) {
+                var renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (var j = 0; j < renderables.length; j++) {
+                    var renderable = renderables[j];
+                    if (renderable.enabled && renderable.isVisibleFromCamera(this.camera))
+                        this.renderAfterStateCheck(renderable, this.camera);
+                }
+            }
+            if (this.shouldDebugRender && es.Core.debugRenderEndabled)
+                this.debugRender(scene, this.camera);
+        };
+        ScreenSpaceRenderer.prototype.debugRender = function (scene, cam) {
+            for (var i = 0; i < this.renderLayers.length; i++) {
+                var renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (var j = 0; j < renderables.length; j++) {
+                    var entity = renderables[j];
+                    if (entity.enabled)
+                        entity.debugRender();
+                }
+            }
+        };
+        ScreenSpaceRenderer.prototype.onSceneBackBufferSizeChanged = function (newWidth, newHeight) {
+            _super.prototype.onSceneBackBufferSizeChanged.call(this, newWidth, newHeight);
+            if (!this.camera)
+                this.camera = es.Core.scene.createEntity("screenspace camera").addComponent(new es.Camera());
         };
         return ScreenSpaceRenderer;
     }(es.Renderer));
@@ -8102,22 +8200,21 @@ var es;
         };
         TiledMapLoader.parseTmxTileset = function (map, xTileset) {
             return __awaiter(this, void 0, void 0, function () {
-                var xFirstGid, firstGid, source, xDocTileset, tileset;
+                var xFirstGid, firstGid, source, xDocTileset;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
                             xFirstGid = xTileset["firstgid"];
                             firstGid = xFirstGid;
-                            source = xTileset["image"];
+                            source = xTileset["source"];
                             if (!(source != undefined)) return [3, 2];
                             source = map.tmxDirectory + source;
-                            return [4, RES.getResByUrl(source, null, this, RES.ResourceItem.TYPE_IMAGE).catch(function (err) {
+                            return [4, RES.getResByUrl(source).catch(function (err) {
                                     throw new Error(err);
                                 })];
                         case 1:
                             xDocTileset = _a.sent();
-                            tileset = this.loadTmxTileset(new es.TmxTileset(), map, xDocTileset["tileset"], firstGid);
-                            return [2, tileset];
+                            return [2, this.loadTmxTileset(new es.TmxTileset(), map, xDocTileset["tileset"], firstGid)];
                         case 2: return [2, this.loadTmxTileset(new es.TmxTileset(), map, xTileset, firstGid)];
                     }
                 });
@@ -8125,9 +8222,9 @@ var es;
         };
         TiledMapLoader.loadTmxTileset = function (tileset, map, xTileset, firstGid) {
             return __awaiter(this, void 0, void 0, function () {
-                var xImage, _a, _i, _b, e, _c, _d, _e, t, xTile, tile, id, y, column, x;
-                return __generator(this, function (_f) {
-                    switch (_f.label) {
+                var xImage, _i, _a, e, _b, _c, _d, t, xTile, tile, id, y, column, x;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
                         case 0:
                             tileset.map = map;
                             tileset.firstGid = firstGid;
@@ -8141,38 +8238,39 @@ var es;
                             tileset.tileOffset = this.parseTmxTileOffset(xTileset["tileoffset"]);
                             xImage = xTileset["image"];
                             if (!xImage) return [3, 2];
-                            _a = tileset;
-                            return [4, this.loadTmxImage(new es.TmxImage(), xTileset, map.tmxDirectory).catch(function (err) {
+                            return [4, this.loadTmxImage(new es.TmxImage(), xTileset, map.tmxDirectory).then(function (image) {
+                                    tileset.image = image;
+                                }).catch(function (err) {
                                     throw new Error(err);
                                 })];
                         case 1:
-                            _a.image = _f.sent();
-                            _f.label = 2;
+                            _e.sent();
+                            _e.label = 2;
                         case 2:
                             tileset.terrains = [];
                             if (xTileset["terrains"])
-                                for (_i = 0, _b = xTileset["terrains"]; _i < _b.length; _i++) {
-                                    e = _b[_i];
+                                for (_i = 0, _a = xTileset["terrains"]; _i < _a.length; _i++) {
+                                    e = _a[_i];
                                     tileset.terrains.push(this.parseTmxTerrain(e));
                                 }
                             tileset.tiles = new Map();
-                            _c = [];
-                            for (_d in xTileset["tiles"])
-                                _c.push(_d);
-                            _e = 0;
-                            _f.label = 3;
+                            _b = [];
+                            for (_c in xTileset["tiles"])
+                                _b.push(_c);
+                            _d = 0;
+                            _e.label = 3;
                         case 3:
-                            if (!(_e < _c.length)) return [3, 6];
-                            t = _c[_e];
+                            if (!(_d < _b.length)) return [3, 6];
+                            t = _b[_d];
                             if (!xTileset["tiles"].hasOwnProperty(t)) return [3, 5];
                             xTile = xTileset["tiles"][t];
                             return [4, this.loadTmxTilesetTile(new es.TmxTilesetTile(), tileset, xTile, tileset.terrains, map.tmxDirectory)];
                         case 4:
-                            tile = _f.sent();
+                            tile = _e.sent();
                             tileset.tiles.set(tile.id == undefined ? Number(t) + 1 : tile.id, tile);
-                            _f.label = 5;
+                            _e.label = 5;
                         case 5:
-                            _e++;
+                            _d++;
                             return [3, 3];
                         case 6:
                             tileset.properties = this.parsePropertyDict(xTileset["properties"]);
diff --git a/source/bin/framework.min.js b/source/bin/framework.min.js
index 79523ccc..ce6c6fd2 100644
--- a/source/bin/framework.min.js
+++ b/source/bin/framework.min.js
@@ -1 +1 @@
-window.es={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var i in e)e.hasOwnProperty(i)&&(t[i]=e[i])};return function(e,i){function n(){this.constructor=e}t(e,i),e.prototype=null===i?Object.create(i):(n.prototype=i.prototype,new n)}}();var transform,__awaiter=this&&this.__awaiter||function(t,e,i,n){return new(i||(i=Promise))(function(r,o){function s(t){try{h(n.next(t))}catch(t){o(t)}}function a(t){try{h(n.throw(t))}catch(t){o(t)}}function h(t){t.done?r(t.value):new i(function(e){e(t.value)}).then(s,a)}h((n=n.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var i,n,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(i)throw new TypeError("Generator is already executing.");for(;s;)try{if(i=1,n&&(r=2&o[0]?n.return:o[0]?n.throw||((r=n.return)&&r.call(n),0):n.next)&&!(r=r.call(n,o[1])).done)return r;switch(n=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,n=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],n=0}finally{i=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++)if(e.call(arguments[2],t[i],i,t))return i;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var i=t.findIndex(e);return-1==i?null:t[i]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return e.call(arguments[2],n,r,t)&&i.push(n),i},[]);for(var i=[],n=0,r=t.length;n<r;n++){var o=t[n];e.call(arguments[2],o,n,t)&&i.push(o)}return i}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++){if(t[i]instanceof egret.HashObject&&e instanceof egret.HashObject&&t[i].hashCode==e.hashCode)return!0;if(t[i]==e)return!0}return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var i;do{(i=t.findIndex(e))>=0&&t.splice(i,1)}while(i>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var i=t.findIndex(function(t){return t===e});return i>=0&&(t.splice(i,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,i){t.splice(e,i)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return i.push(e.call(arguments[2],n,r,t)),i},[]);for(var i=[],n=0,r=t.length;n<r;n++)i.push(e.call(arguments[2],t[n],n,t));return i}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?i(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?-i(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var i=[];return t.reduce(function(n,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=i.findIndex(function(t){return t===s});return a<0&&(a=i.push(s)-1),n[a]||(n[a]=[]),n[a].push(r),n},[])}for(var n=[],r=[],o=function(i,o){var a=JSON.stringify(e.call(s[1],t[i],i,t)),h=r.findIndex(function(t){return t===a});h<0&&(h=r.push(a)-1),n[h]||(n[h]=[]),n[h].push(t[i])},s=arguments,a=0,h=t.length;a<h;a++)o(a);return n}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var i,n=0,r=t.length;n<r;n++)0==n?i=e?e.call(arguments[2],t[n],n,t):t[n]:i+=e?e.call(arguments[2],t[n],n,t):t[n];return i}(this,t)},function(t){var e=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}();t.PriorityQueueNode=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new i(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";e.getNeighbors(t.data).forEach(function(n){var s=h.get(t.data)+e.cost(t.data,n);if(!o.hasKey(h,n)||s<h.get(n)){h.set(n,s);var u=s+e.heuristic(n,r);c.enqueue(new i(n),u),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},e.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},e}();t.AStarPathfinder=e;var i=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.AStarNode=i}(es||(es={})),function(t){var e=function(){function e(e,i){this.dirs=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=i}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.AStarPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this.dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},e}();t.AstarGridGraph=e}(es||(es={})),function(t){var e=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var i=e+1;if(i<this._nodes.length&&this._nodes[i]&&this.hasHigherPriority(this._nodes[i],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),i=this._nodes[e];e>0&&this.hasHigherPriority(t,i)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,i=t.queueIndex;;){e=t;var n=2*i;if(n>this._numNodes){t.queueIndex=i,this._nodes[i]=t;break}var r=this._nodes[n];this.hasHigherPriority(r,e)&&(e=r);var o=n+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=i,this._nodes[i]=t;break}this._nodes[i]=e;var a=e.queueIndex;e.queueIndex=i,i=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var i=this._nodes[e];if(this.hasHigherPriority(i,t))break;this.swap(t,i),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var i=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=i},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}();t.PriorityQueue=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,i,n){var r=this,o=!1,s=[];s.unshift(i);var a=new Map;a.set(i,i);for(var h=function(){var t=s.shift();if(JSON.stringify(t)==JSON.stringify(n))return o=!0,"break";e.getNeighbors(t).forEach(function(e){r.hasKey(a,e)||(s.unshift(e),a.set(e,t))})};s.length>0;){if("break"===h())break}return o?t.AStarPathfinder.recontructPath(a,i,n):null},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e}();t.BreadthFirstPathfinder=e}(es||(es={})),function(t){var e=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}();t.UnweightedGraph=e}(es||(es={})),function(t){var e=function(){function e(t,e){this.x=0,this.y=0,this.x=t||0,this.y=null!=e?e:this.x}return Object.defineProperty(e,"zero",{get:function(){return e.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"one",{get:function(){return e.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitX",{get:function(){return e.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitY",{get:function(){return e.unitYVector},enumerable:!0,configurable:!0}),e.add=function(t,i){var n=new e(0,0);return n.x=t.x+i.x,n.y=t.y+i.y,n},e.divide=function(t,i){var n=new e(0,0);return n.x=t.x/i.x,n.y=t.y/i.y,n},e.multiply=function(t,i){var n=new e(0,0);return n.x=t.x*i.x,n.y=t.y*i.y,n},e.subtract=function(t,i){var n=new e(0,0);return n.x=t.x-i.x,n.y=t.y-i.y,n},e.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},e.dot=function(t,e){return t.x*e.x+t.y*e.y},e.distanceSquared=function(t,e){var i=t.x-e.x,n=t.y-e.y;return i*i+n*n},e.clamp=function(i,n,r){return new e(t.MathHelper.clamp(i.x,n.x,r.x),t.MathHelper.clamp(i.y,n.y,r.y))},e.lerp=function(i,n,r){return new e(t.MathHelper.lerp(i.x,n.x,r),t.MathHelper.lerp(i.y,n.y,r))},e.transform=function(t,i){return new e(t.x*i.m11+t.y*i.m21+i.m31,t.x*i.m12+t.y*i.m22+i.m32)},e.distance=function(t,e){var i=t.x-e.x,n=t.y-e.y;return Math.sqrt(i*i+n*n)},e.angle=function(i,n){return i=e.normalize(i),n=e.normalize(n),Math.acos(t.MathHelper.clamp(e.dot(i,n),-1,1))*t.MathHelper.Rad2Deg},e.negate=function(t){var i=new e;return i.x=-t.x,i.y=-t.y,i},e.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this},e.prototype.divide=function(t){return this.x/=t.x,this.y/=t.y,this},e.prototype.multiply=function(t){return this.x*=t.x,this.y*=t.y,this},e.prototype.subtract=function(t){return this.x-=t.x,this.y-=t.y,this},e.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);return this.x*=t,this.y*=t,this},e.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},e.prototype.lengthSquared=function(){return this.x*this.x+this.y*this.y},e.prototype.round=function(){return new e(Math.round(this.x),Math.round(this.y))},e.prototype.equals=function(t){return t.x==this.x&&t.y==this.y},e.unitYVector=new e(0,1),e.unitXVector=new e(1,0),e.unitVector2=new e(1,1),e.zeroVector2=new e(0,0),e}();t.Vector2=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this._neighbors=new Array(4),this._width=t,this._hegiht=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.search=function(e,i){return t.BreadthFirstPathfinder.search(this,e,i)},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,-1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.UnweightedGridGraph=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.WeightedPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.WeightedGridGraph=e}(es||(es={})),function(t){var e=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.WeightedNode=e;var i=function(){function i(){}return i.search=function(i,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new e(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";i.getNeighbors(t.data).forEach(function(n){var r=h.get(t.data)+i.cost(t.data,n);if(!o.hasKey(h,n)||r<h.get(n)){h.set(n,r);var s=r;c.enqueue(new e(n),s),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},i.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},i.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},i.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},i}();t.WeightedPathfinder=i}(es||(es={})),function(t){var e=function(){function e(){}return e.drawHollowRect=function(e,i,n){void 0===n&&(n=0),this._debugDrawItems.push(new t.DebugDrawItem(e,i,n))},e.render=function(){if(this._debugDrawItems.length>0){var e=new egret.Shape;t.Core.scene&&t.Core.scene.addChild(e);for(var i=this._debugDrawItems.length-1;i>=0;i--){this._debugDrawItems[i].draw(e)&&this._debugDrawItems.removeAt(i)}}},e._debugDrawItems=[],e}();t.Debug=e}(es||(es={})),function(t){var e=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();t.DebugDefaults=e}(es||(es={})),function(t){var e;!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(e=t.DebugDrawType||(t.DebugDrawType={}));var i=function(){function i(t,i,n){this.rectangle=t,this.color=i,this.duration=n,this.drawType=e.hollowRectangle}return i.prototype.draw=function(i){switch(this.drawType){case e.line:case e.hollowRectangle:case e.pixel:case e.text:}return this.duration-=t.Time.deltaTime,this.duration<0},i}();t.DebugDrawItem=i}(es||(es={})),function(t){var e=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.updateInterval=1,e._enabled=!0,e._updateOrder=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"transform",{get:function(){return this.entity.transform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onAddedToEntity=function(){},e.prototype.onRemovedFromEntity=function(){},e.prototype.onEntityTransformChanged=function(t){},e.prototype.debugRender=function(){},e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},e.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},e.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,t},e}(egret.HashObject);t.Component=e}(es||(es={})),function(t){var e=function(e){function i(){var n=e.call(this)||this;return n._globalManagers=[],i._instance=n,i.emitter=new t.Emitter,i.content=new t.ContentManager,n.addEventListener(egret.Event.ADDED_TO_STAGE,n.onAddToStage,n),n}return __extends(i,e),Object.defineProperty(i,"Instance",{get:function(){return this._instance},enumerable:!0,configurable:!0}),Object.defineProperty(i,"scene",{get:function(){return this._instance?this._instance._scene:null},set:function(t){t?null==this._instance._scene?(this._instance._scene=t,this._instance.addChild(t),this._instance._scene.begin(),i.Instance.onSceneChanged()):this._instance._nextScene=t:console.error("场景不能为空")},enumerable:!0,configurable:!0}),i.startSceneTransition=function(t){if(!this._instance._sceneTransition)return this._instance._sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},i.registerGlobalManager=function(t){this._instance._globalManagers.push(t),t.enabled=!0},i.unregisterGlobalManager=function(t){this._instance._globalManagers.remove(t),t.enabled=!1},i.getGlobalManager=function(t){for(var e=0;e<this._instance._globalManagers.length;e++)if(this._instance._globalManagers[e]instanceof t)return this._instance._globalManagers[e];return null},i.prototype.onOrientationChanged=function(){i.emitter.emit(t.CoreEvents.OrientationChanged)},i.prototype.draw=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this._sceneTransition?(this._sceneTransition.preRender(),!this._scene||this._sceneTransition.hasPreviousSceneRender?[3,2]:(this._scene.render(),this._scene.postRender(),[4,this._sceneTransition.onBeginTransition()])):[3,4];case 1:return e.sent(),[3,3];case 2:this._sceneTransition&&(this._scene&&this._sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this._sceneTransition.render()),e.label=3;case 3:return[3,5];case 4:this._scene&&(this._scene.render(),t.Debug.render(),this._scene.postRender()),e.label=5;case 5:return[2]}})})},i.prototype.startDebugUpdate=function(){t.TimeRuler.Instance.startFrame(),t.TimeRuler.Instance.beginMark("update",65280)},i.prototype.endDebugUpdate=function(){t.TimeRuler.Instance.endMark("update")},i.prototype.onSceneChanged=function(){i.emitter.emit(t.CoreEvents.SceneChanged),t.Time.sceneChanged()},i.prototype.onGraphicsDeviceReset=function(){i.emitter.emit(t.CoreEvents.GraphicsDeviceReset)},i.prototype.initialize=function(){},i.prototype.update=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:if(t.Time.update(egret.getTimer()),!this._scene)return[3,2];for(e=this._globalManagers.length-1;e>=0;e--)this._globalManagers[e].enabled&&this._globalManagers[e].update();return this._sceneTransition&&(!this._sceneTransition||this._sceneTransition.loadsNewScene&&!this._sceneTransition.isNewSceneLoaded)||this._scene.update(),this._nextScene?(this.removeChild(this._scene),this._scene.end(),this._scene=this._nextScene,this._nextScene=null,this.onSceneChanged(),this.addChild(this._scene),[4,this._scene.begin()]):[3,2];case 1:i.sent(),i.label=2;case 2:return[4,this.draw()];case 3:return i.sent(),[2]}})})},i.prototype.onAddToStage=function(){i.graphicsDevice=new t.GraphicsDevice,this.addEventListener(egret.Event.RESIZE,this.onGraphicsDeviceReset,this),this.addEventListener(egret.StageOrientationEvent.ORIENTATION_CHANGE,this.onOrientationChanged,this),this.addEventListener(egret.Event.ENTER_FRAME,this.update,this),t.Input.initialize(),this.initialize()},i.debugRenderEndabled=!1,i}(egret.DisplayObjectContainer);t.Core=e}(es||(es={})),function(t){!function(t){t[t.GraphicsDeviceReset=0]="GraphicsDeviceReset",t[t.SceneChanged=1]="SceneChanged",t[t.OrientationChanged=2]="OrientationChanged"}(t.CoreEvents||(t.CoreEvents={}))}(es||(es={})),function(t){var e=function(){function e(i){this.updateInterval=1,this._tag=0,this._enabled=!0,this._updateOrder=0,this.components=new t.ComponentList(this),this.transform=new t.Transform(this),this.name=i,this.id=e._idGenerator++,this.componentBits=new t.BitSet}return Object.defineProperty(e.prototype,"isDestroyed",{get:function(){return this._isDestroyed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parent",{get:function(){return this.transform.parent},set:function(t){this.transform.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"childCount",{get:function(){return this.transform.childCount},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this.transform.position},set:function(t){this.transform.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localPosition",{get:function(){return this.transform.localPosition},set:function(t){this.transform.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.transform.rotation},set:function(t){this.transform.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotationDegrees",{get:function(){return this.transform.rotationDegrees},set:function(t){this.transform.setRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotation",{get:function(){return this.transform.localRotation},set:function(t){this.transform.setLocalRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotationDegrees",{get:function(){return this.transform.localRotationDegrees},set:function(t){this.transform.setLocalRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return this.transform.scale},set:function(t){this.transform.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localScale",{get:function(){return this.transform.localScale},set:function(t){this.transform.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldInverseTransform",{get:function(){return this.transform.worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localToWorldTransform",{get:function(){return this.transform.localToWorldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldToLocalTransform",{get:function(){return this.transform.worldToLocalTransform},enumerable:!0,configurable:!0}),e.prototype.onTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.components.onEntityEnabled():this.components.onEntityDisabled()),this},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene&&(this.scene.entities.markEntityListUnsorted(),this.scene.entities.markTagUnsorted(this.tag)),this},e.prototype.destroy=function(){this._isDestroyed=!0,this.scene.entities.remove(this),this.transform.parent=null;for(var t=this.transform.childCount-1;t>=0;t--){this.transform.getChild(t).entity.destroy()}},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.transform.childCount;t++)this.transform.getChild(t).entity.detachFromScene()},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.transform.childCount;e++)this.transform.getChild(e).entity.attachToScene(t)},e.prototype.clone=function(i){void 0===i&&(i=new t.Vector2);var n=new e(this.name+"(clone)");return n.copyFrom(this),n.transform.position=i,n},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestroyed&&this.components.removeAllComponents()},e.prototype.update=function(){this.components.update()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),t.initialize(),t},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.compareTo=function(t){var e=this._updateOrder-t._updateOrder;return 0==e&&(e=this.id-t.id),e},e.prototype.toString=function(){return"[Entity: name: "+this.name+", tag: "+this.tag+", enabled: "+this.enabled+", depth: "+this.updateOrder+"]"},e.prototype.copyFrom=function(t){this.tag=t.tag,this.updateInterval=t.updateInterval,this.updateOrder=t.updateOrder,this.enabled=t.enabled,this.transform.scale=t.transform.scale,this.transform.rotation=t.transform.rotation;for(var e=0;e<t.components.count;e++)this.addComponent(t.components.buffer[e].clone());for(e=0;e<t.components._componentsToAdd.length;e++)this.addComponent(t.components._componentsToAdd[e].clone());for(e=0;e<t.transform.childCount;e++){var i=t.transform.getChild(e).entity,n=i.clone();n.transform.copyFrom(i.transform),n.transform.parent=this.transform}},e._idGenerator=0,e}();t.Entity=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.enablePostProcessing=!0,i._sceneComponents=[],i._renderers=[],i._postProcessors=[],i.entities=new t.EntityList(i),i.renderableComponents=new t.RenderableComponentList,i.content=new t.ContentManager,i.entityProcessors=new t.EntityProcessorList,i.initialize(),i}return __extends(i,e),i.createWithDefaultRenderer=function(){var e=new i;return e.addRenderer(new t.DefaultRenderer),e},i.prototype.initialize=function(){},i.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},i.prototype.unload=function(){},i.prototype.onActive=function(){},i.prototype.onDeactive=function(){},i.prototype.begin=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){return 0==this._renderers.length&&(this.addRenderer(new t.DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new t.Camera),t.Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.addEventListener(egret.Event.ACTIVATE,this.onActive,this),this.addEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart(),[2]})})},i.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren();for(t=0;t<this._sceneComponents.length;t++)this._sceneComponents[t].onRemovedFromScene();this._sceneComponents.length=0,this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.parent&&this.parent.removeChild(this),this.unload()},i.prototype.update=function(){this.entities.updateLists();for(var t=this._sceneComponents.length-1;t>=0;t--)this._sceneComponents[t].enabled&&this._sceneComponents[t].update();this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},i.prototype.render=function(){if(0!=this._renderers.length)for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this);else console.error("场景中没有渲染器!")},i.prototype.postRender=function(){if(this.enablePostProcessing)for(var e=0;e<this._postProcessors.length;e++)this._postProcessors[e].enabled&&this._postProcessors[e].process();if(this._screenshotRequestCallback){var i=new egret.RenderTexture;i.drawToTexture(this,new t.Rectangle(0,0,this.stage.stageWidth,this.stage.stageHeight)),this._screenshotRequestCallback(i),this._screenshotRequestCallback=null}},i.prototype.requestScreenshot=function(t){this._screenshotRequestCallback=t},i.prototype.addSceneComponent=function(t){return t.scene=this,t.onEnabled(),this._sceneComponents.push(t),this._sceneComponents.sort(t.compareTo),t},i.prototype.getSceneComponent=function(t){for(var e=0;e<this._sceneComponents.length;e++){var i=this._sceneComponents[e];if(i instanceof t)return i}return null},i.prototype.getOrCreateSceneComponent=function(t){var e=this.getSceneComponent(t);return null==e&&(e=this.addSceneComponent(new t)),e},i.prototype.removeSceneComponent=function(t){this._sceneComponents.contains(t)?(this._sceneComponents.remove(t),t.onRemovedFromScene()):console.warn("SceneComponent"+t+"不在SceneComponents列表中!")},i.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},i.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},i.prototype.removeRenderer=function(t){this._renderers.contains(t)&&(this._renderers.remove(t),t.unload())},i.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},i.prototype.getPostProcessor=function(t){for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e]instanceof t)return this._postProcessors[e];return null},i.prototype.removePostProcessor=function(t){this._postProcessors.contains(t)&&(this._postProcessors.remove(t),t.unload())},i.prototype.createEntity=function(e){var i=new t.Entity(e);return this.addEntity(i)},i.prototype.createEntityAsync=function(t){var e=this;return new Promise(function(i){i(e.createEntity(t))})},i.prototype.addEntity=function(t){this.entities.buffer.contains(t)&&console.warn("您试图将同一实体添加到场景两次: "+t),this.entities.add(t),t.scene=this;for(var e=0;e<t.transform.childCount;e++)this.addEntity(t.transform.getChild(e).entity);return t},i.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},i.prototype.findEntity=function(t){return this.entities.findEntity(t)},i.prototype.findEntitiesWithTag=function(t){return this.entities.entitiesWithTag(t)},i.prototype.entitiesOfType=function(t){return this.entities.entitiesOfType(t)},i.prototype.findComponentOfType=function(t){return this.entities.findComponentOfType(t)},i.prototype.findComponentsOfType=function(t){return this.entities.findComponentsOfType(t)},i.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},i.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},i.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},i}(egret.DisplayObjectContainer);t.Scene=e}(es||(es={})),function(t){!function(t){t[t.position=0]="position",t[t.scale=1]="scale",t[t.rotation=2]="rotation"}(t.Component||(t.Component={}))}(transform||(transform={})),function(t){var e,i=egret.HashObject;!function(t){t[t.clean=0]="clean",t[t.positionDirty=1]="positionDirty",t[t.scaleDirty=2]="scaleDirty",t[t.rotationDirty=3]="rotationDirty"}(e=t.DirtyType||(t.DirtyType={}));var n=function(i){function n(e){var n=i.call(this)||this;return n._localTransform=t.Matrix2D.create(),n._worldTransform=t.Matrix2D.create().identity(),n._rotationMatrix=t.Matrix2D.create(),n._translationMatrix=t.Matrix2D.create(),n._scaleMatrix=t.Matrix2D.create(),n._worldToLocalTransform=t.Matrix2D.create().identity(),n._worldInverseTransform=t.Matrix2D.create().identity(),n._position=t.Vector2.zero,n._scale=t.Vector2.one,n._rotation=0,n._localPosition=t.Vector2.zero,n._localScale=t.Vector2.one,n._localRotation=0,n.entity=e,n.scale=t.Vector2.one,n._children=[],n}return __extends(n,i),Object.defineProperty(n.prototype,"childCount",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._rotation)},set:function(e){this.setRotation(t.MathHelper.toRadians(e))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._localRotation)},set:function(e){this.localRotation=t.MathHelper.toRadians(e)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localToWorldTransform",{get:function(){return this.updateTransform(),this._worldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"parent",{get:function(){return this._parent},set:function(t){this.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldToLocalTransform",{get:function(){return this._worldToLocalDirty&&(this.parent?(this.parent.updateTransform(),this._worldToLocalTransform=this.parent._worldTransform.invert()):this._worldToLocalTransform=t.Matrix2D.create().identity(),this._worldToLocalDirty=!1),this._worldToLocalTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldInverseTransform",{get:function(){return this.updateTransform(),this._worldInverseDirty&&(this._worldInverseTransform=this._worldTransform.invert(),this._worldInverseDirty=!1),this._worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"position",{get:function(){return this.updateTransform(),this._positionDirty&&(this.parent?(this.parent.updateTransform(),this._position=t.Vector2Ext.transformR(this._localPosition,this.parent._worldTransform)):this._position=this._localPosition,this._positionDirty=!1),this._position},set:function(t){this.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"scale",{get:function(){return this.updateTransform(),this._scale},set:function(t){this.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotation",{get:function(){return this.updateTransform(),this._rotation},set:function(t){this.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localPosition",{get:function(){return this.updateTransform(),this._localPosition},set:function(t){this.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localScale",{get:function(){return this.updateTransform(),this._localScale},set:function(t){this.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotation",{get:function(){return this.updateTransform(),this._localRotation},set:function(t){this.setLocalRotation(t)},enumerable:!0,configurable:!0}),n.prototype.getChild=function(t){return this._children[t]},n.prototype.setParent=function(t){return this._parent.equals(t)?this:(this._parent||(this._parent._children.remove(this),this._parent._children.push(this)),this._parent=t,this.setDirty(e.positionDirty),this)},n.prototype.setPosition=function(e,i){var n=new t.Vector2(e,i);return n.equals(this._position)?this:(this._position=n,this.parent?this.localPosition=t.Vector2Ext.transformR(this._position,this._worldToLocalTransform):this.localPosition=n,this._positionDirty=!1,this)},n.prototype.setLocalPosition=function(t){return t.equals(this._localPosition)?this:(this._localPosition=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.positionDirty),this)},n.prototype.setRotation=function(t){return this._rotation=t,this.parent?this.localRotation=this.parent.rotation+t:this.localRotation=t,this},n.prototype.setRotationDegrees=function(e){return this.setRotation(t.MathHelper.toRadians(e))},n.prototype.lookAt=function(e){var i=this.position.x>e.x?-1:1,n=t.Vector2.normalize(t.Vector2.subtract(this.position,e));this.rotation=i*Math.acos(t.Vector2.dot(n,t.Vector2.unitY))},n.prototype.setLocalRotation=function(t){return this._localRotation=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.rotationDirty),this},n.prototype.setLocalRotationDegrees=function(e){return this.setLocalRotation(t.MathHelper.toRadians(e))},n.prototype.setScale=function(e){return this._scale=e,this.parent?this.localScale=t.Vector2.divide(e,this.parent._scale):this.localScale=e,this},n.prototype.setLocalScale=function(t){return this._localScale=t,this._localDirty=this._positionDirty=this._localScaleDirty=!0,this.setDirty(e.scaleDirty),this},n.prototype.roundPosition=function(){this.position=this._position.round()},n.prototype.updateTransform=function(){this.hierarchyDirty!=e.clean&&(this.parent&&this.parent.updateTransform(),this._localDirty&&(this._localPositionDirty&&(this._translationMatrix=t.Matrix2D.create().translate(this._localPosition.x,this._localPosition.y),this._localPositionDirty=!1),this._localRotationDirty&&(this._rotationMatrix=t.Matrix2D.create().rotate(this._localRotation),this._localRotationDirty=!1),this._localScaleDirty&&(this._scaleMatrix=t.Matrix2D.create().scale(this._localScale.x,this._localScale.y),this._localScaleDirty=!1),this._localTransform=this._scaleMatrix.multiply(this._rotationMatrix),this._localTransform=this._localTransform.multiply(this._translationMatrix),this.parent||(this._worldTransform=this._localTransform,this._rotation=this._localRotation,this._scale=this._localScale,this._worldInverseDirty=!0),this._localDirty=!1),this.parent&&(this._worldTransform=this._localTransform.multiply(this.parent._worldTransform),this._rotation=this._localRotation+this.parent._rotation,this._scale=t.Vector2.multiply(this.parent._scale,this._localScale),this._worldInverseDirty=!0),this._worldToLocalDirty=!0,this._positionDirty=!0,this.hierarchyDirty=e.clean)},n.prototype.setDirty=function(e){if(0==(this.hierarchyDirty&e)){switch(this.hierarchyDirty|=e,e){case t.DirtyType.positionDirty:this.entity.onTransformChanged(transform.Component.position);break;case t.DirtyType.rotationDirty:this.entity.onTransformChanged(transform.Component.rotation);break;case t.DirtyType.scaleDirty:this.entity.onTransformChanged(transform.Component.scale)}this._children||(this._children=[]);for(var i=0;i<this._children.length;i++)this._children[i].setDirty(e)}},n.prototype.copyFrom=function(t){this._position=t.position,this._localPosition=t._localPosition,this._rotation=t._rotation,this._localRotation=t._localRotation,this._scale=t._scale,this._localScale=t._localScale,this.setDirty(e.positionDirty),this.setDirty(e.rotationDirty),this.setDirty(e.scaleDirty)},n.prototype.toString=function(){return"[Transform: parent: "+this.parent+", position: "+this.position+", rotation: "+this.rotation+",\n                scale: "+this.scale+", localPosition: "+this._localPosition+", localRotation: "+this._localRotation+",\n                localScale: "+this._localScale+"]"},n.prototype.equals=function(t){return t.hashCode==this.hashCode},n}(i);t.Transform=n}(es||(es={})),function(t){var e;!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(e=t.CameraStyle||(t.CameraStyle={}));var i=function(){return function(){this.left=0,this.right=0,this.top=0,this.bottom=0}}();t.CameraInset=i;var n=function(n){function r(r,o){void 0===r&&(r=null),void 0===o&&(o=e.lockOn);var s=n.call(this)||this;return s._inset=new i,s._areMatrixedDirty=!0,s._areBoundsDirty=!0,s._isProjectionMatrixDirty=!0,s.followLerp=.1,s.deadzone=new t.Rectangle,s.focusOffset=t.Vector2.zero,s.mapLockEnabled=!1,s.mapSize=new t.Rectangle,s._desiredPositionDelta=new t.Vector2,s._worldSpaceDeadZone=new t.Rectangle,s._minimumZoom=.3,s._maximumZoom=3,s._bounds=new t.Rectangle,s._transformMatrix=(new t.Matrix2D).identity(),s._inverseTransformMatrix=(new t.Matrix2D).identity(),s._origin=t.Vector2.zero,s._targetEntity=r,s._cameraStyle=o,s.setZoom(0),s}return __extends(r,n),Object.defineProperty(r.prototype,"position",{get:function(){return this.entity.transform.position},set:function(t){this.entity.transform.position=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"rotation",{get:function(){return this.entity.transform.rotation},set:function(t){this.entity.transform.rotation=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?t.MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):t.MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"bounds",{get:function(){if(this._areMatrixedDirty&&this.updateMatrixes(),this._areBoundsDirty){var e=this.screenToWorldPoint(new t.Vector2(this._inset.left,this._inset.top)),i=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,t.Core.graphicsDevice.viewport.height-this._inset.bottom));if(0!=this.entity.transform.rotation){var n=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,this._inset.top)),r=this.screenToWorldPoint(new t.Vector2(this._inset.left,t.Core.graphicsDevice.viewport.height-this._inset.bottom)),o=Math.min(e.x,i.x,n.x,r.x),s=Math.max(e.x,i.x,n.x,r.x),a=Math.min(e.y,i.y,n.y,r.y),h=Math.max(e.y,i.y,n.y,r.y);this._bounds.location=new t.Vector2(o,a),this._bounds.width=s-o,this._bounds.height=h-a}else this._bounds.location=e,this._bounds.width=i.x-e.x,this._bounds.height=i.y-e.y;this._areBoundsDirty=!1}return this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"transformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._transformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"inverseTransformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._inverseTransformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t,this._areMatrixedDirty=!0)},enumerable:!0,configurable:!0}),r.prototype.onSceneSizeChanged=function(e,i){var n=this._origin;this.origin=new t.Vector2(e/2,i/2),this.entity.transform.position=t.Vector2.add(this.entity.transform.position,t.Vector2.subtract(this._origin,n))},r.prototype.setInset=function(t,e,n,r){return this._inset=new i,this._inset.left=t,this._inset.right=e,this._inset.top=n,this._inset.bottom=r,this._areBoundsDirty=!0,this},r.prototype.setPosition=function(t){return this.entity.transform.setPosition(t.x,t.y),this},r.prototype.setRotation=function(t){return this.entity.transform.setRotation(t),this},r.prototype.setZoom=function(e){var i=t.MathHelper.clamp(e,-1,1);return this._zoom=0==i?1:i<0?t.MathHelper.map(i,-1,0,this._minimumZoom,1):t.MathHelper.map(i,0,1,1,this._maximumZoom),this._areMatrixedDirty=!0,this},r.prototype.setMinimumZoom=function(t){if(!(t<=0))return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this;console.error("minimumZoom must be greater than zero")},r.prototype.setMaximumZoom=function(t){if(!(t<=0))return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this;console.error("maximumZoom must be greater than zero")},r.prototype.onEntityTransformChanged=function(t){this._areMatrixedDirty=!0},r.prototype.zoomIn=function(t){this.zoom+=t},r.prototype.zoomOut=function(t){this.zoom-=t},r.prototype.worldToScreenPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._transformMatrix)},r.prototype.screenToWorldPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._inverseTransformMatrix)},r.prototype.mouseToWorldPoint=function(){return this.screenToWorldPoint(t.Input.touchPosition)},r.prototype.onAddedToEntity=function(){this.follow(this._targetEntity,this._cameraStyle)},r.prototype.update=function(){var e=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*t.Core.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*t.Core.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this._targetEntity&&this.updateFollow(),this.position=t.Vector2.lerp(this.position,t.Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.transform.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.transform.roundPosition())},r.prototype.clampToMapSize=function(e){var i=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5)).add(new t.Vector2(this.mapSize.x,this.mapSize.y)),n=new t.Vector2(this.mapSize.width-i.x,this.mapSize.height-i.y);return t.Vector2.clamp(e,i,n)},r.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this._cameraStyle==e.lockOn){var i=this._targetEntity.transform.position.x,n=this._targetEntity.transform.position.y;this._worldSpaceDeadZone.x>i?this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<i&&(this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<n?this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>n&&(this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this._targetEntity.getComponent(t.Collider),!this._targetCollider))return;var r=this._targetEntity.getComponent(t.Collider).bounds;this._worldSpaceDeadZone.containsRect(r)||(this._worldSpaceDeadZone.left>r.left?this._desiredPositionDelta.x=r.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<r.right&&(this._desiredPositionDelta.x=r.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<r.bottom?this._desiredPositionDelta.y=r.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>r.top&&(this._desiredPositionDelta.y=r.top-this._worldSpaceDeadZone.top))}},r.prototype.follow=function(i,n){switch(void 0===n&&(n=e.cameraWindow),this._targetEntity=i,this._cameraStyle=n,this._cameraStyle){case e.cameraWindow:var r=this.bounds.width/6,o=this.bounds.height/3;this.deadzone=new t.Rectangle((this.bounds.width-r)/2,(this.bounds.height-o)/2,r,o);break;case e.lockOn:this.deadzone=new t.Rectangle(this.bounds.width/2,this.bounds.height/2,10,10)}},r.prototype.setCenteredDeadzone=function(e,i){this.deadzone=new t.Rectangle((this.bounds.width-e)/2,(this.bounds.height-i)/2,e,i)},r.prototype.updateMatrixes=function(){var e;this._areMatrixedDirty&&(this._transformMatrix=t.Matrix2D.create().translate(-this.entity.transform.position.x,-this.entity.transform.position.y),1!=this._zoom&&(e=t.Matrix2D.create().scale(this._zoom,this._zoom),this._transformMatrix=this._transformMatrix.multiply(e)),0!=this.entity.transform.rotation&&(e=t.Matrix2D.create().rotate(this.entity.transform.rotation),this._transformMatrix=this._transformMatrix.multiply(e)),e=t.Matrix2D.create().translate(this._origin.x,this._origin.y),this._transformMatrix=this._transformMatrix.multiply(e),this._inverseTransformMatrix=this._transformMatrix.invert(),this._areBoundsDirty=!0,this._areMatrixedDirty=!1)},r}(t.Component);t.Camera=n}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i._shakeDirection=t.Vector2.zero,i._shakeOffset=t.Vector2.zero,i._shakeIntensity=0,i._shakeDegredation=.95,i}return __extends(i,e),i.prototype.shake=function(e,i,n){void 0===e&&(e=15),void 0===i&&(i=.9),void 0===n&&(n=t.Vector2.zero),this.enabled=!0,this._shakeIntensity<e&&(this._shakeDirection=n,this._shakeIntensity=e,(i<0||i>=1)&&(i=.95),this._shakeDegredation=i)},i.prototype.update=function(){Math.abs(this._shakeIntensity)>0&&(this._shakeOffset=this._shakeDirection,0!=this._shakeOffset.x||0!=this._shakeOffset.y?this._shakeOffset.normalize():(this._shakeOffset.x=this._shakeOffset.x+Math.random()-.5,this._shakeOffset.y=this._shakeOffset.y+Math.random()-.5),this._shakeOffset.multiply(new t.Vector2(this._shakeIntensity)),this._shakeIntensity*=-this._shakeDegredation,Math.abs(this._shakeIntensity)<=.01&&(this._shakeIntensity=0,this.enabled=!1)),this.entity.scene.camera.position.add(this._shakeOffset)},i}(t.Component);t.CameraShake=e}(es||(es={})),function(t){var e=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}();t.ComponentPool=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return t.updateOrder-e.updateOrder},t}();t.IUpdatableComparer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Component);t.PooledComponent=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.displayObject=new egret.DisplayObject,i.color=0,i._areBoundsDirty=!0,i._localOffset=t.Vector2.zero,i._renderLayer=0,i._bounds=new t.Rectangle,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.bounds.width},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.bounds.height},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"renderLayer",{get:function(){return this._renderLayer},set:function(t){this.setRenderLayer(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return this._areBoundsDirty&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,t.Vector2.zero,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible!=t&&(this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible())},enumerable:!0,configurable:!0}),i.prototype.onEntityTransformChanged=function(t){this._areBoundsDirty=!0},i.prototype.isVisibleFromCamera=function(t){return this.isVisible=t.bounds.intersects(this.displayObject.getBounds().union(this.bounds)),this.isVisible},i.prototype.setRenderLayer=function(t){if(t!=this._renderLayer){var e=this._renderLayer;this._renderLayer=t,this.entity&&this.entity.scene&&this.entity.scene.renderableComponents.updateRenderableRenderLayer(this,e,this._renderLayer)}return this},i.prototype.setColor=function(t){return this.color=t,this},i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this._localOffset=t),this},i.prototype.sync=function(e){var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y),this.displayObject.scaleX!=this.entity.scale.x&&(this.displayObject.scaleX=this.entity.scale.x),this.displayObject.scaleY!=this.entity.scale.y&&(this.displayObject.scaleY=this.entity.scale.y),this.displayObject.rotation!=this.entity.rotation&&(this.displayObject.rotation=this.entity.rotation)},i.prototype.toString=function(){return"[RenderableComponent] renderLayer: "+this.renderLayer},i.prototype.onBecameVisible=function(){this.displayObject.visible=this.isVisible},i.prototype.onBecameInvisible=function(){this.displayObject.visible=this.isVisible},i}(t.Component);t.RenderableComponent=e}(es||(es={})),function(t){var e=function(){function e(){this.updateOrder=0,this._enabled=!0}return Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.onRemovedFromScene=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled),this},e.prototype.setUpdateOrder=function(e){return this.updateOrder!=e&&(this.updateOrder=e,t.Core.scene._sceneComponents.sort(this.compareTo)),this},e.prototype.compareTo=function(t){return this.updateOrder-t.updateOrder},e}();t.SceneComponent=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(i){function n(e){void 0===e&&(e=null);var n=i.call(this)||this;return e instanceof t.Sprite?n.setSprite(e):e instanceof egret.Texture&&n.setSprite(new t.Sprite(e)),n}return __extends(n,i),Object.defineProperty(n.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this._sprite.sourceRect.width,this._sprite.sourceRect.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"originNormalized",{get:function(){return new t.Vector2(this._origin.x/this.width*this.entity.transform.scale.x,this._origin.y/this.height*this.entity.transform.scale.y)},set:function(e){this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"origin",{get:function(){return this._origin},set:function(t){this.setOrigin(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),n.prototype.setSprite=function(t){return this._sprite=t,this._sprite&&(this._origin=this._sprite.origin,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y),this.displayObject=new e(t.texture2D),this},n.prototype.setOrigin=function(t){return this._origin!=t&&(this._origin=t,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y,this._areBoundsDirty=!0),this},n.prototype.setOriginNormalized=function(e){return this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y)),this},n.prototype.render=function(e){this.sync(e);var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y)},n}(t.RenderableComponent);t.SpriteRenderer=i}(es||(es={})),function(t){var e=egret.Bitmap,i=egret.RenderTexture,n=function(n){function r(e){var i=n.call(this,e)||this;return i._textureScale=t.Vector2.one,i._inverseTexScale=t.Vector2.one,i._gapX=0,i._gapY=0,i._sourceRect=e.sourceRect,i.displayObject.$fillMode=egret.BitmapFillMode.REPEAT,i}return __extends(r,n),Object.defineProperty(r.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollX",{get:function(){return this._sourceRect.x},set:function(t){this._sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollY",{get:function(){return this._sourceRect.y},set:function(t){this._sourceRect.y=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y),this._sourceRect.width=this._sprite.sourceRect.width*this._inverseTexScale.x,this._sourceRect.height=this._sprite.sourceRect.height*this._inverseTexScale.y},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"width",{get:function(){return this._sourceRect.width},set:function(t){this._areBoundsDirty=!0,this._sourceRect.width=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"height",{get:function(){return this._sourceRect.height},set:function(t){this._areBoundsDirty=!0,this._sourceRect.height=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"gapXY",{get:function(){return new t.Vector2(this._gapX,this._gapY)},set:function(t){this._gapX=t.x,this._gapY=t.y;var n=new i,r=this.sprite.sourceRect;r.x=0,r.y=0,r.width+=this._gapX,r.height+=this._gapY,n.drawToTexture(this.displayObject,r),this.displayObject?this.displayObject.texture=n:this.displayObject=new e(n)},enumerable:!0,configurable:!0}),r.prototype.setGapXY=function(t){return this.gapXY=t,this},r.prototype.render=function(t){n.prototype.render.call(this,t);var e=this.displayObject;e.width=this.width,e.height=this.height,e.scrollRect=this._sourceRect},r}(t.SpriteRenderer);t.TiledSpriteRenderer=n}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.scrollSpeedX=15,i.scroolSpeedY=0,i._scrollX=0,i._scrollY=0,i._scrollWidth=0,i._scrollHeight=0,i._scrollWidth=i.width,i._scrollHeight=i.height,i}return __extends(i,e),Object.defineProperty(i.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollWidth",{get:function(){return this._scrollWidth},set:function(t){this._scrollWidth=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollHeight",{get:function(){return this._scrollHeight},set:function(t){this._scrollHeight=t},enumerable:!0,configurable:!0}),i.prototype.update=function(){this.sprite&&(this._scrollX+=this.scrollSpeedX*t.Time.deltaTime,this._scrollY+=this.scroolSpeedY*t.Time.deltaTime,this._sourceRect.x=this._scrollX,this._sourceRect.y=this._scrollY,this._sourceRect.width=this._scrollWidth+Math.abs(this._scrollX),this._sourceRect.height=this._scrollHeight+Math.abs(this._scrollY))},i}(t.TiledSpriteRenderer);t.ScrollingSpriteRenderer=e}(es||(es={})),function(t){var e=function(){return function(e,i,n){void 0===i&&(i=new t.Rectangle(0,0,e.textureWidth,e.textureHeight)),void 0===n&&(n=i.getHalfSize()),this.uvs=new t.Rectangle,this.texture2D=e,this.sourceRect=i,this.center=new t.Vector2(.5*i.width,.5*i.height),this.origin=n;var r=1/e.textureWidth,o=1/e.textureHeight;this.uvs.x=i.x*r,this.uvs.y=i.y*o,this.uvs.width=i.width*r,this.uvs.height=i.height*o}}();t.Sprite=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.sprites=t,this.frameRate=e}}();t.SpriteAnimation=e}(es||(es={})),function(t){var e,i;!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(e=t.LoopMode||(t.LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(i=t.State||(t.State={}));var n=function(n){function r(t){var e=n.call(this,t)||this;return e.speed=1,e.animationState=i.none,e._elapsedTime=0,e._animations=new Map,e}return __extends(r,n),Object.defineProperty(r.prototype,"isRunning",{get:function(){return this.animationState==i.running},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),r.prototype.update=function(){if(this.animationState==i.running&&this.currentAnimation){var n=this.currentAnimation,r=1/(n.frameRate*this.speed),o=r*n.sprites.length;this._elapsedTime+=t.Time.deltaTime;var s=Math.abs(this._elapsedTime);if(this._loopMode==e.once&&s>o||this._loopMode==e.pingPongOnce&&s>2*o)return this.animationState=i.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=n.sprites[this.currentFrame]);var a=Math.floor(s/r),h=n.sprites.length;if(h>2&&(this._loopMode==e.pingPong||this._loopMode==e.pingPongOnce)){var c=h-1;this.currentFrame=c-Math.abs(c-a%(2*c))}else this.currentFrame=a%h;this.sprite=n.sprites[this.currentFrame]}},r.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},r.prototype.play=function(t,n){void 0===n&&(n=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=i.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=n||e.loop},r.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},r.prototype.pause=function(){this.animationState=i.paused},r.prototype.unPause=function(){this.animationState=i.running},r.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=i.none},r}(t.SpriteRenderer);t.SpriteAnimator=n}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"hasCollision",{get:function(){return this.below||this.right||this.left||this.above},enumerable:!0,configurable:!0}),t.prototype.reset=function(){this.becameGroundedThisFrame=this.isGroundedOnOnewayPlatform=this.right=this.left=this.above=this.below=!1,this.slopAngle=0},t.prototype.toString=function(){return"[CollisionState] r: "+this.right+", l: "+this.left+", a: "+this.above+", b: "+this.below+", angle: "+this.slopAngle+", wasGroundedLastFrame: "+this.wasGroundedLastFrame+", becameGroundedThisFrame: "+this.becameGroundedThisFrame},t}();t.CollisionState=e;var i=function(e){function i(){var t=e.call(this)||this;return t.colliderHorizontalInset=2,t.colliderVerticalInset=6,t}return __extends(i,e),i.prototype.testCollisions=function(e,i,n){this._boxColliderBounds=i,n.wasGroundedLastFrame=n.below,n.reset();var r=e.x;e.y;if(0!=r){var o=r>0?t.Edge.right:t.Edge.left,s=this.collisionRectForSide(o,r);this.testMapCollision(s,o,n,0)?(e.x=0-t.RectangleExt.getSide(i,o),n.left=o==t.Edge.left,n.right=o==t.Edge.right,n._movementRemainderX.reset()):(n.left=!1,n.right=!1)}},i.prototype.testMapCollision=function(e,i,n,r){var o=t.EdgeExt.oppositeEdge(i);t.EdgeExt.isVertical(o)?e.center.x:e.center.y,t.RectangleExt.getSide(e,i),t.EdgeExt.isVertical(o)},i.prototype.collisionRectForSide=function(e,i){var n;return n=t.EdgeExt.isHorizontal(e)?t.RectangleExt.getRectEdgePortion(this._boxColliderBounds,e):t.RectangleExt.getHalfRect(this._boxColliderBounds,e),t.EdgeExt.isVertical(e)?t.RectangleExt.contract(n,this.colliderHorizontalInset,0):t.RectangleExt.contract(n,0,this.colliderVerticalInset),t.RectangleExt.expandSide(n,e,i),n},i}(t.Component);t.TiledMapMover=i}(es||(es={})),function(t){var e=function(e){function i(t,i,n){void 0===i&&(i=null),void 0===n&&(n=!0);var r=e.call(this)||this;return r.physicsLayer=1,r.toContainer=!1,r.tiledMap=t,r._shouldCreateColliders=n,r.displayObject=new egret.DisplayObjectContainer,i&&(r.collisionLayer=t.tileLayers[i]),r}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.tiledMap.width*this.tiledMap.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.tiledMap.height*this.tiledMap.tileHeight},enumerable:!0,configurable:!0}),i.prototype.setLayerToRender=function(t){this.layerIndicesToRender=[],this.layerIndicesToRender[0]=this.getLayerIndex(t)},i.prototype.setLayersToRender=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];this.layerIndicesToRender=[];for(var i=0;i<t.length;i++)this.layerIndicesToRender[i]=this.getLayerIndex(t[i])},i.prototype.getLayerIndex=function(t){var e=this.tiledMap.getLayer(t);for(var i in this.tiledMap.layers)if(this.tiledMap.layers.hasOwnProperty(i)&&this.tiledMap.layers[i]==e)return 0;return-1},i.prototype.getRowAtWorldPosition=function(t){return t-=this.entity.transform.position.y+this._localOffset.y,this.tiledMap.worldToTilePositionY(t)},i.prototype.getColumnAtWorldPosition=function(t){return t-=this.entity.transform.position.x+this._localOffset.x,this.tiledMap.worldToTilePositionX(t)},i.prototype.onEntityTransformChanged=function(t){this._shouldCreateColliders&&t==transform.Component.position&&(this.removeColliders(),this.addColliders())},i.prototype.onAddedToEntity=function(){this.addColliders()},i.prototype.onRemovedFromEntity=function(){this.removeColliders()},i.prototype.update=function(){this.tiledMap.update()},i.prototype.render=function(e){if(this.sync(e),this.layerIndicesToRender)for(var i=0;i<this.tiledMap.layers.length;i++)this.tiledMap.layers[i].visible&&this.layerIndicesToRender.contains(i)&&t.TiledRendering.renderLayerRenderCamera(this.tiledMap.layers[i],this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer,e.bounds);else t.TiledRendering.renderMap(this.tiledMap,this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer);this.toContainer||(this.displayObject.cacheAsBitmap=!0,this.toContainer=!0)},i.prototype.addColliders=function(){if(this.collisionLayer&&this._shouldCreateColliders){var e=this.collisionLayer.getCollisionRectangles();this._colliders=[];for(var i=0;i<e.length;i++){var n=(new t.BoxCollider).createBoxRect(e[i].x+this._localOffset.x,e[i].y+this._localOffset.y,e[i].width,e[i].height);n.physicsLayer=this.physicsLayer,n.entity=this.entity,this._colliders[i]=n,t.Physics.addCollider(n)}}},i.prototype.removeColliders=function(){if(null!=this._colliders){for(var e=0,i=this._colliders;e<i.length;e++){var n=i[e];t.Physics.removeCollider(n)}this._colliders=null}},i}(t.RenderableComponent);t.TiledMapRenderer=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._triggerHelper=new t.ColliderTriggerHelper(this.entity)},i.prototype.calculateMovement=function(e,i){if(!this.entity.getComponent(t.Collider)||!this._triggerHelper)return!1;for(var n=this.entity.getComponents(t.Collider),r=0;r<n.length;r++){var o=n[r];if(!o.isTrigger){var s=o.bounds;s.x+=e.x,s.y+=e.y;for(var a=t.Physics.boxcastBroadphaseExcludingSelf(o,s,o.collidesWithLayers),h=0;h<a.length;h++){var c=a[h];if(!c.isTrigger){var u=new t.CollisionResult;o.collidesWith(c,e,u)&&(e=e.subtract(u.minimumTranslationVector),null!=u.collider&&(i=u))}}}}return t.ListPool.free(n),null!=i.collider},i.prototype.applyMovement=function(e){this.entity.position=t.Vector2.add(this.entity.position,e),this._triggerHelper&&this._triggerHelper.update()},i.prototype.move=function(t,e){return this.calculateMovement(t,e),this.applyMovement(t),null!=e.collider},i}(t.Component);t.Mover=e}(es||(es={})),function(t){var e=function(e){function i(){var t=null!==e&&e.apply(this,arguments)||this;return t._tempTriggerList=[],t}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(t.Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},i.prototype.move=function(e){if(!this._collider)return!1;var i=!1;this.entity.position=t.Vector2.add(this.entity.position,e);for(var n=t.Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),r=0;r<n.length;r++){var o=n[r];this._collider.overlaps(o)&&o.enabled&&(i=!0,this.notifyTriggerListeners(this._collider,o))}return i},i.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(e,t);this._tempTriggerList.length=0},i}(t.Component);t.ProjectileMover=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.physicsLayer=1,i.collidesWithLayers=t.Physics.allLayers,i.shouldColliderScaleAndRotateWithTransform=!0,i.registeredPhysicsBounds=new t.Rectangle,i._isPositionDirty=!0,i._isRotationDirty=!0,i._localOffset=t.Vector2.zero,i}return __extends(i,e),Object.defineProperty(i.prototype,"absolutePosition",{get:function(){return t.Vector2.add(this.entity.transform.position,this._localOffset)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"rotation",{get:function(){return this.shouldColliderScaleAndRotateWithTransform&&this.entity?this.entity.transform.rotation:0},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return(this._isPositionDirty||this._isRotationDirty)&&(this.shape.recalculateBounds(this),this._isPositionDirty=this._isRotationDirty=!1),this.shape.bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this.unregisterColliderWithPhysicsSystem(),this._localOffset=t,this._localOffsetLength=this._localOffset.length(),this._isPositionDirty=!0,this.registerColliderWithPhysicsSystem()),this},i.prototype.setShouldColliderScaleAndRotateWithTransform=function(t){return this.shouldColliderScaleAndRotateWithTransform=t,this._isPositionDirty=this._isRotationDirty=!0,this},i.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){if(!(this instanceof t.BoxCollider||this instanceof t.CircleCollider))return void console.error("Only box and circle colliders can be created automatically");var e=this.entity.getComponent(t.RenderableComponent);if(e){var i=e.bounds,n=i.width/this.entity.scale.x,r=i.height/this.entity.scale.y;this instanceof t.CircleCollider?this.radius=.5*Math.max(n,r):(this.width=n,this.height=r),this.localOffset=t.Vector2.subtract(i.center,this.entity.transform.position)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},i.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1},i.prototype.onEntityTransformChanged=function(e){switch(e){case transform.Component.position:case transform.Component.scale:this._isPositionDirty=!0;break;case transform.Component.rotation:this._isRotationDirty=!0}this._isColliderRegistered&&t.Physics.updateCollider(this)},i.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem(),this._isPositionDirty=this._isRotationDirty=!0},i.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},i.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(t.Physics.addCollider(this),this._isColliderRegistered=!0)},i.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&t.Physics.removeCollider(this),this._isColliderRegistered=!1},i.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},i.prototype.collidesWith=function(t,e,i){var n=this.entity.position;this.entity.position=this.entity.position.add(e);var r=this.shape.collidesWithShape(t.shape,i);return r&&(i.collider=t),this.entity.position=n,r},i.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,this.shape&&(t.shape=this.shape.clone()),t},i}(t.Component);t.Collider=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.shape=new t.Box(1,1),i._colliderRequiresAutoSizing=!0,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),i.prototype.createBoxRect=function(e,i,n,r){return this._localOffset=new t.Vector2(e+n/2,i+n/2),this.shape=new t.Box(n,r),this._colliderRequiresAutoSizing=!1,this},i.prototype.setSize=function(e,i){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e==n.width&&i==n.height||(n.updateBox(e,i),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setWidth=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.width&&(i.updateBox(e,i.height),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setHeight=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;e!=i.height&&(i.updateBox(i.width,e),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this))},i.prototype.toString=function(){return"[BoxCollider: bounds: "+this.bounds+"]"},i}(t.Collider);t.BoxCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;return i&&(n._colliderRequiresAutoSizing=!0),n.shape=new t.Circle(i||1),n}return __extends(i,e),Object.defineProperty(i.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),i.prototype.setRadius=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.radius&&(i.radius=e,i._originalRadius=e,this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.toString=function(){return"[CircleCollider: bounds: "+this.bounds+", radius: "+this.shape.radius+"]"},i}(t.Collider);t.CircleCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;i[0]==i[i.length-1]&&i.splice(i.length-1,1);var r=t.Polygon.findPolygonCenter(i);return n.setLocalOffset(r),t.Polygon.recenterPolygonVerts(i),n.shape=new t.Polygon(i),n}return __extends(i,e),i}(t.Collider);t.PolygonCollider=e}(es||(es={})),function(t){var e=function(){function e(e){this._entities=[],this._matcher=e||t.Matcher.empty()}return Object.defineProperty(e.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onChanged=function(t){var e=this._entities.contains(t),i=this._matcher.IsIntersted(t);i&&!e?this.add(t):!i&&e&&this.remove(t)},e.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},e.prototype.onAdded=function(t){},e.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},e.prototype.onRemoved=function(t){},e.prototype.update=function(){this.begin(),this.process(this._entities)},e.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},e.prototype.begin=function(){},e.prototype.process=function(t){},e.prototype.lateProcess=function(t){},e.prototype.end=function(){},e}();t.EntitySystem=e}(es||(es={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(t.EntitySystem);t.EntityProcessingSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(t.EntitySystem);t.PassiveSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(t.EntitySystem);t.ProcessingSystem=e}(es||(es={})),function(t){var e=function(){function t(e){void 0===e&&(e=64);var i=e>>6;0!=(e&t.LONG_MASK)&&i++,this._bits=new Array(i)}return t.prototype.and=function(t){for(var e,i=Math.min(this._bits.length,t._bits.length),n=0;n<i;++n)this._bits[n]&=t._bits[n];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var i=this._bits[e];if(0!=i)if(-1!=i){var n=((i=((i=(i>>1&0x5555555555555400)+(0x5555555555555400&i))>>2&0x3333333333333400)+(0x3333333333333400&i))>>32)+i;t+=((n=((n=(n>>4&252645135)+(252645135&n))>>8&16711935)+(16711935&n))>>16&65535)+(65535&n)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var i=0;i<this._bits.length;i++)this._bits[i]=0},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,i=1<<t;e<this._bits.length;){var n=this._bits[e];do{if(0!=(n&i))return t;i<<=1,t++}while(0!=i);i=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var i=t>>6;this.ensure(i),this._bits[i]|=1<<t}else this.clear(t)},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.LONG_MASK=63,t}();t.BitSet=e}(es||(es={})),function(t){var e=function(){function e(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isComponentListUnsorted=!0},e.prototype.add=function(t){this._componentsToAdd.push(t)},e.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},e.prototype.deregisterAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.removeChild(i.displayObject),this._entity.scene.renderableComponents.remove(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},e.prototype.registerAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.addChild(i.displayObject),this._entity.scene.renderableComponents.add(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},e.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var i=0;i<this._componentsToRemove.length;i++)this.handleRemove(this._componentsToRemove[i]),this._components.remove(this._componentsToRemove[i]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){i=0;for(var n=this._componentsToAdd.length;i<n;i++){(r=this._componentsToAdd[i])instanceof t.RenderableComponent&&(this._entity.scene.addChild(r.displayObject),this._entity.scene.renderableComponents.add(r)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(r)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(r),this._tempBufferList.push(r)}this._componentsToAdd.length=0,this._isComponentListUnsorted=!0;for(i=0;i<this._tempBufferList.length;i++){var r;(r=this._tempBufferList[i]).onAddedToEntity(),r.enabled&&r.onEnabled()}this._tempBufferList.length=0}this._isComponentListUnsorted&&(this._components.sort(e.compareUpdatableOrder.compare),this._isComponentListUnsorted=!1)},e.prototype.handleRemove=function(e){e instanceof t.RenderableComponent&&(this._entity.scene.removeChild(e.displayObject),this._entity.scene.renderableComponents.remove(e)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),e.onRemovedFromEntity(),e.entity=null},e.prototype.getComponent=function(t,e){for(var i=0;i<this._components.length;i++){if((n=this._components[i])instanceof t)return n}if(!e)for(i=0;i<this._componentsToAdd.length;i++){var n;if((n=this._componentsToAdd[i])instanceof t)return n}return null},e.prototype.getComponents=function(t,e){e||(e=[]);for(var i=0;i<this._components.length;i++){var n=this._components[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}for(i=0;i<this._componentsToAdd.length;i++){n=this._componentsToAdd[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}return e},e.prototype.update=function(){this.updateLists();for(var e=0;e<this._components.length;e++){var i=this._components[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},e.prototype.onEntityEnabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onEnabled()},e.prototype.onEntityDisabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onDisabled()},e.compareUpdatableOrder=new t.IUpdatableComparer,e}();t.ComponentList=e}(es||(es={})),function(t){var e=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}();t.ComponentTypeManager=e}(es||(es={})),function(t){var e=function(){function e(t){this._entities=[],this._entitiesToAdded=[],this._entitiesToRemove=[],this._entityDict=new Map,this._unsortedTags=[],this._tempEntityList=[],this.scene=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isEntityListUnsorted=!0},e.prototype.markTagUnsorted=function(t){this._unsortedTags.push(t)},e.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},e.prototype.remove=function(t){this._entitiesToRemove.contains(t)?this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t):console.warn("You are trying to remove an entity ("+t.name+") that you already removed")},e.prototype.removeAllEntities=function(){this._unsortedTags.length=0,this._entitiesToAdded.length=0,this._isEntityListUnsorted=!1,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestroyed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},e.prototype.contains=function(t){return this._entities.contains(t)||this._entitiesToAdded.contains(t)},e.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},e.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},e.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},e.prototype.update=function(){for(var e=0;e<this._entities.length;e++){var i=this._entities[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t.removeFromTagList(e),t._entities.remove(e),e.onRemovedFromScene(),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.addToTagList(e),t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0,this._isEntityListUnsorted=!0}this._isEntityListUnsorted&&(this._entities.sort(),this._isEntityListUnsorted=!1),this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},e.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},e.prototype.entitiesWithTag=function(e){for(var i=this.getTagList(e),n=t.ListPool.obtain(),r=0;r<i.length;r++)n.push(i[r]);return n},e.prototype.entitiesOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n]instanceof e&&i.push(this._entities[n]);return this._entitiesToAdded.forEach(function(t){t instanceof e&&i.push(t)}),i},e.prototype.findComponentOfType=function(t){for(var e=0;e<this._entities.length;e++){if(this._entities[e].enabled)if(i=this._entities[e].getComponent(t))return i}for(e=0;e<this._entitiesToAdded.length;e++){var i,n=this._entitiesToAdded[e];if(n.enabled)if(i=n.getComponent(t))return i}return null},e.prototype.findComponentsOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n].enabled&&this._entities[n].getComponents(e,i);for(n=0;n<this._entitiesToAdded.length;n++){var r=this._entitiesToAdded[n];r.enabled&&r.getComponents(e,i)}return i},e}();t.EntityList=e}(es||(es={})),function(t){var e=function(){function e(){this._processors=[]}return e.prototype.add=function(t){this._processors.push(t)},e.prototype.remove=function(t){this._processors.remove(t)},e.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},e.prototype.begin=function(){},e.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},e.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},e.prototype.end=function(){},e.prototype.getProcessor=function(){for(var e=0;e<this._processors.length;e++){var i=this._processors[e];if(i instanceof t.EntitySystem)return i}return null},e.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},e.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},e}();t.EntityProcessorList=e}(es||(es={})),function(t){var e=function(){function e(){this.allSet=new t.BitSet,this.exclusionSet=new t.BitSet,this.oneSet=new t.BitSet}return e.empty=function(){return new e},e.prototype.getAllSet=function(){return this.allSet},e.prototype.getExclusionSet=function(){return this.exclusionSet},e.prototype.getOneSet=function(){return this.oneSet},e.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},e.prototype.all=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.allSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.exclude=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.exclusionSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.one=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.oneSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e}();t.Matcher=e}(es||(es={}));var ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var i in t)"object"==typeof t[i]?(e[i]=t[i]instanceof Array?[]:{},this.clone(t[i],e[i])):e[i]=t[i];return e},t.elements=function(t){var e=[];for(var i in t)if(Array.isArray(t[i]))for(var n=0,r=t[i];n<r.length;n++){var o=r[n];e.push(o)}else e.push(t[i]);return e},t}();!function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return e.renderLayer-t.renderLayer},t}();t.RenderableComparer=e}(es||(es={})),function(t){var e=function(){function e(){this._components=[],this._componentsByRenderLayer=new Map,this._unsortedRenderLayers=[],this._componentsNeedSort=!0}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.add=function(t){this._components.push(t),this.addToRenderLayerList(t,t.renderLayer)},e.prototype.remove=function(t){this._components.remove(t),this._componentsByRenderLayer.get(t.renderLayer).remove(t)},e.prototype.updateRenderableRenderLayer=function(t,e,i){this._componentsByRenderLayer.has(e)&&this._componentsByRenderLayer.get(e).contains(t)&&(this._componentsByRenderLayer.get(e).remove(t),this.addToRenderLayerList(t,i))},e.prototype.setRenderLayerNeedsComponentSort=function(t){this._unsortedRenderLayers.contains(t)||this._unsortedRenderLayers.push(t),this._componentsNeedSort=!0},e.prototype.setNeedsComponentSort=function(){this._componentsNeedSort=!0},e.prototype.addToRenderLayerList=function(t,e){var i=this.componentsWithRenderLayer(e);i.contains(t)?console.warn("组件呈现层列表已经包含此组件"):(i.push(t),this._unsortedRenderLayers.contains(e)||this._unsortedRenderLayers.push(e),this._componentsNeedSort=!0)},e.prototype.componentsWithRenderLayer=function(t){return this._componentsByRenderLayer.get(t)||this._componentsByRenderLayer.set(t,[]),this._componentsByRenderLayer.get(t)},e.prototype.updateList=function(){if(this._componentsNeedSort&&(this._components.sort(e.compareUpdatableOrder.compare),this._componentsNeedSort=!1,this.updateEgretList()),this._unsortedRenderLayers.length>0){for(var t=0,i=this._unsortedRenderLayers.length;t<i;t++){var n=this._componentsByRenderLayer.get(this._unsortedRenderLayers[t]);n&&n.sort(e.compareUpdatableOrder.compare)}this._unsortedRenderLayers.length=0,this.updateEgretList()}},e.prototype.updateEgretList=function(){var e=t.Core._instance._scene;if(e)for(var i=function(t){var i=n._components[t],r=e.$children.find(function(t){return t.hashCode==i.displayObject.hashCode}),o=e.getChildIndex(r);o!=t&&e.swapChildrenAt(o,t)},n=this,r=0;r<this._components.length;r++)i(r)},e.compareUpdatableOrder=new t.RenderableComparer,e}();t.RenderableComponentList=e}(es||(es={}));var StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,i,n){void 0===n&&(n=!1);for(var r=t.length,o="",s=!1,a=1==n?e.toLowerCase():e,h=0;h<r;h++)s=!1,t.charAt(h)==a.charAt(0)&&t.substr(h,a.length)==a&&(s=!0),s?(o+=i,h=h+a.length-1):o+=t.charAt(h);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var i=this.specialSigns.length,n=0;n<i;n+=2){var r=void 0,o=void 0;if(r=this.specialSigns[n],o=this.specialSigns[n+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var i=t.length;if(i>=e)return t;var n=!1;"-"==t.substr(0,1)&&(n=!0,t=t.substr(1));for(var r=e-i,o=0;o<r;o++)t="0"+t;return n&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,i,n){void 0===n&&(n=!0),e=Math.floor(e),i=Math.floor(i);var r=t.length;e>r&&(e=r);var o,s=e,a=e+i;return n?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-i)+i,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var i=0,n=e.length;i<n;i++)null!=e[i]&&""!=e[i]||(e[i]="无"),t=t.replace("{"+i+"}",e[i]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}();!function(t){var e=function(){function e(){}return e.convertImageToCanvas=function(e,i){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var n=e.$getTextureWidth(),r=e.$getTextureHeight();i||((i=egret.$TempRectangle).x=0,i.y=0,i.width=n,i.height=r),i.x=Math.min(i.x,n-1),i.y=Math.min(i.y,r-1),i.width=Math.min(i.width,n-i.x),i.height=Math.min(i.height,r-i.y);var o=Math.floor(i.width),s=Math.floor(i.height),a=this.sharedCanvas;if(a.style.width=o+"px",a.style.height=s+"px",this.sharedCanvas.width=o,this.sharedCanvas.height=s,"webgl"==egret.Capabilities.renderMode){var h=void 0;e.$renderBuffer?h=e:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(h=new egret.RenderTexture).drawToTexture(new egret.Bitmap(e)));for(var c=h.$renderBuffer.getPixels(i.x,i.y,o,s),u=0,l=0,p=0;p<c.length;p+=4)this.sharedContext.fillStyle="rgba("+c[p]+","+c[p+1]+","+c[p+2]+","+c[p+3]/255+")",this.sharedContext.fillRect(u,l,1,1),++u==o&&(u=0,l++);return e.$renderBuffer||h.dispose(),a}var d=e,f=Math.round(d.$offsetX),g=Math.round(d.$offsetY),m=d.$bitmapWidth,y=d.$bitmapHeight,_=t.Core._instance.stage.textureScaleFactor;return this.sharedContext.drawImage(d.$bitmapData.source,d.$bitmapX+i.x/_,d.$bitmapY+i.y/_,m*i.width/n,y*i.height/r,f,g,i.width,i.height),a},e.toDataURL=function(t,e,i,n){try{return this.convertImageToCanvas(e,i).toDataURL(t,n)}catch(t){egret.$error(1033)}return null},e.eliFoTevas=function(t,e,i,n,r){var o=this.convertImageToCanvas(e,n).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+i,success:function(t){}}),o},e.getPixel32=function(t,e,i){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,i)},e.getPixels=function(t,e,i,n,r){if(void 0===n&&(n=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,i,n,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,i,n,r).data}catch(t){egret.$error(1039)}},e}();t.TextureUtils=e}(es||(es={})),function(t){var e=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}();t.Time=e}(es||(es={}));var TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),i=t.getMonth()+1;return parseInt(e+(i<10?"0":"")+i)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,i=e<10?"0":"",n=t.getDate(),r=n<10?"0":"";return parseInt(t.getFullYear()+i+e+r+n)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var i=new Date;i.setTime(t.getTime()),i.setDate(1),i.setMonth(0);var n=i.getFullYear(),r=i.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,i.setDate(i.getDate()-(r-1))):i.setDate(i.getDate()+7-r+1);var s=this.diffDay(t,i,!1);if(s<0)return i.setDate(1),i.setMonth(0),i.setDate(i.getDate()-1),this.weekId(i,!1);var a=s/7,h=Math.floor(a)+1;if(53==h){i.setTime(t.getTime()),i.setDate(i.getDate()-1);var c=i.getDay();if(0==c&&(c=7),e&&(!o||c<4))return i.setFullYear(i.getFullYear()+1),i.setDate(1),i.setMonth(0),this.weekId(i,!1)}return parseInt(n+"00"+(h>9?"":"0")+h)},t.diffDay=function(t,e,i){void 0===i&&(i=!1);var n=(t.getTime()-e.getTime())/864e5;return i?Math.ceil(n):Math.floor(n)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();return e+"-"+i+"-"+(n=n<10?"0"+n:n)},t.formatDateTime=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();n=n<10?"0"+n:n;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+i+"-"+n+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,i){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===i&&(i=!0);var n=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=n.toString(),a=r.toString(),h=o.toString();return n<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(h="0"+h),i?s+e+a+e+h:a+e+h},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var i=t.split(e),n=0,r=i.length,o=0;o<r;o++){n+=i[o]*Math.pow(60,r-1-o)}return(n*=1e3).toString()},t}();!function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){if(e.runtimeType==egret.RuntimeType.WXGAME){this.isMobile=!0;var i=wx.getSystemInfoSync(),n=i.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var r=i.language;r=r.indexOf("zh")>-1?"zh-CN":"en-US",this.language=r}},e}(egret.Capabilities);t.GraphicsCapabilities=e}(es||(es={})),function(t){var e=function(){function e(){this.setup(),this.graphicsCapabilities=new t.GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}return Object.defineProperty(e.prototype,"viewport",{get:function(){return this._viewport},enumerable:!0,configurable:!0}),e.prototype.setup=function(){this._viewport=new t.Viewport(0,0,t.Core._instance.stage.stageWidth,t.Core._instance.stage.stageHeight)},e}();t.GraphicsDevice=e}(es||(es={})),function(t){var e=function(){function e(t,e,i,n){this._x=t,this._y=e,this._width=i,this._height=n,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(e.prototype,"width",{get:function(){return this._width},set:function(t){this._width=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"height",{get:function(){return this._height},set:function(t){this._height=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new t.Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),e}();t.Viewport=e}(es||(es={})),function(t){var e=function(e){function i(){return e.call(this,t.PostProcessor.default_vert,i.blur_frag,{screenWidth:t.Core.graphicsDevice.viewport.width,screenHeight:t.Core.graphicsDevice.viewport.height})||this}return __extends(i,e),i.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",i}(egret.CustomFilter);t.GaussianBlurEffect=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter);t.PolygonLightEffect=e}(es||(es={})),function(t){var e=function(){function e(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return e.prototype.onAddedToScene=function(e){this.scene=e,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.shape.graphics.endFill(),e.addChild(this.shape)},e.prototype.process=function(){this.drawFullscreenQuad()},e.prototype.onSceneBackBufferSizeChanged=function(t,e){},e.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},e.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},e.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",e}();t.PostProcessor=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToScene=function(i){e.prototype.onAddedToScene.call(this,i),this.effect=new t.GaussianBlurEffect},i}(t.PostProcessor);t.GaussianBlurPostProcessor=e}(es||(es={})),function(t){var e=function(){function t(t,e){void 0===e&&(e=null),this.renderOrder=0,this.camera=e,this.renderOrder=t}return t.prototype.onAddedToScene=function(t){},t.prototype.unload=function(){},t.prototype.onSceneBackBufferSizeChanged=function(t,e){},t.prototype.compareTo=function(t){return this.renderOrder-t.renderOrder},t.prototype.beginRender=function(t){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t}();t.Renderer=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,0,null)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var i=0;i<t.renderableComponents.count;i++){var n=t.renderableComponents.buffer[i];n.enabled&&n.isVisibleFromCamera(e)&&this.renderAfterStateCheck(n,e)}},e}(t.Renderer);t.DefaultRenderer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){},e}(t.Renderer);t.ScreenSpaceRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e,i,n){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=n,r.color=i,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e}(t.RenderableComponent);t.PolyLight=e}(es||(es={})),function(t){var e=function(){function e(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(e.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),e.prototype.preRender=function(){},e.prototype.render=function(){},e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},e.prototype.tickEffectProgressProperty=function(t,e,i,n){return void 0===n&&(n=!1),new Promise(function(r){var o=n?1:0,s=n?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,i).call(function(){r()})})},e.prototype.transitionComplete=function(){t.Core._instance._sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},e.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),e=t.Core,[4,this.sceneLoadAction()];case 1:return e.scene=i.sent(),this.isNewSceneLoaded=!0,[2]}})})},e}();t.SceneTransition=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.fadeToColor=0,i.fadeOutDuration=.4,i.fadeEaseType=egret.Ease.quadInOut,i.delayBeforeFadeInDuration=.1,i._alpha=0,i._mask=new egret.Shape,i}return __extends(i,e),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var e=this;return __generator(this,function(i){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill(),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(e,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(e).to({_alpha:0},1e3*e.fadeOutDuration,e.fadeEaseType).call(function(){e.transitionComplete()})}),[2]})})},i.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill()},i}(t.SceneTransition);t.FadeTransition=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this,i)||this;n.duration=1,n.easeType=egret.Ease.quadOut;return n._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),n._mask=new egret.Shape,n._mask.graphics.beginFill(16777215,1),n._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),n._mask.graphics.endFill(),n._mask.filters=[n._windEffect],n}return __extends(i,e),Object.defineProperty(i.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return t.sent(),this.transitionComplete(),[2]}})})},i}(t.SceneTransition);t.WindTransition=e}(es||(es={})),function(t){var e=function(){function e(){}return e.getPoint=function(e,i,n,r){var o=1-(r=t.MathHelper.clamp01(r));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(o*o),e),t.Vector2.multiply(new t.Vector2(2*o*r),i)),t.Vector2.multiply(new t.Vector2(r*r),n))},e.getFirstDerivative=function(e,i,n,r){return t.Vector2.add(t.Vector2.multiply(new t.Vector2(2*(1-r)),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(2*r),t.Vector2.subtract(n,i)))},e.getFirstDerivativeThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(3*s*s),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(6*s*o),t.Vector2.subtract(n,i))),t.Vector2.multiply(new t.Vector2(3*o*o),t.Vector2.subtract(r,n)))},e.getPointThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(s*s*s),e),t.Vector2.multiply(new t.Vector2(3*s*s*o),i)),t.Vector2.multiply(new t.Vector2(3*s*o*o),n)),t.Vector2.multiply(new t.Vector2(o*o*o),r))},e.getOptimizedDrawingPoints=function(e,i,n,r,o){void 0===o&&(o=1);var s=t.ListPool.obtain();return s.push(e),this.recursiveGetOptimizedDrawingPoints(e,i,n,r,s,o),s.push(r),s},e.recursiveGetOptimizedDrawingPoints=function(e,i,n,r,o,s){var a=t.Vector2.divide(t.Vector2.add(e,i),new t.Vector2(2)),h=t.Vector2.divide(t.Vector2.add(i,n),new t.Vector2(2)),c=t.Vector2.divide(t.Vector2.add(n,r),new t.Vector2(2)),u=t.Vector2.divide(t.Vector2.add(a,h),new t.Vector2(2)),l=t.Vector2.divide(t.Vector2.add(h,c),new t.Vector2(2)),p=t.Vector2.divide(t.Vector2.add(u,l),new t.Vector2(2)),d=t.Vector2.subtract(r,e),f=Math.abs((i.x,r.x*d.y-(i.y-r.y)*d.x)),g=Math.abs((n.x-r.x)*d.y-(n.y-r.y)*d.x);(f+g)*(f+g)<s*(d.x*d.x+d.y*d.y)?o.push(p):(this.recursiveGetOptimizedDrawingPoints(e,a,u,p,o,s),this.recursiveGetOptimizedDrawingPoints(p,l,c,r,o,s))},e}();t.Bezier=e}(es||(es={})),function(t){var e=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}();t.Flags=e}(es||(es={})),function(t){var e=function(){function e(){}return e.toDegrees=function(t){return 57.29577951308232*t},e.toRadians=function(t){return.017453292519943295*t},e.map=function(t,e,i,n,r){return n+(t-e)*(r-n)/(i-e)},e.lerp=function(t,e,i){return t+(e-t)*i},e.clamp=function(t,e,i){return t<e?e:t>i?i:t},e.pointOnCirlce=function(i,n,r){var o=e.toRadians(r);return new t.Vector2(Math.cos(o)*o+i.x,Math.sin(o)*o+i.y)},e.isEven=function(t){return t%2==0},e.clamp01=function(t){return t<0?0:t>1?1:t},e.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},e.incrementWithWrap=function(t,e){return++t==e?0:t},e.Epsilon=1e-5,e.Rad2Deg=57.29578,e.Deg2Rad=.0174532924,e.PiOver2=Math.PI/2,e}();t.MathHelper=e}(es||(es={})),function(t){t.matrixPool=[];var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"m11",{get:function(){return this.a},set:function(t){this.a=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m12",{get:function(){return this.b},set:function(t){this.b=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m21",{get:function(){return this.c},set:function(t){this.c=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m22",{get:function(){return this.d},set:function(t){this.d=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m31",{get:function(){return this.tx},set:function(t){this.tx=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m32",{get:function(){return this.ty},set:function(t){this.ty=t},enumerable:!0,configurable:!0}),i.create=function(){var e=t.matrixPool.pop();return e||(e=new i),e},i.prototype.identity=function(){return this.a=this.d=1,this.b=this.c=this.tx=this.ty=0,this},i.prototype.translate=function(t,e){return this.tx+=t,this.ty+=e,this},i.prototype.scale=function(t,e){return 1!==t&&(this.a*=t,this.c*=t,this.tx*=t),1!==e&&(this.b*=e,this.d*=e,this.ty*=e),this},i.prototype.rotate=function(t){if(0!==(t=+t)){t/=DEG_TO_RAD;var e=Math.cos(t),i=Math.sin(t),n=this.a,r=this.b,o=this.c,s=this.d,a=this.tx,h=this.ty;this.a=n*e-r*i,this.b=n*i+r*e,this.c=o*e-s*i,this.d=o*i+s*e,this.tx=a*e-h*i,this.ty=a*i+h*e}return this},i.prototype.invert=function(){return this.$invertInto(this),this},i.prototype.add=function(t){return this.m11+=t.m11,this.m12+=t.m12,this.m21+=t.m21,this.m22+=t.m22,this.m31+=t.m31,this.m32+=t.m32,this},i.prototype.substract=function(t){return this.m11-=t.m11,this.m12-=t.m12,this.m21-=t.m21,this.m22-=t.m22,this.m31-=t.m31,this.m32-=t.m32,this},i.prototype.divide=function(t){return this.m11/=t.m11,this.m12/=t.m12,this.m21/=t.m21,this.m22/=t.m22,this.m31/=t.m31,this.m32/=t.m32,this},i.prototype.multiply=function(t){var e=this.m11*t.m11+this.m12*t.m21,i=this.m11*t.m12+this.m12*t.m22,n=this.m21*t.m11+this.m22*t.m21,r=this.m21*t.m12+this.m22*t.m22,o=this.m31*t.m11+this.m32*t.m21+t.m31,s=this.m31*t.m12+this.m32*t.m22+t.m32;return this.m11=e,this.m12=i,this.m21=n,this.m22=r,this.m31=o,this.m32=s,this},i.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},i.prototype.release=function(e){e&&t.matrixPool.push(e)},i}(egret.Matrix);t.Matrix2D=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"max",{get:function(){return new t.Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"center",{get:function(){return new t.Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"location",{get:function(){return new t.Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{get:function(){return new t.Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),i.fromMinMax=function(t,e,n,r){return new i(t,e,n-t,r-e)},i.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,i=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>n&&(n=s.x),s.y<i&&(i=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,i,n,r)},i.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},i.prototype.rayIntersects=function(t){var e=0,i=Number.MAX_VALUE;if(Math.abs(t.direction.x)<1e-6){if(t.start.x<this.x||t.start.x>this.x+this.width)return e}else{var n=1/t.direction.x,r=(this.x-t.start.x)*n,o=(this.x+this.width-t.start.x)*n;if(r>o){var s=r;r=o,o=s}if((e=Math.max(r,e))>(i=Math.min(o,i)))return e}if(Math.abs(t.direction.y)<1e-6){if(t.start.y<this.y||t.start.y>this.y+this.height)return e}else{var a=1/t.direction.y,h=(this.y-t.start.y)*a,c=(this.y+this.height-t.start.y)*a;if(h>c){var u=h;h=c,c=u}if((e=Math.max(h,e))>(i=Math.max(c,i)))return e}return e},i.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},i.prototype.contains=function(t,e){return this.x<=t&&t<this.x+this.width&&this.y<=e&&e<this.y+this.height},i.prototype.getHalfSize=function(){return new t.Vector2(.5*this.width,.5*this.height)},i.prototype.getClosestPointOnRectangleBorderToPoint=function(e,i){i=t.Vector2.zero;var n=new t.Vector2;if(n.x=t.MathHelper.clamp(e.x,this.left,this.right),n.y=t.MathHelper.clamp(e.y,this.top,this.bottom),this.contains(n.x,n.y)){var r=n.x-this.left,o=this.right-n.x,s=n.y-this.top,a=this.bottom-n.y,h=Math.min(r,o,s,a);h==s?(n.y=this.top,i.y=-1):h==a?(n.y=this.bottom,i.y=1):h==r?(n.x=this.left,i.x=-1):(n.x=this.right,i.x=1)}else n.x==this.left&&(i.x=-1),n.x==this.right&&(i.x=1),n.y==this.top&&(i.y=-1),n.y==this.bottom&&(i.y=1);return n},i.prototype.getClosestPointOnBoundsToOrigin=function(){var e=this.max,i=Math.abs(this.location.x),n=new t.Vector2(this.location.x,0);return Math.abs(e.x)<i&&(i=Math.abs(e.x),n.x=e.x,n.y=0),Math.abs(e.y)<i&&(i=Math.abs(e.y),n.x=0,n.y=e.y),Math.abs(this.location.y)<i&&(i=Math.abs(this.location.y),n.x=0,n.y=this.location.y),n},i.prototype.calculateBounds=function(e,i,n,r,o,s,a){if(0==o)this.x=e.x+i.x-n.x*r.x,this.y=e.y+i.y-n.y*r.y,this.width=s*r.x,this.height=a*r.y;else{var h=e.x+i.x,c=e.y+i.y;this._transformMat=t.Matrix2D.create().translate(-h-n.x,-c-n.y),this._tempMat=t.Matrix2D.create().scale(r.x,r.y),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().rotate(o),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().translate(h,c),this._transformMat=this._transformMat.multiply(this._tempMat);var u=new t.Vector2(h,c),l=new t.Vector2(h+s,c),p=new t.Vector2(h,c+a),d=new t.Vector2(h+s,c+a);u=t.Vector2Ext.transformR(u,this._transformMat),l=t.Vector2Ext.transformR(l,this._transformMat),p=t.Vector2Ext.transformR(p,this._transformMat),d=t.Vector2Ext.transformR(d,this._transformMat);var f=Math.min(u.x,d.x,l.x,p.x),g=Math.max(u.x,d.x,l.x,p.x),m=Math.min(u.y,d.y,l.y,p.y),y=Math.max(u.y,d.y,l.y,p.y);this.location=new t.Vector2(f,m),this.width=g-f,this.height=y-m}},i}(egret.Rectangle);t.Rectangle=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.x=t,this.y=e,this.z=i}}();t.Vector3=e}(es||(es={})),function(t){var e=function(){function e(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return e.prototype.update=function(){for(var e=this._entity.getComponents(t.Collider),i=0;i<e.length;i++)for(var n=e[i],r=t.Physics.boxcastBroadphase(n.bounds,n.collidesWithLayers),o=function(e){var i=r[e];if(!n.isTrigger&&!i.isTrigger)return"continue";if(n.overlaps(i)){var o=new t.Pair(n,i);-1==s._activeTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&-1==s._previousTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&s.notifyTriggerListeners(o,!0),s._activeTriggerIntersections.contains(o)||s._activeTriggerIntersections.push(o)}},s=this,a=0;a<r.length;a++)o(a);t.ListPool.free(e),this.checkForExitedColliders()},e.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var n=i._previousTriggerIntersections.findIndex(function(i){return i.first==t._activeTriggerIntersections[e].first&&i.second==t._activeTriggerIntersections[e].second});-1!=n&&i._previousTriggerIntersections.removeAt(n)},i=this,n=0;n<this._activeTriggerIntersections.length;n++)e(n);for(n=0;n<this._previousTriggerIntersections.length;n++)this.notifyTriggerListeners(this._previousTriggerIntersections[n],!1);this._previousTriggerIntersections.length=0;for(n=0;n<this._activeTriggerIntersections.length;n++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[n])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[n]);this._activeTriggerIntersections.length=0},e.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)if(e?this._tempTriggerList[i].onTriggerEnter(t.second,t.first):this._tempTriggerList[i].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)e?this._tempTriggerList[n].onTriggerEnter(t.first,t.second):this._tempTriggerList[n].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},e}();t.ColliderTriggerHelper=e}(es||(es={})),function(t){var e;!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(e=t.PointSectors||(t.PointSectors={}));var i=function(){function i(){}return i.isLineToLine=function(e,i,n,r){var o=t.Vector2.subtract(i,e),s=t.Vector2.subtract(r,n),a=o.x*s.y-o.y*s.x;if(0==a)return!1;var h=t.Vector2.subtract(n,e),c=(h.x*s.y-h.y*s.x)/a;if(c<0||c>1)return!1;var u=(h.x*o.y-h.y*o.x)/a;return!(u<0||u>1)},i.lineToLineIntersection=function(e,i,n,r){var o=new t.Vector2(0,0),s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return o;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return o;var l=(c.x*s.y-c.y*s.x)/h;return l<0||l>1?o:o=t.Vector2.add(e,new t.Vector2(u*s.x,u*s.y))},i.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,new t.Vector2(r.x*s,r.y*s))},i.isCircleToCircle=function(e,i,n,r){return t.Vector2.distanceSquared(e,n)<(i+r)*(i+r)},i.isCircleToLine=function(e,i,n,r){return t.Vector2.distanceSquared(e,this.closestPointOnLine(n,r,e))<i*i},i.isCircleToPoint=function(e,i,n){return t.Vector2.distanceSquared(e,n)<i*i},i.isRectToCircle=function(t,e,i){var n=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-n),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<i*i},i.isRectToLine=function(i,n,r){var o=this.getSector(i.x,i.y,i.width,i.height,n),s=this.getSector(i.x,i.y,i.width,i.height,r);if(o==e.center||s==e.center)return!0;if(0!=(o&s))return!1;var a=o|s,h=void 0,c=void 0;return!(0==(a&e.top)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x+i.width,i.y),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.bottom)||(h=new t.Vector2(i.x,i.y+i.height),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.left)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x,i.y+i.height),!this.isLineToLine(h,c,n,r)))||!(0==(a&e.right)||(h=new t.Vector2(i.x+i.width,i.y),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))))},i.isRectToPoint=function(t,e,i,n,r){return r.x>=t&&r.y>=e&&r.x<t+i&&r.y<e+n},i.getSector=function(t,i,n,r,o){var s=e.center;return o.x<t?s|=e.left:o.x>=t+n&&(s|=e.right),o.y<i?s|=e.top:o.y>=i+r&&(s|=e.bottom),s},i}();t.Collisions=i}(es||(es={})),function(t){var e=function(){function e(){}return e.reset=function(){this._spatialHash=new t.SpatialHash(this.spatialHashCellSize)},e.clear=function(){this._spatialHash.clear()},e.overlapCircleAll=function(t,e,i,n){if(void 0===n&&(n=-1),0!=i.length)return this._spatialHash.overlapCircle(t,e,i,n);console.error("An empty results array was passed in. No results will ever be returned.")},e.boxcastBroadphase=function(t,e){return void 0===e&&(e=this.allLayers),this._spatialHash.aabbBroadphase(t,null,e)},e.boxcastBroadphaseExcludingSelf=function(t,e,i){return void 0===i&&(i=this.allLayers),this._spatialHash.aabbBroadphase(e,t,i)},e.addCollider=function(t){e._spatialHash.register(t)},e.removeCollider=function(t){e._spatialHash.remove(t)},e.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},e.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},e.spatialHashCellSize=100,e.allLayers=-1,e.raycastsHitTriggers=!1,e.raycastsStartInColliders=!1,e}();t.Physics=e}(es||(es={})),function(t){var e=function(){return function(e,i){this.start=e,this.end=i,this.direction=t.Vector2.subtract(this.end,this.start)}}();t.Ray2D=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r,o){this.fraction=0,this.distance=0,this.point=t.Vector2.zero,this.normal=t.Vector2.zero,this.collider=e,this.fraction=i,this.distance=n,this.point=r,this.centroid=t.Vector2.zero}return e.prototype.setValues=function(t,e,i,n){this.collider=t,this.fraction=e,this.distance=i,this.point=n},e.prototype.setValuesNonCollider=function(t,e,i,n){this.fraction=t,this.distance=e,this.point=i,this.normal=n},e.prototype.reset=function(){this.collider=null,this.fraction=this.distance=0},e.prototype.toString=function(){return"[RaycastHit] fraction: "+this.fraction+", distance: "+this.distance+", normal: "+this.normal+", centroid: "+this.centroid+", point: "+this.point},e}();t.RaycastHit=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.clone=function(){return ObjectUtils.clone(this)},t}();t.Shape=e}(es||(es={})),function(t){var e=function(e){function i(t,i){var n=e.call(this)||this;return n._areEdgeNormalsDirty=!0,n.isUnrotated=!0,n.setPoints(t),n.isBox=i,n}return __extends(i,e),Object.defineProperty(i.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),i.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},i.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=i.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},i.prototype.buildEdgeNormals=function(){var e,i=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==i||(this._edgeNormals=new Array(i));for(var n=0;n<i;n++){var r=this.points[n];e=n+1>=this.points.length?this.points[0]:this.points[n+1];var o=t.Vector2Ext.perpendicular(r,e);o=t.Vector2.normalize(o),this._edgeNormals[n]=o}},i.buildSymmetricalPolygon=function(e,i){for(var n=new Array(e),r=0;r<e;r++){var o=2*Math.PI*(r/e);n[r]=t.Vector2.multiply(new t.Vector2(Math.cos(o),Math.sin(o)),new t.Vector2(i))}return n},i.recenterPolygonVerts=function(e){for(var i=this.findPolygonCenter(e),n=0;n<e.length;n++)e[n]=t.Vector2.subtract(e[n],i)},i.findPolygonCenter=function(e){for(var i=0,n=0,r=0;r<e.length;r++)i+=e[r].x,n+=e[r].y;return new t.Vector2(i/e.length,n/e.length)},i.getFarthestPointInDirection=function(e,i){for(var n=0,r=t.Vector2.dot(e[n],i),o=1;o<e.length;o++){var s=t.Vector2.dot(e[o],i);s>r&&(r=s,n=o)}return e[n]},i.getClosestPointOnPolygonToPoint=function(e,i,n,r){n=Number.MAX_VALUE,r=new t.Vector2(0,0);for(var o,s=new t.Vector2(0,0),a=0;a<e.length;a++){var h=a+1;h==e.length&&(h=0);var c=t.ShapeCollisions.closestPointOnLine(e[a],e[h],i);if((o=t.Vector2.distanceSquared(i,c))<n){n=o,s=c;var u=t.Vector2.subtract(e[h],e[a]);r=new t.Vector2(-u.y,u.x)}}return t.Vector2Ext.normalize(r),s},i.rotatePolygonVerts=function(e,i,n){for(var r=Math.cos(e),o=Math.sign(e),s=0;s<i.length;s++){var a=i[s];n[s]=new t.Vector2(a.x*r+a.y*-o,a.x*o+a.y*r)}},i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=!0,n=void 0,r=t.Matrix2D.create().translate(-this._polygonCenter.x,-this._polygonCenter.y);if(e.entity.transform.scale!=t.Vector2.zero&&(n=t.Matrix2D.create().scale(e.entity.transform.scale.x,e.entity.transform.scale.y),r=r.multiply(n),i=!1,this.center=t.Vector2.multiply(e.localOffset,e.entity.transform.scale)),0!=e.entity.transform.rotation){n=t.Matrix2D.create().rotate(e.entity.transform.rotation),r=r.multiply(n);var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=i?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}n=t.Matrix2D.create().translate(this._polygonCenter.x,this._polygonCenter.y),r=r.multiply(n),t.Vector2Ext.transform(this._originalPoints,r,this.points),this.isUnrotated=0==e.entity.transform.rotation,e._isRotationDirty&&(this._areEdgeNormalsDirty=!0)}this.position=t.Vector2.add(e.entity.transform.position,this.center),this.bounds=t.Rectangle.rectEncompassingPoints(this.points),this.bounds.location=this.bounds.location.add(this.position)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Pologon to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Polygon to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToPoly(e,i,this,n)},i.prototype.containsPoint=function(e){e=t.Vector2.subtract(e,this.position);for(var i=!1,n=0,r=this.points.length-1;n<this.points.length;r=n++)this.points[n].y>e.y!=this.points[r].y>e.y&&e.x<(this.points[r].x-this.points[n].x)*(e.y-this.points[n].y)/(this.points[r].y-this.points[n].y)+this.points[n].x&&(i=!i);return i},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToPoly(e,this,i)},i}(t.Shape);t.Polygon=e}(es||(es={})),function(t){var e=function(e){function i(t,n){var r=e.call(this,i.buildBox(t,n),!0)||this;return r.width=t,r.height=n,r}return __extends(i,e),i.buildBox=function(e,i){var n=e/2,r=i/2,o=new Array(4);return o[0]=new t.Vector2(-n,-r),o[1]=new t.Vector2(n,-r),o[2]=new t.Vector2(n,r),o[3]=new t.Vector2(-n,r),o},i.prototype.updateBox=function(e,i){this.width=e,this.height=i;var n=e/2,r=i/2;this.points[0]=new t.Vector2(-n,-r),this.points[1]=new t.Vector2(n,-r),this.points[2]=new t.Vector2(n,r),this.points[3]=new t.Vector2(-n,r);for(var o=0;o<this.points.length;o++)this._originalPoints[o]=this.points[o]},i.prototype.overlaps=function(n){if(this.isUnrotated){if(n instanceof i&&n.isUnrotated)return this.bounds.intersects(n.bounds);if(n instanceof t.Circle)return t.Collisions.isRectToCircle(this.bounds,n.position,n.radius)}return e.prototype.overlaps.call(this,n)},i.prototype.collidesWithShape=function(n,r){return n instanceof i&&n.isUnrotated?t.ShapeCollisions.boxToBox(this,n,r):e.prototype.collidesWithShape.call(this,n,r)},i.prototype.containsPoint=function(t){return this.isUnrotated?this.bounds.contains(t.x,t.y):e.prototype.containsPoint.call(this,t)},i.prototype.pointCollidesWithShape=function(i,n){return this.isUnrotated?t.ShapeCollisions.pointToBox(i,this,n):e.prototype.pointCollidesWithShape.call(this,i,n)},i}(t.Polygon);t.Box=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this)||this;return i.radius=t,i._originalRadius=t,i}return __extends(i,e),i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=e.entity.transform.scale,n=1==i.x&&1==i.y,r=Math.max(i.x,i.y);if(this.radius=this._originalRadius*r,0!=e.entity.transform.rotation){var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=n?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}}this.position=t.Vector2.add(e.transform.position,this.center),this.bounds=new t.Rectangle(this.position.x-this.radius,this.position.y-this.radius,2*this.radius,2*this.radius)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof t.Box&&e.isUnrotated)return t.Collisions.isRectToCircle(e.bounds,this.position,this.radius);if(e instanceof i)return t.Collisions.isCircleToCircle(this.position,this.radius,e.position,e.radius);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("overlaps of circle to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof t.Box&&e.isUnrotated)return t.ShapeCollisions.circleToBox(this,e,n);if(e instanceof i)return t.ShapeCollisions.circleToCircle(this,e,n);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("Collisions of Circle to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToCircle(e,i,this,n)},i.prototype.containsPoint=function(e){return t.Vector2.subtract(e,this.position).lengthSquared()<=this.radius*this.radius},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToCircle(e,this,i)},i}(t.Shape);t.Circle=e}(es||(es={})),function(t){var e=function(){function e(){this.normal=t.Vector2.zero,this.minimumTranslationVector=t.Vector2.zero,this.point=t.Vector2.zero}return e.prototype.removeHorizontal=function(e){if(Math.sign(this.normal.x)!=Math.sign(e.x)||0==e.x&&0!=this.normal.x){var i=this.minimumTranslationVector.length()/this.normal.y;1!=Math.abs(this.normal.x)&&Math.abs(i)<Math.abs(3*e.y)&&(this.minimumTranslationVector=new t.Vector2(0,-i))}},e.prototype.invertResult=function(){return this.minimumTranslationVector=t.Vector2.negate(this.minimumTranslationVector),this.normal=t.Vector2.negate(this.normal),this},e.prototype.toString=function(){return"[CollisionResult] normal: "+this.normal+", minimumTranslationVector: "+this.minimumTranslationVector},e}();t.CollisionResult=e}(es||(es={})),function(t){var e=function(){function e(){}return e.intersectMovingCircleToBox=function(e,i,n){var r=i.bounds;r.inflate(e.radius,e.radius);var o=new t.Ray2D(t.Vector2.subtract(e.position,n),e.position),s=r.rayIntersects(o);if(s>1)return s;var a,h=t.Vector2.add(o.start,t.Vector2.add(o.direction,new t.Vector2(s))),c=0;h.x<i.bounds.left&&(a|=1),h.x>i.bounds.right&&(c|=1),h.y<i.bounds.top&&(a|=2),h.y>i.bounds.bottom&&(c|=2);var u=a+c;return 3==u&&console.log("m == 3. corner "+t.Time.frameCount),s},e}();t.RealtimeCollisions=e}(es||(es={})),function(t){var e=function(){function e(){}return e.polygonToPolygon=function(e,i,n){for(var r,o=!0,s=e.edgeNormals,a=i.edgeNormals,h=Number.POSITIVE_INFINITY,c=new t.Vector2,u=t.Vector2.subtract(e.position,i.position),l=0;l<s.length+a.length;l++){r=l<s.length?s[l]:a[l-s.length];var p=0,d=0,f=0,g=0,m=0,y=this.getInterval(r,e,p,f);p=y.min,d=y.max;var _=this.getInterval(r,i,d,g);d=_.min,g=_.max;var v=t.Vector2.dot(u,r);if(p+=v,f+=v,(m=this.intervalDistance(p,f,d,g))>0&&(o=!1),!o)return!1;(m=Math.abs(m))<h&&(h=m,c=r,t.Vector2.dot(c,u)<0&&(c=new t.Vector2(-c)))}return n.normal=c,n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-c.x,-c.y),new t.Vector2(h)),!0},e.intervalDistance=function(t,e,i,n){return t<i?i-e:t-i},e.getInterval=function(e,i,n,r){var o=t.Vector2.dot(i.points[0],e);n=r=o;for(var s=1;s<i.points.length;s++)(o=t.Vector2.dot(i.points[s],e))<n?n=o:o>r&&(r=o);return{min:n,max:r}},e.circleToPolygon=function(e,i,n){var r,o=t.Vector2.subtract(e.position,i.position),s=t.Polygon.getClosestPointOnPolygonToPoint(i.points,o,0,n.normal),a=i.containsPoint(e.position);if(0>e.radius*e.radius&&!a)return!1;a?r=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0)-e.radius)):r=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));return n.minimumTranslationVector=r,n.point=t.Vector2.add(s,i.position),!0},e.circleToBox=function(e,i,n){var r=i.bounds.getClosestPointOnRectangleBorderToPoint(e.position,n.normal);if(i.containsPoint(e.position)){n.point=r;var o=t.Vector2.add(r,t.Vector2.multiply(n.normal,new t.Vector2(e.radius)));return n.minimumTranslationVector=t.Vector2.subtract(e.position,o),!0}var s=t.Vector2.distanceSquared(r,e.position);if(0==s)n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));else if(s<=e.radius*e.radius){n.normal=t.Vector2.subtract(e.position,r);var a=n.normal.length()-e.radius;return n.point=r,n.normal=t.Vector2Ext.normalize(n.normal),n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(a),n.normal),!0}return!1},e.pointToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e,i.position),o=1+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s,-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius,i.radius))),!0}return!1},e.pointToBox=function(e,i,n){return!!i.containsPoint(e)&&(n.point=i.bounds.getClosestPointOnRectangleBorderToPoint(e,n.normal),n.minimumTranslationVector=t.Vector2.subtract(e,n.point),!0)},e.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,t.Vector2.multiply(r,new t.Vector2(s,s)))},e.pointToPoly=function(e,i,n){if(i.containsPoint(e)){var r=t.Polygon.getClosestPointOnPolygonToPoint(i.points,t.Vector2.subtract(e,i.position),0,n.normal);return n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0),Math.sqrt(0))),n.point=t.Vector2.add(r,i.position),!0}return!1},e.circleToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e.position,i.position),o=e.radius+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e.position,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius))),!0}return!1},e.boxToBox=function(e,i,n){var r=this.minkowskiDifference(e,i);return!!r.contains(0,0)&&(n.minimumTranslationVector=r.getClosestPointOnBoundsToOrigin(),!n.minimumTranslationVector.equals(t.Vector2.zero)&&(n.normal=new t.Vector2(-n.minimumTranslationVector.x,-n.minimumTranslationVector.y),n.normal=n.normal.normalize(),!0))},e.minkowskiDifference=function(e,i){var n=t.Vector2.subtract(e.position,t.Vector2.add(e.bounds.location,t.Vector2.divide(e.bounds.size,new t.Vector2(2)))),r=t.Vector2.subtract(t.Vector2.add(e.bounds.location,n),i.bounds.max),o=t.Vector2.add(e.bounds.size,i.bounds.size);return new t.Rectangle(r.x,r.y,o.x,o.y)},e.lineToPoly=function(e,i,n,r){for(var o=t.Vector2.zero,s=t.Vector2.zero,a=Number.MAX_VALUE,h=!1,c=n.points.length-1,u=0;u<n.points.length;c=u,u++){var l=t.Vector2.add(n.position,n.points[c]),p=t.Vector2.add(n.position,n.points[u]),d=t.Vector2.zero;if(this.lineToLine(l,p,e,i,d)){h=!0;var f=(d.x-e.x)/(i.x-e.x);if((Number.isNaN(f)||Number.isFinite(f))&&(f=(d.y-e.y)/(i.y-e.y)),f<a){var g=t.Vector2.subtract(p,l);o=new t.Vector2(g.y,-g.x),a=f,s=d}}}if(h){o=o.normalize();var m=t.Vector2.distance(e,s);return r.setValuesNonCollider(a,m,s,o),!0}return!1},e.lineToLine=function(e,i,n,r,o){var s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return!1;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return!1;var l=(c.x*s.y-c.y*s.x)/h;return!(l<0||l>1)&&(o=o.add(e).add(t.Vector2.multiply(new t.Vector2(u),s)),!0)},e.lineToCircle=function(e,i,n,r){var o=t.Vector2.distance(e,i),s=t.Vector2.divide(t.Vector2.subtract(i,e),new t.Vector2(o)),a=t.Vector2.subtract(e,n.position),h=t.Vector2.dot(a,s),c=t.Vector2.dot(a,a)-n.radius*n.radius;if(c>0&&h>0)return!1;var u=h*h-c;return!(u<0)&&(r.fraction=-h-Math.sqrt(u),r.fraction<0&&(r.fraction=0),r.point=t.Vector2.add(e,t.Vector2.multiply(new t.Vector2(r.fraction),s)),r.distance=t.Vector2.distance(e,r.point),r.normal=t.Vector2.normalize(t.Vector2.subtract(r.point,n.position)),r.fraction=r.distance/o,!0)},e.boxToBoxCast=function(e,i,n,r){var o=this.minkowskiDifference(e,i);if(o.contains(0,0)){var s=o.getClosestPointOnBoundsToOrigin();return!s.equals(t.Vector2.zero)&&(r.normal=new t.Vector2(-s.x),r.normal=r.normal.normalize(),r.distance=0,r.fraction=0,!0)}var a=new t.Ray2D(t.Vector2.zero,new t.Vector2(-n.x)),h=o.rayIntersects(a);return h<=1&&(r.fraction=h,r.distance=n.length()*h,r.normal=new t.Vector2(-n.x),r.normal=r.normal.normalize(),r.centroid=t.Vector2.add(e.bounds.center,t.Vector2.multiply(n,new t.Vector2(h))),!0)},e}();t.ShapeCollisions=e}(es||(es={})),function(t){var e=function(){function e(e){void 0===e&&(e=100),this.gridBounds=new t.Rectangle,this._overlapTestCircle=new t.Circle(0),this._cellDict=new i,this._tempHashSet=[],this._cellSize=e,this._inverseCellSize=1/this._cellSize,this._raycastParser=new n}return e.prototype.register=function(e){var i=e.bounds;e.registeredPhysicsBounds=i;var n=this.cellCoords(i.x,i.y),r=this.cellCoords(i.right,i.bottom);this.gridBounds.contains(n.x,n.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,n)),this.gridBounds.contains(r.x,r.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,r));for(var o=n.x;o<=r.x;o++)for(var s=n.y;s<=r.y;s++){var a=this.cellAtPosition(o,s,!0);a.firstOrDefault(function(t){return t.hashCode==e.hashCode})||a.push(e)}},e.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,i=this.cellCoords(e.x,e.y),n=this.cellCoords(e.right,e.bottom),r=i.x;r<=n.x;r++)for(var o=i.y;o<=n.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.log("从不存在碰撞器的单元格中移除碰撞器: ["+t+"]")}},e.prototype.removeWithBruteForce=function(t){this._cellDict.remove(t)},e.prototype.clear=function(){this._cellDict.clear()},e.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var i=this.gridBounds.x;i<=this.gridBounds.right;i++)for(var n=this.gridBounds.y;n<=this.gridBounds.bottom;n++){var r=this.cellAtPosition(i,n);r&&r.length>0&&this.debugDrawCellDetails(i,n,r.length,t,e)}},e.prototype.aabbBroadphase=function(e,i,n){this._tempHashSet.length=0;for(var r=this.cellCoords(e.x,e.y),o=this.cellCoords(e.right,e.bottom),s=r.x;s<=o.x;s++)for(var a=r.y;a<=o.y;a++){var h=this.cellAtPosition(s,a);if(h)for(var c=function(r){var o=h[r];if(o==i||!t.Flags.isFlagSet(n,o.physicsLayer))return"continue";e.intersects(o.bounds)&&(u._tempHashSet.firstOrDefault(function(t){return t.hashCode==o.hashCode})||u._tempHashSet.push(o))},u=this,l=0;l<h.length;l++)c(l)}return this._tempHashSet},e.prototype.overlapCircle=function(e,i,n,r){var o=new t.Rectangle(e.x-i,e.y-i,2*i,2*i);this._overlapTestCircle.radius=i,this._overlapTestCircle.position=e;for(var s=0,a=this.aabbBroadphase(o,null,r),h=0;h<a.length;h++){var c=a[h];if(c instanceof t.BoxCollider)n[s]=c,s++;else if(c instanceof t.CircleCollider)c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++);else{if(!(c instanceof t.PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++)}if(s==n.length)return s}return s},e.prototype.cellCoords=function(e,i){return new t.Vector2(Math.floor(e*this._inverseCellSize),Math.floor(i*this._inverseCellSize))},e.prototype.cellAtPosition=function(t,e,i){void 0===i&&(i=!1);var n=this._cellDict.tryGetValue(t,e);return n||i&&(n=[],this._cellDict.add(t,e,n)),n},e.prototype.debugDrawCellDetails=function(t,e,i,n,r){void 0===n&&(n=.5),void 0===r&&(r=1)},e}();t.SpatialHash=e;var i=function(){function t(){this._store=new Map}return t.prototype.add=function(t,e,i){this._store.set(this.getKey(t,e),i)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!0)).toString()},t}();t.NumberDictionary=i;var n=function(){function e(){this._checkedColliders=[],this._cellHits=[]}return e.prototype.start=function(t,e,i){this._ray=t,this._hits=e,this._layerMask=i,this.hitCounter=0},e.prototype.checkRayIntersection=function(i,n,r){for(var o=0;o<r.length;o++){var s=r[o];if(!this._checkedColliders.contains(s))if(this._checkedColliders.push(s),!s.isTrigger||t.Physics.raycastsHitTriggers)if(t.Flags.isFlagSet(this._layerMask,s.physicsLayer))if(s.bounds.rayIntersects(this._ray)<=1&&s.shape.collidesWithLine(this._ray.start,this._ray.end,this._tempHit)){if(!t.Physics.raycastsStartInColliders&&s.shape.containsPoint(this._ray.start))continue;this._tempHit.collider=s,this._cellHits.push(this._tempHit)}}if(0==this._cellHits.length)return!1;this._cellHits.sort(e.compareRaycastHits);for(o=0;o<this._cellHits.length;o++)if(this._hits[this.hitCounter]=this._cellHits[o],this.hitCounter++,this.hitCounter==this._hits.length)return!0;return!1},e.prototype.reset=function(){this._hits=null,this._checkedColliders.length=0,this._cellHits.length=0},e.compareRaycastHits=function(t,e){return t.distance-e.distance},e}();t.RaycastResultParser=n}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxGroup=e}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxImageLayer=e}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"offset",{get:function(){return new t.Vector2(this.offsetX,this.offsetY)},enumerable:!0,configurable:!0}),e.prototype.getTileWithGid=function(t){for(var e=0;e<this.tiles.length;e++)if(this.tiles[e]&&this.tiles[e].gid==t)return this.tiles[e];return null},e.prototype.getTile=function(t,e){return this.tiles[t+e*this.width]},e.prototype.getCollisionRectangles=function(){for(var t=[],e=[],i=-1,n=-1,r=0;r<this.map.height;r++){for(var o=0;o<this.map.width;o++){n=r*this.map.width+o;var s=this.getTile(o,r);s&&!t[n]?(i<0&&(i=o),t[n]=!0):(s||t[n])&&i>=0&&(e.push(this.findBoundsRect(i,o,r,t)),i=-1)}i>=0&&(e.push(this.findBoundsRect(i,this.map.width,r,t)),i=-1)}return e},e.prototype.findBoundsRect=function(e,i,n,r){for(var o=-1,s=n+1;s<this.map.height;s++)for(var a=e;a<i;a++){if(o=s*this.map.width+a,this.getTile(a,s)||r[o]){for(var h=e;h<a;h++)r[o=s*this.map.width+h]=!1;return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(s-n)*this.map.tileHeight)}r[o]=!0}return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(this.map.height-n)*this.map.tileHeight)},e}();t.TmxLayer=e;var i=function(){function e(t,i,n,r){this.x=n,this.y=r;var o,s=i;o=0!=(s&e.FLIPPED_HORIZONTALLY_FLAG),this.horizontalFlip=o,o=0!=(s&e.FLIPPED_VERTICALLY_FLAG),this.verticalFlip=o,s&=~(e.FLIPPED_HORIZONTALLY_FLAG|e.FLIPPED_VERTICALLY_FLAG),this.gid=s,this.tileset=t.getTilesetForTileGid(this.gid)}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tilesetTile",{get:function(){null==this._tilesetTileIndex&&(this._tilesetTileIndex=-1,this.tileset.firstGid<=this.gid&&this.tileset.tiles.get(this.gid-this.tileset.firstGid)&&(this._tilesetTileIndex=this.gid-this.tileset.firstGid));return this._tilesetTileIndex<0?null:this.tileset.tiles.get(this._tilesetTileIndex)},enumerable:!0,configurable:!0}),e.FLIPPED_HORIZONTALLY_FLAG=2147483648,e.FLIPPED_VERTICALLY_FLAG=1073741824,e}();t.TmxLayerTile=i}(es||(es={})),function(t){var e=function(){return function(){this.tmxDirectory="resource/assets/"}}();t.TmxDocument=e;var i=function(){function t(){}return t.prototype.dispose=function(){this.bitmap&&(this.bitmap.dispose(),this.bitmap=null)},t}();t.TmxImage=i}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"worldWidth",{get:function(){return this.width*this.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"worldHeight",{get:function(){return this.height*this.tileHeight},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"requiresLargeTileCulling",{get:function(){return this.maxTileHeight>this.tileHeight||this.maxTileWidth>this.tileWidth},enumerable:!0,configurable:!0}),i.prototype.getTilesetForTileGid=function(t){if(0==t)return null;for(var e=this.tilesets.length-1;e>=0;e--)if(this.tilesets[e].firstGid<=t)return this.tilesets[e];console.error("tile gid"+t+"未在任何tileset中找到")},i.prototype.worldToTilePositionX=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileWidth);return i?t.MathHelper.clamp(n,0,this.width-1):n},i.prototype.worldToTilePositionY=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileHeight);return i?t.MathHelper.clamp(n,0,this.height-1):n},i.prototype.getLayer=function(t){return this.layers[t]},i.prototype.update=function(){this.tilesets.forEach(function(t){t.update()})},i.prototype.dispose=function(t){void 0===t&&(t=!0),this._isDisposed||(t&&(this.tilesets.forEach(function(t){t.image&&t.image.dispose()}),this.imageLayers.forEach(function(t){t.image&&t.image.dispose()})),this._isDisposed=!0)},i}(t.TmxDocument);t.TmxMap=e,function(t){t[t.unknown=0]="unknown",t[t.orthogonal=1]="orthogonal",t[t.isometric=2]="isometric",t[t.staggered=3]="staggered",t[t.hexagonal=4]="hexagonal"}(t.OrientationType||(t.OrientationType={})),function(t){t[t.x=0]="x",t[t.y=1]="y"}(t.StaggerAxisType||(t.StaggerAxisType={})),function(t){t[t.odd=0]="odd",t[t.even=1]="even"}(t.StaggerIndexType||(t.StaggerIndexType={})),function(t){t[t.rightDown=0]="rightDown",t[t.rightUp=1]="rightUp",t[t.leftDown=2]="leftDown",t[t.leftUp=3]="leftUp"}(t.RenderOrderType||(t.RenderOrderType={}))}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxObjectGroup=e;var i=function(){return function(){this.shape=new egret.Shape,this.textField=new egret.TextField}}();t.TmxObject=i;var n=function(){return function(){}}();t.TmxText=n;var r=function(){return function(){}}();t.TmxAlignment=r,function(t){t[t.basic=0]="basic",t[t.point=1]="point",t[t.tile=2]="tile",t[t.ellipse=3]="ellipse",t[t.polygon=4]="polygon",t[t.polyline=5]="polyline",t[t.text=6]="text"}(t.TmxObjectType||(t.TmxObjectType={})),function(t){t[t.unkownOrder=-1]="unkownOrder",t[t.TopDown=0]="TopDown",t[t.IndexOrder=1]="IndexOrder"}(t.DrawOrderType||(t.DrawOrderType={})),function(t){t[t.left=0]="left",t[t.center=1]="center",t[t.right=2]="right",t[t.justify=3]="justify"}(t.TmxHorizontalAlignment||(t.TmxHorizontalAlignment={})),function(t){t[t.top=0]="top",t[t.center=1]="center",t[t.bottom=2]="bottom"}(t.TmxVerticalAlignment||(t.TmxVerticalAlignment={}))}(es||(es={})),function(t){var e=function(){function e(){}return e.loadTmxMap=function(t,e){var i=RES.getRes(e);return this.loadTmxMapData(t,i)},e.loadTmxMapData=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:e.version=i.version,e.tiledVersion=i.tiledversion,e.width=i.width,e.height=i.height,e.tileWidth=i.tilewidth,e.tileHeight=i.tileheight,e.hexSideLength=i.hexsidelength,e.orientation=this.parseOrientationType(i.orientation),e.staggerAxis=this.parseStaggerAxisType(i.staggeraxis),e.staggerIndex=this.parseStaggerIndexType(i.staggerindex),e.renderOrder=this.parseRenderOrderType(i.renderorder),e.nextObjectID=i.nextobjectid,e.backgroundColor=t.TmxUtils.color16ToUnit(i.color),e.properties=this.parsePropertyDict(i.properties),e.maxTileWidth=e.tileWidth,e.maxTileHeight=e.tileHeight,e.tilesets=[],n=0,r=i.tilesets,a.label=1;case 1:return n<r.length?(o=r[n],[4,this.parseTmxTileset(e,o)]):[3,4];case 2:s=a.sent(),e.tilesets.push(s),this.updateMaxTileSizes(s),a.label=3;case 3:return n++,[3,1];case 4:return e.layers=[],e.tileLayers=[],e.objectGroups=[],e.imageLayers=[],e.groups=[],this.parseLayers(e,i,e,e.width,e.height,e.tmxDirectory),[2,e]}})})},e.parseLayers=function(e,i,n,r,o,s){return __awaiter(this,void 0,void 0,function(){var a,h,c,u,l,p,d,f;return __generator(this,function(g){switch(g.label){case 0:a=0,h=ObjectUtils.elements(i).where(function(t){return"tilelayer"==t.type||"objectgroup"==t.type||"imagelayer"==t.type||"group"==t.type}),g.label=1;case 1:if(!(a<h.length))return[3,11];switch(c=h[a],u=void 0,c.type){case"tilelayer":return[3,2];case"objectgroup":return[3,3];case"imagelayer":return[3,4];case"group":return[3,6]}return[3,8];case 2:return l=this.loadTmxLayer(new t.TmxLayer,n,c,r,o),u=l,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.tileLayers.push(l),[3,9];case 3:return p=this.loadTmxObjectGroup(new t.TmxObjectGroup,n,c),u=p,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.objectGroups.push(p),[3,9];case 4:return[4,this.loadTmxImageLayer(new t.TmxImageLayer,n,c,s)];case 5:return d=g.sent(),u=d,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.imageLayers.push(d),[3,9];case 6:return[4,this.loadTmxGroup(new t.TmxGroup,n,c,r,o,s)];case 7:return f=g.sent(),u=f,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.groups.push(f),[3,9];case 8:throw new Error("无效的操作");case 9:(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.layers.push(u),g.label=10;case 10:return a++,[3,1];case 11:return[2]}})})},e.loadTmxGroup=function(t,e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(s){switch(s.label){case 0:return t.map=e,t.name=null!=i.name?i.name:"",t.opacity=null!=i.opacity?i.opacity:1,t.visible=null==i.visible||i.visible,t.offsetX=null!=i.offsetx?i.offsetx:0,t.offsetY=null!=i.offsety?i.offsety:0,t.properties=this.parsePropertyDict(i.properties),t.layers=[],t.tileLayers=[],t.objectGroups=[],t.imageLayers=[],t.groups=[],[4,this.parseLayers(t,i,e,n,r,o)];case 1:return s.sent(),[2,t]}})})},e.loadTmxImageLayer=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s;return __generator(this,function(a){switch(a.label){case 0:return e.map=i,e.name=n.name,e.width=n.width,e.height=n.height,e.visible=null==n.visible||n.visible,e.opacity=null!=n.opacity?n.opacity:1,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0,(o=n.image)?(s=e,[4,this.loadTmxImage(new t.TmxImage,o,r)]):[3,2];case 1:s.image=a.sent(),a.label=2;case 2:return e.properties=this.parsePropertyDict(n.properties),[2,e]}})})},e.loadTmxLayer=function(i,n,r,o,s){i.map=n,i.name=r.name,i.opacity=null!=r.opacity?r.opacity:1,i.visible=null==r.visible||r.visible,i.offsetX=null!=r.offsetx?r.offsetx:0,i.offsetY=null!=r.offsety?r.offsety:0,i.width=r.width,i.height=r.height;var a=r.data,h=null!=a.encoding?a.encoding:"csv";if(i.tiles=new Array(o*s),"base64"==h)for(var c=t.TmxUtils.decode(a.toString(),h,a.compression),u=0,l=0;l<s;l++)for(var p=0;p<o;p++){var d=c[u];i.tiles[u++]=0!=d?new t.TmxLayerTile(n,d,p,l):null}else if("csv"==h)for(var f=0,g=0,m=a;g<m.length;g++){d=m[g];var y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}else{if(h)throw new Error("TmxLayer:未知编码");f=0;for(var v=0,b=a.tile;v<b.length;v++){var x=b[v];d=null!=x.gid?x.gid:0,y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}}return i.properties=e.parsePropertyDict(r.properties),i},e.updateMaxTileSizes=function(t){t.tiles.forEach(function(e){e.image&&(e.image.width>t.map.maxTileWidth&&(t.map.maxTileWidth=e.image.width),e.image.height>t.map.maxTileHeight&&(t.map.maxTileHeight=e.image.height))}),t.tileRegions.forEach(function(e){var i=e.width,n=e.height;i>t.map.maxTileWidth&&(t.map.maxTileWidth=i),i>t.map.maxTileHeight&&(t.map.maxTileHeight=n)})},e.parseOrientationType=function(e){return"unknown"==e?t.OrientationType.unknown:"orthogonal"==e?t.OrientationType.orthogonal:"isometric"==e?t.OrientationType.isometric:"staggered"==e?t.OrientationType.staggered:"hexagonal"==e?t.OrientationType.hexagonal:t.OrientationType.unknown},e.parseStaggerAxisType=function(e){return"y"==e?t.StaggerAxisType.y:t.StaggerAxisType.x},e.parseStaggerIndexType=function(e){return"even"==e?t.StaggerIndexType.even:t.StaggerIndexType.odd},e.parseRenderOrderType=function(e){return"right-up"==e?t.RenderOrderType.rightUp:"left-down"==e?t.RenderOrderType.leftDown:"left-up"==e?t.RenderOrderType.leftUp:t.RenderOrderType.rightDown},e.parsePropertyDict=function(e){if(!e)return null;for(var i=new Map,n=0,r=e;n<r.length;n++){var o=r[n],s=o.name,a=o.value;"color"==o.type?i.set(s,t.TmxUtils.color16ToUnit(a).toString()):i.set(s,a)}return i},e.parseTmxTileset=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:return n=i.firstgid,r=n,null==(o=i.image)?[3,2]:(o=e.tmxDirectory+o,[4,RES.getResByUrl(o,null,this,RES.ResourceItem.TYPE_IMAGE).catch(function(t){throw new Error(t)})]);case 1:return s=a.sent(),[2,this.loadTmxTileset(new t.TmxTileset,e,s.tileset,r)];case 2:return[2,this.loadTmxTileset(new t.TmxTileset,e,i,r)]}})})},e.loadTmxTileset=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s,a,h,c,u,l,p,d,f,g,m,y,_;return __generator(this,function(v){switch(v.label){case 0:return e.map=i,e.firstGid=r,e.name=n.name,e.tileWidth=n.tilewidth,e.tileHeight=n.tileheight,e.spacing=null!=n.spacing?n.spacing:0,e.margin=null!=n.margin?n.margin:0,e.columns=n.columns,e.tileCount=n.tilecount,e.tileOffset=this.parseTmxTileOffset(n.tileoffset),n.image?(o=e,[4,this.loadTmxImage(new t.TmxImage,n,i.tmxDirectory).catch(function(t){throw new Error(t)})]):[3,2];case 1:o.image=v.sent(),v.label=2;case 2:if(e.terrains=[],n.terrains)for(s=0,a=n.terrains;s<a.length;s++)h=a[s],e.terrains.push(this.parseTmxTerrain(h));for(u in e.tiles=new Map,c=[],n.tiles)c.push(u);l=0,v.label=3;case 3:return l<c.length?(p=c[l],n.tiles.hasOwnProperty(p)?(d=n.tiles[p],[4,this.loadTmxTilesetTile(new t.TmxTilesetTile,e,d,e.terrains,i.tmxDirectory)]):[3,5]):[3,6];case 4:f=v.sent(),e.tiles.set(null==f.id?Number(p)+1:f.id,f),v.label=5;case 5:return l++,[3,3];case 6:if(e.properties=this.parsePropertyDict(n.properties),e.tileRegions=new Map,e.image)for(g=r,m=e.margin;m<e.image.height-e.margin;m+=e.tileHeight+e.spacing)for(y=0,_=e.margin;_<e.image.width-e.margin&&(e.tileRegions.set(g++,new t.Rectangle(_,m,e.tileWidth,e.tileHeight)),!(++y>=e.columns));_+=e.tileWidth+e.spacing);else e.tiles.forEach(function(i,n){e.tileRegions.set(n,new t.Rectangle(0,0,i.image.width,i.image.height))});return[2,e]}})})},e.loadTmxTilesetTile=function(e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){var s,a,h,c,u,l,p,d,f,g,m,y,_;return __generator(this,function(v){switch(v.label){case 0:if(e.tileset=i,e.id=n.id,s=n.terrain)for(e.terrainEdges=new Array(4),a=0,h=0,c=s;h<c.length;h++)u=c[h],l=r[u],e.terrainEdges[a++]=l;return e.probability=null!=n.probability?n.probability:1,e.type=n.type,(p=n.image)?(d=e,[4,this.loadTmxImage(new t.TmxImage,p,o)]):[3,2];case 1:d.image=v.sent(),v.label=2;case 2:if(e.objectGroups=[],n.objectgroup)for(f=0,g=n.objectgroup;f<g.length;f++)_=g[f],e.objectGroups.push(this.loadTmxObjectGroup(new t.TmxObjectGroup,i.map,_));if(e.animationFrames=[],n.animation)for(m=0,y=n.animation.frame;m<y.length;m++)_=y[m],e.animationFrames.push(this.loadTmxAnimationFrame(new t.TmxAnimationFrame,_));return e.properties=this.parsePropertyDict(n.properties),e.properties&&e.processProperties(),[2,e]}})})},e.loadTmxAnimationFrame=function(t,e){return t.gid=e.tileid,t.duration=e.duration/1e3,t},e.loadTmxObjectGroup=function(e,i,n){e.map=i,e.name=null!=n.name?n.name:"",e.color=t.TmxUtils.color16ToUnit(n.color),e.opacity=null!=n.opacity?n.opacity:1,e.visible=null==n.visible||n.visible,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0;var r=new Map;r.set("unknown",t.DrawOrderType.unkownOrder),r.set("topdown",t.DrawOrderType.IndexOrder),r.set("index",t.DrawOrderType.TopDown);var o=n.draworder;o&&(e.drawOrder=r.get(o)),e.objects=[];for(var s=0,a=n.objects;s<a.length;s++){var h=a[s];e.objects.push(this.loadTmxObject(new t.TmxObject,i,h))}return e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxObject=function(e,i,n){e.id=null!=n.id?n.id:0,e.name=null!=n.name?n.name:"",e.x=n.x,e.y=n.y,e.width=null!=n.width?n.width:0,e.height=null!=n.height?n.height:0,e.type=null!=n.type?n.type:"",e.visible=null==n.visible||n.visible,e.rotation=null!=n.rotation?n.rotation:0;var r=n.gid,o=n.ellipse,s=n.polygon,a=n.polyline,h=n.text,c=n.point;return r?(e.tile=new t.TmxLayerTile(i,r,Math.round(e.x),Math.round(e.y)),e.objectType=t.TmxObjectType.tile):o?e.objectType=t.TmxObjectType.ellipse:s?(e.points=this.parsePoints(s),e.objectType=t.TmxObjectType.polygon):a?(e.points=this.parsePoints(a),e.objectType=t.TmxObjectType.polyline):h?(e.text=this.loadTmxText(new t.TmxText,h),e.objectType=t.TmxObjectType.text):e.objectType=c?t.TmxObjectType.point:t.TmxObjectType.basic,e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxText=function(e,i){return e.fontFamily=null!=i.fontfamily?i.fontfamily:"sans-serif",e.pixelSize=null!=i.pixelsize?i.pixelsize:16,e.wrap=null!=i.wrap&&i.wrap,e.color=t.TmxUtils.color16ToUnit(i.color),e.bold=!!i.bold&&i.bold,e.italic=!!i.italic&&i.italic,e.underline=!!i.underline&&i.underline,e.strikeout=!!i.strikeout&&i.strikeout,e.kerning=!i.kerning||i.kerning,e.alignment=this.loadTmxAlignment(new t.TmxAlignment,i),e.value=i,e},e.loadTmxAlignment=function(e,i){function n(t){return t&&""!=t?t[0].toString().toUpperCase()+t.substr(1):t}var r=null!=i.halign?i.halign:"left";e.horizontal=t.TmxHorizontalAlignment[n(r)];var o=null!=i.valign?i.valign:"top";return e.vertical=t.TmxVerticalAlignment[n(o)],e},e.parsePoints=function(t){for(var e=[],i=0,n=0,r=t;n<r.length;n++){var o=r[n];e[i++]=this.parsePoint(o)}return e},e.parsePoint=function(e){return new t.Vector2(e.x,e.y)},e.parseTmxTerrain=function(e){var i=new t.TmxTerrain;return i.name=e.name,i.tile=e.tile,i.properties=this.parsePropertyDict(e.properties),i},e.parseTmxTileOffset=function(e){var i=new t.TmxTileOffset;return e?(i.x=e.x,i.y=e.y,i):(i.x=0,i.y=0,i)},e.loadTmxImage=function(e,i,n){return __awaiter(this,void 0,void 0,function(){var r,o;return __generator(this,function(s){switch(s.label){case 0:return r=i.image,e.source=null!=r?n+r:n+i,[4,RES.getResByUrl(e.source,null,this,RES.ResourceItem.TYPE_IMAGE).catch(function(t){throw new Error(t)})];case 1:return o=s.sent(),e.bitmap=new egret.SpriteSheet(o),e.trans=t.TmxUtils.color16ToUnit(i.trans),e.width=null!=i.imagewidth?i.imagewidth:o.textureWidth,e.height=null!=i.imageheight?i.imageheight:o.textureHeight,[2,e]}})})},e}();t.TiledMapLoader=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){}return i.renderMap=function(e,i,n,r,o){var s=this;e.layers.forEach(function(e){e instanceof t.TmxLayer&&e.visible?s.renderLayer(e,i,n,r,o):e instanceof t.TmxImageLayer&&e.visible?s.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?s.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&s.renderObjectGroup(e,i,n,r,o)})},i.renderLayer=function(e,i,n,r,o){if(e.visible)for(var s=e.map.tileWidth*r.x,a=e.map.tileHeight*r.y,h=t.DrawUtils.getColorMatrix(16777215),c=0;c<e.tiles.length;c++){var u=e.tiles[c];u&&this.renderTile(u,i,n,r,s,a,h,o)}},i.renderLayerRenderCamera=function(e,i,n,r,o,s){e instanceof t.TmxLayer&&e.visible?this.renderLayerCamera(e,i,n,r,o,s):e instanceof t.TmxImageLayer&&e.visible?this.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?this.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&this.renderObjectGroup(e,i,n,r,o)},i.renderLayerCamera=function(e,i,n,r,o,s){if(e.visible){n=n.add(e.offset),s.location=s.location.subtract(n);var a,h,c,u=e.map.tileWidth*r.x,l=e.map.tileHeight*r.y,p=0;e.map.requiresLargeTileCulling?(a=e.map.worldToTilePositionX(s.left-(e.map.maxTileWidth*r.x-u)),h=e.map.worldToTilePositionY(s.top-(e.map.maxTileHeight*r.y-l)),c=e.map.worldToTilePositionX(s.right+(e.map.maxTileWidth*r.x-u)),p=e.map.worldToTilePositionY(s.bottom+(e.map.maxTileHeight*r.y-l))):(a=e.map.worldToTilePositionX(s.left),h=e.map.worldToTilePositionY(s.top),c=e.map.worldToTilePositionX(s.right),p=e.map.worldToTilePositionY(s.bottom));for(var d=t.DrawUtils.getColorMatrix(16777215),f=h;f<=p;f++)for(var g=a;g<=c;g++){var m=e.getTile(g,f);m&&this.renderTile(m,i,n,r,u,l,d,o)}}},i.renderImageLayer=function(e,i,n,r,o){if(e.visible){var s=t.DrawUtils.getColorMatrix(16777215),a=t.Vector2.add(n,new t.Vector2(e.offsetX,e.offsetY).multiply(r));e.image.texture.parent||i.addChild(e.image.texture),e.image.texture.x=a.x,e.image.texture.y=a.y,e.image.texture.scaleX=r.x,e.image.texture.scaleY=r.y,e.image.texture.filters=[s]}},i.renderObjectGroup=function(e,i,n,r,o){if(e.visible)for(var s in e.objects){var a=e.objects[s];if(a.visible&&(t.Core.debugRenderEndabled||a.objectType==t.TmxObjectType.tile||a.objectType==t.TmxObjectType.text)){var h=t.Vector2.add(n,new t.Vector2(a.x,a.y).multiply(r));switch(a.objectType){case t.TmxObjectType.basic:a.shape.parent||(a.shape.x=a.x,a.shape.y=a.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawRect(0,0,a.width*r.x,a.height*r.y),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.point:var c=.5*e.map.tileWidth;h.x-=.5*c,h.y-=.5*c,a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,1),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.tile:this.renderTilesetTile(e,a,i,h,r,p);break;case t.TmxObjectType.ellipse:h=new t.Vector2(a.x+.5*a.width,a.y+.5*a.height).multiply(r),a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,.5*a.width),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.polygon:case t.TmxObjectType.polyline:for(var u=[],l=0;l<a.points.length;l++)u[l]=t.Vector2.multiply(a.points[l],r);if(!a.shape.parent&&u.length>0){a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884);for(l=0;l<u.length;l++)a.shape.graphics.lineTo(u[l].x,u[l].y);a.shape.graphics.endFill(),p(a,h)}break;case t.TmxObjectType.text:a.textField.parent||(a.textField.x=h.x,a.textField.y=h.y,i.addChild(a.textField),a.textField.text=a.text.value,a.textField.textColor=a.text.color,a.textField.bold=null!=a.text.bold&&a.text.bold,a.textField.italic=null!=a.text.italic&&a.text.italic,a.textField.size=a.text.pixelSize,a.textField.fontFamily=a.text.fontFamily)}}}function p(e,n){i&&t.Core.debugRenderEndabled&&!e.textField.parent&&e.name&&(e.textField.text=e.name,e.textField.size=12,e.textField.fontFamily="sans-serif",e.shape?(e.textField.x=n.x+(e.shape.getBounds().width-e.textField.width)/2+e.shape.getBounds().x,e.textField.y=n.y-e.textField.height-5+e.shape.getBounds().y):(e.textField.x=n.x+(e.width-e.textField.width)/2,e.textField.y=n.y-e.textField.height-5),e.textField.background=!0,e.textField.backgroundColor=10526884,e.textField.textColor=16777215,i.addChild(e.textField))}},i.renderTilesetTile=function(t,i,n,r,o,s){var a=t.map.getTilesetForTileGid(i.tile.gid),h=a.tileRegions.get(i.tile.gid);if(n)if(a.image){i.tile.horizontalFlip&&i.tile.verticalFlip?(r.x+=a.tileHeight+(h.height*o.y-a.tileHeight),r.y-=h.width*o.x-a.tileWidth):i.tile.horizontalFlip?r.x+=a.tileWidth+(h.height*o.y-a.tileHeight):i.tile.verticalFlip?r.y+=a.tileWidth-h.width*o.x:r.y+=a.tileHeight-h.height*o.y,(c=a.image.bitmap.getTexture(""+i.tile.gid))||(c=a.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),a.image.texture=new e(c),n.addChild(a.image.texture),a.image.texture.x=r.x,a.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=-1):i.tile.verticalFlip?(a.image.texture.scaleX=o.x,a.image.texture.scaleY=-1):i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=o.y):(a.image.texture.scaleX=o.x,a.image.texture.scaleY=o.y),a.image.texture.anchorOffsetX=0,a.image.texture.anchorOffsetY=0,s(i,r)}else{var c,u=a.tiles.get(i.tile.gid);(c=u.image.bitmap.getTexture(""+i.tile.gid))||(c=u.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),r.y-=i.height,u.image.texture=new e(c),n.addChild(u.image.texture),u.image.texture.width=i.width,u.image.texture.height=i.height,u.image.texture.x=r.x,u.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=-1):i.tile.verticalFlip?(u.image.texture.scaleX=o.x,u.image.texture.scaleY=-1):i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=o.y):(u.image.texture.scaleX=o.x,u.image.texture.scaleY=o.y),u.image.texture.anchorOffsetX=0,u.image.texture.anchorOffsetY=0}},i.renderGroup=function(e,i,n,r,o){var s=this;e.visible&&e.layers.forEach(function(e){e instanceof t.TmxGroup&&s.renderGroup(e,i,n,r,o),e instanceof t.TmxObjectGroup&&s.renderObjectGroup(e,i,n,r,o),e instanceof t.TmxLayer&&s.renderLayer(e,i,n,r,o),e instanceof t.TmxImageLayer&&s.renderImageLayer(e,i,n,r,o)})},i.renderTile=function(i,n,r,o,s,a,h,c){var u=i.gid,l=i.tilesetTile;l&&l.animationFrames.length>0&&(u=l.currentAnimationFrameGid);var p=i.tileset.tileRegions.get(u),d=Math.floor(i.x)*s,f=Math.floor(i.y)*a;i.horizontalFlip&&i.verticalFlip?(d+=a+(p.height*o.y-a),f-=p.width*o.x-s):i.horizontalFlip?d+=s+(p.height*o.y-a):i.verticalFlip?f+=s-p.width*o.x:f+=a-p.height*o.y;var g=new t.Vector2(d,f).add(r);if(i.tileset.image){if(n){var m=i.tileset.image.bitmap.getTexture(""+u);m||(m=i.tileset.image.bitmap.createTexture(""+u,p.x,p.y,p.width,p.height)),i.tileset.image.texture=new e(m),n.addChild(i.tileset.image.texture),i.tileset.image.texture.x!=g.x&&(i.tileset.image.texture.x=g.x),i.tileset.image.texture.y!=g.y&&(i.tileset.image.texture.y=g.y),i.verticalFlip&&i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=-1):i.verticalFlip?(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=-1):i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=o.y):(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=o.y),0!=i.tileset.image.texture.rotation&&(i.tileset.image.texture.rotation=0),0!=i.tileset.image.texture.anchorOffsetX&&(i.tileset.image.texture.anchorOffsetX=0),0!=i.tileset.image.texture.anchorOffsetY&&(i.tileset.image.texture.anchorOffsetY=0)}}else l.image.texture&&(l.image.bitmap.getTexture(u.toString())||(l.image.texture=new e(l.image.bitmap.createTexture(u.toString(),p.x,p.y,p.width,p.height)),n.addChild(l.image.texture)),l.image.texture.x=g.x,l.image.texture.y=g.y,l.image.texture.scaleX=o.x,l.image.texture.scaleY=o.y,l.image.texture.rotation=0,l.image.texture.anchorOffsetX=0,l.image.texture.anchorOffsetY=0,l.image.texture.filters=[h])},i}();t.TiledRendering=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.update=function(){this.tiles.forEach(function(t){t.updateAnimatedTiles()})},e}(t.TmxDocument);t.TmxTileset=e;var i=function(){return function(){}}();t.TmxTileOffset=i;var n=function(){return function(){}}();t.TmxTerrain=n}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"currentAnimationFrameGid",{get:function(){return this.animationFrames[this._animationCurrentFrame].gid+this.tileset.firstGid},enumerable:!0,configurable:!0}),e.prototype.processProperties=function(){var t;(t=this.properties.get("engine.isDestructable"))&&(this.isDestructable=Boolean(t)),(t=this.properties.get("engine:isSlope"))&&(this.isSlope=Boolean(t)),(t=this.properties.get("engine:isOneWayPlatform"))&&(this.isOneWayPlatform=Boolean(t)),(t=this.properties.get("engine:slopeTopLeft"))&&(this.slopeTopLeft=Number(t)),(t=this.properties.get("engine:slopeTopRight"))&&(this.slopeTopRight=Number(t))},e.prototype.updateAnimatedTiles=function(){0!=this.animationFrames.length&&(this._animationElapsedTime+=t.Time.deltaTime,this._animationElapsedTime>this.animationFrames[this._animationCurrentFrame].duration&&(this._animationCurrentFrame=t.MathHelper.incrementWithWrap(this._animationCurrentFrame,this.animationFrames.length),this._animationElapsedTime=0))},e}();t.TmxTilesetTile=e;var i=function(){return function(){}}();t.TmxAnimationFrame=i}(es||(es={})),function(t){var e=function(){function e(){}return e.decode=function(e,i,n){switch(n=n||"none",i=i||"none"){case"base64":var r=t.Base64Utils.decodeBase64AsArray(e,4);return"none"===n?r:t.Base64Utils.decompress(e,r,n);case"csv":return t.Base64Utils.decodeCSV(e);case"none":for(var o=[],s=0;s<e.length;s++)o[s]=+e[s].gid;return o;default:throw new Error("未定义的编码:"+i)}},e.color16ToUnit=function(t){if(!t)return 16777215;var e="0x"+t.slice(1);return parseInt(e,16)},e}();t.TmxUtils=e}(es||(es={}));var ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,i=0;i<t.length;i++){e=!1;for(var n=t.length-1;n>i;n--)if(t[n]<t[n-1]){var r=t[n];t[n]=t[n-1],t[n-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,i=1;i<e;i++){for(var n=t[i],r=i;r>0&&t[r-1]>n;r--)t[r]=t[r-1];t[r]=n}},t.binarySearch=function(t,e){for(var i=0,n=t.length,r=i+n>>1;i<n;)e<=t[r]?n=r:e>=t[r]&&(i=r+1),r=i+n>>1;return t[i]==e?i:-1},t.findElementIndex=function(t,e){for(var i=t.length,n=0;n<i;++n)if(t[n]==e)return n;return null},t.getMaxElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]>t[e]&&(e=n);return e},t.getMinElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]<t[e]&&(e=n);return e},t.getUniqueAry=function(t){for(var e=[],i=[],n=t.length,r=0;r<n;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(n=e.length)-1;r>=0;--r)i.unshift(e[r]);return i},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var i=t.concat(e),n={},r=[],o=i.length,s=0;s<o;++s)n[i[s]]?n[i[s]]instanceof Object&&n[i[s]].count++:(n[i[s]]={},n[i[s]].count=0,n[i[s]].key=i[s],n[i[s]].count++);for(var a in n)2!=n[a].count&&r.unshift(n[a].key);return r},t.swap=function(t,e,i){var n=t[e];t[e]=t[i],t[i]=n},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var i=t.length;if(i!=e.length)return!1;for(;i--;)if(t[i]!=e[i])return!1;return!0},t.insert=function(t,e,i){if(!t)return null;var n=t.length;if(e>n&&(e=n),e<0&&(e=0),e==n)t.push(i);else if(0==e)t.unshift(i);else{for(var r=n-1;r>=e;r-=1)t[r+1]=t[r];t[e]=i}return i},t}();!function(t){var e=function(){function t(){}return Object.defineProperty(t,"nativeBase64",{get:function(){return"function"==typeof window.atob},enumerable:!0,configurable:!0}),t.decode=function(t){if(t=t.replace(/[^A-Za-z0-9\+\/\=]/g,""),this.nativeBase64)return window.atob(t);for(var e,i,n,r,o,s,a=[],h=0;h<t.length;)e=this._keyStr.indexOf(t.charAt(h++))<<2|(r=this._keyStr.indexOf(t.charAt(h++)))>>4,i=(15&r)<<4|(o=this._keyStr.indexOf(t.charAt(h++)))>>2,n=(3&o)<<6|(s=this._keyStr.indexOf(t.charAt(h++))),a.push(String.fromCharCode(e)),64!==o&&a.push(String.fromCharCode(i)),64!==s&&a.push(String.fromCharCode(n));return a=a.join("")},t.encode=function(t){if(t=t.replace(/\r\n/g,"\n"),!this.nativeBase64){for(var e,i,n,r,o,s,a,h=[],c=0;c<t.length;)r=(e=t.charCodeAt(c++))>>2,o=(3&e)<<4|(i=t.charCodeAt(c++))>>4,s=(15&i)<<2|(n=t.charCodeAt(c++))>>6,a=63&n,isNaN(i)?s=a=64:isNaN(n)&&(a=64),h.push(this._keyStr.charAt(r)),h.push(this._keyStr.charAt(o)),h.push(this._keyStr.charAt(s)),h.push(this._keyStr.charAt(a));return h=h.join("")}window.btoa(t)},t.decodeBase64AsArray=function(e,i){i=i||1;var n,r,o,s=t.decode(e),a=new Uint32Array(s.length/i);for(n=0,o=s.length/i;n<o;n++)for(a[n]=0,r=i-1;r>=0;--r)a[n]+=s.charCodeAt(n*i+r)<<(r<<3);return a},t.decompress=function(t,e,i){throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!")},t.decodeCSV=function(t){for(var e=t.replace("\n","").trim().split(","),i=[],n=0;n<e.length;n++)i.push(+e[n]);return i},t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",t}();t.Base64Utils=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r){if(0!=(4294967040&(e|i|n|r))){var o=t.MathHelper.clamp(e,0,255),s=t.MathHelper.clamp(i,0,255),a=t.MathHelper.clamp(n,0,255),h=t.MathHelper.clamp(r,0,255);this._packedValue=h<<24|a<<16|s<<8|o}else this._packedValue=r<<24|n<<16|i<<8|e}return Object.defineProperty(e.prototype,"b",{get:function(){return this._packedValue>>16},set:function(t){this._packedValue=4278255615&this._packedValue|t<<16},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"g",{get:function(){return this._packedValue>>8},set:function(t){this._packedValue=4294902015&this._packedValue|t<<8},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"r",{get:function(){return this._packedValue},set:function(t){this._packedValue=4294967040&this._packedValue|t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"a",{get:function(){return this._packedValue>>24},set:function(t){this._packedValue=16777215&this._packedValue|t<<24},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedValue",{get:function(){return this._packedValue},set:function(t){this._packedValue=t},enumerable:!0,configurable:!0}),e.prototype.equals=function(t){return this._packedValue==t._packedValue},e}();t.Color=e}(es||(es={})),function(t){var e=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var i=this;return void 0===e&&(e=!0),new Promise(function(n,r){var o=i.loadedAssets.get(t);o?n(o):e?RES.getResAsync(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}();t.ContentManager=e}(es||(es={})),function(t){var e=function(){function t(){}return t.getColorMatrix=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];return e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255,new egret.ColorMatrixFilter(e)},t}();t.DrawUtils=e}(es||(es={})),function(t){var e=function(){function e(){}return e.oppositeEdge=function(e){switch(e){case t.Edge.bottom:return t.Edge.top;case t.Edge.top:return t.Edge.bottom;case t.Edge.left:return t.Edge.right;case t.Edge.right:return t.Edge.left}},e.isHorizontal=function(e){return e==t.Edge.right||e==t.Edge.left},e.isVertical=function(e){return e==t.Edge.top||e==t.Edge.bottom},e}();t.EdgeExt=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.func=t,this.context=e}}();t.FuncPack=e;var i=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,i,n){var r=this._messageTable.get(t);r||(r=[],this._messageTable.set(t,r)),-1!=r.findIndex(function(t){return t.func==i})&&console.warn("您试图添加相同的观察者两次"),r.push(new e(i,n))},t.prototype.removeObserver=function(t,e){var i=this._messageTable.get(t),n=i.findIndex(function(t){return t.func==e});-1!=n&&i.removeAt(n)},t.prototype.emit=function(t,e){var i=this._messageTable.get(t);if(i)for(var n=i.length-1;n>=0;n--)i[n].func.call(i[n].context,e)},t}();t.Emitter=i}(es||(es={})),function(t){!function(t){t[t.top=0]="top",t[t.bottom=1]="bottom",t[t.left=2]="left",t[t.right=3]="right"}(t.Edge||(t.Edge={}))}(es||(es={})),function(t){var e=function(){function t(){}return t.repeat=function(t,e){for(var i=[];e--;)i.push(t);return i},t}();t.Enumerable=e}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t}();t.GlobalManager=e}(es||(es={})),function(t){var e=function(){function e(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),e.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},e}();t.TouchState=e;var i=function(){function i(){}return Object.defineProperty(i,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(i,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(i,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:t.Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(i,"maxSupportedTouch",{get:function(){return t.Core._instance.stage.maxTouches},set:function(e){t.Core._instance.stage.maxTouches=e,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPositionDelta",{get:function(){var e=t.Vector2.subtract(this.touchPosition,this._previousTouchState.position);return e.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),e},enumerable:!0,configurable:!0}),i.initialize=function(){this._init||(this._init=!0,t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},i.scaledPosition=function(e){var i=new t.Vector2(e.x-this._resolutionOffset.x,e.y-this._resolutionOffset.y);return t.Vector2.multiply(i,this.resolutionScale)},i.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new e)},i.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},i.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var i=this._gameTouchs[e];i.x=t.stageX,i.y=t.stageY}},i.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},i.setpreviousTouchState=function(t){this._previousTouchState=new e,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},i._init=!1,i._previousTouchState=new e,i._resolutionOffset=new t.Vector2,i._touchIndex=0,i._gameTouchs=[],i._resolutionScale=t.Vector2.one,i._totalTouchCount=0,i}();t.Input=i}(es||(es={}));var KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.registerKey=function(t,e,i,n){void 0===n&&(n=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(n?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:i}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),i=this.keyDownDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),i=this.keyUpDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}();!function(t){var e=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}();t.ListPool=e}(es||(es={}));var THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y",this.setItem=egret.localStorage.setItem.bind(localStorage),this.getItem=egret.localStorage.getItem.bind(localStorage),this.removeItem=egret.localStorage.removeItem.bind(localStorage)}return t.prototype.lock=function(){var t=this;return new Promise(function(e,i){var n=function(){t.setItem(t._keyX,THREAD_ID),null===!t.getItem(t._keyY)&&nextTick(n),t.setItem(t._keyY,THREAD_ID),t.getItem(t._keyX)!==THREAD_ID?setTimeout(function(){t.getItem(t._keyY)===THREAD_ID?(e(),t.removeItem(t._keyY)):nextTick(n)},10):(e(),t.removeItem(t._keyY))};n()})},t}();!function(t){var e=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}();t.Pair=e}(es||(es={}));var RandomUtils=function(){function t(){}return t.randrange=function(t,e,i){if(void 0===i&&(i=1),0==i)throw new Error("step 不能为 0");var n=e-t;if(0==n)throw new Error("没有可用的范围("+t+","+e+")");n<0&&(n=t-e);var r=Math.floor((n+i-1)/i);return Math.floor(this.random()*r)*i+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var i=t.length;if(e<=0||i<e)throw new Error("采样数量不够");for(var n=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*i);r.indexOf(s)>=0;)s=Math.floor(this.random()*i);n.push(t[s]),r.push(s)}return n},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t}();!function(t){var e=function(){function e(){}return e.getSide=function(e,i){switch(i){case t.Edge.top:return e.top;case t.Edge.bottom:return e.bottom;case t.Edge.left:return e.left;case t.Edge.right:return e.right}},e.union=function(e,i){var n=new t.Rectangle(i.x,i.y,0,0),r=new t.Rectangle;return r.x=Math.min(e.x,n.x),r.y=Math.min(e.y,n.y),r.width=Math.max(e.right,n.right)-r.x,r.height=Math.max(e.bottom,r.bottom)-r.y,r},e.getHalfRect=function(e,i){switch(i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,e.height/2);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height/2,e.width,e.height/2);case t.Edge.left:return new t.Rectangle(e.x,e.y,e.width/2,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width/2,e.y,e.width/2,e.height)}},e.getRectEdgePortion=function(e,i,n){switch(void 0===n&&(n=1),i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,n);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height-n,e.width,n);case t.Edge.left:return new t.Rectangle(e.x,e.y,n,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width-n,e.y,n,e.height)}},e.expandSide=function(e,i,n){switch(n=Math.abs(n),i){case t.Edge.top:e.y-=n,e.height+=n;break;case t.Edge.bottom:e.height+=n;break;case t.Edge.left:e.x-=n,e.width+=n;break;case t.Edge.right:e.width+=n}},e.contract=function(t,e,i){t.x+=e,t.y+=i,t.width-=2*e,t.height-=2*i},e}();t.RectangleExt=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.update=function(t){this.remainder+=t;var e=Math.trunc(this.remainder);return this.remainder-=e,e},t.prototype.reset=function(){this.remainder=0},t}();t.SubpixelNumber=e}(es||(es={})),function(t){var e=function(){function e(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return e.testPointTriangle=function(e,i,n,r){return!(t.Vector2Ext.cross(t.Vector2.subtract(e,i),t.Vector2.subtract(n,i))<0)&&(!(t.Vector2Ext.cross(t.Vector2.subtract(e,n),t.Vector2.subtract(r,n))<0)&&!(t.Vector2Ext.cross(t.Vector2.subtract(e,r),t.Vector2.subtract(i,r))<0))},e.prototype.triangulate=function(i,n){void 0===n&&(n=!0);var r=i.length;this.initialize(r);for(var o=0,s=0;r>3&&o<500;){o++;var a=!0,h=i[this._triPrev[s]],c=i[s],u=i[this._triNext[s]];if(t.Vector2Ext.isTriangleCCW(h,c,u)){var l=this._triNext[this._triNext[s]];do{if(e.testPointTriangle(i[l],h,c,u)){a=!1;break}l=this._triNext[l]}while(l!=this._triPrev[s])}else a=!1;a?(this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),this._triNext[this._triPrev[s]]=this._triNext[s],this._triPrev[this._triNext[s]]=this._triPrev[s],r--,s=this._triPrev[s]):s=this._triNext[s]}this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),n||this.triangleIndices.reverse()},e.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},e}();t.Triangulator=e}(es||(es={})),function(t){var e=function(){function e(){}return e.isTriangleCCW=function(e,i,n){return this.cross(t.Vector2.subtract(i,e),t.Vector2.subtract(n,i))<0},e.cross=function(t,e){return t.y*e.x-t.x*e.y},e.perpendicular=function(e,i){return new t.Vector2(-1*(i.y-e.y),i.x-e.x)},e.normalize=function(e){var i=Math.sqrt(e.x*e.x+e.y*e.y);return i>t.MathHelper.Epsilon?e=t.Vector2.divide(e,new t.Vector2(i)):e.x=e.y=0,e},e.transformA=function(t,e,i,n,r,o){for(var s=0;s<o;s++){var a=t[e+s],h=n[r+s];h.x=a.x*i.m11+a.y*i.m21+i.m31,h.y=a.x*i.m12+a.y*i.m22+i.m32,n[r+s]=h}},e.transformR=function(e,i){var n=e.x*i.m11+e.y*i.m21+i.m31,r=e.x*i.m12+e.y*i.m22+i.m32;return new t.Vector2(n,r)},e.transform=function(t,e,i){this.transformA(t,0,e,i,0,t.length)},e.round=function(e){return new t.Vector2(Math.round(e.x),Math.round(e.y))},e}();t.Vector2Ext=e}(es||(es={}));var stopwatch,WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}();!function(t){var e,i=function(){function i(){this.clientArea=new t.Rectangle(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.safeArea=this.clientArea}return i.prototype.place=function(i,n,r,o){var s=new t.Rectangle(0,0,i.x,i.y);return 0!=(o&e.left)?s.x=this.clientArea.x+this.clientArea.width*n:0!=(o&e.right)?s.x=this.clientArea.x+this.clientArea.width*(1-n)-s.width:0!=(o&e.horizontalCenter)&&(s.x=this.clientArea.x+(this.clientArea.width-s.width)/2+n*this.clientArea.width),0!=(o&e.top)?s.y=this.clientArea.y+this.clientArea.height*r:0!=(o&e.bottom)?s.y=this.clientArea.y+this.clientArea.height*(1-r)-s.height:0!=(o&e.verticalCenter)&&(s.y=this.clientArea.y+(this.clientArea.height-s.height)/2+r*this.clientArea.height),s.left<this.safeArea.left&&(s.x=this.safeArea.left),s.right>this.safeArea.right&&(s.x=this.safeArea.right-s.width),s.top<this.safeArea.top&&(s.y=this.safeArea.top),s.bottom>this.safeArea.bottom&&(s.y=this.safeArea.bottom-s.height),s},i}();t.Layout=i,function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(e=t.Alignment||(t.Alignment={}))}(es||(es={})),function(t){var e,i=function(){function t(t){void 0===t&&(t=n),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(i=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var i=this.getSystemTime();this._startSystemTime=i,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=i,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),n=t};var n=Date.now}(stopwatch||(stopwatch={})),function(t){var e=function(){function e(){this.showLog=!1,this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this._logs=new Array(2);for(var e=0;e<this._logs.length;++e)this._logs[e]=new i;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*t.Core.graphicsDevice.viewport.width,t.Core.emitter.addObserver(t.CoreEvents.GraphicsDeviceReset,this.onGraphicsDeviceReset,this),this.onGraphicsDeviceReset()}return Object.defineProperty(e,"Instance",{get:function(){return this._instance||(this._instance=new e),this._instance},enumerable:!0,configurable:!0}),e.prototype.startFrame=function(){var t=this;new LockUtils(this._frameKey).lock().then(function(){t._updateCount=parseInt(egret.localStorage.getItem(t._frameKey),10),isNaN(t._updateCount)&&(t._updateCount=0);var i=t._updateCount;if(i+=1,egret.localStorage.setItem(t._frameKey,i.toString()),!(t.enabled&&1<i&&i<e.maxSampleFrames)){t._prevLog=t._logs[1&t.frameCount++],t._curLog=t._logs[1&t.frameCount];for(var n=t.stopwacth.getTime(),r=0;r<t._prevLog.bars.length;++r){for(var o=t._prevLog.bars[r],s=t._curLog.bars[r],a=0;a<o.nestCount;++a){var h=o.markerNests[a];o.markers[h].endTime=n,s.markerNests[a]=a,s.markers[a].markerId=o.markers[h].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[h].color}for(h=0;h<o.markCount;++h){var c=o.markers[h].endTime-o.markers[h].beginTime,u=o.markers[h].markerId,l=t.markers[u];l.logs[r].color=o.markers[h].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,c),l.logs[r].max=Math.min(l.logs[r].max,c),l.logs[r].avg+=c,l.logs[r].avg*=.5,l.logs[r].samples++>=e.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=c,l.logs[r].max=c,l.logs[r].avg=c,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}t.stopwacth.reset(),t.stopwacth.start()}})},e.prototype.beginMark=function(t,i,n){var r=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=e.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[n];if(o.markCount>=e.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=e.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(t);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(t,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=i,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},e.prototype.endMark=function(t,i){var n=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=e.maxBars)throw new Error("barIndex argument out of range");var r=n._curLog.bars[i];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=n._markerNameToIdMap.get(t);if(isNaN(o))throw new Error("Marker "+t+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=n.stopwacth.getTime()})},e.prototype.getAverageTime=function(t,i){if(t<0||t>=e.maxBars)throw new Error("barIndex argument out of range");var n=0,r=this._markerNameToIdMap.get(i);return r&&(n=this.markers[r].logs[t].avg),n},e.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},e.prototype.render=function(t,i){if(void 0===t&&(t=this._position),void 0===i&&(i=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var n=0,r=0;this._prevLog.bars.forEach(function(t){t.markCount>0&&(n+=e.barHeight+2*e.barPadding,r=Math.max(r,t.markers[t.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>e.autoAdjustDelay&&(this.sampleFrames=Math.min(e.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);t.y,e.barHeight}},e.prototype.onGraphicsDeviceReset=function(){var i=new t.Layout;this._position=i.place(new t.Vector2(this.width,e.barHeight),0,.01,t.Alignment.bottomCenter).location},e.maxBars=8,e.maxSamples=256,e.maxNestCall=32,e.barHeight=8,e.maxSampleFrames=4,e.logSnapDuration=120,e.barPadding=2,e.autoAdjustDelay=30,e}();t.TimeRuler=e;var i=function(){return function(){this.bars=new Array(e.maxBars),this.bars.fill(new n,0,e.maxBars)}}();t.FrameLog=i;var n=function(){return function(){this.markers=new Array(e.maxSamples),this.markCount=0,this.markerNests=new Array(e.maxNestCall),this.nestCount=0,this.markers.fill(new r,0,e.maxSamples),this.markerNests.fill(0,0,e.maxNestCall)}}();t.MarkerCollection=n;var r=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}();t.Marker=r;var o=function(){return function(t){this.logs=new Array(e.maxBars),this.name=t,this.logs.fill(new s,0,e.maxBars)}}();t.MarkerInfo=o;var s=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();t.MarkerLog=s}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){this.itemsToRaster=[],this.useCache=!1,this.cacheName="",this._sprites=new Map,this.allow4096Textures=!1}return i.prototype.addTextureToPack=function(e,i){this.itemsToRaster.push(new t.TextureToPack(e,i))},i.prototype.process=function(t){return void 0===t&&(t=!1),__awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this.allow4096Textures=t,this.useCache?""==this.cacheName?(console.error("未指定缓存名称"),[2]):[4,RES.getResByUrl(this.cacheName)]:[3,2];case 1:return e.sent()?this.loadPack():this.createPack(),[3,3];case 2:this.createPack(),e.label=3;case 3:return[2]}})})},i.prototype.loadPack=function(){return __awaiter(this,void 0,void 0,function(){var t;return __generator(this,function(e){switch(e.label){case 0:return[4,RES.getResByUrl(this.cacheName)];case 1:return t=e.sent(),this.onProcessCompleted&&this.onProcessCompleted(),[2,t]}})})},i.prototype.createPack=function(){for(var i=[],n=[],r=0,o=this.itemsToRaster;r<o.length;r++){var s=o[r];i.push(new e(s.texture)),n.push(s.id)}for(var a=this.allow4096Textures?4096:2048,h=[],c=0;c<i.length;c++){if(i[c].width>a||i[c].height>a)throw new Error("一个纹理的大小比图集的大小大");h.push(new t.Rectangle(0,0,i[c].width,i[c].height))}for(;h.length>0;){var u=new egret.RenderTexture,l=new t.RectanglePacker(a,a,1);for(c=0;c<h.length;c++)l.insertRectangle(Math.floor(h[c].width),Math.floor(h[c].height),c);if(l.packRectangles(),l.rectangleCount>0){for(var p=new t.IntegerRectangle,d=[],f=[],g=[],m=[],y=0;y<l.rectangleCount;y++){p=l.getRectangle(y,p);var _=l.getRectangleId(y);u.drawToTexture(i[_],new t.Rectangle(p.x,p.y,p.width,p.height)),(R=new t.TextureAsset).x=p.x,R.y=p.y,R.width=p.width,R.height=p.height,R.name=n[_],d.push(R),f.push(h[_]),g.push(i[_].texture),m.push(n[_])}for(var v=0,b=f;v<b.length;v++){var x=b[v];h.remove(x)}for(var T=function(t){i.removeAll(function(e){return e.texture.hashCode==t.hashCode})},w=0,C=g;w<C.length;w++){T(x=C[w])}for(var S=0,P=m;S<P.length;S++){x=P[S];n.remove(x)}""!=this.cacheName&&(u.saveToFile("image/png",this.cacheName),0);for(var O=0,D=d;O<D.length;O++){var R=D[O];this._sprites.set(R.name,u)}}}this.onProcessCompleted&&this.onProcessCompleted()},i.prototype.dispose=function(){this._sprites.forEach(function(t,e){t.dispose(),RES.destroyRes(e)}),this._sprites.clear()},i.prototype.getTexture=function(t){return this._sprites.get(t)},i}();t.AssetPacker=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Rectangle);t.IntegerRectangle=e}(es||(es={})),function(t){var e=function(){function e(e,i,n){void 0===n&&(n=0),this._width=0,this._height=0,this._padding=8,this._packedWidth=0,this._packedHeight=0,this._insertList=[],this._insertedRectangles=[],this._freeAreas=[],this._newFreeAreas=[],this._sortableSizeStack=[],this._rectangleStack=[],this._outsideRectangle=new t.IntegerRectangle(e+1,i+1,0,0),this.reset(e,i,n)}return Object.defineProperty(e.prototype,"rectangleCount",{get:function(){return this._insertedRectangles.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedWidth",{get:function(){return this._packedWidth},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedHeight",{get:function(){return this._packedHeight},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"padding",{get:function(){return this._padding},enumerable:!0,configurable:!0}),e.prototype.reset=function(t,e,i){for(void 0===i&&(i=0);this._insertedRectangles.length>0;)this.freeRectangle(this._insertedRectangles.pop());for(;this._freeAreas.length>0;)this.freeRectangle(this._freeAreas.pop());for(this._width=t,this._height=e,this._packedWidth=0,this._packedHeight=0,this._freeAreas.push(this.allocateRectangle(0,0,this._width,this._height));this._insertedRectangles.length>0;)this.freeSize(this._insertList.pop());this._padding=i},e.prototype.insertRectangle=function(t,e,i){var n=this.allocateSize(t,e,i);this._insertList.push(n)},e.prototype.packRectangles=function(t){for(void 0===t&&(t=!0),t&&this._insertList.sort(function(t,e){return t.width-e.width});this._insertList.length>0;){var e=this._insertList.pop(),i=e.width,n=e.height,r=this.getFreeAreaIndex(i,n);if(r>=0){var o=this._freeAreas[r],s=this.allocateRectangle(o.x,o.y,i,n);for(s.id=e.id,this.generateNewFreeAreas(s,this._freeAreas,this._newFreeAreas);this._newFreeAreas.length>0;)this._freeAreas.push(this._newFreeAreas.pop());this._insertedRectangles.push(s),s.right>this._packedWidth&&(this._packedWidth=s.right),s.bottom>this._packedHeight&&(this._packedHeight=s.bottom)}this.freeSize(e)}return this.rectangleCount},e.prototype.getRectangle=function(t,e){var i=this._insertedRectangles[t];return e.x=i.x,e.y=i.y,e.width=i.width,e.height=i.height,e},e.prototype.getRectangleId=function(t){return this._insertedRectangles[t].id},e.prototype.generateNewFreeAreas=function(t,e,i){var n=t.x,r=t.y,o=t.right+1+this._padding,s=t.bottom+1+this._padding,a=null;0==this._padding&&(a=t);for(var h=e.length-1;h>=0;h--){var c=e[h];if(!(n>=c.right||o<=c.x||r>=c.bottom||s<=c.y)){null==a&&(a=this.allocateRectangle(t.x,t.y,t.width+this._padding,t.height+this._padding)),this.generateDividedAreas(a,c,i);var u=e.pop();h<e.length&&(e[h]=u)}}null!=a&&a!=t&&this.freeRectangle(a),this.filterSelfSubAreas(i)},e.prototype.filterSelfSubAreas=function(t){for(var e=t.length-1;e>=0;e--)for(var i=t[e],n=t.length-1;n>=0;n--)if(e!=n){var r=t[n];if(i.x>=r.x&&i.y>=r.y&&i.right<=r.right&&i.bottom<=r.bottom){this.freeRectangle(i);var o=t.pop();e<t.length&&(t[e]=o);break}}},e.prototype.generateDividedAreas=function(t,e,i){var n=0,r=e.right-t.right;r>0&&(i.push(this.allocateRectangle(t.right,e.y,r,e.height)),n++);var o=t.x-e.x;o>0&&(i.push(this.allocateRectangle(e.x,e.y,o,e.height)),n++);var s=e.bottom-t.bottom;s>0&&(i.push(this.allocateRectangle(e.x,t.bottom,e.width,s)),n++);var a=t.y-e.y;a>0&&(i.push(this.allocateRectangle(e.x,e.y,e.width,a)),n++),0==n&&(t.width<e.width||t.height<e.height)?i.push(e):this.freeRectangle(e)},e.prototype.getFreeAreaIndex=function(t,e){for(var i=this._outsideRectangle,n=-1,r=t+this._padding,o=e+this._padding,s=this._freeAreas.length-1;s>=0;s--){var a=this._freeAreas[s];if(a.x<this._packedWidth||a.y<this.packedHeight){if(a.x<i.x&&r<=a.width&&o<=a.height){if(n=s,r==a.width&&a.width<=a.height&&a.right<this._width||o==a.height&&a.height<=a.width)break;i=a}}else if(a.x<i.x&&t<=a.width&&e<=a.height){if(n=s,t==a.width&&a.width<=a.height&&a.right<this._width||e==a.height&&a.height<=a.width)break;i=a}}return n},e.prototype.allocateSize=function(e,i,n){if(this._sortableSizeStack.length>0){var r=this._sortableSizeStack.pop();return r.width=e,r.height=i,r.id=n,r}return new t.SortableSize(e,i,n)},e.prototype.freeSize=function(t){this._sortableSizeStack.push(t)},e.prototype.allocateRectangle=function(e,i,n,r){if(this._rectangleStack.length>0){var o=this._rectangleStack.pop();return o.x=e,o.y=i,o.width=n,o.height=r,o.right=e+n,o.bottom=i+r,o}return new t.IntegerRectangle(e,i,n,r)},e.prototype.freeRectangle=function(t){this._rectangleStack.push(t)},e}();t.RectanglePacker=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.width=t,this.height=e,this.id=i}}();t.SortableSize=e}(es||(es={})),function(t){var e=function(){return function(t){this.assets=t}}();t.TextureAssets=e;var i=function(){return function(){}}();t.TextureAsset=i}(es||(es={})),function(t){var e=function(){return function(t,e){this.texture=t,this.id=e}}();t.TextureToPack=e}(es||(es={}));
\ No newline at end of file
+window.es={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var i in e)e.hasOwnProperty(i)&&(t[i]=e[i])};return function(e,i){function n(){this.constructor=e}t(e,i),e.prototype=null===i?Object.create(i):(n.prototype=i.prototype,new n)}}();var transform,__awaiter=this&&this.__awaiter||function(t,e,i,n){return new(i||(i=Promise))(function(r,o){function s(t){try{h(n.next(t))}catch(t){o(t)}}function a(t){try{h(n.throw(t))}catch(t){o(t)}}function h(t){t.done?r(t.value):new i(function(e){e(t.value)}).then(s,a)}h((n=n.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var i,n,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(i)throw new TypeError("Generator is already executing.");for(;s;)try{if(i=1,n&&(r=2&o[0]?n.return:o[0]?n.throw||((r=n.return)&&r.call(n),0):n.next)&&!(r=r.call(n,o[1])).done)return r;switch(n=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,n=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],n=0}finally{i=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++)if(e.call(arguments[2],t[i],i,t))return i;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var i=t.findIndex(e);return-1==i?null:t[i]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return e.call(arguments[2],n,r,t)&&i.push(n),i},[]);for(var i=[],n=0,r=t.length;n<r;n++){var o=t[n];e.call(arguments[2],o,n,t)&&i.push(o)}return i}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var i=0,n=t.length;i<n;i++){if(t[i]instanceof egret.HashObject&&e instanceof egret.HashObject&&t[i].hashCode==e.hashCode)return!0;if(t[i]==e)return!0}return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var i;do{(i=t.findIndex(e))>=0&&t.splice(i,1)}while(i>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var i=t.findIndex(function(t){return t===e});return i>=0&&(t.splice(i,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,i){t.splice(e,i)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(i,n,r){return i.push(e.call(arguments[2],n,r,t)),i},[]);for(var i=[],n=0,r=t.length;n<r;n++)i.push(e.call(arguments[2],t[n],n,t));return i}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?i(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,i){return t.sort(function(t,n){var r=e(t),o=e(n);return i?-i(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var i=[];return t.reduce(function(n,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=i.findIndex(function(t){return t===s});return a<0&&(a=i.push(s)-1),n[a]||(n[a]=[]),n[a].push(r),n},[])}for(var n=[],r=[],o=function(i,o){var a=JSON.stringify(e.call(s[1],t[i],i,t)),h=r.findIndex(function(t){return t===a});h<0&&(h=r.push(a)-1),n[h]||(n[h]=[]),n[h].push(t[i])},s=arguments,a=0,h=t.length;a<h;a++)o(a);return n}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var i,n=0,r=t.length;n<r;n++)0==n?i=e?e.call(arguments[2],t[n],n,t):t[n]:i+=e?e.call(arguments[2],t[n],n,t):t[n];return i}(this,t)},function(t){var e=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}();t.PriorityQueueNode=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new i(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";e.getNeighbors(t.data).forEach(function(n){var s=h.get(t.data)+e.cost(t.data,n);if(!o.hasKey(h,n)||s<h.get(n)){h.set(n,s);var u=s+e.heuristic(n,r);c.enqueue(new i(n),u),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},e.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},e}();t.AStarPathfinder=e;var i=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.AStarNode=i}(es||(es={})),function(t){var e=function(){function e(e,i){this.dirs=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=i}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.AStarPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this.dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},e}();t.AstarGridGraph=e}(es||(es={})),function(t){var e=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var i=e+1;if(i<this._nodes.length&&this._nodes[i]&&this.hasHigherPriority(this._nodes[i],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),i=this._nodes[e];e>0&&this.hasHigherPriority(t,i)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,i=t.queueIndex;;){e=t;var n=2*i;if(n>this._numNodes){t.queueIndex=i,this._nodes[i]=t;break}var r=this._nodes[n];this.hasHigherPriority(r,e)&&(e=r);var o=n+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=i,this._nodes[i]=t;break}this._nodes[i]=e;var a=e.queueIndex;e.queueIndex=i,i=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var i=this._nodes[e];if(this.hasHigherPriority(i,t))break;this.swap(t,i),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var i=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=i},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}();t.PriorityQueue=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,i,n){var r=this,o=!1,s=[];s.unshift(i);var a=new Map;a.set(i,i);for(var h=function(){var t=s.shift();if(JSON.stringify(t)==JSON.stringify(n))return o=!0,"break";e.getNeighbors(t).forEach(function(e){r.hasKey(a,e)||(s.unshift(e),a.set(e,t))})};s.length>0;){if("break"===h())break}return o?t.AStarPathfinder.recontructPath(a,i,n):null},e.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},e}();t.BreadthFirstPathfinder=e}(es||(es={})),function(t){var e=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}();t.UnweightedGraph=e}(es||(es={})),function(t){var e=function(){function e(t,e){this.x=0,this.y=0,this.x=t||0,this.y=null!=e?e:this.x}return Object.defineProperty(e,"zero",{get:function(){return e.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"one",{get:function(){return e.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitX",{get:function(){return e.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitY",{get:function(){return e.unitYVector},enumerable:!0,configurable:!0}),e.add=function(t,i){var n=new e(0,0);return n.x=t.x+i.x,n.y=t.y+i.y,n},e.divide=function(t,i){var n=new e(0,0);return n.x=t.x/i.x,n.y=t.y/i.y,n},e.multiply=function(t,i){var n=new e(0,0);return n.x=t.x*i.x,n.y=t.y*i.y,n},e.subtract=function(t,i){var n=new e(0,0);return n.x=t.x-i.x,n.y=t.y-i.y,n},e.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},e.dot=function(t,e){return t.x*e.x+t.y*e.y},e.distanceSquared=function(t,e){var i=t.x-e.x,n=t.y-e.y;return i*i+n*n},e.clamp=function(i,n,r){return new e(t.MathHelper.clamp(i.x,n.x,r.x),t.MathHelper.clamp(i.y,n.y,r.y))},e.lerp=function(i,n,r){return new e(t.MathHelper.lerp(i.x,n.x,r),t.MathHelper.lerp(i.y,n.y,r))},e.transform=function(t,i){return new e(t.x*i.m11+t.y*i.m21+i.m31,t.x*i.m12+t.y*i.m22+i.m32)},e.distance=function(t,e){var i=t.x-e.x,n=t.y-e.y;return Math.sqrt(i*i+n*n)},e.angle=function(i,n){return i=e.normalize(i),n=e.normalize(n),Math.acos(t.MathHelper.clamp(e.dot(i,n),-1,1))*t.MathHelper.Rad2Deg},e.negate=function(t){var i=new e;return i.x=-t.x,i.y=-t.y,i},e.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this},e.prototype.divide=function(t){return this.x/=t.x,this.y/=t.y,this},e.prototype.multiply=function(t){return this.x*=t.x,this.y*=t.y,this},e.prototype.subtract=function(t){return this.x-=t.x,this.y-=t.y,this},e.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);return this.x*=t,this.y*=t,this},e.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},e.prototype.lengthSquared=function(){return this.x*this.x+this.y*this.y},e.prototype.round=function(){return new e(Math.round(this.x),Math.round(this.y))},e.prototype.equals=function(t){return t.x==this.x&&t.y==this.y},e.unitYVector=new e(0,1),e.unitXVector=new e(1,0),e.unitVector2=new e(1,1),e.zeroVector2=new e(0,0),e}();t.Vector2=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this._neighbors=new Array(4),this._width=t,this._hegiht=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.search=function(e,i){return t.BreadthFirstPathfinder.search(this,e,i)},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,-1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.UnweightedGridGraph=e}(es||(es={})),function(t){var e=function(){function e(t,i,n){void 0===n&&(n=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=i,this._dirs=n?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,i){return t.WeightedPathfinder.search(this,e,i)},e.prototype.getNeighbors=function(e){var i=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var r=new t.Vector2(e.x+n.x,e.y+n.y);i.isNodeInBounds(r)&&i.isNodePassable(r)&&i._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.WeightedGridGraph=e}(es||(es={})),function(t){var e=function(t){function e(e){var i=t.call(this)||this;return i.data=e,i}return __extends(e,t),e}(t.PriorityQueueNode);t.WeightedNode=e;var i=function(){function i(){}return i.search=function(i,n,r){var o=this,s=!1,a=new Map;a.set(n,n);var h=new Map,c=new t.PriorityQueue(1e3);c.enqueue(new e(n),0),h.set(n,0);for(var u=function(){var t=c.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";i.getNeighbors(t.data).forEach(function(n){var r=h.get(t.data)+i.cost(t.data,n);if(!o.hasKey(h,n)||r<h.get(n)){h.set(n,r);var s=r;c.enqueue(new e(n),s),a.set(n,t.data)}})};c.count>0;){if("break"===u())break}return s?this.recontructPath(a,n,r):null},i.recontructPath=function(t,e,i){var n=[],r=i;for(n.push(i);r!=e;)r=this.getKey(t,r),n.push(r);return n.reverse(),n},i.hasKey=function(t,e){for(var i,n=t.keys();!(i=n.next()).done;)if(JSON.stringify(i.value)==JSON.stringify(e))return!0;return!1},i.getKey=function(t,e){for(var i,n,r=t.keys(),o=t.values();i=r.next(),n=o.next(),!i.done;)if(JSON.stringify(i.value)==JSON.stringify(e))return n.value;return null},i}();t.WeightedPathfinder=i}(es||(es={})),function(t){var e=function(){function e(){}return e.drawHollowRect=function(e,i,n){void 0===n&&(n=0),this._debugDrawItems.push(new t.DebugDrawItem(e,i,n))},e.render=function(){if(this._debugDrawItems.length>0){var e=new egret.Shape;t.Core.scene&&t.Core.scene.addChild(e);for(var i=this._debugDrawItems.length-1;i>=0;i--){this._debugDrawItems[i].draw(e)&&this._debugDrawItems.removeAt(i)}}},e._debugDrawItems=[],e}();t.Debug=e}(es||(es={})),function(t){var e=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();t.DebugDefaults=e}(es||(es={})),function(t){var e;!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(e=t.DebugDrawType||(t.DebugDrawType={}));var i=function(){function i(t,i,n){this.rectangle=t,this.color=i,this.duration=n,this.drawType=e.hollowRectangle}return i.prototype.draw=function(i){switch(this.drawType){case e.line:case e.hollowRectangle:case e.pixel:case e.text:}return this.duration-=t.Time.deltaTime,this.duration<0},i}();t.DebugDrawItem=i}(es||(es={})),function(t){var e=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.updateInterval=1,e._enabled=!0,e._updateOrder=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"transform",{get:function(){return this.entity.transform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onAddedToEntity=function(){},e.prototype.onRemovedFromEntity=function(){},e.prototype.onEntityTransformChanged=function(t){},e.prototype.debugRender=function(){},e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},e.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},e.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,t},e}(egret.HashObject);t.Component=e}(es||(es={})),function(t){var e=function(e){function i(){var n=e.call(this)||this;return n._globalManagers=[],i._instance=n,i.emitter=new t.Emitter,i.content=new t.ContentManager,n.addEventListener(egret.Event.ADDED_TO_STAGE,n.onAddToStage,n),n}return __extends(i,e),Object.defineProperty(i,"Instance",{get:function(){return this._instance},enumerable:!0,configurable:!0}),Object.defineProperty(i,"scene",{get:function(){return this._instance?this._instance._scene:null},set:function(t){t?null==this._instance._scene?(this._instance._scene=t,this._instance.addChild(t),this._instance._scene.begin(),i.Instance.onSceneChanged()):this._instance._nextScene=t:console.error("场景不能为空")},enumerable:!0,configurable:!0}),i.startSceneTransition=function(t){if(!this._instance._sceneTransition)return this._instance._sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},i.registerGlobalManager=function(t){this._instance._globalManagers.push(t),t.enabled=!0},i.unregisterGlobalManager=function(t){this._instance._globalManagers.remove(t),t.enabled=!1},i.getGlobalManager=function(t){for(var e=0;e<this._instance._globalManagers.length;e++)if(this._instance._globalManagers[e]instanceof t)return this._instance._globalManagers[e];return null},i.prototype.onOrientationChanged=function(){i.emitter.emit(t.CoreEvents.OrientationChanged)},i.prototype.draw=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this._sceneTransition?(this._sceneTransition.preRender(),!this._scene||this._sceneTransition.hasPreviousSceneRender?[3,2]:(this._scene.render(),this._scene.postRender(),[4,this._sceneTransition.onBeginTransition()])):[3,4];case 1:return e.sent(),[3,3];case 2:this._sceneTransition&&(this._scene&&this._sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this._sceneTransition.render()),e.label=3;case 3:return[3,5];case 4:this._scene&&(this._scene.render(),t.Debug.render(),this._scene.postRender()),e.label=5;case 5:return[2]}})})},i.prototype.startDebugUpdate=function(){t.TimeRuler.Instance.startFrame(),t.TimeRuler.Instance.beginMark("update",65280)},i.prototype.endDebugUpdate=function(){t.TimeRuler.Instance.endMark("update")},i.prototype.onSceneChanged=function(){i.emitter.emit(t.CoreEvents.SceneChanged),t.Time.sceneChanged()},i.prototype.onGraphicsDeviceReset=function(){i.emitter.emit(t.CoreEvents.GraphicsDeviceReset)},i.prototype.initialize=function(){},i.prototype.update=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:if(t.Time.update(egret.getTimer()),!this._scene)return[3,2];for(e=this._globalManagers.length-1;e>=0;e--)this._globalManagers[e].enabled&&this._globalManagers[e].update();return this._sceneTransition&&(!this._sceneTransition||this._sceneTransition.loadsNewScene&&!this._sceneTransition.isNewSceneLoaded)||this._scene.update(),this._nextScene?(this.removeChild(this._scene),this._scene.end(),this._scene=this._nextScene,this._nextScene=null,this.onSceneChanged(),this.addChild(this._scene),[4,this._scene.begin()]):[3,2];case 1:i.sent(),i.label=2;case 2:return[4,this.draw()];case 3:return i.sent(),[2]}})})},i.prototype.onAddToStage=function(){i.graphicsDevice=new t.GraphicsDevice,this.addEventListener(egret.Event.RESIZE,this.onGraphicsDeviceReset,this),this.addEventListener(egret.StageOrientationEvent.ORIENTATION_CHANGE,this.onOrientationChanged,this),this.addEventListener(egret.Event.ENTER_FRAME,this.update,this),t.Input.initialize(),this.initialize()},i.debugRenderEndabled=!1,i}(egret.DisplayObjectContainer);t.Core=e}(es||(es={})),function(t){!function(t){t[t.GraphicsDeviceReset=0]="GraphicsDeviceReset",t[t.SceneChanged=1]="SceneChanged",t[t.OrientationChanged=2]="OrientationChanged"}(t.CoreEvents||(t.CoreEvents={}))}(es||(es={})),function(t){var e=function(){function e(i){this.updateInterval=1,this._tag=0,this._enabled=!0,this._updateOrder=0,this.components=new t.ComponentList(this),this.transform=new t.Transform(this),this.name=i,this.id=e._idGenerator++,this.componentBits=new t.BitSet}return Object.defineProperty(e.prototype,"isDestroyed",{get:function(){return this._isDestroyed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parent",{get:function(){return this.transform.parent},set:function(t){this.transform.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"childCount",{get:function(){return this.transform.childCount},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this.transform.position},set:function(t){this.transform.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localPosition",{get:function(){return this.transform.localPosition},set:function(t){this.transform.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.transform.rotation},set:function(t){this.transform.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotationDegrees",{get:function(){return this.transform.rotationDegrees},set:function(t){this.transform.setRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotation",{get:function(){return this.transform.localRotation},set:function(t){this.transform.setLocalRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localRotationDegrees",{get:function(){return this.transform.localRotationDegrees},set:function(t){this.transform.setLocalRotationDegrees(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return this.transform.scale},set:function(t){this.transform.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localScale",{get:function(){return this.transform.localScale},set:function(t){this.transform.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldInverseTransform",{get:function(){return this.transform.worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localToWorldTransform",{get:function(){return this.transform.localToWorldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worldToLocalTransform",{get:function(){return this.transform.worldToLocalTransform},enumerable:!0,configurable:!0}),e.prototype.onTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.components.onEntityEnabled():this.components.onEntityDisabled()),this},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene&&(this.scene.entities.markEntityListUnsorted(),this.scene.entities.markTagUnsorted(this.tag)),this},e.prototype.destroy=function(){this._isDestroyed=!0,this.scene.entities.remove(this),this.transform.parent=null;for(var t=this.transform.childCount-1;t>=0;t--){this.transform.getChild(t).entity.destroy()}},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.transform.childCount;t++)this.transform.getChild(t).entity.detachFromScene()},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.transform.childCount;e++)this.transform.getChild(e).entity.attachToScene(t)},e.prototype.clone=function(i){void 0===i&&(i=new t.Vector2);var n=new e(this.name+"(clone)");return n.copyFrom(this),n.transform.position=i,n},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestroyed&&this.components.removeAllComponents()},e.prototype.update=function(){this.components.update()},e.prototype.debugRender=function(){this.components.debugRender()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),t.initialize(),t},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.compareTo=function(t){var e=this._updateOrder-t._updateOrder;return 0==e&&(e=this.id-t.id),e},e.prototype.toString=function(){return"[Entity: name: "+this.name+", tag: "+this.tag+", enabled: "+this.enabled+", depth: "+this.updateOrder+"]"},e.prototype.copyFrom=function(t){this.tag=t.tag,this.updateInterval=t.updateInterval,this.updateOrder=t.updateOrder,this.enabled=t.enabled,this.transform.scale=t.transform.scale,this.transform.rotation=t.transform.rotation;for(var e=0;e<t.components.count;e++)this.addComponent(t.components.buffer[e].clone());for(e=0;e<t.components._componentsToAdd.length;e++)this.addComponent(t.components._componentsToAdd[e].clone());for(e=0;e<t.transform.childCount;e++){var i=t.transform.getChild(e).entity,n=i.clone();n.transform.copyFrom(i.transform),n.transform.parent=this.transform}},e._idGenerator=0,e}();t.Entity=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.enablePostProcessing=!0,i._sceneComponents=[],i._renderers=[],i._postProcessors=[],i.entities=new t.EntityList(i),i.renderableComponents=new t.RenderableComponentList,i.content=new t.ContentManager,i.entityProcessors=new t.EntityProcessorList,i.initialize(),i}return __extends(i,e),i.createWithDefaultRenderer=function(){var e=new i;return e.addRenderer(new t.DefaultRenderer),e},i.prototype.initialize=function(){},i.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},i.prototype.unload=function(){},i.prototype.onActive=function(){},i.prototype.onDeactive=function(){},i.prototype.begin=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){return 0==this._renderers.length&&(this.addRenderer(new t.DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new t.Camera),t.Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.addEventListener(egret.Event.ACTIVATE,this.onActive,this),this.addEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart(),[2]})})},i.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren();for(t=0;t<this._sceneComponents.length;t++)this._sceneComponents[t].onRemovedFromScene();this._sceneComponents.length=0,this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.parent&&this.parent.removeChild(this),this.unload()},i.prototype.update=function(){this.entities.updateLists();for(var t=this._sceneComponents.length-1;t>=0;t--)this._sceneComponents[t].enabled&&this._sceneComponents[t].update();this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},i.prototype.render=function(){if(0!=this._renderers.length)for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this);else console.error("场景中没有渲染器!")},i.prototype.postRender=function(){if(this.enablePostProcessing)for(var e=0;e<this._postProcessors.length;e++)this._postProcessors[e].enabled&&this._postProcessors[e].process();if(this._screenshotRequestCallback){var i=new egret.RenderTexture;i.drawToTexture(this,new t.Rectangle(0,0,this.stage.stageWidth,this.stage.stageHeight)),this._screenshotRequestCallback(i),this._screenshotRequestCallback=null}},i.prototype.requestScreenshot=function(t){this._screenshotRequestCallback=t},i.prototype.addSceneComponent=function(t){return t.scene=this,t.onEnabled(),this._sceneComponents.push(t),this._sceneComponents.sort(t.compareTo),t},i.prototype.getSceneComponent=function(t){for(var e=0;e<this._sceneComponents.length;e++){var i=this._sceneComponents[e];if(i instanceof t)return i}return null},i.prototype.getOrCreateSceneComponent=function(t){var e=this.getSceneComponent(t);return null==e&&(e=this.addSceneComponent(new t)),e},i.prototype.removeSceneComponent=function(t){this._sceneComponents.contains(t)?(this._sceneComponents.remove(t),t.onRemovedFromScene()):console.warn("SceneComponent"+t+"不在SceneComponents列表中!")},i.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},i.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},i.prototype.removeRenderer=function(t){this._renderers.contains(t)&&(this._renderers.remove(t),t.unload())},i.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},i.prototype.getPostProcessor=function(t){for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e]instanceof t)return this._postProcessors[e];return null},i.prototype.removePostProcessor=function(t){this._postProcessors.contains(t)&&(this._postProcessors.remove(t),t.unload())},i.prototype.createEntity=function(e){var i=new t.Entity(e);return this.addEntity(i)},i.prototype.createEntityAsync=function(t){var e=this;return new Promise(function(i){i(e.createEntity(t))})},i.prototype.addEntity=function(t){this.entities.buffer.contains(t)&&console.warn("您试图将同一实体添加到场景两次: "+t),this.entities.add(t),t.scene=this;for(var e=0;e<t.transform.childCount;e++)this.addEntity(t.transform.getChild(e).entity);return t},i.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},i.prototype.findEntity=function(t){return this.entities.findEntity(t)},i.prototype.findEntitiesWithTag=function(t){return this.entities.entitiesWithTag(t)},i.prototype.entitiesOfType=function(t){return this.entities.entitiesOfType(t)},i.prototype.findComponentOfType=function(t){return this.entities.findComponentOfType(t)},i.prototype.findComponentsOfType=function(t){return this.entities.findComponentsOfType(t)},i.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},i.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},i.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},i}(egret.DisplayObjectContainer);t.Scene=e}(es||(es={})),function(t){!function(t){t[t.position=0]="position",t[t.scale=1]="scale",t[t.rotation=2]="rotation"}(t.Component||(t.Component={}))}(transform||(transform={})),function(t){var e,i=egret.HashObject;!function(t){t[t.clean=0]="clean",t[t.positionDirty=1]="positionDirty",t[t.scaleDirty=2]="scaleDirty",t[t.rotationDirty=3]="rotationDirty"}(e=t.DirtyType||(t.DirtyType={}));var n=function(i){function n(e){var n=i.call(this)||this;return n._localTransform=t.Matrix2D.create(),n._worldTransform=t.Matrix2D.create().identity(),n._rotationMatrix=t.Matrix2D.create(),n._translationMatrix=t.Matrix2D.create(),n._scaleMatrix=t.Matrix2D.create(),n._worldToLocalTransform=t.Matrix2D.create().identity(),n._worldInverseTransform=t.Matrix2D.create().identity(),n._position=t.Vector2.zero,n._scale=t.Vector2.one,n._rotation=0,n._localPosition=t.Vector2.zero,n._localScale=t.Vector2.one,n._localRotation=0,n.entity=e,n.scale=t.Vector2.one,n._children=[],n}return __extends(n,i),Object.defineProperty(n.prototype,"childCount",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._rotation)},set:function(e){this.setRotation(t.MathHelper.toRadians(e))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotationDegrees",{get:function(){return t.MathHelper.toDegrees(this._localRotation)},set:function(e){this.localRotation=t.MathHelper.toRadians(e)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localToWorldTransform",{get:function(){return this.updateTransform(),this._worldTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"parent",{get:function(){return this._parent},set:function(t){this.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldToLocalTransform",{get:function(){return this._worldToLocalDirty&&(this.parent?(this.parent.updateTransform(),this._worldToLocalTransform=this.parent._worldTransform.invert()):this._worldToLocalTransform=t.Matrix2D.create().identity(),this._worldToLocalDirty=!1),this._worldToLocalTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"worldInverseTransform",{get:function(){return this.updateTransform(),this._worldInverseDirty&&(this._worldInverseTransform=this._worldTransform.invert(),this._worldInverseDirty=!1),this._worldInverseTransform},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"position",{get:function(){return this.updateTransform(),this._positionDirty&&(this.parent?(this.parent.updateTransform(),this._position=t.Vector2Ext.transformR(this._localPosition,this.parent._worldTransform)):this._position=this._localPosition,this._positionDirty=!1),this._position},set:function(t){this.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"scale",{get:function(){return this.updateTransform(),this._scale},set:function(t){this.setScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotation",{get:function(){return this.updateTransform(),this._rotation},set:function(t){this.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localPosition",{get:function(){return this.updateTransform(),this._localPosition},set:function(t){this.setLocalPosition(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localScale",{get:function(){return this.updateTransform(),this._localScale},set:function(t){this.setLocalScale(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localRotation",{get:function(){return this.updateTransform(),this._localRotation},set:function(t){this.setLocalRotation(t)},enumerable:!0,configurable:!0}),n.prototype.getChild=function(t){return this._children[t]},n.prototype.setParent=function(t){return this._parent.equals(t)?this:(this._parent||(this._parent._children.remove(this),this._parent._children.push(this)),this._parent=t,this.setDirty(e.positionDirty),this)},n.prototype.setPosition=function(e,i){var n=new t.Vector2(e,i);return n.equals(this._position)?this:(this._position=n,this.parent?this.localPosition=t.Vector2Ext.transformR(this._position,this._worldToLocalTransform):this.localPosition=n,this._positionDirty=!1,this)},n.prototype.setLocalPosition=function(t){return t.equals(this._localPosition)?this:(this._localPosition=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.positionDirty),this)},n.prototype.setRotation=function(t){return this._rotation=t,this.parent?this.localRotation=this.parent.rotation+t:this.localRotation=t,this},n.prototype.setRotationDegrees=function(e){return this.setRotation(t.MathHelper.toRadians(e))},n.prototype.lookAt=function(e){var i=this.position.x>e.x?-1:1,n=t.Vector2.normalize(t.Vector2.subtract(this.position,e));this.rotation=i*Math.acos(t.Vector2.dot(n,t.Vector2.unitY))},n.prototype.setLocalRotation=function(t){return this._localRotation=t,this._localDirty=this._positionDirty=this._localPositionDirty=this._localRotationDirty=this._localScaleDirty=!0,this.setDirty(e.rotationDirty),this},n.prototype.setLocalRotationDegrees=function(e){return this.setLocalRotation(t.MathHelper.toRadians(e))},n.prototype.setScale=function(e){return this._scale=e,this.parent?this.localScale=t.Vector2.divide(e,this.parent._scale):this.localScale=e,this},n.prototype.setLocalScale=function(t){return this._localScale=t,this._localDirty=this._positionDirty=this._localScaleDirty=!0,this.setDirty(e.scaleDirty),this},n.prototype.roundPosition=function(){this.position=this._position.round()},n.prototype.updateTransform=function(){this.hierarchyDirty!=e.clean&&(this.parent&&this.parent.updateTransform(),this._localDirty&&(this._localPositionDirty&&(this._translationMatrix=t.Matrix2D.create().translate(this._localPosition.x,this._localPosition.y),this._localPositionDirty=!1),this._localRotationDirty&&(this._rotationMatrix=t.Matrix2D.create().rotate(this._localRotation),this._localRotationDirty=!1),this._localScaleDirty&&(this._scaleMatrix=t.Matrix2D.create().scale(this._localScale.x,this._localScale.y),this._localScaleDirty=!1),this._localTransform=this._scaleMatrix.multiply(this._rotationMatrix),this._localTransform=this._localTransform.multiply(this._translationMatrix),this.parent||(this._worldTransform=this._localTransform,this._rotation=this._localRotation,this._scale=this._localScale,this._worldInverseDirty=!0),this._localDirty=!1),this.parent&&(this._worldTransform=this._localTransform.multiply(this.parent._worldTransform),this._rotation=this._localRotation+this.parent._rotation,this._scale=t.Vector2.multiply(this.parent._scale,this._localScale),this._worldInverseDirty=!0),this._worldToLocalDirty=!0,this._positionDirty=!0,this.hierarchyDirty=e.clean)},n.prototype.setDirty=function(e){if(0==(this.hierarchyDirty&e)){switch(this.hierarchyDirty|=e,e){case t.DirtyType.positionDirty:this.entity.onTransformChanged(transform.Component.position);break;case t.DirtyType.rotationDirty:this.entity.onTransformChanged(transform.Component.rotation);break;case t.DirtyType.scaleDirty:this.entity.onTransformChanged(transform.Component.scale)}this._children||(this._children=[]);for(var i=0;i<this._children.length;i++)this._children[i].setDirty(e)}},n.prototype.copyFrom=function(t){this._position=t.position,this._localPosition=t._localPosition,this._rotation=t._rotation,this._localRotation=t._localRotation,this._scale=t._scale,this._localScale=t._localScale,this.setDirty(e.positionDirty),this.setDirty(e.rotationDirty),this.setDirty(e.scaleDirty)},n.prototype.toString=function(){return"[Transform: parent: "+this.parent+", position: "+this.position+", rotation: "+this.rotation+",\n                scale: "+this.scale+", localPosition: "+this._localPosition+", localRotation: "+this._localRotation+",\n                localScale: "+this._localScale+"]"},n.prototype.equals=function(t){return t.hashCode==this.hashCode},n}(i);t.Transform=n}(es||(es={})),function(t){var e;!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(e=t.CameraStyle||(t.CameraStyle={}));var i=function(){return function(){this.left=0,this.right=0,this.top=0,this.bottom=0}}();t.CameraInset=i;var n=function(n){function r(r,o){void 0===r&&(r=null),void 0===o&&(o=e.lockOn);var s=n.call(this)||this;return s._inset=new i,s._areMatrixedDirty=!0,s._areBoundsDirty=!0,s._isProjectionMatrixDirty=!0,s.followLerp=.1,s.deadzone=new t.Rectangle,s.focusOffset=t.Vector2.zero,s.mapLockEnabled=!1,s.mapSize=new t.Rectangle,s._desiredPositionDelta=new t.Vector2,s._worldSpaceDeadZone=new t.Rectangle,s._minimumZoom=.3,s._maximumZoom=3,s._bounds=new t.Rectangle,s._transformMatrix=(new t.Matrix2D).identity(),s._inverseTransformMatrix=(new t.Matrix2D).identity(),s._origin=t.Vector2.zero,s._targetEntity=r,s._cameraStyle=o,s.setZoom(0),s}return __extends(r,n),Object.defineProperty(r.prototype,"position",{get:function(){return this.entity.transform.position},set:function(t){this.entity.transform.position=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"rotation",{get:function(){return this.entity.transform.rotation},set:function(t){this.entity.transform.rotation=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?t.MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):t.MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"bounds",{get:function(){if(this._areMatrixedDirty&&this.updateMatrixes(),this._areBoundsDirty){var e=this.screenToWorldPoint(new t.Vector2(this._inset.left,this._inset.top)),i=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,t.Core.graphicsDevice.viewport.height-this._inset.bottom));if(0!=this.entity.transform.rotation){var n=this.screenToWorldPoint(new t.Vector2(t.Core.graphicsDevice.viewport.width-this._inset.right,this._inset.top)),r=this.screenToWorldPoint(new t.Vector2(this._inset.left,t.Core.graphicsDevice.viewport.height-this._inset.bottom)),o=Math.min(e.x,i.x,n.x,r.x),s=Math.max(e.x,i.x,n.x,r.x),a=Math.min(e.y,i.y,n.y,r.y),h=Math.max(e.y,i.y,n.y,r.y);this._bounds.location=new t.Vector2(o,a),this._bounds.width=s-o,this._bounds.height=h-a}else this._bounds.location=e,this._bounds.width=i.x-e.x,this._bounds.height=i.y-e.y;this._areBoundsDirty=!1}return this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"transformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._transformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"inverseTransformMatrix",{get:function(){return this._areMatrixedDirty&&this.updateMatrixes(),this._inverseTransformMatrix},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t,this._areMatrixedDirty=!0)},enumerable:!0,configurable:!0}),r.prototype.onSceneSizeChanged=function(e,i){var n=this._origin;this.origin=new t.Vector2(e/2,i/2),this.entity.transform.position=t.Vector2.add(this.entity.transform.position,t.Vector2.subtract(this._origin,n))},r.prototype.setInset=function(t,e,n,r){return this._inset=new i,this._inset.left=t,this._inset.right=e,this._inset.top=n,this._inset.bottom=r,this._areBoundsDirty=!0,this},r.prototype.setPosition=function(t){return this.entity.transform.setPosition(t.x,t.y),this},r.prototype.setRotation=function(t){return this.entity.transform.setRotation(t),this},r.prototype.setZoom=function(e){var i=t.MathHelper.clamp(e,-1,1);return this._zoom=0==i?1:i<0?t.MathHelper.map(i,-1,0,this._minimumZoom,1):t.MathHelper.map(i,0,1,1,this._maximumZoom),this._areMatrixedDirty=!0,this},r.prototype.setMinimumZoom=function(t){if(!(t<=0))return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this;console.error("minimumZoom must be greater than zero")},r.prototype.setMaximumZoom=function(t){if(!(t<=0))return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this;console.error("maximumZoom must be greater than zero")},r.prototype.onEntityTransformChanged=function(t){this._areMatrixedDirty=!0},r.prototype.zoomIn=function(t){this.zoom+=t},r.prototype.zoomOut=function(t){this.zoom-=t},r.prototype.worldToScreenPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._transformMatrix)},r.prototype.screenToWorldPoint=function(e){return this.updateMatrixes(),e=t.Vector2.transform(e,this._inverseTransformMatrix)},r.prototype.mouseToWorldPoint=function(){return this.screenToWorldPoint(t.Input.touchPosition)},r.prototype.onAddedToEntity=function(){this.follow(this._targetEntity,this._cameraStyle)},r.prototype.update=function(){var e=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*t.Core.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*t.Core.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this._targetEntity&&this.updateFollow(),this.position=t.Vector2.lerp(this.position,t.Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.transform.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.transform.roundPosition())},r.prototype.clampToMapSize=function(e){var i=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5)).add(new t.Vector2(this.mapSize.x,this.mapSize.y)),n=new t.Vector2(this.mapSize.width-i.x,this.mapSize.height-i.y);return t.Vector2.clamp(e,i,n)},r.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this._cameraStyle==e.lockOn){var i=this._targetEntity.transform.position.x,n=this._targetEntity.transform.position.y;this._worldSpaceDeadZone.x>i?this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<i&&(this._desiredPositionDelta.x=i-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<n?this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>n&&(this._desiredPositionDelta.y=n-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this._targetEntity.getComponent(t.Collider),!this._targetCollider))return;var r=this._targetEntity.getComponent(t.Collider).bounds;this._worldSpaceDeadZone.containsRect(r)||(this._worldSpaceDeadZone.left>r.left?this._desiredPositionDelta.x=r.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<r.right&&(this._desiredPositionDelta.x=r.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<r.bottom?this._desiredPositionDelta.y=r.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>r.top&&(this._desiredPositionDelta.y=r.top-this._worldSpaceDeadZone.top))}},r.prototype.follow=function(i,n){switch(void 0===n&&(n=e.cameraWindow),this._targetEntity=i,this._cameraStyle=n,this._cameraStyle){case e.cameraWindow:var r=this.bounds.width/6,o=this.bounds.height/3;this.deadzone=new t.Rectangle((this.bounds.width-r)/2,(this.bounds.height-o)/2,r,o);break;case e.lockOn:this.deadzone=new t.Rectangle(this.bounds.width/2,this.bounds.height/2,10,10)}},r.prototype.setCenteredDeadzone=function(e,i){this.deadzone=new t.Rectangle((this.bounds.width-e)/2,(this.bounds.height-i)/2,e,i)},r.prototype.updateMatrixes=function(){var e;this._areMatrixedDirty&&(this._transformMatrix=t.Matrix2D.create().translate(-this.entity.transform.position.x,-this.entity.transform.position.y),1!=this._zoom&&(e=t.Matrix2D.create().scale(this._zoom,this._zoom),this._transformMatrix=this._transformMatrix.multiply(e)),0!=this.entity.transform.rotation&&(e=t.Matrix2D.create().rotate(this.entity.transform.rotation),this._transformMatrix=this._transformMatrix.multiply(e)),e=t.Matrix2D.create().translate(this._origin.x,this._origin.y),this._transformMatrix=this._transformMatrix.multiply(e),this._inverseTransformMatrix=this._transformMatrix.invert(),this._areBoundsDirty=!0,this._areMatrixedDirty=!1)},r}(t.Component);t.Camera=n}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i._shakeDirection=t.Vector2.zero,i._shakeOffset=t.Vector2.zero,i._shakeIntensity=0,i._shakeDegredation=.95,i}return __extends(i,e),i.prototype.shake=function(e,i,n){void 0===e&&(e=15),void 0===i&&(i=.9),void 0===n&&(n=t.Vector2.zero),this.enabled=!0,this._shakeIntensity<e&&(this._shakeDirection=n,this._shakeIntensity=e,(i<0||i>=1)&&(i=.95),this._shakeDegredation=i)},i.prototype.update=function(){Math.abs(this._shakeIntensity)>0&&(this._shakeOffset=this._shakeDirection,0!=this._shakeOffset.x||0!=this._shakeOffset.y?this._shakeOffset.normalize():(this._shakeOffset.x=this._shakeOffset.x+Math.random()-.5,this._shakeOffset.y=this._shakeOffset.y+Math.random()-.5),this._shakeOffset.multiply(new t.Vector2(this._shakeIntensity)),this._shakeIntensity*=-this._shakeDegredation,Math.abs(this._shakeIntensity)<=.01&&(this._shakeIntensity=0,this.enabled=!1)),this.entity.scene.camera.position.add(this._shakeOffset)},i}(t.Component);t.CameraShake=e}(es||(es={})),function(t){var e=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}();t.ComponentPool=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return t.updateOrder-e.updateOrder},t}();t.IUpdatableComparer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Component);t.PooledComponent=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.displayObject=new egret.DisplayObject,i.color=0,i._areBoundsDirty=!0,i._localOffset=t.Vector2.zero,i._renderLayer=0,i._bounds=new t.Rectangle,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.bounds.width},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.bounds.height},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"renderLayer",{get:function(){return this._renderLayer},set:function(t){this.setRenderLayer(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return this._areBoundsDirty&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,t.Vector2.zero,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible!=t&&(this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible())},enumerable:!0,configurable:!0}),i.prototype.onEntityTransformChanged=function(t){this._areBoundsDirty=!0},i.prototype.isVisibleFromCamera=function(t){return!!t&&(this.isVisible=t.bounds.intersects(this.displayObject.getBounds().union(this.bounds)),this.isVisible)},i.prototype.setRenderLayer=function(t){if(t!=this._renderLayer){var e=this._renderLayer;this._renderLayer=t,this.entity&&this.entity.scene&&this.entity.scene.renderableComponents.updateRenderableRenderLayer(this,e,this._renderLayer)}return this},i.prototype.setColor=function(t){return this.color=t,this},i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this._localOffset=t),this},i.prototype.sync=function(e){var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y),this.displayObject.scaleX!=this.entity.scale.x&&(this.displayObject.scaleX=this.entity.scale.x),this.displayObject.scaleY!=this.entity.scale.y&&(this.displayObject.scaleY=this.entity.scale.y),this.displayObject.rotation!=this.entity.rotation&&(this.displayObject.rotation=this.entity.rotation)},i.prototype.toString=function(){return"[RenderableComponent] renderLayer: "+this.renderLayer},i.prototype.onBecameVisible=function(){this.displayObject.visible=this.isVisible},i.prototype.onBecameInvisible=function(){this.displayObject.visible=this.isVisible},i}(t.Component);t.RenderableComponent=e}(es||(es={})),function(t){var e=function(){function e(){this.updateOrder=0,this._enabled=!0}return Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.onRemovedFromScene=function(){},e.prototype.update=function(){},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled),this},e.prototype.setUpdateOrder=function(e){return this.updateOrder!=e&&(this.updateOrder=e,t.Core.scene._sceneComponents.sort(this.compareTo)),this},e.prototype.compareTo=function(t){return this.updateOrder-t.updateOrder},e}();t.SceneComponent=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(i){function n(e){void 0===e&&(e=null);var n=i.call(this)||this;return e instanceof t.Sprite?n.setSprite(e):e instanceof egret.Texture&&n.setSprite(new t.Sprite(e)),n}return __extends(n,i),Object.defineProperty(n.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this._sprite.sourceRect.width,this._sprite.sourceRect.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"originNormalized",{get:function(){return new t.Vector2(this._origin.x/this.width*this.entity.transform.scale.x,this._origin.y/this.height*this.entity.transform.scale.y)},set:function(e){this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"origin",{get:function(){return this._origin},set:function(t){this.setOrigin(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),n.prototype.setSprite=function(t){return this._sprite=t,this._sprite&&(this._origin=this._sprite.origin,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y),this.displayObject=new e(t.texture2D),this},n.prototype.setOrigin=function(t){return this._origin!=t&&(this._origin=t,this.displayObject.anchorOffsetX=this._origin.x,this.displayObject.anchorOffsetY=this._origin.y,this._areBoundsDirty=!0),this},n.prototype.setOriginNormalized=function(e){return this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y)),this},n.prototype.render=function(e){this.sync(e);var i=new t.Vector2(this.entity.position.x+this.localOffset.x-e.position.x+e.origin.x,this.entity.position.y+this.localOffset.y-e.position.y+e.origin.y);this.displayObject.x!=i.x&&(this.displayObject.x=i.x),this.displayObject.y!=i.y&&(this.displayObject.y=i.y)},n}(t.RenderableComponent);t.SpriteRenderer=i}(es||(es={})),function(t){var e=egret.Bitmap,i=egret.RenderTexture,n=function(n){function r(e){var i=n.call(this,e)||this;return i._textureScale=t.Vector2.one,i._inverseTexScale=t.Vector2.one,i._gapX=0,i._gapY=0,i._sourceRect=e.sourceRect,i.displayObject.$fillMode=egret.BitmapFillMode.REPEAT,i}return __extends(r,n),Object.defineProperty(r.prototype,"bounds",{get:function(){return this._areBoundsDirty&&this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollX",{get:function(){return this._sourceRect.x},set:function(t){this._sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"scrollY",{get:function(){return this._sourceRect.y},set:function(t){this._sourceRect.y=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y),this._sourceRect.width=this._sprite.sourceRect.width*this._inverseTexScale.x,this._sourceRect.height=this._sprite.sourceRect.height*this._inverseTexScale.y},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"width",{get:function(){return this._sourceRect.width},set:function(t){this._areBoundsDirty=!0,this._sourceRect.width=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"height",{get:function(){return this._sourceRect.height},set:function(t){this._areBoundsDirty=!0,this._sourceRect.height=t},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"gapXY",{get:function(){return new t.Vector2(this._gapX,this._gapY)},set:function(t){this._gapX=t.x,this._gapY=t.y;var n=new i,r=this.sprite.sourceRect;r.x=0,r.y=0,r.width+=this._gapX,r.height+=this._gapY,n.drawToTexture(this.displayObject,r),this.displayObject?this.displayObject.texture=n:this.displayObject=new e(n)},enumerable:!0,configurable:!0}),r.prototype.setGapXY=function(t){return this.gapXY=t,this},r.prototype.render=function(t){n.prototype.render.call(this,t);var e=this.displayObject;e.width=this.width,e.height=this.height,e.scrollRect=this._sourceRect},r}(t.SpriteRenderer);t.TiledSpriteRenderer=n}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.scrollSpeedX=15,i.scroolSpeedY=0,i._scrollX=0,i._scrollY=0,i._scrollWidth=0,i._scrollHeight=0,i._scrollWidth=i.width,i._scrollHeight=i.height,i}return __extends(i,e),Object.defineProperty(i.prototype,"textureScale",{get:function(){return this._textureScale},set:function(e){this._textureScale=e,this._inverseTexScale=new t.Vector2(1/this._textureScale.x,1/this._textureScale.y)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollWidth",{get:function(){return this._scrollWidth},set:function(t){this._scrollWidth=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"scrollHeight",{get:function(){return this._scrollHeight},set:function(t){this._scrollHeight=t},enumerable:!0,configurable:!0}),i.prototype.update=function(){this.sprite&&(this._scrollX+=this.scrollSpeedX*t.Time.deltaTime,this._scrollY+=this.scroolSpeedY*t.Time.deltaTime,this._sourceRect.x=this._scrollX,this._sourceRect.y=this._scrollY,this._sourceRect.width=this._scrollWidth+Math.abs(this._scrollX),this._sourceRect.height=this._scrollHeight+Math.abs(this._scrollY))},i}(t.TiledSpriteRenderer);t.ScrollingSpriteRenderer=e}(es||(es={})),function(t){var e=function(){return function(e,i,n){void 0===i&&(i=new t.Rectangle(0,0,e.textureWidth,e.textureHeight)),void 0===n&&(n=i.getHalfSize()),this.uvs=new t.Rectangle,this.texture2D=e,this.sourceRect=i,this.center=new t.Vector2(.5*i.width,.5*i.height),this.origin=n;var r=1/e.textureWidth,o=1/e.textureHeight;this.uvs.x=i.x*r,this.uvs.y=i.y*o,this.uvs.width=i.width*r,this.uvs.height=i.height*o}}();t.Sprite=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.sprites=t,this.frameRate=e}}();t.SpriteAnimation=e}(es||(es={})),function(t){var e,i;!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(e=t.LoopMode||(t.LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(i=t.State||(t.State={}));var n=function(n){function r(t){var e=n.call(this,t)||this;return e.speed=1,e.animationState=i.none,e._elapsedTime=0,e._animations=new Map,e}return __extends(r,n),Object.defineProperty(r.prototype,"isRunning",{get:function(){return this.animationState==i.running},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),r.prototype.update=function(){if(this.animationState==i.running&&this.currentAnimation){var n=this.currentAnimation,r=1/(n.frameRate*this.speed),o=r*n.sprites.length;this._elapsedTime+=t.Time.deltaTime;var s=Math.abs(this._elapsedTime);if(this._loopMode==e.once&&s>o||this._loopMode==e.pingPongOnce&&s>2*o)return this.animationState=i.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=n.sprites[this.currentFrame]);var a=Math.floor(s/r),h=n.sprites.length;if(h>2&&(this._loopMode==e.pingPong||this._loopMode==e.pingPongOnce)){var c=h-1;this.currentFrame=c-Math.abs(c-a%(2*c))}else this.currentFrame=a%h;this.sprite=n.sprites[this.currentFrame]}},r.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},r.prototype.play=function(t,n){void 0===n&&(n=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=i.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=n||e.loop},r.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},r.prototype.pause=function(){this.animationState=i.paused},r.prototype.unPause=function(){this.animationState=i.running},r.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=i.none},r}(t.SpriteRenderer);t.SpriteAnimator=n}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"hasCollision",{get:function(){return this.below||this.right||this.left||this.above},enumerable:!0,configurable:!0}),t.prototype.reset=function(){this.becameGroundedThisFrame=this.isGroundedOnOnewayPlatform=this.right=this.left=this.above=this.below=!1,this.slopAngle=0},t.prototype.toString=function(){return"[CollisionState] r: "+this.right+", l: "+this.left+", a: "+this.above+", b: "+this.below+", angle: "+this.slopAngle+", wasGroundedLastFrame: "+this.wasGroundedLastFrame+", becameGroundedThisFrame: "+this.becameGroundedThisFrame},t}();t.CollisionState=e;var i=function(e){function i(){var t=e.call(this)||this;return t.colliderHorizontalInset=2,t.colliderVerticalInset=6,t}return __extends(i,e),i.prototype.testCollisions=function(e,i,n){this._boxColliderBounds=i,n.wasGroundedLastFrame=n.below,n.reset();var r=e.x;e.y;if(0!=r){var o=r>0?t.Edge.right:t.Edge.left,s=this.collisionRectForSide(o,r);this.testMapCollision(s,o,n,0)?(e.x=0-t.RectangleExt.getSide(i,o),n.left=o==t.Edge.left,n.right=o==t.Edge.right,n._movementRemainderX.reset()):(n.left=!1,n.right=!1)}},i.prototype.testMapCollision=function(e,i,n,r){var o=t.EdgeExt.oppositeEdge(i);t.EdgeExt.isVertical(o)?e.center.x:e.center.y,t.RectangleExt.getSide(e,i),t.EdgeExt.isVertical(o)},i.prototype.collisionRectForSide=function(e,i){var n;return n=t.EdgeExt.isHorizontal(e)?t.RectangleExt.getRectEdgePortion(this._boxColliderBounds,e):t.RectangleExt.getHalfRect(this._boxColliderBounds,e),t.EdgeExt.isVertical(e)?t.RectangleExt.contract(n,this.colliderHorizontalInset,0):t.RectangleExt.contract(n,0,this.colliderVerticalInset),t.RectangleExt.expandSide(n,e,i),n},i}(t.Component);t.TiledMapMover=i}(es||(es={})),function(t){var e=function(e){function i(t,i,n){void 0===i&&(i=null),void 0===n&&(n=!0);var r=e.call(this)||this;return r.physicsLayer=1,r.toContainer=!1,r.tiledMap=t,r._shouldCreateColliders=n,r.displayObject=new egret.DisplayObjectContainer,i&&(r.collisionLayer=t.tileLayers[i]),r}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.tiledMap.width*this.tiledMap.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.tiledMap.height*this.tiledMap.tileHeight},enumerable:!0,configurable:!0}),i.prototype.setLayerToRender=function(t){this.layerIndicesToRender=[],this.layerIndicesToRender[0]=this.getLayerIndex(t)},i.prototype.setLayersToRender=function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];this.layerIndicesToRender=[];for(var i=0;i<t.length;i++)this.layerIndicesToRender[i]=this.getLayerIndex(t[i])},i.prototype.getLayerIndex=function(t){var e=this.tiledMap.getLayer(t);for(var i in this.tiledMap.layers)if(this.tiledMap.layers.hasOwnProperty(i)&&this.tiledMap.layers[i]==e)return 0;return-1},i.prototype.getRowAtWorldPosition=function(t){return t-=this.entity.transform.position.y+this._localOffset.y,this.tiledMap.worldToTilePositionY(t)},i.prototype.getColumnAtWorldPosition=function(t){return t-=this.entity.transform.position.x+this._localOffset.x,this.tiledMap.worldToTilePositionX(t)},i.prototype.onEntityTransformChanged=function(t){this._shouldCreateColliders&&t==transform.Component.position&&(this.removeColliders(),this.addColliders())},i.prototype.onAddedToEntity=function(){this.addColliders()},i.prototype.onRemovedFromEntity=function(){this.removeColliders()},i.prototype.update=function(){this.tiledMap.update()},i.prototype.render=function(e){if(this.sync(e),this.layerIndicesToRender)for(var i=0;i<this.tiledMap.layers.length;i++)this.tiledMap.layers[i].visible&&this.layerIndicesToRender.contains(i)&&t.TiledRendering.renderLayerRenderCamera(this.tiledMap.layers[i],this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer,e.bounds);else t.TiledRendering.renderMap(this.tiledMap,this.toContainer?null:this.displayObject,t.Vector2.add(this.entity.transform.position,this._localOffset),this.transform.scale,this.renderLayer);this.toContainer||(this.displayObject.cacheAsBitmap=!0,this.toContainer=!0)},i.prototype.addColliders=function(){if(this.collisionLayer&&this._shouldCreateColliders){var e=this.collisionLayer.getCollisionRectangles();this._colliders=[];for(var i=0;i<e.length;i++){var n=(new t.BoxCollider).createBoxRect(e[i].x+this._localOffset.x,e[i].y+this._localOffset.y,e[i].width,e[i].height);n.physicsLayer=this.physicsLayer,n.entity=this.entity,this._colliders[i]=n,t.Physics.addCollider(n)}}},i.prototype.removeColliders=function(){if(null!=this._colliders){for(var e=0,i=this._colliders;e<i.length;e++){var n=i[e];t.Physics.removeCollider(n)}this._colliders=null}},i}(t.RenderableComponent);t.TiledMapRenderer=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._triggerHelper=new t.ColliderTriggerHelper(this.entity)},i.prototype.calculateMovement=function(e,i){if(!this.entity.getComponent(t.Collider)||!this._triggerHelper)return!1;for(var n=this.entity.getComponents(t.Collider),r=0;r<n.length;r++){var o=n[r];if(!o.isTrigger){var s=o.bounds;s.x+=e.x,s.y+=e.y;for(var a=t.Physics.boxcastBroadphaseExcludingSelf(o,s,o.collidesWithLayers),h=0;h<a.length;h++){var c=a[h];if(!c.isTrigger){var u=new t.CollisionResult;o.collidesWith(c,e,u)&&(e=e.subtract(u.minimumTranslationVector),null!=u.collider&&(i=u))}}}}return t.ListPool.free(n),null!=i.collider},i.prototype.applyMovement=function(e){this.entity.position=t.Vector2.add(this.entity.position,e),this._triggerHelper&&this._triggerHelper.update()},i.prototype.move=function(t,e){return this.calculateMovement(t,e),this.applyMovement(t),null!=e.collider},i}(t.Component);t.Mover=e}(es||(es={})),function(t){var e=function(e){function i(){var t=null!==e&&e.apply(this,arguments)||this;return t._tempTriggerList=[],t}return __extends(i,e),i.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(t.Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},i.prototype.move=function(e){if(!this._collider)return!1;var i=!1;this.entity.position=t.Vector2.add(this.entity.position,e);for(var n=t.Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),r=0;r<n.length;r++){var o=n[r];this._collider.overlaps(o)&&o.enabled&&(i=!0,this.notifyTriggerListeners(this._collider,o))}return i},i.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(i=0;i<this._tempTriggerList.length;i++)this._tempTriggerList[i].onTriggerEnter(e,t);this._tempTriggerList.length=0},i}(t.Component);t.ProjectileMover=e}(es||(es={})),function(t){var e=function(e){function i(){var i=null!==e&&e.apply(this,arguments)||this;return i.physicsLayer=1,i.collidesWithLayers=t.Physics.allLayers,i.shouldColliderScaleAndRotateWithTransform=!0,i.registeredPhysicsBounds=new t.Rectangle,i._isPositionDirty=!0,i._isRotationDirty=!0,i._localOffset=t.Vector2.zero,i}return __extends(i,e),Object.defineProperty(i.prototype,"absolutePosition",{get:function(){return t.Vector2.add(this.entity.transform.position,this._localOffset)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"rotation",{get:function(){return this.shouldColliderScaleAndRotateWithTransform&&this.entity?this.entity.transform.rotation:0},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return(this._isPositionDirty||this._isRotationDirty)&&(this.shape.recalculateBounds(this),this._isPositionDirty=this._isRotationDirty=!1),this.shape.bounds},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),i.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this.unregisterColliderWithPhysicsSystem(),this._localOffset=t,this._localOffsetLength=this._localOffset.length(),this._isPositionDirty=!0,this.registerColliderWithPhysicsSystem()),this},i.prototype.setShouldColliderScaleAndRotateWithTransform=function(t){return this.shouldColliderScaleAndRotateWithTransform=t,this._isPositionDirty=this._isRotationDirty=!0,this},i.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){if(!(this instanceof t.BoxCollider||this instanceof t.CircleCollider))return void console.error("Only box and circle colliders can be created automatically");var e=this.entity.getComponent(t.RenderableComponent);if(e){var i=e.bounds,n=i.width/this.entity.scale.x,r=i.height/this.entity.scale.y;this instanceof t.CircleCollider?this.radius=.5*Math.max(n,r):(this.width=n,this.height=r),this.localOffset=t.Vector2.subtract(i.center,this.entity.transform.position)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},i.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1},i.prototype.onEntityTransformChanged=function(e){switch(e){case transform.Component.position:case transform.Component.scale:this._isPositionDirty=!0;break;case transform.Component.rotation:this._isRotationDirty=!0}this._isColliderRegistered&&t.Physics.updateCollider(this)},i.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem(),this._isPositionDirty=this._isRotationDirty=!0},i.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},i.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(t.Physics.addCollider(this),this._isColliderRegistered=!0)},i.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&t.Physics.removeCollider(this),this._isColliderRegistered=!1},i.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},i.prototype.collidesWith=function(t,e,i){var n=this.entity.position;this.entity.position=this.entity.position.add(e);var r=this.shape.collidesWithShape(t.shape,i);return r&&(i.collider=t),this.entity.position=n,r},i.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,this.shape&&(t.shape=this.shape.clone()),t},i}(t.Component);t.Collider=e}(es||(es={})),function(t){var e=function(e){function i(){var i=e.call(this)||this;return i.shape=new t.Box(1,1),i._colliderRequiresAutoSizing=!0,i}return __extends(i,e),Object.defineProperty(i.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),i.prototype.createBoxRect=function(e,i,n,r){return this._localOffset=new t.Vector2(e+n/2,i+n/2),this.shape=new t.Box(n,r),this._colliderRequiresAutoSizing=!1,this},i.prototype.setSize=function(e,i){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e==n.width&&i==n.height||(n.updateBox(e,i),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setWidth=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.width&&(i.updateBox(e,i.height),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.setHeight=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;e!=i.height&&(i.updateBox(i.width,e),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this))},i.prototype.toString=function(){return"[BoxCollider: bounds: "+this.bounds+"]"},i}(t.Collider);t.BoxCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;return i&&(n._colliderRequiresAutoSizing=!0),n.shape=new t.Circle(i||1),n}return __extends(i,e),Object.defineProperty(i.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),i.prototype.setRadius=function(e){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e!=i.radius&&(i.radius=e,i._originalRadius=e,this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},i.prototype.toString=function(){return"[CircleCollider: bounds: "+this.bounds+", radius: "+this.shape.radius+"]"},i}(t.Collider);t.CircleCollider=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this)||this;i[0]==i[i.length-1]&&i.splice(i.length-1,1);var r=t.Polygon.findPolygonCenter(i);return n.setLocalOffset(r),t.Polygon.recenterPolygonVerts(i),n.shape=new t.Polygon(i),n}return __extends(i,e),i}(t.Collider);t.PolygonCollider=e}(es||(es={})),function(t){var e=function(){function e(e){this._entities=[],this._matcher=e||t.Matcher.empty()}return Object.defineProperty(e.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onChanged=function(t){var e=this._entities.contains(t),i=this._matcher.IsIntersted(t);i&&!e?this.add(t):!i&&e&&this.remove(t)},e.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},e.prototype.onAdded=function(t){},e.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},e.prototype.onRemoved=function(t){},e.prototype.update=function(){this.begin(),this.process(this._entities)},e.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},e.prototype.begin=function(){},e.prototype.process=function(t){},e.prototype.lateProcess=function(t){},e.prototype.end=function(){},e}();t.EntitySystem=e}(es||(es={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(t.EntitySystem);t.EntityProcessingSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(t.EntitySystem);t.PassiveSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(t.EntitySystem);t.ProcessingSystem=e}(es||(es={})),function(t){var e=function(){function t(e){void 0===e&&(e=64);var i=e>>6;0!=(e&t.LONG_MASK)&&i++,this._bits=new Array(i)}return t.prototype.and=function(t){for(var e,i=Math.min(this._bits.length,t._bits.length),n=0;n<i;++n)this._bits[n]&=t._bits[n];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var i=this._bits[e];if(0!=i)if(-1!=i){var n=((i=((i=(i>>1&0x5555555555555400)+(0x5555555555555400&i))>>2&0x3333333333333400)+(0x3333333333333400&i))>>32)+i;t+=((n=((n=(n>>4&252645135)+(252645135&n))>>8&16711935)+(16711935&n))>>16&65535)+(65535&n)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var i=0;i<this._bits.length;i++)this._bits[i]=0},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,i=1<<t;e<this._bits.length;){var n=this._bits[e];do{if(0!=(n&i))return t;i<<=1,t++}while(0!=i);i=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var i=t>>6;this.ensure(i),this._bits[i]|=1<<t}else this.clear(t)},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.LONG_MASK=63,t}();t.BitSet=e}(es||(es={})),function(t){var e=function(){function e(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isComponentListUnsorted=!0},e.prototype.add=function(t){this._componentsToAdd.push(t)},e.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},e.prototype.deregisterAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.removeChild(i.displayObject),this._entity.scene.renderableComponents.remove(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},e.prototype.registerAllComponents=function(){for(var e=0;e<this._components.length;e++){var i=this._components[e];i instanceof t.RenderableComponent&&(this._entity.scene.addChild(i.displayObject),this._entity.scene.renderableComponents.add(i)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(i)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},e.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var i=0;i<this._componentsToRemove.length;i++)this.handleRemove(this._componentsToRemove[i]),this._components.remove(this._componentsToRemove[i]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){i=0;for(var n=this._componentsToAdd.length;i<n;i++){(r=this._componentsToAdd[i])instanceof t.RenderableComponent&&(this._entity.scene.addChild(r.displayObject),this._entity.scene.renderableComponents.add(r)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(r)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(r),this._tempBufferList.push(r)}this._componentsToAdd.length=0,this._isComponentListUnsorted=!0;for(i=0;i<this._tempBufferList.length;i++){var r;(r=this._tempBufferList[i]).onAddedToEntity(),r.enabled&&r.onEnabled()}this._tempBufferList.length=0}this._isComponentListUnsorted&&(this._components.sort(e.compareUpdatableOrder.compare),this._isComponentListUnsorted=!1)},e.prototype.handleRemove=function(e){e instanceof t.RenderableComponent&&(this._entity.scene.removeChild(e.displayObject),this._entity.scene.renderableComponents.remove(e)),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),e.onRemovedFromEntity(),e.entity=null},e.prototype.getComponent=function(t,e){for(var i=0;i<this._components.length;i++){if((n=this._components[i])instanceof t)return n}if(!e)for(i=0;i<this._componentsToAdd.length;i++){var n;if((n=this._componentsToAdd[i])instanceof t)return n}return null},e.prototype.getComponents=function(t,e){e||(e=[]);for(var i=0;i<this._components.length;i++){var n=this._components[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}for(i=0;i<this._componentsToAdd.length;i++){n=this._componentsToAdd[i];"string"==typeof t?egret.is(n,t)&&e.push(n):n instanceof t&&e.push(n)}return e},e.prototype.update=function(){this.updateLists();for(var e=0;e<this._components.length;e++){var i=this._components[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},e.prototype.onEntityEnabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onEnabled()},e.prototype.onEntityDisabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onDisabled()},e.prototype.debugRender=function(){for(var t=0;t<this._components.length;t++)this._components[t].enabled&&this._components[t].debugRender()},e.compareUpdatableOrder=new t.IUpdatableComparer,e}();t.ComponentList=e}(es||(es={})),function(t){var e=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}();t.ComponentTypeManager=e}(es||(es={})),function(t){var e=function(){function e(t){this._entities=[],this._entitiesToAdded=[],this._entitiesToRemove=[],this._entityDict=new Map,this._unsortedTags=[],this._tempEntityList=[],this.scene=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isEntityListUnsorted=!0},e.prototype.markTagUnsorted=function(t){this._unsortedTags.push(t)},e.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},e.prototype.remove=function(t){this._entitiesToRemove.contains(t)?this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t):console.warn("You are trying to remove an entity ("+t.name+") that you already removed")},e.prototype.removeAllEntities=function(){this._unsortedTags.length=0,this._entitiesToAdded.length=0,this._isEntityListUnsorted=!1,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestroyed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},e.prototype.contains=function(t){return this._entities.contains(t)||this._entitiesToAdded.contains(t)},e.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},e.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},e.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},e.prototype.update=function(){for(var e=0;e<this._entities.length;e++){var i=this._entities[e];!i.enabled||1!=i.updateInterval&&t.Time.frameCount%i.updateInterval!=0||i.update()}},e.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t.removeFromTagList(e),t._entities.remove(e),e.onRemovedFromScene(),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.addToTagList(e),t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0,this._isEntityListUnsorted=!0}this._isEntityListUnsorted&&(this._entities.sort(),this._isEntityListUnsorted=!1),this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},e.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},e.prototype.entitiesWithTag=function(e){for(var i=this.getTagList(e),n=t.ListPool.obtain(),r=0;r<i.length;r++)n.push(i[r]);return n},e.prototype.entitiesOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n]instanceof e&&i.push(this._entities[n]);return this._entitiesToAdded.forEach(function(t){t instanceof e&&i.push(t)}),i},e.prototype.findComponentOfType=function(t){for(var e=0;e<this._entities.length;e++){if(this._entities[e].enabled)if(i=this._entities[e].getComponent(t))return i}for(e=0;e<this._entitiesToAdded.length;e++){var i,n=this._entitiesToAdded[e];if(n.enabled)if(i=n.getComponent(t))return i}return null},e.prototype.findComponentsOfType=function(e){for(var i=t.ListPool.obtain(),n=0;n<this._entities.length;n++)this._entities[n].enabled&&this._entities[n].getComponents(e,i);for(n=0;n<this._entitiesToAdded.length;n++){var r=this._entitiesToAdded[n];r.enabled&&r.getComponents(e,i)}return i},e}();t.EntityList=e}(es||(es={})),function(t){var e=function(){function e(){this._processors=[]}return e.prototype.add=function(t){this._processors.push(t)},e.prototype.remove=function(t){this._processors.remove(t)},e.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},e.prototype.begin=function(){},e.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},e.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},e.prototype.end=function(){},e.prototype.getProcessor=function(){for(var e=0;e<this._processors.length;e++){var i=this._processors[e];if(i instanceof t.EntitySystem)return i}return null},e.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},e.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},e}();t.EntityProcessorList=e}(es||(es={})),function(t){var e=function(){function e(){this.allSet=new t.BitSet,this.exclusionSet=new t.BitSet,this.oneSet=new t.BitSet}return e.empty=function(){return new e},e.prototype.getAllSet=function(){return this.allSet},e.prototype.getExclusionSet=function(){return this.exclusionSet},e.prototype.getOneSet=function(){return this.oneSet},e.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},e.prototype.all=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.allSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.exclude=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.exclusionSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e.prototype.one=function(){for(var e=this,i=[],n=0;n<arguments.length;n++)i[n]=arguments[n];return i.forEach(function(i){e.oneSet.set(t.ComponentTypeManager.getIndexFor(i))}),this},e}();t.Matcher=e}(es||(es={}));var ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var i in t)"object"==typeof t[i]?(e[i]=t[i]instanceof Array?[]:{},this.clone(t[i],e[i])):e[i]=t[i];return e},t.elements=function(t){var e=[];for(var i in t)if(Array.isArray(t[i]))for(var n=0,r=t[i];n<r.length;n++){var o=r[n];e.push(o)}else e.push(t[i]);return e},t}();!function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return e.renderLayer-t.renderLayer},t}();t.RenderableComparer=e}(es||(es={})),function(t){var e=function(){function e(){this._components=[],this._componentsByRenderLayer=new Map,this._unsortedRenderLayers=[],this._componentsNeedSort=!0}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.add=function(t){this._components.push(t),this.addToRenderLayerList(t,t.renderLayer)},e.prototype.remove=function(t){this._components.remove(t),this._componentsByRenderLayer.get(t.renderLayer).remove(t)},e.prototype.updateRenderableRenderLayer=function(t,e,i){this._componentsByRenderLayer.has(e)&&this._componentsByRenderLayer.get(e).contains(t)&&(this._componentsByRenderLayer.get(e).remove(t),this.addToRenderLayerList(t,i))},e.prototype.setRenderLayerNeedsComponentSort=function(t){this._unsortedRenderLayers.contains(t)||this._unsortedRenderLayers.push(t),this._componentsNeedSort=!0},e.prototype.setNeedsComponentSort=function(){this._componentsNeedSort=!0},e.prototype.addToRenderLayerList=function(t,e){var i=this.componentsWithRenderLayer(e);i.contains(t)?console.warn("组件呈现层列表已经包含此组件"):(i.push(t),this._unsortedRenderLayers.contains(e)||this._unsortedRenderLayers.push(e),this._componentsNeedSort=!0)},e.prototype.componentsWithRenderLayer=function(t){return this._componentsByRenderLayer.get(t)||this._componentsByRenderLayer.set(t,[]),this._componentsByRenderLayer.get(t)},e.prototype.updateList=function(){if(this._componentsNeedSort&&(this._components.sort(e.compareUpdatableOrder.compare),this._componentsNeedSort=!1,this.updateEgretList()),this._unsortedRenderLayers.length>0){for(var t=0,i=this._unsortedRenderLayers.length;t<i;t++){var n=this._componentsByRenderLayer.get(this._unsortedRenderLayers[t]);n&&n.sort(e.compareUpdatableOrder.compare)}this._unsortedRenderLayers.length=0,this.updateEgretList()}},e.prototype.updateEgretList=function(){var e=t.Core._instance._scene;if(e)for(var i=function(t){var i=n._components[t],r=e.$children.find(function(t){return t.hashCode==i.displayObject.hashCode}),o=e.getChildIndex(r);o!=t&&e.swapChildrenAt(o,t)},n=this,r=0;r<this._components.length;r++)i(r)},e.compareUpdatableOrder=new t.RenderableComparer,e}();t.RenderableComponentList=e}(es||(es={}));var StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,i,n){void 0===n&&(n=!1);for(var r=t.length,o="",s=!1,a=1==n?e.toLowerCase():e,h=0;h<r;h++)s=!1,t.charAt(h)==a.charAt(0)&&t.substr(h,a.length)==a&&(s=!0),s?(o+=i,h=h+a.length-1):o+=t.charAt(h);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var i=this.specialSigns.length,n=0;n<i;n+=2){var r=void 0,o=void 0;if(r=this.specialSigns[n],o=this.specialSigns[n+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var i=t.length;if(i>=e)return t;var n=!1;"-"==t.substr(0,1)&&(n=!0,t=t.substr(1));for(var r=e-i,o=0;o<r;o++)t="0"+t;return n&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,i,n){void 0===n&&(n=!0),e=Math.floor(e),i=Math.floor(i);var r=t.length;e>r&&(e=r);var o,s=e,a=e+i;return n?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-i)+i,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var i=0,n=e.length;i<n;i++)null!=e[i]&&""!=e[i]||(e[i]="无"),t=t.replace("{"+i+"}",e[i]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}();!function(t){var e=function(){function e(){}return e.convertImageToCanvas=function(e,i){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var n=e.$getTextureWidth(),r=e.$getTextureHeight();i||((i=egret.$TempRectangle).x=0,i.y=0,i.width=n,i.height=r),i.x=Math.min(i.x,n-1),i.y=Math.min(i.y,r-1),i.width=Math.min(i.width,n-i.x),i.height=Math.min(i.height,r-i.y);var o=Math.floor(i.width),s=Math.floor(i.height),a=this.sharedCanvas;if(a.style.width=o+"px",a.style.height=s+"px",this.sharedCanvas.width=o,this.sharedCanvas.height=s,"webgl"==egret.Capabilities.renderMode){var h=void 0;e.$renderBuffer?h=e:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(h=new egret.RenderTexture).drawToTexture(new egret.Bitmap(e)));for(var c=h.$renderBuffer.getPixels(i.x,i.y,o,s),u=0,l=0,p=0;p<c.length;p+=4)this.sharedContext.fillStyle="rgba("+c[p]+","+c[p+1]+","+c[p+2]+","+c[p+3]/255+")",this.sharedContext.fillRect(u,l,1,1),++u==o&&(u=0,l++);return e.$renderBuffer||h.dispose(),a}var d=e,f=Math.round(d.$offsetX),g=Math.round(d.$offsetY),m=d.$bitmapWidth,y=d.$bitmapHeight,_=t.Core._instance.stage.textureScaleFactor;return this.sharedContext.drawImage(d.$bitmapData.source,d.$bitmapX+i.x/_,d.$bitmapY+i.y/_,m*i.width/n,y*i.height/r,f,g,i.width,i.height),a},e.toDataURL=function(t,e,i,n){try{return this.convertImageToCanvas(e,i).toDataURL(t,n)}catch(t){egret.$error(1033)}return null},e.eliFoTevas=function(t,e,i,n,r){var o=this.convertImageToCanvas(e,n).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+i,success:function(t){}}),o},e.getPixel32=function(t,e,i){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,i)},e.getPixels=function(t,e,i,n,r){if(void 0===n&&(n=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,i,n,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,i,n,r).data}catch(t){egret.$error(1039)}},e}();t.TextureUtils=e}(es||(es={})),function(t){var e=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}();t.Time=e}(es||(es={}));var TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),i=t.getMonth()+1;return parseInt(e+(i<10?"0":"")+i)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,i=e<10?"0":"",n=t.getDate(),r=n<10?"0":"";return parseInt(t.getFullYear()+i+e+r+n)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var i=new Date;i.setTime(t.getTime()),i.setDate(1),i.setMonth(0);var n=i.getFullYear(),r=i.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,i.setDate(i.getDate()-(r-1))):i.setDate(i.getDate()+7-r+1);var s=this.diffDay(t,i,!1);if(s<0)return i.setDate(1),i.setMonth(0),i.setDate(i.getDate()-1),this.weekId(i,!1);var a=s/7,h=Math.floor(a)+1;if(53==h){i.setTime(t.getTime()),i.setDate(i.getDate()-1);var c=i.getDay();if(0==c&&(c=7),e&&(!o||c<4))return i.setFullYear(i.getFullYear()+1),i.setDate(1),i.setMonth(0),this.weekId(i,!1)}return parseInt(n+"00"+(h>9?"":"0")+h)},t.diffDay=function(t,e,i){void 0===i&&(i=!1);var n=(t.getTime()-e.getTime())/864e5;return i?Math.ceil(n):Math.floor(n)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();return e+"-"+i+"-"+(n=n<10?"0"+n:n)},t.formatDateTime=function(t){var e=t.getFullYear(),i=t.getMonth()+1;i=i<10?"0"+i:i;var n=t.getDate();n=n<10?"0"+n:n;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+i+"-"+n+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,i){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===i&&(i=!0);var n=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=n.toString(),a=r.toString(),h=o.toString();return n<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(h="0"+h),i?s+e+a+e+h:a+e+h},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var i=t.split(e),n=0,r=i.length,o=0;o<r;o++){n+=i[o]*Math.pow(60,r-1-o)}return(n*=1e3).toString()},t}();!function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){if(e.runtimeType==egret.RuntimeType.WXGAME){this.isMobile=!0;var i=wx.getSystemInfoSync(),n=i.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var r=i.language;r=r.indexOf("zh")>-1?"zh-CN":"en-US",this.language=r}},e}(egret.Capabilities);t.GraphicsCapabilities=e}(es||(es={})),function(t){var e=function(){function e(){this.setup(),this.graphicsCapabilities=new t.GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}return Object.defineProperty(e.prototype,"viewport",{get:function(){return this._viewport},enumerable:!0,configurable:!0}),e.prototype.setup=function(){this._viewport=new t.Viewport(0,0,t.Core._instance.stage.stageWidth,t.Core._instance.stage.stageHeight)},e}();t.GraphicsDevice=e}(es||(es={})),function(t){var e=function(){function e(t,e,i,n){this._x=t,this._y=e,this._width=i,this._height=n,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(e.prototype,"width",{get:function(){return this._width},set:function(t){this._width=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"height",{get:function(){return this._height},set:function(t){this._height=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new t.Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),e}();t.Viewport=e}(es||(es={})),function(t){var e=function(e){function i(){return e.call(this,t.PostProcessor.default_vert,i.blur_frag,{screenWidth:t.Core.graphicsDevice.viewport.width,screenHeight:t.Core.graphicsDevice.viewport.height})||this}return __extends(i,e),i.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",i}(egret.CustomFilter);t.GaussianBlurEffect=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter);t.PolygonLightEffect=e}(es||(es={})),function(t){var e=function(){function e(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return e.prototype.onAddedToScene=function(e){this.scene=e,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.shape.graphics.endFill(),e.addChild(this.shape)},e.prototype.process=function(){this.drawFullscreenQuad()},e.prototype.onSceneBackBufferSizeChanged=function(t,e){},e.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},e.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},e.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",e}();t.PostProcessor=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),i.prototype.onAddedToScene=function(i){e.prototype.onAddedToScene.call(this,i),this.effect=new t.GaussianBlurEffect},i}(t.PostProcessor);t.GaussianBlurPostProcessor=e}(es||(es={})),function(t){var e=function(){function t(t,e){void 0===e&&(e=null),this.renderOrder=0,this.shouldDebugRender=!0,this.camera=e,this.renderOrder=t}return Object.defineProperty(t.prototype,"wantsToRenderToSceneRenderTarget",{get:function(){return!!this.renderTexture},enumerable:!0,configurable:!0}),t.prototype.onAddedToScene=function(t){},t.prototype.unload=function(){},t.prototype.onSceneBackBufferSizeChanged=function(t,e){},t.prototype.compareTo=function(t){return this.renderOrder-t.renderOrder},t.prototype.beginRender=function(t){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t.prototype.debugRender=function(t,e){for(var i=0;i<t.entities.count;i++){var n=t.entities.buffer[i];n.enabled&&n.debugRender()}},t}();t.Renderer=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,0,null)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var i=0;i<t.renderableComponents.count;i++){var n=t.renderableComponents.buffer[i];n.enabled&&n.isVisibleFromCamera(e)&&this.renderAfterStateCheck(n,e)}},e}(t.Renderer);t.DefaultRenderer=e}(es||(es={})),function(t){var e=function(e){function i(t){for(var i=[],n=1;n<arguments.length;n++)i[n-1]=arguments[n];var r=e.call(this,t,null)||this;return r.excludedRenderLayers=i,r}return __extends(i,e),i.prototype.render=function(e){var i=this.camera?this.camera:e.camera;this.beginRender(i);for(var n=0;n<e.renderableComponents.count;n++){var r=e.renderableComponents.buffer[n];!this.excludedRenderLayers.contains(r.renderLayer)&&r.enabled&&r.isVisibleFromCamera(i)&&this.renderAfterStateCheck(r,i)}this.shouldDebugRender&&t.Core.debugRenderEndabled&&this.debugRender(e,i)},i.prototype.debugRender=function(t,i){for(var n=0;n<t.renderableComponents.count;n++){var r=t.renderableComponents.buffer[n];!this.excludedRenderLayers.contains(r.renderLayer)&&r.enabled&&r.isVisibleFromCamera(i)&&r.debugRender()}e.prototype.debugRender.call(this,t,i)},i}(t.Renderer);t.RenderLayerExcludeRenderer=e}(es||(es={})),function(t){var e=function(e){function i(t){for(var i=[],n=1;n<arguments.length;n++)i[n-1]=arguments[n];var r=e.call(this,t,null)||this;return i.sort(),i.reverse(),r.renderLayers=i,r}return __extends(i,e),i.prototype.render=function(e){this.beginRender(this.camera);for(var i=0;i<this.renderLayers.length;i++)for(var n=e.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]),r=0;r<n.length;r++){var o=n[r];o.enabled&&o.isVisibleFromCamera(this.camera)&&this.renderAfterStateCheck(o,this.camera)}this.shouldDebugRender&&t.Core.debugRenderEndabled&&this.debugRender(e,this.camera)},i.prototype.debugRender=function(t,e){for(var i=0;i<this.renderLayers.length;i++)for(var n=t.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]),r=0;r<n.length;r++){var o=n[r];o.enabled&&o.debugRender()}},i.prototype.onSceneBackBufferSizeChanged=function(i,n){e.prototype.onSceneBackBufferSizeChanged.call(this,i,n),this.camera||(this.camera=t.Core.scene.createEntity("screenspace camera").addComponent(new t.Camera))},i}(t.Renderer);t.ScreenSpaceRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e,i,n){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=n,r.color=i,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e}(t.RenderableComponent);t.PolyLight=e}(es||(es={})),function(t){var e=function(){function e(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(e.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),e.prototype.preRender=function(){},e.prototype.render=function(){},e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},e.prototype.tickEffectProgressProperty=function(t,e,i,n){return void 0===n&&(n=!1),new Promise(function(r){var o=n?1:0,s=n?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,i).call(function(){r()})})},e.prototype.transitionComplete=function(){t.Core._instance._sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},e.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(i){switch(i.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),e=t.Core,[4,this.sceneLoadAction()];case 1:return e.scene=i.sent(),this.isNewSceneLoaded=!0,[2]}})})},e}();t.SceneTransition=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this,t)||this;return i.fadeToColor=0,i.fadeOutDuration=.4,i.fadeEaseType=egret.Ease.quadInOut,i.delayBeforeFadeInDuration=.1,i._alpha=0,i._mask=new egret.Shape,i}return __extends(i,e),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var e=this;return __generator(this,function(i){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill(),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(e,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(e).to({_alpha:0},1e3*e.fadeOutDuration,e.fadeEaseType).call(function(){e.transitionComplete()})}),[2]})})},i.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this._mask.graphics.endFill()},i}(t.SceneTransition);t.FadeTransition=e}(es||(es={})),function(t){var e=function(e){function i(i){var n=e.call(this,i)||this;n.duration=1,n.easeType=egret.Ease.quadOut;return n._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),n._mask=new egret.Shape,n._mask.graphics.beginFill(16777215,1),n._mask.graphics.drawRect(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),n._mask.graphics.endFill(),n._mask.filters=[n._windEffect],n}return __extends(i,e),Object.defineProperty(i.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),i.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return t.sent(),this.transitionComplete(),[2]}})})},i}(t.SceneTransition);t.WindTransition=e}(es||(es={})),function(t){var e=function(){function e(){}return e.getPoint=function(e,i,n,r){var o=1-(r=t.MathHelper.clamp01(r));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(o*o),e),t.Vector2.multiply(new t.Vector2(2*o*r),i)),t.Vector2.multiply(new t.Vector2(r*r),n))},e.getFirstDerivative=function(e,i,n,r){return t.Vector2.add(t.Vector2.multiply(new t.Vector2(2*(1-r)),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(2*r),t.Vector2.subtract(n,i)))},e.getFirstDerivativeThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(3*s*s),t.Vector2.subtract(i,e)),t.Vector2.multiply(new t.Vector2(6*s*o),t.Vector2.subtract(n,i))),t.Vector2.multiply(new t.Vector2(3*o*o),t.Vector2.subtract(r,n)))},e.getPointThree=function(e,i,n,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(s*s*s),e),t.Vector2.multiply(new t.Vector2(3*s*s*o),i)),t.Vector2.multiply(new t.Vector2(3*s*o*o),n)),t.Vector2.multiply(new t.Vector2(o*o*o),r))},e.getOptimizedDrawingPoints=function(e,i,n,r,o){void 0===o&&(o=1);var s=t.ListPool.obtain();return s.push(e),this.recursiveGetOptimizedDrawingPoints(e,i,n,r,s,o),s.push(r),s},e.recursiveGetOptimizedDrawingPoints=function(e,i,n,r,o,s){var a=t.Vector2.divide(t.Vector2.add(e,i),new t.Vector2(2)),h=t.Vector2.divide(t.Vector2.add(i,n),new t.Vector2(2)),c=t.Vector2.divide(t.Vector2.add(n,r),new t.Vector2(2)),u=t.Vector2.divide(t.Vector2.add(a,h),new t.Vector2(2)),l=t.Vector2.divide(t.Vector2.add(h,c),new t.Vector2(2)),p=t.Vector2.divide(t.Vector2.add(u,l),new t.Vector2(2)),d=t.Vector2.subtract(r,e),f=Math.abs((i.x,r.x*d.y-(i.y-r.y)*d.x)),g=Math.abs((n.x-r.x)*d.y-(n.y-r.y)*d.x);(f+g)*(f+g)<s*(d.x*d.x+d.y*d.y)?o.push(p):(this.recursiveGetOptimizedDrawingPoints(e,a,u,p,o,s),this.recursiveGetOptimizedDrawingPoints(p,l,c,r,o,s))},e}();t.Bezier=e}(es||(es={})),function(t){var e=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}();t.Flags=e}(es||(es={})),function(t){var e=function(){function e(){}return e.toDegrees=function(t){return 57.29577951308232*t},e.toRadians=function(t){return.017453292519943295*t},e.map=function(t,e,i,n,r){return n+(t-e)*(r-n)/(i-e)},e.lerp=function(t,e,i){return t+(e-t)*i},e.clamp=function(t,e,i){return t<e?e:t>i?i:t},e.pointOnCirlce=function(i,n,r){var o=e.toRadians(r);return new t.Vector2(Math.cos(o)*o+i.x,Math.sin(o)*o+i.y)},e.isEven=function(t){return t%2==0},e.clamp01=function(t){return t<0?0:t>1?1:t},e.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},e.incrementWithWrap=function(t,e){return++t==e?0:t},e.Epsilon=1e-5,e.Rad2Deg=57.29578,e.Deg2Rad=.0174532924,e.PiOver2=Math.PI/2,e}();t.MathHelper=e}(es||(es={})),function(t){t.matrixPool=[];var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"m11",{get:function(){return this.a},set:function(t){this.a=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m12",{get:function(){return this.b},set:function(t){this.b=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m21",{get:function(){return this.c},set:function(t){this.c=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m22",{get:function(){return this.d},set:function(t){this.d=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m31",{get:function(){return this.tx},set:function(t){this.tx=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"m32",{get:function(){return this.ty},set:function(t){this.ty=t},enumerable:!0,configurable:!0}),i.create=function(){var e=t.matrixPool.pop();return e||(e=new i),e},i.prototype.identity=function(){return this.a=this.d=1,this.b=this.c=this.tx=this.ty=0,this},i.prototype.translate=function(t,e){return this.tx+=t,this.ty+=e,this},i.prototype.scale=function(t,e){return 1!==t&&(this.a*=t,this.c*=t,this.tx*=t),1!==e&&(this.b*=e,this.d*=e,this.ty*=e),this},i.prototype.rotate=function(t){if(0!==(t=+t)){t/=DEG_TO_RAD;var e=Math.cos(t),i=Math.sin(t),n=this.a,r=this.b,o=this.c,s=this.d,a=this.tx,h=this.ty;this.a=n*e-r*i,this.b=n*i+r*e,this.c=o*e-s*i,this.d=o*i+s*e,this.tx=a*e-h*i,this.ty=a*i+h*e}return this},i.prototype.invert=function(){return this.$invertInto(this),this},i.prototype.add=function(t){return this.m11+=t.m11,this.m12+=t.m12,this.m21+=t.m21,this.m22+=t.m22,this.m31+=t.m31,this.m32+=t.m32,this},i.prototype.substract=function(t){return this.m11-=t.m11,this.m12-=t.m12,this.m21-=t.m21,this.m22-=t.m22,this.m31-=t.m31,this.m32-=t.m32,this},i.prototype.divide=function(t){return this.m11/=t.m11,this.m12/=t.m12,this.m21/=t.m21,this.m22/=t.m22,this.m31/=t.m31,this.m32/=t.m32,this},i.prototype.multiply=function(t){var e=this.m11*t.m11+this.m12*t.m21,i=this.m11*t.m12+this.m12*t.m22,n=this.m21*t.m11+this.m22*t.m21,r=this.m21*t.m12+this.m22*t.m22,o=this.m31*t.m11+this.m32*t.m21+t.m31,s=this.m31*t.m12+this.m32*t.m22+t.m32;return this.m11=e,this.m12=i,this.m21=n,this.m22=r,this.m31=o,this.m32=s,this},i.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},i.prototype.release=function(e){e&&t.matrixPool.push(e)},i}(egret.Matrix);t.Matrix2D=e}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"max",{get:function(){return new t.Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"center",{get:function(){return new t.Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"location",{get:function(){return new t.Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"size",{get:function(){return new t.Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),i.fromMinMax=function(t,e,n,r){return new i(t,e,n-t,r-e)},i.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,i=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>n&&(n=s.x),s.y<i&&(i=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,i,n,r)},i.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},i.prototype.rayIntersects=function(t){var e=0,i=Number.MAX_VALUE;if(Math.abs(t.direction.x)<1e-6){if(t.start.x<this.x||t.start.x>this.x+this.width)return e}else{var n=1/t.direction.x,r=(this.x-t.start.x)*n,o=(this.x+this.width-t.start.x)*n;if(r>o){var s=r;r=o,o=s}if((e=Math.max(r,e))>(i=Math.min(o,i)))return e}if(Math.abs(t.direction.y)<1e-6){if(t.start.y<this.y||t.start.y>this.y+this.height)return e}else{var a=1/t.direction.y,h=(this.y-t.start.y)*a,c=(this.y+this.height-t.start.y)*a;if(h>c){var u=h;h=c,c=u}if((e=Math.max(h,e))>(i=Math.max(c,i)))return e}return e},i.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},i.prototype.contains=function(t,e){return this.x<=t&&t<this.x+this.width&&this.y<=e&&e<this.y+this.height},i.prototype.getHalfSize=function(){return new t.Vector2(.5*this.width,.5*this.height)},i.prototype.getClosestPointOnRectangleBorderToPoint=function(e,i){i=t.Vector2.zero;var n=new t.Vector2;if(n.x=t.MathHelper.clamp(e.x,this.left,this.right),n.y=t.MathHelper.clamp(e.y,this.top,this.bottom),this.contains(n.x,n.y)){var r=n.x-this.left,o=this.right-n.x,s=n.y-this.top,a=this.bottom-n.y,h=Math.min(r,o,s,a);h==s?(n.y=this.top,i.y=-1):h==a?(n.y=this.bottom,i.y=1):h==r?(n.x=this.left,i.x=-1):(n.x=this.right,i.x=1)}else n.x==this.left&&(i.x=-1),n.x==this.right&&(i.x=1),n.y==this.top&&(i.y=-1),n.y==this.bottom&&(i.y=1);return n},i.prototype.getClosestPointOnBoundsToOrigin=function(){var e=this.max,i=Math.abs(this.location.x),n=new t.Vector2(this.location.x,0);return Math.abs(e.x)<i&&(i=Math.abs(e.x),n.x=e.x,n.y=0),Math.abs(e.y)<i&&(i=Math.abs(e.y),n.x=0,n.y=e.y),Math.abs(this.location.y)<i&&(i=Math.abs(this.location.y),n.x=0,n.y=this.location.y),n},i.prototype.calculateBounds=function(e,i,n,r,o,s,a){if(0==o)this.x=e.x+i.x-n.x*r.x,this.y=e.y+i.y-n.y*r.y,this.width=s*r.x,this.height=a*r.y;else{var h=e.x+i.x,c=e.y+i.y;this._transformMat=t.Matrix2D.create().translate(-h-n.x,-c-n.y),this._tempMat=t.Matrix2D.create().scale(r.x,r.y),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().rotate(o),this._transformMat=this._transformMat.multiply(this._tempMat),this._tempMat=t.Matrix2D.create().translate(h,c),this._transformMat=this._transformMat.multiply(this._tempMat);var u=new t.Vector2(h,c),l=new t.Vector2(h+s,c),p=new t.Vector2(h,c+a),d=new t.Vector2(h+s,c+a);u=t.Vector2Ext.transformR(u,this._transformMat),l=t.Vector2Ext.transformR(l,this._transformMat),p=t.Vector2Ext.transformR(p,this._transformMat),d=t.Vector2Ext.transformR(d,this._transformMat);var f=Math.min(u.x,d.x,l.x,p.x),g=Math.max(u.x,d.x,l.x,p.x),m=Math.min(u.y,d.y,l.y,p.y),y=Math.max(u.y,d.y,l.y,p.y);this.location=new t.Vector2(f,m),this.width=g-f,this.height=y-m}},i}(egret.Rectangle);t.Rectangle=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.x=t,this.y=e,this.z=i}}();t.Vector3=e}(es||(es={})),function(t){var e=function(){function e(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return e.prototype.update=function(){for(var e=this._entity.getComponents(t.Collider),i=0;i<e.length;i++)for(var n=e[i],r=t.Physics.boxcastBroadphase(n.bounds,n.collidesWithLayers),o=function(e){var i=r[e];if(!n.isTrigger&&!i.isTrigger)return"continue";if(n.overlaps(i)){var o=new t.Pair(n,i);-1==s._activeTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&-1==s._previousTriggerIntersections.findIndex(function(t){return t.first==o.first&&t.second==o.second})&&s.notifyTriggerListeners(o,!0),s._activeTriggerIntersections.contains(o)||s._activeTriggerIntersections.push(o)}},s=this,a=0;a<r.length;a++)o(a);t.ListPool.free(e),this.checkForExitedColliders()},e.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var n=i._previousTriggerIntersections.findIndex(function(i){return i.first==t._activeTriggerIntersections[e].first&&i.second==t._activeTriggerIntersections[e].second});-1!=n&&i._previousTriggerIntersections.removeAt(n)},i=this,n=0;n<this._activeTriggerIntersections.length;n++)e(n);for(n=0;n<this._previousTriggerIntersections.length;n++)this.notifyTriggerListeners(this._previousTriggerIntersections[n],!1);this._previousTriggerIntersections.length=0;for(n=0;n<this._activeTriggerIntersections.length;n++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[n])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[n]);this._activeTriggerIntersections.length=0},e.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)if(e?this._tempTriggerList[i].onTriggerEnter(t.second,t.first):this._tempTriggerList[i].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)e?this._tempTriggerList[n].onTriggerEnter(t.first,t.second):this._tempTriggerList[n].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},e}();t.ColliderTriggerHelper=e}(es||(es={})),function(t){var e;!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(e=t.PointSectors||(t.PointSectors={}));var i=function(){function i(){}return i.isLineToLine=function(e,i,n,r){var o=t.Vector2.subtract(i,e),s=t.Vector2.subtract(r,n),a=o.x*s.y-o.y*s.x;if(0==a)return!1;var h=t.Vector2.subtract(n,e),c=(h.x*s.y-h.y*s.x)/a;if(c<0||c>1)return!1;var u=(h.x*o.y-h.y*o.x)/a;return!(u<0||u>1)},i.lineToLineIntersection=function(e,i,n,r){var o=new t.Vector2(0,0),s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return o;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return o;var l=(c.x*s.y-c.y*s.x)/h;return l<0||l>1?o:o=t.Vector2.add(e,new t.Vector2(u*s.x,u*s.y))},i.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,new t.Vector2(r.x*s,r.y*s))},i.isCircleToCircle=function(e,i,n,r){return t.Vector2.distanceSquared(e,n)<(i+r)*(i+r)},i.isCircleToLine=function(e,i,n,r){return t.Vector2.distanceSquared(e,this.closestPointOnLine(n,r,e))<i*i},i.isCircleToPoint=function(e,i,n){return t.Vector2.distanceSquared(e,n)<i*i},i.isRectToCircle=function(t,e,i){var n=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-n),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<i*i},i.isRectToLine=function(i,n,r){var o=this.getSector(i.x,i.y,i.width,i.height,n),s=this.getSector(i.x,i.y,i.width,i.height,r);if(o==e.center||s==e.center)return!0;if(0!=(o&s))return!1;var a=o|s,h=void 0,c=void 0;return!(0==(a&e.top)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x+i.width,i.y),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.bottom)||(h=new t.Vector2(i.x,i.y+i.height),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))||(!(0==(a&e.left)||(h=new t.Vector2(i.x,i.y),c=new t.Vector2(i.x,i.y+i.height),!this.isLineToLine(h,c,n,r)))||!(0==(a&e.right)||(h=new t.Vector2(i.x+i.width,i.y),c=new t.Vector2(i.x+i.width,i.y+i.height),!this.isLineToLine(h,c,n,r)))))},i.isRectToPoint=function(t,e,i,n,r){return r.x>=t&&r.y>=e&&r.x<t+i&&r.y<e+n},i.getSector=function(t,i,n,r,o){var s=e.center;return o.x<t?s|=e.left:o.x>=t+n&&(s|=e.right),o.y<i?s|=e.top:o.y>=i+r&&(s|=e.bottom),s},i}();t.Collisions=i}(es||(es={})),function(t){var e=function(){function e(){}return e.reset=function(){this._spatialHash=new t.SpatialHash(this.spatialHashCellSize)},e.clear=function(){this._spatialHash.clear()},e.overlapCircleAll=function(t,e,i,n){if(void 0===n&&(n=-1),0!=i.length)return this._spatialHash.overlapCircle(t,e,i,n);console.error("An empty results array was passed in. No results will ever be returned.")},e.boxcastBroadphase=function(t,e){return void 0===e&&(e=this.allLayers),this._spatialHash.aabbBroadphase(t,null,e)},e.boxcastBroadphaseExcludingSelf=function(t,e,i){return void 0===i&&(i=this.allLayers),this._spatialHash.aabbBroadphase(e,t,i)},e.addCollider=function(t){e._spatialHash.register(t)},e.removeCollider=function(t){e._spatialHash.remove(t)},e.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},e.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},e.spatialHashCellSize=100,e.allLayers=-1,e.raycastsHitTriggers=!1,e.raycastsStartInColliders=!1,e}();t.Physics=e}(es||(es={})),function(t){var e=function(){return function(e,i){this.start=e,this.end=i,this.direction=t.Vector2.subtract(this.end,this.start)}}();t.Ray2D=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r,o){this.fraction=0,this.distance=0,this.point=t.Vector2.zero,this.normal=t.Vector2.zero,this.collider=e,this.fraction=i,this.distance=n,this.point=r,this.centroid=t.Vector2.zero}return e.prototype.setValues=function(t,e,i,n){this.collider=t,this.fraction=e,this.distance=i,this.point=n},e.prototype.setValuesNonCollider=function(t,e,i,n){this.fraction=t,this.distance=e,this.point=i,this.normal=n},e.prototype.reset=function(){this.collider=null,this.fraction=this.distance=0},e.prototype.toString=function(){return"[RaycastHit] fraction: "+this.fraction+", distance: "+this.distance+", normal: "+this.normal+", centroid: "+this.centroid+", point: "+this.point},e}();t.RaycastHit=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.clone=function(){return ObjectUtils.clone(this)},t}();t.Shape=e}(es||(es={})),function(t){var e=function(e){function i(t,i){var n=e.call(this)||this;return n._areEdgeNormalsDirty=!0,n.isUnrotated=!0,n.setPoints(t),n.isBox=i,n}return __extends(i,e),Object.defineProperty(i.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),i.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},i.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=i.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},i.prototype.buildEdgeNormals=function(){var e,i=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==i||(this._edgeNormals=new Array(i));for(var n=0;n<i;n++){var r=this.points[n];e=n+1>=this.points.length?this.points[0]:this.points[n+1];var o=t.Vector2Ext.perpendicular(r,e);o=t.Vector2.normalize(o),this._edgeNormals[n]=o}},i.buildSymmetricalPolygon=function(e,i){for(var n=new Array(e),r=0;r<e;r++){var o=2*Math.PI*(r/e);n[r]=t.Vector2.multiply(new t.Vector2(Math.cos(o),Math.sin(o)),new t.Vector2(i))}return n},i.recenterPolygonVerts=function(e){for(var i=this.findPolygonCenter(e),n=0;n<e.length;n++)e[n]=t.Vector2.subtract(e[n],i)},i.findPolygonCenter=function(e){for(var i=0,n=0,r=0;r<e.length;r++)i+=e[r].x,n+=e[r].y;return new t.Vector2(i/e.length,n/e.length)},i.getFarthestPointInDirection=function(e,i){for(var n=0,r=t.Vector2.dot(e[n],i),o=1;o<e.length;o++){var s=t.Vector2.dot(e[o],i);s>r&&(r=s,n=o)}return e[n]},i.getClosestPointOnPolygonToPoint=function(e,i,n,r){n=Number.MAX_VALUE,r=new t.Vector2(0,0);for(var o,s=new t.Vector2(0,0),a=0;a<e.length;a++){var h=a+1;h==e.length&&(h=0);var c=t.ShapeCollisions.closestPointOnLine(e[a],e[h],i);if((o=t.Vector2.distanceSquared(i,c))<n){n=o,s=c;var u=t.Vector2.subtract(e[h],e[a]);r=new t.Vector2(-u.y,u.x)}}return t.Vector2Ext.normalize(r),s},i.rotatePolygonVerts=function(e,i,n){for(var r=Math.cos(e),o=Math.sign(e),s=0;s<i.length;s++){var a=i[s];n[s]=new t.Vector2(a.x*r+a.y*-o,a.x*o+a.y*r)}},i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=!0,n=void 0,r=t.Matrix2D.create().translate(-this._polygonCenter.x,-this._polygonCenter.y);if(e.entity.transform.scale!=t.Vector2.zero&&(n=t.Matrix2D.create().scale(e.entity.transform.scale.x,e.entity.transform.scale.y),r=r.multiply(n),i=!1,this.center=t.Vector2.multiply(e.localOffset,e.entity.transform.scale)),0!=e.entity.transform.rotation){n=t.Matrix2D.create().rotate(e.entity.transform.rotation),r=r.multiply(n);var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=i?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}n=t.Matrix2D.create().translate(this._polygonCenter.x,this._polygonCenter.y),r=r.multiply(n),t.Vector2Ext.transform(this._originalPoints,r,this.points),this.isUnrotated=0==e.entity.transform.rotation,e._isRotationDirty&&(this._areEdgeNormalsDirty=!0)}this.position=t.Vector2.add(e.entity.transform.position,this.center),this.bounds=t.Rectangle.rectEncompassingPoints(this.points),this.bounds.location=this.bounds.location.add(this.position)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Pologon to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof i)return t.ShapeCollisions.polygonToPolygon(this,e,n);if(e instanceof t.Circle)return!!t.ShapeCollisions.circleToPolygon(e,this,n)&&(n.invertResult(),!0);throw new Error("overlaps of Polygon to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToPoly(e,i,this,n)},i.prototype.containsPoint=function(e){e=t.Vector2.subtract(e,this.position);for(var i=!1,n=0,r=this.points.length-1;n<this.points.length;r=n++)this.points[n].y>e.y!=this.points[r].y>e.y&&e.x<(this.points[r].x-this.points[n].x)*(e.y-this.points[n].y)/(this.points[r].y-this.points[n].y)+this.points[n].x&&(i=!i);return i},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToPoly(e,this,i)},i}(t.Shape);t.Polygon=e}(es||(es={})),function(t){var e=function(e){function i(t,n){var r=e.call(this,i.buildBox(t,n),!0)||this;return r.width=t,r.height=n,r}return __extends(i,e),i.buildBox=function(e,i){var n=e/2,r=i/2,o=new Array(4);return o[0]=new t.Vector2(-n,-r),o[1]=new t.Vector2(n,-r),o[2]=new t.Vector2(n,r),o[3]=new t.Vector2(-n,r),o},i.prototype.updateBox=function(e,i){this.width=e,this.height=i;var n=e/2,r=i/2;this.points[0]=new t.Vector2(-n,-r),this.points[1]=new t.Vector2(n,-r),this.points[2]=new t.Vector2(n,r),this.points[3]=new t.Vector2(-n,r);for(var o=0;o<this.points.length;o++)this._originalPoints[o]=this.points[o]},i.prototype.overlaps=function(n){if(this.isUnrotated){if(n instanceof i&&n.isUnrotated)return this.bounds.intersects(n.bounds);if(n instanceof t.Circle)return t.Collisions.isRectToCircle(this.bounds,n.position,n.radius)}return e.prototype.overlaps.call(this,n)},i.prototype.collidesWithShape=function(n,r){return n instanceof i&&n.isUnrotated?t.ShapeCollisions.boxToBox(this,n,r):e.prototype.collidesWithShape.call(this,n,r)},i.prototype.containsPoint=function(t){return this.isUnrotated?this.bounds.contains(t.x,t.y):e.prototype.containsPoint.call(this,t)},i.prototype.pointCollidesWithShape=function(i,n){return this.isUnrotated?t.ShapeCollisions.pointToBox(i,this,n):e.prototype.pointCollidesWithShape.call(this,i,n)},i}(t.Polygon);t.Box=e}(es||(es={})),function(t){var e=function(e){function i(t){var i=e.call(this)||this;return i.radius=t,i._originalRadius=t,i}return __extends(i,e),i.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var i=e.entity.transform.scale,n=1==i.x&&1==i.y,r=Math.max(i.x,i.y);if(this.radius=this._originalRadius*r,0!=e.entity.transform.rotation){var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=n?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}}this.position=t.Vector2.add(e.transform.position,this.center),this.bounds=new t.Rectangle(this.position.x-this.radius,this.position.y-this.radius,2*this.radius,2*this.radius)},i.prototype.overlaps=function(e){var n=new t.CollisionResult;if(e instanceof t.Box&&e.isUnrotated)return t.Collisions.isRectToCircle(e.bounds,this.position,this.radius);if(e instanceof i)return t.Collisions.isCircleToCircle(this.position,this.radius,e.position,e.radius);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("overlaps of circle to "+e+" are not supported")},i.prototype.collidesWithShape=function(e,n){if(e instanceof t.Box&&e.isUnrotated)return t.ShapeCollisions.circleToBox(this,e,n);if(e instanceof i)return t.ShapeCollisions.circleToCircle(this,e,n);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e,n);throw new Error("Collisions of Circle to "+e+" are not supported")},i.prototype.collidesWithLine=function(e,i,n){return t.ShapeCollisions.lineToCircle(e,i,this,n)},i.prototype.containsPoint=function(e){return t.Vector2.subtract(e,this.position).lengthSquared()<=this.radius*this.radius},i.prototype.pointCollidesWithShape=function(e,i){return t.ShapeCollisions.pointToCircle(e,this,i)},i}(t.Shape);t.Circle=e}(es||(es={})),function(t){var e=function(){function e(){this.normal=t.Vector2.zero,this.minimumTranslationVector=t.Vector2.zero,this.point=t.Vector2.zero}return e.prototype.removeHorizontal=function(e){if(Math.sign(this.normal.x)!=Math.sign(e.x)||0==e.x&&0!=this.normal.x){var i=this.minimumTranslationVector.length()/this.normal.y;1!=Math.abs(this.normal.x)&&Math.abs(i)<Math.abs(3*e.y)&&(this.minimumTranslationVector=new t.Vector2(0,-i))}},e.prototype.invertResult=function(){return this.minimumTranslationVector=t.Vector2.negate(this.minimumTranslationVector),this.normal=t.Vector2.negate(this.normal),this},e.prototype.toString=function(){return"[CollisionResult] normal: "+this.normal+", minimumTranslationVector: "+this.minimumTranslationVector},e}();t.CollisionResult=e}(es||(es={})),function(t){var e=function(){function e(){}return e.intersectMovingCircleToBox=function(e,i,n){var r=i.bounds;r.inflate(e.radius,e.radius);var o=new t.Ray2D(t.Vector2.subtract(e.position,n),e.position),s=r.rayIntersects(o);if(s>1)return s;var a,h=t.Vector2.add(o.start,t.Vector2.add(o.direction,new t.Vector2(s))),c=0;h.x<i.bounds.left&&(a|=1),h.x>i.bounds.right&&(c|=1),h.y<i.bounds.top&&(a|=2),h.y>i.bounds.bottom&&(c|=2);var u=a+c;return 3==u&&console.log("m == 3. corner "+t.Time.frameCount),s},e}();t.RealtimeCollisions=e}(es||(es={})),function(t){var e=function(){function e(){}return e.polygonToPolygon=function(e,i,n){for(var r,o=!0,s=e.edgeNormals,a=i.edgeNormals,h=Number.POSITIVE_INFINITY,c=new t.Vector2,u=t.Vector2.subtract(e.position,i.position),l=0;l<s.length+a.length;l++){r=l<s.length?s[l]:a[l-s.length];var p=0,d=0,f=0,g=0,m=0,y=this.getInterval(r,e,p,f);p=y.min,d=y.max;var _=this.getInterval(r,i,d,g);d=_.min,g=_.max;var v=t.Vector2.dot(u,r);if(p+=v,f+=v,(m=this.intervalDistance(p,f,d,g))>0&&(o=!1),!o)return!1;(m=Math.abs(m))<h&&(h=m,c=r,t.Vector2.dot(c,u)<0&&(c=new t.Vector2(-c)))}return n.normal=c,n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-c.x,-c.y),new t.Vector2(h)),!0},e.intervalDistance=function(t,e,i,n){return t<i?i-e:t-i},e.getInterval=function(e,i,n,r){var o=t.Vector2.dot(i.points[0],e);n=r=o;for(var s=1;s<i.points.length;s++)(o=t.Vector2.dot(i.points[s],e))<n?n=o:o>r&&(r=o);return{min:n,max:r}},e.circleToPolygon=function(e,i,n){var r,o=t.Vector2.subtract(e.position,i.position),s=t.Polygon.getClosestPointOnPolygonToPoint(i.points,o,0,n.normal),a=i.containsPoint(e.position);if(0>e.radius*e.radius&&!a)return!1;a?r=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0)-e.radius)):r=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));return n.minimumTranslationVector=r,n.point=t.Vector2.add(s,i.position),!0},e.circleToBox=function(e,i,n){var r=i.bounds.getClosestPointOnRectangleBorderToPoint(e.position,n.normal);if(i.containsPoint(e.position)){n.point=r;var o=t.Vector2.add(r,t.Vector2.multiply(n.normal,new t.Vector2(e.radius)));return n.minimumTranslationVector=t.Vector2.subtract(e.position,o),!0}var s=t.Vector2.distanceSquared(r,e.position);if(0==s)n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(e.radius));else if(s<=e.radius*e.radius){n.normal=t.Vector2.subtract(e.position,r);var a=n.normal.length()-e.radius;return n.point=r,n.normal=t.Vector2Ext.normalize(n.normal),n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(a),n.normal),!0}return!1},e.pointToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e,i.position),o=1+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s,-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius,i.radius))),!0}return!1},e.pointToBox=function(e,i,n){return!!i.containsPoint(e)&&(n.point=i.bounds.getClosestPointOnRectangleBorderToPoint(e,n.normal),n.minimumTranslationVector=t.Vector2.subtract(e,n.point),!0)},e.closestPointOnLine=function(e,i,n){var r=t.Vector2.subtract(i,e),o=t.Vector2.subtract(n,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,t.Vector2.multiply(r,new t.Vector2(s,s)))},e.pointToPoly=function(e,i,n){if(i.containsPoint(e)){var r=t.Polygon.getClosestPointOnPolygonToPoint(i.points,t.Vector2.subtract(e,i.position),0,n.normal);return n.minimumTranslationVector=t.Vector2.multiply(n.normal,new t.Vector2(Math.sqrt(0),Math.sqrt(0))),n.point=t.Vector2.add(r,i.position),!0}return!1},e.circleToCircle=function(e,i,n){var r=t.Vector2.distanceSquared(e.position,i.position),o=e.radius+i.radius;if(r<o*o){n.normal=t.Vector2.normalize(t.Vector2.subtract(e.position,i.position));var s=o-Math.sqrt(r);return n.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s),n.normal),n.point=t.Vector2.add(i.position,t.Vector2.multiply(n.normal,new t.Vector2(i.radius))),!0}return!1},e.boxToBox=function(e,i,n){var r=this.minkowskiDifference(e,i);return!!r.contains(0,0)&&(n.minimumTranslationVector=r.getClosestPointOnBoundsToOrigin(),!n.minimumTranslationVector.equals(t.Vector2.zero)&&(n.normal=new t.Vector2(-n.minimumTranslationVector.x,-n.minimumTranslationVector.y),n.normal=n.normal.normalize(),!0))},e.minkowskiDifference=function(e,i){var n=t.Vector2.subtract(e.position,t.Vector2.add(e.bounds.location,t.Vector2.divide(e.bounds.size,new t.Vector2(2)))),r=t.Vector2.subtract(t.Vector2.add(e.bounds.location,n),i.bounds.max),o=t.Vector2.add(e.bounds.size,i.bounds.size);return new t.Rectangle(r.x,r.y,o.x,o.y)},e.lineToPoly=function(e,i,n,r){for(var o=t.Vector2.zero,s=t.Vector2.zero,a=Number.MAX_VALUE,h=!1,c=n.points.length-1,u=0;u<n.points.length;c=u,u++){var l=t.Vector2.add(n.position,n.points[c]),p=t.Vector2.add(n.position,n.points[u]),d=t.Vector2.zero;if(this.lineToLine(l,p,e,i,d)){h=!0;var f=(d.x-e.x)/(i.x-e.x);if((Number.isNaN(f)||Number.isFinite(f))&&(f=(d.y-e.y)/(i.y-e.y)),f<a){var g=t.Vector2.subtract(p,l);o=new t.Vector2(g.y,-g.x),a=f,s=d}}}if(h){o=o.normalize();var m=t.Vector2.distance(e,s);return r.setValuesNonCollider(a,m,s,o),!0}return!1},e.lineToLine=function(e,i,n,r,o){var s=t.Vector2.subtract(i,e),a=t.Vector2.subtract(r,n),h=s.x*a.y-s.y*a.x;if(0==h)return!1;var c=t.Vector2.subtract(n,e),u=(c.x*a.y-c.y*a.x)/h;if(u<0||u>1)return!1;var l=(c.x*s.y-c.y*s.x)/h;return!(l<0||l>1)&&(o=o.add(e).add(t.Vector2.multiply(new t.Vector2(u),s)),!0)},e.lineToCircle=function(e,i,n,r){var o=t.Vector2.distance(e,i),s=t.Vector2.divide(t.Vector2.subtract(i,e),new t.Vector2(o)),a=t.Vector2.subtract(e,n.position),h=t.Vector2.dot(a,s),c=t.Vector2.dot(a,a)-n.radius*n.radius;if(c>0&&h>0)return!1;var u=h*h-c;return!(u<0)&&(r.fraction=-h-Math.sqrt(u),r.fraction<0&&(r.fraction=0),r.point=t.Vector2.add(e,t.Vector2.multiply(new t.Vector2(r.fraction),s)),r.distance=t.Vector2.distance(e,r.point),r.normal=t.Vector2.normalize(t.Vector2.subtract(r.point,n.position)),r.fraction=r.distance/o,!0)},e.boxToBoxCast=function(e,i,n,r){var o=this.minkowskiDifference(e,i);if(o.contains(0,0)){var s=o.getClosestPointOnBoundsToOrigin();return!s.equals(t.Vector2.zero)&&(r.normal=new t.Vector2(-s.x),r.normal=r.normal.normalize(),r.distance=0,r.fraction=0,!0)}var a=new t.Ray2D(t.Vector2.zero,new t.Vector2(-n.x)),h=o.rayIntersects(a);return h<=1&&(r.fraction=h,r.distance=n.length()*h,r.normal=new t.Vector2(-n.x),r.normal=r.normal.normalize(),r.centroid=t.Vector2.add(e.bounds.center,t.Vector2.multiply(n,new t.Vector2(h))),!0)},e}();t.ShapeCollisions=e}(es||(es={})),function(t){var e=function(){function e(e){void 0===e&&(e=100),this.gridBounds=new t.Rectangle,this._overlapTestCircle=new t.Circle(0),this._cellDict=new i,this._tempHashSet=[],this._cellSize=e,this._inverseCellSize=1/this._cellSize,this._raycastParser=new n}return e.prototype.register=function(e){var i=e.bounds;e.registeredPhysicsBounds=i;var n=this.cellCoords(i.x,i.y),r=this.cellCoords(i.right,i.bottom);this.gridBounds.contains(n.x,n.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,n)),this.gridBounds.contains(r.x,r.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,r));for(var o=n.x;o<=r.x;o++)for(var s=n.y;s<=r.y;s++){var a=this.cellAtPosition(o,s,!0);a.firstOrDefault(function(t){return t.hashCode==e.hashCode})||a.push(e)}},e.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,i=this.cellCoords(e.x,e.y),n=this.cellCoords(e.right,e.bottom),r=i.x;r<=n.x;r++)for(var o=i.y;o<=n.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.log("从不存在碰撞器的单元格中移除碰撞器: ["+t+"]")}},e.prototype.removeWithBruteForce=function(t){this._cellDict.remove(t)},e.prototype.clear=function(){this._cellDict.clear()},e.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var i=this.gridBounds.x;i<=this.gridBounds.right;i++)for(var n=this.gridBounds.y;n<=this.gridBounds.bottom;n++){var r=this.cellAtPosition(i,n);r&&r.length>0&&this.debugDrawCellDetails(i,n,r.length,t,e)}},e.prototype.aabbBroadphase=function(e,i,n){this._tempHashSet.length=0;for(var r=this.cellCoords(e.x,e.y),o=this.cellCoords(e.right,e.bottom),s=r.x;s<=o.x;s++)for(var a=r.y;a<=o.y;a++){var h=this.cellAtPosition(s,a);if(h)for(var c=function(r){var o=h[r];if(o==i||!t.Flags.isFlagSet(n,o.physicsLayer))return"continue";e.intersects(o.bounds)&&(u._tempHashSet.firstOrDefault(function(t){return t.hashCode==o.hashCode})||u._tempHashSet.push(o))},u=this,l=0;l<h.length;l++)c(l)}return this._tempHashSet},e.prototype.overlapCircle=function(e,i,n,r){var o=new t.Rectangle(e.x-i,e.y-i,2*i,2*i);this._overlapTestCircle.radius=i,this._overlapTestCircle.position=e;for(var s=0,a=this.aabbBroadphase(o,null,r),h=0;h<a.length;h++){var c=a[h];if(c instanceof t.BoxCollider)n[s]=c,s++;else if(c instanceof t.CircleCollider)c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++);else{if(!(c instanceof t.PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");c.shape.overlaps(this._overlapTestCircle)&&(n[s]=c,s++)}if(s==n.length)return s}return s},e.prototype.cellCoords=function(e,i){return new t.Vector2(Math.floor(e*this._inverseCellSize),Math.floor(i*this._inverseCellSize))},e.prototype.cellAtPosition=function(t,e,i){void 0===i&&(i=!1);var n=this._cellDict.tryGetValue(t,e);return n||i&&(n=[],this._cellDict.add(t,e,n)),n},e.prototype.debugDrawCellDetails=function(t,e,i,n,r){void 0===n&&(n=.5),void 0===r&&(r=1)},e}();t.SpatialHash=e;var i=function(){function t(){this._store=new Map}return t.prototype.add=function(t,e,i){this._store.set(this.getKey(t,e),i)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!0)).toString()},t}();t.NumberDictionary=i;var n=function(){function e(){this._checkedColliders=[],this._cellHits=[]}return e.prototype.start=function(t,e,i){this._ray=t,this._hits=e,this._layerMask=i,this.hitCounter=0},e.prototype.checkRayIntersection=function(i,n,r){for(var o=0;o<r.length;o++){var s=r[o];if(!this._checkedColliders.contains(s))if(this._checkedColliders.push(s),!s.isTrigger||t.Physics.raycastsHitTriggers)if(t.Flags.isFlagSet(this._layerMask,s.physicsLayer))if(s.bounds.rayIntersects(this._ray)<=1&&s.shape.collidesWithLine(this._ray.start,this._ray.end,this._tempHit)){if(!t.Physics.raycastsStartInColliders&&s.shape.containsPoint(this._ray.start))continue;this._tempHit.collider=s,this._cellHits.push(this._tempHit)}}if(0==this._cellHits.length)return!1;this._cellHits.sort(e.compareRaycastHits);for(o=0;o<this._cellHits.length;o++)if(this._hits[this.hitCounter]=this._cellHits[o],this.hitCounter++,this.hitCounter==this._hits.length)return!0;return!1},e.prototype.reset=function(){this._hits=null,this._checkedColliders.length=0,this._cellHits.length=0},e.compareRaycastHits=function(t,e){return t.distance-e.distance},e}();t.RaycastResultParser=n}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxGroup=e}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxImageLayer=e}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"offset",{get:function(){return new t.Vector2(this.offsetX,this.offsetY)},enumerable:!0,configurable:!0}),e.prototype.getTileWithGid=function(t){for(var e=0;e<this.tiles.length;e++)if(this.tiles[e]&&this.tiles[e].gid==t)return this.tiles[e];return null},e.prototype.getTile=function(t,e){return this.tiles[t+e*this.width]},e.prototype.getCollisionRectangles=function(){for(var t=[],e=[],i=-1,n=-1,r=0;r<this.map.height;r++){for(var o=0;o<this.map.width;o++){n=r*this.map.width+o;var s=this.getTile(o,r);s&&!t[n]?(i<0&&(i=o),t[n]=!0):(s||t[n])&&i>=0&&(e.push(this.findBoundsRect(i,o,r,t)),i=-1)}i>=0&&(e.push(this.findBoundsRect(i,this.map.width,r,t)),i=-1)}return e},e.prototype.findBoundsRect=function(e,i,n,r){for(var o=-1,s=n+1;s<this.map.height;s++)for(var a=e;a<i;a++){if(o=s*this.map.width+a,this.getTile(a,s)||r[o]){for(var h=e;h<a;h++)r[o=s*this.map.width+h]=!1;return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(s-n)*this.map.tileHeight)}r[o]=!0}return new t.Rectangle(e*this.map.tileWidth,n*this.map.tileHeight,(i-e)*this.map.tileWidth,(this.map.height-n)*this.map.tileHeight)},e}();t.TmxLayer=e;var i=function(){function e(t,i,n,r){this.x=n,this.y=r;var o,s=i;o=0!=(s&e.FLIPPED_HORIZONTALLY_FLAG),this.horizontalFlip=o,o=0!=(s&e.FLIPPED_VERTICALLY_FLAG),this.verticalFlip=o,s&=~(e.FLIPPED_HORIZONTALLY_FLAG|e.FLIPPED_VERTICALLY_FLAG),this.gid=s,this.tileset=t.getTilesetForTileGid(this.gid)}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tilesetTile",{get:function(){null==this._tilesetTileIndex&&(this._tilesetTileIndex=-1,this.tileset.firstGid<=this.gid&&this.tileset.tiles.get(this.gid-this.tileset.firstGid)&&(this._tilesetTileIndex=this.gid-this.tileset.firstGid));return this._tilesetTileIndex<0?null:this.tileset.tiles.get(this._tilesetTileIndex)},enumerable:!0,configurable:!0}),e.FLIPPED_HORIZONTALLY_FLAG=2147483648,e.FLIPPED_VERTICALLY_FLAG=1073741824,e}();t.TmxLayerTile=i}(es||(es={})),function(t){var e=function(){return function(){this.tmxDirectory="resource/assets/"}}();t.TmxDocument=e;var i=function(){function t(){}return t.prototype.dispose=function(){this.bitmap&&(this.bitmap.dispose(),this.bitmap=null)},t}();t.TmxImage=i}(es||(es={})),function(t){var e=function(e){function i(){return null!==e&&e.apply(this,arguments)||this}return __extends(i,e),Object.defineProperty(i.prototype,"worldWidth",{get:function(){return this.width*this.tileWidth},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"worldHeight",{get:function(){return this.height*this.tileHeight},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"requiresLargeTileCulling",{get:function(){return this.maxTileHeight>this.tileHeight||this.maxTileWidth>this.tileWidth},enumerable:!0,configurable:!0}),i.prototype.getTilesetForTileGid=function(t){if(0==t)return null;for(var e=this.tilesets.length-1;e>=0;e--)if(this.tilesets[e].firstGid<=t)return this.tilesets[e];console.error("tile gid"+t+"未在任何tileset中找到")},i.prototype.worldToTilePositionX=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileWidth);return i?t.MathHelper.clamp(n,0,this.width-1):n},i.prototype.worldToTilePositionY=function(e,i){void 0===i&&(i=!0);var n=Math.floor(e/this.tileHeight);return i?t.MathHelper.clamp(n,0,this.height-1):n},i.prototype.getLayer=function(t){return this.layers[t]},i.prototype.update=function(){this.tilesets.forEach(function(t){t.update()})},i.prototype.dispose=function(t){void 0===t&&(t=!0),this._isDisposed||(t&&(this.tilesets.forEach(function(t){t.image&&t.image.dispose()}),this.imageLayers.forEach(function(t){t.image&&t.image.dispose()})),this._isDisposed=!0)},i}(t.TmxDocument);t.TmxMap=e,function(t){t[t.unknown=0]="unknown",t[t.orthogonal=1]="orthogonal",t[t.isometric=2]="isometric",t[t.staggered=3]="staggered",t[t.hexagonal=4]="hexagonal"}(t.OrientationType||(t.OrientationType={})),function(t){t[t.x=0]="x",t[t.y=1]="y"}(t.StaggerAxisType||(t.StaggerAxisType={})),function(t){t[t.odd=0]="odd",t[t.even=1]="even"}(t.StaggerIndexType||(t.StaggerIndexType={})),function(t){t[t.rightDown=0]="rightDown",t[t.rightUp=1]="rightUp",t[t.leftDown=2]="leftDown",t[t.leftUp=3]="leftUp"}(t.RenderOrderType||(t.RenderOrderType={}))}(es||(es={})),function(t){var e=function(){return function(){}}();t.TmxObjectGroup=e;var i=function(){return function(){this.shape=new egret.Shape,this.textField=new egret.TextField}}();t.TmxObject=i;var n=function(){return function(){}}();t.TmxText=n;var r=function(){return function(){}}();t.TmxAlignment=r,function(t){t[t.basic=0]="basic",t[t.point=1]="point",t[t.tile=2]="tile",t[t.ellipse=3]="ellipse",t[t.polygon=4]="polygon",t[t.polyline=5]="polyline",t[t.text=6]="text"}(t.TmxObjectType||(t.TmxObjectType={})),function(t){t[t.unkownOrder=-1]="unkownOrder",t[t.TopDown=0]="TopDown",t[t.IndexOrder=1]="IndexOrder"}(t.DrawOrderType||(t.DrawOrderType={})),function(t){t[t.left=0]="left",t[t.center=1]="center",t[t.right=2]="right",t[t.justify=3]="justify"}(t.TmxHorizontalAlignment||(t.TmxHorizontalAlignment={})),function(t){t[t.top=0]="top",t[t.center=1]="center",t[t.bottom=2]="bottom"}(t.TmxVerticalAlignment||(t.TmxVerticalAlignment={}))}(es||(es={})),function(t){var e=function(){function e(){}return e.loadTmxMap=function(t,e){var i=RES.getRes(e);return this.loadTmxMapData(t,i)},e.loadTmxMapData=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:e.version=i.version,e.tiledVersion=i.tiledversion,e.width=i.width,e.height=i.height,e.tileWidth=i.tilewidth,e.tileHeight=i.tileheight,e.hexSideLength=i.hexsidelength,e.orientation=this.parseOrientationType(i.orientation),e.staggerAxis=this.parseStaggerAxisType(i.staggeraxis),e.staggerIndex=this.parseStaggerIndexType(i.staggerindex),e.renderOrder=this.parseRenderOrderType(i.renderorder),e.nextObjectID=i.nextobjectid,e.backgroundColor=t.TmxUtils.color16ToUnit(i.color),e.properties=this.parsePropertyDict(i.properties),e.maxTileWidth=e.tileWidth,e.maxTileHeight=e.tileHeight,e.tilesets=[],n=0,r=i.tilesets,a.label=1;case 1:return n<r.length?(o=r[n],[4,this.parseTmxTileset(e,o)]):[3,4];case 2:s=a.sent(),e.tilesets.push(s),this.updateMaxTileSizes(s),a.label=3;case 3:return n++,[3,1];case 4:return e.layers=[],e.tileLayers=[],e.objectGroups=[],e.imageLayers=[],e.groups=[],this.parseLayers(e,i,e,e.width,e.height,e.tmxDirectory),[2,e]}})})},e.parseLayers=function(e,i,n,r,o,s){return __awaiter(this,void 0,void 0,function(){var a,h,c,u,l,p,d,f;return __generator(this,function(g){switch(g.label){case 0:a=0,h=ObjectUtils.elements(i).where(function(t){return"tilelayer"==t.type||"objectgroup"==t.type||"imagelayer"==t.type||"group"==t.type}),g.label=1;case 1:if(!(a<h.length))return[3,11];switch(c=h[a],u=void 0,c.type){case"tilelayer":return[3,2];case"objectgroup":return[3,3];case"imagelayer":return[3,4];case"group":return[3,6]}return[3,8];case 2:return l=this.loadTmxLayer(new t.TmxLayer,n,c,r,o),u=l,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.tileLayers.push(l),[3,9];case 3:return p=this.loadTmxObjectGroup(new t.TmxObjectGroup,n,c),u=p,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.objectGroups.push(p),[3,9];case 4:return[4,this.loadTmxImageLayer(new t.TmxImageLayer,n,c,s)];case 5:return d=g.sent(),u=d,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.imageLayers.push(d),[3,9];case 6:return[4,this.loadTmxGroup(new t.TmxGroup,n,c,r,o,s)];case 7:return f=g.sent(),u=f,(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.groups.push(f),[3,9];case 8:throw new Error("无效的操作");case 9:(e instanceof t.TmxMap||e instanceof t.TmxGroup)&&e.layers.push(u),g.label=10;case 10:return a++,[3,1];case 11:return[2]}})})},e.loadTmxGroup=function(t,e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(s){switch(s.label){case 0:return t.map=e,t.name=null!=i.name?i.name:"",t.opacity=null!=i.opacity?i.opacity:1,t.visible=null==i.visible||i.visible,t.offsetX=null!=i.offsetx?i.offsetx:0,t.offsetY=null!=i.offsety?i.offsety:0,t.properties=this.parsePropertyDict(i.properties),t.layers=[],t.tileLayers=[],t.objectGroups=[],t.imageLayers=[],t.groups=[],[4,this.parseLayers(t,i,e,n,r,o)];case 1:return s.sent(),[2,t]}})})},e.loadTmxImageLayer=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s;return __generator(this,function(a){switch(a.label){case 0:return e.map=i,e.name=n.name,e.width=n.width,e.height=n.height,e.visible=null==n.visible||n.visible,e.opacity=null!=n.opacity?n.opacity:1,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0,(o=n.image)?(s=e,[4,this.loadTmxImage(new t.TmxImage,o,r)]):[3,2];case 1:s.image=a.sent(),a.label=2;case 2:return e.properties=this.parsePropertyDict(n.properties),[2,e]}})})},e.loadTmxLayer=function(i,n,r,o,s){i.map=n,i.name=r.name,i.opacity=null!=r.opacity?r.opacity:1,i.visible=null==r.visible||r.visible,i.offsetX=null!=r.offsetx?r.offsetx:0,i.offsetY=null!=r.offsety?r.offsety:0,i.width=r.width,i.height=r.height;var a=r.data,h=null!=a.encoding?a.encoding:"csv";if(i.tiles=new Array(o*s),"base64"==h)for(var c=t.TmxUtils.decode(a.toString(),h,a.compression),u=0,l=0;l<s;l++)for(var p=0;p<o;p++){var d=c[u];i.tiles[u++]=0!=d?new t.TmxLayerTile(n,d,p,l):null}else if("csv"==h)for(var f=0,g=0,m=a;g<m.length;g++){d=m[g];var y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}else{if(h)throw new Error("TmxLayer:未知编码");f=0;for(var v=0,b=a.tile;v<b.length;v++){var x=b[v];d=null!=x.gid?x.gid:0,y=f%o,_=f/o;i.tiles[f++]=0!=d?new t.TmxLayerTile(n,d,y,_):null}}return i.properties=e.parsePropertyDict(r.properties),i},e.updateMaxTileSizes=function(t){t.tiles.forEach(function(e){e.image&&(e.image.width>t.map.maxTileWidth&&(t.map.maxTileWidth=e.image.width),e.image.height>t.map.maxTileHeight&&(t.map.maxTileHeight=e.image.height))}),t.tileRegions.forEach(function(e){var i=e.width,n=e.height;i>t.map.maxTileWidth&&(t.map.maxTileWidth=i),i>t.map.maxTileHeight&&(t.map.maxTileHeight=n)})},e.parseOrientationType=function(e){return"unknown"==e?t.OrientationType.unknown:"orthogonal"==e?t.OrientationType.orthogonal:"isometric"==e?t.OrientationType.isometric:"staggered"==e?t.OrientationType.staggered:"hexagonal"==e?t.OrientationType.hexagonal:t.OrientationType.unknown},e.parseStaggerAxisType=function(e){return"y"==e?t.StaggerAxisType.y:t.StaggerAxisType.x},e.parseStaggerIndexType=function(e){return"even"==e?t.StaggerIndexType.even:t.StaggerIndexType.odd},e.parseRenderOrderType=function(e){return"right-up"==e?t.RenderOrderType.rightUp:"left-down"==e?t.RenderOrderType.leftDown:"left-up"==e?t.RenderOrderType.leftUp:t.RenderOrderType.rightDown},e.parsePropertyDict=function(e){if(!e)return null;for(var i=new Map,n=0,r=e;n<r.length;n++){var o=r[n],s=o.name,a=o.value;"color"==o.type?i.set(s,t.TmxUtils.color16ToUnit(a).toString()):i.set(s,a)}return i},e.parseTmxTileset=function(e,i){return __awaiter(this,void 0,void 0,function(){var n,r,o,s;return __generator(this,function(a){switch(a.label){case 0:return n=i.firstgid,r=n,null==(o=i.source)?[3,2]:(o=e.tmxDirectory+o,[4,RES.getResByUrl(o).catch(function(t){throw new Error(t)})]);case 1:return s=a.sent(),[2,this.loadTmxTileset(new t.TmxTileset,e,s.tileset,r)];case 2:return[2,this.loadTmxTileset(new t.TmxTileset,e,i,r)]}})})},e.loadTmxTileset=function(e,i,n,r){return __awaiter(this,void 0,void 0,function(){var o,s,a,h,c,u,l,p,d,f,g,m,y;return __generator(this,function(_){switch(_.label){case 0:return e.map=i,e.firstGid=r,e.name=n.name,e.tileWidth=n.tilewidth,e.tileHeight=n.tileheight,e.spacing=null!=n.spacing?n.spacing:0,e.margin=null!=n.margin?n.margin:0,e.columns=n.columns,e.tileCount=n.tilecount,e.tileOffset=this.parseTmxTileOffset(n.tileoffset),n.image?[4,this.loadTmxImage(new t.TmxImage,n,i.tmxDirectory).then(function(t){e.image=t}).catch(function(t){throw new Error(t)})]:[3,2];case 1:_.sent(),_.label=2;case 2:if(e.terrains=[],n.terrains)for(o=0,s=n.terrains;o<s.length;o++)a=s[o],e.terrains.push(this.parseTmxTerrain(a));for(c in e.tiles=new Map,h=[],n.tiles)h.push(c);u=0,_.label=3;case 3:return u<h.length?(l=h[u],n.tiles.hasOwnProperty(l)?(p=n.tiles[l],[4,this.loadTmxTilesetTile(new t.TmxTilesetTile,e,p,e.terrains,i.tmxDirectory)]):[3,5]):[3,6];case 4:d=_.sent(),e.tiles.set(null==d.id?Number(l)+1:d.id,d),_.label=5;case 5:return u++,[3,3];case 6:if(e.properties=this.parsePropertyDict(n.properties),e.tileRegions=new Map,e.image)for(f=r,g=e.margin;g<e.image.height-e.margin;g+=e.tileHeight+e.spacing)for(m=0,y=e.margin;y<e.image.width-e.margin&&(e.tileRegions.set(f++,new t.Rectangle(y,g,e.tileWidth,e.tileHeight)),!(++m>=e.columns));y+=e.tileWidth+e.spacing);else e.tiles.forEach(function(i,n){e.tileRegions.set(n,new t.Rectangle(0,0,i.image.width,i.image.height))});return[2,e]}})})},e.loadTmxTilesetTile=function(e,i,n,r,o){return __awaiter(this,void 0,void 0,function(){var s,a,h,c,u,l,p,d,f,g,m,y,_;return __generator(this,function(v){switch(v.label){case 0:if(e.tileset=i,e.id=n.id,s=n.terrain)for(e.terrainEdges=new Array(4),a=0,h=0,c=s;h<c.length;h++)u=c[h],l=r[u],e.terrainEdges[a++]=l;return e.probability=null!=n.probability?n.probability:1,e.type=n.type,(p=n.image)?(d=e,[4,this.loadTmxImage(new t.TmxImage,p,o)]):[3,2];case 1:d.image=v.sent(),v.label=2;case 2:if(e.objectGroups=[],n.objectgroup)for(f=0,g=n.objectgroup;f<g.length;f++)_=g[f],e.objectGroups.push(this.loadTmxObjectGroup(new t.TmxObjectGroup,i.map,_));if(e.animationFrames=[],n.animation)for(m=0,y=n.animation.frame;m<y.length;m++)_=y[m],e.animationFrames.push(this.loadTmxAnimationFrame(new t.TmxAnimationFrame,_));return e.properties=this.parsePropertyDict(n.properties),e.properties&&e.processProperties(),[2,e]}})})},e.loadTmxAnimationFrame=function(t,e){return t.gid=e.tileid,t.duration=e.duration/1e3,t},e.loadTmxObjectGroup=function(e,i,n){e.map=i,e.name=null!=n.name?n.name:"",e.color=t.TmxUtils.color16ToUnit(n.color),e.opacity=null!=n.opacity?n.opacity:1,e.visible=null==n.visible||n.visible,e.offsetX=null!=n.offsetx?n.offsetx:0,e.offsetY=null!=n.offsety?n.offsety:0;var r=new Map;r.set("unknown",t.DrawOrderType.unkownOrder),r.set("topdown",t.DrawOrderType.IndexOrder),r.set("index",t.DrawOrderType.TopDown);var o=n.draworder;o&&(e.drawOrder=r.get(o)),e.objects=[];for(var s=0,a=n.objects;s<a.length;s++){var h=a[s];e.objects.push(this.loadTmxObject(new t.TmxObject,i,h))}return e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxObject=function(e,i,n){e.id=null!=n.id?n.id:0,e.name=null!=n.name?n.name:"",e.x=n.x,e.y=n.y,e.width=null!=n.width?n.width:0,e.height=null!=n.height?n.height:0,e.type=null!=n.type?n.type:"",e.visible=null==n.visible||n.visible,e.rotation=null!=n.rotation?n.rotation:0;var r=n.gid,o=n.ellipse,s=n.polygon,a=n.polyline,h=n.text,c=n.point;return r?(e.tile=new t.TmxLayerTile(i,r,Math.round(e.x),Math.round(e.y)),e.objectType=t.TmxObjectType.tile):o?e.objectType=t.TmxObjectType.ellipse:s?(e.points=this.parsePoints(s),e.objectType=t.TmxObjectType.polygon):a?(e.points=this.parsePoints(a),e.objectType=t.TmxObjectType.polyline):h?(e.text=this.loadTmxText(new t.TmxText,h),e.objectType=t.TmxObjectType.text):e.objectType=c?t.TmxObjectType.point:t.TmxObjectType.basic,e.properties=this.parsePropertyDict(n.properties),e},e.loadTmxText=function(e,i){return e.fontFamily=null!=i.fontfamily?i.fontfamily:"sans-serif",e.pixelSize=null!=i.pixelsize?i.pixelsize:16,e.wrap=null!=i.wrap&&i.wrap,e.color=t.TmxUtils.color16ToUnit(i.color),e.bold=!!i.bold&&i.bold,e.italic=!!i.italic&&i.italic,e.underline=!!i.underline&&i.underline,e.strikeout=!!i.strikeout&&i.strikeout,e.kerning=!i.kerning||i.kerning,e.alignment=this.loadTmxAlignment(new t.TmxAlignment,i),e.value=i,e},e.loadTmxAlignment=function(e,i){function n(t){return t&&""!=t?t[0].toString().toUpperCase()+t.substr(1):t}var r=null!=i.halign?i.halign:"left";e.horizontal=t.TmxHorizontalAlignment[n(r)];var o=null!=i.valign?i.valign:"top";return e.vertical=t.TmxVerticalAlignment[n(o)],e},e.parsePoints=function(t){for(var e=[],i=0,n=0,r=t;n<r.length;n++){var o=r[n];e[i++]=this.parsePoint(o)}return e},e.parsePoint=function(e){return new t.Vector2(e.x,e.y)},e.parseTmxTerrain=function(e){var i=new t.TmxTerrain;return i.name=e.name,i.tile=e.tile,i.properties=this.parsePropertyDict(e.properties),i},e.parseTmxTileOffset=function(e){var i=new t.TmxTileOffset;return e?(i.x=e.x,i.y=e.y,i):(i.x=0,i.y=0,i)},e.loadTmxImage=function(e,i,n){return __awaiter(this,void 0,void 0,function(){var r,o;return __generator(this,function(s){switch(s.label){case 0:return r=i.image,e.source=null!=r?n+r:n+i,[4,RES.getResByUrl(e.source,null,this,RES.ResourceItem.TYPE_IMAGE).catch(function(t){throw new Error(t)})];case 1:return o=s.sent(),e.bitmap=new egret.SpriteSheet(o),e.trans=t.TmxUtils.color16ToUnit(i.trans),e.width=null!=i.imagewidth?i.imagewidth:o.textureWidth,e.height=null!=i.imageheight?i.imageheight:o.textureHeight,[2,e]}})})},e}();t.TiledMapLoader=e}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){}return i.renderMap=function(e,i,n,r,o){var s=this;e.layers.forEach(function(e){e instanceof t.TmxLayer&&e.visible?s.renderLayer(e,i,n,r,o):e instanceof t.TmxImageLayer&&e.visible?s.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?s.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&s.renderObjectGroup(e,i,n,r,o)})},i.renderLayer=function(e,i,n,r,o){if(e.visible)for(var s=e.map.tileWidth*r.x,a=e.map.tileHeight*r.y,h=t.DrawUtils.getColorMatrix(16777215),c=0;c<e.tiles.length;c++){var u=e.tiles[c];u&&this.renderTile(u,i,n,r,s,a,h,o)}},i.renderLayerRenderCamera=function(e,i,n,r,o,s){e instanceof t.TmxLayer&&e.visible?this.renderLayerCamera(e,i,n,r,o,s):e instanceof t.TmxImageLayer&&e.visible?this.renderImageLayer(e,i,n,r,o):e instanceof t.TmxGroup&&e.visible?this.renderGroup(e,i,n,r,o):e instanceof t.TmxObjectGroup&&e.visible&&this.renderObjectGroup(e,i,n,r,o)},i.renderLayerCamera=function(e,i,n,r,o,s){if(e.visible){n=n.add(e.offset),s.location=s.location.subtract(n);var a,h,c,u=e.map.tileWidth*r.x,l=e.map.tileHeight*r.y,p=0;e.map.requiresLargeTileCulling?(a=e.map.worldToTilePositionX(s.left-(e.map.maxTileWidth*r.x-u)),h=e.map.worldToTilePositionY(s.top-(e.map.maxTileHeight*r.y-l)),c=e.map.worldToTilePositionX(s.right+(e.map.maxTileWidth*r.x-u)),p=e.map.worldToTilePositionY(s.bottom+(e.map.maxTileHeight*r.y-l))):(a=e.map.worldToTilePositionX(s.left),h=e.map.worldToTilePositionY(s.top),c=e.map.worldToTilePositionX(s.right),p=e.map.worldToTilePositionY(s.bottom));for(var d=t.DrawUtils.getColorMatrix(16777215),f=h;f<=p;f++)for(var g=a;g<=c;g++){var m=e.getTile(g,f);m&&this.renderTile(m,i,n,r,u,l,d,o)}}},i.renderImageLayer=function(e,i,n,r,o){if(e.visible){var s=t.DrawUtils.getColorMatrix(16777215),a=t.Vector2.add(n,new t.Vector2(e.offsetX,e.offsetY).multiply(r));e.image.texture.parent||i.addChild(e.image.texture),e.image.texture.x=a.x,e.image.texture.y=a.y,e.image.texture.scaleX=r.x,e.image.texture.scaleY=r.y,e.image.texture.filters=[s]}},i.renderObjectGroup=function(e,i,n,r,o){if(e.visible)for(var s in e.objects){var a=e.objects[s];if(a.visible&&(t.Core.debugRenderEndabled||a.objectType==t.TmxObjectType.tile||a.objectType==t.TmxObjectType.text)){var h=t.Vector2.add(n,new t.Vector2(a.x,a.y).multiply(r));switch(a.objectType){case t.TmxObjectType.basic:a.shape.parent||(a.shape.x=a.x,a.shape.y=a.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawRect(0,0,a.width*r.x,a.height*r.y),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.point:var c=.5*e.map.tileWidth;h.x-=.5*c,h.y-=.5*c,a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,1),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.tile:this.renderTilesetTile(e,a,i,h,r,p);break;case t.TmxObjectType.ellipse:h=new t.Vector2(a.x+.5*a.width,a.y+.5*a.height).multiply(r),a.shape.parent||(a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884),a.shape.graphics.beginFill(9934744,.5),a.shape.graphics.drawCircle(0,0,.5*a.width),a.shape.graphics.endFill(),p(a,h));break;case t.TmxObjectType.polygon:case t.TmxObjectType.polyline:for(var u=[],l=0;l<a.points.length;l++)u[l]=t.Vector2.multiply(a.points[l],r);if(!a.shape.parent&&u.length>0){a.shape.x=h.x,a.shape.y=h.y,i.addChild(a.shape),a.shape.graphics.clear(),a.shape.graphics.lineStyle(1,10526884);for(l=0;l<u.length;l++)a.shape.graphics.lineTo(u[l].x,u[l].y);a.shape.graphics.endFill(),p(a,h)}break;case t.TmxObjectType.text:a.textField.parent||(a.textField.x=h.x,a.textField.y=h.y,i.addChild(a.textField),a.textField.text=a.text.value,a.textField.textColor=a.text.color,a.textField.bold=null!=a.text.bold&&a.text.bold,a.textField.italic=null!=a.text.italic&&a.text.italic,a.textField.size=a.text.pixelSize,a.textField.fontFamily=a.text.fontFamily)}}}function p(e,n){i&&t.Core.debugRenderEndabled&&!e.textField.parent&&e.name&&(e.textField.text=e.name,e.textField.size=12,e.textField.fontFamily="sans-serif",e.shape?(e.textField.x=n.x+(e.shape.getBounds().width-e.textField.width)/2+e.shape.getBounds().x,e.textField.y=n.y-e.textField.height-5+e.shape.getBounds().y):(e.textField.x=n.x+(e.width-e.textField.width)/2,e.textField.y=n.y-e.textField.height-5),e.textField.background=!0,e.textField.backgroundColor=10526884,e.textField.textColor=16777215,i.addChild(e.textField))}},i.renderTilesetTile=function(t,i,n,r,o,s){var a=t.map.getTilesetForTileGid(i.tile.gid),h=a.tileRegions.get(i.tile.gid);if(n)if(a.image){i.tile.horizontalFlip&&i.tile.verticalFlip?(r.x+=a.tileHeight+(h.height*o.y-a.tileHeight),r.y-=h.width*o.x-a.tileWidth):i.tile.horizontalFlip?r.x+=a.tileWidth+(h.height*o.y-a.tileHeight):i.tile.verticalFlip?r.y+=a.tileWidth-h.width*o.x:r.y+=a.tileHeight-h.height*o.y,(c=a.image.bitmap.getTexture(""+i.tile.gid))||(c=a.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),a.image.texture=new e(c),n.addChild(a.image.texture),a.image.texture.x=r.x,a.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=-1):i.tile.verticalFlip?(a.image.texture.scaleX=o.x,a.image.texture.scaleY=-1):i.tile.horizontalFlip?(a.image.texture.scaleX=-1,a.image.texture.scaleY=o.y):(a.image.texture.scaleX=o.x,a.image.texture.scaleY=o.y),a.image.texture.anchorOffsetX=0,a.image.texture.anchorOffsetY=0,s(i,r)}else{var c,u=a.tiles.get(i.tile.gid);(c=u.image.bitmap.getTexture(""+i.tile.gid))||(c=u.image.bitmap.createTexture(""+i.tile.gid,h.x,h.y,h.width,h.height)),r.y-=i.height,u.image.texture=new e(c),n.addChild(u.image.texture),u.image.texture.width=i.width,u.image.texture.height=i.height,u.image.texture.x=r.x,u.image.texture.y=r.y,i.tile.verticalFlip&&i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=-1):i.tile.verticalFlip?(u.image.texture.scaleX=o.x,u.image.texture.scaleY=-1):i.tile.horizontalFlip?(u.image.texture.scaleX=-1,u.image.texture.scaleY=o.y):(u.image.texture.scaleX=o.x,u.image.texture.scaleY=o.y),u.image.texture.anchorOffsetX=0,u.image.texture.anchorOffsetY=0}},i.renderGroup=function(e,i,n,r,o){var s=this;e.visible&&e.layers.forEach(function(e){e instanceof t.TmxGroup&&s.renderGroup(e,i,n,r,o),e instanceof t.TmxObjectGroup&&s.renderObjectGroup(e,i,n,r,o),e instanceof t.TmxLayer&&s.renderLayer(e,i,n,r,o),e instanceof t.TmxImageLayer&&s.renderImageLayer(e,i,n,r,o)})},i.renderTile=function(i,n,r,o,s,a,h,c){var u=i.gid,l=i.tilesetTile;l&&l.animationFrames.length>0&&(u=l.currentAnimationFrameGid);var p=i.tileset.tileRegions.get(u),d=Math.floor(i.x)*s,f=Math.floor(i.y)*a;i.horizontalFlip&&i.verticalFlip?(d+=a+(p.height*o.y-a),f-=p.width*o.x-s):i.horizontalFlip?d+=s+(p.height*o.y-a):i.verticalFlip?f+=s-p.width*o.x:f+=a-p.height*o.y;var g=new t.Vector2(d,f).add(r);if(i.tileset.image){if(n){var m=i.tileset.image.bitmap.getTexture(""+u);m||(m=i.tileset.image.bitmap.createTexture(""+u,p.x,p.y,p.width,p.height)),i.tileset.image.texture=new e(m),n.addChild(i.tileset.image.texture),i.tileset.image.texture.x!=g.x&&(i.tileset.image.texture.x=g.x),i.tileset.image.texture.y!=g.y&&(i.tileset.image.texture.y=g.y),i.verticalFlip&&i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=-1):i.verticalFlip?(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=-1):i.horizontalFlip?(i.tileset.image.texture.scaleX=-1,i.tileset.image.texture.scaleY=o.y):(i.tileset.image.texture.scaleX=o.x,i.tileset.image.texture.scaleY=o.y),0!=i.tileset.image.texture.rotation&&(i.tileset.image.texture.rotation=0),0!=i.tileset.image.texture.anchorOffsetX&&(i.tileset.image.texture.anchorOffsetX=0),0!=i.tileset.image.texture.anchorOffsetY&&(i.tileset.image.texture.anchorOffsetY=0)}}else l.image.texture&&(l.image.bitmap.getTexture(u.toString())||(l.image.texture=new e(l.image.bitmap.createTexture(u.toString(),p.x,p.y,p.width,p.height)),n.addChild(l.image.texture)),l.image.texture.x=g.x,l.image.texture.y=g.y,l.image.texture.scaleX=o.x,l.image.texture.scaleY=o.y,l.image.texture.rotation=0,l.image.texture.anchorOffsetX=0,l.image.texture.anchorOffsetY=0,l.image.texture.filters=[h])},i}();t.TiledRendering=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.update=function(){this.tiles.forEach(function(t){t.updateAnimatedTiles()})},e}(t.TmxDocument);t.TmxTileset=e;var i=function(){return function(){}}();t.TmxTileOffset=i;var n=function(){return function(){}}();t.TmxTerrain=n}(es||(es={})),function(t){var e=function(){function e(){}return Object.defineProperty(e.prototype,"currentAnimationFrameGid",{get:function(){return this.animationFrames[this._animationCurrentFrame].gid+this.tileset.firstGid},enumerable:!0,configurable:!0}),e.prototype.processProperties=function(){var t;(t=this.properties.get("engine.isDestructable"))&&(this.isDestructable=Boolean(t)),(t=this.properties.get("engine:isSlope"))&&(this.isSlope=Boolean(t)),(t=this.properties.get("engine:isOneWayPlatform"))&&(this.isOneWayPlatform=Boolean(t)),(t=this.properties.get("engine:slopeTopLeft"))&&(this.slopeTopLeft=Number(t)),(t=this.properties.get("engine:slopeTopRight"))&&(this.slopeTopRight=Number(t))},e.prototype.updateAnimatedTiles=function(){0!=this.animationFrames.length&&(this._animationElapsedTime+=t.Time.deltaTime,this._animationElapsedTime>this.animationFrames[this._animationCurrentFrame].duration&&(this._animationCurrentFrame=t.MathHelper.incrementWithWrap(this._animationCurrentFrame,this.animationFrames.length),this._animationElapsedTime=0))},e}();t.TmxTilesetTile=e;var i=function(){return function(){}}();t.TmxAnimationFrame=i}(es||(es={})),function(t){var e=function(){function e(){}return e.decode=function(e,i,n){switch(n=n||"none",i=i||"none"){case"base64":var r=t.Base64Utils.decodeBase64AsArray(e,4);return"none"===n?r:t.Base64Utils.decompress(e,r,n);case"csv":return t.Base64Utils.decodeCSV(e);case"none":for(var o=[],s=0;s<e.length;s++)o[s]=+e[s].gid;return o;default:throw new Error("未定义的编码:"+i)}},e.color16ToUnit=function(t){if(!t)return 16777215;var e="0x"+t.slice(1);return parseInt(e,16)},e}();t.TmxUtils=e}(es||(es={}));var ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,i=0;i<t.length;i++){e=!1;for(var n=t.length-1;n>i;n--)if(t[n]<t[n-1]){var r=t[n];t[n]=t[n-1],t[n-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,i=1;i<e;i++){for(var n=t[i],r=i;r>0&&t[r-1]>n;r--)t[r]=t[r-1];t[r]=n}},t.binarySearch=function(t,e){for(var i=0,n=t.length,r=i+n>>1;i<n;)e<=t[r]?n=r:e>=t[r]&&(i=r+1),r=i+n>>1;return t[i]==e?i:-1},t.findElementIndex=function(t,e){for(var i=t.length,n=0;n<i;++n)if(t[n]==e)return n;return null},t.getMaxElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]>t[e]&&(e=n);return e},t.getMinElementIndex=function(t){for(var e=0,i=t.length,n=1;n<i;n++)t[n]<t[e]&&(e=n);return e},t.getUniqueAry=function(t){for(var e=[],i=[],n=t.length,r=0;r<n;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(n=e.length)-1;r>=0;--r)i.unshift(e[r]);return i},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var i=t.concat(e),n={},r=[],o=i.length,s=0;s<o;++s)n[i[s]]?n[i[s]]instanceof Object&&n[i[s]].count++:(n[i[s]]={},n[i[s]].count=0,n[i[s]].key=i[s],n[i[s]].count++);for(var a in n)2!=n[a].count&&r.unshift(n[a].key);return r},t.swap=function(t,e,i){var n=t[e];t[e]=t[i],t[i]=n},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var i=t.length;if(i!=e.length)return!1;for(;i--;)if(t[i]!=e[i])return!1;return!0},t.insert=function(t,e,i){if(!t)return null;var n=t.length;if(e>n&&(e=n),e<0&&(e=0),e==n)t.push(i);else if(0==e)t.unshift(i);else{for(var r=n-1;r>=e;r-=1)t[r+1]=t[r];t[e]=i}return i},t}();!function(t){var e=function(){function t(){}return Object.defineProperty(t,"nativeBase64",{get:function(){return"function"==typeof window.atob},enumerable:!0,configurable:!0}),t.decode=function(t){if(t=t.replace(/[^A-Za-z0-9\+\/\=]/g,""),this.nativeBase64)return window.atob(t);for(var e,i,n,r,o,s,a=[],h=0;h<t.length;)e=this._keyStr.indexOf(t.charAt(h++))<<2|(r=this._keyStr.indexOf(t.charAt(h++)))>>4,i=(15&r)<<4|(o=this._keyStr.indexOf(t.charAt(h++)))>>2,n=(3&o)<<6|(s=this._keyStr.indexOf(t.charAt(h++))),a.push(String.fromCharCode(e)),64!==o&&a.push(String.fromCharCode(i)),64!==s&&a.push(String.fromCharCode(n));return a=a.join("")},t.encode=function(t){if(t=t.replace(/\r\n/g,"\n"),!this.nativeBase64){for(var e,i,n,r,o,s,a,h=[],c=0;c<t.length;)r=(e=t.charCodeAt(c++))>>2,o=(3&e)<<4|(i=t.charCodeAt(c++))>>4,s=(15&i)<<2|(n=t.charCodeAt(c++))>>6,a=63&n,isNaN(i)?s=a=64:isNaN(n)&&(a=64),h.push(this._keyStr.charAt(r)),h.push(this._keyStr.charAt(o)),h.push(this._keyStr.charAt(s)),h.push(this._keyStr.charAt(a));return h=h.join("")}window.btoa(t)},t.decodeBase64AsArray=function(e,i){i=i||1;var n,r,o,s=t.decode(e),a=new Uint32Array(s.length/i);for(n=0,o=s.length/i;n<o;n++)for(a[n]=0,r=i-1;r>=0;--r)a[n]+=s.charCodeAt(n*i+r)<<(r<<3);return a},t.decompress=function(t,e,i){throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!")},t.decodeCSV=function(t){for(var e=t.replace("\n","").trim().split(","),i=[],n=0;n<e.length;n++)i.push(+e[n]);return i},t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",t}();t.Base64Utils=e}(es||(es={})),function(t){var e=function(){function e(e,i,n,r){if(0!=(4294967040&(e|i|n|r))){var o=t.MathHelper.clamp(e,0,255),s=t.MathHelper.clamp(i,0,255),a=t.MathHelper.clamp(n,0,255),h=t.MathHelper.clamp(r,0,255);this._packedValue=h<<24|a<<16|s<<8|o}else this._packedValue=r<<24|n<<16|i<<8|e}return Object.defineProperty(e.prototype,"b",{get:function(){return this._packedValue>>16},set:function(t){this._packedValue=4278255615&this._packedValue|t<<16},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"g",{get:function(){return this._packedValue>>8},set:function(t){this._packedValue=4294902015&this._packedValue|t<<8},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"r",{get:function(){return this._packedValue},set:function(t){this._packedValue=4294967040&this._packedValue|t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"a",{get:function(){return this._packedValue>>24},set:function(t){this._packedValue=16777215&this._packedValue|t<<24},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedValue",{get:function(){return this._packedValue},set:function(t){this._packedValue=t},enumerable:!0,configurable:!0}),e.prototype.equals=function(t){return this._packedValue==t._packedValue},e}();t.Color=e}(es||(es={})),function(t){var e=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var i=this;return void 0===e&&(e=!0),new Promise(function(n,r){var o=i.loadedAssets.get(t);o?n(o):e?RES.getResAsync(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){i.loadedAssets.set(t,e),n(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}();t.ContentManager=e}(es||(es={})),function(t){var e=function(){function t(){}return t.getColorMatrix=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];return e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255,new egret.ColorMatrixFilter(e)},t}();t.DrawUtils=e}(es||(es={})),function(t){var e=function(){function e(){}return e.oppositeEdge=function(e){switch(e){case t.Edge.bottom:return t.Edge.top;case t.Edge.top:return t.Edge.bottom;case t.Edge.left:return t.Edge.right;case t.Edge.right:return t.Edge.left}},e.isHorizontal=function(e){return e==t.Edge.right||e==t.Edge.left},e.isVertical=function(e){return e==t.Edge.top||e==t.Edge.bottom},e}();t.EdgeExt=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.func=t,this.context=e}}();t.FuncPack=e;var i=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,i,n){var r=this._messageTable.get(t);r||(r=[],this._messageTable.set(t,r)),-1!=r.findIndex(function(t){return t.func==i})&&console.warn("您试图添加相同的观察者两次"),r.push(new e(i,n))},t.prototype.removeObserver=function(t,e){var i=this._messageTable.get(t),n=i.findIndex(function(t){return t.func==e});-1!=n&&i.removeAt(n)},t.prototype.emit=function(t,e){var i=this._messageTable.get(t);if(i)for(var n=i.length-1;n>=0;n--)i[n].func.call(i[n].context,e)},t}();t.Emitter=i}(es||(es={})),function(t){!function(t){t[t.top=0]="top",t[t.bottom=1]="bottom",t[t.left=2]="left",t[t.right=3]="right"}(t.Edge||(t.Edge={}))}(es||(es={})),function(t){var e=function(){function t(){}return t.repeat=function(t,e){for(var i=[];e--;)i.push(t);return i},t}();t.Enumerable=e}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t}();t.GlobalManager=e}(es||(es={})),function(t){var e=function(){function e(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),e.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},e}();t.TouchState=e;var i=function(){function i(){}return Object.defineProperty(i,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(i,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(i,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:t.Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(i,"maxSupportedTouch",{get:function(){return t.Core._instance.stage.maxTouches},set:function(e){t.Core._instance.stage.maxTouches=e,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(i,"touchPositionDelta",{get:function(){var e=t.Vector2.subtract(this.touchPosition,this._previousTouchState.position);return e.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),e},enumerable:!0,configurable:!0}),i.initialize=function(){this._init||(this._init=!0,t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),t.Core._instance.stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},i.scaledPosition=function(e){var i=new t.Vector2(e.x-this._resolutionOffset.x,e.y-this._resolutionOffset.y);return t.Vector2.multiply(i,this.resolutionScale)},i.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new e)},i.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},i.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var i=this._gameTouchs[e];i.x=t.stageX,i.y=t.stageY}},i.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},i.setpreviousTouchState=function(t){this._previousTouchState=new e,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},i._init=!1,i._previousTouchState=new e,i._resolutionOffset=new t.Vector2,i._touchIndex=0,i._gameTouchs=[],i._resolutionScale=t.Vector2.one,i._totalTouchCount=0,i}();t.Input=i}(es||(es={}));var KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.registerKey=function(t,e,i,n){void 0===n&&(n=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(n?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:i}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),i=this.keyDownDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),i=this.keyUpDict[e];if(i){var n=i.fun,r=i.thisObj,o=i.args;n.apply(r,o)}}},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}();!function(t){var e=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}();t.ListPool=e}(es||(es={}));var THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y",this.setItem=egret.localStorage.setItem.bind(localStorage),this.getItem=egret.localStorage.getItem.bind(localStorage),this.removeItem=egret.localStorage.removeItem.bind(localStorage)}return t.prototype.lock=function(){var t=this;return new Promise(function(e,i){var n=function(){t.setItem(t._keyX,THREAD_ID),null===!t.getItem(t._keyY)&&nextTick(n),t.setItem(t._keyY,THREAD_ID),t.getItem(t._keyX)!==THREAD_ID?setTimeout(function(){t.getItem(t._keyY)===THREAD_ID?(e(),t.removeItem(t._keyY)):nextTick(n)},10):(e(),t.removeItem(t._keyY))};n()})},t}();!function(t){var e=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}();t.Pair=e}(es||(es={}));var RandomUtils=function(){function t(){}return t.randrange=function(t,e,i){if(void 0===i&&(i=1),0==i)throw new Error("step 不能为 0");var n=e-t;if(0==n)throw new Error("没有可用的范围("+t+","+e+")");n<0&&(n=t-e);var r=Math.floor((n+i-1)/i);return Math.floor(this.random()*r)*i+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var i=t.length;if(e<=0||i<e)throw new Error("采样数量不够");for(var n=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*i);r.indexOf(s)>=0;)s=Math.floor(this.random()*i);n.push(t[s]),r.push(s)}return n},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t}();!function(t){var e=function(){function e(){}return e.getSide=function(e,i){switch(i){case t.Edge.top:return e.top;case t.Edge.bottom:return e.bottom;case t.Edge.left:return e.left;case t.Edge.right:return e.right}},e.union=function(e,i){var n=new t.Rectangle(i.x,i.y,0,0),r=new t.Rectangle;return r.x=Math.min(e.x,n.x),r.y=Math.min(e.y,n.y),r.width=Math.max(e.right,n.right)-r.x,r.height=Math.max(e.bottom,r.bottom)-r.y,r},e.getHalfRect=function(e,i){switch(i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,e.height/2);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height/2,e.width,e.height/2);case t.Edge.left:return new t.Rectangle(e.x,e.y,e.width/2,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width/2,e.y,e.width/2,e.height)}},e.getRectEdgePortion=function(e,i,n){switch(void 0===n&&(n=1),i){case t.Edge.top:return new t.Rectangle(e.x,e.y,e.width,n);case t.Edge.bottom:return new t.Rectangle(e.x,e.y+e.height-n,e.width,n);case t.Edge.left:return new t.Rectangle(e.x,e.y,n,e.height);case t.Edge.right:return new t.Rectangle(e.x+e.width-n,e.y,n,e.height)}},e.expandSide=function(e,i,n){switch(n=Math.abs(n),i){case t.Edge.top:e.y-=n,e.height+=n;break;case t.Edge.bottom:e.height+=n;break;case t.Edge.left:e.x-=n,e.width+=n;break;case t.Edge.right:e.width+=n}},e.contract=function(t,e,i){t.x+=e,t.y+=i,t.width-=2*e,t.height-=2*i},e}();t.RectangleExt=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.update=function(t){this.remainder+=t;var e=Math.trunc(this.remainder);return this.remainder-=e,e},t.prototype.reset=function(){this.remainder=0},t}();t.SubpixelNumber=e}(es||(es={})),function(t){var e=function(){function e(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return e.testPointTriangle=function(e,i,n,r){return!(t.Vector2Ext.cross(t.Vector2.subtract(e,i),t.Vector2.subtract(n,i))<0)&&(!(t.Vector2Ext.cross(t.Vector2.subtract(e,n),t.Vector2.subtract(r,n))<0)&&!(t.Vector2Ext.cross(t.Vector2.subtract(e,r),t.Vector2.subtract(i,r))<0))},e.prototype.triangulate=function(i,n){void 0===n&&(n=!0);var r=i.length;this.initialize(r);for(var o=0,s=0;r>3&&o<500;){o++;var a=!0,h=i[this._triPrev[s]],c=i[s],u=i[this._triNext[s]];if(t.Vector2Ext.isTriangleCCW(h,c,u)){var l=this._triNext[this._triNext[s]];do{if(e.testPointTriangle(i[l],h,c,u)){a=!1;break}l=this._triNext[l]}while(l!=this._triPrev[s])}else a=!1;a?(this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),this._triNext[this._triPrev[s]]=this._triNext[s],this._triPrev[this._triNext[s]]=this._triPrev[s],r--,s=this._triPrev[s]):s=this._triNext[s]}this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),n||this.triangleIndices.reverse()},e.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},e}();t.Triangulator=e}(es||(es={})),function(t){var e=function(){function e(){}return e.isTriangleCCW=function(e,i,n){return this.cross(t.Vector2.subtract(i,e),t.Vector2.subtract(n,i))<0},e.cross=function(t,e){return t.y*e.x-t.x*e.y},e.perpendicular=function(e,i){return new t.Vector2(-1*(i.y-e.y),i.x-e.x)},e.normalize=function(e){var i=Math.sqrt(e.x*e.x+e.y*e.y);return i>t.MathHelper.Epsilon?e=t.Vector2.divide(e,new t.Vector2(i)):e.x=e.y=0,e},e.transformA=function(t,e,i,n,r,o){for(var s=0;s<o;s++){var a=t[e+s],h=n[r+s];h.x=a.x*i.m11+a.y*i.m21+i.m31,h.y=a.x*i.m12+a.y*i.m22+i.m32,n[r+s]=h}},e.transformR=function(e,i){var n=e.x*i.m11+e.y*i.m21+i.m31,r=e.x*i.m12+e.y*i.m22+i.m32;return new t.Vector2(n,r)},e.transform=function(t,e,i){this.transformA(t,0,e,i,0,t.length)},e.round=function(e){return new t.Vector2(Math.round(e.x),Math.round(e.y))},e}();t.Vector2Ext=e}(es||(es={}));var stopwatch,WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}();!function(t){var e,i=function(){function i(){this.clientArea=new t.Rectangle(0,0,t.Core.graphicsDevice.viewport.width,t.Core.graphicsDevice.viewport.height),this.safeArea=this.clientArea}return i.prototype.place=function(i,n,r,o){var s=new t.Rectangle(0,0,i.x,i.y);return 0!=(o&e.left)?s.x=this.clientArea.x+this.clientArea.width*n:0!=(o&e.right)?s.x=this.clientArea.x+this.clientArea.width*(1-n)-s.width:0!=(o&e.horizontalCenter)&&(s.x=this.clientArea.x+(this.clientArea.width-s.width)/2+n*this.clientArea.width),0!=(o&e.top)?s.y=this.clientArea.y+this.clientArea.height*r:0!=(o&e.bottom)?s.y=this.clientArea.y+this.clientArea.height*(1-r)-s.height:0!=(o&e.verticalCenter)&&(s.y=this.clientArea.y+(this.clientArea.height-s.height)/2+r*this.clientArea.height),s.left<this.safeArea.left&&(s.x=this.safeArea.left),s.right>this.safeArea.right&&(s.x=this.safeArea.right-s.width),s.top<this.safeArea.top&&(s.y=this.safeArea.top),s.bottom>this.safeArea.bottom&&(s.y=this.safeArea.bottom-s.height),s},i}();t.Layout=i,function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(e=t.Alignment||(t.Alignment={}))}(es||(es={})),function(t){var e,i=function(){function t(t){void 0===t&&(t=n),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(i=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var i=this.getSystemTime();this._startSystemTime=i,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=i,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),n=t};var n=Date.now}(stopwatch||(stopwatch={})),function(t){var e=function(){function e(){this.showLog=!1,this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this._logs=new Array(2);for(var e=0;e<this._logs.length;++e)this._logs[e]=new i;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*t.Core.graphicsDevice.viewport.width,t.Core.emitter.addObserver(t.CoreEvents.GraphicsDeviceReset,this.onGraphicsDeviceReset,this),this.onGraphicsDeviceReset()}return Object.defineProperty(e,"Instance",{get:function(){return this._instance||(this._instance=new e),this._instance},enumerable:!0,configurable:!0}),e.prototype.startFrame=function(){var t=this;new LockUtils(this._frameKey).lock().then(function(){t._updateCount=parseInt(egret.localStorage.getItem(t._frameKey),10),isNaN(t._updateCount)&&(t._updateCount=0);var i=t._updateCount;if(i+=1,egret.localStorage.setItem(t._frameKey,i.toString()),!(t.enabled&&1<i&&i<e.maxSampleFrames)){t._prevLog=t._logs[1&t.frameCount++],t._curLog=t._logs[1&t.frameCount];for(var n=t.stopwacth.getTime(),r=0;r<t._prevLog.bars.length;++r){for(var o=t._prevLog.bars[r],s=t._curLog.bars[r],a=0;a<o.nestCount;++a){var h=o.markerNests[a];o.markers[h].endTime=n,s.markerNests[a]=a,s.markers[a].markerId=o.markers[h].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[h].color}for(h=0;h<o.markCount;++h){var c=o.markers[h].endTime-o.markers[h].beginTime,u=o.markers[h].markerId,l=t.markers[u];l.logs[r].color=o.markers[h].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,c),l.logs[r].max=Math.min(l.logs[r].max,c),l.logs[r].avg+=c,l.logs[r].avg*=.5,l.logs[r].samples++>=e.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=c,l.logs[r].max=c,l.logs[r].avg=c,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}t.stopwacth.reset(),t.stopwacth.start()}})},e.prototype.beginMark=function(t,i,n){var r=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=e.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[n];if(o.markCount>=e.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=e.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(t);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(t,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=i,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},e.prototype.endMark=function(t,i){var n=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=e.maxBars)throw new Error("barIndex argument out of range");var r=n._curLog.bars[i];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=n._markerNameToIdMap.get(t);if(isNaN(o))throw new Error("Marker "+t+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=n.stopwacth.getTime()})},e.prototype.getAverageTime=function(t,i){if(t<0||t>=e.maxBars)throw new Error("barIndex argument out of range");var n=0,r=this._markerNameToIdMap.get(i);return r&&(n=this.markers[r].logs[t].avg),n},e.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},e.prototype.render=function(t,i){if(void 0===t&&(t=this._position),void 0===i&&(i=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var n=0,r=0;this._prevLog.bars.forEach(function(t){t.markCount>0&&(n+=e.barHeight+2*e.barPadding,r=Math.max(r,t.markers[t.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>e.autoAdjustDelay&&(this.sampleFrames=Math.min(e.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);t.y,e.barHeight}},e.prototype.onGraphicsDeviceReset=function(){var i=new t.Layout;this._position=i.place(new t.Vector2(this.width,e.barHeight),0,.01,t.Alignment.bottomCenter).location},e.maxBars=8,e.maxSamples=256,e.maxNestCall=32,e.barHeight=8,e.maxSampleFrames=4,e.logSnapDuration=120,e.barPadding=2,e.autoAdjustDelay=30,e}();t.TimeRuler=e;var i=function(){return function(){this.bars=new Array(e.maxBars),this.bars.fill(new n,0,e.maxBars)}}();t.FrameLog=i;var n=function(){return function(){this.markers=new Array(e.maxSamples),this.markCount=0,this.markerNests=new Array(e.maxNestCall),this.nestCount=0,this.markers.fill(new r,0,e.maxSamples),this.markerNests.fill(0,0,e.maxNestCall)}}();t.MarkerCollection=n;var r=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}();t.Marker=r;var o=function(){return function(t){this.logs=new Array(e.maxBars),this.name=t,this.logs.fill(new s,0,e.maxBars)}}();t.MarkerInfo=o;var s=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();t.MarkerLog=s}(es||(es={})),function(t){var e=egret.Bitmap,i=function(){function i(){this.itemsToRaster=[],this.useCache=!1,this.cacheName="",this._sprites=new Map,this.allow4096Textures=!1}return i.prototype.addTextureToPack=function(e,i){this.itemsToRaster.push(new t.TextureToPack(e,i))},i.prototype.process=function(t){return void 0===t&&(t=!1),__awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this.allow4096Textures=t,this.useCache?""==this.cacheName?(console.error("未指定缓存名称"),[2]):[4,RES.getResByUrl(this.cacheName)]:[3,2];case 1:return e.sent()?this.loadPack():this.createPack(),[3,3];case 2:this.createPack(),e.label=3;case 3:return[2]}})})},i.prototype.loadPack=function(){return __awaiter(this,void 0,void 0,function(){var t;return __generator(this,function(e){switch(e.label){case 0:return[4,RES.getResByUrl(this.cacheName)];case 1:return t=e.sent(),this.onProcessCompleted&&this.onProcessCompleted(),[2,t]}})})},i.prototype.createPack=function(){for(var i=[],n=[],r=0,o=this.itemsToRaster;r<o.length;r++){var s=o[r];i.push(new e(s.texture)),n.push(s.id)}for(var a=this.allow4096Textures?4096:2048,h=[],c=0;c<i.length;c++){if(i[c].width>a||i[c].height>a)throw new Error("一个纹理的大小比图集的大小大");h.push(new t.Rectangle(0,0,i[c].width,i[c].height))}for(;h.length>0;){var u=new egret.RenderTexture,l=new t.RectanglePacker(a,a,1);for(c=0;c<h.length;c++)l.insertRectangle(Math.floor(h[c].width),Math.floor(h[c].height),c);if(l.packRectangles(),l.rectangleCount>0){for(var p=new t.IntegerRectangle,d=[],f=[],g=[],m=[],y=0;y<l.rectangleCount;y++){p=l.getRectangle(y,p);var _=l.getRectangleId(y);u.drawToTexture(i[_],new t.Rectangle(p.x,p.y,p.width,p.height)),(D=new t.TextureAsset).x=p.x,D.y=p.y,D.width=p.width,D.height=p.height,D.name=n[_],d.push(D),f.push(h[_]),g.push(i[_].texture),m.push(n[_])}for(var v=0,b=f;v<b.length;v++){var x=b[v];h.remove(x)}for(var T=function(t){i.removeAll(function(e){return e.texture.hashCode==t.hashCode})},w=0,C=g;w<C.length;w++){T(x=C[w])}for(var S=0,P=m;S<P.length;S++){x=P[S];n.remove(x)}""!=this.cacheName&&(u.saveToFile("image/png",this.cacheName),0);for(var O=0,R=d;O<R.length;O++){var D=R[O];this._sprites.set(D.name,u)}}}this.onProcessCompleted&&this.onProcessCompleted()},i.prototype.dispose=function(){this._sprites.forEach(function(t,e){t.dispose(),RES.destroyRes(e)}),this._sprites.clear()},i.prototype.getTexture=function(t){return this._sprites.get(t)},i}();t.AssetPacker=i}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Rectangle);t.IntegerRectangle=e}(es||(es={})),function(t){var e=function(){function e(e,i,n){void 0===n&&(n=0),this._width=0,this._height=0,this._padding=8,this._packedWidth=0,this._packedHeight=0,this._insertList=[],this._insertedRectangles=[],this._freeAreas=[],this._newFreeAreas=[],this._sortableSizeStack=[],this._rectangleStack=[],this._outsideRectangle=new t.IntegerRectangle(e+1,i+1,0,0),this.reset(e,i,n)}return Object.defineProperty(e.prototype,"rectangleCount",{get:function(){return this._insertedRectangles.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedWidth",{get:function(){return this._packedWidth},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"packedHeight",{get:function(){return this._packedHeight},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"padding",{get:function(){return this._padding},enumerable:!0,configurable:!0}),e.prototype.reset=function(t,e,i){for(void 0===i&&(i=0);this._insertedRectangles.length>0;)this.freeRectangle(this._insertedRectangles.pop());for(;this._freeAreas.length>0;)this.freeRectangle(this._freeAreas.pop());for(this._width=t,this._height=e,this._packedWidth=0,this._packedHeight=0,this._freeAreas.push(this.allocateRectangle(0,0,this._width,this._height));this._insertedRectangles.length>0;)this.freeSize(this._insertList.pop());this._padding=i},e.prototype.insertRectangle=function(t,e,i){var n=this.allocateSize(t,e,i);this._insertList.push(n)},e.prototype.packRectangles=function(t){for(void 0===t&&(t=!0),t&&this._insertList.sort(function(t,e){return t.width-e.width});this._insertList.length>0;){var e=this._insertList.pop(),i=e.width,n=e.height,r=this.getFreeAreaIndex(i,n);if(r>=0){var o=this._freeAreas[r],s=this.allocateRectangle(o.x,o.y,i,n);for(s.id=e.id,this.generateNewFreeAreas(s,this._freeAreas,this._newFreeAreas);this._newFreeAreas.length>0;)this._freeAreas.push(this._newFreeAreas.pop());this._insertedRectangles.push(s),s.right>this._packedWidth&&(this._packedWidth=s.right),s.bottom>this._packedHeight&&(this._packedHeight=s.bottom)}this.freeSize(e)}return this.rectangleCount},e.prototype.getRectangle=function(t,e){var i=this._insertedRectangles[t];return e.x=i.x,e.y=i.y,e.width=i.width,e.height=i.height,e},e.prototype.getRectangleId=function(t){return this._insertedRectangles[t].id},e.prototype.generateNewFreeAreas=function(t,e,i){var n=t.x,r=t.y,o=t.right+1+this._padding,s=t.bottom+1+this._padding,a=null;0==this._padding&&(a=t);for(var h=e.length-1;h>=0;h--){var c=e[h];if(!(n>=c.right||o<=c.x||r>=c.bottom||s<=c.y)){null==a&&(a=this.allocateRectangle(t.x,t.y,t.width+this._padding,t.height+this._padding)),this.generateDividedAreas(a,c,i);var u=e.pop();h<e.length&&(e[h]=u)}}null!=a&&a!=t&&this.freeRectangle(a),this.filterSelfSubAreas(i)},e.prototype.filterSelfSubAreas=function(t){for(var e=t.length-1;e>=0;e--)for(var i=t[e],n=t.length-1;n>=0;n--)if(e!=n){var r=t[n];if(i.x>=r.x&&i.y>=r.y&&i.right<=r.right&&i.bottom<=r.bottom){this.freeRectangle(i);var o=t.pop();e<t.length&&(t[e]=o);break}}},e.prototype.generateDividedAreas=function(t,e,i){var n=0,r=e.right-t.right;r>0&&(i.push(this.allocateRectangle(t.right,e.y,r,e.height)),n++);var o=t.x-e.x;o>0&&(i.push(this.allocateRectangle(e.x,e.y,o,e.height)),n++);var s=e.bottom-t.bottom;s>0&&(i.push(this.allocateRectangle(e.x,t.bottom,e.width,s)),n++);var a=t.y-e.y;a>0&&(i.push(this.allocateRectangle(e.x,e.y,e.width,a)),n++),0==n&&(t.width<e.width||t.height<e.height)?i.push(e):this.freeRectangle(e)},e.prototype.getFreeAreaIndex=function(t,e){for(var i=this._outsideRectangle,n=-1,r=t+this._padding,o=e+this._padding,s=this._freeAreas.length-1;s>=0;s--){var a=this._freeAreas[s];if(a.x<this._packedWidth||a.y<this.packedHeight){if(a.x<i.x&&r<=a.width&&o<=a.height){if(n=s,r==a.width&&a.width<=a.height&&a.right<this._width||o==a.height&&a.height<=a.width)break;i=a}}else if(a.x<i.x&&t<=a.width&&e<=a.height){if(n=s,t==a.width&&a.width<=a.height&&a.right<this._width||e==a.height&&a.height<=a.width)break;i=a}}return n},e.prototype.allocateSize=function(e,i,n){if(this._sortableSizeStack.length>0){var r=this._sortableSizeStack.pop();return r.width=e,r.height=i,r.id=n,r}return new t.SortableSize(e,i,n)},e.prototype.freeSize=function(t){this._sortableSizeStack.push(t)},e.prototype.allocateRectangle=function(e,i,n,r){if(this._rectangleStack.length>0){var o=this._rectangleStack.pop();return o.x=e,o.y=i,o.width=n,o.height=r,o.right=e+n,o.bottom=i+r,o}return new t.IntegerRectangle(e,i,n,r)},e.prototype.freeRectangle=function(t){this._rectangleStack.push(t)},e}();t.RectanglePacker=e}(es||(es={})),function(t){var e=function(){return function(t,e,i){this.width=t,this.height=e,this.id=i}}();t.SortableSize=e}(es||(es={})),function(t){var e=function(){return function(t){this.assets=t}}();t.TextureAssets=e;var i=function(){return function(){}}();t.TextureAsset=i}(es||(es={})),function(t){var e=function(){return function(t,e){this.texture=t,this.id=e}}();t.TextureToPack=e}(es||(es={}));
\ No newline at end of file
diff --git a/source/gulpfile.js b/source/gulpfile.js
index 941e0520..99853120 100644
--- a/source/gulpfile.js
+++ b/source/gulpfile.js
@@ -25,4 +25,4 @@ gulp.task("buildDts", ["buildJs"], () => {
 gulp.task("build", ["buildDts"], () => {
     return gulp.src('bin/**/*')
         .pipe(gulp.dest('../demo/libs/framework/'))
-});
+});
\ No newline at end of file
diff --git a/source/package-lock.json b/source/package-lock.json
index 74aa62fe..457778a5 100644
--- a/source/package-lock.json
+++ b/source/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "@esengine/egret-framework",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -10,7 +10,7 @@
       "integrity": "sha512-a9gxpmdXtZEInkCSHUJDLHZVBgb1QS0jhss4cPP93EW7s+uC5bikET2twEF3KV+7rDblJcmNvTR7VJejqd2C2g==",
       "dev": true,
       "requires": {
-        "@babel/highlight": "7.9.0"
+        "@babel/highlight": "^7.8.3"
       }
     },
     "@babel/core": {
@@ -19,22 +19,22 @@
       "integrity": "sha512-FGgV2XyPoVtYDvbFXlukEWt13Afka4mBRQ2CoTsHxpgVGO6XfgtT6eI+WyjQRGGTL90IDkIVmme8riFCLZ8lUw==",
       "dev": true,
       "requires": {
-        "@babel/code-frame": "7.8.3",
-        "@babel/generator": "7.10.0",
-        "@babel/helper-module-transforms": "7.9.0",
-        "@babel/helpers": "7.10.0",
-        "@babel/parser": "7.10.0",
-        "@babel/template": "7.10.0",
-        "@babel/traverse": "7.10.0",
-        "@babel/types": "7.10.0",
-        "convert-source-map": "1.7.0",
-        "debug": "4.1.1",
-        "gensync": "1.0.0-beta.1",
-        "json5": "2.1.3",
-        "lodash": "4.17.15",
-        "resolve": "1.17.0",
-        "semver": "5.7.1",
-        "source-map": "0.5.7"
+        "@babel/code-frame": "^7.8.3",
+        "@babel/generator": "^7.10.0",
+        "@babel/helper-module-transforms": "^7.9.0",
+        "@babel/helpers": "^7.10.0",
+        "@babel/parser": "^7.10.0",
+        "@babel/template": "^7.10.0",
+        "@babel/traverse": "^7.10.0",
+        "@babel/types": "^7.10.0",
+        "convert-source-map": "^1.7.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.1",
+        "json5": "^2.1.2",
+        "lodash": "^4.17.13",
+        "resolve": "^1.3.2",
+        "semver": "^5.4.1",
+        "source-map": "^0.5.0"
       }
     },
     "@babel/generator": {
@@ -43,10 +43,10 @@
       "integrity": "sha512-ThoWCJHlgukbtCP79nAK4oLqZt5fVo70AHUni/y8Jotyg5rtJiG2FVl+iJjRNKIyl4hppqztLyAoEWcCvqyOFQ==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.10.0",
-        "jsesc": "2.5.2",
-        "lodash": "4.17.15",
-        "source-map": "0.5.7"
+        "@babel/types": "^7.10.0",
+        "jsesc": "^2.5.1",
+        "lodash": "^4.17.13",
+        "source-map": "^0.5.0"
       }
     },
     "@babel/helper-function-name": {
@@ -55,9 +55,9 @@
       "integrity": "sha512-JVcQZeXM59Cd1qanDUxv9fgJpt3NeKUaqBqUEvfmQ+BCOKq2xUgaWZW2hr0dkbyJgezYuplEoh5knmrnS68efw==",
       "dev": true,
       "requires": {
-        "@babel/helper-get-function-arity": "7.8.3",
-        "@babel/template": "7.10.0",
-        "@babel/types": "7.10.0"
+        "@babel/helper-get-function-arity": "^7.8.3",
+        "@babel/template": "^7.8.3",
+        "@babel/types": "^7.9.5"
       }
     },
     "@babel/helper-get-function-arity": {
@@ -66,7 +66,7 @@
       "integrity": "sha512-FVDR+Gd9iLjUMY1fzE2SR0IuaJToR4RkCDARVfsBBPSP53GEqSFjD8gNyxg246VUyc/ALRxFaAK8rVG7UT7xRA==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.10.0"
+        "@babel/types": "^7.8.3"
       }
     },
     "@babel/helper-member-expression-to-functions": {
@@ -75,7 +75,7 @@
       "integrity": "sha512-xKLTpbMkJcvwEsDaTfs9h0IlfUiBLPFfybxaPpPPsQDsZTRg+UKh+86oK7sctHF3OUiRQkb10oS9MXSqgyV6/g==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.10.0"
+        "@babel/types": "^7.10.0"
       }
     },
     "@babel/helper-module-imports": {
@@ -84,7 +84,7 @@
       "integrity": "sha512-R0Bx3jippsbAEtzkpZ/6FIiuzOURPcMjHp+Z6xPe6DtApDJx+w7UYyOLanZqO8+wKR9G10s/FmHXvxaMd9s6Kg==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.10.0"
+        "@babel/types": "^7.8.3"
       }
     },
     "@babel/helper-module-transforms": {
@@ -93,13 +93,13 @@
       "integrity": "sha512-0FvKyu0gpPfIQ8EkxlrAydOWROdHpBmiCiRwLkUiBGhCUPRRbVD2/tm3sFr/c/GWFrQ/ffutGUAnx7V0FzT2wA==",
       "dev": true,
       "requires": {
-        "@babel/helper-module-imports": "7.8.3",
-        "@babel/helper-replace-supers": "7.10.0",
-        "@babel/helper-simple-access": "7.8.3",
-        "@babel/helper-split-export-declaration": "7.8.3",
-        "@babel/template": "7.10.0",
-        "@babel/types": "7.10.0",
-        "lodash": "4.17.15"
+        "@babel/helper-module-imports": "^7.8.3",
+        "@babel/helper-replace-supers": "^7.8.6",
+        "@babel/helper-simple-access": "^7.8.3",
+        "@babel/helper-split-export-declaration": "^7.8.3",
+        "@babel/template": "^7.8.6",
+        "@babel/types": "^7.9.0",
+        "lodash": "^4.17.13"
       }
     },
     "@babel/helper-optimise-call-expression": {
@@ -108,7 +108,7 @@
       "integrity": "sha512-HgMd8QKA8wMJs5uK/DYKdyzJAEuGt1zyDp9wLMlMR6LitTQTHPUE+msC82ZsEDwq+U3/yHcIXIngRm9MS4IcIg==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.10.0"
+        "@babel/types": "^7.10.0"
       }
     },
     "@babel/helper-replace-supers": {
@@ -117,10 +117,10 @@
       "integrity": "sha512-erl4iVeiANf14JszXP7b69bSrz3e3+qW09pVvEmTWwzRQEOoyb1WFlYCA8d/VjVZGYW8+nGpLh7swf9CifH5wg==",
       "dev": true,
       "requires": {
-        "@babel/helper-member-expression-to-functions": "7.10.0",
-        "@babel/helper-optimise-call-expression": "7.10.0",
-        "@babel/traverse": "7.10.0",
-        "@babel/types": "7.10.0"
+        "@babel/helper-member-expression-to-functions": "^7.10.0",
+        "@babel/helper-optimise-call-expression": "^7.10.0",
+        "@babel/traverse": "^7.10.0",
+        "@babel/types": "^7.10.0"
       }
     },
     "@babel/helper-simple-access": {
@@ -129,8 +129,8 @@
       "integrity": "sha512-VNGUDjx5cCWg4vvCTR8qQ7YJYZ+HBjxOgXEl7ounz+4Sn7+LMD3CFrCTEU6/qXKbA2nKg21CwhhBzO0RpRbdCw==",
       "dev": true,
       "requires": {
-        "@babel/template": "7.10.0",
-        "@babel/types": "7.10.0"
+        "@babel/template": "^7.8.3",
+        "@babel/types": "^7.8.3"
       }
     },
     "@babel/helper-split-export-declaration": {
@@ -139,7 +139,7 @@
       "integrity": "sha512-3x3yOeyBhW851hroze7ElzdkeRXQYQbFIb7gLK1WQYsw2GWDay5gAJNw1sWJ0VFP6z5J1whqeXH/WCdCjZv6dA==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.10.0"
+        "@babel/types": "^7.8.3"
       }
     },
     "@babel/helper-validator-identifier": {
@@ -154,9 +154,9 @@
       "integrity": "sha512-lQtFJoDZAGf/t2PgR6Z59Q2MwjvOGGsxZ0BAlsrgyDhKuMbe63EfbQmVmcLfyTBj8J4UtiadQimcotvYVg/kVQ==",
       "dev": true,
       "requires": {
-        "@babel/template": "7.10.0",
-        "@babel/traverse": "7.10.0",
-        "@babel/types": "7.10.0"
+        "@babel/template": "^7.10.0",
+        "@babel/traverse": "^7.10.0",
+        "@babel/types": "^7.10.0"
       }
     },
     "@babel/highlight": {
@@ -165,9 +165,9 @@
       "integrity": "sha512-lJZPilxX7Op3Nv/2cvFdnlepPXDxi29wxteT57Q965oc5R9v86ztx0jfxVrTcBk8C2kcPkkDa2Z4T3ZsPPVWsQ==",
       "dev": true,
       "requires": {
-        "@babel/helper-validator-identifier": "7.9.5",
-        "chalk": "2.4.2",
-        "js-tokens": "4.0.0"
+        "@babel/helper-validator-identifier": "^7.9.0",
+        "chalk": "^2.0.0",
+        "js-tokens": "^4.0.0"
       }
     },
     "@babel/parser": {
@@ -182,9 +182,9 @@
       "integrity": "sha512-aMLEQn5tcG49LEWrsEwxiRTdaJmvLem3+JMCMSeCy2TILau0IDVyWdm/18ACx7XOCady64FLt6KkHy28tkDQHQ==",
       "dev": true,
       "requires": {
-        "@babel/code-frame": "7.8.3",
-        "@babel/parser": "7.10.0",
-        "@babel/types": "7.10.0"
+        "@babel/code-frame": "^7.8.3",
+        "@babel/parser": "^7.10.0",
+        "@babel/types": "^7.10.0"
       }
     },
     "@babel/traverse": {
@@ -193,15 +193,15 @@
       "integrity": "sha512-NZsFleMaLF1zX3NxbtXI/JCs2RPOdpGru6UBdGsfhdsDsP+kFF+h2QQJnMJglxk0kc69YmMFs4A44OJY0tKo5g==",
       "dev": true,
       "requires": {
-        "@babel/code-frame": "7.8.3",
-        "@babel/generator": "7.10.0",
-        "@babel/helper-function-name": "7.9.5",
-        "@babel/helper-split-export-declaration": "7.8.3",
-        "@babel/parser": "7.10.0",
-        "@babel/types": "7.10.0",
-        "debug": "4.1.1",
-        "globals": "11.12.0",
-        "lodash": "4.17.15"
+        "@babel/code-frame": "^7.8.3",
+        "@babel/generator": "^7.10.0",
+        "@babel/helper-function-name": "^7.9.5",
+        "@babel/helper-split-export-declaration": "^7.8.3",
+        "@babel/parser": "^7.10.0",
+        "@babel/types": "^7.10.0",
+        "debug": "^4.1.0",
+        "globals": "^11.1.0",
+        "lodash": "^4.17.13"
       }
     },
     "@babel/types": {
@@ -210,9 +210,9 @@
       "integrity": "sha512-t41W8yWFyQFPOAAvPvjyRhejcLGnJTA3iRpFcDbEKwVJ3UnHQePFzLk8GagTsucJlImyNwrGikGsYURrWbQG8w==",
       "dev": true,
       "requires": {
-        "@babel/helper-validator-identifier": "7.9.5",
-        "lodash": "4.17.15",
-        "to-fast-properties": "2.0.0"
+        "@babel/helper-validator-identifier": "^7.9.5",
+        "lodash": "^4.17.13",
+        "to-fast-properties": "^2.0.0"
       }
     },
     "JSONStream": {
@@ -221,8 +221,8 @@
       "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==",
       "dev": true,
       "requires": {
-        "jsonparse": "1.3.1",
-        "through": "2.3.8"
+        "jsonparse": "^1.2.0",
+        "through": ">=2.2.7 <3"
       }
     },
     "acorn": {
@@ -237,9 +237,9 @@
       "integrity": "sha512-8mt+fslDufLYntIoPAaIMUe/lrbrehIiwmR3t2k9LljIzoigEPF27eLk2hy8zSGzmR/ogr7zbRKINMo1u0yh5A==",
       "dev": true,
       "requires": {
-        "acorn": "7.2.0",
-        "acorn-walk": "7.1.1",
-        "xtend": "4.0.2"
+        "acorn": "^7.0.0",
+        "acorn-walk": "^7.0.0",
+        "xtend": "^4.0.2"
       }
     },
     "acorn-walk": {
@@ -254,7 +254,7 @@
       "integrity": "sha512-SFKX67auSNoVR38N3L+nvsPjOE0bybKTYbkf5tRvushrAPQ9V75huw0ZxBkKVeRU9kqH3d6HA4xTckbwZ4ixmA==",
       "dev": true,
       "requires": {
-        "ansi-wrap": "0.1.0"
+        "ansi-wrap": "^0.1.0"
       }
     },
     "ansi-cyan": {
@@ -296,7 +296,7 @@
       "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
       "dev": true,
       "requires": {
-        "color-convert": "1.9.3"
+        "color-convert": "^1.9.0"
       }
     },
     "ansi-wrap": {
@@ -317,8 +317,8 @@
       "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==",
       "dev": true,
       "requires": {
-        "micromatch": "3.1.10",
-        "normalize-path": "2.1.1"
+        "micromatch": "^3.1.4",
+        "normalize-path": "^2.1.1"
       }
     },
     "archy": {
@@ -381,9 +381,9 @@
       "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==",
       "dev": true,
       "requires": {
-        "bn.js": "4.11.9",
-        "inherits": "2.0.4",
-        "minimalistic-assert": "1.0.1"
+        "bn.js": "^4.0.0",
+        "inherits": "^2.0.1",
+        "minimalistic-assert": "^1.0.0"
       },
       "dependencies": {
         "bn.js": {
@@ -400,7 +400,7 @@
       "integrity": "sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==",
       "dev": true,
       "requires": {
-        "object-assign": "4.1.1",
+        "object-assign": "^4.1.1",
         "util": "0.10.3"
       },
       "dependencies": {
@@ -445,9 +445,9 @@
       "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=",
       "dev": true,
       "requires": {
-        "chalk": "1.1.3",
-        "esutils": "2.0.3",
-        "js-tokens": "3.0.2"
+        "chalk": "^1.1.3",
+        "esutils": "^2.0.2",
+        "js-tokens": "^3.0.2"
       },
       "dependencies": {
         "ansi-styles": {
@@ -462,11 +462,11 @@
           "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
           "dev": true,
           "requires": {
-            "ansi-styles": "2.2.1",
-            "escape-string-regexp": "1.0.5",
-            "has-ansi": "2.0.0",
-            "strip-ansi": "3.0.1",
-            "supports-color": "2.0.0"
+            "ansi-styles": "^2.2.1",
+            "escape-string-regexp": "^1.0.2",
+            "has-ansi": "^2.0.0",
+            "strip-ansi": "^3.0.0",
+            "supports-color": "^2.0.0"
           }
         },
         "js-tokens": {
@@ -489,10 +489,10 @@
       "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=",
       "dev": true,
       "requires": {
-        "babel-helper-hoist-variables": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-traverse": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-helper-hoist-variables": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-traverse": "^6.24.1",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-helper-define-map": {
@@ -501,10 +501,10 @@
       "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=",
       "dev": true,
       "requires": {
-        "babel-helper-function-name": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0",
-        "lodash": "4.17.15"
+        "babel-helper-function-name": "^6.24.1",
+        "babel-runtime": "^6.26.0",
+        "babel-types": "^6.26.0",
+        "lodash": "^4.17.4"
       }
     },
     "babel-helper-function-name": {
@@ -513,11 +513,11 @@
       "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=",
       "dev": true,
       "requires": {
-        "babel-helper-get-function-arity": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0",
-        "babel-traverse": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-helper-get-function-arity": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1",
+        "babel-traverse": "^6.24.1",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-helper-get-function-arity": {
@@ -526,8 +526,8 @@
       "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-helper-hoist-variables": {
@@ -536,8 +536,8 @@
       "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-helper-optimise-call-expression": {
@@ -546,8 +546,8 @@
       "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-helper-regex": {
@@ -556,9 +556,9 @@
       "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0",
-        "lodash": "4.17.15"
+        "babel-runtime": "^6.26.0",
+        "babel-types": "^6.26.0",
+        "lodash": "^4.17.4"
       }
     },
     "babel-helper-replace-supers": {
@@ -567,12 +567,12 @@
       "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=",
       "dev": true,
       "requires": {
-        "babel-helper-optimise-call-expression": "6.24.1",
-        "babel-messages": "6.23.0",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0",
-        "babel-traverse": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-helper-optimise-call-expression": "^6.24.1",
+        "babel-messages": "^6.23.0",
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1",
+        "babel-traverse": "^6.24.1",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-messages": {
@@ -581,7 +581,7 @@
       "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-check-es2015-constants": {
@@ -590,7 +590,7 @@
       "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-arrow-functions": {
@@ -599,7 +599,7 @@
       "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-block-scoped-functions": {
@@ -608,7 +608,7 @@
       "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-block-scoping": {
@@ -617,11 +617,11 @@
       "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0",
-        "babel-traverse": "6.26.0",
-        "babel-types": "6.26.0",
-        "lodash": "4.17.15"
+        "babel-runtime": "^6.26.0",
+        "babel-template": "^6.26.0",
+        "babel-traverse": "^6.26.0",
+        "babel-types": "^6.26.0",
+        "lodash": "^4.17.4"
       }
     },
     "babel-plugin-transform-es2015-classes": {
@@ -630,15 +630,15 @@
       "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=",
       "dev": true,
       "requires": {
-        "babel-helper-define-map": "6.26.0",
-        "babel-helper-function-name": "6.24.1",
-        "babel-helper-optimise-call-expression": "6.24.1",
-        "babel-helper-replace-supers": "6.24.1",
-        "babel-messages": "6.23.0",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0",
-        "babel-traverse": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-helper-define-map": "^6.24.1",
+        "babel-helper-function-name": "^6.24.1",
+        "babel-helper-optimise-call-expression": "^6.24.1",
+        "babel-helper-replace-supers": "^6.24.1",
+        "babel-messages": "^6.23.0",
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1",
+        "babel-traverse": "^6.24.1",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-computed-properties": {
@@ -647,8 +647,8 @@
       "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0"
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-destructuring": {
@@ -657,7 +657,7 @@
       "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-duplicate-keys": {
@@ -666,8 +666,8 @@
       "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-for-of": {
@@ -676,7 +676,7 @@
       "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-function-name": {
@@ -685,9 +685,9 @@
       "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=",
       "dev": true,
       "requires": {
-        "babel-helper-function-name": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-helper-function-name": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-literals": {
@@ -696,7 +696,7 @@
       "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-modules-amd": {
@@ -705,9 +705,9 @@
       "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=",
       "dev": true,
       "requires": {
-        "babel-plugin-transform-es2015-modules-commonjs": "6.26.2",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0"
+        "babel-plugin-transform-es2015-modules-commonjs": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-modules-commonjs": {
@@ -716,10 +716,10 @@
       "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==",
       "dev": true,
       "requires": {
-        "babel-plugin-transform-strict-mode": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-plugin-transform-strict-mode": "^6.24.1",
+        "babel-runtime": "^6.26.0",
+        "babel-template": "^6.26.0",
+        "babel-types": "^6.26.0"
       }
     },
     "babel-plugin-transform-es2015-modules-systemjs": {
@@ -728,9 +728,9 @@
       "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=",
       "dev": true,
       "requires": {
-        "babel-helper-hoist-variables": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0"
+        "babel-helper-hoist-variables": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-modules-umd": {
@@ -739,9 +739,9 @@
       "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=",
       "dev": true,
       "requires": {
-        "babel-plugin-transform-es2015-modules-amd": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0"
+        "babel-plugin-transform-es2015-modules-amd": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-object-super": {
@@ -750,8 +750,8 @@
       "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=",
       "dev": true,
       "requires": {
-        "babel-helper-replace-supers": "6.24.1",
-        "babel-runtime": "6.26.0"
+        "babel-helper-replace-supers": "^6.24.1",
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-parameters": {
@@ -760,12 +760,12 @@
       "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=",
       "dev": true,
       "requires": {
-        "babel-helper-call-delegate": "6.24.1",
-        "babel-helper-get-function-arity": "6.24.1",
-        "babel-runtime": "6.26.0",
-        "babel-template": "6.26.0",
-        "babel-traverse": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-helper-call-delegate": "^6.24.1",
+        "babel-helper-get-function-arity": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-template": "^6.24.1",
+        "babel-traverse": "^6.24.1",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-shorthand-properties": {
@@ -774,8 +774,8 @@
       "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-spread": {
@@ -784,7 +784,7 @@
       "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-sticky-regex": {
@@ -793,9 +793,9 @@
       "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=",
       "dev": true,
       "requires": {
-        "babel-helper-regex": "6.26.0",
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-helper-regex": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-plugin-transform-es2015-template-literals": {
@@ -804,7 +804,7 @@
       "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-typeof-symbol": {
@@ -813,7 +813,7 @@
       "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0"
+        "babel-runtime": "^6.22.0"
       }
     },
     "babel-plugin-transform-es2015-unicode-regex": {
@@ -822,9 +822,9 @@
       "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=",
       "dev": true,
       "requires": {
-        "babel-helper-regex": "6.26.0",
-        "babel-runtime": "6.26.0",
-        "regexpu-core": "2.0.0"
+        "babel-helper-regex": "^6.24.1",
+        "babel-runtime": "^6.22.0",
+        "regexpu-core": "^2.0.0"
       }
     },
     "babel-plugin-transform-regenerator": {
@@ -833,7 +833,7 @@
       "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=",
       "dev": true,
       "requires": {
-        "regenerator-transform": "0.10.1"
+        "regenerator-transform": "^0.10.0"
       }
     },
     "babel-plugin-transform-strict-mode": {
@@ -842,8 +842,8 @@
       "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0"
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.24.1"
       }
     },
     "babel-preset-es2015": {
@@ -852,30 +852,30 @@
       "integrity": "sha1-1EBQ1rwsn+6nAqrzjXJ6AhBTiTk=",
       "dev": true,
       "requires": {
-        "babel-plugin-check-es2015-constants": "6.22.0",
-        "babel-plugin-transform-es2015-arrow-functions": "6.22.0",
-        "babel-plugin-transform-es2015-block-scoped-functions": "6.22.0",
-        "babel-plugin-transform-es2015-block-scoping": "6.26.0",
-        "babel-plugin-transform-es2015-classes": "6.24.1",
-        "babel-plugin-transform-es2015-computed-properties": "6.24.1",
-        "babel-plugin-transform-es2015-destructuring": "6.23.0",
-        "babel-plugin-transform-es2015-duplicate-keys": "6.24.1",
-        "babel-plugin-transform-es2015-for-of": "6.23.0",
-        "babel-plugin-transform-es2015-function-name": "6.24.1",
-        "babel-plugin-transform-es2015-literals": "6.22.0",
-        "babel-plugin-transform-es2015-modules-amd": "6.24.1",
-        "babel-plugin-transform-es2015-modules-commonjs": "6.26.2",
-        "babel-plugin-transform-es2015-modules-systemjs": "6.24.1",
-        "babel-plugin-transform-es2015-modules-umd": "6.24.1",
-        "babel-plugin-transform-es2015-object-super": "6.24.1",
-        "babel-plugin-transform-es2015-parameters": "6.24.1",
-        "babel-plugin-transform-es2015-shorthand-properties": "6.24.1",
-        "babel-plugin-transform-es2015-spread": "6.22.0",
-        "babel-plugin-transform-es2015-sticky-regex": "6.24.1",
-        "babel-plugin-transform-es2015-template-literals": "6.22.0",
-        "babel-plugin-transform-es2015-typeof-symbol": "6.23.0",
-        "babel-plugin-transform-es2015-unicode-regex": "6.24.1",
-        "babel-plugin-transform-regenerator": "6.26.0"
+        "babel-plugin-check-es2015-constants": "^6.22.0",
+        "babel-plugin-transform-es2015-arrow-functions": "^6.22.0",
+        "babel-plugin-transform-es2015-block-scoped-functions": "^6.22.0",
+        "babel-plugin-transform-es2015-block-scoping": "^6.24.1",
+        "babel-plugin-transform-es2015-classes": "^6.24.1",
+        "babel-plugin-transform-es2015-computed-properties": "^6.24.1",
+        "babel-plugin-transform-es2015-destructuring": "^6.22.0",
+        "babel-plugin-transform-es2015-duplicate-keys": "^6.24.1",
+        "babel-plugin-transform-es2015-for-of": "^6.22.0",
+        "babel-plugin-transform-es2015-function-name": "^6.24.1",
+        "babel-plugin-transform-es2015-literals": "^6.22.0",
+        "babel-plugin-transform-es2015-modules-amd": "^6.24.1",
+        "babel-plugin-transform-es2015-modules-commonjs": "^6.24.1",
+        "babel-plugin-transform-es2015-modules-systemjs": "^6.24.1",
+        "babel-plugin-transform-es2015-modules-umd": "^6.24.1",
+        "babel-plugin-transform-es2015-object-super": "^6.24.1",
+        "babel-plugin-transform-es2015-parameters": "^6.24.1",
+        "babel-plugin-transform-es2015-shorthand-properties": "^6.24.1",
+        "babel-plugin-transform-es2015-spread": "^6.22.0",
+        "babel-plugin-transform-es2015-sticky-regex": "^6.24.1",
+        "babel-plugin-transform-es2015-template-literals": "^6.22.0",
+        "babel-plugin-transform-es2015-typeof-symbol": "^6.22.0",
+        "babel-plugin-transform-es2015-unicode-regex": "^6.24.1",
+        "babel-plugin-transform-regenerator": "^6.24.1"
       }
     },
     "babel-runtime": {
@@ -884,8 +884,8 @@
       "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=",
       "dev": true,
       "requires": {
-        "core-js": "2.6.11",
-        "regenerator-runtime": "0.11.1"
+        "core-js": "^2.4.0",
+        "regenerator-runtime": "^0.11.0"
       }
     },
     "babel-template": {
@@ -894,11 +894,11 @@
       "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-traverse": "6.26.0",
-        "babel-types": "6.26.0",
-        "babylon": "6.18.0",
-        "lodash": "4.17.15"
+        "babel-runtime": "^6.26.0",
+        "babel-traverse": "^6.26.0",
+        "babel-types": "^6.26.0",
+        "babylon": "^6.18.0",
+        "lodash": "^4.17.4"
       }
     },
     "babel-traverse": {
@@ -907,15 +907,15 @@
       "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=",
       "dev": true,
       "requires": {
-        "babel-code-frame": "6.26.0",
-        "babel-messages": "6.23.0",
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0",
-        "babylon": "6.18.0",
-        "debug": "2.6.9",
-        "globals": "9.18.0",
-        "invariant": "2.2.4",
-        "lodash": "4.17.15"
+        "babel-code-frame": "^6.26.0",
+        "babel-messages": "^6.23.0",
+        "babel-runtime": "^6.26.0",
+        "babel-types": "^6.26.0",
+        "babylon": "^6.18.0",
+        "debug": "^2.6.8",
+        "globals": "^9.18.0",
+        "invariant": "^2.2.2",
+        "lodash": "^4.17.4"
       },
       "dependencies": {
         "debug": {
@@ -947,10 +947,10 @@
       "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "esutils": "2.0.3",
-        "lodash": "4.17.15",
-        "to-fast-properties": "1.0.3"
+        "babel-runtime": "^6.26.0",
+        "esutils": "^2.0.2",
+        "lodash": "^4.17.4",
+        "to-fast-properties": "^1.0.3"
       },
       "dependencies": {
         "to-fast-properties": {
@@ -979,13 +979,13 @@
       "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==",
       "dev": true,
       "requires": {
-        "cache-base": "1.0.1",
-        "class-utils": "0.3.6",
-        "component-emitter": "1.3.0",
-        "define-property": "1.0.0",
-        "isobject": "3.0.1",
-        "mixin-deep": "1.3.2",
-        "pascalcase": "0.1.1"
+        "cache-base": "^1.0.1",
+        "class-utils": "^0.3.5",
+        "component-emitter": "^1.2.1",
+        "define-property": "^1.0.0",
+        "isobject": "^3.0.1",
+        "mixin-deep": "^1.2.0",
+        "pascalcase": "^0.1.1"
       },
       "dependencies": {
         "define-property": {
@@ -994,7 +994,7 @@
           "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "1.0.2"
+            "is-descriptor": "^1.0.0"
           }
         },
         "is-accessor-descriptor": {
@@ -1003,7 +1003,7 @@
           "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-data-descriptor": {
@@ -1012,7 +1012,7 @@
           "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-descriptor": {
@@ -1021,9 +1021,9 @@
           "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
           "dev": true,
           "requires": {
-            "is-accessor-descriptor": "1.0.0",
-            "is-data-descriptor": "1.0.0",
-            "kind-of": "6.0.3"
+            "is-accessor-descriptor": "^1.0.0",
+            "is-data-descriptor": "^1.0.0",
+            "kind-of": "^6.0.2"
           }
         }
       }
@@ -1068,7 +1068,7 @@
       "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
       "dev": true,
       "requires": {
-        "balanced-match": "1.0.0",
+        "balanced-match": "^1.0.0",
         "concat-map": "0.0.1"
       }
     },
@@ -1078,16 +1078,16 @@
       "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==",
       "dev": true,
       "requires": {
-        "arr-flatten": "1.1.0",
-        "array-unique": "0.3.2",
-        "extend-shallow": "2.0.1",
-        "fill-range": "4.0.0",
-        "isobject": "3.0.1",
-        "repeat-element": "1.1.3",
-        "snapdragon": "0.8.2",
-        "snapdragon-node": "2.1.1",
-        "split-string": "3.1.0",
-        "to-regex": "3.0.2"
+        "arr-flatten": "^1.1.0",
+        "array-unique": "^0.3.2",
+        "extend-shallow": "^2.0.1",
+        "fill-range": "^4.0.0",
+        "isobject": "^3.0.1",
+        "repeat-element": "^1.1.2",
+        "snapdragon": "^0.8.1",
+        "snapdragon-node": "^2.0.1",
+        "split-string": "^3.0.2",
+        "to-regex": "^3.0.1"
       },
       "dependencies": {
         "extend-shallow": {
@@ -1096,7 +1096,7 @@
           "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
           "dev": true,
           "requires": {
-            "is-extendable": "0.1.1"
+            "is-extendable": "^0.1.0"
           }
         }
       }
@@ -1113,12 +1113,12 @@
       "integrity": "sha512-erYug8XoqzU3IfcU8fUgyHqyOXqIE4tUTTQ+7mqUjQlvnXkOO6OlT9c/ZoJVHYoAaqGxr09CN53G7XIsO4KtWA==",
       "dev": true,
       "requires": {
-        "JSONStream": "1.3.5",
-        "combine-source-map": "0.8.0",
-        "defined": "1.0.0",
-        "safe-buffer": "5.1.2",
-        "through2": "2.0.5",
-        "umd": "3.0.3"
+        "JSONStream": "^1.0.3",
+        "combine-source-map": "~0.8.0",
+        "defined": "^1.0.0",
+        "safe-buffer": "^5.1.1",
+        "through2": "^2.0.0",
+        "umd": "^3.0.0"
       }
     },
     "browser-resolve": {
@@ -1144,53 +1144,53 @@
       "integrity": "sha512-gKfOsNQv/toWz+60nSPfYzuwSEdzvV2WdxrVPUbPD/qui44rAkB3t3muNtmmGYHqrG56FGwX9SUEQmzNLAeS7g==",
       "dev": true,
       "requires": {
-        "JSONStream": "1.3.5",
-        "assert": "1.5.0",
-        "browser-pack": "6.1.0",
-        "browser-resolve": "1.11.3",
-        "browserify-zlib": "0.2.0",
-        "buffer": "5.6.0",
-        "cached-path-relative": "1.0.2",
-        "concat-stream": "1.5.2",
-        "console-browserify": "1.2.0",
-        "constants-browserify": "1.0.0",
-        "crypto-browserify": "3.12.0",
-        "defined": "1.0.0",
-        "deps-sort": "2.0.1",
-        "domain-browser": "1.1.7",
-        "duplexer2": "0.1.4",
-        "events": "1.1.1",
-        "glob": "7.1.6",
-        "has": "1.0.3",
-        "htmlescape": "1.1.1",
-        "https-browserify": "1.0.0",
-        "inherits": "2.0.4",
-        "insert-module-globals": "7.2.0",
-        "labeled-stream-splicer": "2.0.2",
-        "module-deps": "4.1.1",
-        "os-browserify": "0.3.0",
-        "parents": "1.0.1",
-        "path-browserify": "0.0.1",
-        "process": "0.11.10",
-        "punycode": "1.4.1",
-        "querystring-es3": "0.2.1",
-        "read-only-stream": "2.0.0",
-        "readable-stream": "2.3.7",
-        "resolve": "1.17.0",
-        "shasum": "1.0.2",
-        "shell-quote": "1.7.2",
-        "stream-browserify": "2.0.2",
-        "stream-http": "2.8.3",
-        "string_decoder": "1.0.3",
-        "subarg": "1.0.0",
-        "syntax-error": "1.4.0",
-        "through2": "2.0.5",
-        "timers-browserify": "1.4.2",
-        "tty-browserify": "0.0.1",
-        "url": "0.11.0",
-        "util": "0.10.4",
-        "vm-browserify": "0.0.4",
-        "xtend": "4.0.2"
+        "JSONStream": "^1.0.3",
+        "assert": "^1.4.0",
+        "browser-pack": "^6.0.1",
+        "browser-resolve": "^1.11.0",
+        "browserify-zlib": "~0.2.0",
+        "buffer": "^5.0.2",
+        "cached-path-relative": "^1.0.0",
+        "concat-stream": "~1.5.1",
+        "console-browserify": "^1.1.0",
+        "constants-browserify": "~1.0.0",
+        "crypto-browserify": "^3.0.0",
+        "defined": "^1.0.0",
+        "deps-sort": "^2.0.0",
+        "domain-browser": "~1.1.0",
+        "duplexer2": "~0.1.2",
+        "events": "~1.1.0",
+        "glob": "^7.1.0",
+        "has": "^1.0.0",
+        "htmlescape": "^1.1.0",
+        "https-browserify": "^1.0.0",
+        "inherits": "~2.0.1",
+        "insert-module-globals": "^7.0.0",
+        "labeled-stream-splicer": "^2.0.0",
+        "module-deps": "^4.0.8",
+        "os-browserify": "~0.3.0",
+        "parents": "^1.0.1",
+        "path-browserify": "~0.0.0",
+        "process": "~0.11.0",
+        "punycode": "^1.3.2",
+        "querystring-es3": "~0.2.0",
+        "read-only-stream": "^2.0.0",
+        "readable-stream": "^2.0.2",
+        "resolve": "^1.1.4",
+        "shasum": "^1.0.0",
+        "shell-quote": "^1.6.1",
+        "stream-browserify": "^2.0.0",
+        "stream-http": "^2.0.0",
+        "string_decoder": "~1.0.0",
+        "subarg": "^1.0.0",
+        "syntax-error": "^1.1.1",
+        "through2": "^2.0.0",
+        "timers-browserify": "^1.0.1",
+        "tty-browserify": "~0.0.0",
+        "url": "~0.11.0",
+        "util": "~0.10.1",
+        "vm-browserify": "~0.0.1",
+        "xtend": "^4.0.0"
       }
     },
     "browserify-aes": {
@@ -1199,12 +1199,12 @@
       "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==",
       "dev": true,
       "requires": {
-        "buffer-xor": "1.0.3",
-        "cipher-base": "1.0.4",
-        "create-hash": "1.2.0",
-        "evp_bytestokey": "1.0.3",
-        "inherits": "2.0.4",
-        "safe-buffer": "5.1.2"
+        "buffer-xor": "^1.0.3",
+        "cipher-base": "^1.0.0",
+        "create-hash": "^1.1.0",
+        "evp_bytestokey": "^1.0.3",
+        "inherits": "^2.0.1",
+        "safe-buffer": "^5.0.1"
       }
     },
     "browserify-cipher": {
@@ -1213,9 +1213,9 @@
       "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==",
       "dev": true,
       "requires": {
-        "browserify-aes": "1.2.0",
-        "browserify-des": "1.0.2",
-        "evp_bytestokey": "1.0.3"
+        "browserify-aes": "^1.0.4",
+        "browserify-des": "^1.0.0",
+        "evp_bytestokey": "^1.0.0"
       }
     },
     "browserify-des": {
@@ -1224,10 +1224,10 @@
       "integrity": "sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==",
       "dev": true,
       "requires": {
-        "cipher-base": "1.0.4",
-        "des.js": "1.0.1",
-        "inherits": "2.0.4",
-        "safe-buffer": "5.1.2"
+        "cipher-base": "^1.0.1",
+        "des.js": "^1.0.0",
+        "inherits": "^2.0.1",
+        "safe-buffer": "^5.1.2"
       }
     },
     "browserify-rsa": {
@@ -1236,8 +1236,8 @@
       "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=",
       "dev": true,
       "requires": {
-        "bn.js": "4.11.9",
-        "randombytes": "2.1.0"
+        "bn.js": "^4.1.0",
+        "randombytes": "^2.0.1"
       },
       "dependencies": {
         "bn.js": {
@@ -1254,15 +1254,15 @@
       "integrity": "sha512-hEZC1KEeYuoHRqhGhTy6gWrpJA3ZDjFWv0DE61643ZnOXAKJb3u7yWcrU0mMc9SwAqK1n7myPGndkp0dFG7NFA==",
       "dev": true,
       "requires": {
-        "bn.js": "5.1.2",
-        "browserify-rsa": "4.0.1",
-        "create-hash": "1.2.0",
-        "create-hmac": "1.1.7",
-        "elliptic": "6.5.2",
-        "inherits": "2.0.4",
-        "parse-asn1": "5.1.5",
-        "readable-stream": "3.6.0",
-        "safe-buffer": "5.2.1"
+        "bn.js": "^5.1.1",
+        "browserify-rsa": "^4.0.1",
+        "create-hash": "^1.2.0",
+        "create-hmac": "^1.1.7",
+        "elliptic": "^6.5.2",
+        "inherits": "^2.0.4",
+        "parse-asn1": "^5.1.5",
+        "readable-stream": "^3.6.0",
+        "safe-buffer": "^5.2.0"
       },
       "dependencies": {
         "readable-stream": {
@@ -1271,9 +1271,9 @@
           "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
           "dev": true,
           "requires": {
-            "inherits": "2.0.4",
-            "string_decoder": "1.3.0",
-            "util-deprecate": "1.0.2"
+            "inherits": "^2.0.3",
+            "string_decoder": "^1.1.1",
+            "util-deprecate": "^1.0.1"
           }
         },
         "safe-buffer": {
@@ -1288,7 +1288,7 @@
           "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
           "dev": true,
           "requires": {
-            "safe-buffer": "5.2.1"
+            "safe-buffer": "~5.2.0"
           }
         }
       }
@@ -1299,7 +1299,7 @@
       "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==",
       "dev": true,
       "requires": {
-        "pako": "1.0.11"
+        "pako": "~1.0.5"
       }
     },
     "buffer": {
@@ -1308,8 +1308,8 @@
       "integrity": "sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw==",
       "dev": true,
       "requires": {
-        "base64-js": "1.3.1",
-        "ieee754": "1.1.13"
+        "base64-js": "^1.0.2",
+        "ieee754": "^1.1.4"
       }
     },
     "buffer-from": {
@@ -1336,15 +1336,15 @@
       "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==",
       "dev": true,
       "requires": {
-        "collection-visit": "1.0.0",
-        "component-emitter": "1.3.0",
-        "get-value": "2.0.6",
-        "has-value": "1.0.0",
-        "isobject": "3.0.1",
-        "set-value": "2.0.1",
-        "to-object-path": "0.3.0",
-        "union-value": "1.0.1",
-        "unset-value": "1.0.0"
+        "collection-visit": "^1.0.0",
+        "component-emitter": "^1.2.1",
+        "get-value": "^2.0.6",
+        "has-value": "^1.0.0",
+        "isobject": "^3.0.1",
+        "set-value": "^2.0.0",
+        "to-object-path": "^0.3.0",
+        "union-value": "^1.0.0",
+        "unset-value": "^1.0.0"
       }
     },
     "cached-path-relative": {
@@ -1359,9 +1359,9 @@
       "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
       "dev": true,
       "requires": {
-        "ansi-styles": "3.2.1",
-        "escape-string-regexp": "1.0.5",
-        "supports-color": "5.5.0"
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
       }
     },
     "chokidar": {
@@ -1370,18 +1370,18 @@
       "integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==",
       "dev": true,
       "requires": {
-        "anymatch": "2.0.0",
-        "async-each": "1.0.3",
-        "braces": "2.3.2",
-        "fsevents": "1.2.13",
-        "glob-parent": "3.1.0",
-        "inherits": "2.0.4",
-        "is-binary-path": "1.0.1",
-        "is-glob": "4.0.1",
-        "normalize-path": "3.0.0",
-        "path-is-absolute": "1.0.1",
-        "readdirp": "2.2.1",
-        "upath": "1.2.0"
+        "anymatch": "^2.0.0",
+        "async-each": "^1.0.1",
+        "braces": "^2.3.2",
+        "fsevents": "^1.2.7",
+        "glob-parent": "^3.1.0",
+        "inherits": "^2.0.3",
+        "is-binary-path": "^1.0.0",
+        "is-glob": "^4.0.0",
+        "normalize-path": "^3.0.0",
+        "path-is-absolute": "^1.0.0",
+        "readdirp": "^2.2.1",
+        "upath": "^1.1.1"
       },
       "dependencies": {
         "is-glob": {
@@ -1390,7 +1390,7 @@
           "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
           "dev": true,
           "requires": {
-            "is-extglob": "2.1.1"
+            "is-extglob": "^2.1.1"
           }
         },
         "normalize-path": {
@@ -1407,8 +1407,8 @@
       "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "safe-buffer": "5.1.2"
+        "inherits": "^2.0.1",
+        "safe-buffer": "^5.0.1"
       }
     },
     "class-utils": {
@@ -1417,10 +1417,10 @@
       "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==",
       "dev": true,
       "requires": {
-        "arr-union": "3.1.0",
-        "define-property": "0.2.5",
-        "isobject": "3.0.1",
-        "static-extend": "0.1.2"
+        "arr-union": "^3.1.0",
+        "define-property": "^0.2.5",
+        "isobject": "^3.0.0",
+        "static-extend": "^0.1.1"
       },
       "dependencies": {
         "define-property": {
@@ -1429,7 +1429,7 @@
           "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "0.1.6"
+            "is-descriptor": "^0.1.0"
           }
         }
       }
@@ -1458,9 +1458,9 @@
       "integrity": "sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "process-nextick-args": "2.0.1",
-        "readable-stream": "2.3.7"
+        "inherits": "^2.0.1",
+        "process-nextick-args": "^2.0.0",
+        "readable-stream": "^2.3.5"
       }
     },
     "collection-visit": {
@@ -1469,8 +1469,8 @@
       "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=",
       "dev": true,
       "requires": {
-        "map-visit": "1.0.0",
-        "object-visit": "1.0.1"
+        "map-visit": "^1.0.0",
+        "object-visit": "^1.0.0"
       }
     },
     "color-convert": {
@@ -1500,10 +1500,10 @@
       "integrity": "sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=",
       "dev": true,
       "requires": {
-        "convert-source-map": "1.1.3",
-        "inline-source-map": "0.6.2",
-        "lodash.memoize": "3.0.4",
-        "source-map": "0.5.7"
+        "convert-source-map": "~1.1.0",
+        "inline-source-map": "~0.6.0",
+        "lodash.memoize": "~3.0.3",
+        "source-map": "~0.5.3"
       },
       "dependencies": {
         "convert-source-map": {
@@ -1538,9 +1538,9 @@
       "integrity": "sha1-cIl4Yk2FavQaWnQd790mHadSwmY=",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "readable-stream": "2.0.6",
-        "typedarray": "0.0.6"
+        "inherits": "~2.0.1",
+        "readable-stream": "~2.0.0",
+        "typedarray": "~0.0.5"
       },
       "dependencies": {
         "process-nextick-args": {
@@ -1555,12 +1555,12 @@
           "integrity": "sha1-j5A0HmilPMySh4jaz80Rs265t44=",
           "dev": true,
           "requires": {
-            "core-util-is": "1.0.2",
-            "inherits": "2.0.4",
-            "isarray": "1.0.0",
-            "process-nextick-args": "1.0.7",
-            "string_decoder": "0.10.31",
-            "util-deprecate": "1.0.2"
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.1",
+            "isarray": "~1.0.0",
+            "process-nextick-args": "~1.0.6",
+            "string_decoder": "~0.10.x",
+            "util-deprecate": "~1.0.1"
           }
         },
         "string_decoder": {
@@ -1577,7 +1577,7 @@
       "integrity": "sha512-4gEjHJFT9e+2W/77h/DS5SGUgwDaOwprX8L/gl5+3ixnzkVJJsZWDSelmN3Oilw3LNDZjZV0yqH1hLG3k6nghg==",
       "dev": true,
       "requires": {
-        "source-map": "0.6.1"
+        "source-map": "^0.6.1"
       },
       "dependencies": {
         "source-map": {
@@ -1606,7 +1606,7 @@
       "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==",
       "dev": true,
       "requires": {
-        "safe-buffer": "5.1.2"
+        "safe-buffer": "~5.1.1"
       }
     },
     "copy-descriptor": {
@@ -1633,8 +1633,8 @@
       "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==",
       "dev": true,
       "requires": {
-        "bn.js": "4.11.9",
-        "elliptic": "6.5.2"
+        "bn.js": "^4.1.0",
+        "elliptic": "^6.0.0"
       },
       "dependencies": {
         "bn.js": {
@@ -1651,11 +1651,11 @@
       "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==",
       "dev": true,
       "requires": {
-        "cipher-base": "1.0.4",
-        "inherits": "2.0.4",
-        "md5.js": "1.3.5",
-        "ripemd160": "2.0.2",
-        "sha.js": "2.4.11"
+        "cipher-base": "^1.0.1",
+        "inherits": "^2.0.1",
+        "md5.js": "^1.3.4",
+        "ripemd160": "^2.0.1",
+        "sha.js": "^2.4.0"
       }
     },
     "create-hmac": {
@@ -1664,12 +1664,12 @@
       "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==",
       "dev": true,
       "requires": {
-        "cipher-base": "1.0.4",
-        "create-hash": "1.2.0",
-        "inherits": "2.0.4",
-        "ripemd160": "2.0.2",
-        "safe-buffer": "5.1.2",
-        "sha.js": "2.4.11"
+        "cipher-base": "^1.0.3",
+        "create-hash": "^1.1.0",
+        "inherits": "^2.0.1",
+        "ripemd160": "^2.0.0",
+        "safe-buffer": "^5.0.1",
+        "sha.js": "^2.4.8"
       }
     },
     "crypto-browserify": {
@@ -1678,17 +1678,17 @@
       "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==",
       "dev": true,
       "requires": {
-        "browserify-cipher": "1.0.1",
-        "browserify-sign": "4.2.0",
-        "create-ecdh": "4.0.3",
-        "create-hash": "1.2.0",
-        "create-hmac": "1.1.7",
-        "diffie-hellman": "5.0.3",
-        "inherits": "2.0.4",
-        "pbkdf2": "3.0.17",
-        "public-encrypt": "4.0.3",
-        "randombytes": "2.1.0",
-        "randomfill": "1.0.4"
+        "browserify-cipher": "^1.0.0",
+        "browserify-sign": "^4.0.0",
+        "create-ecdh": "^4.0.0",
+        "create-hash": "^1.1.0",
+        "create-hmac": "^1.1.0",
+        "diffie-hellman": "^5.0.0",
+        "inherits": "^2.0.1",
+        "pbkdf2": "^3.0.3",
+        "public-encrypt": "^4.0.0",
+        "randombytes": "^2.0.0",
+        "randomfill": "^1.0.3"
       }
     },
     "dash-ast": {
@@ -1709,7 +1709,7 @@
       "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==",
       "dev": true,
       "requires": {
-        "ms": "2.1.2"
+        "ms": "^2.1.1"
       }
     },
     "decode-uri-component": {
@@ -1724,7 +1724,7 @@
       "integrity": "sha1-xlYFHpgX2f8I7YgUd/P+QBnz730=",
       "dev": true,
       "requires": {
-        "clone": "1.0.4"
+        "clone": "^1.0.2"
       }
     },
     "define-property": {
@@ -1733,8 +1733,8 @@
       "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
       "dev": true,
       "requires": {
-        "is-descriptor": "1.0.2",
-        "isobject": "3.0.1"
+        "is-descriptor": "^1.0.2",
+        "isobject": "^3.0.1"
       },
       "dependencies": {
         "is-accessor-descriptor": {
@@ -1743,7 +1743,7 @@
           "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-data-descriptor": {
@@ -1752,7 +1752,7 @@
           "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-descriptor": {
@@ -1761,9 +1761,9 @@
           "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
           "dev": true,
           "requires": {
-            "is-accessor-descriptor": "1.0.0",
-            "is-data-descriptor": "1.0.0",
-            "kind-of": "6.0.3"
+            "is-accessor-descriptor": "^1.0.0",
+            "is-data-descriptor": "^1.0.0",
+            "kind-of": "^6.0.2"
           }
         }
       }
@@ -1786,10 +1786,10 @@
       "integrity": "sha512-1orqXQr5po+3KI6kQb9A4jnXT1PBwggGl2d7Sq2xsnOeI9GPcE/tGcF9UiSZtZBM7MukY4cAh7MemS6tZYipfw==",
       "dev": true,
       "requires": {
-        "JSONStream": "1.3.5",
-        "shasum-object": "1.0.0",
-        "subarg": "1.0.0",
-        "through2": "2.0.5"
+        "JSONStream": "^1.0.3",
+        "shasum-object": "^1.0.0",
+        "subarg": "^1.0.0",
+        "through2": "^2.0.0"
       }
     },
     "des.js": {
@@ -1798,8 +1798,8 @@
       "integrity": "sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "minimalistic-assert": "1.0.1"
+        "inherits": "^2.0.1",
+        "minimalistic-assert": "^1.0.0"
       }
     },
     "detect-file": {
@@ -1814,8 +1814,8 @@
       "integrity": "sha512-H6PmeeUcZloWtdt4DAkFyzFL94arpHr3NOwwmVILFiy+9Qd4JTxxXrzfyGk/lmct2qVGBwTSwSXagqu2BxmWig==",
       "dev": true,
       "requires": {
-        "acorn": "5.7.4",
-        "defined": "1.0.0"
+        "acorn": "^5.2.1",
+        "defined": "^1.0.0"
       },
       "dependencies": {
         "acorn": {
@@ -1832,9 +1832,9 @@
       "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==",
       "dev": true,
       "requires": {
-        "bn.js": "4.11.9",
-        "miller-rabin": "4.0.1",
-        "randombytes": "2.1.0"
+        "bn.js": "^4.1.0",
+        "miller-rabin": "^4.0.0",
+        "randombytes": "^2.0.0"
       },
       "dependencies": {
         "bn.js": {
@@ -1863,7 +1863,7 @@
       "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=",
       "dev": true,
       "requires": {
-        "readable-stream": "2.3.7"
+        "readable-stream": "^2.0.2"
       }
     },
     "duplexify": {
@@ -1872,10 +1872,10 @@
       "integrity": "sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==",
       "dev": true,
       "requires": {
-        "end-of-stream": "1.4.4",
-        "inherits": "2.0.4",
-        "readable-stream": "2.3.7",
-        "stream-shift": "1.0.1"
+        "end-of-stream": "^1.0.0",
+        "inherits": "^2.0.1",
+        "readable-stream": "^2.0.0",
+        "stream-shift": "^1.0.0"
       },
       "dependencies": {
         "end-of-stream": {
@@ -1884,7 +1884,7 @@
           "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
           "dev": true,
           "requires": {
-            "once": "1.4.0"
+            "once": "^1.4.0"
           }
         }
       }
@@ -1895,13 +1895,13 @@
       "integrity": "sha512-f4x70okzZbIQl/NSRLkI/+tteV/9WqL98zx+SQ69KbXxmVrmjwsNUPn/gYJJ0sHvEak24cZgHIPegRePAtA/xw==",
       "dev": true,
       "requires": {
-        "bn.js": "4.11.9",
-        "brorand": "1.1.0",
-        "hash.js": "1.1.7",
-        "hmac-drbg": "1.0.1",
-        "inherits": "2.0.4",
-        "minimalistic-assert": "1.0.1",
-        "minimalistic-crypto-utils": "1.0.1"
+        "bn.js": "^4.4.0",
+        "brorand": "^1.0.1",
+        "hash.js": "^1.0.0",
+        "hmac-drbg": "^1.0.0",
+        "inherits": "^2.0.1",
+        "minimalistic-assert": "^1.0.0",
+        "minimalistic-crypto-utils": "^1.0.0"
       },
       "dependencies": {
         "bn.js": {
@@ -1918,7 +1918,7 @@
       "integrity": "sha1-jhdyBsPICDfYVjLouTWd/osvbq8=",
       "dev": true,
       "requires": {
-        "once": "1.3.3"
+        "once": "~1.3.0"
       },
       "dependencies": {
         "once": {
@@ -1927,7 +1927,7 @@
           "integrity": "sha1-suJhVXzkwxTsgwTz+oJmPkKXyiA=",
           "dev": true,
           "requires": {
-            "wrappy": "1.0.2"
+            "wrappy": "1"
           }
         }
       }
@@ -1938,7 +1938,7 @@
       "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
       "dev": true,
       "requires": {
-        "is-arrayish": "0.2.1"
+        "is-arrayish": "^0.2.1"
       }
     },
     "escape-string-regexp": {
@@ -1959,13 +1959,13 @@
       "integrity": "sha1-SrTJoPWlTbkzi0w02Gv86PSzVXE=",
       "dev": true,
       "requires": {
-        "duplexer": "0.1.1",
-        "from": "0.1.7",
-        "map-stream": "0.1.0",
+        "duplexer": "~0.1.1",
+        "from": "~0",
+        "map-stream": "~0.1.0",
         "pause-stream": "0.0.11",
-        "split": "0.3.3",
-        "stream-combiner": "0.0.4",
-        "through": "2.3.8"
+        "split": "0.3",
+        "stream-combiner": "~0.0.4",
+        "through": "~2.3.1"
       }
     },
     "events": {
@@ -1980,8 +1980,8 @@
       "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==",
       "dev": true,
       "requires": {
-        "md5.js": "1.3.5",
-        "safe-buffer": "5.1.2"
+        "md5.js": "^1.3.4",
+        "safe-buffer": "^5.1.1"
       }
     },
     "expand-brackets": {
@@ -1990,13 +1990,13 @@
       "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=",
       "dev": true,
       "requires": {
-        "debug": "2.6.9",
-        "define-property": "0.2.5",
-        "extend-shallow": "2.0.1",
-        "posix-character-classes": "0.1.1",
-        "regex-not": "1.0.2",
-        "snapdragon": "0.8.2",
-        "to-regex": "3.0.2"
+        "debug": "^2.3.3",
+        "define-property": "^0.2.5",
+        "extend-shallow": "^2.0.1",
+        "posix-character-classes": "^0.1.0",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.1"
       },
       "dependencies": {
         "debug": {
@@ -2014,7 +2014,7 @@
           "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "0.1.6"
+            "is-descriptor": "^0.1.0"
           }
         },
         "extend-shallow": {
@@ -2023,7 +2023,7 @@
           "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
           "dev": true,
           "requires": {
-            "is-extendable": "0.1.1"
+            "is-extendable": "^0.1.0"
           }
         },
         "ms": {
@@ -2040,7 +2040,7 @@
       "integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=",
       "dev": true,
       "requires": {
-        "fill-range": "2.2.4"
+        "fill-range": "^2.1.0"
       },
       "dependencies": {
         "fill-range": {
@@ -2049,11 +2049,11 @@
           "integrity": "sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==",
           "dev": true,
           "requires": {
-            "is-number": "2.1.0",
-            "isobject": "2.1.0",
-            "randomatic": "3.1.1",
-            "repeat-element": "1.1.3",
-            "repeat-string": "1.6.1"
+            "is-number": "^2.1.0",
+            "isobject": "^2.0.0",
+            "randomatic": "^3.0.0",
+            "repeat-element": "^1.1.2",
+            "repeat-string": "^1.5.2"
           }
         },
         "is-number": {
@@ -2062,7 +2062,7 @@
           "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=",
           "dev": true,
           "requires": {
-            "kind-of": "3.2.2"
+            "kind-of": "^3.0.2"
           }
         },
         "isobject": {
@@ -2080,7 +2080,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -2091,7 +2091,7 @@
       "integrity": "sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=",
       "dev": true,
       "requires": {
-        "homedir-polyfill": "1.0.3"
+        "homedir-polyfill": "^1.0.1"
       }
     },
     "extend": {
@@ -2106,8 +2106,8 @@
       "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
       "dev": true,
       "requires": {
-        "assign-symbols": "1.0.0",
-        "is-extendable": "1.0.1"
+        "assign-symbols": "^1.0.0",
+        "is-extendable": "^1.0.1"
       },
       "dependencies": {
         "is-extendable": {
@@ -2116,7 +2116,7 @@
           "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
           "dev": true,
           "requires": {
-            "is-plain-object": "2.0.4"
+            "is-plain-object": "^2.0.4"
           }
         }
       }
@@ -2127,14 +2127,14 @@
       "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==",
       "dev": true,
       "requires": {
-        "array-unique": "0.3.2",
-        "define-property": "1.0.0",
-        "expand-brackets": "2.1.4",
-        "extend-shallow": "2.0.1",
-        "fragment-cache": "0.2.1",
-        "regex-not": "1.0.2",
-        "snapdragon": "0.8.2",
-        "to-regex": "3.0.2"
+        "array-unique": "^0.3.2",
+        "define-property": "^1.0.0",
+        "expand-brackets": "^2.1.4",
+        "extend-shallow": "^2.0.1",
+        "fragment-cache": "^0.2.1",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.1"
       },
       "dependencies": {
         "define-property": {
@@ -2143,7 +2143,7 @@
           "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "1.0.2"
+            "is-descriptor": "^1.0.0"
           }
         },
         "extend-shallow": {
@@ -2152,7 +2152,7 @@
           "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
           "dev": true,
           "requires": {
-            "is-extendable": "0.1.1"
+            "is-extendable": "^0.1.0"
           }
         },
         "is-accessor-descriptor": {
@@ -2161,7 +2161,7 @@
           "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-data-descriptor": {
@@ -2170,7 +2170,7 @@
           "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-descriptor": {
@@ -2179,9 +2179,9 @@
           "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
           "dev": true,
           "requires": {
-            "is-accessor-descriptor": "1.0.0",
-            "is-data-descriptor": "1.0.0",
-            "kind-of": "6.0.3"
+            "is-accessor-descriptor": "^1.0.0",
+            "is-data-descriptor": "^1.0.0",
+            "kind-of": "^6.0.2"
           }
         }
       }
@@ -2192,10 +2192,10 @@
       "integrity": "sha512-k9oEhlyc0FrVh25qYuSELjr8oxsCoc4/LEZfg2iJJrfEk/tZL9bCoJE47gqAvI2m/AUjluCS4+3I0eTx8n3AEw==",
       "dev": true,
       "requires": {
-        "ansi-gray": "0.1.1",
-        "color-support": "1.1.3",
-        "parse-node-version": "1.0.1",
-        "time-stamp": "1.1.0"
+        "ansi-gray": "^0.1.1",
+        "color-support": "^1.1.3",
+        "parse-node-version": "^1.0.0",
+        "time-stamp": "^1.0.0"
       }
     },
     "fast-safe-stringify": {
@@ -2223,10 +2223,10 @@
       "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=",
       "dev": true,
       "requires": {
-        "extend-shallow": "2.0.1",
-        "is-number": "3.0.0",
-        "repeat-string": "1.6.1",
-        "to-regex-range": "2.1.1"
+        "extend-shallow": "^2.0.1",
+        "is-number": "^3.0.0",
+        "repeat-string": "^1.6.1",
+        "to-regex-range": "^2.1.0"
       },
       "dependencies": {
         "extend-shallow": {
@@ -2235,7 +2235,7 @@
           "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
           "dev": true,
           "requires": {
-            "is-extendable": "0.1.1"
+            "is-extendable": "^0.1.0"
           }
         }
       }
@@ -2252,10 +2252,10 @@
       "integrity": "sha1-kyaxSIwi0aYIhlCoaQGy2akKLLw=",
       "dev": true,
       "requires": {
-        "detect-file": "1.0.0",
-        "is-glob": "3.1.0",
-        "micromatch": "3.1.10",
-        "resolve-dir": "1.0.1"
+        "detect-file": "^1.0.0",
+        "is-glob": "^3.1.0",
+        "micromatch": "^3.0.4",
+        "resolve-dir": "^1.0.1"
       }
     },
     "fined": {
@@ -2264,11 +2264,11 @@
       "integrity": "sha512-ZYDqPLGxDkDhDZBjZBb+oD1+j0rA4E0pXY50eplAAOPg2N/gUBSSk5IM1/QhPfyVo19lJ+CvXpqfvk+b2p/8Ng==",
       "dev": true,
       "requires": {
-        "expand-tilde": "2.0.2",
-        "is-plain-object": "2.0.4",
-        "object.defaults": "1.1.0",
-        "object.pick": "1.3.0",
-        "parse-filepath": "1.0.2"
+        "expand-tilde": "^2.0.2",
+        "is-plain-object": "^2.0.3",
+        "object.defaults": "^1.1.0",
+        "object.pick": "^1.2.0",
+        "parse-filepath": "^1.0.1"
       }
     },
     "first-chunk-stream": {
@@ -2295,7 +2295,7 @@
       "integrity": "sha1-xjMy9BXO3EsE2/5wz4NklMU8tEs=",
       "dev": true,
       "requires": {
-        "for-in": "1.0.2"
+        "for-in": "^1.0.1"
       }
     },
     "fragment-cache": {
@@ -2304,7 +2304,7 @@
       "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=",
       "dev": true,
       "requires": {
-        "map-cache": "0.2.2"
+        "map-cache": "^0.2.2"
       }
     },
     "from": {
@@ -2326,8 +2326,8 @@
       "dev": true,
       "optional": true,
       "requires": {
-        "bindings": "1.5.0",
-        "nan": "2.14.1"
+        "bindings": "^1.5.0",
+        "nan": "^2.12.1"
       }
     },
     "function-bind": {
@@ -2342,7 +2342,7 @@
       "integrity": "sha1-QLcJU30k0dRXZ9takIaJ3+aaxE8=",
       "dev": true,
       "requires": {
-        "globule": "0.1.0"
+        "globule": "~0.1.0"
       }
     },
     "gensync": {
@@ -2369,12 +2369,12 @@
       "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
       "dev": true,
       "requires": {
-        "fs.realpath": "1.0.0",
-        "inflight": "1.0.6",
-        "inherits": "2.0.4",
-        "minimatch": "3.0.4",
-        "once": "1.4.0",
-        "path-is-absolute": "1.0.1"
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
       }
     },
     "glob-base": {
@@ -2383,8 +2383,8 @@
       "integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=",
       "dev": true,
       "requires": {
-        "glob-parent": "2.0.0",
-        "is-glob": "2.0.1"
+        "glob-parent": "^2.0.0",
+        "is-glob": "^2.0.0"
       },
       "dependencies": {
         "glob-parent": {
@@ -2393,7 +2393,7 @@
           "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
           "dev": true,
           "requires": {
-            "is-glob": "2.0.1"
+            "is-glob": "^2.0.0"
           }
         },
         "is-extglob": {
@@ -2408,7 +2408,7 @@
           "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
           "dev": true,
           "requires": {
-            "is-extglob": "1.0.0"
+            "is-extglob": "^1.0.0"
           }
         }
       }
@@ -2419,8 +2419,8 @@
       "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=",
       "dev": true,
       "requires": {
-        "is-glob": "3.1.0",
-        "path-dirname": "1.0.2"
+        "is-glob": "^3.1.0",
+        "path-dirname": "^1.0.0"
       }
     },
     "glob-stream": {
@@ -2429,12 +2429,12 @@
       "integrity": "sha1-kXCl8St5Awb9/lmPMT+PeVT9FDs=",
       "dev": true,
       "requires": {
-        "glob": "4.5.3",
-        "glob2base": "0.0.12",
-        "minimatch": "2.0.10",
-        "ordered-read-streams": "0.1.0",
-        "through2": "0.6.5",
-        "unique-stream": "1.0.0"
+        "glob": "^4.3.1",
+        "glob2base": "^0.0.12",
+        "minimatch": "^2.0.1",
+        "ordered-read-streams": "^0.1.0",
+        "through2": "^0.6.1",
+        "unique-stream": "^1.0.0"
       },
       "dependencies": {
         "glob": {
@@ -2443,10 +2443,10 @@
           "integrity": "sha1-xstz0yJsHv7wTePFbQEvAzd+4V8=",
           "dev": true,
           "requires": {
-            "inflight": "1.0.6",
-            "inherits": "2.0.4",
-            "minimatch": "2.0.10",
-            "once": "1.4.0"
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "^2.0.1",
+            "once": "^1.3.0"
           }
         },
         "isarray": {
@@ -2461,7 +2461,7 @@
           "integrity": "sha1-jQh8OcazjAAbl/ynzm0OHoCvusc=",
           "dev": true,
           "requires": {
-            "brace-expansion": "1.1.11"
+            "brace-expansion": "^1.0.0"
           }
         },
         "readable-stream": {
@@ -2470,10 +2470,10 @@
           "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=",
           "dev": true,
           "requires": {
-            "core-util-is": "1.0.2",
-            "inherits": "2.0.4",
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.1",
             "isarray": "0.0.1",
-            "string_decoder": "0.10.31"
+            "string_decoder": "~0.10.x"
           }
         },
         "string_decoder": {
@@ -2488,8 +2488,8 @@
           "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=",
           "dev": true,
           "requires": {
-            "readable-stream": "1.0.34",
-            "xtend": "4.0.2"
+            "readable-stream": ">=1.0.33-1 <1.1.0-0",
+            "xtend": ">=4.0.0 <4.1.0-0"
           }
         }
       }
@@ -2500,7 +2500,7 @@
       "integrity": "sha1-uVtKjfdLOcgymLDAXJeLTZo7cQs=",
       "dev": true,
       "requires": {
-        "gaze": "0.5.2"
+        "gaze": "^0.5.1"
       }
     },
     "glob2base": {
@@ -2509,7 +2509,7 @@
       "integrity": "sha1-nUGbPijxLoOjYhZKJ3BVkiycDVY=",
       "dev": true,
       "requires": {
-        "find-index": "0.1.1"
+        "find-index": "^0.1.1"
       }
     },
     "global-modules": {
@@ -2518,9 +2518,9 @@
       "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==",
       "dev": true,
       "requires": {
-        "global-prefix": "1.0.2",
-        "is-windows": "1.0.2",
-        "resolve-dir": "1.0.1"
+        "global-prefix": "^1.0.1",
+        "is-windows": "^1.0.1",
+        "resolve-dir": "^1.0.0"
       }
     },
     "global-prefix": {
@@ -2529,11 +2529,11 @@
       "integrity": "sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=",
       "dev": true,
       "requires": {
-        "expand-tilde": "2.0.2",
-        "homedir-polyfill": "1.0.3",
-        "ini": "1.3.5",
-        "is-windows": "1.0.2",
-        "which": "1.3.1"
+        "expand-tilde": "^2.0.2",
+        "homedir-polyfill": "^1.0.1",
+        "ini": "^1.3.4",
+        "is-windows": "^1.0.1",
+        "which": "^1.2.14"
       }
     },
     "globals": {
@@ -2548,9 +2548,9 @@
       "integrity": "sha1-2cjt3h2nnRJaFRt5UzuXhnY0auU=",
       "dev": true,
       "requires": {
-        "glob": "3.1.21",
-        "lodash": "1.0.2",
-        "minimatch": "0.2.14"
+        "glob": "~3.1.21",
+        "lodash": "~1.0.1",
+        "minimatch": "~0.2.11"
       },
       "dependencies": {
         "glob": {
@@ -2559,9 +2559,9 @@
           "integrity": "sha1-0p4KBV3qUTj00H7UDomC6DwgZs0=",
           "dev": true,
           "requires": {
-            "graceful-fs": "1.2.3",
-            "inherits": "1.0.2",
-            "minimatch": "0.2.14"
+            "graceful-fs": "~1.2.0",
+            "inherits": "1",
+            "minimatch": "~0.2.11"
           }
         },
         "graceful-fs": {
@@ -2588,8 +2588,8 @@
           "integrity": "sha1-x054BXT2PG+aCQ6Q775u9TpqdWo=",
           "dev": true,
           "requires": {
-            "lru-cache": "2.7.3",
-            "sigmund": "1.0.1"
+            "lru-cache": "2",
+            "sigmund": "~1.0.0"
           }
         }
       }
@@ -2600,7 +2600,7 @@
       "integrity": "sha512-5mwUoSuBk44Y4EshyiqcH95ZntbDdTQqA3QYSrxmzj28Ai0vXBGMH1ApSANH14j2sIRtqCEyg6PfsuP7ElOEDA==",
       "dev": true,
       "requires": {
-        "sparkles": "1.0.1"
+        "sparkles": "^1.0.0"
       }
     },
     "graceful-fs": {
@@ -2609,7 +2609,7 @@
       "integrity": "sha512-J55gaCS4iTTJfTXIxSVw3EMQckcqkpdRv3IR7gu6sq0+tbC363Zx6KH/SEwXASK9JRbhyZmVjJEVJIOxYsB3Qg==",
       "dev": true,
       "requires": {
-        "natives": "1.1.6"
+        "natives": "^1.1.3"
       }
     },
     "gulp": {
@@ -2618,19 +2618,19 @@
       "integrity": "sha1-VxzkWSjdQK9lFPxAEYZgFsE4RbQ=",
       "dev": true,
       "requires": {
-        "archy": "1.0.0",
-        "chalk": "1.1.3",
-        "deprecated": "0.0.1",
-        "gulp-util": "3.0.8",
-        "interpret": "1.2.0",
-        "liftoff": "2.5.0",
-        "minimist": "1.2.5",
-        "orchestrator": "0.3.8",
-        "pretty-hrtime": "1.0.3",
-        "semver": "4.3.6",
-        "tildify": "1.2.0",
-        "v8flags": "2.1.1",
-        "vinyl-fs": "0.3.14"
+        "archy": "^1.0.0",
+        "chalk": "^1.0.0",
+        "deprecated": "^0.0.1",
+        "gulp-util": "^3.0.0",
+        "interpret": "^1.0.0",
+        "liftoff": "^2.1.0",
+        "minimist": "^1.1.0",
+        "orchestrator": "^0.3.0",
+        "pretty-hrtime": "^1.0.0",
+        "semver": "^4.1.0",
+        "tildify": "^1.0.0",
+        "v8flags": "^2.0.2",
+        "vinyl-fs": "^0.3.0"
       },
       "dependencies": {
         "ansi-styles": {
@@ -2645,11 +2645,11 @@
           "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
           "dev": true,
           "requires": {
-            "ansi-styles": "2.2.1",
-            "escape-string-regexp": "1.0.5",
-            "has-ansi": "2.0.0",
-            "strip-ansi": "3.0.1",
-            "supports-color": "2.0.0"
+            "ansi-styles": "^2.2.1",
+            "escape-string-regexp": "^1.0.2",
+            "has-ansi": "^2.0.0",
+            "strip-ansi": "^3.0.0",
+            "supports-color": "^2.0.0"
           }
         },
         "semver": {
@@ -2672,10 +2672,10 @@
       "integrity": "sha512-oomaIqDXxFkg7lbpBou/gnUkX51/Y/M2ZfSjL2hdqXTAlSWZcgZtd2o0cOH0r/eE8LWD0+Q/PsLsr2DKOoqToQ==",
       "dev": true,
       "requires": {
-        "plugin-error": "1.0.1",
-        "replace-ext": "1.0.1",
-        "through2": "2.0.5",
-        "vinyl-sourcemaps-apply": "0.2.1"
+        "plugin-error": "^1.0.1",
+        "replace-ext": "^1.0.0",
+        "through2": "^2.0.0",
+        "vinyl-sourcemaps-apply": "^0.2.0"
       },
       "dependencies": {
         "replace-ext": {
@@ -2692,9 +2692,9 @@
       "integrity": "sha1-Yz0WyV2IUEYorQJmVmPO5aR5M1M=",
       "dev": true,
       "requires": {
-        "concat-with-sourcemaps": "1.1.0",
-        "through2": "2.0.5",
-        "vinyl": "2.2.0"
+        "concat-with-sourcemaps": "^1.0.0",
+        "through2": "^2.0.0",
+        "vinyl": "^2.0.0"
       },
       "dependencies": {
         "clone": {
@@ -2721,12 +2721,12 @@
           "integrity": "sha512-MBH+yP0kC/GQ5GwBqrTPTzEfiiLjta7hTtvQtbxBgTeSXsmKQRQecjibMbxIXzVT3Y9KJK+drOz1/k+vsu8Nkg==",
           "dev": true,
           "requires": {
-            "clone": "2.1.2",
-            "clone-buffer": "1.0.0",
-            "clone-stats": "1.0.0",
-            "cloneable-readable": "1.1.3",
-            "remove-trailing-separator": "1.1.0",
-            "replace-ext": "1.0.1"
+            "clone": "^2.1.1",
+            "clone-buffer": "^1.0.0",
+            "clone-stats": "^1.0.0",
+            "cloneable-readable": "^1.0.0",
+            "remove-trailing-separator": "^1.0.1",
+            "replace-ext": "^1.0.0"
           }
         }
       }
@@ -2738,7 +2738,7 @@
       "dev": true,
       "requires": {
         "event-stream": "3.3.4",
-        "plugin-error": "1.0.1"
+        "plugin-error": "^1.0.1"
       }
     },
     "gulp-minify": {
@@ -2747,12 +2747,12 @@
       "integrity": "sha512-ixF41aYg+NQikI8hpoHdEclYcQkbGdXQu1CBdHaU7Epg8H6e8d2jWXw1+rBPgYwl/XpKgjHj7NI6gkhoSNSSAg==",
       "dev": true,
       "requires": {
-        "ansi-colors": "1.1.0",
-        "minimatch": "3.0.4",
-        "plugin-error": "0.1.2",
-        "terser": "3.17.0",
-        "through2": "2.0.5",
-        "vinyl": "2.2.0"
+        "ansi-colors": "^1.0.1",
+        "minimatch": "^3.0.2",
+        "plugin-error": "^0.1.2",
+        "terser": "^3.7.6",
+        "through2": "^2.0.3",
+        "vinyl": "^2.1.0"
       },
       "dependencies": {
         "arr-diff": {
@@ -2761,8 +2761,8 @@
           "integrity": "sha1-aHwydYFjWI/vfeezb6vklesaOZo=",
           "dev": true,
           "requires": {
-            "arr-flatten": "1.1.0",
-            "array-slice": "0.2.3"
+            "arr-flatten": "^1.0.1",
+            "array-slice": "^0.2.3"
           }
         },
         "arr-union": {
@@ -2795,7 +2795,7 @@
           "integrity": "sha1-Gda/lN/AnXa6cR85uHLSH/TdkHE=",
           "dev": true,
           "requires": {
-            "kind-of": "1.1.0"
+            "kind-of": "^1.1.0"
           }
         },
         "kind-of": {
@@ -2810,11 +2810,11 @@
           "integrity": "sha1-O5uzM1zPAPQl4HQ34ZJ2ln2kes4=",
           "dev": true,
           "requires": {
-            "ansi-cyan": "0.1.1",
-            "ansi-red": "0.1.1",
-            "arr-diff": "1.1.0",
-            "arr-union": "2.1.0",
-            "extend-shallow": "1.1.4"
+            "ansi-cyan": "^0.1.1",
+            "ansi-red": "^0.1.1",
+            "arr-diff": "^1.0.1",
+            "arr-union": "^2.0.1",
+            "extend-shallow": "^1.1.2"
           }
         },
         "replace-ext": {
@@ -2829,12 +2829,12 @@
           "integrity": "sha512-MBH+yP0kC/GQ5GwBqrTPTzEfiiLjta7hTtvQtbxBgTeSXsmKQRQecjibMbxIXzVT3Y9KJK+drOz1/k+vsu8Nkg==",
           "dev": true,
           "requires": {
-            "clone": "2.1.2",
-            "clone-buffer": "1.0.0",
-            "clone-stats": "1.0.0",
-            "cloneable-readable": "1.1.3",
-            "remove-trailing-separator": "1.1.0",
-            "replace-ext": "1.0.1"
+            "clone": "^2.1.1",
+            "clone-buffer": "^1.0.0",
+            "clone-stats": "^1.0.0",
+            "cloneable-readable": "^1.0.0",
+            "remove-trailing-separator": "^1.0.1",
+            "replace-ext": "^1.0.0"
           }
         }
       }
@@ -2845,11 +2845,11 @@
       "integrity": "sha1-uG/zSdgBzrVuHZ59x7vLS33uYAw=",
       "dev": true,
       "requires": {
-        "convert-source-map": "1.7.0",
-        "graceful-fs": "4.2.4",
-        "strip-bom": "2.0.0",
-        "through2": "2.0.5",
-        "vinyl": "1.2.0"
+        "convert-source-map": "^1.1.1",
+        "graceful-fs": "^4.1.2",
+        "strip-bom": "^2.0.0",
+        "through2": "^2.0.0",
+        "vinyl": "^1.0.0"
       },
       "dependencies": {
         "graceful-fs": {
@@ -2864,7 +2864,7 @@
           "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=",
           "dev": true,
           "requires": {
-            "is-utf8": "0.2.1"
+            "is-utf8": "^0.2.0"
           }
         },
         "vinyl": {
@@ -2873,8 +2873,8 @@
           "integrity": "sha1-XIgDbPVl5d8FVYv8kR+GVt8hiIQ=",
           "dev": true,
           "requires": {
-            "clone": "1.0.4",
-            "clone-stats": "0.0.1",
+            "clone": "^1.0.0",
+            "clone-stats": "^0.0.1",
             "replace-ext": "0.0.1"
           }
         }
@@ -2886,12 +2886,12 @@
       "integrity": "sha512-8T0eE2SIKPxhG4YNgVM6SEoKRXKh4mRgNT3N/0zXLBGTN4y/E9Y+TR+1gDCrqi431RNkS6ZeLlJ24rKNrdVzYQ==",
       "dev": true,
       "requires": {
-        "chalk": "2.4.2",
-        "extend": "3.0.2",
-        "fancy-log": "1.3.3",
-        "plugin-error": "1.0.1",
-        "replacestream": "4.0.3",
-        "through2": "2.0.5"
+        "chalk": "^2.4.1",
+        "extend": "^3.0.1",
+        "fancy-log": "^1.3.2",
+        "plugin-error": "^1.0.1",
+        "replacestream": "^4.0.3",
+        "through2": "^2.0.3"
       }
     },
     "gulp-typescript": {
@@ -2900,10 +2900,10 @@
       "integrity": "sha512-bZosNvbUGzFA4bjjWoUPyjU5vfgJSzlYKkU0Jutbsrj+td8yvtqxethhqfzB9MwyamaUODIuidj5gIytZ523Bw==",
       "dev": true,
       "requires": {
-        "gulp-util": "3.0.8",
-        "source-map": "0.5.7",
-        "through2": "2.0.5",
-        "vinyl-fs": "2.4.4"
+        "gulp-util": "~3.0.7",
+        "source-map": "~0.5.3",
+        "through2": "~2.0.1",
+        "vinyl-fs": "~2.4.3"
       },
       "dependencies": {
         "arr-diff": {
@@ -2912,7 +2912,7 @@
           "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
           "dev": true,
           "requires": {
-            "arr-flatten": "1.1.0"
+            "arr-flatten": "^1.0.1"
           }
         },
         "array-unique": {
@@ -2927,9 +2927,9 @@
           "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
           "dev": true,
           "requires": {
-            "expand-range": "1.8.2",
-            "preserve": "0.2.0",
-            "repeat-element": "1.1.3"
+            "expand-range": "^1.8.1",
+            "preserve": "^0.2.0",
+            "repeat-element": "^1.1.2"
           }
         },
         "expand-brackets": {
@@ -2938,7 +2938,7 @@
           "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
           "dev": true,
           "requires": {
-            "is-posix-bracket": "0.1.1"
+            "is-posix-bracket": "^0.1.0"
           }
         },
         "extglob": {
@@ -2947,7 +2947,7 @@
           "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
           "dev": true,
           "requires": {
-            "is-extglob": "1.0.0"
+            "is-extglob": "^1.0.0"
           }
         },
         "glob": {
@@ -2956,11 +2956,11 @@
           "integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=",
           "dev": true,
           "requires": {
-            "inflight": "1.0.6",
-            "inherits": "2.0.4",
-            "minimatch": "3.0.4",
-            "once": "1.4.0",
-            "path-is-absolute": "1.0.1"
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "2 || 3",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
           }
         },
         "glob-stream": {
@@ -2969,14 +2969,14 @@
           "integrity": "sha1-pVZlqajM3EGRWofHAeMtTgFvrSI=",
           "dev": true,
           "requires": {
-            "extend": "3.0.2",
-            "glob": "5.0.15",
-            "glob-parent": "3.1.0",
-            "micromatch": "2.3.11",
-            "ordered-read-streams": "0.3.0",
-            "through2": "0.6.5",
-            "to-absolute-glob": "0.1.1",
-            "unique-stream": "2.3.1"
+            "extend": "^3.0.0",
+            "glob": "^5.0.3",
+            "glob-parent": "^3.0.0",
+            "micromatch": "^2.3.7",
+            "ordered-read-streams": "^0.3.0",
+            "through2": "^0.6.0",
+            "to-absolute-glob": "^0.1.1",
+            "unique-stream": "^2.0.2"
           },
           "dependencies": {
             "readable-stream": {
@@ -2985,10 +2985,10 @@
               "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=",
               "dev": true,
               "requires": {
-                "core-util-is": "1.0.2",
-                "inherits": "2.0.4",
+                "core-util-is": "~1.0.0",
+                "inherits": "~2.0.1",
                 "isarray": "0.0.1",
-                "string_decoder": "0.10.31"
+                "string_decoder": "~0.10.x"
               }
             },
             "through2": {
@@ -2997,8 +2997,8 @@
               "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=",
               "dev": true,
               "requires": {
-                "readable-stream": "1.0.34",
-                "xtend": "4.0.2"
+                "readable-stream": ">=1.0.33-1 <1.1.0-0",
+                "xtend": ">=4.0.0 <4.1.0-0"
               }
             }
           }
@@ -3021,7 +3021,7 @@
           "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
           "dev": true,
           "requires": {
-            "is-extglob": "1.0.0"
+            "is-extglob": "^1.0.0"
           }
         },
         "isarray": {
@@ -3036,7 +3036,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         },
         "micromatch": {
@@ -3045,19 +3045,19 @@
           "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
           "dev": true,
           "requires": {
-            "arr-diff": "2.0.0",
-            "array-unique": "0.2.1",
-            "braces": "1.8.5",
-            "expand-brackets": "0.1.5",
-            "extglob": "0.3.2",
-            "filename-regex": "2.0.1",
-            "is-extglob": "1.0.0",
-            "is-glob": "2.0.1",
-            "kind-of": "3.2.2",
-            "normalize-path": "2.1.1",
-            "object.omit": "2.0.1",
-            "parse-glob": "3.0.4",
-            "regex-cache": "0.4.4"
+            "arr-diff": "^2.0.0",
+            "array-unique": "^0.2.1",
+            "braces": "^1.8.2",
+            "expand-brackets": "^0.1.4",
+            "extglob": "^0.3.1",
+            "filename-regex": "^2.0.0",
+            "is-extglob": "^1.0.0",
+            "is-glob": "^2.0.1",
+            "kind-of": "^3.0.2",
+            "normalize-path": "^2.0.1",
+            "object.omit": "^2.0.0",
+            "parse-glob": "^3.0.4",
+            "regex-cache": "^0.4.2"
           }
         },
         "ordered-read-streams": {
@@ -3066,8 +3066,8 @@
           "integrity": "sha1-cTfmmzKYuzQiR6G77jiByA4v14s=",
           "dev": true,
           "requires": {
-            "is-stream": "1.1.0",
-            "readable-stream": "2.3.7"
+            "is-stream": "^1.0.1",
+            "readable-stream": "^2.0.1"
           }
         },
         "string_decoder": {
@@ -3082,7 +3082,7 @@
           "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=",
           "dev": true,
           "requires": {
-            "is-utf8": "0.2.1"
+            "is-utf8": "^0.2.0"
           }
         },
         "unique-stream": {
@@ -3091,8 +3091,8 @@
           "integrity": "sha512-2nY4TnBE70yoxHkDli7DMazpWiP7xMdCYqU2nBRO0UB+ZpEkGsSija7MvmvnZFUeC+mrgiUfcHSr3LmRFIg4+A==",
           "dev": true,
           "requires": {
-            "json-stable-stringify-without-jsonify": "1.0.1",
-            "through2-filter": "3.0.0"
+            "json-stable-stringify-without-jsonify": "^1.0.1",
+            "through2-filter": "^3.0.0"
           },
           "dependencies": {
             "through2-filter": {
@@ -3101,8 +3101,8 @@
               "integrity": "sha512-jaRjI2WxN3W1V8/FMZ9HKIBXixtiqs3SQSX4/YGIiP3gL6djW48VoZq9tDqeCWs3MT8YY5wb/zli8VW8snY1CA==",
               "dev": true,
               "requires": {
-                "through2": "2.0.5",
-                "xtend": "4.0.2"
+                "through2": "~2.0.0",
+                "xtend": "~4.0.0"
               }
             }
           }
@@ -3113,8 +3113,8 @@
           "integrity": "sha1-XIgDbPVl5d8FVYv8kR+GVt8hiIQ=",
           "dev": true,
           "requires": {
-            "clone": "1.0.4",
-            "clone-stats": "0.0.1",
+            "clone": "^1.0.0",
+            "clone-stats": "^0.0.1",
             "replace-ext": "0.0.1"
           }
         },
@@ -3124,23 +3124,23 @@
           "integrity": "sha1-vm/zJwy1Xf19MGNkDegfJddTIjk=",
           "dev": true,
           "requires": {
-            "duplexify": "3.7.1",
-            "glob-stream": "5.3.5",
-            "graceful-fs": "4.2.4",
+            "duplexify": "^3.2.0",
+            "glob-stream": "^5.3.2",
+            "graceful-fs": "^4.0.0",
             "gulp-sourcemaps": "1.6.0",
-            "is-valid-glob": "0.3.0",
-            "lazystream": "1.0.0",
-            "lodash.isequal": "4.5.0",
-            "merge-stream": "1.0.1",
-            "mkdirp": "0.5.5",
-            "object-assign": "4.1.1",
-            "readable-stream": "2.3.7",
-            "strip-bom": "2.0.0",
-            "strip-bom-stream": "1.0.0",
-            "through2": "2.0.5",
-            "through2-filter": "2.0.0",
-            "vali-date": "1.0.0",
-            "vinyl": "1.2.0"
+            "is-valid-glob": "^0.3.0",
+            "lazystream": "^1.0.0",
+            "lodash.isequal": "^4.0.0",
+            "merge-stream": "^1.0.0",
+            "mkdirp": "^0.5.0",
+            "object-assign": "^4.0.0",
+            "readable-stream": "^2.0.4",
+            "strip-bom": "^2.0.0",
+            "strip-bom-stream": "^1.0.0",
+            "through2": "^2.0.0",
+            "through2-filter": "^2.0.0",
+            "vali-date": "^1.0.0",
+            "vinyl": "^1.0.0"
           }
         }
       }
@@ -3151,16 +3151,16 @@
       "integrity": "sha512-gk1dhB74AkV2kzqPMQBLA3jPoIAPd/nlNzP2XMDSG8XZrqnlCiDGAqC+rZOumzFvB5zOphlFh6yr3lgcAb/OOg==",
       "dev": true,
       "requires": {
-        "array-each": "1.0.1",
-        "extend-shallow": "3.0.2",
-        "gulplog": "1.0.0",
-        "has-gulplog": "0.1.0",
-        "isobject": "3.0.1",
-        "make-error-cause": "1.2.2",
-        "safe-buffer": "5.1.2",
-        "through2": "2.0.5",
-        "uglify-js": "3.9.3",
-        "vinyl-sourcemaps-apply": "0.2.1"
+        "array-each": "^1.0.1",
+        "extend-shallow": "^3.0.2",
+        "gulplog": "^1.0.0",
+        "has-gulplog": "^0.1.0",
+        "isobject": "^3.0.1",
+        "make-error-cause": "^1.1.1",
+        "safe-buffer": "^5.1.2",
+        "through2": "^2.0.0",
+        "uglify-js": "^3.0.5",
+        "vinyl-sourcemaps-apply": "^0.2.0"
       }
     },
     "gulp-util": {
@@ -3169,24 +3169,24 @@
       "integrity": "sha1-AFTh50RQLifATBh8PsxQXdVLu08=",
       "dev": true,
       "requires": {
-        "array-differ": "1.0.0",
-        "array-uniq": "1.0.3",
-        "beeper": "1.1.1",
-        "chalk": "1.1.3",
-        "dateformat": "2.2.0",
-        "fancy-log": "1.3.3",
-        "gulplog": "1.0.0",
-        "has-gulplog": "0.1.0",
-        "lodash._reescape": "3.0.0",
-        "lodash._reevaluate": "3.0.0",
-        "lodash._reinterpolate": "3.0.0",
-        "lodash.template": "3.6.2",
-        "minimist": "1.2.5",
-        "multipipe": "0.1.2",
-        "object-assign": "3.0.0",
+        "array-differ": "^1.0.0",
+        "array-uniq": "^1.0.2",
+        "beeper": "^1.0.0",
+        "chalk": "^1.0.0",
+        "dateformat": "^2.0.0",
+        "fancy-log": "^1.1.0",
+        "gulplog": "^1.0.0",
+        "has-gulplog": "^0.1.0",
+        "lodash._reescape": "^3.0.0",
+        "lodash._reevaluate": "^3.0.0",
+        "lodash._reinterpolate": "^3.0.0",
+        "lodash.template": "^3.0.0",
+        "minimist": "^1.1.0",
+        "multipipe": "^0.1.2",
+        "object-assign": "^3.0.0",
         "replace-ext": "0.0.1",
-        "through2": "2.0.5",
-        "vinyl": "0.5.3"
+        "through2": "^2.0.0",
+        "vinyl": "^0.5.0"
       },
       "dependencies": {
         "ansi-styles": {
@@ -3201,11 +3201,11 @@
           "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=",
           "dev": true,
           "requires": {
-            "ansi-styles": "2.2.1",
-            "escape-string-regexp": "1.0.5",
-            "has-ansi": "2.0.0",
-            "strip-ansi": "3.0.1",
-            "supports-color": "2.0.0"
+            "ansi-styles": "^2.2.1",
+            "escape-string-regexp": "^1.0.2",
+            "has-ansi": "^2.0.0",
+            "strip-ansi": "^3.0.0",
+            "supports-color": "^2.0.0"
           }
         },
         "object-assign": {
@@ -3228,7 +3228,7 @@
       "integrity": "sha1-4oxNRdBey77YGDY86PnFkmIp/+U=",
       "dev": true,
       "requires": {
-        "glogg": "1.0.2"
+        "glogg": "^1.0.0"
       }
     },
     "has": {
@@ -3237,7 +3237,7 @@
       "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
       "dev": true,
       "requires": {
-        "function-bind": "1.1.1"
+        "function-bind": "^1.1.1"
       }
     },
     "has-ansi": {
@@ -3246,7 +3246,7 @@
       "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=",
       "dev": true,
       "requires": {
-        "ansi-regex": "2.1.1"
+        "ansi-regex": "^2.0.0"
       }
     },
     "has-flag": {
@@ -3261,7 +3261,7 @@
       "integrity": "sha1-ZBTIKRNpfaUVkDl9r7EvIpZ4Ec4=",
       "dev": true,
       "requires": {
-        "sparkles": "1.0.1"
+        "sparkles": "^1.0.0"
       }
     },
     "has-value": {
@@ -3270,9 +3270,9 @@
       "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=",
       "dev": true,
       "requires": {
-        "get-value": "2.0.6",
-        "has-values": "1.0.0",
-        "isobject": "3.0.1"
+        "get-value": "^2.0.6",
+        "has-values": "^1.0.0",
+        "isobject": "^3.0.0"
       }
     },
     "has-values": {
@@ -3281,8 +3281,8 @@
       "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=",
       "dev": true,
       "requires": {
-        "is-number": "3.0.0",
-        "kind-of": "4.0.0"
+        "is-number": "^3.0.0",
+        "kind-of": "^4.0.0"
       },
       "dependencies": {
         "kind-of": {
@@ -3291,7 +3291,7 @@
           "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -3302,9 +3302,9 @@
       "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "readable-stream": "3.6.0",
-        "safe-buffer": "5.2.1"
+        "inherits": "^2.0.4",
+        "readable-stream": "^3.6.0",
+        "safe-buffer": "^5.2.0"
       },
       "dependencies": {
         "readable-stream": {
@@ -3313,9 +3313,9 @@
           "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
           "dev": true,
           "requires": {
-            "inherits": "2.0.4",
-            "string_decoder": "1.3.0",
-            "util-deprecate": "1.0.2"
+            "inherits": "^2.0.3",
+            "string_decoder": "^1.1.1",
+            "util-deprecate": "^1.0.1"
           }
         },
         "safe-buffer": {
@@ -3330,7 +3330,7 @@
           "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
           "dev": true,
           "requires": {
-            "safe-buffer": "5.2.1"
+            "safe-buffer": "~5.2.0"
           }
         }
       }
@@ -3341,8 +3341,8 @@
       "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "minimalistic-assert": "1.0.1"
+        "inherits": "^2.0.3",
+        "minimalistic-assert": "^1.0.1"
       }
     },
     "hmac-drbg": {
@@ -3351,9 +3351,9 @@
       "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=",
       "dev": true,
       "requires": {
-        "hash.js": "1.1.7",
-        "minimalistic-assert": "1.0.1",
-        "minimalistic-crypto-utils": "1.0.1"
+        "hash.js": "^1.0.3",
+        "minimalistic-assert": "^1.0.0",
+        "minimalistic-crypto-utils": "^1.0.1"
       }
     },
     "homedir-polyfill": {
@@ -3362,7 +3362,7 @@
       "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==",
       "dev": true,
       "requires": {
-        "parse-passwd": "1.0.0"
+        "parse-passwd": "^1.0.0"
       }
     },
     "htmlescape": {
@@ -3395,8 +3395,8 @@
       "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
       "dev": true,
       "requires": {
-        "once": "1.4.0",
-        "wrappy": "1.0.2"
+        "once": "^1.3.0",
+        "wrappy": "1"
       }
     },
     "inherits": {
@@ -3417,7 +3417,7 @@
       "integrity": "sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=",
       "dev": true,
       "requires": {
-        "source-map": "0.5.7"
+        "source-map": "~0.5.3"
       }
     },
     "insert-module-globals": {
@@ -3426,16 +3426,16 @@
       "integrity": "sha512-VE6NlW+WGn2/AeOMd496AHFYmE7eLKkUY6Ty31k4og5vmA3Fjuwe9v6ifH6Xx/Hz27QvdoMoviw1/pqWRB09Sw==",
       "dev": true,
       "requires": {
-        "JSONStream": "1.3.5",
-        "acorn-node": "1.8.2",
-        "combine-source-map": "0.8.0",
-        "concat-stream": "1.6.2",
-        "is-buffer": "1.1.6",
-        "path-is-absolute": "1.0.1",
-        "process": "0.11.10",
-        "through2": "2.0.5",
-        "undeclared-identifiers": "1.1.3",
-        "xtend": "4.0.2"
+        "JSONStream": "^1.0.3",
+        "acorn-node": "^1.5.2",
+        "combine-source-map": "^0.8.0",
+        "concat-stream": "^1.6.1",
+        "is-buffer": "^1.1.0",
+        "path-is-absolute": "^1.0.1",
+        "process": "~0.11.0",
+        "through2": "^2.0.0",
+        "undeclared-identifiers": "^1.1.2",
+        "xtend": "^4.0.0"
       },
       "dependencies": {
         "concat-stream": {
@@ -3444,18 +3444,18 @@
           "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
           "dev": true,
           "requires": {
-            "buffer-from": "1.1.1",
-            "inherits": "2.0.4",
-            "readable-stream": "2.3.7",
-            "typedarray": "0.0.6"
+            "buffer-from": "^1.0.0",
+            "inherits": "^2.0.3",
+            "readable-stream": "^2.2.2",
+            "typedarray": "^0.0.6"
           }
         }
       }
     },
     "interpret": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.2.0.tgz",
-      "integrity": "sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw==",
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz",
+      "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==",
       "dev": true
     },
     "invariant": {
@@ -3464,7 +3464,7 @@
       "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==",
       "dev": true,
       "requires": {
-        "loose-envify": "1.4.0"
+        "loose-envify": "^1.0.0"
       }
     },
     "is-absolute": {
@@ -3473,8 +3473,8 @@
       "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==",
       "dev": true,
       "requires": {
-        "is-relative": "1.0.0",
-        "is-windows": "1.0.2"
+        "is-relative": "^1.0.0",
+        "is-windows": "^1.0.1"
       }
     },
     "is-accessor-descriptor": {
@@ -3483,7 +3483,7 @@
       "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=",
       "dev": true,
       "requires": {
-        "kind-of": "3.2.2"
+        "kind-of": "^3.0.2"
       },
       "dependencies": {
         "kind-of": {
@@ -3492,7 +3492,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -3509,7 +3509,7 @@
       "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=",
       "dev": true,
       "requires": {
-        "binary-extensions": "1.13.1"
+        "binary-extensions": "^1.0.0"
       }
     },
     "is-buffer": {
@@ -3524,7 +3524,7 @@
       "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=",
       "dev": true,
       "requires": {
-        "kind-of": "3.2.2"
+        "kind-of": "^3.0.2"
       },
       "dependencies": {
         "kind-of": {
@@ -3533,7 +3533,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -3544,9 +3544,9 @@
       "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==",
       "dev": true,
       "requires": {
-        "is-accessor-descriptor": "0.1.6",
-        "is-data-descriptor": "0.1.4",
-        "kind-of": "5.1.0"
+        "is-accessor-descriptor": "^0.1.6",
+        "is-data-descriptor": "^0.1.4",
+        "kind-of": "^5.0.0"
       },
       "dependencies": {
         "kind-of": {
@@ -3569,7 +3569,7 @@
       "integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=",
       "dev": true,
       "requires": {
-        "is-primitive": "2.0.0"
+        "is-primitive": "^2.0.0"
       }
     },
     "is-extendable": {
@@ -3590,7 +3590,7 @@
       "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=",
       "dev": true,
       "requires": {
-        "is-extglob": "2.1.1"
+        "is-extglob": "^2.1.0"
       }
     },
     "is-number": {
@@ -3599,7 +3599,7 @@
       "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
       "dev": true,
       "requires": {
-        "kind-of": "3.2.2"
+        "kind-of": "^3.0.2"
       },
       "dependencies": {
         "kind-of": {
@@ -3608,7 +3608,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -3619,7 +3619,7 @@
       "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
       "dev": true,
       "requires": {
-        "isobject": "3.0.1"
+        "isobject": "^3.0.1"
       }
     },
     "is-posix-bracket": {
@@ -3640,7 +3640,7 @@
       "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==",
       "dev": true,
       "requires": {
-        "is-unc-path": "1.0.0"
+        "is-unc-path": "^1.0.0"
       }
     },
     "is-stream": {
@@ -3655,7 +3655,7 @@
       "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==",
       "dev": true,
       "requires": {
-        "unc-path-regex": "0.1.2"
+        "unc-path-regex": "^0.1.2"
       }
     },
     "is-utf8": {
@@ -3712,7 +3712,7 @@
       "integrity": "sha1-YRwj6BTbN1Un34URk9tZ3Sryf0U=",
       "dev": true,
       "requires": {
-        "jsonify": "0.0.0"
+        "jsonify": "~0.0.0"
       }
     },
     "json-stable-stringify-without-jsonify": {
@@ -3727,7 +3727,7 @@
       "integrity": "sha512-KXPvOm8K9IJKFM0bmdn8QXh7udDh1g/giieX0NLCaMnb4hEiVFqnop2ImTXCc5e0/oHz3LTqmHGtExn5hfMkOA==",
       "dev": true,
       "requires": {
-        "minimist": "1.2.5"
+        "minimist": "^1.2.5"
       }
     },
     "jsonify": {
@@ -3754,8 +3754,8 @@
       "integrity": "sha512-Ca4LSXFFZUjPScRaqOcFxneA0VpKZr4MMYCljyQr4LIewTLb3Y0IUTIsnBBsVubIeEfxeSZpSjSsRM8APEQaAw==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "stream-splicer": "2.0.1"
+        "inherits": "^2.0.1",
+        "stream-splicer": "^2.0.0"
       }
     },
     "lazystream": {
@@ -3764,7 +3764,7 @@
       "integrity": "sha1-9plf4PggOS9hOWvolGJAe7dxaOQ=",
       "dev": true,
       "requires": {
-        "readable-stream": "2.3.7"
+        "readable-stream": "^2.0.5"
       }
     },
     "liftoff": {
@@ -3773,14 +3773,14 @@
       "integrity": "sha1-IAkpG7Mc6oYbvxCnwVooyvdcMew=",
       "dev": true,
       "requires": {
-        "extend": "3.0.2",
-        "findup-sync": "2.0.0",
-        "fined": "1.2.0",
-        "flagged-respawn": "1.0.1",
-        "is-plain-object": "2.0.4",
-        "object.map": "1.0.1",
-        "rechoir": "0.6.2",
-        "resolve": "1.17.0"
+        "extend": "^3.0.0",
+        "findup-sync": "^2.0.0",
+        "fined": "^1.0.1",
+        "flagged-respawn": "^1.0.0",
+        "is-plain-object": "^2.0.4",
+        "object.map": "^1.0.0",
+        "rechoir": "^0.6.2",
+        "resolve": "^1.1.7"
       }
     },
     "lodash": {
@@ -3849,7 +3849,7 @@
       "integrity": "sha1-mV7g3BjBtIzJLv+ucaEKq1tIdpg=",
       "dev": true,
       "requires": {
-        "lodash._root": "3.0.1"
+        "lodash._root": "^3.0.0"
       }
     },
     "lodash.isarguments": {
@@ -3876,9 +3876,9 @@
       "integrity": "sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=",
       "dev": true,
       "requires": {
-        "lodash._getnative": "3.9.1",
-        "lodash.isarguments": "3.1.0",
-        "lodash.isarray": "3.0.4"
+        "lodash._getnative": "^3.0.0",
+        "lodash.isarguments": "^3.0.0",
+        "lodash.isarray": "^3.0.0"
       }
     },
     "lodash.memoize": {
@@ -3899,15 +3899,15 @@
       "integrity": "sha1-+M3sxhaaJVvpCYrosMU9N4kx0U8=",
       "dev": true,
       "requires": {
-        "lodash._basecopy": "3.0.1",
-        "lodash._basetostring": "3.0.1",
-        "lodash._basevalues": "3.0.0",
-        "lodash._isiterateecall": "3.0.9",
-        "lodash._reinterpolate": "3.0.0",
-        "lodash.escape": "3.2.0",
-        "lodash.keys": "3.1.2",
-        "lodash.restparam": "3.6.1",
-        "lodash.templatesettings": "3.1.1"
+        "lodash._basecopy": "^3.0.0",
+        "lodash._basetostring": "^3.0.0",
+        "lodash._basevalues": "^3.0.0",
+        "lodash._isiterateecall": "^3.0.0",
+        "lodash._reinterpolate": "^3.0.0",
+        "lodash.escape": "^3.0.0",
+        "lodash.keys": "^3.0.0",
+        "lodash.restparam": "^3.0.0",
+        "lodash.templatesettings": "^3.0.0"
       }
     },
     "lodash.templatesettings": {
@@ -3916,8 +3916,8 @@
       "integrity": "sha1-+zB4RHU7Zrnxr6VOJix0UwfbqOU=",
       "dev": true,
       "requires": {
-        "lodash._reinterpolate": "3.0.0",
-        "lodash.escape": "3.2.0"
+        "lodash._reinterpolate": "^3.0.0",
+        "lodash.escape": "^3.0.0"
       }
     },
     "loose-envify": {
@@ -3926,7 +3926,7 @@
       "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
       "dev": true,
       "requires": {
-        "js-tokens": "4.0.0"
+        "js-tokens": "^3.0.0 || ^4.0.0"
       }
     },
     "lru-cache": {
@@ -3947,7 +3947,7 @@
       "integrity": "sha1-3wOI/NCzeBbf8KX7gQiTl3fcvJ0=",
       "dev": true,
       "requires": {
-        "make-error": "1.3.6"
+        "make-error": "^1.2.0"
       }
     },
     "make-iterator": {
@@ -3956,7 +3956,7 @@
       "integrity": "sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==",
       "dev": true,
       "requires": {
-        "kind-of": "6.0.3"
+        "kind-of": "^6.0.2"
       }
     },
     "map-cache": {
@@ -3977,7 +3977,7 @@
       "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=",
       "dev": true,
       "requires": {
-        "object-visit": "1.0.1"
+        "object-visit": "^1.0.0"
       }
     },
     "math-random": {
@@ -3992,9 +3992,9 @@
       "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==",
       "dev": true,
       "requires": {
-        "hash-base": "3.1.0",
-        "inherits": "2.0.4",
-        "safe-buffer": "5.1.2"
+        "hash-base": "^3.0.0",
+        "inherits": "^2.0.1",
+        "safe-buffer": "^5.1.2"
       }
     },
     "merge-stream": {
@@ -4003,7 +4003,7 @@
       "integrity": "sha1-QEEgLVCKNCugAXQAjfDCUbjBNeE=",
       "dev": true,
       "requires": {
-        "readable-stream": "2.3.7"
+        "readable-stream": "^2.0.1"
       }
     },
     "micromatch": {
@@ -4012,19 +4012,19 @@
       "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==",
       "dev": true,
       "requires": {
-        "arr-diff": "4.0.0",
-        "array-unique": "0.3.2",
-        "braces": "2.3.2",
-        "define-property": "2.0.2",
-        "extend-shallow": "3.0.2",
-        "extglob": "2.0.4",
-        "fragment-cache": "0.2.1",
-        "kind-of": "6.0.3",
-        "nanomatch": "1.2.13",
-        "object.pick": "1.3.0",
-        "regex-not": "1.0.2",
-        "snapdragon": "0.8.2",
-        "to-regex": "3.0.2"
+        "arr-diff": "^4.0.0",
+        "array-unique": "^0.3.2",
+        "braces": "^2.3.1",
+        "define-property": "^2.0.2",
+        "extend-shallow": "^3.0.2",
+        "extglob": "^2.0.4",
+        "fragment-cache": "^0.2.1",
+        "kind-of": "^6.0.2",
+        "nanomatch": "^1.2.9",
+        "object.pick": "^1.3.0",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.2"
       }
     },
     "miller-rabin": {
@@ -4033,8 +4033,8 @@
       "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==",
       "dev": true,
       "requires": {
-        "bn.js": "4.11.9",
-        "brorand": "1.1.0"
+        "bn.js": "^4.0.0",
+        "brorand": "^1.0.1"
       },
       "dependencies": {
         "bn.js": {
@@ -4063,7 +4063,7 @@
       "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
       "dev": true,
       "requires": {
-        "brace-expansion": "1.1.11"
+        "brace-expansion": "^1.1.7"
       }
     },
     "minimist": {
@@ -4078,8 +4078,8 @@
       "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==",
       "dev": true,
       "requires": {
-        "for-in": "1.0.2",
-        "is-extendable": "1.0.1"
+        "for-in": "^1.0.2",
+        "is-extendable": "^1.0.1"
       },
       "dependencies": {
         "is-extendable": {
@@ -4088,7 +4088,7 @@
           "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
           "dev": true,
           "requires": {
-            "is-plain-object": "2.0.4"
+            "is-plain-object": "^2.0.4"
           }
         }
       }
@@ -4099,7 +4099,7 @@
       "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
       "dev": true,
       "requires": {
-        "minimist": "1.2.5"
+        "minimist": "^1.2.5"
       }
     },
     "mkdirp-classic": {
@@ -4114,21 +4114,21 @@
       "integrity": "sha1-IyFYM/HaE/1gbMuAh7RIUty4If0=",
       "dev": true,
       "requires": {
-        "JSONStream": "1.3.5",
-        "browser-resolve": "1.11.3",
-        "cached-path-relative": "1.0.2",
-        "concat-stream": "1.5.2",
-        "defined": "1.0.0",
-        "detective": "4.7.1",
-        "duplexer2": "0.1.4",
-        "inherits": "2.0.4",
-        "parents": "1.0.1",
-        "readable-stream": "2.3.7",
-        "resolve": "1.17.0",
-        "stream-combiner2": "1.1.1",
-        "subarg": "1.0.0",
-        "through2": "2.0.5",
-        "xtend": "4.0.2"
+        "JSONStream": "^1.0.3",
+        "browser-resolve": "^1.7.0",
+        "cached-path-relative": "^1.0.0",
+        "concat-stream": "~1.5.0",
+        "defined": "^1.0.0",
+        "detective": "^4.0.0",
+        "duplexer2": "^0.1.2",
+        "inherits": "^2.0.1",
+        "parents": "^1.0.0",
+        "readable-stream": "^2.0.2",
+        "resolve": "^1.1.3",
+        "stream-combiner2": "^1.1.1",
+        "subarg": "^1.0.0",
+        "through2": "^2.0.0",
+        "xtend": "^4.0.0"
       }
     },
     "ms": {
@@ -4152,7 +4152,7 @@
           "integrity": "sha1-xhTc9n4vsUmVqRcR5aYX6KYKMds=",
           "dev": true,
           "requires": {
-            "readable-stream": "1.1.14"
+            "readable-stream": "~1.1.9"
           }
         },
         "isarray": {
@@ -4167,10 +4167,10 @@
           "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=",
           "dev": true,
           "requires": {
-            "core-util-is": "1.0.2",
-            "inherits": "2.0.4",
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.1",
             "isarray": "0.0.1",
-            "string_decoder": "0.10.31"
+            "string_decoder": "~0.10.x"
           }
         },
         "string_decoder": {
@@ -4194,17 +4194,17 @@
       "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==",
       "dev": true,
       "requires": {
-        "arr-diff": "4.0.0",
-        "array-unique": "0.3.2",
-        "define-property": "2.0.2",
-        "extend-shallow": "3.0.2",
-        "fragment-cache": "0.2.1",
-        "is-windows": "1.0.2",
-        "kind-of": "6.0.3",
-        "object.pick": "1.3.0",
-        "regex-not": "1.0.2",
-        "snapdragon": "0.8.2",
-        "to-regex": "3.0.2"
+        "arr-diff": "^4.0.0",
+        "array-unique": "^0.3.2",
+        "define-property": "^2.0.2",
+        "extend-shallow": "^3.0.2",
+        "fragment-cache": "^0.2.1",
+        "is-windows": "^1.0.2",
+        "kind-of": "^6.0.2",
+        "object.pick": "^1.3.0",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.1"
       }
     },
     "natives": {
@@ -4219,7 +4219,7 @@
       "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=",
       "dev": true,
       "requires": {
-        "remove-trailing-separator": "1.1.0"
+        "remove-trailing-separator": "^1.0.1"
       }
     },
     "object-assign": {
@@ -4234,9 +4234,9 @@
       "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=",
       "dev": true,
       "requires": {
-        "copy-descriptor": "0.1.1",
-        "define-property": "0.2.5",
-        "kind-of": "3.2.2"
+        "copy-descriptor": "^0.1.0",
+        "define-property": "^0.2.5",
+        "kind-of": "^3.0.3"
       },
       "dependencies": {
         "define-property": {
@@ -4245,7 +4245,7 @@
           "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "0.1.6"
+            "is-descriptor": "^0.1.0"
           }
         },
         "kind-of": {
@@ -4254,7 +4254,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -4265,7 +4265,7 @@
       "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=",
       "dev": true,
       "requires": {
-        "isobject": "3.0.1"
+        "isobject": "^3.0.0"
       }
     },
     "object.defaults": {
@@ -4274,10 +4274,10 @@
       "integrity": "sha1-On+GgzS0B96gbaFtiNXNKeQ1/s8=",
       "dev": true,
       "requires": {
-        "array-each": "1.0.1",
-        "array-slice": "1.1.0",
-        "for-own": "1.0.0",
-        "isobject": "3.0.1"
+        "array-each": "^1.0.1",
+        "array-slice": "^1.0.0",
+        "for-own": "^1.0.0",
+        "isobject": "^3.0.0"
       }
     },
     "object.map": {
@@ -4286,8 +4286,8 @@
       "integrity": "sha1-z4Plncj8wK1fQlDh94s7gb2AHTc=",
       "dev": true,
       "requires": {
-        "for-own": "1.0.0",
-        "make-iterator": "1.0.1"
+        "for-own": "^1.0.0",
+        "make-iterator": "^1.0.0"
       }
     },
     "object.omit": {
@@ -4296,8 +4296,8 @@
       "integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=",
       "dev": true,
       "requires": {
-        "for-own": "0.1.5",
-        "is-extendable": "0.1.1"
+        "for-own": "^0.1.4",
+        "is-extendable": "^0.1.1"
       },
       "dependencies": {
         "for-own": {
@@ -4306,7 +4306,7 @@
           "integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=",
           "dev": true,
           "requires": {
-            "for-in": "1.0.2"
+            "for-in": "^1.0.1"
           }
         }
       }
@@ -4317,7 +4317,7 @@
       "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=",
       "dev": true,
       "requires": {
-        "isobject": "3.0.1"
+        "isobject": "^3.0.1"
       }
     },
     "once": {
@@ -4326,7 +4326,7 @@
       "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
       "dev": true,
       "requires": {
-        "wrappy": "1.0.2"
+        "wrappy": "1"
       }
     },
     "orchestrator": {
@@ -4335,9 +4335,9 @@
       "integrity": "sha1-FOfp4nZPcxX7rBhOUGx6pt+UrX4=",
       "dev": true,
       "requires": {
-        "end-of-stream": "0.1.5",
-        "sequencify": "0.0.7",
-        "stream-consume": "0.1.1"
+        "end-of-stream": "~0.1.5",
+        "sequencify": "~0.0.7",
+        "stream-consume": "~0.1.0"
       }
     },
     "ordered-read-streams": {
@@ -4364,7 +4364,7 @@
       "integrity": "sha1-UM+GFjZeh+Ax4ppeyTOaPaRyX6I=",
       "dev": true,
       "requires": {
-        "shell-quote": "1.7.2"
+        "shell-quote": "^1.4.2"
       }
     },
     "pako": {
@@ -4379,7 +4379,7 @@
       "integrity": "sha1-/t1NK/GTp3dF/nHjcdc8MwfZx1E=",
       "dev": true,
       "requires": {
-        "path-platform": "0.11.15"
+        "path-platform": "~0.11.15"
       }
     },
     "parse-asn1": {
@@ -4388,12 +4388,12 @@
       "integrity": "sha512-jkMYn1dcJqF6d5CpU689bq7w/b5ALS9ROVSpQDPrZsqqesUJii9qutvoT5ltGedNXMO2e16YUWIghG9KxaViTQ==",
       "dev": true,
       "requires": {
-        "asn1.js": "4.10.1",
-        "browserify-aes": "1.2.0",
-        "create-hash": "1.2.0",
-        "evp_bytestokey": "1.0.3",
-        "pbkdf2": "3.0.17",
-        "safe-buffer": "5.1.2"
+        "asn1.js": "^4.0.0",
+        "browserify-aes": "^1.0.0",
+        "create-hash": "^1.1.0",
+        "evp_bytestokey": "^1.0.0",
+        "pbkdf2": "^3.0.3",
+        "safe-buffer": "^5.1.1"
       }
     },
     "parse-filepath": {
@@ -4402,9 +4402,9 @@
       "integrity": "sha1-pjISf1Oq89FYdvWHLz/6x2PWyJE=",
       "dev": true,
       "requires": {
-        "is-absolute": "1.0.0",
-        "map-cache": "0.2.2",
-        "path-root": "0.1.1"
+        "is-absolute": "^1.0.0",
+        "map-cache": "^0.2.0",
+        "path-root": "^0.1.1"
       }
     },
     "parse-glob": {
@@ -4413,10 +4413,10 @@
       "integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=",
       "dev": true,
       "requires": {
-        "glob-base": "0.3.0",
-        "is-dotfile": "1.0.3",
-        "is-extglob": "1.0.0",
-        "is-glob": "2.0.1"
+        "glob-base": "^0.3.0",
+        "is-dotfile": "^1.0.0",
+        "is-extglob": "^1.0.0",
+        "is-glob": "^2.0.0"
       },
       "dependencies": {
         "is-extglob": {
@@ -4431,7 +4431,7 @@
           "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
           "dev": true,
           "requires": {
-            "is-extglob": "1.0.0"
+            "is-extglob": "^1.0.0"
           }
         }
       }
@@ -4442,7 +4442,7 @@
       "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=",
       "dev": true,
       "requires": {
-        "error-ex": "1.3.2"
+        "error-ex": "^1.2.0"
       }
     },
     "parse-node-version": {
@@ -4499,7 +4499,7 @@
       "integrity": "sha1-mkpoFMrBwM1zNgqV8yCDyOpHRbc=",
       "dev": true,
       "requires": {
-        "path-root-regex": "0.1.2"
+        "path-root-regex": "^0.1.0"
       }
     },
     "path-root-regex": {
@@ -4514,7 +4514,7 @@
       "integrity": "sha1-/lo0sMvOErWqaitAPuLnO2AvFEU=",
       "dev": true,
       "requires": {
-        "through": "2.3.8"
+        "through": "~2.3"
       }
     },
     "pbkdf2": {
@@ -4523,11 +4523,11 @@
       "integrity": "sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==",
       "dev": true,
       "requires": {
-        "create-hash": "1.2.0",
-        "create-hmac": "1.1.7",
-        "ripemd160": "2.0.2",
-        "safe-buffer": "5.1.2",
-        "sha.js": "2.4.11"
+        "create-hash": "^1.1.2",
+        "create-hmac": "^1.1.4",
+        "ripemd160": "^2.0.1",
+        "safe-buffer": "^5.0.1",
+        "sha.js": "^2.4.8"
       }
     },
     "plugin-error": {
@@ -4536,10 +4536,10 @@
       "integrity": "sha512-L1zP0dk7vGweZME2i+EeakvUNqSrdiI3F91TwEoYiGrAfUXmVv6fJIq4g82PAXxNsWOp0J7ZqQy/3Szz0ajTxA==",
       "dev": true,
       "requires": {
-        "ansi-colors": "1.1.0",
-        "arr-diff": "4.0.0",
-        "arr-union": "3.1.0",
-        "extend-shallow": "3.0.2"
+        "ansi-colors": "^1.0.1",
+        "arr-diff": "^4.0.0",
+        "arr-union": "^3.1.0",
+        "extend-shallow": "^3.0.2"
       }
     },
     "posix-character-classes": {
@@ -4584,12 +4584,12 @@
       "integrity": "sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==",
       "dev": true,
       "requires": {
-        "bn.js": "4.11.9",
-        "browserify-rsa": "4.0.1",
-        "create-hash": "1.2.0",
-        "parse-asn1": "5.1.5",
-        "randombytes": "2.1.0",
-        "safe-buffer": "5.1.2"
+        "bn.js": "^4.1.0",
+        "browserify-rsa": "^4.0.0",
+        "create-hash": "^1.1.0",
+        "parse-asn1": "^5.0.0",
+        "randombytes": "^2.0.1",
+        "safe-buffer": "^5.1.2"
       },
       "dependencies": {
         "bn.js": {
@@ -4624,9 +4624,9 @@
       "integrity": "sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw==",
       "dev": true,
       "requires": {
-        "is-number": "4.0.0",
-        "kind-of": "6.0.3",
-        "math-random": "1.0.4"
+        "is-number": "^4.0.0",
+        "kind-of": "^6.0.0",
+        "math-random": "^1.0.1"
       },
       "dependencies": {
         "is-number": {
@@ -4643,7 +4643,7 @@
       "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
       "dev": true,
       "requires": {
-        "safe-buffer": "5.1.2"
+        "safe-buffer": "^5.1.0"
       }
     },
     "randomfill": {
@@ -4652,8 +4652,8 @@
       "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==",
       "dev": true,
       "requires": {
-        "randombytes": "2.1.0",
-        "safe-buffer": "5.1.2"
+        "randombytes": "^2.0.5",
+        "safe-buffer": "^5.1.0"
       }
     },
     "read-only-stream": {
@@ -4662,7 +4662,7 @@
       "integrity": "sha1-JyT9aoET1zdkrCiNQ4YnDB2/F/A=",
       "dev": true,
       "requires": {
-        "readable-stream": "2.3.7"
+        "readable-stream": "^2.0.2"
       }
     },
     "readable-stream": {
@@ -4671,13 +4671,13 @@
       "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
       "dev": true,
       "requires": {
-        "core-util-is": "1.0.2",
-        "inherits": "2.0.4",
-        "isarray": "1.0.0",
-        "process-nextick-args": "2.0.1",
-        "safe-buffer": "5.1.2",
-        "string_decoder": "1.1.1",
-        "util-deprecate": "1.0.2"
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
       },
       "dependencies": {
         "string_decoder": {
@@ -4686,7 +4686,7 @@
           "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
           "dev": true,
           "requires": {
-            "safe-buffer": "5.1.2"
+            "safe-buffer": "~5.1.0"
           }
         }
       }
@@ -4697,9 +4697,9 @@
       "integrity": "sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==",
       "dev": true,
       "requires": {
-        "graceful-fs": "4.2.4",
-        "micromatch": "3.1.10",
-        "readable-stream": "2.3.7"
+        "graceful-fs": "^4.1.11",
+        "micromatch": "^3.1.10",
+        "readable-stream": "^2.0.2"
       },
       "dependencies": {
         "graceful-fs": {
@@ -4716,7 +4716,7 @@
       "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=",
       "dev": true,
       "requires": {
-        "resolve": "1.17.0"
+        "resolve": "^1.1.6"
       }
     },
     "regenerate": {
@@ -4737,9 +4737,9 @@
       "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==",
       "dev": true,
       "requires": {
-        "babel-runtime": "6.26.0",
-        "babel-types": "6.26.0",
-        "private": "0.1.8"
+        "babel-runtime": "^6.18.0",
+        "babel-types": "^6.19.0",
+        "private": "^0.1.6"
       }
     },
     "regex-cache": {
@@ -4748,7 +4748,7 @@
       "integrity": "sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==",
       "dev": true,
       "requires": {
-        "is-equal-shallow": "0.1.3"
+        "is-equal-shallow": "^0.1.3"
       }
     },
     "regex-not": {
@@ -4757,8 +4757,8 @@
       "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
       "dev": true,
       "requires": {
-        "extend-shallow": "3.0.2",
-        "safe-regex": "1.1.0"
+        "extend-shallow": "^3.0.2",
+        "safe-regex": "^1.1.0"
       }
     },
     "regexpu-core": {
@@ -4767,9 +4767,9 @@
       "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=",
       "dev": true,
       "requires": {
-        "regenerate": "1.4.0",
-        "regjsgen": "0.2.0",
-        "regjsparser": "0.1.5"
+        "regenerate": "^1.2.1",
+        "regjsgen": "^0.2.0",
+        "regjsparser": "^0.1.4"
       }
     },
     "regjsgen": {
@@ -4784,7 +4784,7 @@
       "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=",
       "dev": true,
       "requires": {
-        "jsesc": "0.5.0"
+        "jsesc": "~0.5.0"
       },
       "dependencies": {
         "jsesc": {
@@ -4825,9 +4825,9 @@
       "integrity": "sha512-AC0FiLS352pBBiZhd4VXB1Ab/lh0lEgpP+GGvZqbQh8a5cmXVoTe5EX/YeTFArnp4SRGTHh1qCHu9lGs1qG8sA==",
       "dev": true,
       "requires": {
-        "escape-string-regexp": "1.0.5",
-        "object-assign": "4.1.1",
-        "readable-stream": "2.3.7"
+        "escape-string-regexp": "^1.0.3",
+        "object-assign": "^4.0.1",
+        "readable-stream": "^2.0.2"
       }
     },
     "resolve": {
@@ -4836,7 +4836,7 @@
       "integrity": "sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==",
       "dev": true,
       "requires": {
-        "path-parse": "1.0.6"
+        "path-parse": "^1.0.6"
       }
     },
     "resolve-dir": {
@@ -4845,8 +4845,8 @@
       "integrity": "sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=",
       "dev": true,
       "requires": {
-        "expand-tilde": "2.0.2",
-        "global-modules": "1.0.0"
+        "expand-tilde": "^2.0.0",
+        "global-modules": "^1.0.0"
       }
     },
     "resolve-url": {
@@ -4867,8 +4867,8 @@
       "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==",
       "dev": true,
       "requires": {
-        "hash-base": "3.1.0",
-        "inherits": "2.0.4"
+        "hash-base": "^3.0.0",
+        "inherits": "^2.0.1"
       }
     },
     "safe-buffer": {
@@ -4883,7 +4883,7 @@
       "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=",
       "dev": true,
       "requires": {
-        "ret": "0.1.15"
+        "ret": "~0.1.10"
       }
     },
     "semver": {
@@ -4904,10 +4904,10 @@
       "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==",
       "dev": true,
       "requires": {
-        "extend-shallow": "2.0.1",
-        "is-extendable": "0.1.1",
-        "is-plain-object": "2.0.4",
-        "split-string": "3.1.0"
+        "extend-shallow": "^2.0.1",
+        "is-extendable": "^0.1.1",
+        "is-plain-object": "^2.0.3",
+        "split-string": "^3.0.1"
       },
       "dependencies": {
         "extend-shallow": {
@@ -4916,7 +4916,7 @@
           "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
           "dev": true,
           "requires": {
-            "is-extendable": "0.1.1"
+            "is-extendable": "^0.1.0"
           }
         }
       }
@@ -4927,8 +4927,8 @@
       "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "safe-buffer": "5.1.2"
+        "inherits": "^2.0.1",
+        "safe-buffer": "^5.0.1"
       }
     },
     "shasum": {
@@ -4937,8 +4937,8 @@
       "integrity": "sha1-5wEjENj0F/TetXEhUOVni4euVl8=",
       "dev": true,
       "requires": {
-        "json-stable-stringify": "0.0.1",
-        "sha.js": "2.4.11"
+        "json-stable-stringify": "~0.0.0",
+        "sha.js": "~2.4.4"
       }
     },
     "shasum-object": {
@@ -4947,7 +4947,7 @@
       "integrity": "sha512-Iqo5rp/3xVi6M4YheapzZhhGPVs0yZwHj7wvwQ1B9z8H6zk+FEnI7y3Teq7qwnekfEhu8WmG2z0z4iWZaxLWVg==",
       "dev": true,
       "requires": {
-        "fast-safe-stringify": "2.0.7"
+        "fast-safe-stringify": "^2.0.7"
       }
     },
     "shell-quote": {
@@ -4974,14 +4974,14 @@
       "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
       "dev": true,
       "requires": {
-        "base": "0.11.2",
-        "debug": "2.6.9",
-        "define-property": "0.2.5",
-        "extend-shallow": "2.0.1",
-        "map-cache": "0.2.2",
-        "source-map": "0.5.7",
-        "source-map-resolve": "0.5.3",
-        "use": "3.1.1"
+        "base": "^0.11.1",
+        "debug": "^2.2.0",
+        "define-property": "^0.2.5",
+        "extend-shallow": "^2.0.1",
+        "map-cache": "^0.2.2",
+        "source-map": "^0.5.6",
+        "source-map-resolve": "^0.5.0",
+        "use": "^3.1.0"
       },
       "dependencies": {
         "debug": {
@@ -4999,7 +4999,7 @@
           "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "0.1.6"
+            "is-descriptor": "^0.1.0"
           }
         },
         "extend-shallow": {
@@ -5008,7 +5008,7 @@
           "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
           "dev": true,
           "requires": {
-            "is-extendable": "0.1.1"
+            "is-extendable": "^0.1.0"
           }
         },
         "ms": {
@@ -5025,9 +5025,9 @@
       "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==",
       "dev": true,
       "requires": {
-        "define-property": "1.0.0",
-        "isobject": "3.0.1",
-        "snapdragon-util": "3.0.1"
+        "define-property": "^1.0.0",
+        "isobject": "^3.0.0",
+        "snapdragon-util": "^3.0.1"
       },
       "dependencies": {
         "define-property": {
@@ -5036,7 +5036,7 @@
           "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "1.0.2"
+            "is-descriptor": "^1.0.0"
           }
         },
         "is-accessor-descriptor": {
@@ -5045,7 +5045,7 @@
           "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-data-descriptor": {
@@ -5054,7 +5054,7 @@
           "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
           "dev": true,
           "requires": {
-            "kind-of": "6.0.3"
+            "kind-of": "^6.0.0"
           }
         },
         "is-descriptor": {
@@ -5063,9 +5063,9 @@
           "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
           "dev": true,
           "requires": {
-            "is-accessor-descriptor": "1.0.0",
-            "is-data-descriptor": "1.0.0",
-            "kind-of": "6.0.3"
+            "is-accessor-descriptor": "^1.0.0",
+            "is-data-descriptor": "^1.0.0",
+            "kind-of": "^6.0.2"
           }
         }
       }
@@ -5076,7 +5076,7 @@
       "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==",
       "dev": true,
       "requires": {
-        "kind-of": "3.2.2"
+        "kind-of": "^3.2.0"
       },
       "dependencies": {
         "kind-of": {
@@ -5085,7 +5085,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -5102,11 +5102,11 @@
       "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==",
       "dev": true,
       "requires": {
-        "atob": "2.1.2",
-        "decode-uri-component": "0.2.0",
-        "resolve-url": "0.2.1",
-        "source-map-url": "0.4.0",
-        "urix": "0.1.0"
+        "atob": "^2.1.2",
+        "decode-uri-component": "^0.2.0",
+        "resolve-url": "^0.2.1",
+        "source-map-url": "^0.4.0",
+        "urix": "^0.1.0"
       }
     },
     "source-map-support": {
@@ -5115,8 +5115,8 @@
       "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==",
       "dev": true,
       "requires": {
-        "buffer-from": "1.1.1",
-        "source-map": "0.6.1"
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
       },
       "dependencies": {
         "source-map": {
@@ -5145,7 +5145,7 @@
       "integrity": "sha1-zQ7qXmOiEd//frDwkcQTPi0N0o8=",
       "dev": true,
       "requires": {
-        "through": "2.3.8"
+        "through": "2"
       }
     },
     "split-string": {
@@ -5154,7 +5154,7 @@
       "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==",
       "dev": true,
       "requires": {
-        "extend-shallow": "3.0.2"
+        "extend-shallow": "^3.0.0"
       }
     },
     "static-extend": {
@@ -5163,8 +5163,8 @@
       "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=",
       "dev": true,
       "requires": {
-        "define-property": "0.2.5",
-        "object-copy": "0.1.0"
+        "define-property": "^0.2.5",
+        "object-copy": "^0.1.0"
       },
       "dependencies": {
         "define-property": {
@@ -5173,7 +5173,7 @@
           "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
           "dev": true,
           "requires": {
-            "is-descriptor": "0.1.6"
+            "is-descriptor": "^0.1.0"
           }
         }
       }
@@ -5184,8 +5184,8 @@
       "integrity": "sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "readable-stream": "2.3.7"
+        "inherits": "~2.0.1",
+        "readable-stream": "^2.0.2"
       }
     },
     "stream-combiner": {
@@ -5194,7 +5194,7 @@
       "integrity": "sha1-TV5DPBhSYd3mI8o/RMWGvPXErRQ=",
       "dev": true,
       "requires": {
-        "duplexer": "0.1.1"
+        "duplexer": "~0.1.1"
       }
     },
     "stream-combiner2": {
@@ -5203,8 +5203,8 @@
       "integrity": "sha1-+02KFCDqNidk4hrUeAOXvry0HL4=",
       "dev": true,
       "requires": {
-        "duplexer2": "0.1.4",
-        "readable-stream": "2.3.7"
+        "duplexer2": "~0.1.0",
+        "readable-stream": "^2.0.2"
       }
     },
     "stream-consume": {
@@ -5219,11 +5219,11 @@
       "integrity": "sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==",
       "dev": true,
       "requires": {
-        "builtin-status-codes": "3.0.0",
-        "inherits": "2.0.4",
-        "readable-stream": "2.3.7",
-        "to-arraybuffer": "1.0.1",
-        "xtend": "4.0.2"
+        "builtin-status-codes": "^3.0.0",
+        "inherits": "^2.0.1",
+        "readable-stream": "^2.3.6",
+        "to-arraybuffer": "^1.0.0",
+        "xtend": "^4.0.0"
       }
     },
     "stream-shift": {
@@ -5238,8 +5238,8 @@
       "integrity": "sha512-Xizh4/NPuYSyAXyT7g8IvdJ9HJpxIGL9PjyhtywCZvvP0OPIdqyrr4dMikeuvY8xahpdKEBlBTySe583totajg==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.4",
-        "readable-stream": "2.3.7"
+        "inherits": "^2.0.1",
+        "readable-stream": "^2.0.2"
       }
     },
     "string_decoder": {
@@ -5248,7 +5248,7 @@
       "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==",
       "dev": true,
       "requires": {
-        "safe-buffer": "5.1.2"
+        "safe-buffer": "~5.1.0"
       }
     },
     "strip-ansi": {
@@ -5257,7 +5257,7 @@
       "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=",
       "dev": true,
       "requires": {
-        "ansi-regex": "2.1.1"
+        "ansi-regex": "^2.0.0"
       }
     },
     "strip-bom": {
@@ -5266,8 +5266,8 @@
       "integrity": "sha1-hbiGLzhEtabV7IRnqTWYFzo295Q=",
       "dev": true,
       "requires": {
-        "first-chunk-stream": "1.0.0",
-        "is-utf8": "0.2.1"
+        "first-chunk-stream": "^1.0.0",
+        "is-utf8": "^0.2.0"
       }
     },
     "strip-bom-stream": {
@@ -5276,8 +5276,8 @@
       "integrity": "sha1-5xRDmFd9Uaa+0PoZlPoF9D/ZiO4=",
       "dev": true,
       "requires": {
-        "first-chunk-stream": "1.0.0",
-        "strip-bom": "2.0.0"
+        "first-chunk-stream": "^1.0.0",
+        "strip-bom": "^2.0.0"
       },
       "dependencies": {
         "strip-bom": {
@@ -5286,7 +5286,7 @@
           "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=",
           "dev": true,
           "requires": {
-            "is-utf8": "0.2.1"
+            "is-utf8": "^0.2.0"
           }
         }
       }
@@ -5303,7 +5303,7 @@
       "integrity": "sha1-9izxdYHplrSPyWVpn1TAauJouNI=",
       "dev": true,
       "requires": {
-        "minimist": "1.2.5"
+        "minimist": "^1.1.0"
       }
     },
     "supports-color": {
@@ -5312,7 +5312,7 @@
       "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
       "dev": true,
       "requires": {
-        "has-flag": "3.0.0"
+        "has-flag": "^3.0.0"
       }
     },
     "syntax-error": {
@@ -5321,7 +5321,7 @@
       "integrity": "sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==",
       "dev": true,
       "requires": {
-        "acorn-node": "1.8.2"
+        "acorn-node": "^1.2.0"
       }
     },
     "terser": {
@@ -5330,9 +5330,9 @@
       "integrity": "sha512-/FQzzPJmCpjAH9Xvk2paiWrFq+5M6aVOf+2KRbwhByISDX/EujxsK+BAvrhb6H+2rtrLCHK9N01wO014vrIwVQ==",
       "dev": true,
       "requires": {
-        "commander": "2.20.3",
-        "source-map": "0.6.1",
-        "source-map-support": "0.5.19"
+        "commander": "^2.19.0",
+        "source-map": "~0.6.1",
+        "source-map-support": "~0.5.10"
       },
       "dependencies": {
         "source-map": {
@@ -5355,8 +5355,8 @@
       "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==",
       "dev": true,
       "requires": {
-        "readable-stream": "2.3.7",
-        "xtend": "4.0.2"
+        "readable-stream": "~2.3.6",
+        "xtend": "~4.0.1"
       }
     },
     "through2-filter": {
@@ -5365,8 +5365,8 @@
       "integrity": "sha1-YLxVoNrLdghdsfna6Zq0P4PWIuw=",
       "dev": true,
       "requires": {
-        "through2": "2.0.5",
-        "xtend": "4.0.2"
+        "through2": "~2.0.0",
+        "xtend": "~4.0.0"
       }
     },
     "tildify": {
@@ -5375,7 +5375,7 @@
       "integrity": "sha1-3OwD9V3Km3qj5bBPIYF+tW5jWIo=",
       "dev": true,
       "requires": {
-        "os-homedir": "1.0.2"
+        "os-homedir": "^1.0.0"
       }
     },
     "time-stamp": {
@@ -5390,7 +5390,7 @@
       "integrity": "sha1-ycWLV1voQHN1y14kYtrO50NZ9B0=",
       "dev": true,
       "requires": {
-        "process": "0.11.10"
+        "process": "~0.11.0"
       }
     },
     "to-absolute-glob": {
@@ -5399,7 +5399,7 @@
       "integrity": "sha1-HN+kcqnvUMI57maZm2YsoOs5k38=",
       "dev": true,
       "requires": {
-        "extend-shallow": "2.0.1"
+        "extend-shallow": "^2.0.1"
       },
       "dependencies": {
         "extend-shallow": {
@@ -5408,7 +5408,7 @@
           "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
           "dev": true,
           "requires": {
-            "is-extendable": "0.1.1"
+            "is-extendable": "^0.1.0"
           }
         }
       }
@@ -5431,7 +5431,7 @@
       "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=",
       "dev": true,
       "requires": {
-        "kind-of": "3.2.2"
+        "kind-of": "^3.0.2"
       },
       "dependencies": {
         "kind-of": {
@@ -5440,7 +5440,7 @@
           "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
           "dev": true,
           "requires": {
-            "is-buffer": "1.1.6"
+            "is-buffer": "^1.1.5"
           }
         }
       }
@@ -5451,10 +5451,10 @@
       "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
       "dev": true,
       "requires": {
-        "define-property": "2.0.2",
-        "extend-shallow": "3.0.2",
-        "regex-not": "1.0.2",
-        "safe-regex": "1.1.0"
+        "define-property": "^2.0.2",
+        "extend-shallow": "^3.0.2",
+        "regex-not": "^1.0.2",
+        "safe-regex": "^1.1.0"
       }
     },
     "to-regex-range": {
@@ -5463,8 +5463,8 @@
       "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=",
       "dev": true,
       "requires": {
-        "is-number": "3.0.0",
-        "repeat-string": "1.6.1"
+        "is-number": "^3.0.0",
+        "repeat-string": "^1.6.1"
       }
     },
     "tsconfig": {
@@ -5473,10 +5473,10 @@
       "integrity": "sha1-X0J45wGACWeo/Dg/0ZZIh48qbjo=",
       "dev": true,
       "requires": {
-        "any-promise": "1.3.0",
-        "parse-json": "2.2.0",
-        "strip-bom": "2.0.0",
-        "strip-json-comments": "2.0.1"
+        "any-promise": "^1.3.0",
+        "parse-json": "^2.2.0",
+        "strip-bom": "^2.0.0",
+        "strip-json-comments": "^2.0.0"
       },
       "dependencies": {
         "strip-bom": {
@@ -5485,7 +5485,7 @@
           "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=",
           "dev": true,
           "requires": {
-            "is-utf8": "0.2.1"
+            "is-utf8": "^0.2.0"
           }
         }
       }
@@ -5496,12 +5496,12 @@
       "integrity": "sha512-y75+qgB41YS8HJck+jmSIn395I4qRGtm5ZELzvNh80Llzh8ojPWp47jm0ZoIJesNYVzbqEyLzgYXV9d/calvVg==",
       "dev": true,
       "requires": {
-        "convert-source-map": "1.7.0",
-        "fs.realpath": "1.0.0",
-        "object-assign": "4.1.1",
-        "semver": "5.7.1",
-        "through2": "2.0.5",
-        "tsconfig": "5.0.3"
+        "convert-source-map": "^1.1.0",
+        "fs.realpath": "^1.0.0",
+        "object-assign": "^4.1.0",
+        "semver": "^5.1.0",
+        "through2": "^2.0.0",
+        "tsconfig": "^5.0.3"
       }
     },
     "tty-browserify": {
@@ -5528,7 +5528,7 @@
       "integrity": "sha512-r5ImcL6QyzQGVimQoov3aL2ZScywrOgBXGndbWrdehKoSvGe/RmiE5Jpw/v+GvxODt6l2tpBXwA7n+qZVlHBMA==",
       "dev": true,
       "requires": {
-        "commander": "2.20.3"
+        "commander": "~2.20.3"
       }
     },
     "umd": {
@@ -5549,11 +5549,11 @@
       "integrity": "sha512-pJOW4nxjlmfwKApE4zvxLScM/njmwj/DiUBv7EabwE4O8kRUy+HIwxQtZLBPll/jx1LJyBcqNfB3/cpv9EZwOw==",
       "dev": true,
       "requires": {
-        "acorn-node": "1.8.2",
-        "dash-ast": "1.0.0",
-        "get-assigned-identifiers": "1.2.0",
-        "simple-concat": "1.0.0",
-        "xtend": "4.0.2"
+        "acorn-node": "^1.3.0",
+        "dash-ast": "^1.0.0",
+        "get-assigned-identifiers": "^1.2.0",
+        "simple-concat": "^1.0.0",
+        "xtend": "^4.0.1"
       }
     },
     "union-value": {
@@ -5562,10 +5562,10 @@
       "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==",
       "dev": true,
       "requires": {
-        "arr-union": "3.1.0",
-        "get-value": "2.0.6",
-        "is-extendable": "0.1.1",
-        "set-value": "2.0.1"
+        "arr-union": "^3.1.0",
+        "get-value": "^2.0.6",
+        "is-extendable": "^0.1.1",
+        "set-value": "^2.0.1"
       }
     },
     "unique-stream": {
@@ -5580,8 +5580,8 @@
       "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=",
       "dev": true,
       "requires": {
-        "has-value": "0.3.1",
-        "isobject": "3.0.1"
+        "has-value": "^0.3.1",
+        "isobject": "^3.0.0"
       },
       "dependencies": {
         "has-value": {
@@ -5590,9 +5590,9 @@
           "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=",
           "dev": true,
           "requires": {
-            "get-value": "2.0.6",
-            "has-values": "0.1.4",
-            "isobject": "2.1.0"
+            "get-value": "^2.0.3",
+            "has-values": "^0.1.4",
+            "isobject": "^2.0.0"
           },
           "dependencies": {
             "isobject": {
@@ -5685,7 +5685,7 @@
       "integrity": "sha1-qrGh+jDUX4jdMhFIh1rALAtV5bQ=",
       "dev": true,
       "requires": {
-        "user-home": "1.1.1"
+        "user-home": "^1.1.1"
       }
     },
     "vali-date": {
@@ -5700,8 +5700,8 @@
       "integrity": "sha1-sEVbOPxeDPMNQyUTLkYZcMIJHN4=",
       "dev": true,
       "requires": {
-        "clone": "1.0.4",
-        "clone-stats": "0.0.1",
+        "clone": "^1.0.0",
+        "clone-stats": "^0.0.1",
         "replace-ext": "0.0.1"
       }
     },
@@ -5711,14 +5711,14 @@
       "integrity": "sha1-mmhRzhysHBzqX+hsCTHWIMLPqeY=",
       "dev": true,
       "requires": {
-        "defaults": "1.0.3",
-        "glob-stream": "3.1.18",
-        "glob-watcher": "0.0.6",
-        "graceful-fs": "3.0.12",
-        "mkdirp": "0.5.5",
-        "strip-bom": "1.0.0",
-        "through2": "0.6.5",
-        "vinyl": "0.4.6"
+        "defaults": "^1.0.0",
+        "glob-stream": "^3.1.5",
+        "glob-watcher": "^0.0.6",
+        "graceful-fs": "^3.0.0",
+        "mkdirp": "^0.5.0",
+        "strip-bom": "^1.0.0",
+        "through2": "^0.6.1",
+        "vinyl": "^0.4.0"
       },
       "dependencies": {
         "clone": {
@@ -5739,10 +5739,10 @@
           "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=",
           "dev": true,
           "requires": {
-            "core-util-is": "1.0.2",
-            "inherits": "2.0.4",
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.1",
             "isarray": "0.0.1",
-            "string_decoder": "0.10.31"
+            "string_decoder": "~0.10.x"
           }
         },
         "string_decoder": {
@@ -5757,8 +5757,8 @@
           "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=",
           "dev": true,
           "requires": {
-            "readable-stream": "1.0.34",
-            "xtend": "4.0.2"
+            "readable-stream": ">=1.0.33-1 <1.1.0-0",
+            "xtend": ">=4.0.0 <4.1.0-0"
           }
         },
         "vinyl": {
@@ -5767,8 +5767,8 @@
           "integrity": "sha1-LzVsh6VQolVGHza76ypbqL94SEc=",
           "dev": true,
           "requires": {
-            "clone": "0.2.0",
-            "clone-stats": "0.0.1"
+            "clone": "^0.2.0",
+            "clone-stats": "^0.0.1"
           }
         }
       }
@@ -5779,8 +5779,8 @@
       "integrity": "sha1-YrU6E1YQqJbpjKlr7jqH8Aio54A=",
       "dev": true,
       "requires": {
-        "through2": "2.0.5",
-        "vinyl": "0.4.6"
+        "through2": "^2.0.3",
+        "vinyl": "^0.4.3"
       },
       "dependencies": {
         "clone": {
@@ -5795,8 +5795,8 @@
           "integrity": "sha1-LzVsh6VQolVGHza76ypbqL94SEc=",
           "dev": true,
           "requires": {
-            "clone": "0.2.0",
-            "clone-stats": "0.0.1"
+            "clone": "^0.2.0",
+            "clone-stats": "^0.0.1"
           }
         }
       }
@@ -5807,7 +5807,7 @@
       "integrity": "sha1-q2VJ1h0XLCsbh75cUI0jnI74dwU=",
       "dev": true,
       "requires": {
-        "source-map": "0.5.7"
+        "source-map": "^0.5.1"
       }
     },
     "vm-browserify": {
@@ -5825,13 +5825,13 @@
       "integrity": "sha512-WwnUClyFNRMB2NIiHgJU9RQPQNqVeFk7OmZaWf5dC5EnNa0Mgr7imBydbaJ7tGTuPM2hz1Cb4uiBvK9NVxMfog==",
       "dev": true,
       "requires": {
-        "anymatch": "2.0.0",
-        "browserify": "16.5.1",
-        "chokidar": "2.1.8",
-        "defined": "1.0.0",
-        "outpipe": "1.1.1",
-        "through2": "2.0.5",
-        "xtend": "4.0.2"
+        "anymatch": "^2.0.0",
+        "browserify": "^16.1.0",
+        "chokidar": "^2.1.1",
+        "defined": "^1.0.0",
+        "outpipe": "^1.1.0",
+        "through2": "^2.0.0",
+        "xtend": "^4.0.0"
       },
       "dependencies": {
         "browserify": {
@@ -5840,54 +5840,54 @@
           "integrity": "sha512-EQX0h59Pp+0GtSRb5rL6OTfrttlzv+uyaUVlK6GX3w11SQ0jKPKyjC/54RhPR2ib2KmfcELM06e8FxcI5XNU2A==",
           "dev": true,
           "requires": {
-            "JSONStream": "1.3.5",
-            "assert": "1.5.0",
-            "browser-pack": "6.1.0",
-            "browser-resolve": "1.11.3",
-            "browserify-zlib": "0.2.0",
-            "buffer": "5.2.1",
-            "cached-path-relative": "1.0.2",
-            "concat-stream": "1.6.2",
-            "console-browserify": "1.2.0",
-            "constants-browserify": "1.0.0",
-            "crypto-browserify": "3.12.0",
-            "defined": "1.0.0",
-            "deps-sort": "2.0.1",
-            "domain-browser": "1.2.0",
-            "duplexer2": "0.1.4",
-            "events": "2.1.0",
-            "glob": "7.1.6",
-            "has": "1.0.3",
-            "htmlescape": "1.1.1",
-            "https-browserify": "1.0.0",
-            "inherits": "2.0.4",
-            "insert-module-globals": "7.2.0",
-            "labeled-stream-splicer": "2.0.2",
-            "mkdirp-classic": "0.5.3",
-            "module-deps": "6.2.2",
-            "os-browserify": "0.3.0",
-            "parents": "1.0.1",
-            "path-browserify": "0.0.1",
-            "process": "0.11.10",
-            "punycode": "1.4.1",
-            "querystring-es3": "0.2.1",
-            "read-only-stream": "2.0.0",
-            "readable-stream": "2.3.7",
-            "resolve": "1.17.0",
-            "shasum": "1.0.2",
-            "shell-quote": "1.7.2",
-            "stream-browserify": "2.0.2",
-            "stream-http": "3.1.1",
-            "string_decoder": "1.3.0",
-            "subarg": "1.0.0",
-            "syntax-error": "1.4.0",
-            "through2": "2.0.5",
-            "timers-browserify": "1.4.2",
+            "JSONStream": "^1.0.3",
+            "assert": "^1.4.0",
+            "browser-pack": "^6.0.1",
+            "browser-resolve": "^1.11.0",
+            "browserify-zlib": "~0.2.0",
+            "buffer": "~5.2.1",
+            "cached-path-relative": "^1.0.0",
+            "concat-stream": "^1.6.0",
+            "console-browserify": "^1.1.0",
+            "constants-browserify": "~1.0.0",
+            "crypto-browserify": "^3.0.0",
+            "defined": "^1.0.0",
+            "deps-sort": "^2.0.0",
+            "domain-browser": "^1.2.0",
+            "duplexer2": "~0.1.2",
+            "events": "^2.0.0",
+            "glob": "^7.1.0",
+            "has": "^1.0.0",
+            "htmlescape": "^1.1.0",
+            "https-browserify": "^1.0.0",
+            "inherits": "~2.0.1",
+            "insert-module-globals": "^7.0.0",
+            "labeled-stream-splicer": "^2.0.0",
+            "mkdirp-classic": "^0.5.2",
+            "module-deps": "^6.0.0",
+            "os-browserify": "~0.3.0",
+            "parents": "^1.0.1",
+            "path-browserify": "~0.0.0",
+            "process": "~0.11.0",
+            "punycode": "^1.3.2",
+            "querystring-es3": "~0.2.0",
+            "read-only-stream": "^2.0.0",
+            "readable-stream": "^2.0.2",
+            "resolve": "^1.1.4",
+            "shasum": "^1.0.0",
+            "shell-quote": "^1.6.1",
+            "stream-browserify": "^2.0.0",
+            "stream-http": "^3.0.0",
+            "string_decoder": "^1.1.1",
+            "subarg": "^1.0.0",
+            "syntax-error": "^1.1.1",
+            "through2": "^2.0.0",
+            "timers-browserify": "^1.0.1",
             "tty-browserify": "0.0.1",
-            "url": "0.11.0",
-            "util": "0.10.4",
-            "vm-browserify": "1.1.2",
-            "xtend": "4.0.2"
+            "url": "~0.11.0",
+            "util": "~0.10.1",
+            "vm-browserify": "^1.0.0",
+            "xtend": "^4.0.0"
           }
         },
         "buffer": {
@@ -5896,8 +5896,8 @@
           "integrity": "sha512-c+Ko0loDaFfuPWiL02ls9Xd3GO3cPVmUobQ6t3rXNUk304u6hGq+8N/kFi+QEIKhzK3uwolVhLzszmfLmMLnqg==",
           "dev": true,
           "requires": {
-            "base64-js": "1.3.1",
-            "ieee754": "1.1.13"
+            "base64-js": "^1.0.2",
+            "ieee754": "^1.1.4"
           }
         },
         "concat-stream": {
@@ -5906,10 +5906,10 @@
           "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
           "dev": true,
           "requires": {
-            "buffer-from": "1.1.1",
-            "inherits": "2.0.4",
-            "readable-stream": "2.3.7",
-            "typedarray": "0.0.6"
+            "buffer-from": "^1.0.0",
+            "inherits": "^2.0.3",
+            "readable-stream": "^2.2.2",
+            "typedarray": "^0.0.6"
           }
         },
         "detective": {
@@ -5918,9 +5918,9 @@
           "integrity": "sha512-6SsIx+nUUbuK0EthKjv0zrdnajCCXVYGmbYYiYjFVpzcjwEs/JMDZ8tPRG29J/HhN56t3GJp2cGSWDRjjot8Pg==",
           "dev": true,
           "requires": {
-            "acorn-node": "1.8.2",
-            "defined": "1.0.0",
-            "minimist": "1.2.5"
+            "acorn-node": "^1.6.1",
+            "defined": "^1.0.0",
+            "minimist": "^1.1.1"
           }
         },
         "domain-browser": {
@@ -5941,21 +5941,21 @@
           "integrity": "sha512-a9y6yDv5u5I4A+IPHTnqFxcaKr4p50/zxTjcQJaX2ws9tN/W6J6YXnEKhqRyPhl494dkcxx951onSKVezmI+3w==",
           "dev": true,
           "requires": {
-            "JSONStream": "1.3.5",
-            "browser-resolve": "1.11.3",
-            "cached-path-relative": "1.0.2",
-            "concat-stream": "1.6.2",
-            "defined": "1.0.0",
-            "detective": "5.2.0",
-            "duplexer2": "0.1.4",
-            "inherits": "2.0.4",
-            "parents": "1.0.1",
-            "readable-stream": "2.3.7",
-            "resolve": "1.17.0",
-            "stream-combiner2": "1.1.1",
-            "subarg": "1.0.0",
-            "through2": "2.0.5",
-            "xtend": "4.0.2"
+            "JSONStream": "^1.0.3",
+            "browser-resolve": "^1.7.0",
+            "cached-path-relative": "^1.0.2",
+            "concat-stream": "~1.6.0",
+            "defined": "^1.0.0",
+            "detective": "^5.2.0",
+            "duplexer2": "^0.1.2",
+            "inherits": "^2.0.1",
+            "parents": "^1.0.0",
+            "readable-stream": "^2.0.2",
+            "resolve": "^1.4.0",
+            "stream-combiner2": "^1.1.1",
+            "subarg": "^1.0.0",
+            "through2": "^2.0.0",
+            "xtend": "^4.0.0"
           }
         },
         "safe-buffer": {
@@ -5970,10 +5970,10 @@
           "integrity": "sha512-S7OqaYu0EkFpgeGFb/NPOoPLxFko7TPqtEeFg5DXPB4v/KETHG0Ln6fRFrNezoelpaDKmycEmmZ81cC9DAwgYg==",
           "dev": true,
           "requires": {
-            "builtin-status-codes": "3.0.0",
-            "inherits": "2.0.4",
-            "readable-stream": "3.6.0",
-            "xtend": "4.0.2"
+            "builtin-status-codes": "^3.0.0",
+            "inherits": "^2.0.4",
+            "readable-stream": "^3.6.0",
+            "xtend": "^4.0.2"
           },
           "dependencies": {
             "readable-stream": {
@@ -5982,9 +5982,9 @@
               "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
               "dev": true,
               "requires": {
-                "inherits": "2.0.4",
-                "string_decoder": "1.3.0",
-                "util-deprecate": "1.0.2"
+                "inherits": "^2.0.3",
+                "string_decoder": "^1.1.1",
+                "util-deprecate": "^1.0.1"
               }
             }
           }
@@ -5995,7 +5995,7 @@
           "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
           "dev": true,
           "requires": {
-            "safe-buffer": "5.2.1"
+            "safe-buffer": "~5.2.0"
           }
         },
         "vm-browserify": {
@@ -6012,7 +6012,7 @@
       "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
       "dev": true,
       "requires": {
-        "isexe": "2.0.0"
+        "isexe": "^2.0.0"
       }
     },
     "wrappy": {
diff --git a/source/src/ECS/Components/RenderableComponent.ts b/source/src/ECS/Components/RenderableComponent.ts
index 05fd3d8d..4d91f0cb 100644
--- a/source/src/ECS/Components/RenderableComponent.ts
+++ b/source/src/ECS/Components/RenderableComponent.ts
@@ -116,6 +116,9 @@ module es {
          * @param camera
          */
         public isVisibleFromCamera(camera: Camera): boolean {
+            if (!camera)
+                return false;
+
             this.isVisible = camera.bounds.intersects(this.displayObject.getBounds().union(this.bounds));
             return this.isVisible;
         }
diff --git a/source/src/ECS/Entity.ts b/source/src/ECS/Entity.ts
index 8f103394..81b9f35b 100644
--- a/source/src/ECS/Entity.ts
+++ b/source/src/ECS/Entity.ts
@@ -316,6 +316,13 @@ module es {
             this.components.update();
         }
 
+        /**
+         * 在默认渲染器中，如果Core.debugRenderEnabled为true，则调用。自定义渲染器可以选择是否调用它。
+         */
+        public debugRender(){
+            this.components.debugRender();
+        }
+
         /**
          * 将组件添加到组件列表中。返回组件。
          * @param component
diff --git a/source/src/ECS/Utils/ComponentList.ts b/source/src/ECS/Utils/ComponentList.ts
index 1194ebab..9e4806dc 100644
--- a/source/src/ECS/Utils/ComponentList.ts
+++ b/source/src/ECS/Utils/ComponentList.ts
@@ -267,5 +267,12 @@ module es {
             for (let i = 0; i < this._components.length; i++)
                 this._components[i].onDisabled();
         }
+
+        public debugRender(){
+            for (let i = 0; i < this._components.length; i ++){
+                if (this._components[i].enabled)
+                    this._components[i].debugRender();
+            }
+        }
     }
 }
diff --git a/source/src/Graphics/Renderers/IRenderable.ts b/source/src/Graphics/Renderers/IRenderable.ts
index fbfbf21c..be55800b 100644
--- a/source/src/Graphics/Renderers/IRenderable.ts
+++ b/source/src/Graphics/Renderers/IRenderable.ts
@@ -34,6 +34,11 @@ module es {
          * @param camera
          */
         render(camera: Camera);
+
+        /**
+         * 只有在没有碰撞器时才呈现边界。总是在原点上渲染一个正方形。
+         */
+        debugRender();
     }
 
     /**
diff --git a/source/src/Graphics/Renderers/RenderLayerExcludeRenderer.ts b/source/src/Graphics/Renderers/RenderLayerExcludeRenderer.ts
new file mode 100644
index 00000000..f62aeafb
--- /dev/null
+++ b/source/src/Graphics/Renderers/RenderLayerExcludeRenderer.ts
@@ -0,0 +1,40 @@
+module es {
+    /**
+     * 除了一个渲染层，只渲染所有的渲染器。
+     * 当与RenderLayerRenderer一起使用时，将UI渲染与游戏的其他部分分离开来。
+     */
+    export class RenderLayerExcludeRenderer extends Renderer {
+        public excludedRenderLayers: number[];
+
+        constructor(renderOrder: number, ...excludedRenderLayers: number[]){
+            super(renderOrder, null);
+            this.excludedRenderLayers = excludedRenderLayers;
+        }
+
+        public render(scene: es.Scene) {
+            let cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
+
+            for (let i = 0; i < scene.renderableComponents.count; i ++) {
+                let renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
+
+            if (this.shouldDebugRender && Core.debugRenderEndabled)
+                this.debugRender(scene, cam);
+        }
+
+        protected debugRender(scene: es.Scene, cam: es.Camera) {
+            for (let i = 0; i < scene.renderableComponents.count; i ++){
+                let renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    renderable.debugRender();
+            }
+
+            super.debugRender(scene, cam);
+        }
+    }
+}
\ No newline at end of file
diff --git a/source/src/Graphics/Renderers/Renderer.ts b/source/src/Graphics/Renderers/Renderer.ts
index e761e4a8..5b68c370 100644
--- a/source/src/Graphics/Renderers/Renderer.ts
+++ b/source/src/Graphics/Renderers/Renderer.ts
@@ -13,6 +13,23 @@ module es {
          * 指定场景调用渲染器的顺序
          */
         public readonly renderOrder: number = 0;
+        /**
+         * 如果renderTarget不是null，这个渲染器将渲染到渲染目标而不是屏幕
+         */
+        public renderTexture: egret.RenderTexture;
+        /**
+         * 这个渲染器的标志，决定它是否应该调试渲染。
+         * render方法接收一个bool (debugRenderEnabled)，让渲染器知道全局调试渲染是否打开/关闭。
+         * 渲染器然后使用本地bool来决定它是否应该调试渲染。
+         */
+        public shouldDebugRender: boolean = true;
+        /**
+         * 如果为true，场景将使用场景渲染目标调用setRenderTarget。
+         * 如果渲染器有渲染纹理，默认实现返回true
+         */
+        public get wantsToRenderToSceneRenderTarget(): boolean{
+            return !!this.renderTexture;
+        }
 
         protected constructor(renderOrder: number, camera: Camera = null) {
             this.camera = camera;
@@ -62,5 +79,18 @@ module es {
         protected renderAfterStateCheck(renderable: IRenderable, cam: Camera) {
             renderable.render(cam);
         }
+
+        /**
+         * 默认debugRender方法只循环遍历所有实体并调用entity.debugRender
+         * @param scene
+         * @param cam
+         */
+        protected debugRender(scene: Scene, cam: Camera){
+            for (let i = 0; i < scene.entities.count; i ++){
+                let entity = scene.entities.buffer[i];
+                if (entity.enabled)
+                    entity.debugRender();
+            }
+        }
     }
 }
diff --git a/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts b/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts
index 0fbe20c0..c71194d2 100644
--- a/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts
+++ b/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts
@@ -3,7 +3,47 @@ module es {
      * 渲染器使用自己的不移动的摄像机进行渲染。
      */
     export class ScreenSpaceRenderer extends Renderer {
+        public renderLayers: number[];
+
+        constructor(renderOrder: number, ...renderLayers: number[]){
+            super(renderOrder, null);
+            renderLayers.sort();
+            renderLayers.reverse();
+            this.renderLayers = renderLayers;
+        }
+
         public render(scene: Scene) {
+            this.beginRender(this.camera);
+
+            for (let i = 0; i < this.renderLayers.length; i ++){
+                let renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (let j = 0; j < renderables.length; j ++){
+                    let renderable = renderables[j];
+                    if (renderable.enabled && renderable.isVisibleFromCamera(this.camera))
+                        this.renderAfterStateCheck(renderable, this.camera);
+                }
+            }
+
+            if (this.shouldDebugRender && Core.debugRenderEndabled)
+                this.debugRender(scene, this.camera);
+        }
+
+        protected debugRender(scene: es.Scene, cam: es.Camera) {
+            for (let i = 0; i < this.renderLayers.length; i ++){
+                let renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (let j = 0; j < renderables.length; j ++){
+                    let entity = renderables[j];
+                    if (entity.enabled)
+                        entity.debugRender();
+                }
+            }
+        }
+
+        public onSceneBackBufferSizeChanged(newWidth: number, newHeight: number) {
+            super.onSceneBackBufferSizeChanged(newWidth, newHeight);
+
+            if (!this.camera)
+                this.camera = Core.scene.createEntity("screenspace camera").addComponent(new Camera());
         }
     }
 }
diff --git a/source/src/Tiled/TiledMapLoader.ts b/source/src/Tiled/TiledMapLoader.ts
index 278cd64f..403487f6 100644
--- a/source/src/Tiled/TiledMapLoader.ts
+++ b/source/src/Tiled/TiledMapLoader.ts
@@ -1,5 +1,5 @@
 module es {
-    import Bitmap = egret.Bitmap;
+
 
     export class TiledMapLoader {
         public static loadTmxMap(map: TmxMap, filePath: string) {
@@ -266,18 +266,16 @@ module es {
             // firstgid总是在TMX中，而不是在TSX中
             let xFirstGid = xTileset["firstgid"];
             let firstGid = xFirstGid;
-            let source = xTileset["image"];
+            let source = xTileset["source"];
 
             // 如果是嵌入式TmxTileset，即不是外部的，source将为null
             if (source != undefined) {
                 source = map.tmxDirectory + source;
                 // 其他所有内容都在TSX文件中
-                let xDocTileset = await RES.getResByUrl(source, null, this, RES.ResourceItem.TYPE_IMAGE).catch(err => {
+                let xDocTileset = await RES.getResByUrl(source).catch(err => {
                     throw new Error(err);
                 });
-                let tileset = this.loadTmxTileset(new TmxTileset(), map, xDocTileset["tileset"], firstGid);
-
-                return tileset;
+                return this.loadTmxTileset(new TmxTileset(), map, xDocTileset["tileset"], firstGid);
             }
 
             return this.loadTmxTileset(new TmxTileset(), map, xTileset, firstGid);
@@ -299,7 +297,9 @@ module es {
 
             let xImage = xTileset["image"];
             if (xImage)
-                tileset.image = await this.loadTmxImage(new TmxImage(), xTileset, map.tmxDirectory).catch(err => {
+                await this.loadTmxImage(new TmxImage(), xTileset, map.tmxDirectory).then(image => {
+                    tileset.image = image;
+                }).catch(err => {
                     throw new Error(err);
                 });