drgame-cc 1.0.13 → 1.0.14

package/bin/drgame.js

@@ -0,0 +1,3010 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+define("BtnExtra", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _a = cc._decorator, ccclass = _a.ccclass, property = _a.property;
+    var BtnExtra = (function (_super) {
+        __extends(BtnExtra, _super);
+        function BtnExtra() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.hoverSprite = null;
+            _this.normalSprite = null;
+            return _this;
+        }
+        __decorate([
+            property(cc.SpriteFrame),
+            __metadata("design:type", cc.SpriteFrame)
+        ], BtnExtra.prototype, "hoverSprite", void 0);
+        __decorate([
+            property(cc.SpriteFrame),
+            __metadata("design:type", cc.SpriteFrame)
+        ], BtnExtra.prototype, "normalSprite", void 0);
+        BtnExtra = __decorate([
+            ccclass('BtnExtra')
+        ], BtnExtra);
+        return BtnExtra;
+    }(cc.Component));
+    exports.default = BtnExtra;
+});
+define("Define", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EVideoScene = void 0;
+    var EVideoScene;
+    (function (EVideoScene) {
+        EVideoScene["UseProp"] = "use_prop";
+        EVideoScene["StartGame"] = "start_game";
+        EVideoScene["RevivePop"] = "revive_pop";
+        EVideoScene["BuySkin"] = "buy_skin";
+        EVideoScene["BuyProp"] = "buy_prop";
+        EVideoScene["GameOver"] = "game_over";
+        EVideoScene["LevelComplete"] = "level_complete";
+        EVideoScene["Shop"] = "shop";
+        EVideoScene["DailyReward"] = "daily_reward";
+        EVideoScene["Boost"] = "boost";
+    })(EVideoScene || (exports.EVideoScene = EVideoScene = {}));
+});
+define("config/TvUiConfig", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createDefaultTvUiConfig = createDefaultTvUiConfig;
+    function createDefaultTvUiConfig() {
+        return {
+            designWidth: 1920,
+            designHeight: 1080,
+            cpId: "ppl",
+            version: "1.0.0",
+            configPath: "tvui/config/default",
+            defaultScopeId: "page",
+            enableRemoteInput: true,
+            enableLifecycle: true,
+            focus: {
+                enabled: true,
+                frameEnabled: false,
+                framePadding: 10,
+                frameColor: "#ffd451",
+                frameOpacity: 230,
+                lineWidth: 5,
+                animationTime: 0.1,
+                defaultIconKey: "default",
+                iconPlacement: "bottomRight",
+                iconOffsetX: -20,
+                iconOffsetY: 20,
+                zIndex: 800
+            },
+            icons: {
+                "default": {
+                    path: "tvui/icons/pointer-yellow-60",
+                    width: 60,
+                    height: 60,
+                    offsetX: -20,
+                    offsetY: 20
+                },
+                "yellow": {
+                    path: "tvui/icons/pointer-yellow-60",
+                    width: 60,
+                    height: 60,
+                    offsetX: -20,
+                    offsetY: 20
+                },
+                "blue": {
+                    path: "tvui/icons/pointer-blue-60",
+                    width: 60,
+                    height: 60,
+                    offsetX: -20,
+                    offsetY: 20
+                },
+                "pink": {
+                    path: "tvui/icons/pointer-pink-60",
+                    width: 60,
+                    height: 60,
+                    offsetX: -20,
+                    offsetY: 20
+                }
+            },
+            adSdk: {
+                platform: "xiaomi"
+            },
+            ads: {
+                "reward": {
+                    enabled: true,
+                    mode: "reward",
+                    channels: [
+                        { type: "aggregate", priority: 1, reward_type: "reward" },
+                        { type: "mock", priority: 100 }
+                    ]
+                },
+                "popup": {
+                    enabled: true,
+                    mode: "popup",
+                    channels: [
+                        { type: "aggregate", priority: 1 },
+                        { type: "mock", priority: 100 }
+                    ]
+                },
+                "game": {
+                    enabled: true,
+                    mode: "popup",
+                    channels: [
+                        { type: "aggregate", priority: 1 },
+                        { type: "mock", priority: 100 }
+                    ]
+                }
+            }
+        };
+    }
+});
+define("config/TvUiConfigManager", ["require", "exports", "config/TvUiConfig"], function (require, exports, TvUiConfig_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var TvUiConfigManager = (function () {
+        function TvUiConfigManager() {
+        }
+        TvUiConfigManager.init = function (config, callback) {
+            var _this = this;
+            this.projectConfig = config || {};
+            this.rebuildConfig();
+            this.loadResourceConfig(function (loaded) {
+                if (loaded) {
+                    _this.rebuildConfig();
+                    _this.emitChanged();
+                }
+                if (callback)
+                    callback(_this.config);
+            });
+        };
+        TvUiConfigManager.getConfig = function () {
+            return this.config;
+        };
+        TvUiConfigManager.updateConfig = function (config, saveLocal) {
+            if (saveLocal === void 0) { saveLocal = false; }
+            if (saveLocal) {
+                this.saveLocalConfig(config);
+            }
+            else {
+                this.projectConfig = this.merge(this.projectConfig || {}, config || {});
+            }
+            this.rebuildConfig();
+            this.emitChanged();
+        };
+        TvUiConfigManager.onChanged = function (listener) {
+            if (!listener)
+                return;
+            if (this.listeners.indexOf(listener) < 0)
+                this.listeners.push(listener);
+        };
+        TvUiConfigManager.offChanged = function (listener) {
+            var index = this.listeners.indexOf(listener);
+            if (index >= 0)
+                this.listeners.splice(index, 1);
+        };
+        TvUiConfigManager.rebuildConfig = function () {
+            var next = this.merge((0, TvUiConfig_1.createDefaultTvUiConfig)(), this.resourceConfig || {});
+            next = this.merge(next, this.projectConfig || {});
+            next = this.merge(next, this.loadLocalConfig());
+            this.config = next;
+        };
+        TvUiConfigManager.loadResourceConfig = function (callback) {
+            var _this = this;
+            var path = (this.projectConfig && this.projectConfig.configPath) || this.config.configPath;
+            if (!path || !cc || !cc.loader || !cc.loader.loadRes) {
+                callback(false);
+                return;
+            }
+            cc.loader.loadRes(path, function (error, asset) {
+                if (error || !asset) {
+                    callback(false);
+                    return;
+                }
+                var json = asset.json || asset;
+                _this.resourceConfig = json || null;
+                callback(!!_this.resourceConfig);
+            });
+        };
+        TvUiConfigManager.loadLocalConfig = function () {
+            try {
+                var raw = cc.sys.localStorage.getItem(this.LOCAL_KEY);
+                if (!raw)
+                    return {};
+                return JSON.parse(raw) || {};
+            }
+            catch (e) {
+                return {};
+            }
+        };
+        TvUiConfigManager.saveLocalConfig = function (config) {
+            var local = this.merge(this.loadLocalConfig(), config || {});
+            try {
+                cc.sys.localStorage.setItem(this.LOCAL_KEY, JSON.stringify(local));
+            }
+            catch (e) {
+                console.warn("[TvUiConfigManager] save local config failed", e);
+            }
+        };
+        TvUiConfigManager.emitChanged = function () {
+            for (var i = 0; i < this.listeners.length; i++) {
+                this.listeners[i](this.config);
+            }
+        };
+        TvUiConfigManager.merge = function (base, extra) {
+            var result = {};
+            var key;
+            base = base || {};
+            extra = extra || {};
+            for (key in base) {
+                if (!base.hasOwnProperty(key))
+                    continue;
+                result[key] = this.clone(base[key]);
+            }
+            for (key in extra) {
+                if (!extra.hasOwnProperty(key))
+                    continue;
+                if (this.isPlainObject(result[key]) && this.isPlainObject(extra[key])) {
+                    result[key] = this.merge(result[key], extra[key]);
+                }
+                else {
+                    result[key] = this.clone(extra[key]);
+                }
+            }
+            return result;
+        };
+        TvUiConfigManager.clone = function (value) {
+            if (value instanceof Array) {
+                var list = [];
+                for (var i = 0; i < value.length; i++)
+                    list.push(this.clone(value[i]));
+                return list;
+            }
+            if (this.isPlainObject(value)) {
+                return this.merge({}, value);
+            }
+            return value;
+        };
+        TvUiConfigManager.isPlainObject = function (value) {
+            return value && typeof value == "object" && !(value instanceof Array);
+        };
+        TvUiConfigManager.LOCAL_KEY = "tvui_local_config";
+        TvUiConfigManager.config = (0, TvUiConfig_1.createDefaultTvUiConfig)();
+        TvUiConfigManager.projectConfig = null;
+        TvUiConfigManager.resourceConfig = null;
+        TvUiConfigManager.listeners = [];
+        return TvUiConfigManager;
+    }());
+    exports.default = TvUiConfigManager;
+});
+define("input/KeyCodeAdapter", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TvRemoteKey = void 0;
+    var TvRemoteKey;
+    (function (TvRemoteKey) {
+        TvRemoteKey["Back"] = "back";
+        TvRemoteKey["Ok"] = "ok";
+        TvRemoteKey["Left"] = "left";
+        TvRemoteKey["Right"] = "right";
+        TvRemoteKey["Up"] = "up";
+        TvRemoteKey["Down"] = "down";
+        TvRemoteKey["Pause"] = "pause";
+        TvRemoteKey["Unknown"] = "unknown";
+    })(TvRemoteKey || (exports.TvRemoteKey = TvRemoteKey = {}));
+    var KeyCodeAdapter = (function () {
+        function KeyCodeAdapter() {
+        }
+        KeyCodeAdapter.toRemoteKey = function (keyCode) {
+            if ([0, 4, 8, 27, 10009].indexOf(keyCode) >= 0)
+                return TvRemoteKey.Back;
+            if ([13, 23, 66].indexOf(keyCode) >= 0)
+                return TvRemoteKey.Ok;
+            if ([80].indexOf(keyCode) >= 0)
+                return TvRemoteKey.Pause;
+            if ([21, 37].indexOf(keyCode) >= 0)
+                return TvRemoteKey.Left;
+            if ([19, 38].indexOf(keyCode) >= 0)
+                return TvRemoteKey.Up;
+            if ([22, 39].indexOf(keyCode) >= 0)
+                return TvRemoteKey.Right;
+            if ([20, 40].indexOf(keyCode) >= 0)
+                return TvRemoteKey.Down;
+            return TvRemoteKey.Unknown;
+        };
+        return KeyCodeAdapter;
+    }());
+    exports.default = KeyCodeAdapter;
+});
+define("focus/FocusScope", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var FocusScope = (function () {
+        function FocusScope(scopeId, root) {
+            this.lastFocusId = "";
+            this.scopeId = scopeId || "page";
+            this.root = root || null;
+        }
+        return FocusScope;
+    }());
+    exports.default = FocusScope;
+});
+define("focus/FocusManager", ["require", "exports", "input/KeyCodeAdapter", "focus/FocusScope"], function (require, exports, KeyCodeAdapter_1, FocusScope_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var FocusManager = (function () {
+        function FocusManager() {
+        }
+        FocusManager.setCursor = function (options) {
+            this.cursorOptions = options;
+        };
+        FocusManager.getCursor = function () {
+            return this.cursorOptions;
+        };
+        FocusManager.register = function (target, options) {
+            if (options === void 0) { options = {}; }
+            var node = this.resolveNode(target);
+            if (!node)
+                return;
+            var component = this.resolveComponent(target, node);
+            var previousItem = this.findItemByNode(node);
+            var previousBaseScale = previousItem ? { x: previousItem.baseScaleX, y: previousItem.baseScaleY } : null;
+            this.unregister(node);
+            var focusId = options.focusId || (component && component.focusId) || node.uuid || this.createFocusId(node);
+            this.unregisterById(focusId);
+            var baseScale = this.getNodeBaseScale(node, previousBaseScale);
+            var item = {
+                node: node,
+                root: options.root,
+                scopeId: options.scopeId || (component && component.scopeId) || this.activeScopeId || "page",
+                focusId: focusId,
+                iconKey: options.iconKey || (component && component.iconKey) || "",
+                up: options.up || (component && component.up) || "",
+                down: options.down || (component && component.down) || "",
+                left: options.left || (component && component.left) || "",
+                right: options.right || (component && component.right) || "",
+                onClick: options.onClick,
+                onFocus: options.onFocus || (component && component.onFocus),
+                onBlur: options.onBlur || (component && component.onBlur),
+                component: component,
+                baseScaleX: baseScale.x,
+                baseScaleY: baseScale.y,
+                focusScale: options.focusScale || (component && component.focusScale) || 1.08,
+                showCursor: options.showCursor !== false
+            };
+            this.items.push(item);
+            this.itemMap[item.focusId] = item;
+            this.ensureFocus();
+        };
+        FocusManager.unregister = function (target) {
+            var node = this.resolveNode(target);
+            if (!node)
+                return;
+            for (var i = this.items.length - 1; i >= 0; i--) {
+                if (this.items[i].node == node) {
+                    this.removeItemAt(i);
+                }
+            }
+            this.ensureFocus();
+        };
+        FocusManager.unregisterByRoot = function (root) {
+            if (!root)
+                return;
+            for (var i = this.items.length - 1; i >= 0; i--) {
+                var item = this.items[i];
+                if (item.root == root || this.isChildOf(item.node, root)) {
+                    this.removeItemAt(i);
+                }
+            }
+            this.ensureFocus();
+        };
+        FocusManager.unregisterById = function (focusId) {
+            if (!focusId)
+                return;
+            for (var i = this.items.length - 1; i >= 0; i--) {
+                if (this.items[i].focusId == focusId)
+                    this.removeItemAt(i);
+            }
+        };
+        FocusManager.registerButtons = function (root, options) {
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            if (!root)
+                return;
+            this.unregisterByRoot(root);
+            this.walk(root, function (node) {
+                if (node instanceof cc.Scene)
+                    return;
+                var button = node.getComponent(cc.Button);
+                if (!button)
+                    return;
+                _this.register(node, {
+                    root: root,
+                    scopeId: options.scopeId || _this.activeScopeId,
+                    iconKey: options.iconKey,
+                    focusScale: options.focusScale || 1.08,
+                    onClick: function () { return _this.invokeButton(button); }
+                });
+            });
+            this.ensureFocus();
+        };
+        FocusManager.pushScope = function (scopeId, root, firstFocus) {
+            scopeId = scopeId || "modal";
+            var currentScope = this.getActiveScope();
+            if (currentScope)
+                currentScope.lastFocusId = this.currentFocusId;
+            for (var i = 0; i < this.scopes.length; i++) {
+                if (this.scopes[i].scopeId == scopeId) {
+                    this.scopes.splice(i, 1);
+                    break;
+                }
+            }
+            this.scopes.push(new FocusScope_1.default(scopeId, root));
+            this.activeScopeId = scopeId;
+            this.setFocusById("", true);
+            if (firstFocus)
+                this.focus(firstFocus);
+            this.ensureFocus();
+        };
+        FocusManager.popScope = function (scopeId) {
+            if (this.scopes.length <= 1)
+                return;
+            var target = scopeId || this.activeScopeId;
+            for (var i = this.scopes.length - 1; i >= 1; i--) {
+                if (this.scopes[i].scopeId == target) {
+                    this.scopes.splice(i, 1);
+                    break;
+                }
+            }
+            var active = this.scopes[this.scopes.length - 1];
+            this.activeScopeId = active ? active.scopeId : "page";
+            var restored = active && active.lastFocusId ? this.focus(active.lastFocusId) : false;
+            if (!restored) {
+                this.setFocusById("", true);
+                this.ensureFocus();
+            }
+        };
+        FocusManager.reset = function () {
+            var old = this.getCurrentFocusItem();
+            if (old)
+                this.setFocusVisual(old, false, true);
+            this.items = [];
+            this.itemMap = {};
+            this.currentFocusId = "";
+            this.scopes = [new FocusScope_1.default("page")];
+            this.activeScopeId = "page";
+            this.emitFocusChanged(null, old);
+        };
+        FocusManager.focus = function (target) {
+            this.cleanup();
+            if (!target)
+                return false;
+            var item = null;
+            if (typeof target == "string") {
+                item = this.itemMap[target];
+            }
+            else {
+                for (var i = 0; i < this.items.length; i++) {
+                    if (this.items[i].node == target) {
+                        item = this.items[i];
+                        break;
+                    }
+                }
+            }
+            if (!item || !this.isItemActive(item) || !this.isInActiveScope(item))
+                return false;
+            this.setFocusById(item.focusId);
+            return true;
+        };
+        FocusManager.focusNode = function (node) {
+            return this.focus(node);
+        };
+        FocusManager.move = function (direction) {
+            this.cleanup();
+            var current = this.getCurrentFocusItem();
+            if (!current) {
+                this.ensureFocus();
+                return !!this.getCurrentFocusItem();
+            }
+            var explicitId = current[direction];
+            if (explicitId && this.focus(explicitId))
+                return true;
+            var vector = this.getDirectionVector(direction);
+            var currentCenter = this.getWorldCenter(current.node);
+            var best = null;
+            var bestScore = Number.MAX_VALUE;
+            for (var i = 0; i < this.items.length; i++) {
+                var item = this.items[i];
+                if (item == current || !this.isItemActive(item) || !this.isInActiveScope(item))
+                    continue;
+                var center = this.getWorldCenter(item.node);
+                var dx = center.x - currentCenter.x;
+                var dy = center.y - currentCenter.y;
+                if (vector.x != 0 && dx * vector.x <= 8)
+                    continue;
+                if (vector.y != 0 && dy * vector.y <= 8)
+                    continue;
+                var primary = vector.x != 0 ? Math.abs(dx) : Math.abs(dy);
+                var secondary = vector.x != 0 ? Math.abs(dy) : Math.abs(dx);
+                var score = primary + secondary * 2;
+                if (score < bestScore) {
+                    bestScore = score;
+                    best = item;
+                }
+            }
+            if (best) {
+                this.setFocusById(best.focusId);
+                return true;
+            }
+            return this.moveByOrder(direction == "left" || direction == "down" ? -1 : 1);
+        };
+        FocusManager.confirm = function () {
+            this.ensureFocus();
+            var item = this.getCurrentFocusItem();
+            if (!item)
+                return false;
+            if (item.onClick) {
+                item.onClick();
+                return true;
+            }
+            if (item.component && item.component.onConfirm) {
+                item.component.onConfirm();
+                return true;
+            }
+            this.invokeButton(item.node.getComponent(cc.Button));
+            return true;
+        };
+        FocusManager.back = function () {
+            return false;
+        };
+        FocusManager.handleKey = function (keyCode) {
+            var key = KeyCodeAdapter_1.default.toRemoteKey(keyCode);
+            if (key == KeyCodeAdapter_1.TvRemoteKey.Ok)
+                return this.confirm();
+            if (key == KeyCodeAdapter_1.TvRemoteKey.Left)
+                return this.move("left");
+            if (key == KeyCodeAdapter_1.TvRemoteKey.Right)
+                return this.move("right");
+            if (key == KeyCodeAdapter_1.TvRemoteKey.Up)
+                return this.move("up");
+            if (key == KeyCodeAdapter_1.TvRemoteKey.Down)
+                return this.move("down");
+            if (key == KeyCodeAdapter_1.TvRemoteKey.Back)
+                return this.back();
+            return false;
+        };
+        FocusManager.clickCurrent = function () {
+            return this.confirm();
+        };
+        FocusManager.getCurrentFocusItem = function () {
+            var item = this.itemMap[this.currentFocusId];
+            return this.isItemActive(item) ? item : null;
+        };
+        FocusManager.getActiveScopeId = function () {
+            return this.activeScopeId;
+        };
+        FocusManager.onFocusChanged = function (listener) {
+            if (!listener)
+                return;
+            if (this.listeners.indexOf(listener) < 0)
+                this.listeners.push(listener);
+        };
+        FocusManager.offFocusChanged = function (listener) {
+            var index = this.listeners.indexOf(listener);
+            if (index >= 0)
+                this.listeners.splice(index, 1);
+        };
+        FocusManager.setFocusById = function (focusId, silent) {
+            if (silent === void 0) { silent = false; }
+            if (focusId == this.currentFocusId && focusId) {
+                var current_1 = this.getCurrentFocusItem();
+                if (current_1 && !silent) {
+                    this.setFocusVisual(current_1, true);
+                    this.emitFocusChanged(current_1, current_1);
+                }
+                return;
+            }
+            var previous = this.getCurrentFocusItem();
+            if (previous)
+                this.setFocusVisual(previous, false);
+            this.currentFocusId = focusId || "";
+            var current = this.getCurrentFocusItem();
+            if (current) {
+                var scope = this.getActiveScope();
+                if (scope)
+                    scope.lastFocusId = current.focusId;
+                this.setFocusVisual(current, true);
+            }
+            if (!silent)
+                this.emitFocusChanged(current, previous);
+            if (silent && previous)
+                this.emitFocusChanged(null, previous);
+        };
+        FocusManager.setFocusVisual = function (item, focused, immediate) {
+            if (immediate === void 0) { immediate = false; }
+            if (!item || !item.node || !item.node.isValid)
+                return;
+            this.setButtonSpriteVisual(item, focused);
+            item.node.stopActionByTag(this.FOCUS_SCALE_ACTION_TAG);
+            var targetScaleX = focused ? item.baseScaleX * item.focusScale : item.baseScaleX;
+            var targetScaleY = focused ? item.baseScaleY * item.focusScale : item.baseScaleY;
+            if (immediate) {
+                item.node.setScale(targetScaleX, targetScaleY);
+            }
+            else {
+                var action = cc.scaleTo(0.08, targetScaleX, targetScaleY);
+                action.setTag(this.FOCUS_SCALE_ACTION_TAG);
+                item.node.runAction(action);
+            }
+            if (focused && item.onFocus)
+                item.onFocus.call(item.component || item.node);
+            if (!focused && item.onBlur)
+                item.onBlur.call(item.component || item.node);
+        };
+        FocusManager.setButtonSpriteVisual = function (item, focused) {
+            var button = item.node.getComponent(cc.Button);
+            if (!button || button.transition != cc.Button.Transition.SPRITE)
+                return;
+            var target = button.target || button.node;
+            if (!target || !target.isValid)
+                return;
+            var sprite = target.getComponent(cc.Sprite);
+            if (!sprite)
+                return;
+            var spriteFrame = focused ? (button.hoverSprite || button.pressedSprite) : button.normalSprite;
+            if (spriteFrame)
+                sprite.spriteFrame = spriteFrame;
+        };
+        FocusManager.ensureFocus = function () {
+            this.cleanup();
+            if (this.getCurrentFocusItem())
+                return;
+            var activeScope = this.getActiveScope();
+            if (activeScope && activeScope.lastFocusId && this.focus(activeScope.lastFocusId))
+                return;
+            for (var i = 0; i < this.items.length; i++) {
+                var item = this.items[i];
+                if (this.isItemActive(item) && this.isInActiveScope(item)) {
+                    this.setFocusById(item.focusId);
+                    return;
+                }
+            }
+        };
+        FocusManager.moveByOrder = function (step) {
+            var activeItems = [];
+            for (var i = 0; i < this.items.length; i++) {
+                if (this.isItemActive(this.items[i]) && this.isInActiveScope(this.items[i]))
+                    activeItems.push(this.items[i]);
+            }
+            if (activeItems.length <= 0)
+                return false;
+            var index = 0;
+            for (var i = 0; i < activeItems.length; i++) {
+                if (activeItems[i].focusId == this.currentFocusId) {
+                    index = i;
+                    break;
+                }
+            }
+            var next = (index + step + activeItems.length) % activeItems.length;
+            this.setFocusById(activeItems[next].focusId);
+            return true;
+        };
+        FocusManager.removeItemAt = function (index) {
+            var item = this.items[index];
+            if (!item)
+                return;
+            this.setFocusVisual(item, false, true);
+            delete this.itemMap[item.focusId];
+            this.items.splice(index, 1);
+            if (this.currentFocusId == item.focusId) {
+                this.currentFocusId = "";
+                this.emitFocusChanged(null, item);
+            }
+        };
+        FocusManager.cleanup = function () {
+            for (var i = this.items.length - 1; i >= 0; i--) {
+                var item = this.items[i];
+                if (!item.node || !item.node.isValid)
+                    this.removeItemAt(i);
+            }
+        };
+        FocusManager.isItemActive = function (item) {
+            if (!item || !item.node || !item.node.isValid || !item.node.activeInHierarchy)
+                return false;
+            var button = item.node.getComponent(cc.Button);
+            return !button || button.interactable;
+        };
+        FocusManager.isInActiveScope = function (item) {
+            return !!item && item.scopeId == this.activeScopeId;
+        };
+        FocusManager.getActiveScope = function () {
+            for (var i = this.scopes.length - 1; i >= 0; i--) {
+                if (this.scopes[i].scopeId == this.activeScopeId)
+                    return this.scopes[i];
+            }
+            return null;
+        };
+        FocusManager.getWorldCenter = function (node) {
+            var box = node.getBoundingBoxToWorld();
+            return cc.v2(box.x + box.width / 2, box.y + box.height / 2);
+        };
+        FocusManager.getDirectionVector = function (direction) {
+            if (direction == "left")
+                return cc.v2(-1, 0);
+            if (direction == "right")
+                return cc.v2(1, 0);
+            if (direction == "up")
+                return cc.v2(0, 1);
+            return cc.v2(0, -1);
+        };
+        FocusManager.invokeButton = function (button) {
+            if (!button || !button.node || !button.node.activeInHierarchy || !button.interactable)
+                return;
+            if (button.clickEvents && button.clickEvents.length > 0) {
+                cc.Component.EventHandler.emitEvents(button.clickEvents, null);
+                var event = new cc.Event.EventCustom(cc.Node.EventType.TOUCH_END, true);
+                button.node.emit(cc.Node.EventType.TOUCH_END, event);
+            }
+            else {
+                var event = new cc.Event.EventCustom(cc.Node.EventType.TOUCH_END, true);
+                button.node.emit(cc.Node.EventType.TOUCH_END, event);
+            }
+        };
+        FocusManager.emitFocusChanged = function (item, previous) {
+            for (var i = 0; i < this.listeners.length; i++) {
+                this.listeners[i](item, previous);
+            }
+        };
+        FocusManager.resolveNode = function (target) {
+            if (!target)
+                return null;
+            if (target instanceof cc.Node)
+                return target;
+            return target.node || null;
+        };
+        FocusManager.resolveComponent = function (target, node) {
+            if (!target || target instanceof cc.Node)
+                return node.getComponent("FocusItem");
+            return target;
+        };
+        FocusManager.findItemByNode = function (node) {
+            if (!node)
+                return null;
+            for (var i = 0; i < this.items.length; i++) {
+                if (this.items[i].node == node)
+                    return this.items[i];
+            }
+            return null;
+        };
+        FocusManager.getNodeBaseScale = function (node, preferred) {
+            var nodeAny = node;
+            var storedX = nodeAny[this.BASE_SCALE_X_KEY];
+            var storedY = nodeAny[this.BASE_SCALE_Y_KEY];
+            if (this.isValidScale(storedX) && this.isValidScale(storedY)) {
+                return { x: storedX, y: storedY };
+            }
+            var baseScale = preferred || {
+                x: this.readScale(node, "scaleX"),
+                y: this.readScale(node, "scaleY")
+            };
+            nodeAny[this.BASE_SCALE_X_KEY] = baseScale.x;
+            nodeAny[this.BASE_SCALE_Y_KEY] = baseScale.y;
+            return baseScale;
+        };
+        FocusManager.readScale = function (node, key) {
+            var nodeAny = node;
+            var value = nodeAny[key];
+            if (this.isValidScale(value))
+                return value;
+            value = nodeAny.scale;
+            return this.isValidScale(value) ? value : 1;
+        };
+        FocusManager.isValidScale = function (value) {
+            return typeof value == "number" && isFinite(value);
+        };
+        FocusManager.createFocusId = function (node) {
+            return "focus_" + (node.name || "node") + "_" + this.items.length;
+        };
+        FocusManager.walk = function (node, visitor) {
+            visitor(node);
+            for (var i = 0; i < node.childrenCount; i++) {
+                this.walk(node.children[i], visitor);
+            }
+        };
+        FocusManager.isChildOf = function (node, root) {
+            var cur = node;
+            while (cur) {
+                if (cur == root)
+                    return true;
+                cur = cur.parent;
+            }
+            return false;
+        };
+        FocusManager.FOCUS_SCALE_ACTION_TAG = 9911;
+        FocusManager.BASE_SCALE_X_KEY = "__tvFocusBaseScaleX";
+        FocusManager.BASE_SCALE_Y_KEY = "__tvFocusBaseScaleY";
+        FocusManager.items = [];
+        FocusManager.itemMap = {};
+        FocusManager.currentFocusId = "";
+        FocusManager.scopes = [new FocusScope_1.default("page")];
+        FocusManager.activeScopeId = "page";
+        FocusManager.listeners = [];
+        FocusManager.cursorOptions = null;
+        return FocusManager;
+    }());
+    exports.default = FocusManager;
+});
+define("icon/IconManager", ["require", "exports", "config/TvUiConfigManager"], function (require, exports, TvUiConfigManager_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var IconManager = (function () {
+        function IconManager() {
+        }
+        IconManager.init = function () {
+            var _this = this;
+            if (this.inited)
+                return;
+            this.inited = true;
+            TvUiConfigManager_1.default.onChanged(function () {
+                _this.cache = {};
+            });
+        };
+        IconManager.getIconConfig = function (iconKey) {
+            var config = TvUiConfigManager_1.default.getConfig();
+            var key = iconKey || (config.focus && config.focus.defaultIconKey) || "default";
+            var icons = config.icons || {};
+            return icons[key] || icons["default"];
+        };
+        IconManager.getSpriteFrame = function (iconKey, callback) {
+            var iconConfig = this.getIconConfig(iconKey);
+            if (!iconConfig) {
+                callback(null, null);
+                return;
+            }
+            var cacheKey = iconConfig.url || iconConfig.path || iconKey || "default";
+            if (this.cache[cacheKey]) {
+                callback(this.cache[cacheKey], iconConfig);
+                return;
+            }
+            if (iconConfig.url) {
+                this.loadRemote(iconConfig, cacheKey, callback);
+                return;
+            }
+            this.loadLocal(iconConfig, cacheKey, callback);
+        };
+        IconManager.setIconTheme = function (iconKey) {
+            var config = TvUiConfigManager_1.default.getConfig();
+            if (!config.icons || !config.icons[iconKey])
+                return;
+            TvUiConfigManager_1.default.updateConfig({
+                focus: {
+                    defaultIconKey: iconKey
+                }
+            }, true);
+        };
+        IconManager.clearCache = function () {
+            this.cache = {};
+        };
+        IconManager.loadLocal = function (iconConfig, cacheKey, callback) {
+            var _this = this;
+            if (!iconConfig.path) {
+                callback(null, iconConfig);
+                return;
+            }
+            cc.loader.loadRes(iconConfig.path, cc.SpriteFrame, function (error, frame) {
+                if (error || !frame) {
+                    _this.loadFallback(cacheKey, callback);
+                    return;
+                }
+                _this.cache[cacheKey] = frame;
+                callback(frame, iconConfig);
+            });
+        };
+        IconManager.loadRemote = function (iconConfig, cacheKey, callback) {
+            var _this = this;
+            var assetManager = cc.assetManager;
+            if (!assetManager || !assetManager.loadRemote) {
+                this.loadFallback(cacheKey, callback);
+                return;
+            }
+            assetManager.loadRemote(iconConfig.url, { ext: ".png" }, function (error, texture) {
+                if (error || !texture) {
+                    _this.loadFallback(cacheKey, callback);
+                    return;
+                }
+                var frame = new cc.SpriteFrame(texture);
+                _this.cache[cacheKey] = frame;
+                callback(frame, iconConfig);
+            });
+        };
+        IconManager.loadFallback = function (cacheKey, callback) {
+            var fallback = this.getIconConfig("default");
+            if (!fallback || fallback.path == cacheKey) {
+                callback(null, fallback);
+                return;
+            }
+            this.loadLocal(fallback, fallback.path || "default", callback);
+        };
+        IconManager.cache = {};
+        IconManager.inited = false;
+        return IconManager;
+    }());
+    exports.default = IconManager;
+});
+define("focus/FocusVisualLayer", ["require", "exports", "config/TvUiConfigManager", "icon/IconManager", "focus/FocusManager"], function (require, exports, TvUiConfigManager_2, IconManager_1, FocusManager_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ccclass = cc._decorator.ccclass;
+    var FocusVisualLayer = (function (_super) {
+        __extends(FocusVisualLayer, _super);
+        function FocusVisualLayer() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.graphics = null;
+            _this.iconNode = null;
+            _this.iconSprite = null;
+            _this.currentItem = null;
+            _this.currentIconConfig = null;
+            _this.inited = false;
+            _this.onFocusChanged = function (item) {
+                _this.refresh(item);
+            };
+            _this.onConfigChanged = function () {
+                _this.node.zIndex = (TvUiConfigManager_2.default.getConfig().focus || {}).zIndex || 800;
+                _this.refresh(_this.currentItem);
+            };
+            return _this;
+        }
+        FocusVisualLayer_1 = FocusVisualLayer;
+        FocusVisualLayer.create = function (parent) {
+            var node = parent.getChildByName("FocusVisualLayer");
+            if (!node) {
+                node = new cc.Node("FocusVisualLayer");
+                parent.addChild(node, 800);
+            }
+            var layer = node.getComponent(FocusVisualLayer_1);
+            if (!layer)
+                layer = node.addComponent(FocusVisualLayer_1);
+            layer.init();
+            return layer;
+        };
+        FocusVisualLayer.prototype.onDestroy = function () {
+            FocusManager_1.default.offFocusChanged(this.onFocusChanged);
+            TvUiConfigManager_2.default.offChanged(this.onConfigChanged);
+        };
+        FocusVisualLayer.prototype.init = function () {
+            if (this.inited)
+                return;
+            this.inited = true;
+            this.node.zIndex = (TvUiConfigManager_2.default.getConfig().focus || {}).zIndex || 800;
+            this.resizeToParent();
+            this.buildView();
+            FocusManager_1.default.onFocusChanged(this.onFocusChanged);
+            TvUiConfigManager_2.default.onChanged(this.onConfigChanged);
+            this.refresh(FocusManager_1.default.getCurrentFocusItem());
+        };
+        FocusVisualLayer.prototype.update = function () {
+            if (!this.currentItem)
+                return;
+            this.drawFocus(this.currentItem);
+            if (this.iconNode && this.iconNode.active && this.currentIconConfig) {
+                this.positionIcon(this.currentItem, this.currentIconConfig);
+            }
+        };
+        FocusVisualLayer.prototype.buildView = function () {
+            if (!this.graphics) {
+                this.graphics = this.node.addComponent(cc.Graphics);
+            }
+            if (!this.iconNode) {
+                this.iconNode = new cc.Node("FocusIcon");
+                this.iconNode.zIndex = 2;
+                this.iconSprite = this.iconNode.addComponent(cc.Sprite);
+                this.iconSprite.sizeMode = cc.Sprite.SizeMode.CUSTOM;
+                this.node.addChild(this.iconNode, 2);
+            }
+            this.node.active = false;
+        };
+        FocusVisualLayer.prototype.refresh = function (item) {
+            this.currentItem = item;
+            if (!item || item.showCursor === false) {
+                this.hide();
+                return;
+            }
+            this.node.active = true;
+            this.drawFocus(item);
+            this.refreshIcon(item);
+        };
+        FocusVisualLayer.prototype.hide = function () {
+            this.node.active = false;
+            this.currentItem = null;
+            if (this.graphics)
+                this.graphics.clear();
+            if (this.iconNode)
+                this.iconNode.active = false;
+            this.currentIconConfig = null;
+        };
+        FocusVisualLayer.prototype.refreshIcon = function (item) {
+            var _this = this;
+            var iconKey = item.iconKey || (TvUiConfigManager_2.default.getConfig().focus || {}).defaultIconKey || "default";
+            IconManager_1.default.getSpriteFrame(iconKey, function (frame, iconConfig) {
+                if (_this.currentItem != item || !_this.iconNode || !_this.iconSprite)
+                    return;
+                if (!frame) {
+                    _this.iconNode.active = false;
+                    return;
+                }
+                _this.iconNode.active = true;
+                _this.iconSprite.spriteFrame = frame;
+                _this.currentIconConfig = iconConfig || {};
+                _this.positionIcon(item, _this.currentIconConfig);
+            });
+        };
+        FocusVisualLayer.prototype.drawFocus = function (item) {
+            if (!item || !item.node || !item.node.isValid || !item.node.activeInHierarchy) {
+                this.hide();
+                return;
+            }
+            this.resizeToParent();
+            var focusConfig = TvUiConfigManager_2.default.getConfig().focus || {};
+            if (focusConfig.enabled === false) {
+                this.hide();
+                return;
+            }
+            if (!this.graphics)
+                return;
+            this.graphics.clear();
+            if (focusConfig.frameEnabled !== true) {
+                return;
+            }
+            var node = item.node;
+            var worldPos = node.parent.convertToWorldSpaceAR(node.position);
+            var local = this.node.convertToNodeSpaceAR(worldPos);
+            var contentSize = node.getContentSize();
+            var scaleX = node.scaleX;
+            var scaleY = node.scaleY;
+            var width = contentSize.width * scaleX;
+            var height = contentSize.height * scaleY;
+            var padding = focusConfig.framePadding || 0;
+            this.graphics.lineWidth = focusConfig.lineWidth || 4;
+            this.graphics.strokeColor = this.parseColor(focusConfig.frameColor || "#ffd451", focusConfig.frameOpacity);
+            this.graphics.rect(local.x - width / 2 - padding, local.y - height / 2 - padding, width + padding * 2, height + padding * 2);
+            this.graphics.stroke();
+        };
+        FocusVisualLayer.prototype.positionIcon = function (item, iconConfig) {
+            if (!item || !item.node || !item.node.isValid)
+                return;
+            var focusConfig = TvUiConfigManager_2.default.getConfig().focus || {};
+            var node = item.node;
+            var worldPos = node.parent.convertToWorldSpaceAR(node.position);
+            var local = this.node.convertToNodeSpaceAR(worldPos);
+            var contentSize = node.getContentSize();
+            var scaleX = node.scaleX;
+            var scaleY = node.scaleY;
+            var width = contentSize.width * scaleX;
+            var height = contentSize.height * scaleY;
+            var iconWidth = iconConfig.width || 60;
+            var iconHeight = iconConfig.height || 60;
+            var offsetX = iconConfig.offsetX;
+            var offsetY = iconConfig.offsetY;
+            if (offsetX === undefined)
+                offsetX = focusConfig.iconOffsetX || 0;
+            if (offsetY === undefined)
+                offsetY = focusConfig.iconOffsetY || 0;
+            if (!this.iconNode)
+                return;
+            var x = local.x + width / 2 + offsetX;
+            var y = local.y + height / 2 + offsetY;
+            if ((focusConfig.iconPlacement || "bottomRight") == "bottomRight") {
+                y = local.y - height / 2 - offsetY;
+            }
+            this.iconNode.setContentSize(iconWidth, iconHeight);
+            this.iconNode.setPosition(x, y);
+        };
+        FocusVisualLayer.prototype.resizeToParent = function () {
+            var parent = this.node.parent;
+            var width = parent && parent.width ? parent.width : (cc.winSize && cc.winSize.width) || 1920;
+            var height = parent && parent.height ? parent.height : (cc.winSize && cc.winSize.height) || 1080;
+            this.node.setContentSize(width, height);
+            this.node.setPosition(0, 0);
+        };
+        FocusVisualLayer.prototype.parseColor = function (hex, opacity) {
+            hex = (hex || "#ffd451").replace("#", "");
+            var r = parseInt(hex.substr(0, 2), 16);
+            var g = parseInt(hex.substr(2, 2), 16);
+            var b = parseInt(hex.substr(4, 2), 16);
+            return cc.color(r || 255, g || 212, b || 81, opacity === undefined ? 230 : opacity);
+        };
+        var FocusVisualLayer_1;
+        FocusVisualLayer = FocusVisualLayer_1 = __decorate([
+            ccclass
+        ], FocusVisualLayer);
+        return FocusVisualLayer;
+    }(cc.Component));
+    exports.default = FocusVisualLayer;
+});
+define("ad/IAdProvider", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+define("core/NativeBridge", ["require", "exports", "config/TvUiConfigManager"], function (require, exports, TvUiConfigManager_3) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var callbackId = 100;
+    var nativeCallback = null;
+    var root = typeof window !== "undefined" ? window : (typeof global !== "undefined" ? global : {});
+    function hasBridge() {
+        return root.AppBridge && typeof root.AppBridge.call == "function";
+    }
+    function log(message, data) {
+        if (data !== undefined) {
+            console.log("[NativeBridge] " + message, data);
+        }
+        else {
+            console.log("[NativeBridge] " + message);
+        }
+    }
+    function normalizeCallbackData(data) {
+        if (typeof data == "string") {
+            try {
+                return JSON.parse(data);
+            }
+            catch (e) {
+                return { message: data };
+            }
+        }
+        return data || {};
+    }
+    function handleCallback(id, code, data, action) {
+        var callbacks = root._tvuiCallbacks || {};
+        id = id || root._tvuiLastCallbackId;
+        var callback = callbacks[id];
+        if (callback) {
+            callback(code, data, action);
+            delete callbacks[id];
+        }
+    }
+    function bridgeCall(action, data, callback) {
+        var id = "cb_" + (++callbackId);
+        root._tvuiLastCallbackId = id;
+        if (callback) {
+            root._tvuiCallbacks = root._tvuiCallbacks || {};
+            root._tvuiCallbacks[id] = callback;
+        }
+        if (!hasBridge()) {
+            log("AppBridge not found, skip in preview: " + action);
+            if (callback) {
+                callback(-1, { message: "AppBridge not found" }, action);
+                delete root._tvuiCallbacks[id];
+            }
+            return;
+        }
+        root.AppBridge.call(JSON.stringify({
+            action: action,
+            data: data || {},
+            callbackId: id
+        }));
+    }
+    root.onNativeBridgeCallback = function (action, data) {
+        data = normalizeCallbackData(data);
+        log("native callback: " + action, data);
+        switch (action) {
+            case "onBridgeCallback":
+            case "onDeviceInfo":
+            case "onReward":
+            case "onAdClosed":
+            case "onAdFailed":
+            case "onPopupAdLoaded":
+            case "onPopupAdClosed":
+            case "onPopupAdFailed":
+            case "onAggregateReward":
+            case "onAggregateAdClosed":
+            case "onAggregateAdFailed":
+            case "onAggregatePopupAdLoaded":
+            case "onAggregatePopupAdClosed":
+            case "onAggregatePopupAdFailed":
+            case "onRankUploaded":
+            case "onRankList":
+                handleCallback(data.callbackId || data.callback_id, data.code, data.data || data, action);
+                break;
+        }
+        if (nativeCallback)
+            nativeCallback(action, data);
+    };
+    var NativeBridge = (function () {
+        function NativeBridge() {
+        }
+        NativeBridge.hasBridge = function () {
+            return hasBridge();
+        };
+        NativeBridge.call = function (action, data, callback) {
+            bridgeCall(action, data || {}, callback);
+        };
+        NativeBridge.getDeviceInfo = function (callback) {
+            bridgeCall("getDeviceInfo", {}, callback);
+        };
+        NativeBridge.onGameReady = function () {
+            bridgeCall("onGameReady", { version: TvUiConfigManager_3.default.getConfig().version || "1.0.0" });
+        };
+        NativeBridge.onGamePause = function () {
+            bridgeCall("onGamePause", {});
+        };
+        NativeBridge.onGameResume = function () {
+            bridgeCall("onGameResume", {});
+        };
+        NativeBridge.onExitGame = function () {
+            bridgeCall("exitGame", {});
+        };
+        NativeBridge.uploadRank = function (data, callback) {
+            bridgeCall("uploadRank", data, callback);
+        };
+        NativeBridge.getRankList = function (data, callback) {
+            bridgeCall("getRankList", data, callback);
+        };
+        NativeBridge.setNativeCallback = function (callback) {
+            nativeCallback = callback;
+        };
+        return NativeBridge;
+    }());
+    exports.default = NativeBridge;
+});
+define("ad/AggregateAdProvider", ["require", "exports", "config/TvUiConfigManager", "core/NativeBridge", "../ad-sdk/ad-sdk"], function (require, exports, TvUiConfigManager_4, NativeBridge_1, ad_sdk_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var AggregateAdProvider = (function () {
+        function AggregateAdProvider() {
+            this.type = "aggregate";
+        }
+        AggregateAdProvider.prototype.isAvailable = function () {
+            return NativeBridge_1.default.hasBridge();
+        };
+        AggregateAdProvider.prototype.load = function (data) {
+            return this.ensureSdk().then(function () { return data; });
+        };
+        AggregateAdProvider.prototype.show = function (data) {
+            return null;
+        };
+        AggregateAdProvider.prototype.hide = function (slotId, channel) {
+        };
+        AggregateAdProvider.prototype.showReward = function (data) {
+            var _this = this;
+            var options = data.options || {};
+            var channel = data.channel || {};
+            var runtime = TvUiConfigManager_4.default.getConfig();
+            return ad_sdk_1.AdSdk.requestAd({
+                adType: ad_sdk_1.AdType.RewardVideo,
+                cpId: options.cpId || runtime.cpId || "ppl",
+                rewardType: options.reward_type || channel.reward_type || "reward",
+                triggerScene: options.trigger_scene || data.slotId,
+                extra: options.extra || {}
+            }).then(function (result) {
+                if (!result || result.isCompleted !== true) {
+                    if (options.onClose)
+                        options.onClose(result);
+                    return { status: "closed", data: result };
+                }
+                if (options.onSuccess)
+                    options.onSuccess(result);
+                return { status: "success", data: result };
+            }).catch(function (error) {
+                if (_this.isUserAbandoned(error)) {
+                    if (options.onClose)
+                        options.onClose(error);
+                    return { status: "closed", data: error };
+                }
+                return { status: "failed", error: error };
+            });
+        };
+        AggregateAdProvider.prototype.ensureSdk = function () {
+            var _this = this;
+            if (AggregateAdProvider.initialized)
+                return Promise.resolve();
+            if (AggregateAdProvider.initTask)
+                return AggregateAdProvider.initTask;
+            var runtime = TvUiConfigManager_4.default.getConfig();
+            var adSdkConfig = runtime.adSdk || {};
+            var platform = this.getPlatform(adSdkConfig.platform || "xiaomi");
+            var adapterConfig = {};
+            var customConfig = adSdkConfig.adapterConfig || {};
+            var key;
+            adapterConfig.cpId = runtime.cpId || "ppl";
+            for (key in customConfig)
+                adapterConfig[key] = customConfig[key];
+            var adapters = {};
+            adapters[platform] = adapterConfig;
+            AggregateAdProvider.initTask = ad_sdk_1.AdSdk.init({
+                platform: platform,
+                adapters: adapters
+            }).then(function () {
+                AggregateAdProvider.initialized = true;
+                _this.notifyGameReady(runtime.version || AggregateAdProvider.GAME_VERSION);
+            }).catch(function (error) {
+                AggregateAdProvider.initTask = null;
+                throw error;
+            });
+            return AggregateAdProvider.initTask;
+        };
+        AggregateAdProvider.prototype.notifyGameReady = function (version) {
+            if (AggregateAdProvider.gameReadyNotified)
+                return;
+            AggregateAdProvider.gameReadyNotified = true;
+            try {
+                ad_sdk_1.AdSdk.onGameReady(version || AggregateAdProvider.GAME_VERSION);
+            }
+            catch (error) {
+                console.warn("[AggregateAdProvider] onGameReady failed", error);
+            }
+        };
+        AggregateAdProvider.prototype.getPlatform = function (platform) {
+            if (platform == "xiaomi" || !platform)
+                return ad_sdk_1.AdPlatform.Xiaomi;
+            return platform;
+        };
+        AggregateAdProvider.prototype.isUserAbandoned = function (error) {
+            if (!error)
+                return false;
+            return error.code == ad_sdk_1.AdErrorCode.UserAbandoned
+                || error.code == 1006
+                || error.isCompleted === false
+                || error.is_completed === false
+                || error.message == "Ad closed by user before completion";
+        };
+        AggregateAdProvider.initialized = false;
+        AggregateAdProvider.initTask = null;
+        AggregateAdProvider.gameReadyNotified = false;
+        AggregateAdProvider.GAME_VERSION = "1.0.0";
+        return AggregateAdProvider;
+    }());
+    exports.default = AggregateAdProvider;
+});
+define("ad/SelfAdProvider", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var SelfAdProvider = (function () {
+        function SelfAdProvider() {
+            this.type = "self";
+        }
+        SelfAdProvider.prototype.isAvailable = function () {
+            return true;
+        };
+        SelfAdProvider.prototype.load = function (data) {
+            return Promise.resolve(data);
+        };
+        SelfAdProvider.prototype.show = function (data) {
+            var channel = data.channel || {};
+            var options = data.options || {};
+            var path = channel.imagePath || (data.slotConfig.fallback && data.slotConfig.fallback.imagePath);
+            if (!path || !options.container) {
+                if (options.onLoad)
+                    options.onLoad({ self: true, slotId: data.slotId });
+                return Promise.resolve({ status: "loaded", data: { self: true, slotId: data.slotId } });
+            }
+            var node = options.container;
+            var sprite = node.getComponent(cc.Sprite) || node.addComponent(cc.Sprite);
+            sprite.sizeMode = cc.Sprite.SizeMode.CUSTOM;
+            return new Promise(function (resolve) {
+                cc.loader.loadRes(path, cc.SpriteFrame, function (error, frame) {
+                    if (error || !frame) {
+                        resolve({ status: "failed", error: error || { message: "self ad frame missing" } });
+                        return;
+                    }
+                    sprite.spriteFrame = frame;
+                    node.active = true;
+                    if (options.onLoad)
+                        options.onLoad({ self: true, slotId: data.slotId });
+                    resolve({ status: "loaded", data: { self: true, slotId: data.slotId } });
+                });
+            });
+        };
+        SelfAdProvider.prototype.hide = function (_slotId) {
+        };
+        return SelfAdProvider;
+    }());
+    exports.default = SelfAdProvider;
+});
+define("ad/MockAdProvider", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var MockAdProvider = (function () {
+        function MockAdProvider() {
+            this.type = "mock";
+        }
+        MockAdProvider.prototype.isAvailable = function () {
+            return true;
+        };
+        MockAdProvider.prototype.load = function (data) {
+            return Promise.resolve(data);
+        };
+        MockAdProvider.prototype.show = function (data) {
+            var options = data.options || {};
+            var mode = options.mode || data.slotConfig.mode || "popup";
+            console.log("[MockAdProvider] show", data.slotId, mode);
+            return new Promise(function (resolve) {
+                setTimeout(function () {
+                    var result = { mock: true, slotId: data.slotId };
+                    if (mode == "reward") {
+                        var rewardResult = { isCompleted: true, mock: true, slotId: data.slotId };
+                        if (options.onSuccess)
+                            options.onSuccess(rewardResult);
+                        resolve({ status: "success", data: rewardResult });
+                    }
+                    else {
+                        if (options.onLoad)
+                            options.onLoad(result);
+                        resolve({ status: "loaded", data: result });
+                    }
+                }, 0);
+            });
+        };
+        MockAdProvider.prototype.hide = function (slotId) {
+            console.log("[MockAdProvider] hide", slotId);
+        };
+        return MockAdProvider;
+    }());
+    exports.default = MockAdProvider;
+});
+define("ad/AdManager", ["require", "exports", "config/TvUiConfigManager", "ad/AggregateAdProvider", "ad/SelfAdProvider", "ad/MockAdProvider"], function (require, exports, TvUiConfigManager_5, AggregateAdProvider_1, SelfAdProvider_1, MockAdProvider_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var AdManager = (function () {
+        function AdManager() {
+        }
+        AdManager.init = function () {
+            this.providers = {};
+            this.registerProvider(new AggregateAdProvider_1.default());
+            this.registerProvider(new SelfAdProvider_1.default());
+            this.registerProvider(new MockAdProvider_1.default());
+        };
+        AdManager.registerProvider = function (provider) {
+            if (!provider || !provider.type)
+                return;
+            this.providers[provider.type] = provider;
+        };
+        AdManager.showSlot = function (slotId, options) {
+            if (options === void 0) { options = {}; }
+            var slotConfig = this.getSlotConfig(slotId);
+            if (!slotConfig || slotConfig.enabled === false) {
+                if (options.onFail)
+                    options.onFail({ message: "ad slot disabled", slotId: slotId });
+                return Promise.resolve(false);
+            }
+            var channels = this.getSortedChannels(slotConfig);
+            return this.showByChannels(slotId, slotConfig, options, channels, 0, null).then(function (result) {
+                if (result && (result.status == "success" || result.status == "loaded"))
+                    return true;
+                if (result && result.status == "closed")
+                    return false;
+                if (options.onFail) {
+                    options.onFail((result && result.error) || { message: "all ad channels failed", slotId: slotId });
+                }
+                return false;
+            });
+        };
+        AdManager.hideSlot = function (slotId) {
+            var slotConfig = this.getSlotConfig(slotId);
+            var channels = slotConfig ? this.getSortedChannels(slotConfig) : [];
+            if (channels.length > 0) {
+                for (var i = 0; i < channels.length; i++) {
+                    var channel = channels[i];
+                    var provider = channel && this.providers[channel.type];
+                    if (provider)
+                        provider.hide(slotId, channel);
+                }
+                return;
+            }
+            for (var type in this.providers) {
+                if (this.providers.hasOwnProperty(type))
+                    this.providers[type].hide(slotId);
+            }
+        };
+        AdManager.refreshSlot = function (slotId, options) {
+            if (options === void 0) { options = {}; }
+            this.hideSlot(slotId);
+            return this.showSlot(slotId, options);
+        };
+        AdManager.showReward = function (options) {
+            options = this.mergeOptions(options, { mode: "reward" });
+            return this.showSlot((options && options.slotId) || "reward", options);
+        };
+        AdManager.showPopup = function (options) {
+            options = this.mergeOptions(options, { mode: "popup" });
+            return this.showSlot((options && options.slotId) || (options && options.trigger_scene) || "popup", options);
+        };
+        AdManager.hidePopup = function (scene) {
+            this.hideSlot(scene || "popup");
+        };
+        AdManager.getSlotConfig = function (slotId) {
+            var config = TvUiConfigManager_5.default.getConfig();
+            var ads = config.ads || {};
+            return ads[slotId] || ads["popup"] || null;
+        };
+        AdManager.showByChannels = function (slotId, slotConfig, options, channels, index, lastError) {
+            var _this = this;
+            if (index >= channels.length) {
+                return Promise.resolve({ status: "failed", error: lastError || { message: "ad channels empty", slotId: slotId } });
+            }
+            var channel = channels[index];
+            if (!channel || channel.enabled === false) {
+                return this.showByChannels(slotId, slotConfig, options, channels, index + 1, lastError);
+            }
+            var provider = this.providers[channel.type];
+            if (!provider) {
+                return this.showByChannels(slotId, slotConfig, options, channels, index + 1, { message: "ad provider missing", channel: channel.type });
+            }
+            if (!provider.isAvailable()) {
+                return this.showByChannels(slotId, slotConfig, options, channels, index + 1, { message: "ad provider unavailable", channel: channel.type });
+            }
+            var data = {
+                slotId: slotId,
+                slotConfig: slotConfig,
+                channel: channel,
+                options: options
+            };
+            return provider.load(data).then(function (runtimeData) {
+                return provider.show(runtimeData);
+            }).then(function (result) {
+                if (!result || result.status == "failed") {
+                    if (options && options.mode == "reward")
+                        return result || { status: "failed", error: lastError };
+                    return _this.showByChannels(slotId, slotConfig, options, channels, index + 1, result && (result.error || result.data));
+                }
+                return result;
+            }).catch(function (error) {
+                if (options && options.mode == "reward")
+                    return { status: "failed", error: error };
+                return _this.showByChannels(slotId, slotConfig, options, channels, index + 1, error);
+            });
+        };
+        AdManager.getSortedChannels = function (slotConfig) {
+            var _this = this;
+            var channels = [];
+            var configured = (slotConfig && slotConfig.channels) || [];
+            for (var i = 0; i < configured.length; i++) {
+                if (configured[i])
+                    channels.push(configured[i]);
+            }
+            if (slotConfig && slotConfig.fallback) {
+                channels.push(this.normalizeFallback(slotConfig.fallback));
+            }
+            if (!this.hasChannelType(channels, "mock")) {
+                channels.push({ type: "mock", priority: 100 });
+            }
+            channels.sort(function (a, b) {
+                return _this.getPriority(a) - _this.getPriority(b);
+            });
+            return channels;
+        };
+        AdManager.normalizeFallback = function (fallback) {
+            if (fallback.type)
+                return fallback;
+            var result = this.mergeOptions(fallback, {});
+            result.type = (fallback.imagePath || fallback.imageUrl) ? "self" : "mock";
+            if (result.priority === undefined)
+                result.priority = 90;
+            return result;
+        };
+        AdManager.hasChannelType = function (channels, type) {
+            for (var i = 0; i < channels.length; i++) {
+                if (channels[i] && channels[i].type == type)
+                    return true;
+            }
+            return false;
+        };
+        AdManager.getPriority = function (channel) {
+            if (!channel || channel.priority === undefined)
+                return 999;
+            return channel.priority;
+        };
+        AdManager.mergeOptions = function (base, extra) {
+            var result = {};
+            var key;
+            base = base || {};
+            extra = extra || {};
+            for (key in base)
+                result[key] = base[key];
+            for (key in extra)
+                result[key] = extra[key];
+            return result;
+        };
+        AdManager.providers = {};
+        return AdManager;
+    }());
+    exports.default = AdManager;
+});
+define("core/BackManager", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var BackManager = (function () {
+        function BackManager() {
+        }
+        BackManager.reset = function () {
+            this.handlers = [];
+            this.fallback = null;
+        };
+        BackManager.setFallback = function (handler) {
+            this.fallback = handler;
+        };
+        BackManager.push = function (handler) {
+            return;
+            if (!handler)
+                return;
+            this.remove(handler);
+            this.handlers.push(handler);
+        };
+        BackManager.remove = function (handler) {
+            return;
+            for (var i = this.handlers.length - 1; i >= 0; i--) {
+                if (this.handlers[i] == handler)
+                    this.handlers.splice(i, 1);
+            }
+        };
+        BackManager.handle = function () {
+            for (var i = this.handlers.length - 1; i >= 0; i--) {
+                var handler = this.handlers[i];
+                if (!handler)
+                    continue;
+                var result = handler();
+                if (result !== false)
+                    return true;
+            }
+            if (this.fallback)
+                return this.fallback() !== false;
+            return false;
+        };
+        BackManager.handlers = [];
+        BackManager.fallback = null;
+        return BackManager;
+    }());
+    exports.default = BackManager;
+});
+define("input/RemoteInputManager", ["require", "exports", "input/KeyCodeAdapter"], function (require, exports, KeyCodeAdapter_2) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RemoteInputManager = void 0;
+    var RemoteInputManager = (function () {
+        function RemoteInputManager() {
+        }
+        RemoteInputManager.enable = function () {
+            if (this.enabled)
+                return;
+            this.enabled = true;
+            cc.systemEvent.on(cc.SystemEvent.EventType.KEY_DOWN, this.onKeyDown, this);
+            this.enableDomInput();
+            this.focusCanvas();
+        };
+        RemoteInputManager.disable = function () {
+            if (!this.enabled)
+                return;
+            this.enabled = false;
+            cc.systemEvent.off(cc.SystemEvent.EventType.KEY_DOWN, this.onKeyDown, this);
+            this.disableDomInput();
+            this.lastKeyCode = -1;
+            this.lastDispatchTime = 0;
+        };
+        RemoteInputManager.clear = function () {
+            this.handlers = {};
+        };
+        RemoteInputManager.on = function (key, handler) {
+            if (!this.handlers[key])
+                this.handlers[key] = [];
+            this.handlers[key].push(handler);
+        };
+        RemoteInputManager.off = function (key, handler) {
+            var list = this.handlers[key];
+            if (!list)
+                return;
+            var index = list.indexOf(handler);
+            if (index >= 0)
+                list.splice(index, 1);
+        };
+        RemoteInputManager.toRemoteKey = function (keyCode) {
+            return KeyCodeAdapter_2.default.toRemoteKey(keyCode);
+        };
+        RemoteInputManager.dispatchKeyCode = function (keyCode) {
+            var now = Date.now();
+            if (keyCode == this.lastKeyCode && now - this.lastDispatchTime < this.DISPATCH_DEBOUNCE_MS) {
+                return false;
+            }
+            this.lastKeyCode = keyCode;
+            this.lastDispatchTime = now;
+            var key = KeyCodeAdapter_2.default.toRemoteKey(keyCode);
+            var list = this.handlers[key] || [];
+            for (var i = list.length - 1; i >= 0; i--) {
+                var result = list[i](keyCode);
+                if (result !== false)
+                    return true;
+            }
+            return false;
+        };
+        RemoteInputManager.onKeyDown = function (event) {
+            this.dispatchKeyCode(event.keyCode);
+        };
+        RemoteInputManager.enableDomInput = function () {
+            if (this.domInputEnabled || typeof window == "undefined")
+                return;
+            this.domInputEnabled = true;
+            window.addEventListener("keydown", this.onDomKeyDown, true);
+        };
+        RemoteInputManager.disableDomInput = function () {
+            if (!this.domInputEnabled || typeof window == "undefined")
+                return;
+            this.domInputEnabled = false;
+            window.removeEventListener("keydown", this.onDomKeyDown, true);
+        };
+        RemoteInputManager.onDomKeyDown = function (event) {
+            var handled = RemoteInputManager.dispatchKeyCode(event.keyCode || event.which);
+            if (handled && event.preventDefault)
+                event.preventDefault();
+        };
+        RemoteInputManager.focusCanvas = function () {
+            if (typeof document == "undefined")
+                return;
+            try {
+                var canvas = (cc && cc.game && cc.game.canvas) ? cc.game.canvas : document.querySelector("canvas");
+                if (canvas) {
+                    canvas.tabIndex = canvas.tabIndex || 0;
+                    if (typeof canvas.focus == "function") {
+                        canvas.focus();
+                        return;
+                    }
+                }
+                if (typeof window != "undefined" && typeof window.focus == "function")
+                    window.focus();
+            }
+            catch (e) {
+            }
+        };
+        RemoteInputManager.handlers = {};
+        RemoteInputManager.enabled = false;
+        RemoteInputManager.domInputEnabled = false;
+        RemoteInputManager.lastKeyCode = -1;
+        RemoteInputManager.lastDispatchTime = 0;
+        RemoteInputManager.DISPATCH_DEBOUNCE_MS = 160;
+        return RemoteInputManager;
+    }());
+    exports.RemoteInputManager = RemoteInputManager;
+});
+define("core/TvUiRoot", ["require", "exports", "config/TvUiConfigManager", "focus/FocusManager", "focus/FocusVisualLayer", "icon/IconManager", "ad/AdManager", "input/KeyCodeAdapter", "core/BackManager", "core/NativeBridge", "input/RemoteInputManager"], function (require, exports, TvUiConfigManager_6, FocusManager_2, FocusVisualLayer_2, IconManager_2, AdManager_1, KeyCodeAdapter_3, BackManager_1, NativeBridge_2, RemoteInputManager_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ccclass = cc._decorator.ccclass;
+    var TvUiRoot = (function (_super) {
+        __extends(TvUiRoot, _super);
+        function TvUiRoot() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.visualLayer = null;
+            _this.configured = false;
+            return _this;
+        }
+        TvUiRoot_1 = TvUiRoot;
+        TvUiRoot.ensure = function (config) {
+            if (this.instance && this.instance.node && this.instance.node.isValid) {
+                if (config)
+                    this.instance.configure(config);
+                return this.instance;
+            }
+            var scene = cc.director.getScene();
+            var node = new cc.Node("TvUiRoot");
+            node.zIndex = 800;
+            scene.addChild(node, 800);
+            if (cc.game && cc.game.addPersistRootNode) {
+                cc.game.addPersistRootNode(node);
+            }
+            this.instance = node.addComponent(TvUiRoot_1);
+            this.instance.configure(config || {});
+            return this.instance;
+        };
+        TvUiRoot.getInstance = function () {
+            return this.instance;
+        };
+        TvUiRoot.setBackHandler = function (handler) {
+            this.backHandler = handler;
+            if (this.instance)
+                this.instance.bindInputHandlers();
+        };
+        TvUiRoot.prototype.onLoad = function () {
+            TvUiRoot_1.instance = this;
+            this.resize();
+            this.exposeGlobal();
+        };
+        TvUiRoot.prototype.onDestroy = function () {
+            if (TvUiRoot_1.instance == this)
+                TvUiRoot_1.instance = null;
+        };
+        TvUiRoot.prototype.configure = function (config) {
+            var _this = this;
+            this.configured = true;
+            TvUiConfigManager_6.default.init(config || {}, function () {
+                _this.applyConfig();
+            });
+            this.applyConfig();
+        };
+        TvUiRoot.prototype.applyConfig = function () {
+            if (!this.configured)
+                return;
+            var config = TvUiConfigManager_6.default.getConfig();
+            if (cc.view && config.designWidth && config.designHeight) {
+                cc.view.setDesignResolutionSize(config.designWidth, config.designHeight, config.resolutionPolicy || cc.ResolutionPolicy.SHOW_ALL);
+            }
+            this.resize();
+            IconManager_2.default.init();
+            AdManager_1.default.init();
+            this.ensureVisualLayer();
+            this.bindInputHandlers();
+            this.exposeGlobal();
+        };
+        TvUiRoot.prototype.ensureVisualLayer = function () {
+            var config = TvUiConfigManager_6.default.getConfig();
+            if (config.focus && config.focus.enabled === false)
+                return;
+            this.visualLayer = FocusVisualLayer_2.default.create(this.node);
+        };
+        TvUiRoot.prototype.bindInputHandlers = function () {
+            var config = TvUiConfigManager_6.default.getConfig();
+            RemoteInputManager_1.RemoteInputManager.clear();
+            if (config.enableRemoteInput === false) {
+                RemoteInputManager_1.RemoteInputManager.disable();
+                return;
+            }
+            RemoteInputManager_1.RemoteInputManager.enable();
+            RemoteInputManager_1.RemoteInputManager.on(KeyCodeAdapter_3.TvRemoteKey.Ok, function () { return FocusManager_2.default.confirm(); });
+            RemoteInputManager_1.RemoteInputManager.on(KeyCodeAdapter_3.TvRemoteKey.Left, function () { return FocusManager_2.default.move("left"); });
+            RemoteInputManager_1.RemoteInputManager.on(KeyCodeAdapter_3.TvRemoteKey.Right, function () { return FocusManager_2.default.move("right"); });
+            RemoteInputManager_1.RemoteInputManager.on(KeyCodeAdapter_3.TvRemoteKey.Up, function () { return FocusManager_2.default.move("up"); });
+            RemoteInputManager_1.RemoteInputManager.on(KeyCodeAdapter_3.TvRemoteKey.Down, function () { return FocusManager_2.default.move("down"); });
+            RemoteInputManager_1.RemoteInputManager.on(KeyCodeAdapter_3.TvRemoteKey.Back, function () {
+                if (TvUiRoot_1.backHandler)
+                    return TvUiRoot_1.backHandler() !== false;
+                return FocusManager_2.default.back();
+            });
+        };
+        TvUiRoot.prototype.resize = function () {
+            var width = (cc.winSize && cc.winSize.width) || 1920;
+            var height = (cc.winSize && cc.winSize.height) || 1080;
+            this.node.setContentSize(width, height);
+            this.node.setPosition(0, 0);
+        };
+        TvUiRoot.prototype.exposeGlobal = function () {
+            var root = typeof window !== "undefined" ? window : (typeof global !== "undefined" ? global : null);
+            if (!root)
+                return;
+            root.TvUiRoot = TvUiRoot_1;
+            if (root.TvUi) {
+                root.tvui = root.TvUi;
+                return;
+            }
+            if (root.tvui)
+                return;
+            root.tvui = {
+                root: TvUiRoot_1,
+                config: TvUiConfigManager_6.default,
+                focus: FocusManager_2.default,
+                icon: IconManager_2.default,
+                ads: AdManager_1.default,
+                input: RemoteInputManager_1.RemoteInputManager,
+                api: NativeBridge_2.default,
+                back: BackManager_1.default
+            };
+        };
+        var TvUiRoot_1;
+        TvUiRoot.instance = null;
+        TvUiRoot.backHandler = null;
+        TvUiRoot = TvUiRoot_1 = __decorate([
+            ccclass
+        ], TvUiRoot);
+        return TvUiRoot;
+    }(cc.Component));
+    exports.default = TvUiRoot;
+});
+define("core/TvUi", ["require", "exports", "core/TvUiRoot", "core/BackManager", "core/NativeBridge", "config/TvUiConfigManager", "focus/FocusManager", "icon/IconManager", "ad/AdManager", "input/RemoteInputManager"], function (require, exports, TvUiRoot_2, BackManager_2, NativeBridge_3, TvUiConfigManager_7, FocusManager_3, IconManager_3, AdManager_2, RemoteInputManager_2) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var TvUi = (function () {
+        function TvUi() {
+        }
+        TvUi.init = function (config) {
+            TvUiRoot_2.default.ensure(config || {});
+            TvUiRoot_2.default.setBackHandler(function () { return BackManager_2.default.handle(); });
+            NativeBridge_3.default.setNativeCallback(function (action, data) {
+                var runtime = TvUiConfigManager_7.default.getConfig();
+                if (runtime.nativeCallback)
+                    runtime.nativeCallback(action, data);
+            });
+            var runtime = TvUiConfigManager_7.default.getConfig();
+            if (!this.initialized && runtime.enableLifecycle !== false) {
+                NativeBridge_3.default.onGameReady();
+                cc.game.on(cc.game.EVENT_HIDE, this.onGameHide, this);
+                cc.game.on(cc.game.EVENT_SHOW, this.onGameShow, this);
+            }
+            this.exposeGlobal();
+            this.initialized = true;
+        };
+        TvUi.destroy = function () {
+            cc.game.off(cc.game.EVENT_HIDE, this.onGameHide, this);
+            cc.game.off(cc.game.EVENT_SHOW, this.onGameShow, this);
+            RemoteInputManager_2.RemoteInputManager.disable();
+            RemoteInputManager_2.RemoteInputManager.clear();
+            TvUiRoot_2.default.setBackHandler(null);
+            FocusManager_3.default.reset();
+            BackManager_2.default.reset();
+            NativeBridge_3.default.setNativeCallback(null);
+            this.initialized = false;
+        };
+        TvUi.exposeGlobal = function () {
+            var runtimeRoot = typeof window !== "undefined" ? window : (typeof global !== "undefined" ? global : null);
+            if (!runtimeRoot)
+                return;
+            runtimeRoot.TvUi = TvUi;
+            runtimeRoot.tvui = TvUi;
+        };
+        TvUi.onGameHide = function () {
+            NativeBridge_3.default.onGamePause();
+        };
+        TvUi.onGameShow = function () {
+            NativeBridge_3.default.onGameResume();
+        };
+        TvUi.root = TvUiRoot_2.default;
+        TvUi.config = TvUiConfigManager_7.default;
+        TvUi.focus = FocusManager_3.default;
+        TvUi.icon = IconManager_3.default;
+        TvUi.ads = AdManager_2.default;
+        TvUi.api = NativeBridge_3.default;
+        TvUi.input = RemoteInputManager_2.RemoteInputManager;
+        TvUi.back = BackManager_2.default;
+        TvUi.initialized = false;
+        return TvUi;
+    }());
+    exports.default = TvUi;
+});
+define("toast/UIFunctions", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var UIFunctions = (function () {
+        function UIFunctions() {
+        }
+        UIFunctions.getChildrenAnimations = function (node) {
+            var animations = [];
+            var anim = node.getComponent(cc.Animation);
+            if (anim)
+                animations.push(anim);
+            for (var i = 0; i < node.childrenCount; i++) {
+                var child = node.children[i];
+                var anim = child.getComponent(cc.Animation);
+                if (anim)
+                    animations.push(anim);
+            }
+            return animations;
+        };
+        UIFunctions.stopAnimations = function (animations) {
+            animations.forEach(function (anim) {
+                anim.stop();
+            });
+        };
+        UIFunctions.doShowAnimations = function (animations, finishCallback, target) {
+            var maxDuration = 0;
+            var maxDurationAnimation = null;
+            animations.forEach(function (anim) {
+                var clips = anim.getClips();
+                if (clips.length > 0) {
+                    var clip = clips[0];
+                    var animState = anim.play(clip.name);
+                    animState.wrapMode = cc.WrapMode.Normal;
+                    if (clip.duration > maxDuration) {
+                        maxDuration = clip.duration;
+                        maxDurationAnimation = anim;
+                    }
+                }
+            });
+            if (finishCallback) {
+                var func_1 = function () {
+                    if (maxDurationAnimation)
+                        maxDurationAnimation.off("finished", func_1);
+                    finishCallback.call(target);
+                };
+                if (maxDurationAnimation)
+                    maxDurationAnimation.on("finished", func_1);
+                else
+                    finishCallback.call(target);
+            }
+        };
+        UIFunctions.isAnimationRunning = function (animations) {
+            return false;
+        };
+        UIFunctions.doHideAnimations = function (animations, finishCallback, target) {
+            var hasHideAnimation = false;
+            var maxDuration = 0;
+            var maxDurationAnimation = null;
+            animations.forEach(function (anim) {
+                var clips = anim.getClips();
+                if (clips.length == 2) {
+                    var clip = clips[clips.length - 1];
+                    hasHideAnimation = true;
+                    anim.play(clip.name);
+                    if (clip.duration > maxDuration) {
+                        maxDuration = clip.duration;
+                        maxDurationAnimation = anim;
+                    }
+                }
+                else if (clips.length == 1) {
+                    var clip = clips[0];
+                    hasHideAnimation = true;
+                    var animState = anim.play(clip.name);
+                    animState.wrapMode = cc.WrapMode.Reverse;
+                    if (clip.duration > maxDuration) {
+                        maxDuration = clip.duration;
+                        maxDurationAnimation = anim;
+                    }
+                }
+            });
+            if (maxDurationAnimation && finishCallback) {
+                var func_2 = function () {
+                    maxDurationAnimation.off("finished", func_2);
+                    finishCallback.call(target);
+                };
+                maxDurationAnimation.on("finished", func_2);
+            }
+            return hasHideAnimation;
+        };
+        UIFunctions.getToggleIndex = function (toggle) {
+            var container = toggle.node.parent;
+            for (var i = 0; i < container.childrenCount; i++) {
+                var child = container.children[i];
+                if (toggle.node == child) {
+                    return i;
+                }
+            }
+            return -1;
+        };
+        UIFunctions.selectToggleIndex = function (toggleContainer, index) {
+            if (toggleContainer == null) {
+                console.warn("[UIFunction.selectToggleIndex] : invalid toggleContainer :");
+                return;
+            }
+            var toggleNode = toggleContainer.children[index];
+            if (toggleNode) {
+                var toggle = toggleNode.getComponent(cc.Toggle);
+                if (toggle) {
+                    console.log("[UIFunction.selectToggleIndex] :" + index);
+                    toggle.check();
+                }
+            }
+            else {
+                console.warn("[UIFunction.selectToggleIndex] :cannot find toggle with index:" + index);
+            }
+        };
+        UIFunctions.setTouchEnabled = function (node, b) {
+        };
+        UIFunctions.setButtonEnabled = function (btn, b) {
+            btn.node.opacity = b ? 255 : 155;
+            btn.interactable = b;
+        };
+        return UIFunctions;
+    }());
+    exports.default = UIFunctions;
+});
+define("toast/ToastComponent", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _a = cc._decorator, ccclass = _a.ccclass, property = _a.property;
+    var ToastComponent = (function (_super) {
+        __extends(ToastComponent, _super);
+        function ToastComponent() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.label = null;
+            return _this;
+        }
+        ToastComponent.prototype.onLoad = function () {
+        };
+        ToastComponent.prototype.start = function () {
+        };
+        ToastComponent.prototype.hide = function (callback) {
+            this.node.active = true;
+            this.node.active = false;
+            if (callback) {
+                callback(this);
+            }
+        };
+        ToastComponent.prototype.show = function (text) {
+            this.label.string = text;
+        };
+        __decorate([
+            property(cc.Label),
+            __metadata("design:type", cc.Label)
+        ], ToastComponent.prototype, "label", void 0);
+        ToastComponent = __decorate([
+            ccclass
+        ], ToastComponent);
+        return ToastComponent;
+    }(cc.Component));
+    exports.default = ToastComponent;
+});
+define("toast/ToastManager", ["require", "exports", "toast/ToastComponent"], function (require, exports, ToastComponent_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _a = cc._decorator, ccclass = _a.ccclass, property = _a.property;
+    var ToastManager = (function () {
+        function ToastManager() {
+        }
+        ToastManager_1 = ToastManager;
+        ToastManager.prototype.init = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            this.toastPool = new cc.NodePool();
+                            _a = this;
+                            return [4, this.loadSpriteFrame('tvui/prefab/Toast')];
+                        case 1:
+                            _a.prefab = _b.sent();
+                            return [2];
+                    }
+                });
+            });
+        };
+        ToastManager.prototype.loadSpriteFrame = function (path) {
+            return new Promise(function (resolve, reject) {
+                cc.loader.loadRes(path, cc.Prefab, function (err, spriteFrame) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(spriteFrame);
+                    }
+                });
+            });
+        };
+        ToastManager.prototype.onDestroy = function () {
+            this.toastPool.clear();
+        };
+        ToastManager.prototype.make = function (text, dur) {
+            if (dur === void 0) { dur = 1500; }
+            var node = this.toastPool.get();
+            var toastComp = null;
+            if (node == null) {
+                node = cc.instantiate(this.prefab);
+                toastComp = node.getComponent(ToastComponent_1.default);
+                if (toastComp == null) {
+                    console.warn("Toast.make : Toast Prefab must contains ToastComponent");
+                }
+            }
+            else {
+                toastComp = node.getComponent(ToastComponent_1.default);
+            }
+            if (node.parent == null)
+                cc.director.getScene().addChild(node, cc.macro.MAX_ZINDEX);
+            node.setPosition(cc.v2(cc.winSize.width / 2, cc.winSize.height / 2));
+            this.show(toastComp, text, dur);
+            return toastComp;
+        };
+        ToastManager.prototype.show = function (toastComp, text, dur) {
+            var _this = this;
+            toastComp.show(text);
+            setTimeout(function (_) {
+                toastComp.hide(function (_) {
+                    _this.toastPool.put(toastComp.node);
+                    console.log("Toast.hide toastpool size:", _this.toastPool.size());
+                });
+            }, dur);
+        };
+        var ToastManager_1;
+        ToastManager.Inst = new ToastManager_1();
+        ToastManager = ToastManager_1 = __decorate([
+            ccclass
+        ], ToastManager);
+        return ToastManager;
+    }());
+    exports.default = ToastManager;
+});
+define("Info", ["require", "exports", "core/TvUi", "toast/ToastManager"], function (require, exports, TvUi_1, ToastManager_2) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.showRewardVideo = showRewardVideo;
+    function getRuntimeTvUi() {
+        var root = typeof window != "undefined" ? window : null;
+        return TvUi_1.default || (root && (root.TvUi || root.tvui)) || null;
+    }
+    function showRewardVideo(scene, rewardType, callback, target, hooks) {
+        var finishFired = false;
+        var fireFinish = function () {
+            if (finishFired) {
+                return;
+            }
+            finishFired = true;
+            hooks && hooks.onFinish && hooks.onFinish.call(target);
+        };
+        var onSuccess = function () {
+            try {
+                callback && callback.call(target);
+            }
+            finally {
+                fireFinish();
+            }
+        };
+        var onClose = function () {
+            ToastManager_2.default.Inst.make("必须看完视频,才能获取奖励");
+            hooks && hooks.onClose && hooks.onClose.call(target);
+            fireFinish();
+        };
+        var onFail = function () {
+            ToastManager_2.default.Inst.make("广告暂不可用，请稍后再试");
+            hooks && hooks.onFail && hooks.onFail.call(target);
+            fireFinish();
+        };
+        var tvUi = getRuntimeTvUi();
+        if (tvUi && tvUi.ads && tvUi.ads.showReward && tvUi.api && tvUi.api.hasBridge && tvUi.api.hasBridge()) {
+            tvUi.ads.showReward({
+                scene: scene,
+                rewardType: rewardType,
+                onSuccess: onSuccess,
+                onClose: onClose,
+                onFail: onFail,
+                onFinish: fireFinish
+            });
+            return;
+        }
+        callback && callback.call(target);
+        return;
+    }
+});
+define("Loader", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Loader = void 0;
+    var Loader = (function () {
+        function Loader() {
+        }
+        Loader.loadRes = function (path, progressCallback) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, new Promise(function (resolve, reject) {
+                            cc.loader.loadRes(path, function (completedCount, totalCount, item) {
+                                if (progressCallback) {
+                                    progressCallback(completedCount / totalCount);
+                                }
+                            }, function (error, asset) {
+                                if (error) {
+                                    reject(error);
+                                }
+                                else {
+                                    resolve(asset);
+                                }
+                            });
+                        })];
+                });
+            });
+        };
+        Loader.loadResDir = function (dir, progressCallback) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2, new Promise(function (resolve, reject) {
+                            cc.loader.loadResDir(dir, function (completedCount, totalCount, item) {
+                                if (progressCallback) {
+                                    progressCallback(completedCount / totalCount, completedCount, totalCount);
+                                }
+                            }, function (error, assets) {
+                                if (error) {
+                                    reject(error);
+                                }
+                                else {
+                                    resolve(assets);
+                                }
+                            });
+                        })];
+                });
+            });
+        };
+        Loader.loadBatch = function (resources, progressCallback) {
+            return __awaiter(this, void 0, void 0, function () {
+                var results, totalCount, completedCount, loadPromises;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            results = new Map();
+                            totalCount = resources.length;
+                            completedCount = 0;
+                            loadPromises = resources.map(function (res, index) {
+                                var key = res.key || res.path;
+                                return _this.loadRes(res.path)
+                                    .then(function (asset) {
+                                    results.set(key, asset);
+                                    completedCount++;
+                                    if (progressCallback) {
+                                        progressCallback(completedCount / totalCount, completedCount, totalCount);
+                                    }
+                                })
+                                    .catch(function (error) {
+                                    console.error("Failed to load resource: ".concat(res.path), error);
+                                    completedCount++;
+                                    if (progressCallback) {
+                                        progressCallback(completedCount / totalCount, completedCount, totalCount);
+                                    }
+                                });
+                            });
+                            return [4, Promise.all(loadPromises)];
+                        case 1:
+                            _a.sent();
+                            return [2, results];
+                    }
+                });
+            });
+        };
+        return Loader;
+    }());
+    exports.Loader = Loader;
+});
+define("PlatformAdapter", ["require", "exports", "BtnExtra", "core/TvUi", "Info", "Loader", "toast/ToastManager"], function (require, exports, BtnExtra_1, TvUi_2, Info_1, Loader_1, ToastManager_3) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PlatformAdapter = void 0;
+    var PlatformAdapter = (function () {
+        function PlatformAdapter() {
+        }
+        PlatformAdapter.init = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, ToastManager_3.default.Inst.init()];
+                        case 1:
+                            _a.sent();
+                            TvUi_2.default.init({
+                                cpId: this.cpId,
+                                version: this.version,
+                                designWidth: this.designWidth,
+                                designHeight: this.designHeight,
+                                enableCursor: true,
+                                configPath: "tvui/config/default",
+                                focus: {
+                                    enabled: true,
+                                    defaultIconKey: "default"
+                                },
+                                adSdk: {
+                                    platform: "xiaomi"
+                                },
+                                ads: {
+                                    reward: {
+                                        enabled: true,
+                                        mode: "reward",
+                                        channels: [
+                                            { type: "aggregate", priority: 1, reward_type: "reward" },
+                                            { type: "mock", priority: 100 }
+                                        ]
+                                    },
+                                    popup: {
+                                        enabled: true,
+                                        mode: "popup",
+                                        channels: [
+                                            { type: "aggregate", priority: 1 },
+                                            { type: "mock", priority: 100 }
+                                        ]
+                                    },
+                                    game: {
+                                        enabled: true,
+                                        mode: "popup",
+                                        channels: [
+                                            { type: "aggregate", priority: 1 },
+                                            { type: "mock", priority: 100 }
+                                        ]
+                                    }
+                                }
+                            });
+                            return [2];
+                    }
+                });
+            });
+        };
+        PlatformAdapter.showRewardVideo = function (scene, rewardType, callback, target) {
+            (0, Info_1.showRewardVideo)(scene, rewardType, callback, target);
+        };
+        PlatformAdapter.registerButton = function (button) {
+            var sprite = button.getComponent(cc.Sprite);
+            var btnExtra = button.getComponent(BtnExtra_1.default);
+            var onFocus = function () {
+                sprite.spriteFrame = btnExtra.hoverSprite;
+            };
+            var onRomove = function () {
+                sprite.spriteFrame = btnExtra.normalSprite;
+            };
+            TvUi_2.default.focus.register(button, {
+                onFocus: onFocus,
+                onBlur: onRomove,
+            });
+        };
+        PlatformAdapter.registerButtonByName = function (name, parent) {
+            if (parent === void 0) { parent = null; }
+            if (!parent)
+                parent = cc.director.getScene();
+            var button = this.findChildByName(parent, name).getComponent(cc.Button);
+            if (!button)
+                return;
+            this.registerButton(button);
+        };
+        PlatformAdapter.focusButtonByName = function (name, parent) {
+            if (parent === void 0) { parent = null; }
+            if (!parent)
+                parent = cc.director.getScene();
+            var button = this.findChildByName(parent, name).getComponent(cc.Button);
+            if (!button)
+                return;
+            TvUi_2.default.focus.focus(button.node);
+        };
+        PlatformAdapter.focusButton = function (btn) {
+            TvUi_2.default.focus.focus(btn.node);
+        };
+        PlatformAdapter.findChildByName = function (parent, name) {
+            if (parent.name === name) {
+                return parent;
+            }
+            for (var i = 0; i < parent.children.length; i++) {
+                var result = this.findChildByName(parent.children[i], name);
+                if (result) {
+                    return result;
+                }
+            }
+            return null;
+        };
+        PlatformAdapter.showWindow = function (window) {
+            TvUi_2.default.focus.pushScope(window.uuid, window);
+            TvUi_2.default.focus.registerButtons(window);
+        };
+        PlatformAdapter.hideWindow = function (window) {
+            TvUi_2.default.focus.unregisterByRoot(window);
+            TvUi_2.default.focus.popScope(window.uuid);
+        };
+        PlatformAdapter.refreshWindow = function (window) {
+            TvUi_2.default.focus.registerButtons(window);
+        };
+        PlatformAdapter.showExitWin = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var exitPfb, exitWin;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, Loader_1.Loader.loadRes('tvui/prefab/ExitWin')];
+                        case 1:
+                            exitPfb = _a.sent();
+                            exitWin = cc.instantiate(exitPfb);
+                            exitWin.parent = cc.director.getScene();
+                            exitWin.setPosition(cc.v2(cc.winSize.width / 2, cc.winSize.height / 2));
+                            return [2];
+                    }
+                });
+            });
+        };
+        PlatformAdapter.cpId = "xhbj";
+        PlatformAdapter.version = "1.0.0";
+        PlatformAdapter.designWidth = 1920;
+        PlatformAdapter.designHeight = 1080;
+        return PlatformAdapter;
+    }());
+    exports.PlatformAdapter = PlatformAdapter;
+});
+define("ExitWin", ["require", "exports", "core/TvUi", "PlatformAdapter"], function (require, exports, TvUi_3, PlatformAdapter_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _a = cc._decorator, ccclass = _a.ccclass, property = _a.property;
+    var ExitWin = (function (_super) {
+        __extends(ExitWin, _super);
+        function ExitWin() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.btnCancel = null;
+            _this.btnExit = null;
+            return _this;
+        }
+        ExitWin.prototype.start = function () {
+            this.btnCancel.node.on(cc.Node.EventType.TOUCH_END, this.onClickCancel, this);
+            this.btnExit.node.on(cc.Node.EventType.TOUCH_END, this.onClickExit, this);
+        };
+        ExitWin.prototype.onClickCancel = function () {
+            this.node.destroy();
+        };
+        ExitWin.prototype.onClickExit = function () {
+            if (TvUi_3.default.api.hasBridge()) {
+                TvUi_3.default.api.onExitGame();
+                return;
+            }
+            cc.game.end();
+        };
+        ExitWin.prototype.onEnable = function () {
+            PlatformAdapter_1.PlatformAdapter.showWindow(this.node);
+            PlatformAdapter_1.PlatformAdapter.registerButton(this.btnCancel);
+            PlatformAdapter_1.PlatformAdapter.registerButton(this.btnExit);
+        };
+        ExitWin.prototype.onDisable = function () {
+            PlatformAdapter_1.PlatformAdapter.hideWindow(this.node);
+        };
+        __decorate([
+            property(cc.Button),
+            __metadata("design:type", cc.Button)
+        ], ExitWin.prototype, "btnCancel", void 0);
+        __decorate([
+            property(cc.Button),
+            __metadata("design:type", cc.Button)
+        ], ExitWin.prototype, "btnExit", void 0);
+        ExitWin = __decorate([
+            ccclass
+        ], ExitWin);
+        return ExitWin;
+    }(cc.Component));
+    exports.default = ExitWin;
+});
+define("ad/AdSlot", ["require", "exports", "ad/AdManager"], function (require, exports, AdManager_3) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _a = cc._decorator, ccclass = _a.ccclass, property = _a.property;
+    var AdSlot = (function (_super) {
+        __extends(AdSlot, _super);
+        function AdSlot() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.slotId = "popup";
+            _this.showOnLoad = false;
+            return _this;
+        }
+        AdSlot.prototype.onEnable = function () {
+            if (this.showOnLoad)
+                this.show();
+        };
+        AdSlot.prototype.onDisable = function () {
+            this.hide();
+        };
+        AdSlot.prototype.show = function () {
+            AdManager_3.default.showSlot(this.slotId, { container: this.node });
+        };
+        AdSlot.prototype.hide = function () {
+            AdManager_3.default.hideSlot(this.slotId);
+        };
+        AdSlot.prototype.refresh = function () {
+            AdManager_3.default.refreshSlot(this.slotId, { container: this.node });
+        };
+        AdSlot.show = function (slotId) {
+            return AdManager_3.default.showSlot(slotId);
+        };
+        AdSlot.hide = function (slotId) {
+            AdManager_3.default.hideSlot(slotId);
+        };
+        AdSlot.refresh = function (slotId) {
+            return AdManager_3.default.refreshSlot(slotId);
+        };
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], AdSlot.prototype, "slotId", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", Boolean)
+        ], AdSlot.prototype, "showOnLoad", void 0);
+        AdSlot = __decorate([
+            ccclass
+        ], AdSlot);
+        return AdSlot;
+    }(cc.Component));
+    exports.default = AdSlot;
+});
+define("focus/FocusItem", ["require", "exports", "focus/FocusManager"], function (require, exports, FocusManager_4) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _a = cc._decorator, ccclass = _a.ccclass, property = _a.property;
+    var FocusItem = (function (_super) {
+        __extends(FocusItem, _super);
+        function FocusItem() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.focusId = "";
+            _this.scopeId = "";
+            _this.iconKey = "";
+            _this.up = "";
+            _this.down = "";
+            _this.left = "";
+            _this.right = "";
+            _this.focusScale = 1.08;
+            _this.autoRegister = true;
+            return _this;
+        }
+        FocusItem.prototype.onEnable = function () {
+            if (this.autoRegister)
+                FocusManager_4.default.register(this);
+        };
+        FocusItem.prototype.onDisable = function () {
+            if (this.autoRegister)
+                FocusManager_4.default.unregister(this.node);
+        };
+        FocusItem.prototype.onFocus = function () {
+        };
+        FocusItem.prototype.onBlur = function () {
+        };
+        FocusItem.prototype.onConfirm = function () {
+            var button = this.node.getComponent(cc.Button);
+            if (button && button.interactable) {
+                cc.Component.EventHandler.emitEvents(button.clickEvents, null);
+            }
+            else {
+                var event = new cc.Event.EventCustom(cc.Node.EventType.TOUCH_END, true);
+                this.node.emit(cc.Node.EventType.TOUCH_END, event);
+            }
+        };
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], FocusItem.prototype, "focusId", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], FocusItem.prototype, "scopeId", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], FocusItem.prototype, "iconKey", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], FocusItem.prototype, "up", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], FocusItem.prototype, "down", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], FocusItem.prototype, "left", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", String)
+        ], FocusItem.prototype, "right", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", Number)
+        ], FocusItem.prototype, "focusScale", void 0);
+        __decorate([
+            property,
+            __metadata("design:type", Boolean)
+        ], FocusItem.prototype, "autoRegister", void 0);
+        FocusItem = __decorate([
+            ccclass
+        ], FocusItem);
+        return FocusItem;
+    }(cc.Component));
+    exports.default = FocusItem;
+});
+define("icon/IconConfig", ["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+define("toast/TvExitConfirmDialog", ["require", "exports", "core/TvUi"], function (require, exports, TvUi_4) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ccclass = cc._decorator.ccclass;
+    var TvExitConfirmDialog = (function (_super) {
+        __extends(TvExitConfirmDialog, _super);
+        function TvExitConfirmDialog() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.resolver = null;
+            _this.closed = false;
+            _this.tvFocusScopeId = "modal:tvui/tv_exit_confirm";
+            return _this;
+        }
+        TvExitConfirmDialog_1 = TvExitConfirmDialog;
+        TvExitConfirmDialog.show = function (onExitCallback) {
+            if (onExitCallback === void 0) { onExitCallback = null; }
+            var resolveDialog;
+            var promise = new Promise(function (resolve) {
+                resolveDialog = resolve;
+            });
+            TvExitConfirmDialog_1.pendingPromise = promise;
+            var parent = TvExitConfirmDialog_1.getDialogParent();
+            if (!parent) {
+                resolveDialog(false);
+                return promise;
+            }
+            var node = new cc.Node("TvExitConfirmDialog");
+            var size = TvExitConfirmDialog_1.getParentSize(parent);
+            node.setContentSize(size);
+            node.setPosition(0, 0);
+            node.zIndex = 5000;
+            node.addComponent(cc.BlockInputEvents);
+            parent.addChild(node, 5000);
+            var dialog = node.addComponent(TvExitConfirmDialog_1);
+            TvExitConfirmDialog_1.currentDialog = dialog;
+            dialog.open(resolveDialog);
+            dialog.onExitCallback = onExitCallback;
+            return promise;
+        };
+        TvExitConfirmDialog.getDialogParent = function () {
+            var canvas = cc.find("Canvas");
+            if (canvas)
+                return canvas;
+            var scene = cc.director.getScene();
+            return scene;
+        };
+        TvExitConfirmDialog.getParentSize = function (parent) {
+            var width = parent && parent.width ? parent.width : cc.winSize.width;
+            var height = parent && parent.height ? parent.height : cc.winSize.height;
+            return cc.size(width || 1920, height || 1080);
+        };
+        TvExitConfirmDialog.clearPending = function (dialog) {
+            if (TvExitConfirmDialog_1.currentDialog == dialog) {
+            }
+        };
+        TvExitConfirmDialog.prototype.open = function (resolveDialog) {
+            var _this = this;
+            this.resolver = resolveDialog;
+            this.loadSprites(function (sprites) {
+                if (_this.closed || !_this.node || !_this.node.isValid)
+                    return;
+                _this.buildView(sprites);
+                _this.registerTvControls();
+            }, function () {
+                _this.close(false);
+            });
+        };
+        TvExitConfirmDialog.prototype.loadSprites = function (onComplete, onError) {
+            if (TvExitConfirmDialog_1.spriteCache) {
+                onComplete(TvExitConfirmDialog_1.spriteCache);
+                return;
+            }
+            var result = {};
+            var paths = [
+                { key: "title", path: "tvui/tv_exit/退出游戏" },
+                { key: "frame", path: "tvui/tv_exit/框" },
+                { key: "cancelNormal", path: "tvui/tv_exit/取消按钮_普通" },
+                { key: "cancelSelected", path: "tvui/tv_exit/取消按钮_选中" },
+                { key: "confirmNormal", path: "tvui/tv_exit/确认按钮_普通" },
+                { key: "confirmSelected", path: "tvui/tv_exit/确认按钮_选中" }
+            ];
+            var waiting = paths.length;
+            var failed = false;
+            var _loop_1 = function (i) {
+                var item = paths[i];
+                cc.loader.loadRes(item.path, cc.SpriteFrame, function (error, frame) {
+                    if (failed)
+                        return;
+                    if (error || !frame) {
+                        failed = true;
+                        console.warn("[TvExitConfirmDialog] load sprite failed:", item.path, error);
+                        onError();
+                        return;
+                    }
+                    result[item.key] = frame;
+                    waiting--;
+                    if (waiting <= 0) {
+                        TvExitConfirmDialog_1.spriteCache = result;
+                        onComplete(TvExitConfirmDialog_1.spriteCache);
+                    }
+                });
+            };
+            for (var i = 0; i < paths.length; i++) {
+                _loop_1(i);
+            }
+        };
+        TvExitConfirmDialog.prototype.buildView = function (sprites) {
+            var size = TvExitConfirmDialog_1.getParentSize(this.node.parent);
+            this.node.setContentSize(size);
+            this.createMask(size);
+            var frameY = 30;
+            var titleY = frameY + 100;
+            var buttonY = -150;
+            var buttonOffsetX = 195;
+            var frameNode = this.createSpriteNode("frame", sprites.frame, 959, 552);
+            this.node.addChild(frameNode, 1);
+            frameNode.setPosition(0, frameY);
+            this.confirmState = this.createDialogButton("confirm", sprites.confirmNormal, sprites.confirmSelected, -buttonOffsetX, buttonY, true);
+            this.cancelState = this.createDialogButton("cancel", sprites.cancelNormal, sprites.cancelSelected, buttonOffsetX, buttonY, false);
+            frameNode.addChild(this.confirmState.node, 2);
+            frameNode.addChild(this.cancelState.node, 2);
+        };
+        TvExitConfirmDialog.prototype.createMask = function (size) {
+            var mask = new cc.Node("mask");
+            mask.setContentSize(size);
+            mask.addComponent(cc.BlockInputEvents);
+            var graphics = mask.addComponent(cc.Graphics);
+            graphics.fillColor = cc.color(0, 0, 0, 165);
+            graphics.rect(-size.width * 0.5, -size.height * 0.5, size.width, size.height);
+            graphics.fill();
+            this.node.addChild(mask, 0);
+        };
+        TvExitConfirmDialog.prototype.createSpriteNode = function (name, frame, width, height) {
+            var node = new cc.Node(name);
+            node.setContentSize(width, height);
+            var sprite = node.addComponent(cc.Sprite);
+            sprite.sizeMode = cc.Sprite.SizeMode.CUSTOM;
+            sprite.spriteFrame = frame;
+            return node;
+        };
+        TvExitConfirmDialog.prototype.createDialogButton = function (name, normal, selected, x, y, result) {
+            var _this = this;
+            var node = this.createSpriteNode(name, normal, 208, 96);
+            node.setPosition(x, y);
+            var button = node.addComponent(cc.Button);
+            button.transition = cc.Button.Transition.NONE;
+            var state = {
+                node: node,
+                sprite: node.getComponent(cc.Sprite),
+                normal: normal,
+                selected: selected,
+                hovered: false,
+                pressed: false,
+                focused: false
+            };
+            node.on(cc.Node.EventType.MOUSE_ENTER, function () {
+                state.hovered = true;
+                _this.refreshButtonState(state);
+            }, this);
+            node.on(cc.Node.EventType.MOUSE_LEAVE, function () {
+                state.hovered = false;
+                _this.refreshButtonState(state);
+            }, this);
+            node.on(cc.Node.EventType.TOUCH_START, function () {
+                state.pressed = true;
+                _this.refreshButtonState(state);
+            }, this);
+            node.on(cc.Node.EventType.TOUCH_CANCEL, function () {
+                state.pressed = false;
+                _this.refreshButtonState(state);
+            }, this);
+            node.on(cc.Node.EventType.TOUCH_END, function () {
+                state.pressed = false;
+                _this.refreshButtonState(state);
+                _this.close(result);
+            }, this);
+            return state;
+        };
+        TvExitConfirmDialog.prototype.refreshButtonState = function (state) {
+            if (!state || !state.sprite)
+                return;
+            var selected = state.focused || state.hovered || state.pressed;
+            state.sprite.spriteFrame = selected ? state.selected : state.normal;
+        };
+        TvExitConfirmDialog.prototype.registerTvControls = function () {
+            var _this = this;
+            if (!this.tvBackHandler) {
+                this.tvBackHandler = function () {
+                    _this.close(false);
+                    return true;
+                };
+            }
+            TvUi_4.default.back.push(this.tvBackHandler);
+            if (TvUi_4.default.focus.pushScope) {
+                TvUi_4.default.focus.pushScope(this.tvFocusScopeId, this.node);
+            }
+            this.registerFocus(this.confirmState, true);
+            this.registerFocus(this.cancelState, false);
+            if (this.cancelState && this.cancelState.node) {
+                TvUi_4.default.focus.focusNode(this.cancelState.node);
+            }
+            this.refreshAllButtonStates();
+        };
+        TvExitConfirmDialog.prototype.registerFocus = function (state, result) {
+            var _this = this;
+            if (!state || !state.node)
+                return;
+            TvUi_4.default.focus.register(state.node, {
+                root: this.node,
+                focusScale: 1,
+                onClick: function () {
+                    _this.close(result);
+                },
+                onFocus: function () {
+                    _this.setFocusedState(state);
+                },
+                onBlur: function () {
+                    state.focused = false;
+                    _this.refreshAllButtonStates();
+                }
+            });
+        };
+        TvExitConfirmDialog.prototype.setFocusedState = function (focusedState) {
+            if (this.confirmState)
+                this.confirmState.focused = this.confirmState == focusedState;
+            if (this.cancelState)
+                this.cancelState.focused = this.cancelState == focusedState;
+            this.refreshAllButtonStates();
+        };
+        TvExitConfirmDialog.prototype.refreshAllButtonStates = function () {
+            this.refreshButtonState(this.confirmState);
+            this.refreshButtonState(this.cancelState);
+        };
+        TvExitConfirmDialog.prototype.unregisterTvControls = function () {
+            TvUi_4.default.focus.unregisterByRoot(this.node);
+            if (TvUi_4.default.focus.popScope) {
+                TvUi_4.default.focus.popScope(this.tvFocusScopeId);
+            }
+            if (this.tvBackHandler) {
+                TvUi_4.default.back.remove(this.tvBackHandler);
+                this.tvBackHandler = null;
+            }
+        };
+        TvExitConfirmDialog.prototype.close = function (confirmed) {
+            if (this.closed)
+                return;
+            this.finish(confirmed);
+            if (this.node && this.node.isValid) {
+                this.node.destroy();
+            }
+        };
+        TvExitConfirmDialog.prototype.finish = function (confirmed) {
+            if (this.closed)
+                return;
+            this.closed = true;
+            this.unregisterTvControls();
+            TvExitConfirmDialog_1.clearPending(this);
+            if (this.onExitCallback && confirmed) {
+                this.onExitCallback(confirmed);
+                return;
+            }
+            var resolveDialog = this.resolver;
+            this.resolver = null;
+            if (confirmed) {
+                if (TvUi_4.default.api.hasBridge()) {
+                    TvUi_4.default.api.onExitGame();
+                    return;
+                }
+                if (!TvUi_4.default.api.hasBridge() && cc.game && cc.game.end) {
+                    cc.game.end();
+                }
+            }
+        };
+        TvExitConfirmDialog.prototype.onDestroy = function () {
+            if (!this.closed) {
+                this.finish(false);
+                return;
+            }
+            this.unregisterTvControls();
+        };
+        var TvExitConfirmDialog_1;
+        TvExitConfirmDialog = TvExitConfirmDialog_1 = __decorate([
+            ccclass
+        ], TvExitConfirmDialog);
+        return TvExitConfirmDialog;
+    }(cc.Component));
+    exports.default = TvExitConfirmDialog;
+});